Add dependencies locally & include game files

deps/GSL

@@ -1 +0,0 @@
-Subproject commit afaaa71bcee45d9c90c21f8bd3ba2b12902242e9

deps/GSL/.clang-format

@@ -0,0 +1,34 @@
+ColumnLimit: 100
+
+UseTab: Never
+IndentWidth: 4
+AccessModifierOffset: -4
+NamespaceIndentation: Inner
+
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterNamespace: true
+  AfterEnum: true
+  AfterStruct: true
+  AfterClass: true
+  SplitEmptyFunction: false
+  AfterControlStatement: true
+  AfterFunction: true
+  AfterUnion: true
+  BeforeElse: true
+
+
+AlwaysBreakTemplateDeclarations: true
+BreakConstructorInitializersBeforeComma: true
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+AllowShortBlocksOnASingleLine: true
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: true
+AllowShortLoopsOnASingleLine: true
+
+PointerAlignment: Left
+AlignConsecutiveAssignments: false
+AlignTrailingComments: true
+
+SpaceAfterCStyleCast: true
+CommentPragmas: '^ NO-FORMAT:'

deps/GSL/.gitattributes

@@ -0,0 +1 @@
+include/gsl/* linguist-language=C++

deps/GSL/.github/workflows/android.yml

@@ -0,0 +1,50 @@
+name: CI_Android
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  Android:
+    runs-on: macos-latest
+    defaults:
+      run:
+        working-directory: build
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Create build directory
+        run: mkdir -p build
+        working-directory: .
+
+      - name: Start emulator
+        run: |
+          echo "y" | $ANDROID_HOME/tools/bin/sdkmanager --install 'system-images;android-24;default;x86_64'
+          echo "no" | $ANDROID_HOME/tools/bin/avdmanager create avd -n xamarin_android_emulator -k 'system-images;android-24;default;x86_64' --force
+          $ANDROID_HOME/emulator/emulator -list-avds
+          echo "Starting emulator"
+          # Start emulator in background
+          nohup $ANDROID_HOME/emulator/emulator -avd xamarin_android_emulator -no-snapshot > /dev/null 2>&1 &
+          echo "Emulator starting"
+
+      - name: Configure
+        run: cmake -Werror=dev -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_LATEST_HOME/build/cmake/android.toolchain.cmake -DANDROID_PLATFORM=16 -DANDROID_ABI=x86_64 -DCMAKE_BUILD_TYPE=Debug ..
+
+      - name: Build
+        run: cmake --build . --parallel
+
+      - name: Wait for emulator ready
+        run: |
+          $ANDROID_HOME/platform-tools/adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed | tr -d '\r') ]]; do sleep 10; done; input keyevent 82'
+          $ANDROID_HOME/platform-tools/adb devices
+          $ANDROID_HOME/platform-tools/adb shell getprop ro.product.cpu.abi
+          echo "Emulator started"
+
+      - name: Deploy tests
+        run: |
+          adb push tests /data/local/tmp
+          adb shell find /data/local/tmp/tests -maxdepth 1 -exec chmod +x {} \\\;
+
+      - name: Test
+        run: adb shell find /data/local/tmp/tests -name "*_tests" -maxdepth 1 -exec {} \\\;

deps/GSL/.github/workflows/cmake_find_package.yml

@@ -0,0 +1,25 @@
+name: cmake_find_package
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  cmake-find-package:
+    name: Build ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ ubuntu-latest, macos-latest ]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: lukka/get-cmake@latest
+        with:
+          cmakeVersion: 3.14.0
+      - name: Configure GSL
+        run: cmake -S . -B build -G "Ninja" -D GSL_TEST=OFF -D CMAKE_INSTALL_PREFIX=${GITHUB_WORKSPACE}/build/install
+      - name: Install GSL
+        run: cmake --build build --target install
+      - name: Test GSL find_package support
+        run: cmake -S tests/ -B build/tests_find_package -G "Ninja" -D CMAKE_PREFIX_PATH=${GITHUB_WORKSPACE}/build/install -D CMAKE_BUILD_TYPE=Release

deps/GSL/.github/workflows/ios.yml

@@ -0,0 +1,52 @@
+name: CI_iOS
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  iOS:
+    runs-on: macos-latest
+    defaults:
+      run:
+        working-directory: build
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Create build directory
+        run: mkdir -p build
+        working-directory: .
+
+      - name: Configure
+        run: |
+          cmake \
+            -Werror=dev \
+            -GXcode \
+            -DCMAKE_SYSTEM_NAME=iOS \
+            "-DCMAKE_OSX_ARCHITECTURES=arm64;x86_64" \
+            -DCMAKE_OSX_DEPLOYMENT_TARGET=9 \
+            -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY \
+            "-DMACOSX_BUNDLE_GUI_IDENTIFIER=GSL.\$(EXECUTABLE_NAME)" \
+            -DMACOSX_BUNDLE_BUNDLE_VERSION=3.1.0 \
+            -DMACOSX_BUNDLE_SHORT_VERSION_STRING=3.1.0 \
+            ..
+
+      - name: Build
+        run: cmake --build . --parallel `sysctl -n hw.ncpu` --config Release -- -sdk iphonesimulator
+
+      - name: Start simulator
+        run: |
+          RUNTIME=`xcrun simctl list runtimes iOS -j|jq '.runtimes|last.identifier'`
+          UDID=`xcrun simctl list devices iPhone available -j|jq -r ".devices[$RUNTIME]|last.udid"`
+          xcrun simctl bootstatus $UDID -b
+
+      - name: Test
+        run: |
+          for TEST in `find tests/Release-iphonesimulator -depth 1 -name "*.app"`
+          do
+            xcrun simctl install booted $TEST
+            TEST_ID=`plutil -convert json -o - $TEST/Info.plist|jq -r ".CFBundleIdentifier"`
+            xcrun simctl launch --console booted $TEST_ID
+            xcrun simctl uninstall booted $TEST_ID
+          done

deps/GSL/.gitignore

@@ -0,0 +1,16 @@
+CMakeFiles
+build
+tests/CMakeFiles
+tests/Debug
+*.opensdf
+*.sdf
+tests/*tests.dir
+*.vcxproj
+*.vcxproj.filters
+*.sln
+*.tlog
+Testing/Temporary/*.*
+CMakeCache.txt
+*.suo
+.vs/
+.vscode/

deps/GSL/CMakeLists.txt

@@ -0,0 +1,48 @@
+cmake_minimum_required(VERSION 3.14...3.16)
+
+project(GSL VERSION 4.0.0 LANGUAGES CXX)
+
+add_library(GSL INTERFACE)
+add_library(Microsoft.GSL::GSL ALIAS GSL)
+
+# https://cmake.org/cmake/help/latest/variable/PROJECT_IS_TOP_LEVEL.html
+string(COMPARE EQUAL ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_SOURCE_DIR} PROJECT_IS_TOP_LEVEL)
+
+option(GSL_INSTALL "Generate and install GSL target" ${PROJECT_IS_TOP_LEVEL})
+option(GSL_TEST "Build and perform GSL tests" ${PROJECT_IS_TOP_LEVEL})
+
+# The implementation generally assumes a platform that implements C++14 support
+target_compile_features(GSL INTERFACE "cxx_std_14")
+
+# Setup include directory
+add_subdirectory(include)
+
+target_sources(GSL INTERFACE $<BUILD_INTERFACE:${GSL_SOURCE_DIR}/GSL.natvis>)
+
+if (GSL_TEST)
+    enable_testing()
+    add_subdirectory(tests)
+endif()
+
+if (GSL_INSTALL)
+    include(GNUInstallDirs)
+    include(CMakePackageConfigHelpers)
+
+    install(DIRECTORY "${PROJECT_SOURCE_DIR}/include/gsl" DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+    set(export_name "Microsoft.GSLConfig")
+    set(namespace "Microsoft.GSL::")
+    set(cmake_files_install_dir ${CMAKE_INSTALL_DATADIR}/cmake/Microsoft.GSL)
+
+    install(TARGETS GSL EXPORT ${export_name} INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+    install(EXPORT ${export_name} NAMESPACE ${namespace} DESTINATION ${cmake_files_install_dir})
+    export(TARGETS GSL NAMESPACE ${namespace} FILE ${export_name}.cmake)
+
+    set(gls_config_version "${CMAKE_CURRENT_BINARY_DIR}/Microsoft.GSLConfigVersion.cmake")
+
+    write_basic_package_version_file(${gls_config_version} COMPATIBILITY SameMajorVersion ARCH_INDEPENDENT)
+
+    install(FILES ${gls_config_version} DESTINATION ${cmake_files_install_dir})
+
+    install(FILES GSL.natvis DESTINATION ${cmake_files_install_dir})
+endif()

deps/GSL/CMakeSettings.json

@@ -0,0 +1,18 @@
+{
+  "configurations": [
+    {
+      "name": "x64-Debug",
+      "generator": "Ninja",
+      "configurationType": "Debug",
+      "inheritEnvironments": [
+        "msvc_x64_x64"
+      ],
+      "buildRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\build\\${name}",
+      "installRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\install\\${name}",
+      "cmakeCommandArgs": "-DGSL_CXX_STANDARD=17",
+      "buildCommandArgs": "-v",
+      "ctestCommandArgs": "",
+      "codeAnalysisRuleset": "CppCoreCheckRules.ruleset"
+    }
+  ]
+}

deps/GSL/CONTRIBUTING.md

@@ -0,0 +1,29 @@
+## Contributing to the Guidelines Support Library
+
+The Guidelines Support Library (GSL) contains functions and types that are suggested for use by the
+[C++ Core Guidelines](https://github.com/isocpp/CppCoreGuidelines). GSL design changes are made only as a result of modifications to the Guidelines. 
+
+GSL is accepting contributions that improve or refine any of the types in this library as well as ports to other platforms. Changes should have an issue 
+tracking the suggestion that has been approved by the maintainers. Your pull request should include a link to the bug that you are fixing. If you've submitted 
+a PR, please post a comment in the associated issue to avoid duplication of effort.
+
+## Legal
+You will need to complete a Contributor License Agreement (CLA). Briefly, this agreement testifies that you are granting us and the community permission to 
+use the submitted change according to the terms of the project's license, and that the work being submitted is under appropriate copyright.
+
+Please submit a Contributor License Agreement (CLA) before submitting a pull request. You may visit https://cla.microsoft.com to sign digitally.
+
+## Housekeeping
+Your pull request should: 
+
+* Include a description of what your change intends to do
+* Be a child commit of a reasonably recent commit in the **main** branch 
+    * Requests need not be a single commit, but should be a linear sequence of commits (i.e. no merge commits in your PR)
+* It is desirable, but not necessary, for the tests to pass at each commit. Please see [README.md](./README.md) for instructions to build the test suite. 
+* Have clear commit messages 
+    * e.g. "Fix issue", "Add tests for type", etc.
+* Include appropriate tests 
+    * Tests should include reasonable permutations of the target fix/change
+    * Include baseline changes with your change
+    * All changed code must have 100% code coverage
+* To avoid line ending issues, set `autocrlf = input` and `whitespace = cr-at-eol` in your git configuration

deps/GSL/GSL.natvis

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 
+    This will make GitHub and some editors recognize this code as XML: 
+    vim: syntax=xml
+-->
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+    <!-- These types are from the util header. -->
+    <Type Name="gsl::final_action&lt;*&gt;">
+        <DisplayString>{{ invoke = {invoke_}, action = {f_} }}</DisplayString>
+        <Expand>
+            <Item Name="[invoke]">invoke_</Item>
+            <Item Name="[callback]">f_</Item>
+        </Expand>
+    </Type>
+
+  <!-- These types are from the span header. -->
+  <Type Name="gsl::span&lt;*, *&gt;">
+        <DisplayString>{{ extent = {storage_.size_} }}</DisplayString>
+        <Expand>
+            <ArrayItems>
+                <Size>storage_.size_</Size>
+                <ValuePointer>storage_.data_</ValuePointer>
+            </ArrayItems>
+        </Expand>
+    </Type>
+
+    <!-- These types are from the pointers header. -->
+    <Type Name="gsl::not_null&lt;*&gt;">
+        <!-- We can always dereference this since it's an invariant. -->
+        <DisplayString>value = {*ptr_}</DisplayString>
+    </Type>
+</AutoVisualizer>  

deps/GSL/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2015 Microsoft Corporation. All rights reserved. 
+ 
+This code is licensed under the MIT License (MIT). 
+
+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. 

deps/GSL/README.md

@@ -0,0 +1,218 @@
+# GSL: Guidelines Support Library
+[![Build Status](https://dev.azure.com/cppstat/GSL/_apis/build/status/microsoft.GSL?branchName=main)](https://dev.azure.com/cppstat/GSL/_build/latest?definitionId=1&branchName=main)
+
+The Guidelines Support Library (GSL) contains functions and types that are suggested for use by the
+[C++ Core Guidelines](https://github.com/isocpp/CppCoreGuidelines) maintained by the [Standard C++ Foundation](https://isocpp.org).
+This repo contains Microsoft's implementation of GSL.
+
+The entire implementation is provided inline in the headers under the [gsl](./include/gsl) directory. The implementation generally assumes a platform that implements C++14 support.
+
+While some types have been broken out into their own headers (e.g. [gsl/span](./include/gsl/span)),
+it is simplest to just include [gsl/gsl](./include/gsl/gsl) and gain access to the entire library.
+
+> NOTE: We encourage contributions that improve or refine any of the types in this library as well as ports to
+other platforms. Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for more information about contributing.
+
+# Project Code of Conduct
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
+
+# Usage of Third Party Libraries
+This project makes use of the [Google Test](https://github.com/google/googletest) testing library. Please see the [ThirdPartyNotices.txt](./ThirdPartyNotices.txt) file for details regarding the licensing of Google Test.
+
+# Supported features
+## Microsoft GSL implements the following from the C++ Core Guidelines:
+
+Feature                                                                  | Supported? | Description
+-------------------------------------------------------------------------|:----------:|-------------
+[**1. Views**][cg-views]                                                 |            |
+[owner](docs/headers.md#user-content-H-pointers-owner)                   | ☑   | An alias for a raw pointer
+[not_null](docs/headers.md#user-content-H-pointers-not_null)             | ☑   | Restricts a pointer / smart pointer to hold non-null values
+[span](docs/headers.md#user-content-H-span-span)                         | ☑   | A view over a contiguous sequence of memory. Based on the standardized version of `std::span`, however `gsl::span` enforces bounds checking.
+span_p                                                                   | ☐   | Spans a range starting from a pointer to the first place for which the predicate is true
+[basic_zstring](docs/headers.md#user-content-H-string_span)              | ☑   | A pointer to a C-string (zero-terminated array) with a templated char type
+[zstring](docs/headers.md#user-content-H-string_span)                    | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of char
+[czstring](docs/headers.md#user-content-H-string_span)                   | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of const char
+[wzstring](docs/headers.md#user-content-H-string_span)                   | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of wchar_t
+[cwzstring](docs/headers.md#user-content-H-string_span)                  | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of const wchar_t
+[u16zstring](docs/headers.md#user-content-H-string_span)                 | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of char16_t
+[cu16zstring](docs/headers.md#user-content-H-string_span)                | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of const char16_t
+[u32zstring](docs/headers.md#user-content-H-string_span)                 | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of char32_t
+[cu32zstring](docs/headers.md#user-content-H-string_span)                | ☑   | An alias to `basic_zstring` with dynamic extent and a char type of const char32_t
+[**2. Owners**][cg-owners]                                               |            |
+[unique_ptr](docs/headers.md#user-content-H-pointers-unique_ptr)         | ☑   | An alias to `std::unique_ptr`
+[shared_ptr](docs/headers.md#user-content-H-pointers-shared_ptr)         | ☑   | An alias to `std::shared_ptr`
+stack_array                                                              | ☐   | A stack-allocated array
+dyn_array                                                                | ☐   | A heap-allocated array
+[**3. Assertions**][cg-assertions]                                       |            |
+[Expects](docs/headers.md#user-content-H-assert-expects)                 | ☑   | A precondition assertion; on failure it terminates
+[Ensures](docs/headers.md#user-content-H-assert-ensures)                 | ☑   | A postcondition assertion; on failure it terminates
+[**4. Utilities**][cg-utilities]                                         |            |
+move_owner                                                               | ☐   | A helper function that moves one `owner` to the other
+[byte](docs/headers.md#user-content-H-byte-byte)                         | ☑   | Either an alias to `std::byte` or a byte type
+[final_action](docs/headers.md#user-content-H-util-final_action)         | ☑   | A RAII style class that invokes a functor on its destruction
+[finally](docs/headers.md#user-content-H-util-finally)                   | ☑   | A helper function instantiating `final_action`
+[GSL_SUPPRESS](docs/headers.md#user-content-H-assert-gsl_suppress)       | ☑   | A macro that takes an argument and turns it into `[[gsl::suppress(x)]]` or `[[gsl::suppress("x")]]`
+[[implicit]]                                                             | ☐   | A "marker" to put on single-argument constructors to explicitly make them non-explicit
+[index](docs/headers.md#user-content-H-util-index)                       | ☑   | A type to use for all container and array indexing (currently an alias for `std::ptrdiff_t`)
+joining_thread                                                           | ☐   | A RAII style version of `std::thread` that joins
+[narrow](docs/headers.md#user-content-H-narrow-narrow)                   | ☑   | A checked version of `narrow_cast`; it can throw `narrowing_error`
+[narrow_cast](docs/headers.md#user-content-H-util-narrow_cast)           | ☑   | A narrowing cast for values and a synonym for `static_cast`
+[narrowing_error](docs/headers.md#user-content-H-narrow-narrowing_error) | ☑   | A custom exception type thrown by `narrow()`
+[**5. Concepts**][cg-concepts]                                           | ☐   |
+
+## The following features do not exist in or have been removed from the C++ Core Guidelines:
+Feature                            | Supported? | Description
+-----------------------------------|:----------:|-------------
+[strict_not_null](docs/headers.md#user-content-H-pointers-strict_not_null) | ☑   | A stricter version of `not_null` with explicit constructors
+multi_span                         | ☐   | Deprecated. Multi-dimensional span.
+strided_span                       | ☐   | Deprecated. Support for this type has been discontinued.
+basic_string_span                  | ☐   | Deprecated. Like `span` but for strings with a templated char type
+string_span                        | ☐   | Deprecated. An alias to `basic_string_span` with a char type of char
+cstring_span                       | ☐   | Deprecated. An alias to `basic_string_span` with a char type of const char
+wstring_span                       | ☐   | Deprecated. An alias to `basic_string_span` with a char type of wchar_t
+cwstring_span                      | ☐   | Deprecated. An alias to `basic_string_span` with a char type of const wchar_t
+u16string_span                     | ☐   | Deprecated. An alias to `basic_string_span` with a char type of char16_t
+cu16string_span                    | ☐   | Deprecated. An alias to `basic_string_span` with a char type of const char16_t
+u32string_span                     | ☐   | Deprecated. An alias to `basic_string_span` with a char type of char32_t
+cu32string_span                    | ☐   | Deprecated. An alias to `basic_string_span` with a char type of const char32_t
+
+This is based on [CppCoreGuidelines semi-specification](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gsl-guidelines-support-library).
+
+[cg-views]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslview-views
+[cg-owners]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslowner-ownership-pointers
+[cg-assertions]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslassert-assertions
+[cg-utilities]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslutil-utilities
+[cg-concepts]: https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#gslconcept-concepts
+
+# Quick Start
+## Supported Compilers / Toolsets
+The GSL officially supports the latest and previous major versions of VS with MSVC & LLVM, GCC, Clang, and XCode with Apple-Clang.
+Within these two major versions, we try to target the latest minor updates / revisions (although this may be affected by
+delays between a toolchain's release and when it becomes widely available for use).
+Below is a table showing the versions currently being tested.
+
+Compiler |Toolset Versions Currently Tested
+:------- |--:
+ XCode | 13.2.1 & 12.5.1
+ GCC | 11[^1] & 10[^2]
+ Clang | 12[^2] & 11[^2]
+ Visual Studio with MSVC | VS2022[^3] & VS2019[^4]
+ Visual Studio with LLVM | VS2022[^3] & VS2019[^4]
+
+
+[^1]: Precise version may be found in the [latest CI results](https://dev.azure.com/cppstat/GSL/_build?definitionId=1&branchFilter=26).
+[^2]: Precise version may be found in the [latest CI results](https://dev.azure.com/cppstat/GSL/_build?definitionId=1&branchFilter=26). Should be the version specified [here](https://github.com/actions/virtual-environments/blob/main/images/linux/Ubuntu2004-Readme.md#language-and-runtime).
+[^3]: Precise version may be found in the [latest CI results](https://dev.azure.com/cppstat/GSL/_build?definitionId=1&branchFilter=26). Should be the version specified [here](https://github.com/actions/virtual-environments/blob/main/images/win/Windows2022-Readme.md#visual-studio-enterprise-2022).
+[^4]: Precise version may be found in the [latest CI results](https://dev.azure.com/cppstat/GSL/_build?definitionId=1&branchFilter=26). Should be the version specified [here](https://github.com/actions/virtual-environments/blob/main/images/win/Windows2019-Readme.md#visual-studio-enterprise-2019).
+
+---
+If you successfully port GSL to another platform, we would love to hear from you!
+- Submit an issue specifying the platform and target.
+- Consider contributing your changes by filing a pull request with any necessary changes.
+- If at all possible, add a CI/CD step and add the button to the table below!
+
+Target | CI/CD Status
+:------- | -----------:
+iOS | ![CI_iOS](https://github.com/microsoft/GSL/workflows/CI_iOS/badge.svg)
+Android | ![CI_Android](https://github.com/microsoft/GSL/workflows/CI_Android/badge.svg)
+
+Note: These CI/CD steps are run with each pull request, however failures in them are non-blocking.
+
+## Building the tests
+To build the tests, you will require the following:
+
+* [CMake](http://cmake.org), version 3.14 or later to be installed and in your PATH.
+
+These steps assume the source code of this repository has been cloned into a directory named `c:\GSL`.
+
+1. Create a directory to contain the build outputs for a particular architecture (we name it `c:\GSL\build-x86` in this example).
+
+        cd GSL
+        md build-x86
+        cd build-x86
+
+2. Configure CMake to use the compiler of your choice (you can see a list by running `cmake --help`).
+
+        cmake -G "Visual Studio 15 2017" c:\GSL
+
+3. Build the test suite (in this case, in the Debug configuration, Release is another good choice).
+
+        cmake --build . --config Debug
+
+4. Run the test suite.
+
+        ctest -C Debug
+
+All tests should pass - indicating your platform is fully supported and you are ready to use the GSL types!
+
+## Building GSL - Using vcpkg
+
+You can download and install GSL using the [vcpkg](https://github.com/Microsoft/vcpkg) dependency manager:
+
+    git clone https://github.com/Microsoft/vcpkg.git
+    cd vcpkg
+    ./bootstrap-vcpkg.sh
+    ./vcpkg integrate install
+    vcpkg install ms-gsl
+
+The GSL port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
+
+## Using the libraries
+As the types are entirely implemented inline in headers, there are no linking requirements.
+
+You can copy the [gsl](./include/gsl) directory into your source tree so it is available
+to your compiler, then include the appropriate headers in your program.
+
+Alternatively set your compiler's *include path* flag to point to the GSL development folder (`c:\GSL\include` in the example above) or installation folder (after running the install). Eg.
+
+MSVC++
+
+    /I c:\GSL\include
+
+GCC/clang
+
+    -I$HOME/dev/GSL/include
+
+Include the library using:
+
+    #include <gsl/gsl>
+
+## Usage in CMake
+
+The library provides a Config file for CMake, once installed it can be found via `find_package`.
+
+Which, when successful, will add library target called `Microsoft.GSL::GSL` which you can use via the usual
+`target_link_libraries` mechanism.
+
+```cmake
+find_package(Microsoft.GSL CONFIG REQUIRED)
+
+target_link_libraries(foobar PRIVATE Microsoft.GSL::GSL)
+```
+
+### FetchContent
+
+If you are using CMake version 3.11+ you can use the offical [FetchContent module](https://cmake.org/cmake/help/latest/module/FetchContent.html).
+This allows you to easily incorporate GSL into your project.
+
+```cmake
+# NOTE: This example uses CMake version 3.14 (FetchContent_MakeAvailable).
+# Since it streamlines the FetchContent process
+cmake_minimum_required(VERSION 3.14)
+
+include(FetchContent)
+
+FetchContent_Declare(GSL
+    GIT_REPOSITORY "https://github.com/microsoft/GSL"
+    GIT_TAG "v4.0.0"
+    GIT_SHALLOW ON
+)
+
+FetchContent_MakeAvailable(GSL)
+
+target_link_libraries(foobar PRIVATE Microsoft.GSL::GSL)
+```
+
+## Debugging visualization support
+
+For Visual Studio users, the file [GSL.natvis](./GSL.natvis) in the root directory of the repository can be added to your project if you would like more helpful visualization of GSL types in the Visual Studio debugger than would be offered by default.

deps/GSL/SECURITY.md

@@ -0,0 +1,41 @@
+<!-- BEGIN MICROSOFT SECURITY.MD V0.0.7 BLOCK -->
+
+## Security
+
+Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/).
+
+If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://aka.ms/opensource/security/definition), please report it to us as described below.
+
+## Reporting Security Issues
+
+**Please do not report security vulnerabilities through public GitHub issues.**
+
+Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://aka.ms/opensource/security/create-report).
+
+If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com).  If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://aka.ms/opensource/security/pgpkey).
+
+You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://aka.ms/opensource/security/msrc). 
+
+Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
+
+  * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
+  * Full paths of source file(s) related to the manifestation of the issue
+  * The location of the affected source code (tag/branch/commit or direct URL)
+  * Any special configuration required to reproduce the issue
+  * Step-by-step instructions to reproduce the issue
+  * Proof-of-concept or exploit code (if possible)
+  * Impact of the issue, including how an attacker might exploit the issue
+
+This information will help us triage your report more quickly.
+
+If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://aka.ms/opensource/security/bounty) page for more details about our active programs.
+
+## Preferred Languages
+
+We prefer all communications to be in English.
+
+## Policy
+
+Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://aka.ms/opensource/security/cvd).
+
+<!-- END MICROSOFT SECURITY.MD BLOCK -->

deps/GSL/ThirdPartyNotices.txt

@@ -0,0 +1,41 @@
+
+THIRD-PARTY SOFTWARE NOTICES AND INFORMATION
+Do Not Translate or Localize
+
+GSL: Guidelines Support Library incorporates third party material from the projects listed below.
+
+-------------------------------------------------------------------------------
+Software: Google Test
+Owner: Google Inc.
+Source URL: github.com/google/googletest
+License: BSD 3 - Clause
+Text:
+    Copyright 2008, Google Inc.
+    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.
+        * Neither the name of Google Inc. 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 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.
+-------------------------------------------------------------------------------

deps/GSL/azure-pipelines.yml

@@ -0,0 +1,66 @@
+trigger:
+  - main
+
+pr:
+  autoCancel: true
+
+stages:
+- stage: GCC
+  dependsOn: []
+  jobs:
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: gcc
+      image: ubuntu-20.04
+      compilerVersions: [ 11, 10 ]
+      setupfile: 'setup_gcc.yml'
+
+- stage: Clang
+  dependsOn: []
+  jobs:
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: clang
+      image: ubuntu-20.04
+      compilerVersions: [ 12, 11 ]
+      setupfile: 'setup_clang.yml'
+
+- stage: Xcode
+  dependsOn: []
+  jobs:
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: 'Xcode'
+      image: macOS-11
+      compilerVersions: [ '12.5.1', '13.2.1' ]
+      setupfile: 'setup_apple.yml'
+
+- stage: VS_MSVC
+  dependsOn: []
+  jobs:
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: 'VS2019 (MSVC)'
+      compilerVersions: [ 'default' ]
+      image: windows-2019
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: 'VS2022 (MSVC)'
+      compilerVersions: [ 'default' ]
+      image: windows-2022
+
+- stage: VS_LLVM
+  dependsOn: []
+  jobs:
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: 'VS2019 (LLVM)'
+      compilerVersions: [ 'default' ]
+      image: windows-2019
+      extraCmakeArgs: '-T ClangCL'
+  - template: ./pipelines/jobs.yml
+    parameters:
+      compiler: 'VS2022 (LLVM)'
+      compilerVersions: [ 'default' ]
+      image: windows-2022
+      extraCmakeArgs: '-T ClangCL'

deps/GSL/docs/headers.md

@@ -0,0 +1,854 @@
+The Guidelines Support Library (GSL) interface is very lightweight and exposed via a header-only library. This document attempts to document all of the headers and their exposed classes and functions.
+
+Types and functions are exported in the namespace `gsl`.
+
+See [GSL: Guidelines support library](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#S-gsl)
+
+# <a name="H" />Headers
+
+- [`<algorithms>`](#user-content-H-algorithms)
+- [`<assert>`](#user-content-H-assert)
+- [`<byte>`](#user-content-H-byte)
+- [`<gsl>`](#user-content-H-gsl)
+- [`<narrow>`](#user-content-H-narrow)
+- [`<pointers>`](#user-content-H-pointers)
+- [`<span>`](#user-content-H-span)
+- [`<span_ext>`](#user-content-H-span_ext)
+- [`<string_span>`](#user-content-H-string_span)
+- [`<util>`](#user-content-H-util)
+
+## <a name="H-algorithms" />`<algorithms>`
+
+This header contains some common algorithms that have been wrapped in GSL safety features.
+
+- [`gsl::copy`](#user-content-H-algorithms-copy)
+
+### <a name="H-algorithms-copy" />`gsl::copy`
+
+```cpp
+template <class SrcElementType, std::size_t SrcExtent, class DestElementType,
+          std::size_t DestExtent>
+void copy(span<SrcElementType, SrcExtent> src, span<DestElementType, DestExtent> dest);
+```
+
+This function copies the content from the `src` [`span`](#user-content-H-span-span) to the `dest` [`span`](#user-content-H-span-span). It [`Expects`](#user-content-H-assert-expects)
+that the destination `span` is at least as large as the source `span`.
+
+## <a name="H-assert" />`<assert>`
+
+This header contains some macros used for contract checking and suppressing code analysis warnings.
+
+See [GSL.assert: Assertions](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#SS-assertions)
+
+- [`GSL_SUPPRESS`](#user-content-H-assert-gsl_suppress)
+- [`Expects`](#user-content-H-assert-expects)
+- [`Ensures`](#user-content-H-assert-ensures)
+
+### <a name="H-assert-gsl_suppress" />`GSL_SUPPRESS`
+
+This macro can be used to suppress a code analysis warning.
+
+The core guidelines request tools that check for the rules to respect suppressing a rule by writing
+`[[gsl::suppress(tag)]]` or `[[gsl::suppress(tag, justification: "message")]]`.
+
+Clang does not use exactly that syntax, but requires `tag` to be put in double quotes `[[gsl::suppress("tag")]]`.
+
+For portable code you can use `GSL_SUPPRESS(tag)`.
+
+See [In.force: Enforcement](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#inforce-enforcement).
+
+### <a name="H-assert-expects" />`Expects`
+
+This macro can be used for expressing a precondition. If the precondition is not held, then `std::terminate` will be called.
+
+See [I.6: Prefer `Expects()` for expressing preconditions](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i6-prefer-expects-for-expressing-preconditions)
+
+### <a name="H-assert-ensures" />`Ensures`
+
+This macro can be used for expressing a postcondition. If the postcondition is not held, then `std::terminate` will be called.
+
+See [I.8: Prefer `Ensures()` for expressing postconditions](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i8-prefer-ensures-for-expressing-postconditions)
+
+## <a name="H-byte" />`<byte>`
+
+This header contains the definition of a byte type, implementing `std::byte` before it was standardized into C++17.
+
+- [`gsl::byte`](#user-content-H-byte-byte)
+
+### <a name="H-byte-byte" />`gsl::byte`
+
+If `GSL_USE_STD_BYTE` is defined to be `1`, then `gsl::byte` will be an alias to `std::byte`.  
+If `GSL_USE_STD_BYTE` is defined to be `0`, then `gsl::byte` will be a distinct type that implements the concept of byte.  
+If `GSL_USE_STD_BYTE` is not defined, then the header file will check if `std::byte` is available (C\+\+17 or higher). If yes,
+`gsl::byte` will be an alias to `std::byte`, otherwise `gsl::byte` will be a distinct type that implements the concept of byte.
+
+&#x26a0; Take care when linking projects that were compiled with different language standards (before C\+\+17 and C\+\+17 or higher).
+If you do so, you might want to `#define GSL_USE_STD_BYTE 0` to a fixed value to be sure that both projects use exactly
+the same type. Otherwise you might get linker errors.
+
+See [SL.str.5: Use `std::byte` to refer to byte values that do not necessarily represent characters](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rstr-byte)
+
+### Non-member functions
+
+```cpp
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept;
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte operator<<(byte b, IntegerType shift) noexcept;
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept;
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte operator>>(byte b, IntegerType shift) noexcept;
+```
+
+Left or right shift a `byte` by a given number of bits.
+
+```cpp
+constexpr byte& operator|=(byte& l, byte r) noexcept;
+constexpr byte operator|(byte l, byte r) noexcept;
+```
+
+Bitwise "or" of two `byte`s.
+
+```cpp
+constexpr byte& operator&=(byte& l, byte r) noexcept;
+constexpr byte operator&(byte l, byte r) noexcept;
+```
+
+Bitwise "and" of two `byte`s.
+
+```cpp
+constexpr byte& operator^=(byte& l, byte r) noexcept;
+constexpr byte operator^(byte l, byte r) noexcept;
+```
+
+Bitwise xor of two `byte`s.
+
+```cpp
+constexpr byte operator~(byte b) noexcept;
+```
+
+Bitwise negation of a `byte`. Flips all bits. Zeroes become ones, ones become zeroes.
+
+```cpp
+template <typename T>
+constexpr byte to_byte(T t) noexcept;
+```
+
+Convert the given value to a `byte`. The template requires `T` to be an `unsigned char` so that no data loss can occur.
+If you want to convert an integer constant to a `byte` you probably want to call `to_byte<integer constant>()`.
+
+```cpp
+template <int I>
+constexpr byte to_byte() noexcept;
+```
+
+Convert the given value `I` to a `byte`. The template requires `I` to be in the valid range 0..255 for a `gsl::byte`.
+
+## <a name="H-gsl" />`<gsl>`
+
+This header is a convenience header that includes all other [GSL headers](#user-content-H).
+Since `<narrow>` requires exceptions, it will only be included if exceptions are enabled.
+
+## <a name="H-narrow" />`<narrow>`
+
+This header contains utility functions and classes, for narrowing casts, which require exceptions. The narrowing-related utilities that don't require exceptions are found inside [util](#user-content-H-util).
+
+See [GSL.util: Utilities](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#SS-utilities)
+
+- [`gsl::narrowing_error`](#user-content-H-narrow-narrowing_error)
+- [`gsl::narrow`](#user-content-H-narrow-narrow)
+
+### <a name="H-narrow-narrowing_error" />`gsl::narrowing_error`
+
+`gsl::narrowing_error` is the exception thrown by [`gsl::narrow`](#user-content-H-narrow-narrow) when a narrowing conversion fails. It is derived from `std::exception`.
+
+### <a name="H-narrow-narrow" />`gsl::narrow`
+
+`gsl::narrow<T>(x)` is a named cast that does a `static_cast<T>(x)` for narrowing conversions with no signedness promotions.
+If the argument `x` cannot be represented in the target type `T`, then the function throws a [`gsl::narrowing_error`](#user-content-H-narrow-narrowing_error) (e.g., `narrow<unsigned>(-42)` and `narrow<char>(300)` throw).
+
+Note: compare [`gsl::narrow_cast`](#user-content-H-util-narrow_cast) in header [util](#user-content-H-util).
+
+See [ES.46: Avoid lossy (narrowing, truncating) arithmetic conversions](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-narrowing) and [ES.49: If you must use a cast, use a named cast](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-casts-named)
+
+## <a name="H-pointers" />`<pointers>`
+
+This header contains some pointer types.
+
+See [GSL.view](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#SS-views)
+
+- [`gsl::unique_ptr`](#user-content-H-pointers-unique_ptr)
+- [`gsl::shared_ptr`](#user-content-H-pointers-shared_ptr)
+- [`gsl::owner`](#user-content-H-pointers-owner)
+- [`gsl::not_null`](#user-content-H-pointers-not_null)
+- [`gsl::strict_not_null`](#user-content-H-pointers-strict_not_null)
+
+### <a name="H-pointers-unique_ptr" />`gsl::unique_ptr`
+
+`gsl::unique_ptr` is an alias to `std::unique_ptr`.
+
+See [GSL.owner: Ownership pointers](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#SS-ownership)
+
+### <a name="H-pointers-shared_ptr" />`gsl::shared_ptr`
+
+`gsl::shared_ptr` is an alias to `std::shared_ptr`.
+
+See [GSL.owner: Ownership pointers](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#SS-ownership)
+
+### <a name="H-pointers-owner" />`gsl::owner`
+
+`gsl::owner<T>` is designed as a safety mechanism for code that must deal directly with raw pointers that own memory. Ideally such code should be restricted to the implementation of low-level abstractions. `gsl::owner` can also be used as a stepping point in converting legacy code to use more modern RAII constructs such as smart pointers.
+`T` must be a pointer type (`std::is_pointer<T>`).
+
+A `gsl::owner<T>` is a typedef to `T`. It adds no runtime overhead whatsoever, as it is purely syntactic and does not add any runtime checks.  Instead, it serves as an annotation for static analysis tools which check for memory safety, and as a code comprehension guide for human readers.
+
+See Enforcement section of [C.31: All resources acquired by a class must be released by the class’s destructor](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rc-dtor-release).
+
+### <a name="H-pointers-not_null" />`gsl::not_null`
+
+`gsl::not_null<T>` restricts a pointer or smart pointer to only hold non-null values. It has no size overhead over `T`.
+
+The checks for ensuring that the pointer is not null are done in the constructor. There is no overhead when retrieving or dereferencing the checked pointer.
+When a nullptr check fails, `std::terminate` is called.
+
+See [F.23: Use a `not_null<T>` to indicate that “null” is not a valid value](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-nullptr)
+
+#### Member functions
+
+##### Construct/Copy
+
+```cpp
+template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+constexpr not_null(U&& u);
+
+template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>>
+constexpr not_null(T u);
+```
+
+Constructs a `gsl_owner<T>` from a pointer that is convertible to `T` or that is a `T`. It [`Expects`](#user-content-H-assert-expects) that the provided pointer is not `== nullptr`.
+
+```cpp
+template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+constexpr not_null(const not_null<U>& other);
+```
+
+Constructs a `gsl_owner<T>` from another `gsl_owner` where the other pointer is convertible to `T`. It [`Expects`](#user-content-H-assert-expects) that the provided pointer is not `== nullptr`.
+
+```cpp
+not_null(const not_null& other) = default;
+not_null& operator=(const not_null& other) = default;
+```
+
+Copy construction and assignment.
+
+```cpp
+not_null(std::nullptr_t) = delete;
+not_null& operator=(std::nullptr_t) = delete;
+```
+
+Construction from `std::nullptr_t`  and assignment of `std::nullptr_t` are explicitly deleted.
+
+##### Modifiers
+
+```cpp
+not_null& operator++() = delete;
+not_null& operator--() = delete;
+not_null operator++(int) = delete;
+not_null operator--(int) = delete;
+not_null& operator+=(std::ptrdiff_t) = delete;
+not_null& operator-=(std::ptrdiff_t) = delete;
+```
+
+Explicitly deleted operators. Pointers point to single objects ([I.13: Do not pass an array as a single pointer](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Ri-array)), so don't allow these operators.
+
+##### Observers
+
+```cpp
+constexpr details::value_or_reference_return_t<T> get() const;
+constexpr operator T() const { return get(); }
+```
+
+Get the underlying pointer.
+
+```cpp
+constexpr decltype(auto) operator->() const { return get(); }
+constexpr decltype(auto) operator*() const { return *get(); }
+```
+
+Dereference the underlying pointer.
+
+```cpp
+void operator[](std::ptrdiff_t) const = delete;
+```
+
+Array index operator is explicitly deleted. Pointers point to single objects ([I.13: Do not pass an array as a single pointer](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Ri-array)), so don't allow treating them as an array.
+
+#### Non-member functions
+
+```cpp
+template <class T>
+auto make_not_null(T&& t) noexcept;
+```
+
+Creates a `gsl::not_null` object, deducing the target type from the type of the argument.
+
+```cpp
+template <class T, class U>
+auto operator==(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(lhs.get() == rhs.get()))
+    -> decltype(lhs.get() == rhs.get());
+template <class T, class U>
+auto operator!=(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(lhs.get() != rhs.get()))
+    -> decltype(lhs.get() != rhs.get());
+template <class T, class U>
+auto operator<(const not_null<T>& lhs,
+               const not_null<U>& rhs) noexcept(noexcept(lhs.get() < rhs.get()))
+    -> decltype(lhs.get() < rhs.get());
+template <class T, class U>
+auto operator<=(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(lhs.get() <= rhs.get()))
+    -> decltype(lhs.get() <= rhs.get());
+template <class T, class U>
+auto operator>(const not_null<T>& lhs,
+               const not_null<U>& rhs) noexcept(noexcept(lhs.get() > rhs.get()))
+    -> decltype(lhs.get() > rhs.get());
+template <class T, class U>
+auto operator>=(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(lhs.get() >= rhs.get()))
+    -> decltype(lhs.get() >= rhs.get());
+```
+
+Comparison of pointers that are convertible to each other.
+
+##### Input/Output
+
+```cpp
+template <class T>
+std::ostream& operator<<(std::ostream& os, const not_null<T>& val);
+```
+
+Performs stream output on a `not_null` pointer, invoking `os << val.get()`. This function is only available when `GSL_NO_IOSTREAMS` is not defined.
+
+##### Modifiers
+
+```cpp
+template <class T, class U>
+std::ptrdiff_t operator-(const not_null<T>&, const not_null<U>&) = delete;
+template <class T>
+not_null<T> operator-(const not_null<T>&, std::ptrdiff_t) = delete;
+template <class T>
+not_null<T> operator+(const not_null<T>&, std::ptrdiff_t) = delete;
+template <class T>
+not_null<T> operator+(std::ptrdiff_t, const not_null<T>&) = delete;
+```
+
+Addition and subtraction are explicitly deleted. Pointers point to single objects ([I.13: Do not pass an array as a single pointer](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Ri-array)), so don't allow these operators.
+
+##### STL integration
+
+```cpp
+template <class T>
+struct std::hash<gsl::not_null<T>> { ... };
+```
+
+Specialization of `std::hash` for `gsl::not_null`.
+
+### <a name="H-pointers-strict_not_null" />`gsl::strict_not_null`
+
+`strict_not_null` is the same as [`not_null`](#user-content-H-pointers-not_null) except that the constructors are `explicit`.
+
+The free function that deduces the target type from the type of the argument and creates a `gsl::strict_not_null` object is `gsl::make_strict_not_null`.
+
+## <a name="H-span" />`<span>`
+
+This header file exports the class `gsl::span`, a bounds-checked implementation of `std::span`.
+
+- [`gsl::span`](#user-content-H-span-span)
+
+### <a name="H-span-span" />`gsl::span`
+
+```cpp
+template <class ElementType, std::size_t Extent>
+class span;
+```
+
+`gsl::span` is a view over memory. It does not own the memory and is only a way to access contiguous sequences of objects.
+The extent can be either a fixed size or [`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent).
+
+The `gsl::span` is based on the standardized version of `std::span` which was added to C++20. Originally, the plan was to
+deprecate `gsl::span` when `std::span` finished standardization, however that plan changed when the runtime bounds checking
+was removed from `std::span`'s design.
+
+The only difference between `gsl::span` and `std::span` is that `gsl::span` strictly enforces runtime bounds checking.
+Any violations of the bounds check results in termination of the program.
+Like `gsl::span`, `gsl::span`'s iterators also differ from `std::span`'s iterator in that all access operations are bounds checked.
+
+#### Which version of span should I use?
+
+##### Use `gsl::span` if
+
+- you want to guarantee bounds safety in your project.
+  - All data accessing operations use bounds checking to ensure you are only accessing valid memory.
+- your project uses C++14 or C++17.
+  - `std::span` is not available as it was not introduced into the STL until C++20.
+
+##### Use `std::span` if
+
+- your project is C++20 and you need the performance offered by `std::span`.
+
+#### Types
+
+```cpp
+using element_type = ElementType;
+using value_type = std::remove_cv_t<ElementType>;
+using size_type = std::size_t;
+using pointer = element_type*;
+using const_pointer = const element_type*;
+using reference = element_type&;
+using const_reference = const element_type&;
+using difference_type = std::ptrdiff_t;
+
+using iterator = details::span_iterator<ElementType>;
+using reverse_iterator = std::reverse_iterator<iterator>;
+```
+
+#### Member functions
+
+```cpp
+constexpr span() noexcept;
+```
+
+Constructs an empty `span`. This constructor is only available if `Extent` is 0 or [`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent).
+`span::data()` will return `nullptr`.
+
+```cpp
+constexpr explicit(Extent != gsl::dynamic_extent) span(pointer ptr, size_type count) noexcept;
+```
+
+Constructs a `span` from a pointer and a size. If `Extent` is not [`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent),
+then the constructor [`Expects`](#user-content-H-assert-expects) that `count == Extent`.
+
+```cpp
+constexpr explicit(Extent != gsl::dynamic_extent) span(pointer firstElem, pointer lastElem) noexcept;
+```
+
+Constructs a `span` from a pointer to the begin and the end of the data. If `Extent` is not [`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent),
+then the constructor [`Expects`](#user-content-H-assert-expects) that `lastElem - firstElem == Extent`.
+
+```cpp
+template <std::size_t N>
+constexpr span(element_type (&arr)[N]) noexcept;
+```
+
+Constructs a `span` from a C style array. This overload is available if `Extent ==`[`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent)
+or `N == Extent`.
+
+```cpp
+template <class T, std::size_t N>
+constexpr span(std::array<T, N>& arr) noexcept;
+
+template <class T, std::size_t N>
+constexpr span(const std::array<T, N>& arr) noexcept;
+```
+
+Constructs a `span` from a `std::array`. These overloads are available if `Extent ==`[`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent)
+or `N == Extent`, and if the array can be interpreted as a `ElementType` array.
+
+```cpp
+template <class Container>
+constexpr explicit(Extent != gsl::dynamic_extent) span(Container& cont) noexcept;
+
+template <class Container>
+constexpr explicit(Extent != gsl::dynamic_extent) span(const Container& cont) noexcept;
+```
+
+Constructs a `span` from a container. These overloads are available if `Extent ==`[`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent)
+or `N == Extent`, and if the container can be interpreted as a contiguous `ElementType` array.
+
+```cpp
+constexpr span(const span& other) noexcept = default;
+```
+
+Copy constructor.
+
+```cpp
+template <class OtherElementType, std::size_t OtherExtent>
+explicit(Extent != gsl::dynamic_extent && OtherExtent == dynamic_extent)
+constexpr span(const span<OtherElementType, OtherExtent>& other) noexcept;
+```
+
+Constructs a `span` from another `span`. This constructor is available if `OtherExtent == Extent || Extent ==`[`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent)` || OtherExtent ==`[`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent)
+and if `ElementType` and `OtherElementType` are compatible.
+
+If `Extent !=`[`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent) and `OtherExtent ==`[`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent),
+then the constructor [`Expects`](#user-content-H-assert-expects) that `other.size() == Extent`.
+
+```cpp
+constexpr span& operator=(const span& other) noexcept = default;
+```
+
+Copy assignment
+
+```cpp
+template <std::size_t Count>
+constexpr span<element_type, Count> first() const noexcept;
+
+constexpr span<element_type, dynamic_extent> first(size_type count) const noexcept;
+
+template <std::size_t Count>
+constexpr span<element_type, Count> last() const noexcept;
+
+constexpr span<element_type, dynamic_extent> last(size_type count) const noexcept;
+```
+
+Return a subspan of the first/last `Count` elements. [`Expects`](#user-content-H-assert-expects) that `Count` does not exceed the `span`'s size.
+
+```cpp
+template <std::size_t offset, std::size_t count = dynamic_extent>
+constexpr auto subspan() const noexcept;
+
+constexpr span<element_type, dynamic_extent>
+subspan(size_type offset, size_type count = dynamic_extent) const noexcept;
+```
+
+Return a subspan starting at `offset` and having size `count`. [`Expects`](#user-content-H-assert-expects) that `offset` does not exceed the `span`'s size,
+and that `offset == `[`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent) or `offset + count` does not exceed the `span`'s size.
+If `count` is `gsl::dynamic_extent`, the number of elements in the subspan is `size() - offset`.
+
+```cpp
+constexpr size_type size() const noexcept;
+
+constexpr size_type size_bytes() const noexcept;
+```
+
+Returns the size respective the size in bytes of the `span`.
+
+```cpp
+constexpr bool empty() const noexcept;
+```
+
+Is the `span` empty?
+
+```cpp
+constexpr reference operator[](size_type idx) const noexcept;
+```
+
+Returns a reference to the element at the given index. [`Expects`](#user-content-H-assert-expects) that `idx` is less than the `span`'s size.
+
+```cpp
+constexpr reference front() const noexcept;
+constexpr reference back() const noexcept;
+```
+
+Returns a reference to the first/last element in the `span`. [`Expects`](#user-content-H-assert-expects) that the `span` is not empty.
+
+```cpp
+constexpr pointer data() const noexcept;
+```
+
+Returns a pointer to the beginning of the contained data.
+
+```cpp
+constexpr iterator begin() const noexcept;
+constexpr iterator end() const noexcept;
+constexpr reverse_iterator rbegin() const noexcept;
+constexpr reverse_iterator rend() const noexcept;
+```
+
+Returns an iterator to the first/last normal/reverse iterator.
+
+```cpp
+template <class Type, std::size_t Extent>
+span(Type (&)[Extent]) -> span<Type, Extent>;
+
+template <class Type, std::size_t Size>
+span(std::array<Type, Size>&) -> span<Type, Size>;
+
+template <class Type, std::size_t Size>
+span(const std::array<Type, Size>&) -> span<const Type, Size>;
+
+template <class Container,
+          class Element = std::remove_pointer_t<decltype(std::declval<Container&>().data())>>
+span(Container&) -> span<Element>;
+
+template <class Container,
+          class Element = std::remove_pointer_t<decltype(std::declval<const Container&>().data())>>
+span(const Container&) -> span<Element>;
+```
+
+Deduction guides.
+
+```cpp
+template <class ElementType, std::size_t Extent>
+span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
+as_bytes(span<ElementType, Extent> s) noexcept;
+
+template <class ElementType, std::size_t Extent>
+span<byte, details::calculate_byte_size<ElementType, Extent>::value>
+as_writable_bytes(span<ElementType, Extent> s) noexcept;
+```
+
+Converts a `span` into a `span` of `byte`s.
+
+`as_writable_bytes` will only be available for non-const `ElementType`s.
+
+## <a name="H-span_ext" />`<span_ext>`
+
+This file is a companion for and included by [`<gsl/span>`](#user-content-H-span), and should not be used on its own. It contains useful features that aren't part of the `std::span` API as found inside the STL `<span>` header (with the exception of [`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent), which is included here due to implementation constraints).
+
+- [`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent)
+- [`gsl::span`](#user-content-H-span_ext-span)
+- [`gsl::span` comparison operators](#user-content-H-span_ext-span_comparison_operators)
+- [`gsl::make_span`](#user-content-H-span_ext-make_span)
+- [`gsl::at`](#user-content-H-span_ext-at)
+- [`gsl::ssize`](#user-content-H-span_ext-ssize)
+- [`gsl::span` iterator functions](#user-content-H-span_ext-span_iterator_functions)
+
+### <a name="H-span_ext-dynamic_extent" />`gsl::dynamic_extent`
+
+Defines the extent value to be used by all `gsl::span` with dynamic extent. 
+
+Note: `std::dynamic_extent` is exposed by the STL `<span>` header and so ideally `gsl::dynamic_extent` would be under [`<gsl/span>`](#user-content-H-span), but to avoid cyclic dependency issues it is under `<span_ext>` instead.
+
+### <a name="H-span_ext-span" />`gsl::span`
+
+```cpp
+template <class ElementType, std::size_t Extent = dynamic_extent>
+class span;
+```
+
+Forward declaration of `gsl::span`.
+
+### <a name="H-span_ext-span_comparison_operators" />`gsl::span` comparison operators
+
+```cpp
+template <class ElementType, std::size_t FirstExtent, std::size_t SecondExtent>
+constexpr bool operator==(span<ElementType, FirstExtent> l, span<ElementType, SecondExtent> r);
+template <class ElementType, std::size_t FirstExtent, std::size_t SecondExtent>
+constexpr bool operator!=(span<ElementType, FirstExtent> l, span<ElementType, SecondExtent> r);
+template <class ElementType, std::size_t Extent>
+constexpr bool operator<(span<ElementType, Extent> l, span<ElementType, Extent> r);
+template <class ElementType, std::size_t Extent>
+constexpr bool operator<=(span<ElementType, Extent> l, span<ElementType, Extent> r);
+template <class ElementType, std::size_t Extent>
+constexpr bool operator>(span<ElementType, Extent> l, span<ElementType, Extent> r);
+template <class ElementType, std::size_t Extent>
+constexpr bool operator>=(span<ElementType, Extent> l, span<ElementType, Extent> r);
+```
+
+The comparison operators for two `span`s lexicographically compare the elements in the `span`s.
+
+### <a name="H-span_ext-make_span" />`gsl::make_span`
+
+```cpp
+template <class ElementType>
+constexpr span<ElementType> make_span(ElementType* ptr, typename span<ElementType>::size_type count);
+template <class ElementType>
+constexpr span<ElementType> make_span(ElementType* firstElem, ElementType* lastElem);
+template <class ElementType, std::size_t N>
+constexpr span<ElementType, N> make_span(ElementType (&arr)[N]) noexcept;
+template <class Container>
+constexpr span<typename Container::value_type> make_span(Container& cont);
+template <class Container>
+constexpr span<const typename Container::value_type> make_span(const Container& cont);
+template <class Ptr>
+constexpr span<typename Ptr::element_type> make_span(Ptr& cont, std::size_t count);
+template <class Ptr>
+constexpr span<typename Ptr::element_type> make_span(Ptr& cont);
+```
+
+Utility function for creating a `span` with [`gsl::dynamic_extent`](#user-content-H-span_ext-dynamic_extent) from
+- pointer and length,
+- pointer to start and pointer to end,
+- a C style array, or
+- a container.
+
+### <a name="H-span_ext-at" />`gsl::at`
+
+```cpp
+template <class ElementType, std::size_t Extent>
+constexpr ElementType& at(span<ElementType, Extent> s, index i);
+```
+
+The function `gsl::at` offers a safe way to access data with index bounds checking.
+
+This is the specialization of [`gsl::at`](#user-content-H-util-at) for [`span`](#user-content-H-span-span). It returns a reference to the `i`th element and
+[`Expects`](#user-content-H-assert-expects) that the provided index is within the bounds of the `span`.
+
+Note: `gsl::at` supports indexes up to `PTRDIFF_MAX`.
+
+### <a name="H-span_ext-ssize" />`gsl::ssize`
+
+```cpp
+template <class ElementType, std::size_t Extent>
+constexpr std::ptrdiff_t ssize(const span<ElementType, Extent>& s) noexcept;
+```
+
+Return the size of a [`span`](#user-content-H-span-span) as a `ptrdiff_t`.
+
+### <a name="H-span_ext-span_iterator_functions" />`gsl::span` iterator functions
+
+```cpp
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::iterator
+begin(const span<ElementType, Extent>& s) noexcept;
+
+template <class ElementType, std::size_t Extent = dynamic_extent>
+constexpr typename span<ElementType, Extent>::iterator
+end(const span<ElementType, Extent>& s) noexcept;
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+rbegin(const span<ElementType, Extent>& s) noexcept;
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+rend(const span<ElementType, Extent>& s) noexcept;
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::iterator
+cbegin(const span<ElementType, Extent>& s) noexcept;
+
+template <class ElementType, std::size_t Extent = dynamic_extent>
+constexpr typename span<ElementType, Extent>::iterator
+cend(const span<ElementType, Extent>& s) noexcept;
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+crbegin(const span<ElementType, Extent>& s) noexcept;
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+crend(const span<ElementType, Extent>& s) noexcept;
+```
+
+Free functions for getting a non-const/const begin/end normal/reverse iterator for a [`span`](#user-content-H-span-span).
+
+## <a name="H-string_span" />`<string_span>`
+
+This header exports a family of `*zstring` types.
+
+A `gsl::XXzstring<T>` is a typedef to `T`. It adds no checks whatsoever, it is just for having a syntax to describe
+that a pointer points to a zero terminated C style string. This helps static code analysis, and it helps human readers.
+
+`basic_zstring` is a pointer to a C-string (zero-terminated array) with a templated char type. Used to implement the rest of the `*zstring` family.  
+`zstring` is a zero terminated `char` string.  
+`czstring` is a const zero terminated `char` string.  
+`wzstring` is a zero terminated `wchar_t` string.  
+`cwzstring` is a const zero terminated `wchar_t` string.  
+`u16zstring` is a zero terminated `char16_t` string.  
+`cu16zstring` is a const zero terminated `char16_t` string.  
+`u32zstring` is a zero terminated `char32_t` string.  
+`cu32zstring` is a const zero terminated `char32_t` string.  
+
+See [GSL.view](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#SS-views) and [SL.str.3: Use zstring or czstring to refer to a C-style, zero-terminated, sequence of characters](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rstr-zstring).
+
+## <a name="H-util" />`<util>`
+
+This header contains utility functions and classes. This header works without exceptions being available. The parts that require
+exceptions being available are in their own header file [narrow](#user-content-H-narrow).
+
+See [GSL.util: Utilities](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#SS-utilities)
+
+- [`gsl::narrow_cast`](#user-content-H-util-narrow_cast)
+- [`gsl::final_action`](#user-content-H-util-final_action)
+- [`gsl::at`](#user-content-H-util-at)
+
+### <a name="H-util-index" />`gsl::index`
+
+An alias to `std::ptrdiff_t`. It serves as the index type for all container indexes/subscripts/sizes.
+
+### <a name="H-util-narrow_cast" />`gsl::narrow_cast`
+
+`gsl::narrow_cast<T>(x)` is a named cast that is identical to a `static_cast<T>(x)`. It exists to make clear to static code analysis tools and to human readers that a lossy conversion is acceptable.
+
+Note: compare the throwing version [`gsl::narrow`](#user-content-H-narrow-narrow) in header [narrow](#user-content-H-narrow).
+
+See [ES.46: Avoid lossy (narrowing, truncating) arithmetic conversions](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-narrowing) and [ES.49: If you must use a cast, use a named cast](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-casts-named)
+
+### <a name="H-util-final_action" />`gsl::final_action`
+
+```cpp
+template <class F>
+class final_action { ... };
+```
+
+`final_action` allows you to ensure something gets run at the end of a scope.
+
+See [E.19: Use a final_action object to express cleanup if no suitable resource handle is available](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Re-finally)
+
+#### Member functions
+
+```cpp
+explicit final_action(const F& ff) noexcept;
+explicit final_action(F&& ff) noexcept;
+```
+
+Construct an object with the action to invoke in the destructor.
+
+```cpp
+~final_action() noexcept;
+```
+
+The destructor will call the action that was passed in the constructor.
+
+```cpp
+final_action(final_action&& other) noexcept;
+final_action(const final_action&)   = delete;
+void operator=(const final_action&) = delete;
+void operator=(final_action&&)      = delete;
+```
+
+Move construction is allowed. Copy construction is deleted. Copy and move assignment are also explicitely deleted.
+
+#### Non-member functions
+
+```cpp
+template <class F>
+auto finally(F&& f) noexcept;
+```
+
+Creates a `gsl::final_action` object, deducing the template argument type from the type of the argument.
+
+### <a name="H-util-at" />`gsl::at`
+
+The function `gsl::at` offers a safe way to access data with index bounds checking.
+
+Note: `gsl::at` supports indexes up to `PTRDIFF_MAX`.
+
+See [ES.42: Keep use of pointers simple and straightforward](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Res-ptr)
+
+```cpp
+template <class T, std::size_t N>
+constexpr T& at(T (&arr)[N], const index i);
+```
+
+This overload returns a reference to the `i`s element of a C style array `arr`. It [`Expects`](#user-content-H-assert-expects) that the provided index is within the bounds of the array.
+
+```cpp
+template <class Cont>
+constexpr auto at(Cont& cont, const index i) -> decltype(cont[cont.size()]);
+```
+
+This overload returns a reference to the `i`s element of the container `cont`. It [`Expects`](#user-content-H-assert-expects) that the provided index is within the bounds of the array.
+
+```cpp
+template <class T>
+constexpr T at(const std::initializer_list<T> cont, const index i);
+```
+
+This overload returns a reference to the `i`s element of the initializer list `cont`. It [`Expects`](#user-content-H-assert-expects) that the provided index is within the bounds of the array.
+
+```cpp
+template <class T, std::size_t extent = std::dynamic_extent>
+constexpr auto at(std::span<T, extent> sp, const index i) -> decltype(sp[sp.size()]);
+```
+
+This overload returns a reference to the `i`s element of the `std::span` `sp`. It [`Expects`](#user-content-H-assert-expects) that the provided index is within the bounds of the array.
+
+For [`gsl::at`](#user-content-H-span_ext-at) for [`gsl::span`](#user-content-H-span-span) see header [`span_ext`](#user-content-H-span_ext).

deps/GSL/include/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Add include folders to the library and targets that consume it
+# the SYSTEM keyword suppresses warnings for users of the library
+#
+# By adding this directory as an include directory the user gets a
+# namespace effect.
+#
+# IE:
+#   #include <gsl/gsl>
+if(PROJECT_IS_TOP_LEVEL)
+    target_include_directories(GSL INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
+else()
+    target_include_directories(GSL SYSTEM INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
+endif()

deps/GSL/include/gsl/algorithm

@@ -0,0 +1,63 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_ALGORITHM_H
+#define GSL_ALGORITHM_H
+
+#include "assert" // for Expects
+#include "span"   // for dynamic_extent, span
+
+#include <algorithm>   // for copy_n
+#include <cstddef>     // for ptrdiff_t
+#include <type_traits> // for is_assignable
+
+#ifdef _MSC_VER
+#pragma warning(push)
+
+// turn off some warnings that are noisy about our Expects statements
+#pragma warning(disable : 4127) // conditional expression is constant
+#pragma warning(disable : 4996) // unsafe use of std::copy_n
+
+#endif // _MSC_VER
+
+namespace gsl
+{
+// Note: this will generate faster code than std::copy using span iterator in older msvc+stl
+// not necessary for msvc since VS2017 15.8 (_MSC_VER >= 1915)
+template <class SrcElementType, std::size_t SrcExtent, class DestElementType,
+          std::size_t DestExtent>
+void copy(span<SrcElementType, SrcExtent> src, span<DestElementType, DestExtent> dest)
+{
+    static_assert(std::is_assignable<decltype(*dest.data()), decltype(*src.data())>::value,
+                  "Elements of source span can not be assigned to elements of destination span");
+    static_assert(SrcExtent == dynamic_extent || DestExtent == dynamic_extent ||
+                      (SrcExtent <= DestExtent),
+                  "Source range is longer than target range");
+
+    Expects(dest.size() >= src.size());
+    // clang-format off
+    GSL_SUPPRESS(stl.1) // NO-FORMAT: attribute
+    // clang-format on
+    std::copy_n(src.data(), src.size(), dest.data());
+}
+
+} // namespace gsl
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif // _MSC_VER
+
+#endif // GSL_ALGORITHM_H

deps/GSL/include/gsl/assert

@@ -0,0 +1,136 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_ASSERT_H
+#define GSL_ASSERT_H
+
+//
+// Temporary until MSVC STL supports no-exceptions mode.
+// Currently terminate is a no-op in this mode, so we add termination behavior back
+//
+#if defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS))
+#define GSL_KERNEL_MODE
+
+#define GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND
+#include <intrin.h>
+#define RANGE_CHECKS_FAILURE 0
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-noreturn"
+#endif // defined(__clang__)
+
+#else // defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) &&
+      // !_HAS_EXCEPTIONS))
+
+#include <exception>
+
+#endif // defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) &&
+       // !_HAS_EXCEPTIONS))
+
+//
+// make suppress attributes parse for some compilers
+// Hopefully temporary until suppression standardization occurs
+//
+#if defined(__clang__)
+#define GSL_SUPPRESS(x) [[gsl::suppress("x")]]
+#else
+#if defined(_MSC_VER) && !defined(__INTEL_COMPILER) && !defined(__NVCC__)
+#define GSL_SUPPRESS(x) [[gsl::suppress(x)]]
+#else
+#define GSL_SUPPRESS(x)
+#endif // _MSC_VER
+#endif // __clang__
+
+#define GSL_STRINGIFY_DETAIL(x) #x
+#define GSL_STRINGIFY(x) GSL_STRINGIFY_DETAIL(x)
+
+#if defined(__clang__) || defined(__GNUC__)
+#define GSL_LIKELY(x) __builtin_expect(!!(x), 1)
+#define GSL_UNLIKELY(x) __builtin_expect(!!(x), 0)
+
+#else
+
+#define GSL_LIKELY(x) (!!(x))
+#define GSL_UNLIKELY(x) (!!(x))
+#endif // defined(__clang__) || defined(__GNUC__)
+
+//
+// GSL_ASSUME(cond)
+//
+// Tell the optimizer that the predicate cond must hold. It is unspecified
+// whether or not cond is actually evaluated.
+//
+#ifdef _MSC_VER
+#define GSL_ASSUME(cond) __assume(cond)
+#elif defined(__GNUC__)
+#define GSL_ASSUME(cond) ((cond) ? static_cast<void>(0) : __builtin_unreachable())
+#else
+#define GSL_ASSUME(cond) static_cast<void>((cond) ? 0 : 0)
+#endif
+
+//
+// GSL.assert: assertions
+//
+
+namespace gsl
+{
+
+namespace details
+{
+#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+
+    typedef void(__cdecl* terminate_handler)();
+
+    // clang-format off
+    GSL_SUPPRESS(f.6) // NO-FORMAT: attribute
+    // clang-format on
+    [[noreturn]] inline void __cdecl default_terminate_handler()
+    {
+        __fastfail(RANGE_CHECKS_FAILURE);
+    }
+
+    inline gsl::details::terminate_handler& get_terminate_handler() noexcept
+    {
+        static terminate_handler handler = &default_terminate_handler;
+        return handler;
+    }
+
+#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+
+    [[noreturn]] inline void terminate() noexcept
+    {
+#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+        (*gsl::details::get_terminate_handler())();
+#else
+        std::terminate();
+#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+    }
+
+} // namespace details
+} // namespace gsl
+
+#define GSL_CONTRACT_CHECK(type, cond)                                                             \
+    (GSL_LIKELY(cond) ? static_cast<void>(0) : gsl::details::terminate())
+
+#define Expects(cond) GSL_CONTRACT_CHECK("Precondition", cond)
+#define Ensures(cond) GSL_CONTRACT_CHECK("Postcondition", cond)
+
+#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND) && defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+#endif // GSL_ASSERT_H

deps/GSL/include/gsl/byte

@@ -0,0 +1,202 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_BYTE_H
+#define GSL_BYTE_H
+
+//
+// make suppress attributes work for some compilers
+// Hopefully temporary until suppression standardization occurs
+//
+#if defined(__clang__)
+#define GSL_SUPPRESS(x) [[gsl::suppress("x")]]
+#else
+#if defined(_MSC_VER) && !defined(__INTEL_COMPILER) && !defined(__NVCC__)
+#define GSL_SUPPRESS(x) [[gsl::suppress(x)]]
+#else
+#define GSL_SUPPRESS(x)
+#endif // _MSC_VER
+#endif // __clang__
+
+#include <type_traits>
+
+// VS2017 15.8 added support for the __cpp_lib_byte definition
+// To do: drop _HAS_STD_BYTE when support for pre 15.8 expires
+#ifdef _MSC_VER
+
+#pragma warning(push)
+
+// Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool.
+#pragma warning(disable : 26493) // don't use c-style casts // TODO: MSVC suppression in templates
+                                 // does not always work
+
+#ifndef GSL_USE_STD_BYTE
+// this tests if we are under MSVC and the standard lib has std::byte and it is enabled
+#if (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) ||                                                   \
+    (defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603)
+
+#define GSL_USE_STD_BYTE 1
+
+#else // (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >=
+      // 201603)
+
+#define GSL_USE_STD_BYTE 0
+
+#endif // (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >=
+       // 201603)
+#endif // GSL_USE_STD_BYTE
+
+#else // _MSC_VER
+
+#ifndef GSL_USE_STD_BYTE
+#include <cstddef> /* __cpp_lib_byte */
+// this tests if we are under GCC or Clang with enough -std=c++1z power to get us std::byte
+// also check if libc++ version is sufficient (> 5.0) or libstdc++ actually contains std::byte
+#if defined(__cplusplus) && (__cplusplus >= 201703L) &&                                            \
+    (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603) ||                                      \
+     defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
+
+#define GSL_USE_STD_BYTE 1
+
+#else // defined(__cplusplus) && (__cplusplus >= 201703L) &&
+      //   (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  ||
+      //    defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
+
+#define GSL_USE_STD_BYTE 0
+
+#endif // defined(__cplusplus) && (__cplusplus >= 201703L) &&
+       //   (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  ||
+       //    defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))
+#endif // GSL_USE_STD_BYTE
+
+#endif // _MSC_VER
+
+// Use __may_alias__ attribute on gcc and clang
+#if defined __clang__ || (defined(__GNUC__) && __GNUC__ > 5)
+#define byte_may_alias __attribute__((__may_alias__))
+#else // defined __clang__ || defined __GNUC__
+#define byte_may_alias
+#endif // defined __clang__ || defined __GNUC__
+
+#if GSL_USE_STD_BYTE
+#include <cstddef>
+#endif
+
+namespace gsl
+{
+#if GSL_USE_STD_BYTE
+
+using std::byte;
+using std::to_integer;
+
+#else // GSL_USE_STD_BYTE
+
+// This is a simple definition for now that allows
+// use of byte within span<> to be standards-compliant
+enum class byte_may_alias byte : unsigned char
+{
+};
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept
+{
+    return b = byte(static_cast<unsigned char>(b) << shift);
+}
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte operator<<(byte b, IntegerType shift) noexcept
+{
+    return byte(static_cast<unsigned char>(b) << shift);
+}
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept
+{
+    return b = byte(static_cast<unsigned char>(b) >> shift);
+}
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr byte operator>>(byte b, IntegerType shift) noexcept
+{
+    return byte(static_cast<unsigned char>(b) >> shift);
+}
+
+constexpr byte& operator|=(byte& l, byte r) noexcept
+{
+    return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
+}
+
+constexpr byte operator|(byte l, byte r) noexcept
+{
+    return byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
+}
+
+constexpr byte& operator&=(byte& l, byte r) noexcept
+{
+    return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
+}
+
+constexpr byte operator&(byte l, byte r) noexcept
+{
+    return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
+}
+
+constexpr byte& operator^=(byte& l, byte r) noexcept
+{
+    return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
+}
+
+constexpr byte operator^(byte l, byte r) noexcept
+{
+    return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
+}
+
+constexpr byte operator~(byte b) noexcept { return byte(~static_cast<unsigned char>(b)); }
+
+template <class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>
+constexpr IntegerType to_integer(byte b) noexcept
+{
+    return static_cast<IntegerType>(b);
+}
+
+#endif // GSL_USE_STD_BYTE
+
+template <typename T>
+// NOTE: need suppression since c++14 does not allow "return {t}"
+// GSL_SUPPRESS(type.4) // NO-FORMAT: attribute // TODO: suppression does not work
+constexpr byte to_byte(T t) noexcept
+{
+    static_assert(std::is_same<T, unsigned char>::value,
+                  "gsl::to_byte(t) must be provided an unsigned char, otherwise data loss may occur. "
+                  "If you are calling to_byte with an integer contant use: gsl::to_byte<t>() version.");
+    return byte(t);
+}
+
+template <int I>
+constexpr byte to_byte() noexcept
+{
+    static_assert(I >= 0 && I <= 255,
+                  "gsl::byte only has 8 bits of storage, values must be in range 0-255");
+    return static_cast<byte>(I);
+}
+
+} // namespace gsl
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif // _MSC_VER
+
+#endif // GSL_BYTE_H

deps/GSL/include/gsl/gsl

@@ -0,0 +1,32 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_GSL_H
+#define GSL_GSL_H
+
+#include "algorithm"   // copy
+#include "assert"      // Ensures/Expects
+#include "byte"        // byte
+#include "pointers"    // owner, not_null
+#include "span"        // span
+#include "string_span" // zstring, string_span, zstring_builder...
+#include "util"        // finally()/narrow_cast()...
+
+#ifdef __cpp_exceptions
+#include "narrow" // narrow()
+#endif
+
+#endif // GSL_GSL_H

deps/GSL/include/gsl/gsl_algorithm

@@ -0,0 +1,4 @@
+#pragma once
+#pragma message(                                                                                   \
+    "This header will soon be removed. Use <gsl/algorithm> instead of <gsl/gsl_algorithm>")
+#include "algorithm"

deps/GSL/include/gsl/gsl_assert

@@ -0,0 +1,3 @@
+#pragma once
+#pragma message("This header will soon be removed. Use <gsl/assert> instead of <gsl/gsl_assert>")
+#include "assert"

deps/GSL/include/gsl/gsl_byte

@@ -0,0 +1,3 @@
+#pragma once
+#pragma message("This header will soon be removed. Use <gsl/byte> instead of <gsl/gsl_byte>")
+#include "byte"

deps/GSL/include/gsl/gsl_narrow

@@ -0,0 +1,3 @@
+#pragma once
+#pragma message("This header will soon be removed. Use <gsl/narrow> instead of <gsl/gsl_narrow>")
+#include "narrow"

deps/GSL/include/gsl/gsl_util

@@ -0,0 +1,3 @@
+#pragma once
+#pragma message("This header will soon be removed. Use <gsl/util> instead of <gsl/gsl_util>")
+#include "util"

deps/GSL/include/gsl/narrow

@@ -0,0 +1,84 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_NARROW_H
+#define GSL_NARROW_H
+#include "assert"    // for GSL_SUPPRESS
+#include "util"      // for narrow_cast
+#include <exception> // for std::exception
+namespace gsl
+{
+struct narrowing_error : public std::exception
+{
+    const char* what() const noexcept override { return "narrowing_error"; }
+};
+
+// narrow() : a checked version of narrow_cast() that throws if the cast changed the value
+template <class T, class U, typename std::enable_if<std::is_arithmetic<T>::value>::type* = nullptr>
+// clang-format off
+GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+GSL_SUPPRESS(f.6) // NO-FORMAT: attribute // TODO: MSVC /analyze does not recognise noexcept(false)
+GSL_SUPPRESS(es.46) // NO-FORMAT: attribute // The warning suggests that a floating->unsigned conversion can occur
+                                            // in the static_cast below, and that gsl::narrow should be used instead.
+                                            // Suppress this warning, since gsl::narrow is defined in terms of
+                                            // static_cast
+    // clang-format on
+    constexpr T narrow(U u) noexcept(false)
+{
+    constexpr const bool is_different_signedness =
+        (std::is_signed<T>::value != std::is_signed<U>::value);
+
+GSL_SUPPRESS(es.103) // NO-FORMAT: attribute // don't overflow
+GSL_SUPPRESS(es.104) // NO-FORMAT: attribute // don't underflow
+GSL_SUPPRESS(p.2) // NO-FORMAT: attribute // don't rely on undefined behavior
+    const T t = narrow_cast<T>(u); // While this is technically undefined behavior in some cases (i.e., if the source value is of floating-point type
+                                   // and cannot fit into the destination integral type), the resultant behavior is benign on the platforms
+                                   // that we target (i.e., no hardware trap representations are hit).
+
+#if defined(__clang__) || defined(__GNUC__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+    // Note: NaN will always throw, since NaN != NaN
+    if (static_cast<U>(t) != u || (is_different_signedness && ((t < T{}) != (u < U{}))))
+    {
+        throw narrowing_error{};
+    }
+#if defined(__clang__) || defined(__GNUC__)
+    #pragma GCC diagnostic pop
+#endif
+
+    return t;
+}
+
+template <class T, class U, typename std::enable_if<!std::is_arithmetic<T>::value>::type* = nullptr>
+// clang-format off
+GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+GSL_SUPPRESS(f.6) // NO-FORMAT: attribute // TODO: MSVC /analyze does not recognise noexcept(false)
+    // clang-format on
+    constexpr T narrow(U u) noexcept(false)
+{
+    const T t = narrow_cast<T>(u);
+
+    if (static_cast<U>(t) != u)
+    {
+        throw narrowing_error{};
+    }
+
+    return t;
+}
+} // namespace gsl
+#endif // GSL_NARROW_H

deps/GSL/include/gsl/pointers

@@ -0,0 +1,346 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_POINTERS_H
+#define GSL_POINTERS_H
+
+#include "assert" // for Ensures, Expects
+
+#include <algorithm>    // for forward
+#include <cstddef>      // for ptrdiff_t, nullptr_t, size_t
+#include <memory>       // for shared_ptr, unique_ptr
+#include <system_error> // for hash
+#include <type_traits>  // for enable_if_t, is_convertible, is_assignable
+
+#if !defined(GSL_NO_IOSTREAMS)
+#include <iosfwd> // for ostream
+#endif            // !defined(GSL_NO_IOSTREAMS)
+
+namespace gsl
+{
+
+namespace details
+{
+    template <typename T, typename = void>
+    struct is_comparable_to_nullptr : std::false_type
+    {
+    };
+
+    template <typename T>
+    struct is_comparable_to_nullptr<
+        T,
+        std::enable_if_t<std::is_convertible<decltype(std::declval<T>() != nullptr), bool>::value>>
+        : std::true_type
+    {
+    };
+
+    // Resolves to the more efficient of `const T` or `const T&`, in the context of returning a const-qualified value
+    // of type T.
+    //
+    // Copied from cppfront's implementation of the CppCoreGuidelines F.16 (https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-in)
+    template<typename T>
+    using value_or_reference_return_t = std::conditional_t<
+                                            sizeof(T) < 2*sizeof(void*) && std::is_trivially_copy_constructible<T>::value,
+                                            const T,
+                                            const T&>;
+
+} // namespace details
+
+//
+// GSL.owner: ownership pointers
+//
+using std::shared_ptr;
+using std::unique_ptr;
+
+//
+// owner
+//
+// `gsl::owner<T>` is designed as a safety mechanism for code that must deal directly with raw pointers that own memory.
+// Ideally such code should be restricted to the implementation of low-level abstractions. `gsl::owner` can also be used
+// as a stepping point in converting legacy code to use more modern RAII constructs, such as smart pointers.
+//
+// T must be a pointer type
+// - disallow construction from any type other than pointer type
+//
+template <class T, class = std::enable_if_t<std::is_pointer<T>::value>>
+using owner = T;
+
+//
+// not_null
+//
+// Restricts a pointer or smart pointer to only hold non-null values.
+//
+// Has zero size overhead over T.
+//
+// If T is a pointer (i.e. T == U*) then
+// - allow construction from U*
+// - disallow construction from nullptr_t
+// - disallow default construction
+// - ensure construction from null U* fails
+// - allow implicit conversion to U*
+//
+template <class T>
+class not_null
+{
+public:
+    static_assert(details::is_comparable_to_nullptr<T>::value, "T cannot be compared to nullptr.");
+
+    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+    constexpr not_null(U&& u) : ptr_(std::forward<U>(u))
+    {
+        Expects(ptr_ != nullptr);
+    }
+
+    template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>>
+    constexpr not_null(T u) : ptr_(std::move(u))
+    {
+        Expects(ptr_ != nullptr);
+    }
+
+    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+    constexpr not_null(const not_null<U>& other) : not_null(other.get())
+    {}
+
+    not_null(const not_null& other) = default;
+    not_null& operator=(const not_null& other) = default;
+    constexpr details::value_or_reference_return_t<T> get() const
+    {
+        return ptr_;
+    }
+
+    constexpr operator T() const { return get(); }
+    constexpr decltype(auto) operator->() const { return get(); }
+    constexpr decltype(auto) operator*() const { return *get(); }
+
+    // prevents compilation when someone attempts to assign a null pointer constant
+    not_null(std::nullptr_t) = delete;
+    not_null& operator=(std::nullptr_t) = delete;
+
+    // unwanted operators...pointers only point to single objects!
+    not_null& operator++() = delete;
+    not_null& operator--() = delete;
+    not_null operator++(int) = delete;
+    not_null operator--(int) = delete;
+    not_null& operator+=(std::ptrdiff_t) = delete;
+    not_null& operator-=(std::ptrdiff_t) = delete;
+    void operator[](std::ptrdiff_t) const = delete;
+
+private:
+    T ptr_;
+};
+
+template <class T>
+auto make_not_null(T&& t) noexcept
+{
+    return not_null<std::remove_cv_t<std::remove_reference_t<T>>>{std::forward<T>(t)};
+}
+
+#if !defined(GSL_NO_IOSTREAMS)
+template <class T>
+std::ostream& operator<<(std::ostream& os, const not_null<T>& val)
+{
+    os << val.get();
+    return os;
+}
+#endif // !defined(GSL_NO_IOSTREAMS)
+
+template <class T, class U>
+auto operator==(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(lhs.get() == rhs.get()))
+    -> decltype(lhs.get() == rhs.get())
+{
+    return lhs.get() == rhs.get();
+}
+
+template <class T, class U>
+auto operator!=(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(lhs.get() != rhs.get()))
+    -> decltype(lhs.get() != rhs.get())
+{
+    return lhs.get() != rhs.get();
+}
+
+template <class T, class U>
+auto operator<(const not_null<T>& lhs,
+               const not_null<U>& rhs) noexcept(noexcept(std::less<>{}(lhs.get(), rhs.get())))
+    -> decltype(std::less<>{}(lhs.get(), rhs.get()))
+{
+    return std::less<>{}(lhs.get(), rhs.get());
+}
+
+template <class T, class U>
+auto operator<=(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(std::less_equal<>{}(lhs.get(), rhs.get())))
+    -> decltype(std::less_equal<>{}(lhs.get(), rhs.get()))
+{
+    return std::less_equal<>{}(lhs.get(), rhs.get());
+}
+
+template <class T, class U>
+auto operator>(const not_null<T>& lhs,
+               const not_null<U>& rhs) noexcept(noexcept(std::greater<>{}(lhs.get(), rhs.get())))
+    -> decltype(std::greater<>{}(lhs.get(), rhs.get()))
+{
+    return std::greater<>{}(lhs.get(), rhs.get());
+}
+
+template <class T, class U>
+auto operator>=(const not_null<T>& lhs,
+                const not_null<U>& rhs) noexcept(noexcept(std::greater_equal<>{}(lhs.get(), rhs.get())))
+    -> decltype(std::greater_equal<>{}(lhs.get(), rhs.get()))
+{
+    return std::greater_equal<>{}(lhs.get(), rhs.get());
+}
+
+// more unwanted operators
+template <class T, class U>
+std::ptrdiff_t operator-(const not_null<T>&, const not_null<U>&) = delete;
+template <class T>
+not_null<T> operator-(const not_null<T>&, std::ptrdiff_t) = delete;
+template <class T>
+not_null<T> operator+(const not_null<T>&, std::ptrdiff_t) = delete;
+template <class T>
+not_null<T> operator+(std::ptrdiff_t, const not_null<T>&) = delete;
+
+
+template <class T, class U = decltype(std::declval<const T&>().get()), bool = std::is_default_constructible<std::hash<U>>::value>
+struct not_null_hash
+{
+    std::size_t operator()(const T& value) const { return std::hash<U>{}(value.get()); }
+};
+
+template <class T, class U>
+struct not_null_hash<T, U, false>
+{
+    not_null_hash() = delete;
+    not_null_hash(const not_null_hash&) = delete;
+    not_null_hash& operator=(const not_null_hash&) = delete;
+};
+
+} // namespace gsl
+
+namespace std
+{
+template <class T>
+struct hash<gsl::not_null<T>> : gsl::not_null_hash<gsl::not_null<T>>
+{
+};
+
+} // namespace std
+
+namespace gsl
+{
+
+//
+// strict_not_null
+//
+// Restricts a pointer or smart pointer to only hold non-null values,
+//
+// - provides a strict (i.e. explicit constructor from T) wrapper of not_null
+// - to be used for new code that wishes the design to be cleaner and make not_null
+//   checks intentional, or in old code that would like to make the transition.
+//
+//   To make the transition from not_null, incrementally replace not_null
+//   by strict_not_null and fix compilation errors
+//
+//   Expect to
+//   - remove all unneeded conversions from raw pointer to not_null and back
+//   - make API clear by specifying not_null in parameters where needed
+//   - remove unnecessary asserts
+//
+template <class T>
+class strict_not_null : public not_null<T>
+{
+public:
+    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+    constexpr explicit strict_not_null(U&& u) : not_null<T>(std::forward<U>(u))
+    {}
+
+    template <typename = std::enable_if_t<!std::is_same<std::nullptr_t, T>::value>>
+    constexpr explicit strict_not_null(T u) : not_null<T>(u)
+    {}
+
+    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+    constexpr strict_not_null(const not_null<U>& other) : not_null<T>(other)
+    {}
+
+    template <typename U, typename = std::enable_if_t<std::is_convertible<U, T>::value>>
+    constexpr strict_not_null(const strict_not_null<U>& other) : not_null<T>(other)
+    {}
+
+    // To avoid invalidating the "not null" invariant, the contained pointer is actually copied
+    // instead of moved. If it is a custom pointer, its constructor could in theory throw exceptions.
+    strict_not_null(strict_not_null&& other) noexcept(std::is_nothrow_copy_constructible<T>::value) = default;
+    strict_not_null(const strict_not_null& other) = default;
+    strict_not_null& operator=(const strict_not_null& other) = default;
+    strict_not_null& operator=(const not_null<T>& other)
+    {
+        not_null<T>::operator=(other);
+        return *this;
+    }
+
+    // prevents compilation when someone attempts to assign a null pointer constant
+    strict_not_null(std::nullptr_t) = delete;
+    strict_not_null& operator=(std::nullptr_t) = delete;
+
+    // unwanted operators...pointers only point to single objects!
+    strict_not_null& operator++() = delete;
+    strict_not_null& operator--() = delete;
+    strict_not_null operator++(int) = delete;
+    strict_not_null operator--(int) = delete;
+    strict_not_null& operator+=(std::ptrdiff_t) = delete;
+    strict_not_null& operator-=(std::ptrdiff_t) = delete;
+    void operator[](std::ptrdiff_t) const = delete;
+};
+
+// more unwanted operators
+template <class T, class U>
+std::ptrdiff_t operator-(const strict_not_null<T>&, const strict_not_null<U>&) = delete;
+template <class T>
+strict_not_null<T> operator-(const strict_not_null<T>&, std::ptrdiff_t) = delete;
+template <class T>
+strict_not_null<T> operator+(const strict_not_null<T>&, std::ptrdiff_t) = delete;
+template <class T>
+strict_not_null<T> operator+(std::ptrdiff_t, const strict_not_null<T>&) = delete;
+
+template <class T>
+auto make_strict_not_null(T&& t) noexcept
+{
+    return strict_not_null<std::remove_cv_t<std::remove_reference_t<T>>>{std::forward<T>(t)};
+}
+
+#if (defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L))
+
+// deduction guides to prevent the ctad-maybe-unsupported warning
+template <class T>
+not_null(T) -> not_null<T>;
+template <class T>
+strict_not_null(T) -> strict_not_null<T>;
+
+#endif // ( defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L) )
+
+} // namespace gsl
+
+namespace std
+{
+template <class T>
+struct hash<gsl::strict_not_null<T>> : gsl::not_null_hash<gsl::strict_not_null<T>>
+{
+};
+
+} // namespace std
+
+#endif // GSL_POINTERS_H

deps/GSL/include/gsl/span

@@ -0,0 +1,842 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_SPAN_H
+#define GSL_SPAN_H
+
+#include "assert"   // for Expects
+#include "byte"     // for byte
+#include "span_ext" // for span specialization of gsl::at and other span-related extensions
+#include "util"     // for narrow_cast
+
+#include <array>       // for array
+#include <cstddef>     // for ptrdiff_t, size_t, nullptr_t
+#include <iterator>    // for reverse_iterator, distance, random_access_...
+#include <memory>      // for pointer_traits
+#include <type_traits> // for enable_if_t, declval, is_convertible, inte...
+
+#if defined(__has_include) && __has_include(<version>)
+#include <version>
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#pragma warning(push)
+
+// turn off some warnings that are noisy about our Expects statements
+#pragma warning(disable : 4127) // conditional expression is constant
+#pragma warning(                                                                                   \
+    disable : 4146) // unary minus operator applied to unsigned type, result still unsigned
+#pragma warning(disable : 4702) // unreachable code
+
+// Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool.
+#pragma warning(disable : 26495) // uninitalized member when constructor calls constructor
+#pragma warning(disable : 26446) // parser bug does not allow attributes on some templates
+
+#endif // _MSC_VER
+
+// See if we have enough C++17 power to use a static constexpr data member
+// without needing an out-of-line definition
+#if !(defined(__cplusplus) && (__cplusplus >= 201703L))
+#define GSL_USE_STATIC_CONSTEXPR_WORKAROUND
+#endif // !(defined(__cplusplus) && (__cplusplus >= 201703L))
+
+// GCC 7 does not like the signed unsigned missmatch (size_t ptrdiff_t)
+// While there is a conversion from signed to unsigned, it happens at
+// compiletime, so the compiler wouldn't have to warn indiscriminately, but
+// could check if the source value actually doesn't fit into the target type
+// and only warn in those cases.
+#if defined(__GNUC__) && __GNUC__ > 6
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
+namespace gsl
+{
+
+// implementation details
+namespace details
+{
+    template <class T>
+    struct is_span_oracle : std::false_type
+    {
+    };
+
+    template <class ElementType, std::size_t Extent>
+    struct is_span_oracle<gsl::span<ElementType, Extent>> : std::true_type
+    {
+    };
+
+    template <class T>
+    struct is_span : public is_span_oracle<std::remove_cv_t<T>>
+    {
+    };
+
+    template <class T>
+    struct is_std_array_oracle : std::false_type
+    {
+    };
+
+    template <class ElementType, std::size_t Extent>
+    struct is_std_array_oracle<std::array<ElementType, Extent>> : std::true_type
+    {
+    };
+
+    template <class T>
+    struct is_std_array : is_std_array_oracle<std::remove_cv_t<T>>
+    {
+    };
+
+    template <std::size_t From, std::size_t To>
+    struct is_allowed_extent_conversion
+        : std::integral_constant<bool, From == To || To == dynamic_extent>
+    {
+    };
+
+    template <class From, class To>
+    struct is_allowed_element_type_conversion
+        : std::integral_constant<bool, std::is_convertible<From (*)[], To (*)[]>::value>
+    {
+    };
+
+    template <class Type>
+    class span_iterator
+    {
+    public:
+#if defined(__cpp_lib_ranges) || (defined(_MSVC_STL_VERSION) && defined(__cpp_lib_concepts))
+        using iterator_concept = std::contiguous_iterator_tag;
+#endif // __cpp_lib_ranges
+        using iterator_category = std::random_access_iterator_tag;
+        using value_type = std::remove_cv_t<Type>;
+        using difference_type = std::ptrdiff_t;
+        using pointer = Type*;
+        using reference = Type&;
+
+#ifdef _MSC_VER
+        using _Unchecked_type = pointer;
+        using _Prevent_inheriting_unwrap = span_iterator;
+#endif // _MSC_VER
+        constexpr span_iterator() = default;
+
+        constexpr span_iterator(pointer begin, pointer end, pointer current)
+            : begin_(begin), end_(end), current_(current)
+        {}
+
+        constexpr operator span_iterator<const Type>() const noexcept
+        {
+            return {begin_, end_, current_};
+        }
+
+        constexpr reference operator*() const noexcept
+        {
+            Expects(begin_ && end_);
+            Expects(begin_ <= current_ && current_ < end_);
+            return *current_;
+        }
+
+        constexpr pointer operator->() const noexcept
+        {
+            Expects(begin_ && end_);
+            Expects(begin_ <= current_ && current_ < end_);
+            return current_;
+        }
+        constexpr span_iterator& operator++() noexcept
+        {
+            Expects(begin_ && current_ && end_);
+            Expects(current_ < end_);
+            // clang-format off
+            GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+            // clang-format on
+            ++current_;
+            return *this;
+        }
+
+        constexpr span_iterator operator++(int) noexcept
+        {
+            span_iterator ret = *this;
+            ++*this;
+            return ret;
+        }
+
+        constexpr span_iterator& operator--() noexcept
+        {
+            Expects(begin_ && end_);
+            Expects(begin_ < current_);
+            --current_;
+            return *this;
+        }
+
+        constexpr span_iterator operator--(int) noexcept
+        {
+            span_iterator ret = *this;
+            --*this;
+            return ret;
+        }
+
+        constexpr span_iterator& operator+=(const difference_type n) noexcept
+        {
+            if (n != 0) Expects(begin_ && current_ && end_);
+            if (n > 0) Expects(end_ - current_ >= n);
+            if (n < 0) Expects(current_ - begin_ >= -n);
+            // clang-format off
+            GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+            // clang-format on
+            current_ += n;
+            return *this;
+        }
+
+        constexpr span_iterator operator+(const difference_type n) const noexcept
+        {
+            span_iterator ret = *this;
+            ret += n;
+            return ret;
+        }
+
+        friend constexpr span_iterator operator+(const difference_type n,
+                                                 const span_iterator& rhs) noexcept
+        {
+            return rhs + n;
+        }
+
+        constexpr span_iterator& operator-=(const difference_type n) noexcept
+        {
+            if (n != 0) Expects(begin_ && current_ && end_);
+            if (n > 0) Expects(current_ - begin_ >= n);
+            if (n < 0) Expects(end_ - current_ >= -n);
+            GSL_SUPPRESS(bounds .1)
+            current_ -= n;
+            return *this;
+        }
+
+        constexpr span_iterator operator-(const difference_type n) const noexcept
+        {
+            span_iterator ret = *this;
+            ret -= n;
+            return ret;
+        }
+
+        template <
+            class Type2,
+            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
+        constexpr difference_type operator-(const span_iterator<Type2>& rhs) const noexcept
+        {
+            Expects(begin_ == rhs.begin_ && end_ == rhs.end_);
+            return current_ - rhs.current_;
+        }
+
+        constexpr reference operator[](const difference_type n) const noexcept
+        {
+            return *(*this + n);
+        }
+
+        template <
+            class Type2,
+            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
+        constexpr bool operator==(const span_iterator<Type2>& rhs) const noexcept
+        {
+            Expects(begin_ == rhs.begin_ && end_ == rhs.end_);
+            return current_ == rhs.current_;
+        }
+
+        template <
+            class Type2,
+            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
+        constexpr bool operator!=(const span_iterator<Type2>& rhs) const noexcept
+        {
+            return !(*this == rhs);
+        }
+
+        template <
+            class Type2,
+            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
+        constexpr bool operator<(const span_iterator<Type2>& rhs) const noexcept
+        {
+            Expects(begin_ == rhs.begin_ && end_ == rhs.end_);
+            return current_ < rhs.current_;
+        }
+
+        template <
+            class Type2,
+            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
+        constexpr bool operator>(const span_iterator<Type2>& rhs) const noexcept
+        {
+            return rhs < *this;
+        }
+
+        template <
+            class Type2,
+            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
+        constexpr bool operator<=(const span_iterator<Type2>& rhs) const noexcept
+        {
+            return !(rhs < *this);
+        }
+
+        template <
+            class Type2,
+            std::enable_if_t<std::is_same<std::remove_cv_t<Type2>, value_type>::value, int> = 0>
+        constexpr bool operator>=(const span_iterator<Type2>& rhs) const noexcept
+        {
+            return !(*this < rhs);
+        }
+
+#ifdef _MSC_VER
+        // MSVC++ iterator debugging support; allows STL algorithms in 15.8+
+        // to unwrap span_iterator to a pointer type after a range check in STL
+        // algorithm calls
+        friend constexpr void _Verify_range(span_iterator lhs, span_iterator rhs) noexcept
+        { // test that [lhs, rhs) forms a valid range inside an STL algorithm
+            Expects(lhs.begin_ == rhs.begin_ // range spans have to match
+                    && lhs.end_ == rhs.end_ &&
+                    lhs.current_ <= rhs.current_); // range must not be transposed
+        }
+
+        constexpr void _Verify_offset(const difference_type n) const noexcept
+        { // test that *this + n is within the range of this call
+            if (n != 0) Expects(begin_ && current_ && end_);
+            if (n > 0) Expects(end_ - current_ >= n);
+            if (n < 0) Expects(current_ - begin_ >= -n);
+        }
+
+        // clang-format off
+        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
+        constexpr pointer _Unwrapped() const noexcept
+        { // after seeking *this to a high water mark, or using one of the
+            // _Verify_xxx functions above, unwrap this span_iterator to a raw
+            // pointer
+            return current_;
+        }
+
+        // Tell the STL that span_iterator should not be unwrapped if it can't
+        // validate in advance, even in release / optimized builds:
+#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
+        static constexpr const bool _Unwrap_when_unverified = false;
+#else
+        static constexpr bool _Unwrap_when_unverified = false;
+#endif
+        // clang-format off
+        GSL_SUPPRESS(con.3) // NO-FORMAT: attribute // TODO: false positive
+        // clang-format on
+        constexpr void _Seek_to(const pointer p) noexcept
+        { // adjust the position of *this to previously verified location p
+            // after _Unwrapped
+            current_ = p;
+        }
+#endif
+
+        pointer begin_ = nullptr;
+        pointer end_ = nullptr;
+        pointer current_ = nullptr;
+
+        template <typename Ptr>
+        friend struct std::pointer_traits;
+    };
+}} // namespace gsl::details
+
+namespace std
+{
+template <class Type>
+struct pointer_traits<::gsl::details::span_iterator<Type>>
+{
+    using pointer = ::gsl::details::span_iterator<Type>;
+    using element_type = Type;
+    using difference_type = ptrdiff_t;
+
+    static constexpr element_type* to_address(const pointer i) noexcept { return i.current_; }
+};
+} // namespace std
+
+namespace gsl { namespace details {
+    template <std::size_t Ext>
+    class extent_type
+    {
+    public:
+        using size_type = std::size_t;
+
+        constexpr extent_type() noexcept = default;
+
+        constexpr explicit extent_type(extent_type<dynamic_extent>);
+
+        constexpr explicit extent_type(size_type size) { Expects(size == Ext); }
+
+        constexpr size_type size() const noexcept { return Ext; }
+
+    private:
+#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
+        static constexpr const size_type size_ = Ext; // static size equal to Ext
+#else
+        static constexpr size_type size_ = Ext; // static size equal to Ext
+#endif
+    };
+
+    template <>
+    class extent_type<dynamic_extent>
+    {
+    public:
+        using size_type = std::size_t;
+
+        template <size_type Other>
+        constexpr explicit extent_type(extent_type<Other> ext) : size_(ext.size())
+        {}
+
+        constexpr explicit extent_type(size_type size) : size_(size)
+        {
+            Expects(size != dynamic_extent);
+        }
+
+        constexpr size_type size() const noexcept { return size_; }
+
+    private:
+        size_type size_;
+    };
+
+    template <std::size_t Ext>
+    constexpr extent_type<Ext>::extent_type(extent_type<dynamic_extent> ext)
+    {
+        Expects(ext.size() == Ext);
+    }
+
+    template <class ElementType, std::size_t Extent, std::size_t Offset, std::size_t Count>
+    struct calculate_subspan_type
+    {
+        using type = span<ElementType, Count != dynamic_extent
+                                           ? Count
+                                           : (Extent != dynamic_extent ? Extent - Offset : Extent)>;
+    };
+} // namespace details
+
+// [span], class template span
+template <class ElementType, std::size_t Extent>
+class span
+{
+public:
+    // constants and types
+    using element_type = ElementType;
+    using value_type = std::remove_cv_t<ElementType>;
+    using size_type = std::size_t;
+    using pointer = element_type*;
+    using const_pointer = const element_type*;
+    using reference = element_type&;
+    using const_reference = const element_type&;
+    using difference_type = std::ptrdiff_t;
+
+    using iterator = details::span_iterator<ElementType>;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+
+#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
+    static constexpr const size_type extent{Extent};
+#else
+    static constexpr size_type extent{Extent};
+#endif
+
+    // [span.cons], span constructors, copy, assignment, and destructor
+    template <bool Dependent = false,
+              // "Dependent" is needed to make "std::enable_if_t<Dependent || Extent == 0 || Extent
+              // == dynamic_extent>" SFINAE, since "std::enable_if_t<Extent == 0 || Extent ==
+              // dynamic_extent>" is ill-formed when Extent is greater than 0.
+              class = std::enable_if_t<(Dependent ||
+                                        details::is_allowed_extent_conversion<0, Extent>::value)>>
+    constexpr span() noexcept : storage_(nullptr, details::extent_type<0>())
+    {}
+
+    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent != dynamic_extent, int> = 0>
+    constexpr explicit span(pointer ptr, size_type count) noexcept : storage_(ptr, count)
+    {
+        Expects(count == Extent);
+    }
+
+    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent == dynamic_extent, int> = 0>
+    constexpr span(pointer ptr, size_type count) noexcept : storage_(ptr, count)
+    {}
+
+    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent != dynamic_extent, int> = 0>
+    constexpr explicit span(pointer firstElem, pointer lastElem) noexcept
+        : storage_(firstElem, narrow_cast<std::size_t>(lastElem - firstElem))
+    {
+        Expects(lastElem - firstElem == static_cast<difference_type>(Extent));
+    }
+
+    template <std::size_t MyExtent = Extent, std::enable_if_t<MyExtent == dynamic_extent, int> = 0>
+    constexpr span(pointer firstElem, pointer lastElem) noexcept
+        : storage_(firstElem, narrow_cast<std::size_t>(lastElem - firstElem))
+    {}
+
+    template <std::size_t N,
+              std::enable_if_t<details::is_allowed_extent_conversion<N, Extent>::value, int> = 0>
+    constexpr span(element_type (&arr)[N]) noexcept
+        : storage_(KnownNotNull{arr}, details::extent_type<N>())
+    {}
+
+    template <
+        class T, std::size_t N,
+        std::enable_if_t<(details::is_allowed_extent_conversion<N, Extent>::value &&
+                          details::is_allowed_element_type_conversion<T, element_type>::value),
+                         int> = 0>
+    constexpr span(std::array<T, N>& arr) noexcept
+        : storage_(KnownNotNull{arr.data()}, details::extent_type<N>())
+    {}
+
+    template <class T, std::size_t N,
+              std::enable_if_t<
+                  (details::is_allowed_extent_conversion<N, Extent>::value &&
+                   details::is_allowed_element_type_conversion<const T, element_type>::value),
+                  int> = 0>
+    constexpr span(const std::array<T, N>& arr) noexcept
+        : storage_(KnownNotNull{arr.data()}, details::extent_type<N>())
+    {}
+
+    // NB: the SFINAE on these constructors uses .data() as an incomplete/imperfect proxy for the
+    // requirement on Container to be a contiguous sequence container.
+    template <std::size_t MyExtent = Extent, class Container,
+              std::enable_if_t<
+                  MyExtent != dynamic_extent && !details::is_span<Container>::value &&
+                      !details::is_std_array<Container>::value &&
+                      std::is_pointer<decltype(std::declval<Container&>().data())>::value &&
+                      std::is_convertible<
+                          std::remove_pointer_t<decltype(std::declval<Container&>().data())> (*)[],
+                          element_type (*)[]>::value,
+                  int> = 0>
+    constexpr explicit span(Container& cont) noexcept : span(cont.data(), cont.size())
+    {}
+
+    template <std::size_t MyExtent = Extent, class Container,
+              std::enable_if_t<
+                  MyExtent == dynamic_extent && !details::is_span<Container>::value &&
+                      !details::is_std_array<Container>::value &&
+                      std::is_pointer<decltype(std::declval<Container&>().data())>::value &&
+                      std::is_convertible<
+                          std::remove_pointer_t<decltype(std::declval<Container&>().data())> (*)[],
+                          element_type (*)[]>::value,
+                  int> = 0>
+    constexpr span(Container& cont) noexcept : span(cont.data(), cont.size())
+    {}
+
+    template <
+        std::size_t MyExtent = Extent, class Container,
+        std::enable_if_t<
+            MyExtent != dynamic_extent && std::is_const<element_type>::value &&
+                !details::is_span<Container>::value && !details::is_std_array<Container>::value &&
+                std::is_pointer<decltype(std::declval<const Container&>().data())>::value &&
+                std::is_convertible<
+                    std::remove_pointer_t<decltype(std::declval<const Container&>().data())> (*)[],
+                    element_type (*)[]>::value,
+            int> = 0>
+    constexpr explicit span(const Container& cont) noexcept : span(cont.data(), cont.size())
+    {}
+
+    template <
+        std::size_t MyExtent = Extent, class Container,
+        std::enable_if_t<
+            MyExtent == dynamic_extent && std::is_const<element_type>::value &&
+                !details::is_span<Container>::value && !details::is_std_array<Container>::value &&
+                std::is_pointer<decltype(std::declval<const Container&>().data())>::value &&
+                std::is_convertible<
+                    std::remove_pointer_t<decltype(std::declval<const Container&>().data())> (*)[],
+                    element_type (*)[]>::value,
+            int> = 0>
+    constexpr span(const Container& cont) noexcept : span(cont.data(), cont.size())
+    {}
+
+    constexpr span(const span& other) noexcept = default;
+
+    template <class OtherElementType, std::size_t OtherExtent, std::size_t MyExtent = Extent,
+              std::enable_if_t<(MyExtent == dynamic_extent || MyExtent == OtherExtent) &&
+                                   details::is_allowed_element_type_conversion<OtherElementType,
+                                                                               element_type>::value,
+                               int> = 0>
+    constexpr span(const span<OtherElementType, OtherExtent>& other) noexcept
+        : storage_(other.data(), details::extent_type<OtherExtent>(other.size()))
+    {}
+
+    template <class OtherElementType, std::size_t OtherExtent, std::size_t MyExtent = Extent,
+              std::enable_if_t<MyExtent != dynamic_extent && OtherExtent == dynamic_extent &&
+                                   details::is_allowed_element_type_conversion<OtherElementType,
+                                                                               element_type>::value,
+                               int> = 0>
+    constexpr explicit span(const span<OtherElementType, OtherExtent>& other) noexcept
+        : storage_(other.data(), details::extent_type<OtherExtent>(other.size()))
+    {}
+
+    ~span() noexcept = default;
+    constexpr span& operator=(const span& other) noexcept = default;
+
+    // [span.sub], span subviews
+    template <std::size_t Count>
+    constexpr span<element_type, Count> first() const noexcept
+    {
+        Expects(Count <= size());
+        return span<element_type, Count>{data(), Count};
+    }
+
+    template <std::size_t Count>
+    // clang-format off
+    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
+        constexpr span<element_type, Count> last() const noexcept
+    {
+        Expects(Count <= size());
+        return span<element_type, Count>{data() + (size() - Count), Count};
+    }
+
+    template <std::size_t Offset, std::size_t Count = dynamic_extent>
+    // clang-format off
+    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
+        constexpr auto subspan() const noexcept ->
+        typename details::calculate_subspan_type<ElementType, Extent, Offset, Count>::type
+    {
+        Expects((size() >= Offset) && (Count == dynamic_extent || (Count <= size() - Offset)));
+        using type =
+            typename details::calculate_subspan_type<ElementType, Extent, Offset, Count>::type;
+        return type{data() + Offset, Count == dynamic_extent ? size() - Offset : Count};
+    }
+
+    constexpr span<element_type, dynamic_extent> first(size_type count) const noexcept
+    {
+        Expects(count <= size());
+        return {data(), count};
+    }
+
+    constexpr span<element_type, dynamic_extent> last(size_type count) const noexcept
+    {
+        Expects(count <= size());
+        return make_subspan(size() - count, dynamic_extent, subspan_selector<Extent>{});
+    }
+
+    constexpr span<element_type, dynamic_extent>
+    subspan(size_type offset, size_type count = dynamic_extent) const noexcept
+    {
+        return make_subspan(offset, count, subspan_selector<Extent>{});
+    }
+
+    // [span.obs], span observers
+    constexpr size_type size() const noexcept { return storage_.size(); }
+
+    constexpr size_type size_bytes() const noexcept { return size() * sizeof(element_type); }
+
+    constexpr bool empty() const noexcept { return size() == 0; }
+
+    // [span.elem], span element access
+    // clang-format off
+    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+    // clang-format on
+    constexpr reference operator[](size_type idx) const noexcept
+    {
+        Expects(idx < size());
+        return data()[idx];
+    }
+
+    constexpr reference front() const noexcept
+    {
+        Expects(size() > 0);
+        return data()[0];
+    }
+
+    constexpr reference back() const noexcept
+    {
+        Expects(size() > 0);
+        return data()[size() - 1];
+    }
+
+    constexpr pointer data() const noexcept { return storage_.data(); }
+
+    // [span.iter], span iterator support
+    constexpr iterator begin() const noexcept
+    {
+        const auto data = storage_.data();
+        // clang-format off
+        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
+        return {data, data + size(), data};
+    }
+
+    constexpr iterator end() const noexcept
+    {
+        const auto data = storage_.data();
+        // clang-format off
+        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
+        const auto endData = data + storage_.size();
+        return {data, endData, endData};
+    }
+
+    constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator{end()}; }
+    constexpr reverse_iterator rend() const noexcept { return reverse_iterator{begin()}; }
+
+#ifdef _MSC_VER
+    // Tell MSVC how to unwrap spans in range-based-for
+    constexpr pointer _Unchecked_begin() const noexcept { return data(); }
+    constexpr pointer _Unchecked_end() const noexcept
+    {
+        // clang-format off
+        GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+        // clang-format on
+        return data() + size();
+    }
+#endif // _MSC_VER
+
+private:
+    // Needed to remove unnecessary null check in subspans
+    struct KnownNotNull
+    {
+        pointer p;
+    };
+
+    // this implementation detail class lets us take advantage of the
+    // empty base class optimization to pay for only storage of a single
+    // pointer in the case of fixed-size spans
+    template <class ExtentType>
+    class storage_type : public ExtentType
+    {
+    public:
+        // KnownNotNull parameter is needed to remove unnecessary null check
+        // in subspans and constructors from arrays
+        template <class OtherExtentType>
+        constexpr storage_type(KnownNotNull data, OtherExtentType ext)
+            : ExtentType(ext), data_(data.p)
+        {}
+
+        template <class OtherExtentType>
+        constexpr storage_type(pointer data, OtherExtentType ext) : ExtentType(ext), data_(data)
+        {
+            Expects(data || ExtentType::size() == 0);
+        }
+
+        constexpr pointer data() const noexcept { return data_; }
+
+    private:
+        pointer data_;
+    };
+
+    storage_type<details::extent_type<Extent>> storage_;
+
+    // The rest is needed to remove unnecessary null check
+    // in subspans and constructors from arrays
+    constexpr span(KnownNotNull ptr, size_type count) noexcept : storage_(ptr, count) {}
+
+    template <std::size_t CallerExtent>
+    class subspan_selector
+    {
+    };
+
+    template <std::size_t CallerExtent>
+    constexpr span<element_type, dynamic_extent>
+    make_subspan(size_type offset, size_type count, subspan_selector<CallerExtent>) const noexcept
+    {
+        const span<element_type, dynamic_extent> tmp(*this);
+        return tmp.subspan(offset, count);
+    }
+
+    // clang-format off
+    GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+    // clang-format on
+    constexpr span<element_type, dynamic_extent>
+    make_subspan(size_type offset, size_type count, subspan_selector<dynamic_extent>) const noexcept
+    {
+        Expects(size() >= offset);
+
+        if (count == dynamic_extent) { return {KnownNotNull{data() + offset}, size() - offset}; }
+
+        Expects(size() - offset >= count);
+        return {KnownNotNull{data() + offset}, count};
+    }
+};
+
+#if (defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L))
+
+// Deduction Guides
+template <class Type, std::size_t Extent>
+span(Type (&)[Extent]) -> span<Type, Extent>;
+
+template <class Type, std::size_t Size>
+span(std::array<Type, Size>&) -> span<Type, Size>;
+
+template <class Type, std::size_t Size>
+span(const std::array<Type, Size>&) -> span<const Type, Size>;
+
+template <class Container,
+          class Element = std::remove_pointer_t<decltype(std::declval<Container&>().data())>>
+span(Container&) -> span<Element>;
+
+template <class Container,
+          class Element = std::remove_pointer_t<decltype(std::declval<const Container&>().data())>>
+span(const Container&) -> span<Element>;
+
+#endif // ( defined(__cpp_deduction_guides) && (__cpp_deduction_guides >= 201611L) )
+
+#if defined(GSL_USE_STATIC_CONSTEXPR_WORKAROUND)
+template <class ElementType, std::size_t Extent>
+constexpr const typename span<ElementType, Extent>::size_type span<ElementType, Extent>::extent;
+#endif
+
+namespace details
+{
+    // if we only supported compilers with good constexpr support then
+    // this pair of classes could collapse down to a constexpr function
+
+    // we should use a narrow_cast<> to go to std::size_t, but older compilers may not see it as
+    // constexpr
+    // and so will fail compilation of the template
+    template <class ElementType, std::size_t Extent>
+    struct calculate_byte_size : std::integral_constant<std::size_t, sizeof(ElementType) * Extent>
+    {
+        static_assert(Extent < dynamic_extent / sizeof(ElementType), "Size is too big.");
+    };
+
+    template <class ElementType>
+    struct calculate_byte_size<ElementType, dynamic_extent>
+        : std::integral_constant<std::size_t, dynamic_extent>
+    {
+    };
+} // namespace details
+
+// [span.objectrep], views of object representation
+template <class ElementType, std::size_t Extent>
+span<const byte, details::calculate_byte_size<ElementType, Extent>::value>
+as_bytes(span<ElementType, Extent> s) noexcept
+{
+    using type = span<const byte, details::calculate_byte_size<ElementType, Extent>::value>;
+
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return type{reinterpret_cast<const byte*>(s.data()), s.size_bytes()};
+}
+
+template <class ElementType, std::size_t Extent,
+          std::enable_if_t<!std::is_const<ElementType>::value, int> = 0>
+span<byte, details::calculate_byte_size<ElementType, Extent>::value>
+as_writable_bytes(span<ElementType, Extent> s) noexcept
+{
+    using type = span<byte, details::calculate_byte_size<ElementType, Extent>::value>;
+
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return type{reinterpret_cast<byte*>(s.data()), s.size_bytes()};
+}
+
+} // namespace gsl
+
+#if defined(_MSC_VER) && !defined(__clang__)
+
+#pragma warning(pop)
+#endif // _MSC_VER
+
+#if defined(__GNUC__) && __GNUC__ > 6
+#pragma GCC diagnostic pop
+#endif // __GNUC__ > 6
+
+#endif // GSL_SPAN_H

deps/GSL/include/gsl/span_ext

@@ -0,0 +1,212 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_SPAN_EXT_H
+#define GSL_SPAN_EXT_H
+
+///////////////////////////////////////////////////////////////////////////////
+//
+// File: span_ext
+// Purpose: continue offering features that have been cut from the official
+//   implementation of span.
+//   While modernizing gsl::span a number of features needed to be removed to
+//   be compliant with the design of std::span
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "assert" // GSL_KERNEL_MODE
+#include "util"   // for narrow_cast, narrow
+
+#include <cstddef> // for ptrdiff_t, size_t
+#include <utility>
+
+#ifndef GSL_KERNEL_MODE
+#include <algorithm> // for lexicographical_compare
+#endif               // GSL_KERNEL_MODE
+
+namespace gsl
+{
+
+// [span.views.constants], constants
+GSL_INLINE constexpr const std::size_t dynamic_extent = narrow_cast<std::size_t>(-1);
+
+template <class ElementType, std::size_t Extent = dynamic_extent>
+class span;
+
+// std::equal and std::lexicographical_compare are not /kernel compatible
+// so all comparison operators must be removed for kernel mode.
+#ifndef GSL_KERNEL_MODE
+
+// [span.comparison], span comparison operators
+template <class ElementType, std::size_t FirstExtent, std::size_t SecondExtent>
+constexpr bool operator==(span<ElementType, FirstExtent> l, span<ElementType, SecondExtent> r)
+{
+    return std::equal(l.begin(), l.end(), r.begin(), r.end());
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr bool operator!=(span<ElementType, Extent> l, span<ElementType, Extent> r)
+{
+    return !(l == r);
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr bool operator<(span<ElementType, Extent> l, span<ElementType, Extent> r)
+{
+    return std::lexicographical_compare(l.begin(), l.end(), r.begin(), r.end());
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr bool operator<=(span<ElementType, Extent> l, span<ElementType, Extent> r)
+{
+    return !(l > r);
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr bool operator>(span<ElementType, Extent> l, span<ElementType, Extent> r)
+{
+    return r < l;
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr bool operator>=(span<ElementType, Extent> l, span<ElementType, Extent> r)
+{
+    return !(l < r);
+}
+
+#endif // GSL_KERNEL_MODE
+
+//
+// make_span() - Utility functions for creating spans
+//
+template <class ElementType>
+constexpr span<ElementType> make_span(ElementType* ptr, typename span<ElementType>::size_type count)
+{
+    return span<ElementType>(ptr, count);
+}
+
+template <class ElementType>
+constexpr span<ElementType> make_span(ElementType* firstElem, ElementType* lastElem)
+{
+    return span<ElementType>(firstElem, lastElem);
+}
+
+template <class ElementType, std::size_t N>
+constexpr span<ElementType, N> make_span(ElementType (&arr)[N]) noexcept
+{
+    return span<ElementType, N>(arr);
+}
+
+template <class Container>
+constexpr span<typename Container::value_type> make_span(Container& cont)
+{
+    return span<typename Container::value_type>(cont);
+}
+
+template <class Container>
+constexpr span<const typename Container::value_type> make_span(const Container& cont)
+{
+    return span<const typename Container::value_type>(cont);
+}
+
+template <class Ptr>
+constexpr span<typename Ptr::element_type> make_span(Ptr& cont, std::size_t count)
+{
+    return span<typename Ptr::element_type>(cont, count);
+}
+
+template <class Ptr>
+constexpr span<typename Ptr::element_type> make_span(Ptr& cont)
+{
+    return span<typename Ptr::element_type>(cont);
+}
+
+// Specialization of gsl::at for span
+template <class ElementType, std::size_t Extent>
+constexpr ElementType& at(span<ElementType, Extent> s, index i)
+{
+    // No bounds checking here because it is done in span::operator[] called below
+    Ensures(i >= 0);
+    return s[narrow_cast<std::size_t>(i)];
+}
+
+// [span.obs] Free observer functions
+template <class ElementType, std::size_t Extent>
+constexpr std::ptrdiff_t ssize(const span<ElementType, Extent>& s) noexcept
+{
+    return static_cast<std::ptrdiff_t>(s.size());
+}
+
+// [span.iter] Free functions for begin/end functions
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::iterator
+begin(const span<ElementType, Extent>& s) noexcept
+{
+    return s.begin();
+}
+
+template <class ElementType, std::size_t Extent = dynamic_extent>
+constexpr typename span<ElementType, Extent>::iterator
+end(const span<ElementType, Extent>& s) noexcept
+{
+    return s.end();
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+rbegin(const span<ElementType, Extent>& s) noexcept
+{
+    return s.rbegin();
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+rend(const span<ElementType, Extent>& s) noexcept
+{
+    return s.rend();
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::iterator
+cbegin(const span<ElementType, Extent>& s) noexcept
+{
+    return s.begin();
+}
+
+template <class ElementType, std::size_t Extent = dynamic_extent>
+constexpr typename span<ElementType, Extent>::iterator
+cend(const span<ElementType, Extent>& s) noexcept
+{
+    return s.end();
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+crbegin(const span<ElementType, Extent>& s) noexcept
+{
+    return s.rbegin();
+}
+
+template <class ElementType, std::size_t Extent>
+constexpr typename span<ElementType, Extent>::reverse_iterator
+crend(const span<ElementType, Extent>& s) noexcept
+{
+    return s.rend();
+}
+
+} // namespace gsl
+
+#endif // GSL_SPAN_EXT_H

deps/GSL/include/gsl/string_span

@@ -0,0 +1,58 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_STRING_SPAN_H
+#define GSL_STRING_SPAN_H
+
+#include "span_ext" // for dynamic_extent
+
+#include <cstddef>   // for size_t, nullptr_t
+
+namespace gsl
+{
+//
+// czstring and wzstring
+//
+// These are "tag" typedefs for C-style strings (i.e. null-terminated character arrays)
+// that allow static analysis to help find bugs.
+//
+// There are no additional features/semantics that we can find a way to add inside the
+// type system for these types that will not either incur significant runtime costs or
+// (sometimes needlessly) break existing programs when introduced.
+//
+
+template <typename CharT, std::size_t Extent = dynamic_extent>
+using basic_zstring = CharT*;
+
+using czstring = basic_zstring<const char, dynamic_extent>;
+
+using cwzstring = basic_zstring<const wchar_t, dynamic_extent>;
+
+using cu16zstring = basic_zstring<const char16_t, dynamic_extent>;
+
+using cu32zstring = basic_zstring<const char32_t, dynamic_extent>;
+
+using zstring = basic_zstring<char, dynamic_extent>;
+
+using wzstring = basic_zstring<wchar_t, dynamic_extent>;
+
+using u16zstring = basic_zstring<char16_t, dynamic_extent>;
+
+using u32zstring = basic_zstring<char32_t, dynamic_extent>;
+
+} // namespace gsl
+
+#endif // GSL_STRING_SPAN_H

deps/GSL/include/gsl/util

@@ -0,0 +1,157 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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 GSL_UTIL_H
+#define GSL_UTIL_H
+
+#include "assert" // for Expects
+
+#include <array>
+#include <cstddef>          // for ptrdiff_t, size_t
+#include <limits>           // for numeric_limits
+#include <initializer_list> // for initializer_list
+#include <type_traits>      // for is_signed, integral_constant
+#include <utility>          // for exchange, forward
+
+#if defined(__has_include) && __has_include(<version>)
+#include <version>
+#if defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
+#include <span>
+#endif // __cpp_lib_span >= 202002L
+#endif //__has_include(<version>)
+
+#if defined(_MSC_VER) && !defined(__clang__)
+
+#pragma warning(push)
+#pragma warning(disable : 4127) // conditional expression is constant
+
+#endif // _MSC_VER
+
+#if defined(__cplusplus) && (__cplusplus >= 201703L)
+#define GSL_NODISCARD [[nodiscard]]
+#else
+#define GSL_NODISCARD
+#endif // defined(__cplusplus) && (__cplusplus >= 201703L)
+
+#if defined(__cpp_inline_variables)
+#define GSL_INLINE inline
+#else
+#define GSL_INLINE
+#endif
+
+namespace gsl
+{
+//
+// GSL.util: utilities
+//
+
+// index type for all container indexes/subscripts/sizes
+using index = std::ptrdiff_t;
+
+// final_action allows you to ensure something gets run at the end of a scope
+template <class F>
+class final_action
+{
+public:
+    explicit final_action(const F& ff) noexcept : f{ff} { }
+    explicit final_action(F&& ff) noexcept : f{std::move(ff)} { }
+
+    ~final_action() noexcept { if (invoke) f(); }
+
+    final_action(final_action&& other) noexcept
+        : f(std::move(other.f)), invoke(std::exchange(other.invoke, false))
+    { }
+
+    final_action(const final_action&)   = delete;
+    void operator=(const final_action&) = delete;
+    void operator=(final_action&&)      = delete;
+
+private:
+    F f;
+    bool invoke = true;
+};
+
+// finally() - convenience function to generate a final_action
+template <class F>
+GSL_NODISCARD auto finally(F&& f) noexcept
+{
+    return final_action<std::decay_t<F>>{std::forward<F>(f)};
+}
+
+// narrow_cast(): a searchable way to do narrowing casts of values
+template <class T, class U>
+// clang-format off
+GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    constexpr T narrow_cast(U&& u) noexcept
+{
+    return static_cast<T>(std::forward<U>(u));
+}
+
+//
+// at() - Bounds-checked way of accessing builtin arrays, std::array, std::vector
+//
+template <class T, std::size_t N>
+// clang-format off
+GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
+GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
+    // clang-format on
+    constexpr T& at(T (&arr)[N], const index i)
+{
+    static_assert(N <= static_cast<std::size_t>((std::numeric_limits<std::ptrdiff_t>::max)()), "We only support arrays up to PTRDIFF_MAX bytes.");
+    Expects(i >= 0 && i < narrow_cast<index>(N));
+    return arr[narrow_cast<std::size_t>(i)];
+}
+
+template <class Cont>
+// clang-format off
+GSL_SUPPRESS(bounds.4) // NO-FORMAT: attribute
+GSL_SUPPRESS(bounds.2) // NO-FORMAT: attribute
+    // clang-format on
+    constexpr auto at(Cont& cont, const index i) -> decltype(cont[cont.size()])
+{
+    Expects(i >= 0 && i < narrow_cast<index>(cont.size()));
+    using size_type = decltype(cont.size());
+    return cont[narrow_cast<size_type>(i)];
+}
+
+template <class T>
+// clang-format off
+GSL_SUPPRESS(bounds.1) // NO-FORMAT: attribute
+    // clang-format on
+    constexpr T at(const std::initializer_list<T> cont, const index i)
+{
+    Expects(i >= 0 && i < narrow_cast<index>(cont.size()));
+    return *(cont.begin() + i);
+}
+
+#if defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
+template <class T, std::size_t extent = std::dynamic_extent>
+constexpr auto at(std::span<T, extent> sp, const index i) -> decltype(sp[sp.size()])
+{
+    Expects(i >= 0 && i < narrow_cast<index>(sp.size()));
+    return sp[gsl::narrow_cast<std::size_t>(i)];
+}
+#endif // __cpp_lib_span >= 202002L
+} // namespace gsl
+
+#if defined(_MSC_VER) && !defined(__clang__)
+
+#pragma warning(pop)
+
+#endif // _MSC_VER
+
+#endif // GSL_UTIL_H

deps/GSL/pipelines/jobs.yml

@@ -0,0 +1,43 @@
+parameters:
+  CXXVersions: [ 14, 17, 20 ]
+  buildTypes: [ 'Debug', 'Release' ]
+  image: ''
+
+  compiler: ''
+  compilerVersions: ["default"] # if default value, simply uses whatever version is on the machine.
+                                # the text of this default value doesn't actually matter.
+  setupfile: ''
+  extraCmakeArgs: ''
+
+jobs:
+- ${{ each compilerVersion in parameters.compilerVersions }}:
+  - ${{ each CXXVersion in parameters.CXXVersions }}:
+    - ${{ each buildType in parameters.buildTypes }}:
+      - job:
+        displayName: ${{ format('{0} {1} C++{2} {3}', parameters.compiler, compilerVersion, CXXVersion, buildType) }}
+        pool:
+            vmImage: ${{ parameters.image }}
+        continueOnError: false
+
+        steps:
+          - ${{ if not(eq(parameters.setupfile, '')) }}:
+            - template: ${{ parameters.setupfile }}
+              parameters:
+                version: ${{ compilerVersion }}
+
+          - task: CMake@1
+            name: Configure
+            inputs:
+              workingDirectory: build
+              cmakeArgs: '-DGSL_CXX_STANDARD=${{ CXXVersion }} -DCMAKE_BUILD_TYPE=${{ buildType }} -DCI_TESTING:BOOL=ON -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON -Werror=dev ${{ parameters.extraCmakeArgs }} .. '
+
+          - task: CMake@1
+            name: Build
+            inputs:
+              workingDirectory: build
+              cmakeArgs: '--build . '
+
+          - script: ctest . --output-on-failure --no-compress-output
+            name: CTest
+            workingDirectory: build
+            failOnStderr: true

deps/GSL/pipelines/setup_apple.yml

@@ -0,0 +1,9 @@
+parameters:
+    version: 0
+
+steps:
+  - script: |
+      if [ "${{ parameters.version }}" != "default" ]; then sudo xcode-select -switch /Applications/Xcode_${{ parameters.version }}.app; fi
+
+    displayName: "Setup Xcode Version"
+    failOnStderr: true

deps/GSL/pipelines/setup_clang.yml

@@ -0,0 +1,13 @@
+parameters:
+    version: 0
+
+steps:
+  - script: |
+      echo "##vso[task.setvariable variable=CXX;]${CXX}"
+      echo "##vso[task.setvariable variable=CC;]${CC}"
+
+    displayName: "Setup Clang Version"
+    failOnStderr: true
+    env:
+      CC: clang-${{ parameters.version }}
+      CXX: clang++-${{ parameters.version }}

deps/GSL/pipelines/setup_gcc.yml

@@ -0,0 +1,14 @@
+parameters:
+    version: 0
+
+steps:
+  - script: |
+      echo "##vso[task.setvariable variable=CXX;]${CXX}"
+      echo "##vso[task.setvariable variable=CC;]${CC}"
+      if [ "${{ parameters.version }}" = "11" ]; then sudo apt-get install $CXX; fi
+
+    displayName: "Setup GCC Version"
+    failOnStderr: true
+    env:
+      CC: gcc-${{ parameters.version }}
+      CXX: g++-${{ parameters.version }}

deps/GSL/tests/CMakeLists.txt

@@ -0,0 +1,306 @@
+cmake_minimum_required(VERSION 3.14...3.16)
+
+project(GSLTests LANGUAGES CXX)
+
+set(GSL_CXX_STANDARD "14" CACHE STRING "Use c++ standard")
+
+set(CMAKE_CXX_STANDARD ${GSL_CXX_STANDARD})
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+include(FindPkgConfig)
+include(ExternalProject)
+
+# will make visual studio generated project group files
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
+if(CI_TESTING AND GSL_CXX_STANDARD EQUAL 20)
+    add_compile_definitions(FORCE_STD_SPAN_TESTS=1)
+endif()
+
+if(IOS)
+    add_compile_definitions(GTEST_HAS_DEATH_TEST=1 IOS_PROCESS_DELAY_WORKAROUND=1)
+endif()
+
+pkg_search_module(GTestMain gtest_main)
+if (NOT GTestMain_FOUND)
+    # No pre-installed GTest is available, try to download it using Git.
+    find_package(Git REQUIRED QUIET)
+
+    configure_file(CMakeLists.txt.in googletest-download/CMakeLists.txt)
+    execute_process(
+        COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
+        RESULT_VARIABLE result
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download
+    )
+    if(result)
+        message(FATAL_ERROR "CMake step for googletest failed: ${result}")
+    endif()
+
+    execute_process(
+        COMMAND ${CMAKE_COMMAND} --build .
+        RESULT_VARIABLE result
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download
+    )
+    if(result)
+        message(FATAL_ERROR "CMake step for googletest failed: ${result}")
+    endif()
+
+    set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+    set(GTestMain_LIBRARIES gtest_main)
+
+    add_subdirectory(
+        ${CMAKE_CURRENT_BINARY_DIR}/googletest-src
+        ${CMAKE_CURRENT_BINARY_DIR}/googletest-build
+        EXCLUDE_FROM_ALL
+    )
+endif()
+
+if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+    find_package(Microsoft.GSL CONFIG REQUIRED)
+    enable_testing()
+
+    if (NOT DEFINED Microsoft.GSL_VERSION)
+        message(FATAL_ERROR "Microsoft.GSL_VERSION not defined!")
+    endif()
+
+    message(STATUS "Microsoft.GSL_VERSION = ${Microsoft.GSL_VERSION}")
+endif()
+
+if (MSVC AND (GSL_CXX_STANDARD GREATER_EQUAL 17))
+    set(GSL_CPLUSPLUS_OPT -Zc:__cplusplus -permissive-)
+endif()
+
+include(CheckCXXCompilerFlag)
+# this interface adds compile options to how the tests are run
+# please try to keep entries ordered =)
+add_library(gsl_tests_config INTERFACE)
+if(MSVC) # MSVC or simulating MSVC
+    target_compile_options(gsl_tests_config INTERFACE
+        ${GSL_CPLUSPLUS_OPT}
+        /EHsc
+        /W4
+        /WX
+        $<$<CXX_COMPILER_ID:MSVC>:
+          /wd4996  # Use of function or classes marked [[deprecated]]
+          /wd26409 # CppCoreCheck - GTest
+          /wd26426 # CppCoreCheck - GTest
+          /wd26440 # CppCoreCheck - GTest
+          /wd26446 # CppCoreCheck - prefer gsl::at()
+          /wd26472 # CppCoreCheck - use gsl::narrow(_cast)
+          /wd26481 # CppCoreCheck - use span instead of pointer arithmetic
+          $<$<VERSION_LESS:$<CXX_COMPILER_VERSION>,1920>: # VS2015
+            /wd4189 # variable is initialized but not referenced
+            $<$<NOT:$<CONFIG:Debug>>: # Release, RelWithDebInfo
+              /wd4702 # Unreachable code
+            >
+          >
+        >
+        $<$<CXX_COMPILER_ID:Clang>:
+          -Weverything
+          -Wfloat-equal
+          -Wno-c++98-compat
+          -Wno-c++98-compat-pedantic
+          -Wno-covered-switch-default # GTest
+          -Wno-deprecated-declarations # Allow tests for [[deprecated]] elements
+          -Wno-global-constructors # GTest
+          -Wno-language-extension-token # GTest gtest-port.h
+          -Wno-missing-braces
+          -Wno-missing-prototypes
+          -Wno-shift-sign-overflow # GTest gtest-port.h
+          -Wno-undef # GTest
+          -Wno-used-but-marked-unused # GTest EXPECT_DEATH
+          $<$<EQUAL:${GSL_CXX_STANDARD},14>: # no support for [[maybe_unused]]
+            -Wno-unused-member-function
+            -Wno-unused-variable
+            $<$<VERSION_EQUAL:$<CXX_COMPILER_VERSION>,15.0.1>:
+              -Wno-deprecated # False positive in MSVC Clang 15.0.1 raises a C++17 warning
+            >
+          >
+        >
+    )
+    check_cxx_compiler_flag("-Wno-reserved-identifier" WARN_RESERVED_ID)
+    if (WARN_RESERVED_ID)
+        target_compile_options(gsl_tests_config INTERFACE "-Wno-reserved-identifier")
+    endif()
+else()
+    target_compile_options(gsl_tests_config INTERFACE
+        -fno-strict-aliasing
+        -Wall
+        -Wcast-align
+        -Wconversion
+        -Wctor-dtor-privacy
+        -Werror
+        -Wextra
+        -Wpedantic
+        -Wshadow
+        -Wsign-conversion
+        -Wfloat-equal
+        -Wno-deprecated-declarations # Allow tests for [[deprecated]] elements
+        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:
+          -Weverything
+          -Wno-c++98-compat
+          -Wno-c++98-compat-pedantic
+          -Wno-missing-braces
+          -Wno-covered-switch-default # GTest
+          -Wno-global-constructors # GTest
+          -Wno-missing-prototypes
+          -Wno-padded
+          -Wno-unknown-attributes
+          -Wno-used-but-marked-unused # GTest EXPECT_DEATH
+          -Wno-weak-vtables
+          $<$<EQUAL:${GSL_CXX_STANDARD},14>: # no support for [[maybe_unused]]
+            -Wno-unused-member-function
+            -Wno-unused-variable
+          >
+        >
+        $<$<CXX_COMPILER_ID:Clang>:
+          $<$<AND:$<VERSION_GREATER:$<CXX_COMPILER_VERSION>,4.99>,$<VERSION_LESS:$<CXX_COMPILER_VERSION>,6>>:
+            $<$<EQUAL:${GSL_CXX_STANDARD},17>:-Wno-undefined-func-template>
+          >
+          $<$<AND:$<EQUAL:${GSL_CXX_STANDARD},20>,$<OR:$<CXX_COMPILER_VERSION:11.0.0>,$<CXX_COMPILER_VERSION:10.0.0>>>:
+              -Wno-zero-as-null-pointer-constant  # failing Clang Ubuntu 20.04 tests, seems to be a bug with clang 10.0.0
+                                                  # and clang 11.0.0. (operator< is being re-written by the compiler
+                                                  # as operator<=> and raising the warning)
+          >
+        >
+        $<$<CXX_COMPILER_ID:AppleClang>:
+          $<$<AND:$<VERSION_GREATER:$<CXX_COMPILER_VERSION>,9.1>,$<VERSION_LESS:$<CXX_COMPILER_VERSION>,10>>:
+            $<$<EQUAL:${GSL_CXX_STANDARD},17>:-Wno-undefined-func-template>
+          >
+        >
+        $<$<CXX_COMPILER_ID:GNU>:
+          -Wdouble-promotion # float implicit to double
+          -Wlogical-op # suspicious uses of logical operators
+          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,6>>:
+            -Wduplicated-cond # duplicated if-else conditions
+            -Wmisleading-indentation
+            -Wnull-dereference
+            $<$<EQUAL:${GSL_CXX_STANDARD},14>: # no support for [[maybe_unused]]
+              -Wno-unused-variable
+            >
+          >
+          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,7>>:
+            -Wduplicated-branches # identical if-else branches
+          >
+        >
+    )
+endif(MSVC)
+
+# for tests to find the gtest header
+target_include_directories(gsl_tests_config SYSTEM INTERFACE
+    googletest/googletest/include
+)
+
+add_executable(gsl_tests
+    algorithm_tests.cpp
+    assertion_tests.cpp
+    at_tests.cpp
+    byte_tests.cpp
+    notnull_tests.cpp
+    owner_tests.cpp
+    span_compatibility_tests.cpp
+    span_ext_tests.cpp
+    span_tests.cpp
+    strict_notnull_tests.cpp
+    
+    utils_tests.cpp
+)
+
+target_link_libraries(gsl_tests
+    Microsoft.GSL::GSL
+    gsl_tests_config
+    ${GTestMain_LIBRARIES}
+)
+add_test(gsl_tests gsl_tests)
+
+# No exception tests
+
+foreach(flag_var
+        CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE
+        CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO)
+    STRING (REGEX REPLACE "/EHsc" "" ${flag_var} "${${flag_var}}")
+endforeach(flag_var)
+
+# this interface adds compile options to how the tests are run
+# please try to keep entries ordered =)
+add_library(gsl_tests_config_noexcept INTERFACE)
+if(MSVC) # MSVC or simulating MSVC
+    target_compile_definitions(gsl_tests_config_noexcept INTERFACE
+        _HAS_EXCEPTIONS=0 # disable exceptions in the Microsoft STL
+    )
+    target_compile_options(gsl_tests_config_noexcept INTERFACE
+        ${GSL_CPLUSPLUS_OPT}
+        /W4
+        /WX
+        $<$<CXX_COMPILER_ID:MSVC>:
+          /wd4577
+          /wd4702
+          /wd26440 # CppCoreCheck - GTest
+          /wd26446 # CppCoreCheck - prefer gsl::at()
+        >
+        $<$<CXX_COMPILER_ID:Clang>:
+          -Weverything
+          -Wfloat-equal
+          -Wno-c++98-compat
+          -Wno-c++98-compat-pedantic
+          -Wno-missing-prototypes
+          -Wno-unknown-attributes
+          $<$<EQUAL:${GSL_CXX_STANDARD},14>:
+            $<$<VERSION_EQUAL:$<CXX_COMPILER_VERSION>,15.0.1>: 
+              -Wno-deprecated # False positive in MSVC Clang 15.0.1 raises a C++17 warning
+            >
+          >
+        >
+    )
+    check_cxx_compiler_flag("-Wno-reserved-identifier" WARN_RESERVED_ID)
+    if (WARN_RESERVED_ID)
+        target_compile_options(gsl_tests_config_noexcept INTERFACE "-Wno-reserved-identifier")
+    endif()
+else()
+    target_compile_options(gsl_tests_config_noexcept INTERFACE
+        -fno-exceptions
+        -fno-strict-aliasing
+        -Wall
+        -Wcast-align
+        -Wconversion
+        -Wctor-dtor-privacy
+        -Werror
+        -Wextra
+        -Wpedantic
+        -Wshadow
+        -Wsign-conversion
+        -Wfloat-equal
+        $<$<OR:$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:AppleClang>>:
+          -Weverything
+          -Wno-c++98-compat
+          -Wno-c++98-compat-pedantic
+          -Wno-missing-prototypes
+          -Wno-unknown-attributes
+          -Wno-weak-vtables
+        >
+        $<$<CXX_COMPILER_ID:GNU>:
+          -Wdouble-promotion # float implicit to double
+          -Wlogical-op # suspicious uses of logical operators
+          -Wuseless-cast # casting to its own type
+          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,6>>:
+            -Wduplicated-cond # duplicated if-else conditions
+            -Wmisleading-indentation
+            -Wnull-dereference
+          >
+          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,7>>:
+            -Wduplicated-branches # identical if-else branches
+          >
+          $<$<NOT:$<VERSION_LESS:$<CXX_COMPILER_VERSION>,8>>:
+            -Wcast-align=strict # increase alignment (i.e. char* to int*)
+          >
+        >
+    )
+endif(MSVC)
+
+add_executable(gsl_noexcept_tests no_exception_ensure_tests.cpp)
+target_link_libraries(gsl_noexcept_tests
+    Microsoft.GSL::GSL
+    gsl_tests_config_noexcept
+)
+add_test(gsl_noexcept_tests gsl_noexcept_tests)

deps/GSL/tests/CMakeLists.txt.in

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.0.2)
+project(googletest-download NONE)
+
+include(ExternalProject)
+ExternalProject_Add(googletest
+  GIT_REPOSITORY    https://github.com/google/googletest.git
+  GIT_TAG           1b18723e874b256c1e39378c6774a90701d70f7a
+  SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
+  BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
+  CONFIGURE_COMMAND ""
+  BUILD_COMMAND     ""
+  INSTALL_COMMAND   ""
+  TEST_COMMAND      ""
+)

deps/GSL/tests/algorithm_tests.cpp

@@ -0,0 +1,224 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <array>         // for array
+#include <cstddef>       // for size_t
+#include <gsl/algorithm> // for copy
+#include <gsl/span>      // for span
+#include <gtest/gtest.h>
+
+#include "deathTestCommon.h"
+
+namespace gsl
+{
+struct fail_fast;
+} // namespace gsl
+
+using namespace gsl;
+
+TEST(algorithm_tests, same_type)
+{
+    // dynamic source and destination span
+    {
+        std::array<int, 5> src{1, 2, 3, 4, 5};
+        std::array<int, 10> dst{};
+
+        const span<int> src_span(src);
+        const span<int> dst_span(dst);
+
+        copy(src_span, dst_span);
+        copy(src_span, dst_span.subspan(src_span.size()));
+
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
+        }
+    }
+
+    // static source and dynamic destination span
+    {
+        std::array<int, 5> src{1, 2, 3, 4, 5};
+        std::array<int, 10> dst{};
+
+        const span<int, 5> src_span(src);
+        const span<int> dst_span(dst);
+
+        copy(src_span, dst_span);
+        copy(src_span, dst_span.subspan(src_span.size()));
+
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
+        }
+    }
+
+    // dynamic source and static destination span
+    {
+        std::array<int, 5> src{1, 2, 3, 4, 5};
+        std::array<int, 10> dst{};
+
+        const gsl::span<int> src_span(src);
+        const gsl::span<int, 10> dst_span(dst);
+
+        copy(src_span, dst_span);
+        copy(src_span, dst_span.subspan(src_span.size()));
+
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
+        }
+    }
+
+    // static source and destination span
+    {
+        std::array<int, 5> src{1, 2, 3, 4, 5};
+        std::array<int, 10> dst{};
+
+        const span<int, 5> src_span(src);
+        const span<int, 10> dst_span(dst);
+
+        copy(src_span, dst_span);
+        copy(src_span, dst_span.subspan(src_span.size()));
+
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
+        }
+    }
+}
+
+TEST(algorithm_tests, compatible_type)
+{
+    // dynamic source and destination span
+    {
+        std::array<short, 5> src{1, 2, 3, 4, 5};
+        std::array<int, 10> dst{};
+
+        const span<short> src_span(src);
+        const span<int> dst_span(dst);
+
+        copy(src_span, dst_span);
+        copy(src_span, dst_span.subspan(src_span.size()));
+
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
+        }
+    }
+
+    // static source and dynamic destination span
+    {
+        std::array<short, 5> src{1, 2, 3, 4, 5};
+        std::array<int, 10> dst{};
+
+        const span<short, 5> src_span(src);
+        const span<int> dst_span(dst);
+
+        copy(src_span, dst_span);
+        copy(src_span, dst_span.subspan(src_span.size()));
+
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
+        }
+    }
+
+    // dynamic source and static destination span
+    {
+        std::array<short, 5> src{1, 2, 3, 4, 5};
+        std::array<int, 10> dst{};
+
+        const span<short> src_span(src);
+        const span<int, 10> dst_span(dst);
+
+        copy(src_span, dst_span);
+        copy(src_span, dst_span.subspan(src_span.size()));
+
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
+        }
+    }
+
+    // static source and destination span
+    {
+        std::array<short, 5> src{1, 2, 3, 4, 5};
+        std::array<int, 10> dst{};
+
+        const span<short, 5> src_span(src);
+        const span<int, 10> dst_span(dst);
+
+        copy(src_span, dst_span);
+        copy(src_span, dst_span.subspan(src_span.size()));
+
+        for (std::size_t i = 0; i < src.size(); ++i)
+        {
+            EXPECT_TRUE(dst[i] == src[i]);
+            EXPECT_TRUE(dst[i + src.size()] == src[i]);
+        }
+    }
+}
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+TEST(algorithm_tests, incompatible_type)
+{
+    std::array<int, 4> src{1, 2, 3, 4};
+    std::array<int*, 12> dst{};
+
+    span<int> src_span_dyn(src);
+    span<int, 4> src_span_static(src);
+    span<int*> dst_span_dyn(dst);
+    span<int*, 4> dst_span_static(dst);
+
+    // every line should produce a compilation error
+    copy(src_span_dyn, dst_span_dyn);
+    copy(src_span_dyn, dst_span_static);
+    copy(src_span_static, dst_span_dyn);
+    copy(src_span_static, dst_span_static);
+}
+#endif
+
+TEST(algorithm_tests, small_destination_span)
+{
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. small_destination_span";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    std::array<int, 12> src{1, 2, 3, 4};
+    std::array<int, 4> dst{};
+
+    const span<int> src_span_dyn(src);
+    const span<int, 12> src_span_static(src);
+    const span<int> dst_span_dyn(dst);
+    const span<int, 4> dst_span_static(dst);
+
+    EXPECT_DEATH(copy(src_span_dyn, dst_span_dyn), expected);
+    EXPECT_DEATH(copy(src_span_dyn, dst_span_static), expected);
+    EXPECT_DEATH(copy(src_span_static, dst_span_dyn), expected);
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+    copy(src_span_static, dst_span_static);
+#endif
+}

deps/GSL/tests/assertion_tests.cpp

@@ -0,0 +1,60 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include "deathTestCommon.h"
+#include <gsl/assert> // for Ensures, Expects
+#include <gtest/gtest.h>
+
+using namespace gsl;
+
+namespace
+{
+
+int f(int i)
+{
+    Expects(i > 0 && i < 10);
+    return i;
+}
+
+int g(int i)
+{
+    i++;
+    Ensures(i > 0 && i < 10);
+    return i;
+}
+} // namespace
+
+TEST(assertion_tests, expects)
+{
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. expects";
+        std::abort();
+    });
+
+    EXPECT_TRUE(f(2) == 2);
+    EXPECT_DEATH(f(10), GetExpectedDeathString(terminateHandler));
+}
+
+TEST(assertion_tests, ensures)
+{
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. ensures";
+        std::abort();
+    });
+
+    EXPECT_TRUE(g(2) == 3);
+    EXPECT_DEATH(g(9), GetExpectedDeathString(terminateHandler));
+}

deps/GSL/tests/at_tests.cpp

@@ -0,0 +1,173 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <gtest/gtest.h>
+
+#include <gsl/util> // for at
+
+#include <array>            // for array
+#include <cstddef>          // for size_t
+#include <exception>        // for terminate
+#include <initializer_list> // for initializer_list
+#include <vector>           // for vector
+#if defined(__cplusplus) && __cplusplus >= 202002L
+#include <span>
+#endif // __cplusplus >= 202002L
+
+#include "deathTestCommon.h"
+
+TEST(at_tests, static_array)
+{
+    int a[4] = {1, 2, 3, 4};
+    const int(&c_a)[4] = a;
+
+    for (int i = 0; i < 4; ++i)
+    {
+        EXPECT_TRUE(&gsl::at(a, i) == &a[i]);
+        EXPECT_TRUE(&gsl::at(c_a, i) == &a[i]);
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. static_array";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    EXPECT_DEATH(gsl::at(a, -1), expected);
+    EXPECT_DEATH(gsl::at(a, 4), expected);
+    EXPECT_DEATH(gsl::at(c_a, -1), expected);
+    EXPECT_DEATH(gsl::at(c_a, 4), expected);
+}
+
+TEST(at_tests, std_array)
+{
+    std::array<int, 4> a = {1, 2, 3, 4};
+    const std::array<int, 4>& c_a = a;
+
+    for (int i = 0; i < 4; ++i)
+    {
+        EXPECT_TRUE(&gsl::at(a, i) == &a[static_cast<std::size_t>(i)]);
+        EXPECT_TRUE(&gsl::at(c_a, i) == &a[static_cast<std::size_t>(i)]);
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. std_array";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    EXPECT_DEATH(gsl::at(a, -1), expected);
+    EXPECT_DEATH(gsl::at(a, 4), expected);
+    EXPECT_DEATH(gsl::at(c_a, -1), expected);
+    EXPECT_DEATH(gsl::at(c_a, 4), expected);
+}
+
+TEST(at_tests, std_vector)
+{
+    std::vector<int> a = {1, 2, 3, 4};
+    const std::vector<int>& c_a = a;
+
+    for (int i = 0; i < 4; ++i)
+    {
+        EXPECT_TRUE(&gsl::at(a, i) == &a[static_cast<std::size_t>(i)]);
+        EXPECT_TRUE(&gsl::at(c_a, i) == &a[static_cast<std::size_t>(i)]);
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. std_vector";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    EXPECT_DEATH(gsl::at(a, -1), expected);
+    EXPECT_DEATH(gsl::at(a, 4), expected);
+    EXPECT_DEATH(gsl::at(c_a, -1), expected);
+    EXPECT_DEATH(gsl::at(c_a, 4), expected);
+}
+
+TEST(at_tests, InitializerList)
+{
+    const std::initializer_list<int> a = {1, 2, 3, 4};
+
+    for (int i = 0; i < 4; ++i)
+    {
+        EXPECT_TRUE(gsl::at(a, i) == i + 1);
+        EXPECT_TRUE(gsl::at({1, 2, 3, 4}, i) == i + 1);
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. InitializerList";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    EXPECT_DEATH(gsl::at(a, -1), expected);
+    EXPECT_DEATH(gsl::at(a, 4), expected);
+    EXPECT_DEATH(gsl::at({1, 2, 3, 4}, -1), expected);
+    EXPECT_DEATH(gsl::at({1, 2, 3, 4}, 4), expected);
+}
+
+#if defined(FORCE_STD_SPAN_TESTS) || defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
+TEST(at_tests, std_span)
+{
+    std::vector<int> vec{1, 2, 3, 4, 5};
+    std::span sp{vec};
+
+    std::vector<int> cvec{1, 2, 3, 4, 5};
+    std::span csp{cvec};
+
+    for (gsl::index i = 0; i < gsl::narrow_cast<gsl::index>(vec.size()); ++i)
+    {
+        EXPECT_TRUE(&gsl::at(sp, i) == &vec[gsl::narrow_cast<size_t>(i)]);
+        EXPECT_TRUE(&gsl::at(csp, i) == &cvec[gsl::narrow_cast<size_t>(i)]);
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. std_span";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    EXPECT_DEATH(gsl::at(sp, -1), expected);
+    EXPECT_DEATH(gsl::at(sp, gsl::narrow_cast<gsl::index>(sp.size())), expected);
+    EXPECT_DEATH(gsl::at(csp, -1), expected);
+    EXPECT_DEATH(gsl::at(csp, gsl::narrow_cast<gsl::index>(sp.size())), expected);
+}
+#endif // defined(FORCE_STD_SPAN_TESTS) || defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
+
+#if !defined(_MSC_VER) || defined(__clang__) || _MSC_VER >= 1910
+static constexpr bool test_constexpr()
+{
+    int a1[4] = {1, 2, 3, 4};
+    const int(&c_a1)[4] = a1;
+    std::array<int, 4> a2 = {1, 2, 3, 4};
+    const std::array<int, 4>& c_a2 = a2;
+
+    for (int i = 0; i < 4; ++i)
+    {
+        if (&gsl::at(a1, i) != &a1[i]) return false;
+        if (&gsl::at(c_a1, i) != &a1[i]) return false;
+        // requires C++17:
+        // if (&gsl::at(a2, i) != &a2[static_cast<std::size_t>(i)]) return false;
+        if (&gsl::at(c_a2, i) != &c_a2[static_cast<std::size_t>(i)]) return false;
+        if (gsl::at({1, 2, 3, 4}, i) != i + 1) return false;
+    }
+
+    return true;
+}
+
+static_assert(test_constexpr(), "FAIL");
+#endif

deps/GSL/tests/byte_tests.cpp

@@ -0,0 +1,137 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <gtest/gtest.h>
+
+#include <gsl/byte> // for to_byte, to_integer, byte, operator&, ope...
+
+using namespace std;
+using namespace gsl;
+
+namespace
+{
+int modify_both(gsl::byte& b, int& i)
+{
+    i = 10;
+    b = to_byte<5>();
+    return i;
+}
+
+TEST(byte_tests, construction)
+{
+    {
+        const byte b = static_cast<byte>(4);
+        EXPECT_TRUE(static_cast<unsigned char>(b) == 4);
+    }
+
+    // clang-format off
+    GSL_SUPPRESS(es.49)
+    // clang-format on
+    {
+        const byte b = byte(12);
+        EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
+    }
+
+    {
+        const byte b = to_byte<12>();
+        EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
+    }
+    {
+        const unsigned char uc = 12;
+        const byte b = to_byte(uc);
+        EXPECT_TRUE(static_cast<unsigned char>(b) == 12);
+    }
+
+#if defined(__cplusplus) && (__cplusplus >= 201703L)
+    {
+        const byte b{14};
+        EXPECT_TRUE(static_cast<unsigned char>(b) == 14);
+    }
+#endif
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+    to_byte(char{});
+    to_byte(3);
+    to_byte(3u);
+#endif
+}
+
+TEST(byte_tests, bitwise_operations)
+{
+    const byte b = to_byte<0xFF>();
+
+    byte a = to_byte<0x00>();
+    EXPECT_TRUE((b | a) == to_byte<0xFF>());
+    EXPECT_TRUE(a == to_byte<0x00>());
+
+    a |= b;
+    EXPECT_TRUE(a == to_byte<0xFF>());
+
+    a = to_byte<0x01>();
+    EXPECT_TRUE((b & a) == to_byte<0x01>());
+
+    a &= b;
+    EXPECT_TRUE(a == to_byte<0x01>());
+
+    EXPECT_TRUE((b ^ a) == to_byte<0xFE>());
+
+    EXPECT_TRUE(a == to_byte<0x01>());
+    a ^= b;
+    EXPECT_TRUE(a == to_byte<0xFE>());
+
+    a = to_byte<0x01>();
+    EXPECT_TRUE(~a == to_byte<0xFE>());
+
+    a = to_byte<0xFF>();
+    EXPECT_TRUE((a << 4) == to_byte<0xF0>());
+    EXPECT_TRUE((a >> 4) == to_byte<0x0F>());
+
+    a <<= 4;
+    EXPECT_TRUE(a == to_byte<0xF0>());
+    a >>= 4;
+    EXPECT_TRUE(a == to_byte<0x0F>());
+}
+
+TEST(byte_tests, to_integer)
+{
+    const byte b = to_byte<0x12>();
+
+    EXPECT_TRUE(0x12 == gsl::to_integer<char>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<short>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<long>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<long long>(b));
+
+    EXPECT_TRUE(0x12 == gsl::to_integer<unsigned char>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<unsigned short>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<unsigned long>(b));
+    EXPECT_TRUE(0x12 == gsl::to_integer<unsigned long long>(b));
+
+    //      EXPECT_TRUE(0x12 == gsl::to_integer<float>(b));   // expect compile-time error
+    //      EXPECT_TRUE(0x12 == gsl::to_integer<double>(b));  // expect compile-time error
+}
+
+TEST(byte_tests, aliasing)
+{
+    int i{0};
+    const int res = modify_both(reinterpret_cast<byte&>(i), i);
+    EXPECT_TRUE(res == i);
+}
+
+} // namespace
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+copy(src_span_static, dst_span_static);
+#endif

deps/GSL/tests/deathTestCommon.h

@@ -0,0 +1,11 @@
+#pragma once
+#include <gsl/assert>
+
+constexpr char deathstring[] = "Expected Death";
+constexpr char failed_set_terminate_deathstring[] = ".*";
+
+// This prevents a failed call to set_terminate from failing the test suite.
+constexpr const char* GetExpectedDeathString(std::terminate_handler handle)
+{
+    return handle ? deathstring : failed_set_terminate_deathstring;
+}

deps/GSL/tests/no_exception_ensure_tests.cpp

@@ -0,0 +1,55 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <chrono>
+#include <cstdlib>  // for std::exit
+#include <gsl/span> // for span
+#include <iostream>
+#include <thread>
+
+int operator_subscript_no_throw() noexcept
+{
+    int arr[10];
+    const gsl::span<int> sp{arr};
+    return sp[11];
+}
+
+[[noreturn]] void test_terminate() { std::exit(0); }
+
+void setup_termination_handler() noexcept
+{
+#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)
+
+    auto& handler = gsl::details::get_terminate_handler();
+    handler = &test_terminate;
+
+#else
+
+    std::set_terminate(test_terminate);
+
+#endif
+}
+
+int main() noexcept
+{
+    std::cout << "Running main() from " __FILE__ "\n";
+#if defined(IOS_PROCESS_DELAY_WORKAROUND)
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+#endif
+    setup_termination_handler();
+    operator_subscript_no_throw();
+    return -1;
+}

deps/GSL/tests/notnull_tests.cpp

@@ -0,0 +1,636 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <gtest/gtest.h>
+
+#include <gsl/pointers> // for not_null, operator<, operator<=, operator>
+
+#include <algorithm> // for addressof
+#include <cstdint>   // for uint16_t
+#include <memory>    // for shared_ptr, make_shared, operator<, opera...
+#include <sstream>   // for operator<<, ostringstream, basic_ostream:...
+#include <string>    // for basic_string, operator==, string, operator<<
+#include <typeinfo>  // for type_info
+
+#include "deathTestCommon.h"
+using namespace gsl;
+
+struct MyBase
+{
+};
+struct MyDerived : public MyBase
+{
+};
+struct Unrelated
+{
+};
+
+// stand-in for a user-defined ref-counted class
+template <typename T>
+struct RefCounted
+{
+    RefCounted(T* p) : p_(p) {}
+    operator T*() { return p_; }
+    T* p_;
+};
+
+// user defined smart pointer with comparison operators returning non bool value
+template <typename T>
+struct CustomPtr
+{
+    CustomPtr(T* p) : p_(p) {}
+    operator T*() const { return p_; }
+    bool operator!=(std::nullptr_t) const { return p_ != nullptr; }
+    T* p_ = nullptr;
+};
+
+template <typename T, typename U>
+std::string operator==(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
+{
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return reinterpret_cast<const void*>(lhs.p_) == reinterpret_cast<const void*>(rhs.p_) ? "true"
+                                                                                          : "false";
+}
+
+template <typename T, typename U>
+std::string operator!=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
+{
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return reinterpret_cast<const void*>(lhs.p_) != reinterpret_cast<const void*>(rhs.p_) ? "true"
+                                                                                          : "false";
+}
+
+template <typename T, typename U>
+std::string operator<(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
+{
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return reinterpret_cast<const void*>(lhs.p_) < reinterpret_cast<const void*>(rhs.p_) ? "true"
+                                                                                         : "false";
+}
+
+template <typename T, typename U>
+std::string operator>(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
+{
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return reinterpret_cast<const void*>(lhs.p_) > reinterpret_cast<const void*>(rhs.p_) ? "true"
+                                                                                         : "false";
+}
+
+template <typename T, typename U>
+std::string operator<=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
+{
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return reinterpret_cast<const void*>(lhs.p_) <= reinterpret_cast<const void*>(rhs.p_) ? "true"
+                                                                                          : "false";
+}
+
+template <typename T, typename U>
+std::string operator>=(CustomPtr<T> const& lhs, CustomPtr<U> const& rhs)
+{
+    // clang-format off
+    GSL_SUPPRESS(type.1) // NO-FORMAT: attribute
+    // clang-format on
+    return reinterpret_cast<const void*>(lhs.p_) >= reinterpret_cast<const void*>(rhs.p_) ? "true"
+                                                                                          : "false";
+}
+
+struct NonCopyableNonMovable
+{
+    NonCopyableNonMovable() = default;
+    NonCopyableNonMovable(const NonCopyableNonMovable&) = delete;
+    NonCopyableNonMovable& operator=(const NonCopyableNonMovable&) = delete;
+    NonCopyableNonMovable(NonCopyableNonMovable&&) = delete;
+    NonCopyableNonMovable& operator=(NonCopyableNonMovable&&) = delete;
+};
+
+namespace
+{
+// clang-format off
+GSL_SUPPRESS(f .4) // NO-FORMAT: attribute
+// clang-format on
+bool helper(not_null<int*> p) { return *p == 12; }
+// clang-format off
+GSL_SUPPRESS(f .4) // NO-FORMAT: attribute
+// clang-format on
+bool helper_const(not_null<const int*> p) { return *p == 12; }
+
+int* return_pointer() { return nullptr; }
+} // namespace
+
+TEST(notnull_tests, TestNotNullConstructors)
+{
+    {
+#ifdef CONFIRM_COMPILATION_ERRORS
+        not_null<int*> p = nullptr;          // yay...does not compile!
+        not_null<std::vector<char>*> p1 = 0; // yay...does not compile!
+        not_null<int*> p2;                   // yay...does not compile!
+        std::unique_ptr<int> up = std::make_unique<int>(120);
+        not_null<int*> p3 = up;
+
+        // Forbid non-nullptr assignable types
+        not_null<std::vector<int>> f(std::vector<int>{1});
+        not_null<int> z(10);
+        not_null<std::vector<int>> y({1, 2});
+#endif
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. TestNotNullConstructors";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    {
+        // from shared pointer
+        int i = 12;
+        auto rp = RefCounted<int>(&i);
+        not_null<int*> p(rp);
+        EXPECT_TRUE(p.get() == &i);
+
+        not_null<std::shared_ptr<int>> x(
+            std::make_shared<int>(10)); // shared_ptr<int> is nullptr assignable
+
+        int* pi = nullptr;
+        EXPECT_DEATH((not_null<decltype(pi)>(pi)), expected);
+    }
+
+    {
+        // from pointer to local
+        int t = 42;
+
+        not_null<int*> x = &t;
+        helper(&t);
+        helper_const(&t);
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        // from raw pointer
+        // from not_null pointer
+
+        int t = 42;
+        int* p = &t;
+
+        not_null<int*> x = p;
+        helper(p);
+        helper_const(p);
+        helper(x);
+        helper_const(x);
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        // from raw const pointer
+        // from not_null const pointer
+
+        int t = 42;
+        const int* cp = &t;
+
+        not_null<const int*> x = cp;
+        helper_const(cp);
+        helper_const(x);
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        // from not_null const pointer, using auto
+        int t = 42;
+        const int* cp = &t;
+
+        auto x = not_null<const int*>{cp};
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        // from returned pointer
+
+        EXPECT_DEATH(helper(return_pointer()), expected);
+        EXPECT_DEATH(helper_const(return_pointer()), expected);
+    }
+}
+
+template <typename T>
+void ostream_helper(T v)
+{
+    not_null<T*> p(&v);
+    {
+        std::ostringstream os;
+        std::ostringstream ref;
+        os << static_cast<void*>(p);
+        ref << static_cast<void*>(&v);
+        EXPECT_TRUE(os.str() == ref.str());
+    }
+    {
+        std::ostringstream os;
+        std::ostringstream ref;
+        os << *p;
+        ref << v;
+        EXPECT_TRUE(os.str() == ref.str());
+    }
+}
+
+TEST(notnull_tests, TestNotNullostream)
+{
+    ostream_helper<int>(17);
+    ostream_helper<float>(21.5f);
+    ostream_helper<double>(3.4566e-7);
+    ostream_helper<char>('c');
+    ostream_helper<uint16_t>(0x0123u);
+    ostream_helper<const char*>("cstring");
+    ostream_helper<std::string>("string");
+}
+
+TEST(notnull_tests, TestNotNullCasting)
+{
+    MyBase base;
+    MyDerived derived;
+    Unrelated unrelated;
+    not_null<Unrelated*> u{&unrelated};
+    (void) u;
+    not_null<MyDerived*> p{&derived};
+    not_null<MyBase*> q(&base);
+    q = p; // allowed with heterogeneous copy ctor
+    EXPECT_TRUE(q == p);
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+    q = u; // no viable conversion possible between MyBase* and Unrelated*
+    p = q; // not possible to implicitly convert MyBase* to MyDerived*
+
+    not_null<Unrelated*> r = p;
+    not_null<Unrelated*> s = reinterpret_cast<Unrelated*>(p);
+#endif
+    not_null<Unrelated*> t(reinterpret_cast<Unrelated*>(p.get()));
+    EXPECT_TRUE(reinterpret_cast<void*>(p.get()) == reinterpret_cast<void*>(t.get()));
+}
+
+TEST(notnull_tests, TestNotNullAssignment)
+{
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. TestNotNullAssignmentd";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    int i = 12;
+    not_null<int*> p(&i);
+    EXPECT_TRUE(helper(p));
+
+    int* q = nullptr;
+    EXPECT_DEATH(p = not_null<int*>(q), expected);
+}
+
+TEST(notnull_tests, TestNotNullRawPointerComparison)
+{
+    int ints[2] = {42, 43};
+    int* p1 = &ints[0];
+    const int* p2 = &ints[1];
+
+    using NotNull1 = not_null<decltype(p1)>;
+    using NotNull2 = not_null<decltype(p2)>;
+
+    EXPECT_TRUE((NotNull1(p1) == NotNull1(p1)) == true);
+    EXPECT_TRUE((NotNull1(p1) == NotNull2(p2)) == false);
+
+    EXPECT_TRUE((NotNull1(p1) != NotNull1(p1)) == false);
+    EXPECT_TRUE((NotNull1(p1) != NotNull2(p2)) == true);
+
+    EXPECT_TRUE((NotNull1(p1) < NotNull1(p1)) == false);
+    EXPECT_TRUE((NotNull1(p1) < NotNull2(p2)) == (p1 < p2));
+    EXPECT_TRUE((NotNull2(p2) < NotNull1(p1)) == (p2 < p1));
+
+    EXPECT_TRUE((NotNull1(p1) > NotNull1(p1)) == false);
+    EXPECT_TRUE((NotNull1(p1) > NotNull2(p2)) == (p1 > p2));
+    EXPECT_TRUE((NotNull2(p2) > NotNull1(p1)) == (p2 > p1));
+
+    EXPECT_TRUE((NotNull1(p1) <= NotNull1(p1)) == true);
+    EXPECT_TRUE((NotNull1(p1) <= NotNull2(p2)) == (p1 <= p2));
+    EXPECT_TRUE((NotNull2(p2) <= NotNull1(p1)) == (p2 <= p1));
+}
+
+TEST(notnull_tests, TestNotNullDereferenceOperator)
+{
+    {
+        auto sp1 = std::make_shared<NonCopyableNonMovable>();
+
+        using NotNullSp1 = not_null<decltype(sp1)>;
+        EXPECT_TRUE(typeid(*sp1) == typeid(*NotNullSp1(sp1)));
+        EXPECT_TRUE(std::addressof(*NotNullSp1(sp1)) == std::addressof(*sp1));
+    }
+
+    {
+        int ints[1] = {42};
+        CustomPtr<int> p1(&ints[0]);
+
+        using NotNull1 = not_null<decltype(p1)>;
+        EXPECT_TRUE(typeid(*NotNull1(p1)) == typeid(*p1));
+        EXPECT_TRUE(*NotNull1(p1) == 42);
+        *NotNull1(p1) = 43;
+        EXPECT_TRUE(ints[0] == 43);
+    }
+
+    {
+        int v = 42;
+        gsl::not_null<int*> p(&v);
+        EXPECT_TRUE(typeid(*p) == typeid(*(&v)));
+        *p = 43;
+        EXPECT_TRUE(v == 43);
+    }
+}
+
+TEST(notnull_tests, TestNotNullSharedPtrComparison)
+{
+    auto sp1 = std::make_shared<int>(42);
+    auto sp2 = std::make_shared<const int>(43);
+
+    using NotNullSp1 = not_null<decltype(sp1)>;
+    using NotNullSp2 = not_null<decltype(sp2)>;
+
+    EXPECT_TRUE((NotNullSp1(sp1) == NotNullSp1(sp1)) == true);
+    EXPECT_TRUE((NotNullSp1(sp1) == NotNullSp2(sp2)) == false);
+
+    EXPECT_TRUE((NotNullSp1(sp1) != NotNullSp1(sp1)) == false);
+    EXPECT_TRUE((NotNullSp1(sp1) != NotNullSp2(sp2)) == true);
+
+    EXPECT_TRUE((NotNullSp1(sp1) < NotNullSp1(sp1)) == false);
+    EXPECT_TRUE((NotNullSp1(sp1) < NotNullSp2(sp2)) == (sp1 < sp2));
+    EXPECT_TRUE((NotNullSp2(sp2) < NotNullSp1(sp1)) == (sp2 < sp1));
+
+    EXPECT_TRUE((NotNullSp1(sp1) > NotNullSp1(sp1)) == false);
+    EXPECT_TRUE((NotNullSp1(sp1) > NotNullSp2(sp2)) == (sp1 > sp2));
+    EXPECT_TRUE((NotNullSp2(sp2) > NotNullSp1(sp1)) == (sp2 > sp1));
+
+    EXPECT_TRUE((NotNullSp1(sp1) <= NotNullSp1(sp1)) == true);
+    EXPECT_TRUE((NotNullSp1(sp1) <= NotNullSp2(sp2)) == (sp1 <= sp2));
+    EXPECT_TRUE((NotNullSp2(sp2) <= NotNullSp1(sp1)) == (sp2 <= sp1));
+
+    EXPECT_TRUE((NotNullSp1(sp1) >= NotNullSp1(sp1)) == true);
+    EXPECT_TRUE((NotNullSp1(sp1) >= NotNullSp2(sp2)) == (sp1 >= sp2));
+    EXPECT_TRUE((NotNullSp2(sp2) >= NotNullSp1(sp1)) == (sp2 >= sp1));
+}
+
+TEST(notnull_tests, TestNotNullCustomPtrComparison)
+{
+    int ints[2] = {42, 43};
+    CustomPtr<int> p1(&ints[0]);
+    CustomPtr<const int> p2(&ints[1]);
+
+    using NotNull1 = not_null<decltype(p1)>;
+    using NotNull2 = not_null<decltype(p2)>;
+
+    EXPECT_TRUE((NotNull1(p1) == NotNull1(p1)) == "true");
+    EXPECT_TRUE((NotNull1(p1) == NotNull2(p2)) == "false");
+
+    EXPECT_TRUE((NotNull1(p1) != NotNull1(p1)) == "false");
+    EXPECT_TRUE((NotNull1(p1) != NotNull2(p2)) == "true");
+
+    EXPECT_TRUE((NotNull1(p1) < NotNull1(p1)) == "false");
+    EXPECT_TRUE((NotNull1(p1) < NotNull2(p2)) == (p1 < p2));
+    EXPECT_TRUE((NotNull2(p2) < NotNull1(p1)) == (p2 < p1));
+
+    EXPECT_TRUE((NotNull1(p1) > NotNull1(p1)) == "false");
+    EXPECT_TRUE((NotNull1(p1) > NotNull2(p2)) == (p1 > p2));
+    EXPECT_TRUE((NotNull2(p2) > NotNull1(p1)) == (p2 > p1));
+
+    EXPECT_TRUE((NotNull1(p1) <= NotNull1(p1)) == "true");
+    EXPECT_TRUE((NotNull1(p1) <= NotNull2(p2)) == (p1 <= p2));
+    EXPECT_TRUE((NotNull2(p2) <= NotNull1(p1)) == (p2 <= p1));
+
+    EXPECT_TRUE((NotNull1(p1) >= NotNull1(p1)) == "true");
+    EXPECT_TRUE((NotNull1(p1) >= NotNull2(p2)) == (p1 >= p2));
+    EXPECT_TRUE((NotNull2(p2) >= NotNull1(p1)) == (p2 >= p1));
+}
+
+#if defined(__cplusplus) && (__cplusplus >= 201703L)
+
+TEST(notnull_tests, TestNotNullConstructorTypeDeduction)
+{
+    {
+        int i = 42;
+
+        not_null x{&i};
+        helper(not_null{&i});
+        helper_const(not_null{&i});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        const int i = 42;
+
+        not_null x{&i};
+#ifdef CONFIRM_COMPILATION_ERRORS
+        helper(not_null{&i});
+#endif
+        helper_const(not_null{&i});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        int i = 42;
+        int* p = &i;
+
+        not_null x{p};
+        helper(not_null{p});
+        helper_const(not_null{p});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        const int i = 42;
+        const int* p = &i;
+
+        not_null x{p};
+#ifdef CONFIRM_COMPILATION_ERRORS
+        helper(not_null{p});
+#endif
+        helper_const(not_null{p});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. TestNotNullConstructorTypeDeduction";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    {
+        auto workaround_macro = []() {
+            int* p1 = nullptr;
+            const not_null x{p1};
+        };
+        EXPECT_DEATH(workaround_macro(), expected);
+    }
+
+    {
+        auto workaround_macro = []() {
+            const int* p1 = nullptr;
+            const not_null x{p1};
+        };
+        EXPECT_DEATH(workaround_macro(), expected);
+    }
+
+    {
+        int* p = nullptr;
+
+        EXPECT_DEATH(helper(not_null{p}), expected);
+        EXPECT_DEATH(helper_const(not_null{p}), expected);
+    }
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        not_null x{nullptr};
+        helper(not_null{nullptr});
+        helper_const(not_null{nullptr});
+    }
+#endif
+}
+#endif // #if defined(__cplusplus) && (__cplusplus >= 201703L)
+
+TEST(notnull_tests, TestMakeNotNull)
+{
+    {
+        int i = 42;
+
+        const auto x = make_not_null(&i);
+        helper(make_not_null(&i));
+        helper_const(make_not_null(&i));
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        const int i = 42;
+
+        const auto x = make_not_null(&i);
+#ifdef CONFIRM_COMPILATION_ERRORS
+        helper(make_not_null(&i));
+#endif
+        helper_const(make_not_null(&i));
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        int i = 42;
+        int* p = &i;
+
+        const auto x = make_not_null(p);
+        helper(make_not_null(p));
+        helper_const(make_not_null(p));
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        const int i = 42;
+        const int* p = &i;
+
+        const auto x = make_not_null(p);
+#ifdef CONFIRM_COMPILATION_ERRORS
+        helper(make_not_null(p));
+#endif
+        helper_const(make_not_null(p));
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. TestMakeNotNull";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    {
+        const auto workaround_macro = []() {
+            int* p1 = nullptr;
+            const auto x = make_not_null(p1);
+            EXPECT_TRUE(*x == 42);
+        };
+        EXPECT_DEATH(workaround_macro(), expected);
+    }
+
+    {
+        const auto workaround_macro = []() {
+            const int* p1 = nullptr;
+            const auto x = make_not_null(p1);
+            EXPECT_TRUE(*x == 42);
+        };
+        EXPECT_DEATH(workaround_macro(), expected);
+    }
+
+    {
+        int* p = nullptr;
+
+        EXPECT_DEATH(helper(make_not_null(p)), expected);
+        EXPECT_DEATH(helper_const(make_not_null(p)), expected);
+    }
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        EXPECT_DEATH(make_not_null(nullptr), expected);
+        EXPECT_DEATH(helper(make_not_null(nullptr)), expected);
+        EXPECT_DEATH(helper_const(make_not_null(nullptr)), expected);
+    }
+#endif
+}
+
+TEST(notnull_tests, TestStdHash)
+{
+    {
+        int x = 42;
+        int y = 99;
+        not_null<int*> nn{&x};
+        const not_null<int*> cnn{&x};
+
+        std::hash<not_null<int*>> hash_nn;
+        std::hash<int*> hash_intptr;
+
+        EXPECT_TRUE(hash_nn(nn) == hash_intptr(&x));
+        EXPECT_FALSE(hash_nn(nn) == hash_intptr(&y));
+        EXPECT_FALSE(hash_nn(nn) == hash_intptr(nullptr));
+    }
+
+    {
+        const int x = 42;
+        const int y = 99;
+        not_null<const int*> nn{&x};
+        const not_null<const int*> cnn{&x};
+
+        std::hash<not_null<const int*>> hash_nn;
+        std::hash<const int*> hash_intptr;
+
+        EXPECT_TRUE(hash_nn(nn) == hash_intptr(&x));
+        EXPECT_FALSE(hash_nn(nn) == hash_intptr(&y));
+        EXPECT_FALSE(hash_nn(nn) == hash_intptr(nullptr));
+    }
+}

deps/GSL/tests/owner_tests.cpp

@@ -0,0 +1,43 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <gtest/gtest.h>
+
+#include <gsl/pointers> // for owner
+
+using namespace gsl;
+
+GSL_SUPPRESS(f .23) // NO-FORMAT: attribute
+void f(int* i) { *i += 1; }
+
+TEST(owner_tests, basic_test)
+{
+    owner<int*> p = new int(120);
+    EXPECT_TRUE(*p == 120);
+    f(p);
+    EXPECT_TRUE(*p == 121);
+    delete p;
+}
+
+TEST(owner_tests, check_pointer_constraint)
+{
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        owner<int> integerTest = 10;
+        owner<std::shared_ptr<int>> sharedPtrTest(new int(10));
+    }
+#endif
+}

deps/GSL/tests/span_ext_tests.cpp

@@ -0,0 +1,380 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <gtest/gtest.h>
+
+#include <gsl/span> // for span and span_ext
+#include <gsl/util> // for narrow_cast, at
+
+#include <array>     // for array
+#include <exception> // for terminate
+#include <iostream>  // for cerr
+#include <vector>    // for vector
+
+using namespace std;
+using namespace gsl;
+
+#include "deathTestCommon.h"
+
+TEST(span_ext_test, make_span_from_pointer_length_constructor)
+{
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. from_pointer_length_constructor";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    int arr[4] = {1, 2, 3, 4};
+
+    {
+        auto s = make_span(&arr[0], 2);
+        EXPECT_TRUE(s.size() == 2);
+        EXPECT_TRUE(s.data() == &arr[0]);
+        EXPECT_TRUE(s[0] == 1);
+        EXPECT_TRUE(s[1] == 2);
+    }
+
+    {
+        int* p = nullptr;
+        auto s = make_span(p, narrow_cast<gsl::span<int>::size_type>(0));
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == nullptr);
+    }
+
+    {
+        int* p = nullptr;
+        auto workaround_macro = [=]() { make_span(p, 2); };
+        EXPECT_DEATH(workaround_macro(), expected);
+    }
+}
+
+TEST(span_ext_test, make_span_from_pointer_pointer_construction)
+{
+    int arr[4] = {1, 2, 3, 4};
+
+    {
+        auto s = make_span(&arr[0], &arr[2]);
+        EXPECT_TRUE(s.size() == 2);
+        EXPECT_TRUE(s.data() == &arr[0]);
+        EXPECT_TRUE(s[0] == 1);
+        EXPECT_TRUE(s[1] == 2);
+    }
+
+    {
+        auto s = make_span(&arr[0], &arr[0]);
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == &arr[0]);
+    }
+
+    {
+        int* p = nullptr;
+        auto s = make_span(p, p);
+        EXPECT_TRUE(s.size() == 0);
+        EXPECT_TRUE(s.data() == nullptr);
+    }
+}
+
+TEST(span_ext_test, make_span_from_array_constructor)
+{
+    int arr[5] = {1, 2, 3, 4, 5};
+    int arr2d[2][3] = {1, 2, 3, 4, 5, 6};
+    int arr3d[2][3][2] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
+
+    {
+        const auto s = make_span(arr);
+        EXPECT_TRUE(s.size() == 5);
+        EXPECT_TRUE(s.data() == std::addressof(arr[0]));
+    }
+
+    {
+        const auto s = make_span(std::addressof(arr2d[0]), 1);
+        EXPECT_TRUE(s.size() == 1);
+        EXPECT_TRUE(s.data() == std::addressof(arr2d[0]));
+    }
+
+    {
+        const auto s = make_span(std::addressof(arr3d[0]), 1);
+        EXPECT_TRUE(s.size() == 1);
+        EXPECT_TRUE(s.data() == std::addressof(arr3d[0]));
+    }
+}
+
+TEST(span_ext_test, make_span_from_dynamic_array_constructor)
+{
+    double(*arr)[3][4] = new double[100][3][4];
+
+    {
+        auto s = make_span(&arr[0][0][0], 10);
+        EXPECT_TRUE(s.size() == 10);
+        EXPECT_TRUE(s.data() == &arr[0][0][0]);
+    }
+
+    delete[] arr;
+}
+
+TEST(span_ext_test, make_span_from_std_array_constructor)
+{
+    std::array<int, 4> arr = {1, 2, 3, 4};
+
+    {
+        auto s = make_span(arr);
+        EXPECT_TRUE(s.size() == arr.size());
+        EXPECT_TRUE(s.data() == arr.data());
+    }
+
+    // This test checks for the bug found in gcc 6.1, 6.2, 6.3, 6.4, 6.5 7.1, 7.2, 7.3 - issue #590
+    {
+        gsl::span<int> s1 = make_span(arr);
+
+        static gsl::span<int> s2;
+        s2 = s1;
+
+#if defined(__GNUC__) && __GNUC__ == 6 && (__GNUC_MINOR__ == 4 || __GNUC_MINOR__ == 5) &&          \
+    __GNUC_PATCHLEVEL__ == 0 && defined(__OPTIMIZE__)
+        // Known to be broken in gcc 6.4 and 6.5 with optimizations
+        // Issue in gcc: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83116
+        EXPECT_TRUE(s1.size() == 4);
+        EXPECT_TRUE(s2.size() == 0);
+#else
+        EXPECT_TRUE(s1.size() == s2.size());
+#endif
+    }
+}
+
+TEST(span_ext_test, make_span_from_const_std_array_constructor)
+{
+    const std::array<int, 4> arr = {1, 2, 3, 4};
+
+    {
+        auto s = make_span(arr);
+        EXPECT_TRUE(s.size() == arr.size());
+        EXPECT_TRUE(s.data() == arr.data());
+    }
+}
+
+TEST(span_ext_test, make_span_from_std_array_const_constructor)
+{
+    std::array<const int, 4> arr = {1, 2, 3, 4};
+
+    {
+        auto s = make_span(arr);
+        EXPECT_TRUE(s.size() == arr.size());
+        EXPECT_TRUE(s.data() == arr.data());
+    }
+}
+
+TEST(span_ext_test, make_span_from_container_constructor)
+{
+    std::vector<int> v = {1, 2, 3};
+    const std::vector<int> cv = v;
+
+    {
+        auto s = make_span(v);
+        EXPECT_TRUE(s.size() == v.size());
+        EXPECT_TRUE(s.data() == v.data());
+
+        auto cs = make_span(cv);
+        EXPECT_TRUE(cs.size() == cv.size());
+        EXPECT_TRUE(cs.data() == cv.data());
+    }
+}
+
+TEST(span_test, interop_with_gsl_at)
+{
+    std::vector<int> vec{1, 2, 3, 4, 5};
+    gsl::span<int> sp{vec};
+
+    std::vector<int> cvec{1, 2, 3, 4, 5};
+    gsl::span<int> csp{cvec};
+
+    for (gsl::index i = 0; i < gsl::narrow_cast<gsl::index>(vec.size()); ++i)
+    {
+        EXPECT_TRUE(&gsl::at(sp, i) == &vec[gsl::narrow_cast<size_t>(i)]);
+        EXPECT_TRUE(&gsl::at(csp, i) == &cvec[gsl::narrow_cast<size_t>(i)]);
+    }
+
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. interop_with_gsl_at";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    EXPECT_DEATH(gsl::at(sp, -1), expected);
+    EXPECT_DEATH(gsl::at(sp, gsl::narrow_cast<gsl::index>(sp.size())), expected);
+    EXPECT_DEATH(gsl::at(csp, -1), expected);
+    EXPECT_DEATH(gsl::at(csp, gsl::narrow_cast<gsl::index>(sp.size())), expected);
+}
+
+TEST(span_ext_test, iterator_free_functions)
+{
+    int a[] = {1, 2, 3, 4};
+    gsl::span<int> s{a};
+
+    EXPECT_TRUE((std::is_same<decltype(s.begin()), decltype(begin(s))>::value));
+    EXPECT_TRUE((std::is_same<decltype(s.end()), decltype(end(s))>::value));
+
+    EXPECT_TRUE((std::is_same<decltype(std::cbegin(s)), decltype(cbegin(s))>::value));
+    EXPECT_TRUE((std::is_same<decltype(std::cend(s)), decltype(cend(s))>::value));
+
+    EXPECT_TRUE((std::is_same<decltype(s.rbegin()), decltype(rbegin(s))>::value));
+    EXPECT_TRUE((std::is_same<decltype(s.rend()), decltype(rend(s))>::value));
+
+    EXPECT_TRUE((std::is_same<decltype(std::crbegin(s)), decltype(crbegin(s))>::value));
+    EXPECT_TRUE((std::is_same<decltype(std::crend(s)), decltype(crend(s))>::value));
+
+    EXPECT_TRUE(s.begin() == begin(s));
+    EXPECT_TRUE(s.end() == end(s));
+
+    EXPECT_TRUE(s.rbegin() == rbegin(s));
+    EXPECT_TRUE(s.rend() == rend(s));
+
+    EXPECT_TRUE(s.begin() == cbegin(s));
+    EXPECT_TRUE(s.end() == cend(s));
+
+    EXPECT_TRUE(s.rbegin() == crbegin(s));
+    EXPECT_TRUE(s.rend() == crend(s));
+}
+
+TEST(span_ext_test, ssize_free_function)
+{
+    int a[] = {1, 2, 3, 4};
+    gsl::span<int> s{a};
+
+    EXPECT_FALSE((std::is_same<decltype(s.size()), decltype(ssize(s))>::value));
+    EXPECT_TRUE(s.size() == static_cast<std::size_t>(ssize(s)));
+}
+
+#ifndef GSL_KERNEL_MODE
+TEST(span_ext_test, comparison_operators)
+{
+    {
+        gsl::span<int> s1;
+        gsl::span<int> s2;
+        EXPECT_TRUE(s1 == s2);
+        EXPECT_FALSE(s1 != s2);
+        EXPECT_FALSE(s1 < s2);
+        EXPECT_TRUE(s1 <= s2);
+        EXPECT_FALSE(s1 > s2);
+        EXPECT_TRUE(s1 >= s2);
+        EXPECT_TRUE(s2 == s1);
+        EXPECT_FALSE(s2 != s1);
+        EXPECT_FALSE(s2 != s1);
+        EXPECT_TRUE(s2 <= s1);
+        EXPECT_FALSE(s2 > s1);
+        EXPECT_TRUE(s2 >= s1);
+    }
+
+    {
+        int arr[] = {2, 1};
+        gsl::span<int> s1 = arr;
+        gsl::span<int> s2 = arr;
+
+        EXPECT_TRUE(s1 == s2);
+        EXPECT_FALSE(s1 != s2);
+        EXPECT_FALSE(s1 < s2);
+        EXPECT_TRUE(s1 <= s2);
+        EXPECT_FALSE(s1 > s2);
+        EXPECT_TRUE(s1 >= s2);
+        EXPECT_TRUE(s2 == s1);
+        EXPECT_FALSE(s2 != s1);
+        EXPECT_FALSE(s2 < s1);
+        EXPECT_TRUE(s2 <= s1);
+        EXPECT_FALSE(s2 > s1);
+        EXPECT_TRUE(s2 >= s1);
+    }
+
+    {
+        int arr[] = {2, 1}; // bigger
+
+        gsl::span<int> s1;
+        gsl::span<int> s2 = arr;
+
+        EXPECT_TRUE(s1 != s2);
+        EXPECT_TRUE(s2 != s1);
+        EXPECT_FALSE(s1 == s2);
+        EXPECT_FALSE(s2 == s1);
+        EXPECT_TRUE(s1 < s2);
+        EXPECT_FALSE(s2 < s1);
+        EXPECT_TRUE(s1 <= s2);
+        EXPECT_FALSE(s2 <= s1);
+        EXPECT_TRUE(s2 > s1);
+        EXPECT_FALSE(s1 > s2);
+        EXPECT_TRUE(s2 >= s1);
+        EXPECT_FALSE(s1 >= s2);
+    }
+
+    {
+        int arr1[] = {1, 2};
+        int arr2[] = {1, 2};
+        gsl::span<int> s1 = arr1;
+        gsl::span<int> s2 = arr2;
+
+        EXPECT_TRUE(s1 == s2);
+        EXPECT_FALSE(s1 != s2);
+        EXPECT_FALSE(s1 < s2);
+        EXPECT_TRUE(s1 <= s2);
+        EXPECT_FALSE(s1 > s2);
+        EXPECT_TRUE(s1 >= s2);
+        EXPECT_TRUE(s2 == s1);
+        EXPECT_FALSE(s2 != s1);
+        EXPECT_FALSE(s2 < s1);
+        EXPECT_TRUE(s2 <= s1);
+        EXPECT_FALSE(s2 > s1);
+        EXPECT_TRUE(s2 >= s1);
+    }
+
+    {
+        int arr[] = {1, 2, 3};
+
+        gsl::span<int> s1 = {&arr[0], 2}; // shorter
+        gsl::span<int> s2 = arr;          // longer
+
+        EXPECT_TRUE(s1 != s2);
+        EXPECT_TRUE(s2 != s1);
+        EXPECT_FALSE(s1 == s2);
+        EXPECT_FALSE(s2 == s1);
+        EXPECT_TRUE(s1 < s2);
+        EXPECT_FALSE(s2 < s1);
+        EXPECT_TRUE(s1 <= s2);
+        EXPECT_FALSE(s2 <= s1);
+        EXPECT_TRUE(s2 > s1);
+        EXPECT_FALSE(s1 > s2);
+        EXPECT_TRUE(s2 >= s1);
+        EXPECT_FALSE(s1 >= s2);
+    }
+
+    {
+        int arr1[] = {1, 2}; // smaller
+        int arr2[] = {2, 1}; // bigger
+
+        gsl::span<int> s1 = arr1;
+        gsl::span<int> s2 = arr2;
+
+        EXPECT_TRUE(s1 != s2);
+        EXPECT_TRUE(s2 != s1);
+        EXPECT_FALSE(s1 == s2);
+        EXPECT_FALSE(s2 == s1);
+        EXPECT_TRUE(s1 < s2);
+        EXPECT_FALSE(s2 < s1);
+        EXPECT_TRUE(s1 <= s2);
+        EXPECT_FALSE(s2 <= s1);
+        EXPECT_TRUE(s2 > s1);
+        EXPECT_FALSE(s1 > s2);
+        EXPECT_TRUE(s2 >= s1);
+        EXPECT_FALSE(s1 >= s2);
+    }
+}
+#endif // GSL_KERNEL_MODE

deps/GSL/tests/strict_notnull_tests.cpp

@@ -0,0 +1,304 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <gsl/pointers> // for not_null, operator<, operator<=, operator>
+#include <gtest/gtest.h>
+
+#include "deathTestCommon.h"
+
+using namespace gsl;
+
+namespace
+{
+// clang-format off
+GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+// clang-format on
+bool helper(not_null<int*> p) { return *p == 12; }
+
+// clang-format off
+GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+// clang-format on
+bool helper_const(not_null<const int*> p) { return *p == 12; }
+
+// clang-format off
+GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+// clang-format on
+bool strict_helper(strict_not_null<int*> p) { return *p == 12; }
+
+// clang-format off
+GSL_SUPPRESS(f.4) // NO-FORMAT: attribute
+// clang-format on
+bool strict_helper_const(strict_not_null<const int*> p) { return *p == 12; }
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+int* return_pointer() { return nullptr; }
+const int* return_pointer_const() { return nullptr; }
+#endif
+} // namespace
+
+TEST(strict_notnull_tests, TestStrictNotNull)
+{
+    {
+        // raw ptr <-> strict_not_null
+        int x = 42;
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+        strict_not_null<int*> snn = &x;
+        strict_helper(&x);
+        strict_helper_const(&x);
+        strict_helper(return_pointer());
+        strict_helper_const(return_pointer_const());
+#endif
+
+        const strict_not_null<int*> snn1{&x};
+
+        helper(snn1);
+        helper_const(snn1);
+
+        EXPECT_TRUE(*snn1 == 42);
+    }
+
+    {
+        // raw ptr <-> strict_not_null
+        const int x = 42;
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+        strict_not_null<int*> snn = &x;
+        strict_helper(&x);
+        strict_helper_const(&x);
+        strict_helper(return_pointer());
+        strict_helper_const(return_pointer_const());
+#endif
+
+        const strict_not_null<const int*> snn1{&x};
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+        helper(snn1);
+#endif
+        helper_const(snn1);
+
+        EXPECT_TRUE(*snn1 == 42);
+    }
+
+    {
+        // strict_not_null -> strict_not_null
+        int x = 42;
+
+        strict_not_null<int*> snn1{&x};
+        const strict_not_null<int*> snn2{&x};
+
+        strict_helper(snn1);
+        strict_helper_const(snn1);
+        strict_helper_const(snn2);
+
+        EXPECT_TRUE(snn1 == snn2);
+    }
+
+    {
+        // strict_not_null -> strict_not_null
+        const int x = 42;
+
+        strict_not_null<const int*> snn1{&x};
+        const strict_not_null<const int*> snn2{&x};
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+        strict_helper(snn1);
+#endif
+        strict_helper_const(snn1);
+        strict_helper_const(snn2);
+
+        EXPECT_TRUE(snn1 == snn2);
+    }
+
+    {
+        // strict_not_null -> not_null
+        int x = 42;
+
+        strict_not_null<int*> snn{&x};
+
+        const not_null<int*> nn1 = snn;
+        const not_null<int*> nn2{snn};
+
+        helper(snn);
+        helper_const(snn);
+
+        EXPECT_TRUE(snn == nn1);
+        EXPECT_TRUE(snn == nn2);
+    }
+
+    {
+        // strict_not_null -> not_null
+        const int x = 42;
+
+        strict_not_null<const int*> snn{&x};
+
+        const not_null<const int*> nn1 = snn;
+        const not_null<const int*> nn2{snn};
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+        helper(snn);
+#endif
+        helper_const(snn);
+
+        EXPECT_TRUE(snn == nn1);
+        EXPECT_TRUE(snn == nn2);
+    }
+
+    {
+        // not_null -> strict_not_null
+        int x = 42;
+
+        not_null<int*> nn{&x};
+
+        const strict_not_null<int*> snn1{nn};
+        const strict_not_null<int*> snn2{nn};
+
+        strict_helper(nn);
+        strict_helper_const(nn);
+
+        EXPECT_TRUE(snn1 == nn);
+        EXPECT_TRUE(snn2 == nn);
+
+        std::hash<strict_not_null<int*>> hash_snn;
+        std::hash<not_null<int*>> hash_nn;
+
+        EXPECT_TRUE(hash_nn(snn1) == hash_nn(nn));
+        EXPECT_TRUE(hash_snn(snn1) == hash_nn(nn));
+        EXPECT_TRUE(hash_nn(snn1) == hash_nn(snn2));
+        EXPECT_TRUE(hash_snn(snn1) == hash_snn(nn));
+    }
+
+    {
+        // not_null -> strict_not_null
+        const int x = 42;
+
+        not_null<const int*> nn{&x};
+
+        const strict_not_null<const int*> snn1{nn};
+        const strict_not_null<const int*> snn2{nn};
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+        strict_helper(nn);
+#endif
+        strict_helper_const(nn);
+
+        EXPECT_TRUE(snn1 == nn);
+        EXPECT_TRUE(snn2 == nn);
+
+        std::hash<strict_not_null<const int*>> hash_snn;
+        std::hash<not_null<const int*>> hash_nn;
+
+        EXPECT_TRUE(hash_nn(snn1) == hash_nn(nn));
+        EXPECT_TRUE(hash_snn(snn1) == hash_nn(nn));
+        EXPECT_TRUE(hash_nn(snn1) == hash_nn(snn2));
+        EXPECT_TRUE(hash_snn(snn1) == hash_snn(nn));
+    }
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        strict_not_null<int*> p{nullptr};
+    }
+#endif
+}
+
+#if defined(__cplusplus) && (__cplusplus >= 201703L)
+
+TEST(strict_notnull_tests, TestStrictNotNullConstructorTypeDeduction)
+{
+    const auto terminateHandler = std::set_terminate([] {
+        std::cerr << "Expected Death. TestStrictNotNullConstructorTypeDeduction";
+        std::abort();
+    });
+    const auto expected = GetExpectedDeathString(terminateHandler);
+
+    {
+        int i = 42;
+
+        strict_not_null x{&i};
+        helper(strict_not_null{&i});
+        helper_const(strict_not_null{&i});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        const int i = 42;
+
+        strict_not_null x{&i};
+#ifdef CONFIRM_COMPILATION_ERRORS
+        helper(strict_not_null{&i});
+#endif
+        helper_const(strict_not_null{&i});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        int i = 42;
+        int* p = &i;
+
+        strict_not_null x{p};
+        helper(strict_not_null{p});
+        helper_const(strict_not_null{p});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        const int i = 42;
+        const int* p = &i;
+
+        strict_not_null x{p};
+#ifdef CONFIRM_COMPILATION_ERRORS
+        helper(strict_not_null{p});
+#endif
+        helper_const(strict_not_null{p});
+
+        EXPECT_TRUE(*x == 42);
+    }
+
+    {
+        auto workaround_macro = []() {
+            int* p1 = nullptr;
+            const strict_not_null x{p1};
+        };
+        EXPECT_DEATH(workaround_macro(), expected);
+    }
+
+    {
+        auto workaround_macro = []() {
+            const int* p1 = nullptr;
+            const strict_not_null x{p1};
+        };
+        EXPECT_DEATH(workaround_macro(), expected);
+    }
+
+    {
+        int* p = nullptr;
+
+        EXPECT_DEATH(helper(strict_not_null{p}), expected);
+        EXPECT_DEATH(helper_const(strict_not_null{p}), expected);
+    }
+
+#ifdef CONFIRM_COMPILATION_ERRORS
+    {
+        strict_not_null x{nullptr};
+        helper(strict_not_null{nullptr});
+        helper_const(strict_not_null{nullptr});
+    }
+#endif
+}
+#endif // #if defined(__cplusplus) && (__cplusplus >= 201703L)

deps/GSL/tests/utils_tests.cpp

@@ -0,0 +1,165 @@
+///////////////////////////////////////////////////////////////////////////////
+//
+// Copyright (c) 2015 Microsoft Corporation. All rights reserved.
+//
+// This code is licensed under the MIT License (MIT).
+//
+// 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.
+//
+///////////////////////////////////////////////////////////////////////////////
+
+#include <gtest/gtest.h>
+
+#include <algorithm>   // for move
+#include <complex>
+#include <cstddef>     // for std::ptrdiff_t
+#include <cstdint>     // for uint32_t, int32_t
+#include <functional>  // for reference_wrapper, _Bind_helper<>::type
+#include <gsl/narrow>  // for narrow, narrowing_error
+#include <gsl/util>    // finally, narrow_cast
+#include <limits>      // for numeric_limits
+#include <type_traits> // for is_same
+
+using namespace gsl;
+
+namespace
+{
+void f(int& i) { i += 1; }
+static int j = 0;
+void g() { j += 1; }
+} // namespace
+
+TEST(utils_tests, sanity_check_for_gsl_index_typedef)
+{
+    static_assert(std::is_same<gsl::index, std::ptrdiff_t>::value,
+                  "gsl::index represents wrong arithmetic type");
+}
+
+TEST(utils_tests, finally_lambda)
+{
+    int i = 0;
+    {
+        auto _ = finally([&]() { f(i); });
+        EXPECT_TRUE(i == 0);
+    }
+    EXPECT_TRUE(i == 1);
+}
+
+TEST(utils_tests, finally_lambda_move)
+{
+    int i = 0;
+    {
+        auto _1 = finally([&]() { f(i); });
+        {
+            auto _2 = std::move(_1);
+            EXPECT_TRUE(i == 0);
+        }
+        EXPECT_TRUE(i == 1);
+        {
+            auto _2 = std::move(_1);
+            EXPECT_TRUE(i == 1);
+        }
+        EXPECT_TRUE(i == 1);
+    }
+    EXPECT_TRUE(i == 1);
+}
+
+TEST(utils_tests, finally_const_lvalue_lambda)
+{
+    int i = 0;
+    {
+        const auto const_lvalue_lambda = [&]() { f(i); };
+        auto _ = finally(const_lvalue_lambda);
+        EXPECT_TRUE(i == 0);
+    }
+    EXPECT_TRUE(i == 1);
+}
+
+TEST(utils_tests, finally_mutable_lvalue_lambda)
+{
+    int i = 0;
+    {
+        auto mutable_lvalue_lambda = [&]() { f(i); };
+        auto _ = finally(mutable_lvalue_lambda);
+        EXPECT_TRUE(i == 0);
+    }
+    EXPECT_TRUE(i == 1);
+}
+
+TEST(utils_tests, finally_function_with_bind)
+{
+    int i = 0;
+    {
+        auto _ = finally([&i] { return f(i); });
+        EXPECT_TRUE(i == 0);
+    }
+    EXPECT_TRUE(i == 1);
+}
+
+TEST(utils_tests, finally_function_ptr)
+{
+    j = 0;
+    {
+        auto _ = finally(&g);
+        EXPECT_TRUE(j == 0);
+    }
+    EXPECT_TRUE(j == 1);
+}
+
+TEST(utils_tests, finally_function)
+{
+    j = 0;
+    {
+        auto _ = finally(g);
+        EXPECT_TRUE(j == 0);
+    }
+    EXPECT_TRUE(j == 1);
+}
+
+TEST(utils_tests, narrow_cast)
+{
+    int n = 120;
+    char c = narrow_cast<char>(n);
+    EXPECT_TRUE(c == 120);
+
+    n = 300;
+    unsigned char uc = narrow_cast<unsigned char>(n);
+    EXPECT_TRUE(uc == 44);
+}
+
+#ifndef GSL_KERNEL_MODE
+TEST(utils_tests, narrow)
+{
+    int n = 120;
+    const char c = narrow<char>(n);
+    EXPECT_TRUE(c == 120);
+
+    n = 300;
+    EXPECT_THROW(narrow<char>(n), narrowing_error);
+
+    const auto int32_max = std::numeric_limits<int32_t>::max();
+    const auto int32_min = std::numeric_limits<int32_t>::min();
+
+    EXPECT_TRUE(narrow<uint32_t>(int32_t(0)) == 0);
+    EXPECT_TRUE(narrow<uint32_t>(int32_t(1)) == 1);
+    EXPECT_TRUE(narrow<uint32_t>(int32_max) == static_cast<uint32_t>(int32_max));
+
+    EXPECT_THROW(narrow<uint32_t>(int32_t(-1)), narrowing_error);
+    EXPECT_THROW(narrow<uint32_t>(int32_min), narrowing_error);
+
+    n = -42;
+    EXPECT_THROW(narrow<unsigned>(n), narrowing_error);
+
+    EXPECT_TRUE(
+        narrow<std::complex<float>>(std::complex<double>(4, 2)) == std::complex<float>(4, 2));
+    EXPECT_THROW(narrow<std::complex<float>>(std::complex<double>(4.2)), narrowing_error);
+
+    EXPECT_TRUE(narrow<int>(float(1)) == 1);
+}
+#endif // GSL_KERNEL_MODE

deps/HDiffPatch

@@ -1 +0,0 @@
-Subproject commit b2555ed6bcd9d6d9baef0609f43b5707e771180a

deps/HDiffPatch/.github/workflows/ci.yml

@@ -0,0 +1,124 @@
+name: ci
+on: [push, pull_request]
+jobs:
+  make-build:
+    strategy:
+      matrix:
+        platform: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v2
+      - name: makeInit
+        run: |
+          make LZMA=0 ZSTD=0 MD5=0 -j
+          make clean
+      - name: makeUnDef
+        run: |
+          git clone --depth=1 https://github.com/sisong/libmd5.git ../libmd5
+          git clone --depth=1 https://github.com/sisong/lzma.git ../lzma
+          git clone --depth=1 https://github.com/sisong/zstd.git ../zstd
+          make DIR_DIFF=0 MT=0 BSD=0 VCD=0 ZLIB=0 BZIP2=0 -j
+          make clean
+      - name: makeAll
+        run: |
+          make -j
+          make clean
+      - name: makeByCode
+        run: |
+          git clone --depth=1 https://github.com/sisong/zlib.git ../zlib
+          git clone --depth=1 https://github.com/sisong/bzip2.git ../bzip2
+          make ZLIB=1 BZIP2=1 -j
+
+  clang-build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: installClang
+        run: |
+          sudo apt-get install -y llvm clang
+      - name: initAndClone
+        run: |
+          git clone --depth=1 https://github.com/sisong/libmd5.git ../libmd5
+          git clone --depth=1 https://github.com/sisong/lzma.git ../lzma
+          git clone --depth=1 https://github.com/sisong/zstd.git ../zstd
+      - name: makeByClang
+        run: |
+          make CL=1 -j
+
+  xcode-build:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: initAndClone
+        run: |
+          git clone --depth=1 https://github.com/sisong/libmd5.git ../libmd5
+          git clone --depth=1 https://github.com/sisong/lzma.git ../lzma
+          git clone --depth=1 https://github.com/sisong/zstd.git ../zstd
+      - name: buildByXcode
+        run: |
+          xcodebuild -workspace builds/xcode/HDiffPatch.xcworkspace -scheme hdiffz -configuration Release OBJROOT=$PWD/bin SYMROOT=$PWD/bin
+          xcodebuild -workspace builds/xcode/HDiffPatch.xcworkspace -scheme hpatchz -configuration Release OBJROOT=$PWD/bin SYMROOT=$PWD/bin
+          xcodebuild -workspace builds/xcode/HDiffPatch.xcworkspace -scheme unitTest -configuration Release OBJROOT=$PWD/bin SYMROOT=$PWD/bin
+
+  macos-ndk-build:
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: nttld/setup-ndk@v1.0.6
+        with:
+          ndk-version: r16b
+      - name: buildByAndroidNDK
+        run: |
+          git clone --depth=1 https://github.com/sisong/lzma.git ../lzma
+          git clone --depth=1 https://github.com/sisong/zstd.git ../zstd
+          cd ./builds/android_ndk_jni_mk
+          ndk-build NDK_PROJECT_PATH=. APP_BUILD_SCRIPT=./Android.mk NDK_APPLICATION_MK=./Application.mk
+
+  windows-ndk-build:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: nttld/setup-ndk@v1.0.6
+        with:
+          ndk-version: r16b
+      - name: buildByAndroidNDK
+        run: |
+          git clone --depth=1 https://github.com/sisong/lzma.git ../lzma
+          git clone --depth=1 https://github.com/sisong/zstd.git ../zstd
+          git clone --depth=1 https://github.com/sisong/bzip2.git ../bzip2
+          cd ./builds/android_ndk_jni_mk
+          ndk-build NDK_PROJECT_PATH=. APP_BUILD_SCRIPT=./Android.mk NDK_APPLICATION_MK=./Application.mk BSD=1 BZIP2=1
+
+  ubuntu-ndk-build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: nttld/setup-ndk@v1.0.6
+        with:
+          ndk-version: r16b
+      - name: buildByAndroidNDK
+        run: |
+          sudo apt install libncurses5
+          git clone --depth=1 https://github.com/sisong/lzma.git ../lzma
+          git clone --depth=1 https://github.com/sisong/bzip2.git ../bzip2
+          git clone --depth=1 https://github.com/sisong/zstd.git ../zstd
+          cd ./builds/android_ndk_jni_mk
+          ndk-build NDK_PROJECT_PATH=. APP_BUILD_SCRIPT=./Android.mk NDK_APPLICATION_MK=./Application.mk BSD=1 BZIP2=1 VCD=1
+
+  vc-build:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: microsoft/setup-msbuild@v1.1
+        with:
+          msbuild-architecture: x64
+      - name: initAndClone
+        run: |
+          git clone --depth=1 https://github.com/sisong/zlib.git ../zlib
+          git clone --depth=1 https://github.com/sisong/bzip2.git ../bzip2
+          git clone --depth=1 https://github.com/sisong/libmd5.git ../libmd5
+          git clone --depth=1 https://github.com/sisong/lzma.git ../lzma
+          git clone --depth=1 https://github.com/sisong/zstd.git ../zstd
+      - name: buildByVC
+        run: |
+          msbuild builds/vc/HDiffPatch.sln -t:rebuild -verbosity:diag -property:Configuration=Release

deps/HDiffPatch/.gitignore

@@ -0,0 +1,23 @@
+.DS_Store
+xcuserdata
+Debug
+Release
+Release_x86
+*.suo
+*.dcu
+*.~*
+*.depend
+*.layout
+*.filters
+*.xccheckout
+*.xcscmblueprint
+*.xcscheme
+*.o
+*.a
+*.exe
+builds/android_ndk_jni_mk/libs
+builds/android_ndk_jni_mk/obj
+builds/vc/ipch/
+*.opensdf
+*.sdf
+*.ipch

deps/HDiffPatch/CHANGELOG.md

@@ -0,0 +1,203 @@
+# HDiffPatch Change Log
+
+full changelog at: https://github.com/sisong/HDiffPatch/commits   
+
+## [v4.6.0](https://github.com/sisong/HDiffPatch/tree/v4.6.0) - 2023-04-20
+### Added
+* add libhsync for diff&patch by sync; see demo [hsynz](https://github.com/sisong/hsynz) (like [zsync](http://zsync.moria.org.uk))
+* add function create_sync_data(),create_dir_sync_data(),sync_patch(),sync_patch_...(),sync_local_diff(),sync_local_diff_...(),sync_local_patch(),sync_local_patch_...()
+
+## [v4.5.0](https://github.com/sisong/HDiffPatch/tree/v4.5.0) - 2022-11-23
+### Added
+* cmdline added option "-VCD[-compressLevel[-dictSize]]", create diffFile compatible with VCDIFF format;
+* cmdline hpatchz support apply VCDIFF format diffFile, created by `$hdiffz -VCD`,`$xdelta3`,`$open-vcdiff`;
+* add function create_vcdiff(),create_vcdiff_stream(), vcpatch_with_cache();
+* cmdline option "-BSD" support run with -s (before only supported -m), to fast create diffFile compatible with bsdiff4;
+* add function create_bsdiff_stream(), same as create_bsdiff(), but can control memory requires and run speed by different kMatchBlockSize value;
+
+## [v4.4.0](https://github.com/sisong/HDiffPatch/tree/v4.4.0) - 2022-10-09
+### Changed
+* optimize diff -m & -s speed by muti-thread parallel, requires C++11.
+
+## [v4.3.0](https://github.com/sisong/HDiffPatch/tree/v4.3.0) - 2022-09-23
+### Changed
+* recode some patch error code: decompresser errors, file error, disk space full error, jni error
+
+## [v4.2.0](https://github.com/sisong/HDiffPatch/tree/v4.2.0) - 2022-05-15
+### Added
+* add function create_lite_diff() & hpatch_lite_open(),hpatch_lite_patch(); optimized hpatch on MCU,NB-IoT... (demo [HPatchLite](https://github.com/sisong/HPatchLite))
+* add compress&decompress plugin tuzCompressPlugin,tuzDecompressPlugin;
+
+## [v4.1.2](https://github.com/sisong/HDiffPatch/tree/v4.1.2) - 2021-12-02
+### Added
+* add Github Actions CI.
+### Removed
+* remove travis-ci.org CI.
+
+## [v4.1.0](https://github.com/sisong/HDiffPatch/tree/v4.1.0) - 2021-11-27
+### Added
+* cmdline add option "-BSD", to create diffFile compatible with bsdiff4;
+* cmdline hpatchz support apply bsdiff4 format diffFile, created by `$hdiffz -BSD`,`$bsdiff`;
+* cmdline add option "-cache", optimize `$hdiffz -m` speed; note:the big cache max used O(oldFileSize) memory, and build slow.
+* cmdline add option "-block", optimize `$hdiffz -m` speed;
+* add function create_bsdiff() & bspatch_with_cache().
+* add function create_single_compressed_diff_block() & create_compressed_diff_block() & create_bsdiff_block().
+
+## [v4.0.0](https://github.com/sisong/HDiffPatch/tree/v4.0.0) - 2021-06-14
+### Added
+* cmdline add option "-SD", to create single compressed diffData, for optimize decompress buffer when patch, and support step by step patching when step by step downloading; it's better for IoT!  NOTE: old patcher can't work with this new format diffData. 
+* the added create_single_compressed_diff()&patch_single_stream() can be used;
+* add create_single_compressed_diff_stream(), same as create_single_compressed_diff(), but can control memory requires and run speed by different kMatchBlockSize value;
+* now, zstd plugin default added in cmdline;
+### Changed
+* check_compressed_diff_stream() rename to check_compressed_diff();
+* patch_single_stream_by() (preview func) rename to patch_single_stream(); 
+* patch_single_stream_by_mem() (preview func) rename to patch_single_stream_mem(); 
+
+## [v3.1.1](https://github.com/sisong/HDiffPatch/tree/v3.1.1) - 2021-04-02
+### Added
+* add compress&decompress plugin brotliCompressPlugin,brotliDecompressPlugin,lzhamCompressPlugin,lzhamDecompressPlugin;
+### Removed
+* remove sais-lite("sais.hxx") from suffix string sort (still can select divsufsort or std::sort)
+
+## [v3.1.0](https://github.com/sisong/HDiffPatch/tree/v3.1.0) - 2020-12-16
+### Added
+* add a memory cache for patch to newStream, can reduce write I/O times;
+* add create_single_compressed_diff()&patch_single_compressed_diff(), for v4.0, preview;
+### Removed
+* cmdline remove option "-o", no Original diff, you can continue to call patch()|patch_stream() by yourself;  
+* remove patch_decompress_repeat_out(), you need use patch_decompress*() to replace it;
+
+## [v3.0.8](https://github.com/sisong/HDiffPatch/tree/v3.0.8) - 2020-01-01
+### Added
+* patch demo for Android, out lib file libhpatchz.so;
+
+## [v3.0.7](https://github.com/sisong/HDiffPatch/tree/v3.0.7) - 2019-12-19
+### Fixed
+* fix a bug when create dir's manifest file without checksum (`$hdiffz -C-no -M...`);
+* fix a bug when create dir's manifest file on windows operating system;
+
+## [v3.0.6](https://github.com/sisong/HDiffPatch/tree/v3.0.6) - 2019-09-18
+### Fixed
+* fix a patch bug when old file size >=4GB and patch with large cache memory and run as 32bit app;
+
+## [v3.0.5](https://github.com/sisong/HDiffPatch/tree/v3.0.5) - 2019-09-18
+### Fixed
+* fix a directory patch bug when changed file's sumSize >=4GB and run as 32bit app;
+
+## [v3.0.4](https://github.com/sisong/HDiffPatch/tree/v3.0.4) - 2019-09-06
+### Fixed
+* fix dir_patch can't remove some files bug when patch to same dir on Windows operating system;
+
+## [v3.0.0](https://github.com/sisong/HDiffPatch/tree/v3.0.0) - 2019-03-01
+### Added
+* hdiffz,hpatchz command line support diff&patch between directories(folder);
+* support checksum plugin: crc32ChecksumPlugin,adler32ChecksumPlugin,adler64ChecksumPlugin,fadler32ChecksumPlugin,fadler64ChecksumPlugin,fadler128ChecksumPlugin,md5ChecksumPlugin ;
+* lzmaCompressPlugin support parallel compress;
+* add parallel compress plugin: pzlibCompressPlugin,pbz2CompressPlugin,lzma2CompressPlugin
+* command line support SFX(self extract archive);
+
+## [v2.5.3](https://github.com/sisong/HDiffPatch/tree/v2.5.3) - 2018-12-25
+### Fixed
+* fix a bug when cancel LzmaEnc_Encode in lzmaCompressPlugin when diff;
+
+## [v2.5.0](https://github.com/sisong/HDiffPatch/tree/v2.5.0) - 2018-12-01
+### Added
+* resave_compressed_diff(...) support resave diffFile with new compress type;
+
+## [v2.4.2](https://github.com/sisong/HDiffPatch/tree/v2.4.2) - 2018-11-06
+### Added
+* add CI(ci.appveyor.com) for this repository;
+
+## [v2.4.1](https://github.com/sisong/HDiffPatch/tree/v2.4.1) - 2018-08-14
+### Fixed
+* fix a memory bug in zlibCompressPlugin when diff;
+### Added
+* add CI(travis-ci.org) for this repository;
+
+## [v2.4](https://github.com/sisong/HDiffPatch/tree/v2.4) - 2018-04-26
+### Changed
+* improve hdiffz,hpatchz command line;
+
+## [v2.3](https://github.com/sisong/HDiffPatch/tree/v2.3) - 2018-03-21
+### Added
+* hpatch_coverList_open_serializedDiff(...),hpatch_coverList_open_compressedDiff(...) support open diffFile read coverList;
+
+## [v2.2.2](https://github.com/sisong/HDiffPatch/tree/v2.2.2) - 2017-09-10
+### Changed
+* optimize patch_stream_with_cache(...) speed when patch with large cache memory;
+
+## [v2.2.1](https://github.com/sisong/HDiffPatch/tree/v2.2.1) - 2017-09-06
+### Added
+* add compress&decompress plugin lz4hcCompressPlugin,zstdCompressPlugin,zstdDecompressPlugin;
+
+## [v2.2.0](https://github.com/sisong/HDiffPatch/tree/v2.2.0) - 2017-09-02
+### Changed
+* optimize patch_decompress_with_cache(...) speed when patch with large cache memory;
+
+## [v2.1.1](https://github.com/sisong/HDiffPatch/tree/v2.1.1) - 2017-08-23
+### Added
+* add compress&decompress plugin lz4CompressPlugin,lz4DecompressPlugin;
+
+## [v2.1.0](https://github.com/sisong/HDiffPatch/tree/v2.1.0) - 2017-08-22
+### Added
+* create_compressed_diff_stream(...), same as create_compressed_diff(...), but can control memory requires and run speed by different kMatchBlockSize value;
+* add performance test, compare with xdelta3.1;
+
+## [v2.0.3](https://github.com/sisong/HDiffPatch/tree/v2.0.3) - 2017-08-05
+### Added
+* patch_decompress_with_cache(...), same as patch_decompress(...), but support set cache memory size for optimize patch speed;
+* patch_stream_with_cache(...), same as patch_stream(...), but support set cache memory size for optimize patch speed;
+
+
+## [v2.0.0](https://github.com/sisong/HDiffPatch/tree/v2.0.0) - 2017-07-29
+### Added
+* create_compressed_diff(...) support create compressed differential;
+* add compress plugin zlibCompressPlugin, bz2CompressPlugin, lzmaCompressPlugin;
+* patch_decompress(...) support patch apply compressed differential;
+* add decompress plugin zlibDecompressPlugin, bz2DecompressPlugin, lzmaDecompressPlugin;
+
+## [v1.2.0](https://github.com/sisong/HDiffPatch/tree/v1.2.0) - 2017-07-02
+### Changed
+* optimize diff speed;
+
+## [v1.1.4](https://github.com/sisong/HDiffPatch/tree/v1.1.4) - 2017-06-10
+### Added
+* add MakeFile for support make; by author [JayXon](https://github.com/JayXon);
+### Changed
+* slightly optimize diff required memory size;
+
+## [v1.1.3](https://github.com/sisong/HDiffPatch/tree/v1.1.3) - 2017-01-01
+### Changed
+* used divsufsort (still can select sais or std::sort) for suffix string sort;
+
+## [v1.1.2](https://github.com/sisong/HDiffPatch/tree/v1.1.2) - 2016-09-01
+### Fixed
+* fix a bug when write out diffFile on Windows operating system; by author [Wenhai Lin](https://github.com/WenhaiLin);
+
+## [v1.1.0](https://github.com/sisong/HDiffPatch/tree/v1.1.0) - 2014-09-13
+### Added
+* patch_stream(...), same as patch(...) but used O(1) bytes of memory;
+
+## [v1.0.6](https://github.com/sisong/HDiffPatch/tree/v1.0.6) - 2014-09-07
+### Changed
+* Diff&Patch support big datas(>2GB, int32 to int64) on 64bit operating system;
+
+## [v1.0.2](https://github.com/sisong/HDiffPatch/tree/v1.0.2) - 2013-08-03
+### Changed
+* optimize diff speed with two unrelated data;
+
+## [v1.0.1](https://github.com/sisong/HDiffPatch/tree/v1.0.1) - 2013-08-02
+### Fixed
+* fix diff fail between two equal datas;
+
+## [v1.0.0](https://github.com/sisong/HDiffPatch/tree/v1.0.0) - 2013-06-06
+### Added
+* add Readme file; 
+* performance test, compare with BSDiff4.3;
+
+## [Init Release](https://github.com/sisong/HDiffPatch/commit/6d71005c65e1713a8f0c02f9fd2eced32940b4c2) - 2013-05-30
+### Init Release, MIT copyright;
+* create_diff(...) support create differential between two memory datas(src->dst bytes);
+* patch(...) support apply differential for update src bytes to dst bytes;
+* demo app for diff&patch between two files;

deps/HDiffPatch/LICENSE

@@ -0,0 +1,48 @@
+MIT License
+
+HDiffPatch
+Copyright (c) 2012-2023 housisong
+
+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.
+
+----------------------------------------------------------------------------------
+
+libdivsufsort
+Copyright (c) 2003-2008 Yuta Mori All Rights Reserved.
+
+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.

deps/HDiffPatch/Makefile

@@ -0,0 +1,367 @@
+# args
+DIR_DIFF := 1
+MT       := 1
+# 0: not need zlib;  1: compile zlib source code;  2: used -lz to link zlib lib;
+ZLIB     := 2
+LZMA     := 1
+ARM64ASM := 0
+# 0: not need zstd;  1: compile zstd source code;  2: used -lzstd to link zstd lib;
+ZSTD     := 1
+MD5      := 1
+STATIC_CPP := 0
+# used clang?
+CL  	 := 0
+# build with -m32?
+M32      := 0
+# build for out min size
+MINS     := 0
+# support VCDIFF? 
+VCD      := 1
+# support bsdiff&bspatch?
+BSD      := 1
+ifeq ($(OS),Windows_NT) # mingw?
+  CC    := gcc
+  BZIP2 := 1
+else
+  # 0: not need bzip2 (must BSD=0);  1: compile bzip2 source code;  2: used -lbz2 to link bzip2 lib;
+  BZIP2 := 2
+endif
+ifeq ($(BZIP2),0)
+  ifeq ($(BSD),0)
+  else
+  $(error error: support bsdiff need BZIP2! set BSD=0 continue)
+  endif
+endif
+
+HDIFF_OBJ  := 
+HPATCH_OBJ := \
+    libHDiffPatch/HPatch/patch.o \
+    file_for_patch.o
+
+ifeq ($(DIR_DIFF),0)
+else
+  HPATCH_OBJ += \
+    dirDiffPatch/dir_patch/dir_patch.o \
+    dirDiffPatch/dir_patch/res_handle_limit.o \
+    dirDiffPatch/dir_patch/ref_stream.o \
+    dirDiffPatch/dir_patch/new_stream.o \
+    dirDiffPatch/dir_patch/dir_patch_tools.o \
+    dirDiffPatch/dir_patch/new_dir_output.o \
+    libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.o
+endif
+
+ifeq ($(BSD),0)
+else
+	HPATCH_OBJ += bsdiff_wrapper/bspatch_wrapper.o
+endif
+
+MD5_PATH := ../libmd5
+ifeq ($(DIR_DIFF),0)
+else
+  ifeq ($(MD5),0)
+  else # https://sourceforge.net/projects/libmd5-rfc  https://github.com/sisong/libmd5
+	HPATCH_OBJ += $(MD5_PATH)/md5.o
+  endif
+endif
+
+LZMA_PATH := ../lzma/C
+ifeq ($(LZMA),0)
+else # https://www.7-zip.org  https://github.com/sisong/lzma
+  HPATCH_OBJ += $(LZMA_PATH)/LzmaDec.o \
+  				$(LZMA_PATH)/Lzma2Dec.o \
+  				$(LZMA_PATH)/CpuArch.o \
+  				$(LZMA_PATH)/Alloc.o
+  ifeq ($(ARM64ASM),0)
+  else
+  	HPATCH_OBJ += $(LZMA_PATH)/../Asm/arm64/LzmaDecOpt.o
+  endif
+  ifeq ($(MT),0)  
+  else  
+    HPATCH_OBJ+=$(LZMA_PATH)/MtDec.o \
+				$(LZMA_PATH)/Threads.o
+  endif
+  HDIFF_OBJ  += $(LZMA_PATH)/LzFind.o \
+  				$(LZMA_PATH)/LzFindOpt.o \
+  				$(LZMA_PATH)/LzmaEnc.o \
+				$(LZMA_PATH)/Lzma2Enc.o  
+  ifeq ($(MT),0)  
+  else  
+    HDIFF_OBJ+= $(LZMA_PATH)/LzFindMt.o \
+  				$(LZMA_PATH)/MtCoder.o
+  endif
+endif
+ifeq ($(VCD),0)
+else
+  HPATCH_OBJ += vcdiff_wrapper/vcpatch_wrapper.o
+  HDIFF_OBJ  += vcdiff_wrapper/vcdiff_wrapper.o
+  ifeq ($(LZMA),0)
+  else
+	HPATCH_OBJ+=$(LZMA_PATH)/7zCrc.o \
+				$(LZMA_PATH)/7zCrcOpt.o \
+				$(LZMA_PATH)/Bra.o \
+				$(LZMA_PATH)/Bra86.o \
+				$(LZMA_PATH)/BraIA64.o \
+				$(LZMA_PATH)/Delta.o \
+				$(LZMA_PATH)/Sha256.o \
+				$(LZMA_PATH)/Sha256Opt.o \
+				$(LZMA_PATH)/Xz.o \
+				$(LZMA_PATH)/XzCrc64.o \
+				$(LZMA_PATH)/XzCrc64Opt.o \
+				$(LZMA_PATH)/XzDec.o
+	HDIFF_OBJ +=$(LZMA_PATH)/XzEnc.o
+  endif
+endif
+
+ZSTD_PATH := ../zstd/lib
+ifeq ($(ZSTD),1) # https://github.com/sisong/zstd
+  HPATCH_OBJ += $(ZSTD_PATH)/common/debug.o \
+  				$(ZSTD_PATH)/common/entropy_common.o \
+  				$(ZSTD_PATH)/common/error_private.o \
+  				$(ZSTD_PATH)/common/fse_decompress.o \
+  				$(ZSTD_PATH)/common/xxhash.o \
+  				$(ZSTD_PATH)/common/zstd_common.o \
+  				$(ZSTD_PATH)/decompress/huf_decompress.o \
+  				$(ZSTD_PATH)/decompress/zstd_ddict.o \
+  				$(ZSTD_PATH)/decompress/zstd_decompress.o \
+  				$(ZSTD_PATH)/decompress/zstd_decompress_block.o
+  HDIFF_OBJ  += $(ZSTD_PATH)/compress/fse_compress.o \
+  				$(ZSTD_PATH)/compress/hist.o \
+  				$(ZSTD_PATH)/compress/huf_compress.o \
+  				$(ZSTD_PATH)/compress/zstd_compress.o \
+  				$(ZSTD_PATH)/compress/zstd_compress_literals.o \
+  				$(ZSTD_PATH)/compress/zstd_compress_sequences.o \
+  				$(ZSTD_PATH)/compress/zstd_compress_superblock.o \
+  				$(ZSTD_PATH)/compress/zstd_double_fast.o \
+  				$(ZSTD_PATH)/compress/zstd_fast.o \
+  				$(ZSTD_PATH)/compress/zstd_lazy.o \
+  				$(ZSTD_PATH)/compress/zstd_ldm.o \
+  				$(ZSTD_PATH)/compress/zstd_opt.o
+  ifeq ($(MT),0)
+  else  
+    HDIFF_OBJ+= $(ZSTD_PATH)/common/pool.o \
+				$(ZSTD_PATH)/common/threading.o \
+				$(ZSTD_PATH)/compress/zstdmt_compress.o
+  endif
+endif
+
+BZ2_PATH := ../bzip2
+ifeq ($(BZIP2),1) # http://www.bzip.org  https://github.com/sisong/bzip2
+  HPATCH_OBJ += $(BZ2_PATH)/blocksort.o \
+  				$(BZ2_PATH)/bzlib.o \
+  				$(BZ2_PATH)/compress.o \
+  				$(BZ2_PATH)/crctable.o \
+  				$(BZ2_PATH)/decompress.o \
+  				$(BZ2_PATH)/huffman.o \
+  				$(BZ2_PATH)/randtable.o
+endif
+
+ZLIB_PATH := ../zlib
+ifeq ($(ZLIB),1) # http://zlib.net  https://github.com/sisong/zlib  
+  HPATCH_OBJ += $(ZLIB_PATH)/adler32.o \
+  				$(ZLIB_PATH)/crc32.o \
+  				$(ZLIB_PATH)/inffast.o \
+  				$(ZLIB_PATH)/inflate.o \
+  				$(ZLIB_PATH)/inftrees.o \
+  				$(ZLIB_PATH)/trees.o \
+  				$(ZLIB_PATH)/zutil.o
+  HDIFF_OBJ +=  $(ZLIB_PATH)/deflate.o
+endif
+
+HDIFF_OBJ += \
+    hdiffz_import_patch.o \
+    libHDiffPatch/HPatchLite/hpatch_lite.o \
+    libHDiffPatch/HDiff/diff.o \
+    libHDiffPatch/HDiff/match_block.o \
+    libHDiffPatch/HDiff/private_diff/bytes_rle.o \
+    libHDiffPatch/HDiff/private_diff/suffix_string.o \
+    libHDiffPatch/HDiff/private_diff/compress_detect.o \
+    libHDiffPatch/HDiff/private_diff/limit_mem_diff/digest_matcher.o \
+    libHDiffPatch/HDiff/private_diff/limit_mem_diff/stream_serialize.o \
+    libHDiffPatch/HDiff/private_diff/libdivsufsort/divsufsort64.o \
+    libHDiffPatch/HDiff/private_diff/libdivsufsort/divsufsort.o \
+    $(HPATCH_OBJ)
+ifeq ($(DIR_DIFF),0)
+  HDIFF_OBJ += libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.o
+endif
+
+ifeq ($(DIR_DIFF),0)
+else
+  HDIFF_OBJ += \
+    dirDiffPatch/dir_diff/dir_diff.o \
+    dirDiffPatch/dir_diff/dir_diff_tools.o \
+    dirDiffPatch/dir_diff/dir_manifest.o
+endif
+ifeq ($(BSD),0)
+else
+	HDIFF_OBJ += bsdiff_wrapper/bsdiff_wrapper.o
+endif
+ifeq ($(MT),0)
+else
+  HDIFF_OBJ += \
+    libParallel/parallel_import.o \
+    libParallel/parallel_channel.o \
+    compress_parallel.o
+endif
+
+
+DEF_FLAGS := \
+    -O3 -DNDEBUG -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 \
+    -D_IS_NEED_ALL_CompressPlugin=0 \
+    -D_IS_NEED_DEFAULT_CompressPlugin=0 \
+    -D_IS_NEED_ALL_ChecksumPlugin=0 \
+    -D_IS_NEED_DEFAULT_ChecksumPlugin=0 
+ifeq ($(M32),0)
+else
+  DEF_FLAGS += -m32
+endif
+ifeq ($(MINS),0)
+else
+  DEF_FLAGS += \
+    -s \
+    -Wno-error=format-security \
+    -fvisibility=hidden  \
+    -ffunction-sections -fdata-sections \
+    -ffat-lto-objects -flto
+  CXXFLAGS += -fvisibility-inlines-hidden
+endif
+
+ifeq ($(BZIP2),0)
+else
+    DEF_FLAGS += -D_CompressPlugin_bz2
+	ifeq ($(BZIP2),1)
+        DEF_FLAGS += -I$(BZ2_PATH)
+	endif
+endif
+ifeq ($(ZLIB),0)
+else
+    DEF_FLAGS += -D_CompressPlugin_zlib
+	ifeq ($(ZLIB),1)
+        DEF_FLAGS += -I$(ZLIB_PATH)
+	endif
+endif
+ifeq ($(DIR_DIFF),0)
+  DEF_FLAGS += -D_IS_NEED_DIR_DIFF_PATCH=0
+else
+  DEF_FLAGS += \
+    -D_IS_NEED_DIR_DIFF_PATCH=1 \
+    -D_ChecksumPlugin_fadler64
+  ifeq ($(ZLIB),0)
+  else
+    DEF_FLAGS += -D_ChecksumPlugin_crc32
+  endif
+  ifeq ($(MD5),0)
+  else
+    DEF_FLAGS += -D_ChecksumPlugin_md5 -I$(MD5_PATH)
+  endif
+endif
+ifeq ($(BSD),0)
+	DEF_FLAGS += -D_IS_NEED_BSDIFF=0
+else
+	DEF_FLAGS += -D_IS_NEED_BSDIFF=1
+endif
+ifeq ($(VCD),0)
+	DEF_FLAGS += -D_IS_NEED_VCDIFF=0
+else
+	DEF_FLAGS += -D_IS_NEED_VCDIFF=1
+endif
+ifeq ($(LZMA),0)
+else
+  DEF_FLAGS += -D_CompressPlugin_lzma -D_CompressPlugin_lzma2 -I$(LZMA_PATH)
+  ifeq ($(VCD),0)
+  else
+    DEF_FLAGS += -D_CompressPlugin_7zXZ -DUSE_CRC_EMU
+  endif
+  ifeq ($(ARM64ASM),0)
+  else
+    DEF_FLAGS += -D_LZMA_DEC_OPT
+  endif
+endif
+ifeq ($(ZSTD),0)
+else
+    DEF_FLAGS += -D_CompressPlugin_zstd
+	ifeq ($(ZSTD),1)
+      DEF_FLAGS += -DZSTD_HAVE_WEAK_SYMBOLS=0 -DZSTD_TRACE=0 -DZSTD_DISABLE_ASM=1 -DZSTDLIB_VISIBLE= -DZSTDLIB_HIDDEN= \
+	    -I$(ZSTD_PATH) -I$(ZSTD_PATH)/common -I$(ZSTD_PATH)/compress -I$(ZSTD_PATH)/decompress
+	endif
+endif
+
+ifeq ($(MT),0)
+  DEF_FLAGS += \
+    -D_7ZIP_ST \
+    -D_IS_USED_MULTITHREAD=0
+else
+  DEF_FLAGS += \
+    -DZSTD_MULTITHREAD=1 \
+    -D_IS_USED_MULTITHREAD=1 \
+    -D_IS_USED_PTHREAD=1
+endif
+
+PATCH_LINK := 
+ifeq ($(ZLIB),2)
+  PATCH_LINK += -lz			# link zlib
+endif
+ifeq ($(BZIP2),2)
+  PATCH_LINK += -lbz2		# link bzip2
+endif
+ifeq ($(ZSTD),2)
+  PATCH_LINK += -lzstd		# link zstd
+endif
+ifeq ($(MT),0)
+else
+  PATCH_LINK += -lpthread	# link pthread
+endif
+DIFF_LINK  := $(PATCH_LINK)
+ifeq ($(M32),0)
+else
+  DIFF_LINK += -m32
+endif
+ifeq ($(MINS),0)
+else
+  DIFF_LINK += -Wl,--gc-sections,--as-needed
+endif
+ifeq ($(CL),1)
+  CXX := clang++
+  CC  := clang
+endif
+ifeq ($(STATIC_CPP),0)
+  DIFF_LINK += -lstdc++
+else
+  DIFF_LINK += -static-libstdc++
+endif
+
+CFLAGS   += $(DEF_FLAGS) 
+CXXFLAGS += $(DEF_FLAGS) -std=c++11
+
+.PHONY: all install clean
+
+all: libhdiffpatch.a hpatchz hdiffz mostlyclean
+
+libhdiffpatch.a: $(HDIFF_OBJ)
+	$(AR) rcs $@ $^
+
+hpatchz: $(HPATCH_OBJ)
+	$(CC) hpatchz.c $(HPATCH_OBJ) $(CFLAGS) $(PATCH_LINK) -o hpatchz
+hdiffz: libhdiffpatch.a
+	$(CXX) hdiffz.cpp libhdiffpatch.a $(CXXFLAGS) $(DIFF_LINK) -o hdiffz
+
+ifeq ($(OS),Windows_NT) # mingw?
+  RM := del /Q /F
+  DEL_HDIFF_OBJ := $(subst /,\,$(HDIFF_OBJ))
+else
+  RM := rm -f
+  DEL_HDIFF_OBJ := $(HDIFF_OBJ)
+endif
+INSTALL_X := install -m 0755
+INSTALL_BIN := $(DESTDIR)/usr/local/bin
+
+mostlyclean: hpatchz hdiffz
+	$(RM) $(DEL_HDIFF_OBJ)
+clean:
+	$(RM) libhdiffpatch.a hpatchz hdiffz $(DEL_HDIFF_OBJ)
+
+install: all
+	$(INSTALL_X) hdiffz $(INSTALL_BIN)/hdiffz
+	$(INSTALL_X) hpatchz $(INSTALL_BIN)/hpatchz
+
+uninstall:
+	$(RM)  $(INSTALL_BIN)/hdiffz  $(INSTALL_BIN)/hpatchz

deps/HDiffPatch/README.md

@@ -0,0 +1,489 @@
+# [HDiffPatch](https://github.com/sisong/HDiffPatch)
+[![release](https://img.shields.io/badge/release-v4.6.3-blue.svg)](https://github.com/sisong/HDiffPatch/releases) 
+[![license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/sisong/HDiffPatch/blob/master/LICENSE) 
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-blue.svg)](https://github.com/sisong/HDiffPatch/pulls)
+[![+issue Welcome](https://img.shields.io/github/issues-raw/sisong/HDiffPatch?color=green&label=%2Bissue%20welcome)](https://github.com/sisong/HDiffPatch/issues)   
+
+[![Build Status](https://github.com/sisong/HDiffPatch/workflows/ci/badge.svg?branch=master)](https://github.com/sisong/HDiffPatch/actions?query=workflow%3Aci+branch%3Amaster)
+[![Build status](https://ci.appveyor.com/api/projects/status/t9ow8dft8lt898cv/branch/master?svg=true)](https://ci.appveyor.com/project/sisong/hdiffpatch/branch/master)   
+
+a C\C++ library and command-line tools for Diff & Patch between binary files or directories(folder); cross-platform; runs fast; create small delta/differential; support large files and limit memory requires when diff & patch.   
+
+HDiffPatch defines its own patch file format, this lib is also compatible with the [bsdiff4](https://daemonology.net/bsdiff) patch format and partially compatible with the [open-vcdiff](https://github.com/google/open-vcdiff) and [xdelta3](https://github.com/jmacd/xdelta) patch file format VCDIFF(RFC 3284).
+   
+if need patch (OTA) on embedded systems,MCU,NB-IoT..., see demo [HPatchLite](https://github.com/sisong/HPatchLite) (+ [tinyuz](https://github.com/sisong/tinyuz)), can run on 1KB RAM devices!   
+
+update your own Android Apk? Jar or Zip file diff & patch? try [ApkDiffPatch](https://github.com/sisong/ApkDiffPatch), to create smaller delta/differential! NOTE: *ApkDiffPath can't be used by Android app store, because it requires re-signing apks before diff.*   
+
+[sfpatcher](https://github.com/sisong/sfpatcher) not require re-signing apks (like [archive-patcher](https://github.com/google/archive-patcher)), is designed for Android app store, patch speed up by a factor of xx than archive-patcher & run with O(1) memory.   
+
+if you not have the old versions(too many or not obtain or have been modified), thus cannot create the delta in advance. you can see demo [hsynz](https://github.com/sisong/hsynz) (like [zsync](http://zsync.moria.org.uk)), the new version is only need released once and the owners of the old version get the information about the new version and do the diff&patch themselves. hsynz support zstd compressor & run faster than zsync.
+   
+NOTE: *This library does not deal with file metadata, such as file last wirte time, permissions, link file, etc... To this library, a file is just as a stream of bytes; You can extend this library or use other tools.*   
+   
+---
+## Releases/Binaries
+[Download from latest release](https://github.com/sisong/HDiffPatch/releases) : Command line app for Windows, Linux, MacOS; and .so patch lib for Android.     
+( release files build by projects in path `HDiffPatch/builds` )   
+use cmdline to create a delta:   
+`$hdiffz -m-6 -SD -c-zstd-21-24 -d oldPath newPath outDiffFile`   
+if file'size is very large, try changing `-m-6` to `-s-64`   
+apply the delta:   
+`$hpatchz oldPath diffFile outNewPath`   
+
+## Build it yourself
+`$ cd <dir>/HDiffPatch`   
+### Linux or MacOS X ###
+Try:   
+`$ make LZMA=0 ZSTD=0 MD5=0`   
+bzip2 : if the build fails with `fatal error: bzlib.h: No such file or directory`, use your system's package manager to install the libbz2 package and try again.   install bzip2: `$ apt-get install libbz2` or `$ sudo apt-get install libbz2-dev` or `$ yum -y install bzip2` or `$ brew install bzip2` ...   
+Alternatively, get the optional library headers (+bzip2 library) and build completely: `$ git clone https://github.com/sisong/bzip2.git ../bzip2 && pushd ../bzip2 && make && sudo make install && popd`   
+   
+if need lzma zstd md5 support, Try:    
+```
+$ git clone https://github.com/sisong/libmd5.git ../libmd5
+$ git clone https://github.com/sisong/lzma.git ../lzma
+$ git clone https://github.com/sisong/zstd.git ../zstd
+$ make
+```    
+Tip: You can use `$ make -j` to compile in parallel.
+   
+### Windows ###
+Before you build `builds/vc/HDiffPatch.sln` by [`Visual Studio`](https://visualstudio.microsoft.com), first get the libraries into sibling folders, like so: 
+```
+$ git clone https://github.com/sisong/libmd5.git ../libmd5
+$ git clone https://github.com/sisong/lzma.git ../lzma
+$ git clone https://github.com/sisong/zstd.git ../zstd
+$ git clone https://github.com/sisong/zlib.git   ../zlib
+$ git clone https://github.com/sisong/bzip2.git  ../bzip2
+```
+   
+### libhpatchz.so for Android ###   
+* install [Android NDK](https://developer.android.google.cn/ndk/downloads)
+* `$ cd <dir>/HDiffPatch/builds/android_ndk_jni_mk`
+* `$ build_libs.sh`  (or `$ build_libs.bat` on windows, then got \*.so files)
+* import file `com/github/sisong/HPatch.java` (from `HDiffPatch/builds/android_ndk_jni_mk/java/`) & .so files, java code can call the patch function in libhpatchz.so
+   
+
+---
+### command line usage Chinese version: [命令行使用说明中文版](README_cmdline_cn.md)
+   
+## **diff** command line usage:   
+diff     usage: **hdiffz** [options] **oldPath newPath outDiffFile**   
+compress usage: **hdiffz** [-c-...]  **"" newPath outDiffFile**   
+test    usage: **hdiffz**    -t     **oldPath newPath testDiffFile**   
+resave  usage: **hdiffz** [-c-...]  **diffFile outDiffFile**   
+get  manifest: **hdiffz** [-g#...] [-C-checksumType] **inputPath -M#outManifestTxtFile**   
+manifest diff: **hdiffz** [options] **-M-old#oldManifestFile -M-new#newManifestFile oldPath newPath outDiffFile**   
+```
+  oldPath newPath inputPath can be file or directory(folder),
+  oldPath can empty, and input parameter ""
+memory options:
+  -m[-matchScore]
+      DEFAULT; all file load into Memory; best diffFileSize;
+      requires (newFileSize+ oldFileSize*5(or *9 when oldFileSize>=2GB))+O(1)
+        bytes of memory;
+      matchScore>=0, DEFAULT -m-6, recommended bin: 0--4 text: 4--9 etc...
+  -s[-matchBlockSize]
+      all file load as Stream; fast;
+      requires O(oldFileSize*16/matchBlockSize+matchBlockSize*5*parallelThreadNumber)bytes of memory;
+      matchBlockSize>=4, DEFAULT -s-64, recommended 16,32,48,1k,64k,1m etc...
+special options:
+  -block-fastMatchBlockSize
+      must run with -m;
+      set block match befor slow byte-by-byte match, DEFAULT -block-4k;
+      if set -block-0, means don't use block match;
+      fastMatchBlockSize>=4, recommended 256,1k,64k,1m etc...
+      if newData similar to oldData then diff speed++ & diff memory--,
+      but small possibility outDiffFile's size+
+  -cache
+      must run with -m;
+      set is use a big cache for slow match, DEFAULT false;
+      if newData not similar to oldData then diff speed++,
+      big cache max used O(oldFileSize) memory, and build slow(diff speed--)
+  -SD[-stepSize]
+      create single compressed diffData, only need one decompress buffer
+      when patch, and support step by step patching when step by step downloading!
+      stepSize>=(1024*4), DEFAULT -SD-256k, recommended 64k,2m etc...
+  -BSD
+      create diffFile compatible with bsdiff4, unsupport input directory(folder).
+  -VCD[-compressLevel[-dictSize]]
+      create diffFile compatible with VCDIFF, unsupport input directory(folder).
+      DEFAULT no compress, out format same as $open-vcdiff delta ... or $xdelta3 -S -e -n ...
+      if set compressLevel, out format same as $xdelta3 -S lzma -e -n ...
+      compress by 7zXZ(xz), compressLevel in {0..9}, DEFAULT level 7;
+      dictSize can like 4096 or 4k or 4m or 16m etc..., DEFAULT 8m
+      support compress by multi-thread parallel.
+      NOTE: out diffFile used large source window size!
+  -p-parallelThreadNumber
+      if parallelThreadNumber>1 then open multi-thread Parallel mode;
+      DEFAULT -p-4; requires more memory!
+  -p-search-searchThreadNumber
+      must run with -s[-matchBlockSize];
+      DEFAULT searchThreadNumber same as parallelThreadNumber;
+      but multi-thread search need frequent random disk reads when matchBlockSize
+      is small, so some times multi-thread maybe much slower than single-thread!
+      if (searchThreadNumber<=1) then to close multi-thread search mode.
+  -c-compressType[-compressLevel]
+      set outDiffFile Compress type, DEFAULT uncompress;
+      for resave diffFile,recompress diffFile to outDiffFile by new set;
+      support compress type & level & dict:
+        -c-zlib[-{1..9}[-dictBits]]     DEFAULT level 9
+            dictBits can 9--15, DEFAULT 15.
+            support run by multi-thread parallel, fast!
+        -c-bzip2[-{1..9}]               (or -bz2) DEFAULT level 9
+        -c-pbzip2[-{1..9}]              (or -pbz2) DEFAULT level 8
+            support run by multi-thread parallel, fast!
+            WARNING: code not compatible with it compressed by -c-bzip2!
+               and code size may be larger than if it compressed by -c-bzip2.
+        -c-lzma[-{0..9}[-dictSize]]     DEFAULT level 7
+            dictSize can like 4096 or 4k or 4m or 128m etc..., DEFAULT 8m
+            support run by 2-thread parallel.
+        -c-lzma2[-{0..9}[-dictSize]]    DEFAULT level 7
+            dictSize can like 4096 or 4k or 4m or 128m etc..., DEFAULT 8m
+            support run by multi-thread parallel, fast!
+            WARNING: code not compatible with it compressed by -c-lzma!
+        -c-zstd[-{0..22}[-dictBits]]    DEFAULT level 20
+            dictBits can 10--31, DEFAULT 23.
+            support run by multi-thread parallel, fast!
+  -C-checksumType
+      set outDiffFile Checksum type for directory diff, DEFAULT -C-fadler64;
+      support checksum type:
+        -C-no                   no checksum
+        -C-crc32
+        -C-fadler64             DEFAULT
+        -C-md5
+  -n-maxOpenFileNumber
+      limit Number of open files at same time when stream directory diff;
+      maxOpenFileNumber>=8, DEFAULT -n-48, the best limit value by different
+        operating system.
+  -g#ignorePath[#ignorePath#...]
+      set iGnore path list when Directory Diff; ignore path list such as:
+        #.DS_Store#desktop.ini#*thumbs*.db#.git*#.svn/#cache_*/00*11/*.tmp
+      # means separator between names; (if char # in name, need write #: )
+      * means can match any chars in name; (if char * in name, need write *: );
+      / at the end of name means must match directory;
+  -g-old#ignorePath[#ignorePath#...]
+      set iGnore path list in oldPath when Directory Diff;
+      if oldFile can be changed, need add it in old ignore list;
+  -g-new#ignorePath[#ignorePath#...]
+      set iGnore path list in newPath when Directory Diff;
+      in general, new ignore list should is empty;
+  -M#outManifestTxtFile
+      create a Manifest file for inputPath; it is a text file, saved infos of
+      all files and directoriy list in inputPath; this file while be used in
+      manifest diff, support re-checksum data by manifest diff;
+      can be used to protect historical versions be modified!
+  -M-old#oldManifestFile
+      oldManifestFile is created from oldPath; if no oldPath not need -M-old;
+  -M-new#newManifestFile
+      newManifestFile is created from newPath;
+  -D  force run Directory diff between two files; DEFAULT (no -D) run
+      directory diff need oldPath or newPath is directory.
+  -d  Diff only, do't run patch check, DEFAULT run patch check.
+  -t  Test only, run patch check, patch(oldPath,testDiffFile)==newPath ?
+  -f  Force overwrite, ignore write path already exists;
+      DEFAULT (no -f) not overwrite and then return error;
+      if used -f and write path is exist directory, will always return error.
+  --patch
+      swap to hpatchz mode.
+  -v  output Version info.
+  -h (or -?)
+      output usage info.
+```
+   
+## **patch** command line usage:   
+patch usage: **hpatchz** [options] **oldPath diffFile outNewPath**   
+uncompress usage: **hpatchz** [options] **"" diffFile outNewPath**   
+create  SFX: **hpatchz** [-X-exe#selfExecuteFile] **diffFile -X#outSelfExtractArchive**   
+run     SFX: **selfExtractArchive** [options] **oldPath -X outNewPath**   
+extract SFX: **selfExtractArchive**   (same as: selfExtractArchive -f "" -X "./")
+```
+memory options:
+  -s[-cacheSize]
+      DEFAULT -s-4m; oldPath loaded as Stream;
+      cacheSize can like 262144 or 256k or 512m or 2g etc....
+      requires (cacheSize + 4*decompress buffer size)+O(1) bytes of memory.
+      if diffFile is single compressed diffData(created by hdiffz -SD-stepSize), then requires
+        (cacheSize+ stepSize + 1*decompress buffer size)+O(1) bytes of memory;
+      if diffFile is created by hdiffz -BSD,bsdiff4, hdiffz -VCD,xdelta3,open-vcdiff, then requires
+        (cacheSize + 3*decompress buffer size)+O(1) bytes of memory;
+      if diffFile is VCDIFF: if created by hdiffz -VCD, then recommended patch by -s;
+          if created by xdelta3,open-vcdiff, then recommended patch by -m.
+  -m  oldPath all loaded into Memory;
+      requires (oldFileSize + 4*decompress buffer size)+O(1) bytes of memory.
+      if diffFile is single compressed diffData(created by hdiffz -SD-stepSize), then requires
+        (oldFileSize+ stepSize + 1*decompress buffer size)+O(1) bytes of memory.
+      if diffFile is created by hdiffz -BSD,bsdiff4, then requires
+        (oldFileSize + 3*decompress buffer size)+O(1) bytes of memory.
+      if diffFile is VCDIFF(created by hdiffz -VCD,xdelta3,open-vcdiff), then requires
+        (sourceWindowSize+targetWindowSize + 3*decompress buffer size)+O(1) bytes of memory.
+special options:
+  -C-checksumSets
+      set Checksum data for directory patch, DEFAULT -C-new-copy;
+      checksumSets support (can choose multiple):
+        -C-diff         checksum diffFile;
+        -C-old          checksum old reference files;
+        -C-new          checksum new files edited from old reference files;
+        -C-copy         checksum new files copy from old same files;
+        -C-no           no checksum;
+        -C-all          same as: -C-diff-old-new-copy;
+  -C-no or -C-new
+      if diffFile is VCDIFF, then to close or open checksum, DEFAULT -C-new.
+  -n-maxOpenFileNumber
+      limit Number of open files at same time when stream directory patch;
+      maxOpenFileNumber>=8, DEFAULT -n-24, the best limit value by different
+        operating system.
+  -f  Force overwrite, ignore write path already exists;
+      DEFAULT (no -f) not overwrite and then return error;
+      support oldPath outNewPath same path!(patch to tempPath and overwrite old)
+      if used -f and outNewPath is exist file:
+        if patch output file, will overwrite;
+        if patch output directory, will always return error;
+      if used -f and outNewPath is exist directory:
+        if patch output file, will always return error;
+        if patch output directory, will overwrite, but not delete
+          needless existing files in directory.
+  -v  output Version info.
+  -h  (or -?)
+      output usage info.
+```
+   
+---
+## library API usage:
+all **diff**&**patch** function in file: `libHDiffPatch/HDiff/diff.h` & `libHDiffPatch/HPatch/patch.h`   
+**dir_diff()** & **dir patch** in: `dirDiffPatch/dir_diff/dir_diff.h` & `dirDiffPatch/dir_patch/dir_patch.h`   
+### manual:
+* **create diff**(in newData,in oldData,out diffData);
+   release the diffData for update oldData.  
+* **patch**(out newData,in oldData,in diffData);
+   ok , get the newData. 
+### v1 API, uncompressed diffData:
+* **create_diff()**
+* **patch()**
+* **patch_stream()**
+* **patch_stream_with_cache()**
+### v2 API, compressed diffData:
+* **create_compressed_diff()**
+* **create_compressed_diff_stream()**
+* **resave_compressed_diff()**
+* **patch_decompress()**
+* **patch_decompress_with_cache()**
+* **patch_decompress_mem()**
+### v3 API, **diff**&**patch** between directories(folder):
+* **dir_diff()**
+* **TDirPatcher_\*()** functions with **struct TDirPatcher**
+### v4 API, single compressed diffData:
+* **create_single_compressed_diff()**
+* **create_single_compressed_diff_stream()**
+* **resave_single_compressed_diff()**
+* **patch_single_stream()**
+* **patch_single_stream_mem()**
+* **patch_single_compressed_diff()**
+* **patch_single_stream_diff()**
+#### hpatch lite API, optimized hpatch on MCU,NB-IoT... (demo [HPatchLite](https://github.com/sisong/HPatchLite)): 
+* **create_lite_diff()**
+* **hpatch_lite_open()**
+* **hpatch_lite_patch()**
+#### bsdiff wrapper API:
+* **create_bsdiff()**
+* **create_bsdiff_stream()** 
+* **bspatch_with_cache()**
+#### vcdiff wrapper API: 
+* **create_vcdiff()**
+* **create_vcdiff_stream()**
+* **vcpatch_with_cache()**
+#### hsynz API, diff&patch by sync (demo [hsynz](https://github.com/sisong/hsynz)): 
+* **create_sync_data()**
+* **create_dir_sync_data()**
+* **sync_patch()**
+* **sync_patch_...()**
+* **sync_local_diff()**
+* **sync_local_diff_...()**
+* **sync_local_patch()**
+* **sync_local_patch_...()**
+
+---
+## HDiffPatch vs BsDiff & xdelta:
+case list([download from OneDrive](https://1drv.ms/u/s!Aj8ygMPeifoQgUIZxYac5_uflNoN)):   
+| |newFile <-- oldFile|newSize|oldSize|
+|----:|:----|----:|----:|
+|1|7-Zip_22.01.win.tar <-- 7-Zip_21.07.win.tar|5908992|5748224|
+|2|Chrome_107.0.5304.122-x64-Stable.win.tar <-- 106.0.5249.119|278658560|273026560|
+|3|cpu-z_2.03-en.win.tar <-- cpu-z_2.02-en.win.tar|8718336|8643072|
+|4|curl_7.86.0.src.tar <-- curl_7.85.0.src.tar|26275840|26030080|
+|5|douyin_1.5.1.mac.tar <-- douyin_1.4.2.mac.tar|407940608|407642624|
+|6|Emacs_28.2-universal.mac.tar <-- Emacs_27.2-3-universal.mac.tar|196380160|257496064|
+|7|FFmpeg-n_5.1.2.src.tar <-- FFmpeg-n_4.4.3.src.tar|80527360|76154880|
+|8|gcc_12.2.0.src.tar <-- gcc_11.3.0.src.tar|865884160|824309760|
+|9|git_2.33.0-intel-universal-mavericks.mac.tar <-- 2.31.0|73302528|70990848|
+|10|go_1.19.3.linux-amd64.tar <-- go_1.19.2.linux-amd64.tar|468835840|468796416|
+|11|jdk_x64_mac_openj9_16.0.1_9_openj9-0.26.0.tar <-- 9_15.0.2_7-0.24.0|363765760|327188480|
+|12|jre_1.8.0_351-linux-x64.tar <-- jre_1.8.0_311-linux-x64.tar|267796480|257996800|
+|13|linux_5.19.9.src.tar <-- linux_5.15.80.src.tar|1269637120|1138933760|
+|14|Minecraft_175.win.tar <-- Minecraft_172.win.tar|166643200|180084736|
+|15|OpenOffice_4.1.13.mac.tar <-- OpenOffice_4.1.10.mac.tar|408364032|408336896|
+|16|postgresql_15.1.src.tar <-- postgresql_14.6.src.tar|151787520|147660800|
+|17|QQ_9.6.9.win.tar <-- QQ_9.6.8.win.tar|465045504|464837120|
+|18|tensorflow_2.10.1.src.tar <-- tensorflow_2.8.4.src.tar|275548160|259246080|
+|19|VSCode-win32-x64_1.73.1.tar <-- VSCode-win32-x64_1.69.2.tar|364025856|340256768|
+|20|WeChat_3.8.0.41.win.tar <-- WeChat_3.8.0.33.win.tar|505876992|505018368|
+   
+
+**test PC**: Windows11, CPU Ryzen 5800H, SSD Disk, Memroy 8G*2 DDR4 3200MHz   
+**Program version**: HDiffPatch4.6.0, hsynz 0.9.1, BsDiff4.3, xdelta3.1 zstd1.5.2  
+**test Program**:   
+**xdelta** diff with `-S lzma -e -9 -n -f -s {old} {new} {pat}`   
+**xdelta** patch with `-d -f -s {old} {pat} {new}`   
+add **hpatchz** test: `hpatchz -m -f {old} {xdelta3-pat} {new}`   
+**xdelta -B** diff with `-S lzma -B {oldSize} -e -9 -n -f -s {old} {new} {pat}`   
+**xdelta -B** patch with `-B {oldSize} -d -f -s {old} {pat} {new}`   
+add **hpatchz** test: `hpatchz -m -f {old} {xdelta3-B-pat} {new}`   
+**bsdiff** diff with `{old} {new} {pat}`   
+**bspatch** patch with `{old} {new} {pat}`   
+add **hpatchz** test: `hpatchz -m -f {old} {bsdiff-pat} {new}`   
+**hdiffz -BSD** diff with `-m-6 -BSD -d -f -p-1 {old} {new} {pat}`   
+**hdiffz -zlib** diff with `-m-6 -SD -d -f -p-1 -c-zlib-9 {old} {new} {pat}`   
+**hdiffz -lzma2** diff with `-m-6 -SD -d -f -p-1 -c-lzma2-9-16m {old} {new} {pat}`   
+**hdiffz -zstd** diff with `-m-6 -SD -d -f -p-1 -c-zstd-21-24 {old} {new} {pat}`   
+**hdiffz -s -zlib** diff with `-s-64 -SD -d -f -p-1 -c-zlib-9 {old} {new} {pat}`   
+**hdiffz -s -lzma2** diff with `-s-64 -SD -d -f -p-1 -c-lzma2-9-16m {old} {new} {pat}`   
+**hdiffz -s -zstd** diff with `-s-64 -SD -d -f -p-1 -c-zstd-21-24 {old} {new} {pat}`   
+all **hdiffz** add test with -p-8   
+ **hpatchz** patch with `-s-3m -f {old} {pat} {new}`   
+add **zstd --patch-from** diff with `--ultra -21 --long=24 -f --patch-from={old} {new} -o {pat}`   
+ zstd patch with `-d -f --memory=2047MB --patch-from={old} {pat} -o {new}`   
+add **hsynz** test, make sync info by `hsync_make -s-2k {new} {out_newi} {out_newz}`,    
+client sync diff&patch by `hsync_demo {old} {newi} {newz} {out_new} -p-1`   
+**hsynz p1 -zlib** run hsync_make with `-p-1 -c-zlib-9`   
+**hsynz p8 -zlib** run hsync_make with `-p-8 -c-zlib-9` (run `hsync_demo` with `-p-8`)   
+**hsynz p1 -zstd** run hsync_make with `-p-1 -c-zstd-21-24`   
+**hsynz p8 -zstd** run hsync_make with `-p-8 -c-zstd-21-24` (run `hsync_demo` with `-p-8`)   
+   
+**test result average**:
+|Program|compress|diff mem|speed|patch mem|max mem|speed|
+|:----|----:|----:|----:|----:|----:|----:|
+|bzip2-9 |33.67%||16.8MB/s|||44MB/s|
+|zlib-9 |36.53%||15.9MB/s|||421MB/s|
+|lzma2-9-16m |25.85%||3.9MB/s|||162MB/s|
+|zstd-21-24 |27.21%||2.7MB/s|||619MB/s|
+||
+|zstd --patch-from|7.96%|2798M|2.4MB/s|631M|2303M|647MB/s|
+|xdelta3|13.60%|409M|4.7MB/s|86M|102M|95MB/s|
+|xdelta3 +hpatchz -m|13.60%|409M|4.7MB/s|72M|82M|280MB/s|
+|xdelta3 -B|9.63%|2282M|7.3MB/s|460M|2070M|159MB/s|
+|xdelta3 -B +hpatchz -m|9.63%|2282M|7.3MB/s|317M|1100M|345MB/s|
+|bsdiff |8.17%|2773M|1.9MB/s|637M|2312M|121MB/s|
+|bsdiff +hpatchz -m|8.17%|2773M|1.9MB/s|321M|1101M|141MB/s|
+|hdiffz p1 -BSD|7.72%|1215M|10.9MB/s|14M|14M|124MB/s|
+|hdiffz p8 -BSD|7.72%|1191M|22.0MB/s|14M|14M|123MB/s|
+|hdiffz p1 -zlib|7.79%|1214M|11.6MB/s|4M|4M|415MB/s|
+|hdiffz p8 -zlib|7.79%|1191M|30.5MB/s|4M|4M|409MB/s|
+|hdiffz p1 -lzma2|6.44%|1212M|9.2MB/s|17M|20M|312MB/s|
+|hdiffz p8 -lzma2|6.44%|1192M|23.2MB/s|17M|20M|309MB/s|
+|hdiffz p1 -zstd|6.74%|1217M|9.0MB/s|16M|21M|422MB/s|
+|hdiffz p8 -zstd|6.74%|1531M|16.7MB/s|16M|21M|418MB/s|
+|hdiffz -s p1 -BSD|11.96%|91M|33.3MB/s|14M|14M|105MB/s|
+|hdiffz -s p8 -BSD|11.96%|95M|40.6MB/s|14M|14M|105MB/s|
+|hdiffz -s p1 -zlib|12.52%|90M|35.2MB/s|4M|4M|439MB/s|
+|hdiffz -s p8 -zlib|12.53%|95M|104.4MB/s|4M|4M|434MB/s|
+|hdiffz -s p1 -lzma2|9.11%|170M|13.7MB/s|17M|20M|289MB/s|
+|hdiffz -s p8 -lzma2|9.13%|370M|34.7MB/s|17M|20M|286MB/s|
+|hdiffz -s p1 -zstd|9.60%|195M|10.9MB/s|18M|21M|454MB/s|
+|hdiffz -s p8 -zstd|9.60%|976M|17.1MB/s|18M|21M|462MB/s|
+|hsynz p1 -zlib|20.05%|6M|14.3MB/s|6M|21M|172MB/s|
+|hsynz p8 -zlib|20.05%|30M|89.8MB/s|13M|29M|254MB/s|
+|hsynz p1 -zstd|14.90%|532M|1.3MB/s|24M|35M|192MB/s|
+|hsynz p8 -zstd|14.90%|3349M|5.1MB/s|24M|35M|301MB/s|
+    
+
+## input Apk Files for test: 
+case list:
+| |app|newFile <-- oldFile|newSize|oldSize|
+|----:|:---:|:----|----:|----:|
+|1|<img src="https://github.com/sisong/sfpatcher/raw/master/img/cn.wps.moffice_eng.png" width="36">|cn.wps.moffice_eng_13.30.0.apk <-- 13.29.0|95904918|94914262|
+|2|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.achievo.vipshop.png" width="36">|com.achievo.vipshop_7.80.2.apk <-- 7.79.9|127395632|120237937|
+|3|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.adobe.reader.png" width="36">|com.adobe.reader_22.9.0.24118.apk <-- 22.8.1.23587|27351437|27087718|
+|4|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.alibaba.android.rimet.png" width="36">|com.alibaba.android.rimet_6.5.50.apk <-- 6.5.45|195314449|193489159|
+|5|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.amazon.mShop.android.shopping.png" width="36">|com.amazon.mShop.android.shopping_24.18.2.apk <-- 24.18.0|76328858|76287423|
+|6|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.baidu.BaiduMap.png" width="36">|com.baidu.BaiduMap_16.5.0.apk <-- 16.4.5|131382821|132308374|
+|7|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.dragon.read.png" width="36">|com.dragon.read_5.5.3.33.apk <-- 5.5.1.32|45112658|43518658|
+|8|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.ebay.mobile.png" width="36">|com.ebay.mobile_6.80.0.1.apk <-- 6.79.0.1|61202587|61123285|
+|9|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.eg.android.AlipayGphone.png" width="36">|com.eg.android.AlipayGphone_10.3.0.apk <-- 10.2.96|122073135|119046208|
+|10|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.google.android.apps.translate.png" width="36">|com.google.android.apps.translate_6.46.0.apk <-- 6.45.0|48892967|48843378|
+|11|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.google.android.googlequicksearchbox.png" width="36">|com.google.android.googlequicksearchbox_13.38.11.apk <-- 13.37.10|190539272|189493966|
+|12|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.jingdong.app.mall.png" width="36">|com.jingdong.app.mall_11.3.2.apk <-- 11.3.0|101098430|100750191|
+|13|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.netease.cloudmusic.png" width="36">|com.netease.cloudmusic_8.8.45.apk <-- 8.8.40|181914846|181909451|
+|14|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.reddit.frontpage.png" width="36">|com.reddit.frontpage_2022.36.0.apk <-- 2022.34.0|50205119|47854461|
+|15|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.sankuai.meituan.takeoutnew.png" width="36">|com.sankuai.meituan.takeoutnew_7.94.3.apk <-- 7.92.2|74965893|74833926|
+|16|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.sankuai.meituan.png" width="36">|com.sankuai.meituan_12.4.207.apk <-- 12.4.205|93613732|93605911|
+|17|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.sina.weibo.png" width="36">|com.sina.weibo_12.10.0.apk <-- 12.9.5|156881776|156617913|
+|18|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.smile.gifmaker.png" width="36">|com.smile.gifmaker_10.8.40.27845.apk <-- 10.8.30.27728|102403847|101520138|
+|19|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.ss.android.article.news.png" width="36">|com.ss.android.article.news_9.0.7.apk <-- 9.0.6|54444003|53947221|
+|20|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.ss.android.ugc.aweme.png" width="36">|com.ss.android.ugc.aweme_22.6.0.apk <-- 22.5.0|171683897|171353597|
+|21|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.taobao.taobao.png" width="36">|com.taobao.taobao_10.18.10.apk <-- 10.17.0|117218670|117111874|
+|22|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.tencent.mm.png" width="36">|com.tencent.mm_8.0.28.apk <-- 8.0.27|266691829|276603782|
+|23|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.tencent.mobileqq.png" width="36">|com.tencent.mobileqq_8.9.15.apk <-- 8.9.13|311322716|310529631|
+|24|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.tencent.mtt.png" width="36">|com.tencent.mtt_13.2.0.0103.apk <-- 13.2.0.0045|97342747|97296757|
+|25|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.tripadvisor.tripadvisor.png" width="36">|com.tripadvisor.tripadvisor_49.5.apk <-- 49.3|28744498|28695346|
+|26|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.twitter.android.png" width="36">|com.twitter.android_9.61.0.apk <-- 9.58.2|36141840|35575484|
+|27|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.ubercab.png" width="36">|com.ubercab_4.442.10002.apk <-- 4.439.10002|69923232|64284150|
+|28|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.ximalaya.ting.android.png" width="36">|com.ximalaya.ting.android_9.0.66.3.apk <-- 9.0.62.3|115804845|113564876|
+|29|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.xunmeng.pinduoduo.png" width="36">|com.xunmeng.pinduoduo_6.30.0.apk <-- 6.29.1|30896833|30951567|
+|30|<img src="https://github.com/sisong/sfpatcher/raw/master/img/com.youdao.dict.png" width="36">|com.youdao.dict_9.2.29.apk <-- 9.2.28|110624682|110628778|
+|31|<img src="https://github.com/sisong/sfpatcher/raw/master/img/org.mozilla.firefox.png" width="36">|org.mozilla.firefox_105.2.0.apk <-- 105.1.0|83078464|83086656|
+|32|<img src="https://github.com/sisong/sfpatcher/raw/master/img/tv.danmaku.bili.png" width="36">|tv.danmaku.bili_7.1.0.apk <-- 7.0.0|104774723|104727005|
+   
+
+**changed test Program**:   
+**hdiffz ...** `-m-6 -SD` changed to `-m-1 -SD-2m -cache`, `-s-64 -SD` changed to `-s-16 -SD-2m`   
+**hdiffz ...** lzma2 dict size `16m` changed to `8m`, zstd dict bit `24` changed to `23`   
+**hsynz ...** make `-s-2k` changed to `-s-1k`   
+add **hsynz p1**, **hsynz p8** make without compressor   
+add **archive-patcher** v1.0, diff with `--generate --old {old} --new {new} --patch {pat}`,   
+  patch with `--apply --old {old} --patch {pat} --new {new}`   
+  NOTE: archive-patcher's delta file compressed by lzma2-9-8m, diff&patch time not include compress&decompress delta file's memory&time.   
+**sfpatcher -1 -zstd** v1.1.0 diff with `-o-1 -c-zstd-21-23 -m-1 -step-3m -lp-512k -p-8 -cache -d {old} {new} {pat}`   
+**sfpatcher -2 -lzma2** diff with `-o-2 -c-lzma2-9-4m -m-1 -step-2m -lp-8m -p-8 -cache -d {old} {new} {pat}`   
+ sfpatcher patch with `-lp -p-8 {old} {pat} {new}`   
+( [archive-patcher](https://github.com/google/archive-patcher), [sfpatcher](https://github.com/sisong/sfpatcher) optimized diff&patch between apk files )  
+
+**test result average**:
+|Program|compress|diff mem|speed|patch mem|max mem|speed|
+|:----|----:|----:|----:|----:|----:|----:|
+|zstd --patch-from|53.18%|2199M|2.9MB/s|209M|596M|624MB/s|
+|xdelta3|54.51%|422M|2.5MB/s|98M|99M|103MB/s|
+|xdelta3 +hpatchz -m|54.51%|422M|2.5MB/s|70M|81M|331MB/s|
+|bsdiff|53.84%|931M|1.0MB/s|218M|605M|40MB/s|
+|bsdiff +hpatchz -s|53.84%|931M|1.0MB/s|14M|14M|40MB/s|
+|hdiffz p1 -BSD|53.69%|509M|4.9MB/s|14M|14M|40MB/s|
+|hdiffz p8 -BSD|53.70%|514M|9.2MB/s|14M|14M|40MB/s|
+|hdiffz p1 -zlib|53.21%|509M|6.2MB/s|5M|6M|382MB/s|
+|hdiffz p8 -zlib|53.22%|514M|18.2MB/s|5M|6M|380MB/s|
+|hdiffz p1 -lzma2|52.93%|525M|3.3MB/s|21M|22M|195MB/s|
+|hdiffz p8 -lzma2|52.94%|557M|11.2MB/s|21M|22M|196MB/s|
+|hdiffz p1 -zstd|53.04%|537M|4.2MB/s|21M|22M|428MB/s|
+|hdiffz p8 -zstd|53.05%|1251M|7.8MB/s|21M|22M|433MB/s|
+|hdiffz -s p1 -zlib|53.73%|118M|20.0MB/s|4M|6M|380MB/s|
+|hdiffz -s p8 -zlib|53.73%|122M|62.5MB/s|4M|6M|378MB/s|
+|hdiffz -s p1 -lzma2|53.30%|197M|5.2MB/s|20M|22M|195MB/s|
+|hdiffz -s p8 -lzma2|53.30%|309M|20.9MB/s|20M|22M|195MB/s|
+|hdiffz -s p1 -zstd|53.44%|221M|8.1MB/s|20M|22M|452MB/s|
+|hdiffz -s p8 -zstd|53.44%|1048M|11.1MB/s|20M|22M|448MB/s|
+|hsynz p1|62.43%|4M|1243.4MB/s|4M|10M|172MB/s|
+|hsynz p8|62.43%|25M|1902.6MB/s|12M|18M|293MB/s|
+|hsynz p1 -zlib|58.67%|5M|18.5MB/s|4M|11M|170MB/s|
+|hsynz p8 -zlib|58.67%|29M|107.6MB/s|12M|19M|285MB/s|
+|hsynz p1 -zstd|57.92%|534M|2.2MB/s|24M|28M|173MB/s|
+|hsynz p8 -zstd|57.92%|3434M|7.6MB/s|24M|28M|294MB/s|
+|archive-patcher +lzma2|31.68%|3278M|0.7MB/s|759M|788M|15MB/s|
+|sfpatcher -1 p1 -zstd|31.08%|818M|1.8MB/s|15M|19M|154MB/s|
+|sfpatcher -1 p8 -zstd|31.07%|1026M|3.1MB/s|18M|25M|307MB/s|
+|sfpatcher -2 p1 -lzma2|24.11%|976M|1.6MB/s|15M|20M|28MB/s|
+|sfpatcher -2 p8 -lzma2|24.15%|967M|3.3MB/s|20M|26M|79MB/s|
+    
+
+---
+## Contact
+housisong@hotmail.com  
+

deps/HDiffPatch/README_cmdline_cn.md

@@ -0,0 +1,179 @@
+# [HDiffPatch](https://github.com/sisong/HDiffPatch) 命令行使用说明中文版
+
+## diff 命令行用法和参数说明：
+创建新旧版本间的补丁： **hdiffz** [options] **oldPath newPath outDiffFile**   
+压缩一个文件或文件夹： **hdiffz** [-c-...]  **"" newPath outDiffFile**   
+测试补丁是否正确： **hdiffz**    -t     **oldPath newPath testDiffFile**   
+补丁使用新的压缩插件另存： **hdiffz** [-c-...]  **diffFile outDiffFile**   
+创建该版本的校验清单： **hdiffz** [-g#...] [-C-checksumType] **inputPath -M#outManifestTxtFile**   
+校验输入数据后创建补丁： **hdiffz** [options] **-M-old#oldManifestFile -M-new#newManifestFile oldPath newPath outDiffFile**   
+```
+  oldPath、newPath、inputPath 可以是文件或文件夹, 
+  oldPath可以为空, 输入参数为 ""
+内存选项:
+  -m[-matchScore]
+      默认选项; 所有文件都会被加载到内存; 一般生成的补丁文件比较小;
+      需要的内存大小:(新版本文件大小+ 旧版本文件大小*5(或*9 当旧版本文件大小>=2GB时))+O(1);
+      匹配分数matchScore>=0,默认为6,二进制数据时推荐设置为0到4,文件数据时推荐4--9等,跟输入
+      数据的可压缩性相关,一般输入数据的可压缩性越大,这个值就可以越大。
+  -s[-matchBlockSize]
+      所有文件当作文件流加载;一般速度比较快;
+      需要的内存大小: O(旧版本文件大小*16/matchBlockSize+matchBlockSize*5*parallelThreadNumber);
+      匹配块大小matchBlockSize>=4, 默认为64, 推荐16,32,48,1k,64k,1m等;
+      一般匹配块越大,内存占用越小,速度越快,但补丁包可能变大。
+其他选项:
+  -block-fastMatchBlockSize
+      必须和-m配合使用;
+      在使用较慢的逐字节匹配之前使用基于块的快速匹配, 默认-block-4k;
+      如果设置为-block-0，意思是关闭基于块的提前匹配；
+      快速块匹配大小fastMatchBlockSize>=4, 推荐256,1k,64k,1m等;
+      如果新版本和旧版本相同数据比较多,那diff速度就会比较快,并且减少内存占用,
+      但有很小的可能补丁包会变大。
+  -cache
+      必须和-m配合使用;
+      给较慢的匹配开启一个大型缓冲区,来加快匹配速度(不影响补丁大小), 默认不开启;
+      如果新版本和旧版本不相同数据比较多,那diff速度就会比较快;
+      该大型缓冲区最大占用O(旧版本文件大小)的内存, 并且需要较多的时间来创建(从而可能降低diff速度)。
+  -SD[-stepSize]
+      创建单压缩流的补丁文件, 这样patch时就只需要一个解压缩缓冲区, 并且可以支持边下载边patch;
+      压缩步长stepSize>=(1024*4), 默认为256k, 推荐64k,2m等。
+  -BSD
+      创建一个和bsdiff4兼容的补丁, 不支持参数为文件夹。
+  -VCD[-compressLevel[-dictSize]]
+      创建一个标准规范VCDIFF格式的补丁, 不支持参数为文件夹。
+      默认输出补丁不带压缩, 格式和 $open-vcdiff delta ... 或 $xdelta3 -S -e -n ... 命令输出的补丁格式兼容；
+      如果设置了压缩级别compressLevel, 那输出格式和 $xdelta3 -S lzma -e -n ...命令输出的补丁格式兼容；
+      压缩输出时补丁文件使用7zXZ(xz)算法压缩, compressLevel可以选择0到9, 默认级别7；
+      压缩字典大小dictSize可以设置为 4096, 4k, 4m, 16m等, 默认为8m
+      支持多线程并行压缩。
+      注意: 输出的补丁的格式中可能使用了巨大的源窗口大小!
+  -p-parallelThreadNumber
+      设置线程数parallelThreadNumber>1时,开启多线程并行模式;
+      默认为4;需要占用较多的内存。
+  -p-search-searchThreadNumber
+      必须和-s[-matchBlockSize]配合使用;
+      默认情况下搜索线程数searchThreadNumber的值和parallelThreadNumber相同;
+      但当matchBlockSize较小时，多线程搜索需要频繁的随机磁盘读取，
+      所以有些时候多线程搜索反而比单线程搜索还慢很多!
+      如果设置searchThreadNumber<=1，可以关闭多线程搜索模式。
+  -c-compressType[-compressLevel]
+      设置补丁数据使用的压缩算法和压缩级别等, 默认不压缩;
+      补丁另存时,使用新的压缩参数设置来输出新补丁;
+      支持的压缩算法、压缩级别和字典大小等:
+        -c-zlib[-{1..9}[-dictBits]]     默认级别 9
+            压缩字典比特数dictBits可以为9到15, 默认为15。
+            支持多线程并行压缩,很快！
+        -c-bzip2[-{1..9}]               (或 -bz2) 默认级别 9
+        -c-pbzip2[-{1..9}]              (或 -pbz2) 默认级别 8
+            支持并行压缩,生成的补丁和-c-bzip2的输出格式不同,一般也可能稍大一点。
+        -c-lzma[-{0..9}[-dictSize]]     默认级别 7
+            压缩字典大小dictSize可以设置为 4096, 4k, 4m, 128m等, 默认为8m
+            支持2个线程并行压缩。
+        -c-lzma2[-{0..9}[-dictSize]]    默认级别 7
+            压缩字典大小dictSize可以设置为 4096, 4k, 4m, 128m等, 默认为8m
+            支持多线程并行压缩,很快。
+            警告: lzma和lzma2是不同的压缩编码格式。
+        -c-zstd[-{0..22}[-dictBits]]    默认级别 20
+            压缩字典比特数dictBits 可以为10到31, 默认为24。
+            支持多线程并行压缩,很快。
+  -C-checksumType
+      为文件夹间diff设置数据校验算法, 默认为fadler64;
+      支持的校验选项:
+        -C-no                   不校验
+        -C-crc32
+        -C-fadler64             默认
+        -C-md5
+  -n-maxOpenFileNumber
+      为文件夹间的-s模式diff设置最大允许同时打开的文件数;
+      maxOpenFileNumber>=8, 默认为48; 合适的限制值可能不同系统下不同。
+  -g#ignorePath[#ignorePath#...]
+      为文件夹间的diff设置忽略路径(路径可能是文件或文件夹); 忽略路径列表的格式如下:
+        #.DS_Store#desktop.ini#*thumbs*.db#.git*#.svn/#cache_*/00*11/*.tmp
+      # 意味着路径名称之间的间隔; (如果名称中有“#”号, 需要改写为“#:” )
+      * 意味着匹配名称中的任意一段字符; (如果名称中有“*”号, 需要改写为“*:” )
+      / 如果该符号放在名称末尾,意味着必须匹配文件夹;
+  -g-old#ignorePath[#ignorePath#...]
+      为文件夹间的diff设置忽略旧版本的路径;
+      如果旧版本中的某个文件数据可以被运行中的程序改动,那可以将该文件放到该忽略列表中;
+  -g-new#ignorePath[#ignorePath#...]
+      为文件夹间的diff设置忽略新版本的路径;
+      一般情况下,该列表应该是空的吧?
+  -M#outManifestTxtFile
+      创建inputPath的校验清单文件; 该输出文件是一个文本文件, 保存着inputPath中所有
+      文件和文件夹的信息; 该文件被用于manifest diff, 支持diff之前重新校验数据的正确性;
+      可用于确定历史版本的数据没有被篡改!
+  -M-old#oldManifestFile
+      设置oldPath的清单文件oldManifestFile; 如果没有oldPath,那就不需要设置-M-old;
+  -M-new#newManifestFile
+      设置newPath的清单文件newManifestFile;
+  -D  强制执行文件夹间的diff, 即使输入的是2个文件; 从而为文件间的补丁添加校验功能。
+      默认情况下oldPath或newPath有一个是文件夹时才会执行文件夹间的diff。
+  -d  只执行diff, 不要执行patch检查, 默认会执行patch检查.
+  -t  只执行patch检查, 检查是否 patch(oldPath,testDiffFile)==newPath ?
+  -f  强制文件写覆盖, 忽略输出的路径是否已经存在;
+      默认不执行覆盖, 如果输出路径已经存在, 直接返回错误;
+      如果设置了-f,但路径已经存在并且是一个文件夹, 那么会始终返回错误。
+  --patch
+      切换到 hpatchz 模式; 可以支持hpatchz命令行的相关参数和功能。
+  -v  输出程序版本信息。
+  -h 或 -?
+      输出命令行帮助信息 (该说明)。
+```
+   
+## patch 命令行用法和参数说明：  
+打补丁： **hpatchz** [options] **oldPath diffFile outNewPath**   
+解压缩一个文件或文件夹： **hpatchz** [options] **"" diffFile outNewPath**   
+创建一个自释放包： **hpatchz** [-X-exe#selfExecuteFile] **diffFile -X#outSelfExtractArchive**   
+  (将目标平台的hpatchz可执行文件和补丁包文件合并成一个可执行文件, 称作自释放包SFX)   
+执行一个自释放包： **selfExtractArchive** [options] **oldPath -X outNewPath**   
+  (利用自释放包来打补丁,将包中自带的补丁数据应用到oldPath上, 合成outNewPath)   
+执行一个自解压包： **selfExtractArchive**   (等价于： selfExtractArchive -f "" -X "./")
+```
+内存选项:
+  -s[-cacheSize]
+      默认选项,并且默认设置为-s-4m; oldPath所有文件被当作文件流来加载;
+      cacheSize可以设置为262144 或 256k, 512m, 2g等
+      需要的内存大小: (cacheSize + 4*解压缩缓冲区)+O(1)
+      而如果diffFile是单压缩流的补丁文件(用hdiffz -SD-stepSize所创建)
+        那需要的内存大小: (cacheSize+ stepSize + 1*解压缩缓冲区)+O(1);
+      如果diffFile是用hdiffz -BSD、bsdiff4、hdiffz -VCD、xdelta3、open-vcdiff所创建
+        那需要的内存大小: (cacheSize + 3*解压缩缓冲区);
+      如果diffFile是VCDIFF格式补丁文件： 如果是用hdiffz -VCD创建，那推荐用-s模式；
+        如果是xdelta、open-vcdiff所创建，那推荐用-m模式。
+  -m  oldPath所有文件数据被加载到内存中;
+      需要的内存大小: (oldFileSize + 4*解压缩缓冲区)+O(1)
+      而如果diffFile是单压缩流的补丁文件(用hdiffz -SD-stepSize所创建)
+        那需要的内存大小: (oldFileSize+ stepSize + 1*解压缩缓冲区)+O(1);
+      如果diffFile是用hdiffz -BSD、bsdiff4所创建
+        那需要的内存大小: (oldFileSize + 3*解压缩缓冲区);
+      如果diffFile是VCDIFF格式补丁文件(用hdiffz -VCD、xdelta3、open-vcdiff所创建)
+        那需要的内存大小: (源窗口大小+目标窗口大小 + 3*解压缩缓冲区);
+其他选项:
+  -C-checksumSets
+      为文件夹patch设置校验方式, 默认设置为 -C-new-copy;
+      校验设置支持(可以多选):
+        -C-diff         校验补丁数据;
+        -C-old          校验引用到的旧版本的文件;
+        -C-new          校验有修改过的新版本的文件;
+        -C-copy         校验从旧版本直接copy到新版本的文件;
+        -C-no           不执行校验;
+        -C-all          等价于: -C-diff-old-new-copy;
+  -C-no 或 -C-new
+      如果diffFile是VCDIFF格式补丁文件, 使用该选项可以关闭或打开校验，默认打开.
+  -n-maxOpenFileNumber
+      为文件夹间的-s模式patch设置最大允许同时打开的文件数;
+      maxOpenFileNumber>=8, 默认为24; 合适的限制值可能不同系统下不同。
+  -f  强制文件写覆盖, 忽略输出的路径是否已经存在;
+      默认不执行覆盖, 如果输出路径已经存在, 直接返回错误;
+      该模式支持oldPath和outNewPath为相同路径!(patch到一个临时路径,完成后再覆盖回old)
+      如果设置了-f,但outNewPath已经存在并且是一个文件:
+        如果patch输出一个文件, 那么会执行写覆盖;
+        如果patch输出一个文件夹, 那么会始终返回错误。
+      如果设置了-f,但outNewPath已经存在并且是一个文件夹:
+        如果patch输出一个文件, 那么会始终返回错误;
+        如果patch输出一个文件夹, 那么会执行写覆盖, 但不会删除文件夹中已经存在的无关文件。
+  -v  输出程序版本信息。
+  -h 或 -?
+      输出命令行帮助信息 (该说明)。
+```
+   

deps/HDiffPatch/_atosize.h

@@ -0,0 +1,83 @@
+//_atosize.h
+//
+/*
+ This is the HDiffPatch copyright.
+
+ Copyright (c) 2012-2017 HouSisong All Rights Reserved.
+
+ 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 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 HDiffPatch_atosize_h
+#define HDiffPatch_atosize_h
+#include "libHDiffPatch/HPatch/patch_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#define _kSizeMax (~(size_t)0)
+
+hpatch_inline static
+hpatch_BOOL a_to_size(const char* pnum,size_t slen,size_t* out_size){
+    const size_t _kSizeMaxDiv10=_kSizeMax/10;
+    const size_t _kSizeMaxMod10=_kSizeMax-_kSizeMaxDiv10*10;
+    size_t v=0;
+    size_t s;
+    if (slen==0) return hpatch_FALSE;
+    if ((slen>=2)&(pnum[0]=='0')) return hpatch_FALSE;
+    for (s=0; s<slen; ++s) {
+        size_t c=pnum[s];
+        if (('0'<=c)&(c<='9'))
+            ;//empty ok
+        else
+            return hpatch_FALSE;
+        c-='0';
+        if (v<_kSizeMaxDiv10)
+            ;//empty ok
+        else if ((v>_kSizeMaxDiv10)|(c>_kSizeMaxMod10))
+            return hpatch_FALSE;
+        v=v*10+c;
+    }
+    *out_size=v;
+    return hpatch_TRUE;
+}
+
+hpatch_inline static
+hpatch_BOOL kmg_to_size(const char* pkmgnum,size_t slen,size_t* out_size){
+    size_t shl;
+    size_t v;
+    if (slen==0) return hpatch_FALSE;
+    switch (pkmgnum[slen-1]) {
+        case 'k': case 'K': { shl=10; --slen;} break;
+        case 'm': case 'M': { shl=20; --slen;} break;
+        case 'g': case 'G': { shl=30; --slen;} break;
+        default:            { shl= 0;        } break;
+    }
+    if (!a_to_size(pkmgnum,slen,&v)) return hpatch_FALSE;
+    if (v>(_kSizeMax>>shl)) return hpatch_FALSE;
+    *out_size=v<<shl;
+    return hpatch_TRUE;
+}
+
+#ifdef __cplusplus
+}
+#endif
+#endif //HDiffPatch_atosize_h

deps/HDiffPatch/_clock_for_demo.h

@@ -0,0 +1,55 @@
+//_clock_for_demo.h
+// double clock_s()
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-2017 HouSisong
+ 
+ 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 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.
+ */
+
+//  #include <time.h>
+//  static double clock_s(){ return clock()*1.0/CLOCKS_PER_SEC; }
+#ifdef _WIN32
+    #include <windows.h>
+    static double clock_s(){
+        LARGE_INTEGER f;
+        if (QueryPerformanceFrequency(&f)){
+            LARGE_INTEGER c;
+            QueryPerformanceCounter(&c);
+            return c.QuadPart/((double)f.QuadPart);
+        }
+        return GetTickCount()/1000.0; 
+    }
+#else
+    //Unix-like system
+    #include <sys/time.h>
+    #include <assert.h>
+    static double clock_s(){
+        struct timeval t={0,0};
+        int ret=gettimeofday(&t,0);
+        assert(ret==0);
+        if (ret==0)
+            return t.tv_sec + t.tv_usec/1000000.0;
+        else
+            return 0;
+    }
+#endif

deps/HDiffPatch/_dir_ignore.h

@@ -0,0 +1,191 @@
+//  _dir_ignore.h
+//  hdiffz
+//  Created by housisong on 2019-09-30.
+//
+/*
+ The MIT License (MIT)
+ Copyright (c) 2012-2019 HouSisong
+ 
+ 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 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 _dir_ignore_h
+#define _dir_ignore_h
+#include <vector>
+#include <string>
+#include <algorithm>
+#include "dirDiffPatch/dir_patch/dir_patch.h"
+
+#if (_IS_NEED_DIR_DIFF_PATCH)
+static void formatIgnorePathName(std::string& path_utf8){
+    for (size_t i=0;i<path_utf8.size();++i) {
+        char c=path_utf8[i];
+        if ((c=='\\')||(c=='/'))
+            path_utf8[i]=kPatch_dirSeparator;
+#ifdef _WIN32
+        else if (isascii(c))
+            path_utf8[i]=(char)tolower(c);
+#endif
+    }
+}
+
+#ifdef _WIN32
+static const char _private_kIgnoreMagicChar = '?';  //a char not used in path name on WIN32
+#else
+static const char _private_kIgnoreMagicChar = ':';  //a char not used in path name
+#endif
+static void _formatIgnorePathSet(std::string& path_utf8){
+    formatIgnorePathName(path_utf8);
+    size_t insert=0;
+    size_t i=0;
+    while (i<path_utf8.size()) {
+        char c=path_utf8[i];
+        if (c=='*'){
+            if ((i+1<path_utf8.size())&&(path_utf8[i+1]==':')){ // *: as *
+                path_utf8[insert++]=c; i+=2; //skip *:
+            }else{
+                path_utf8[insert++]=_private_kIgnoreMagicChar; ++i; //skip *
+            }
+        }else{
+            path_utf8[insert++]=c; ++i;  //skip c
+        }
+    }
+    path_utf8.resize(insert);
+}
+
+static hpatch_BOOL _getIgnorePathSetList(std::vector<std::string>& out_pathList,const char* plist){
+    std::string cur;
+    while (true) {
+        char c=*plist;
+        if ((c=='#')&&(plist[1]==':')){ // #: as #
+            cur.push_back(c); plist+=2; //skip #:
+        }else if ((c=='*')&&(plist[1]==':')){ // *: as *:
+            cur.push_back(c); cur.push_back(':'); plist+=2; //skip *:
+        }else if ((c=='\0')||((c=='#')&&(plist[1]!=':'))){
+            if (cur.empty()) return hpatch_FALSE;// can't empty
+            if (std::string::npos!=cur.find("**")) return hpatch_FALSE;// can't **
+            _formatIgnorePathSet(cur);
+            out_pathList.push_back(cur);
+            if (c=='\0') return hpatch_TRUE;
+            cur.clear();  ++plist; //skip #
+        }else if (c==_private_kIgnoreMagicChar){
+            return hpatch_FALSE; //error path char
+        }else{
+            cur.push_back(c); ++plist; //skip c
+        }
+    }
+}
+
+static bool _matchIgnore(const char* beginS,const char* endS,
+                         const std::vector<const char*>& matchs,size_t mi,
+                         const char* ignoreBegin,const char* ignoreEnd){
+    //O(n*n) !
+    const char* match   =matchs[mi];
+    const char* matchEnd=matchs[mi+1];
+    const char* curS=beginS;
+    while (curS<endS){
+        const char* found=std::search(curS,endS,match,matchEnd);
+        if (found==endS) return false;
+        bool isMatched=true;
+        //check front
+        if (beginS<found){
+            if (mi>0){ //[front match]*[cur match]
+                for (const char* it=beginS;it<found; ++it) {
+                    if ((*it)==kPatch_dirSeparator) { isMatched=false; break; }
+                }
+            }else{ // ?[first match]
+                if ((match==ignoreBegin)&&(match[0]!=kPatch_dirSeparator)&&(found[-1]!=kPatch_dirSeparator))
+                    isMatched=false;
+            }
+        }
+        const char* foundEnd=found+(matchEnd-match);
+        //check back
+        if (isMatched && (mi+2>=matchs.size()) && (foundEnd<endS)){ //[last match]
+            if ((matchEnd==ignoreEnd)&&(matchEnd[-1]!=kPatch_dirSeparator)&&(foundEnd[0]!=kPatch_dirSeparator))
+                isMatched=false;
+        }
+        if (isMatched && (mi+2<matchs.size())
+            && (!_matchIgnore(foundEnd,endS,matchs,mi+2,ignoreBegin,ignoreEnd)))
+            isMatched=false;
+        if (isMatched) return true;
+        curS=found+1;//continue
+    }
+    return false;
+}
+
+static bool isMatchIgnore(const std::string& subPath,const std::string& ignore){
+    assert(!ignore.empty());
+    std::vector<const char*> matchs;
+    const char* beginI=ignore.c_str();
+    const char* endI=beginI+ignore.size();
+    const char* curI=beginI;
+    while (curI<endI) {
+        const char* clip=std::find(curI,endI,_private_kIgnoreMagicChar);
+        if (curI<clip){
+            matchs.push_back(curI);
+            matchs.push_back(clip);
+        }
+        curI=clip+1;
+    }
+    if (matchs.empty()) return true; // WARNING : match any path
+    const char* beginS=subPath.c_str();
+    const char* endS=beginS+subPath.size();
+    return _matchIgnore(beginS,endS,matchs,0,beginI,endI);
+}
+
+static inline bool isMatchIgnoreList(const std::string& subPath,const std::vector<std::string>& ignoreList){
+    for (size_t i=0; i<ignoreList.size(); ++i) {
+        if (isMatchIgnore(subPath,ignoreList[i])) return true;
+    }
+    return false;
+}
+
+struct CDirPathIgnore{
+    CDirPathIgnore(const std::vector<std::string>& ignorePathListBase,
+                   const std::vector<std::string>& ignorePathList,bool isPrintIgnore)
+    :_ignorePathListBase(ignorePathListBase),_ignorePathList(ignorePathList),
+    _isPrintIgnore(isPrintIgnore),_ignoreCount(0){ }
+    CDirPathIgnore(const std::vector<std::string>& ignorePathList,bool isPrintIgnore)
+    :_ignorePathListBase(ignorePathList),_ignorePathList(ignorePathList),
+    _isPrintIgnore(isPrintIgnore),_ignoreCount(0){ }
+    bool isNeedIgnore(const std::string& path,size_t rootPathNameLen){
+        std::string subPath(path.begin()+rootPathNameLen,path.end());
+        formatIgnorePathName(subPath);
+        bool result=   isMatchIgnoreList(subPath,_ignorePathListBase);
+        if ((!result)&&(&_ignorePathListBase!=&_ignorePathList))
+            result=isMatchIgnoreList(subPath,_ignorePathList);
+        if (result) ++_ignoreCount;
+        if (result&&_isPrintIgnore){ //printf
+            printf("  ignore file : \"");
+            hpatch_printPath_utf8(path.c_str());  printf("\"\n");
+        }
+        return result;
+    }
+    inline size_t ignoreCount()const{ return _ignoreCount; }
+private:
+    const std::vector<std::string>& _ignorePathListBase;
+    const std::vector<std::string>& _ignorePathList;
+    const bool                      _isPrintIgnore;
+    size_t                          _ignoreCount;
+};
+#endif
+
+#endif // dir_ignore_h

deps/HDiffPatch/bsdiff_wrapper/bsdiff_wrapper.cpp

@@ -0,0 +1,283 @@
+// bsdiff_wrapper.cpp
+// HDiffPatch
+/*
+ The MIT License (MIT)
+ Copyright (c) 2021 HouSisong
+ 
+ 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 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.
+ */
+#include "bsdiff_wrapper.h"
+#include "bspatch_wrapper.h"
+#include "../libHDiffPatch/HDiff/match_block.h"
+#include "../libHDiffPatch/HDiff/diff.h"
+#include "../libHDiffPatch/HDiff/private_diff/mem_buf.h"
+#include "../libHDiffPatch/HDiff/private_diff/limit_mem_diff/stream_serialize.h"
+#include "../libHDiffPatch/HPatch/patch.h"
+#include <stdexcept>  //std::runtime_error
+#define _check(value,info) { if (!(value)) { throw std::runtime_error(info); } }
+static const char* kBsDiffVersionType="BSDIFF40";
+
+namespace hdiff_private{
+    static inline void pushUInt64(std::vector<unsigned char>& buf,hpatch_uint64_t v){ 
+        pushUInt(buf,v);
+    }
+    static inline void pushSInt64(std::vector<unsigned char>& buf,hpatch_uint64_t v){
+        if ((v>>63)==1){
+            v=-v;
+            v|=((hpatch_uint64_t)1)<<63;
+        }
+        pushUInt64(buf,v);
+    }
+
+    struct TCtrlStream:public hpatch_TStreamInput{
+        explicit TCtrlStream(const TCovers& _covers)
+        :curPos(0),curi(0),bufi(0),covers(_covers){
+            streamImport=this;
+            read=_read;
+            streamSize=(covers.coverCount()-1)*(hpatch_StreamPos_t)(3*8);
+            buf.reserve(hdiff_kFileIOBufBestSize);
+        }
+    private:
+        hpatch_StreamPos_t curPos;
+        size_t curi;
+        size_t bufi;
+        const TCovers& covers;
+        std::vector<unsigned char> buf;
+        void _updateBuf(){
+            buf.clear();
+            bufi=0;
+            while ((curi+1<covers.coverCount())&&((buf.size()+3*8)<=hdiff_kFileIOBufBestSize)){
+                TCover c,cnext;
+                covers.covers(curi++,&c);
+                covers.covers(curi,&cnext);
+                pushUInt64(buf,c.length);
+                pushUInt64(buf,(hpatch_uint64_t)cnext.newPos-(hpatch_uint64_t)(c.newPos+c.length));
+                pushSInt64(buf,(hpatch_uint64_t)cnext.oldPos-(hpatch_uint64_t)(c.oldPos+c.length));
+            }
+        }
+        hpatch_BOOL readTo(hpatch_StreamPos_t readFromPos,unsigned char* out_data,unsigned char* out_data_end){
+            if (readFromPos!=curPos) 
+                return hpatch_FALSE;
+            size_t readLen=out_data_end-out_data;
+            curPos+=readLen;
+            while (readLen>0){
+                if (bufi==buf.size()){
+                    _updateBuf();
+                    _check(bufi<buf.size(),"TCtrlStream readTo");
+                } 
+                size_t cLen=buf.size()-bufi;
+                if (cLen>readLen) cLen=readLen;
+                memcpy(out_data,buf.data()+bufi,cLen);
+                out_data+=cLen;
+                bufi+=cLen;
+                readLen-=cLen;
+            }
+            return hpatch_TRUE;
+        }
+        static hpatch_BOOL _read(const hpatch_TStreamInput* stream,hpatch_StreamPos_t readFromPos,
+                                 unsigned char* out_data,unsigned char* out_data_end){
+            TCtrlStream* self=(TCtrlStream*)stream->streamImport;
+            return self->readTo(readFromPos,out_data,out_data_end);
+        }
+    };
+
+static void serialize_bsdiff(const hpatch_TStreamInput* newData,const hpatch_TStreamInput* oldData,
+                             const TCovers& covers,const hpatch_TStreamOutput* out_diff,
+                             const hdiff_TCompress* compressPlugin,bool isZeroSubDiff=false){
+    std::vector<unsigned char> buf;
+    TDiffStream outDiff(out_diff);
+    size_t ctrlDataSize_pos;
+    size_t subDataSize_pos;
+    {//head
+        buf.clear();
+        pushCStr(buf,kBsDiffVersionType);
+        ctrlDataSize_pos=buf.size();
+        pushUInt64(buf,0); //ctrlDataSize
+        subDataSize_pos=buf.size();
+        pushUInt64(buf,0); //subDataSize
+        pushUInt64(buf,newData->streamSize);
+        outDiff.pushBack(buf.data(),buf.size());
+    }
+    
+    {//ctrl data
+        TCtrlStream ctrlStream(covers);
+        hpatch_StreamPos_t ctrlDataSize=outDiff.pushStream(&ctrlStream,compressPlugin,true);
+
+        buf.clear();
+        pushUInt64(buf,ctrlDataSize);//update ctrlDataSize
+        _check(out_diff->write(out_diff,ctrlDataSize_pos,buf.data(),
+                               buf.data()+buf.size()),"serialize_bsdiff() out_diff->write");
+    }
+
+    {//sub data
+        TNewDataSubDiffStream subStream(newData,oldData,covers,true,isZeroSubDiff);
+        hpatch_StreamPos_t subDataSize=outDiff.pushStream(&subStream,compressPlugin,true);
+
+        buf.clear();
+        pushUInt64(buf,subDataSize);//update subDataSize
+        _check(out_diff->write(out_diff,subDataSize_pos,buf.data(),
+                               buf.data()+buf.size()),"serialize_bsdiff() out_diff->write");
+    }
+
+    {//copy data
+        TNewDataDiffStream diffStream(covers,newData);
+        outDiff.pushStream(&diffStream,compressPlugin,true);
+    }
+}
+
+template<class _TCover,class _TSize>
+static void _to_bsdiff_covers(std::vector<_TCover>& covers,_TSize newSize){
+    if (covers.empty()||(covers[0].newPos!=0)||(covers[0].oldPos!=0)){//begin cover
+        _TCover lc;
+        lc.newPos=0;
+        lc.oldPos=0;
+        lc.length=0;
+        covers.insert(covers.begin(),lc);
+    }
+    {//last cover
+        _TSize lastOldPos=0;
+        if (!covers.empty()){
+            const _TCover& lc=covers[covers.size()-1];
+            lastOldPos=lc.oldPos+lc.length;
+        }
+        _TCover lc;
+        lc.newPos=newSize;
+        lc.oldPos=lastOldPos;
+        lc.length=0;
+        covers.push_back(lc);
+    }
+}
+
+void _create_bsdiff(const unsigned char* newData,const unsigned char* cur_newData_end,const unsigned char* newData_end,
+                    const unsigned char* oldData,const unsigned char* cur_oldData_end,const unsigned char* oldData_end,
+                    const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin,
+                    int kMinSingleMatchScore,bool isUseBigCacheMatch,
+                    ICoverLinesListener* coverLinesListener,size_t threadNum){
+    std::vector<hpatch_TCover_sz> covers;
+    get_match_covers_by_sstring(newData,cur_newData_end,oldData,cur_oldData_end,covers,
+                                kMinSingleMatchScore,isUseBigCacheMatch,coverLinesListener,threadNum);
+
+    _to_bsdiff_covers(covers,(size_t)(newData_end-newData));
+    const TCovers _covers((void*)covers.data(),covers.size(),
+                          sizeof(*covers.data())==sizeof(hpatch_TCover32));
+    
+    hdiff_TStreamInput newStream;
+    hdiff_TStreamInput oldStream;
+    mem_as_hStreamInput(&newStream,newData,newData_end);
+    mem_as_hStreamInput(&oldStream,oldData,oldData_end);
+    
+    serialize_bsdiff(&newStream,&oldStream,_covers,out_diff,compressPlugin);
+}
+
+}//end namespace hdiff_private
+
+using namespace hdiff_private;
+
+void create_bsdiff(const unsigned char* newData,const unsigned char* newData_end,
+                   const unsigned char* oldData,const unsigned char* oldData_end,
+                   const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin,
+                   int kMinSingleMatchScore,bool isUseBigCacheMatch,
+                   ICoverLinesListener* coverLinesListener,size_t threadNum){
+    _create_bsdiff(newData,newData_end,newData_end,oldData,oldData_end,oldData_end,
+                   out_diff,compressPlugin,kMinSingleMatchScore,isUseBigCacheMatch,
+                   coverLinesListener,threadNum);
+}
+void create_bsdiff(const hpatch_TStreamInput* newData,const hpatch_TStreamInput* oldData,
+                   const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin,
+                   int kMinSingleMatchScore,bool isUseBigCacheMatch,
+                   ICoverLinesListener* coverLinesListener,size_t threadNum){
+    TAutoMem oldAndNewData;
+    loadOldAndNewStream(oldAndNewData,oldData,newData);
+    size_t old_size=oldData?(size_t)oldData->streamSize:0;
+    unsigned char* pOldData=oldAndNewData.data();
+    unsigned char* pNewData=pOldData+old_size;
+    unsigned char* pNewDataEnd=pNewData+(size_t)newData->streamSize;
+    _create_bsdiff(pNewData,pNewDataEnd,pNewDataEnd,pOldData,pOldData+old_size,pOldData+old_size,
+                   out_diff,compressPlugin,kMinSingleMatchScore,isUseBigCacheMatch,
+                   coverLinesListener,threadNum);
+}
+
+void create_bsdiff_stream(const hpatch_TStreamInput* newData,const hpatch_TStreamInput* oldData,
+                          const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin,
+                          size_t kMatchBlockSize,const hdiff_TMTSets_s* mtsets){
+    TCoversBuf covers(newData->streamSize,oldData->streamSize);
+    get_match_covers_by_block(newData,oldData,&covers,kMatchBlockSize,mtsets);
+    if (covers._isCover32)
+        _to_bsdiff_covers(covers.m_covers_limit,(hpatch_uint32_t)newData->streamSize);
+    else
+        _to_bsdiff_covers(covers.m_covers_larger,newData->streamSize);
+    covers.update();
+    serialize_bsdiff(newData,oldData,covers,out_diff,compressPlugin,true);
+}
+
+
+void create_bsdiff_block(unsigned char* newData,unsigned char* newData_end,
+                         unsigned char* oldData,unsigned char* oldData_end,
+                         const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin,
+                         int kMinSingleMatchScore,bool isUseBigCacheMatch,
+                         size_t matchBlockSize,size_t threadNum){
+    if (matchBlockSize==0){
+        _create_bsdiff(newData,newData_end,newData_end,oldData,oldData_end,oldData_end,
+                       out_diff,compressPlugin,kMinSingleMatchScore,isUseBigCacheMatch,0,threadNum);
+        return;
+    }
+    TCoversOptimMB<TMatchBlock> coversOp(newData,newData_end,oldData,oldData_end,matchBlockSize,threadNum);
+    _create_bsdiff(newData,coversOp.matchBlock->newData_end_cur,newData_end,
+                   oldData,coversOp.matchBlock->oldData_end_cur,oldData_end,
+                   out_diff,compressPlugin,kMinSingleMatchScore,isUseBigCacheMatch,&coversOp,threadNum);   
+}
+void create_bsdiff_block(const hpatch_TStreamInput* newData,const hpatch_TStreamInput* oldData,
+                         const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin,
+                         int kMinSingleMatchScore,bool isUseBigCacheMatch,
+                         size_t matchBlockSize,size_t threadNum){
+    TAutoMem oldAndNewData;
+    loadOldAndNewStream(oldAndNewData,oldData,newData);
+    size_t old_size=oldData?(size_t)oldData->streamSize:0;
+    unsigned char* pOldData=oldAndNewData.data();
+    unsigned char* pNewData=pOldData+old_size;
+    create_bsdiff_block(pNewData,pNewData+(size_t)newData->streamSize,pOldData,pOldData+old_size,
+                        out_diff,compressPlugin,kMinSingleMatchScore,isUseBigCacheMatch,
+                        matchBlockSize,threadNum);
+}
+
+bool check_bsdiff(const hpatch_TStreamInput* newData,const hpatch_TStreamInput* oldData,
+                  const hpatch_TStreamInput* diffStream,hpatch_TDecompress* decompressPlugin){
+    const size_t kACacheBufSize=hpatch_kFileIOBufBetterSize;
+    TAutoMem _cache(kACacheBufSize*(1+5));
+    _TCheckOutNewDataStream out_newData(newData,_cache.data(),kACacheBufSize);
+    _test_rt(bspatch_with_cache(&out_newData,oldData,diffStream,decompressPlugin,
+                                _cache.data()+kACacheBufSize,_cache.data_end()));
+    _test_rt(out_newData.isWriteFinish());
+    return true;
+}
+bool check_bsdiff(const unsigned char* newData,const unsigned char* newData_end,
+                  const unsigned char* oldData,const unsigned char* oldData_end,
+                  const unsigned char* diffData,const unsigned char* diffData_end,
+                  hpatch_TDecompress* decompressPlugin){
+    hdiff_TStreamInput newStream;
+    hdiff_TStreamInput oldStream;
+    hdiff_TStreamInput diffStream;
+    mem_as_hStreamInput(&newStream,newData,newData_end);
+    mem_as_hStreamInput(&oldStream,oldData,oldData_end);
+    mem_as_hStreamInput(&diffStream,diffData,diffData_end);
+    return check_bsdiff(&newStream,&oldStream,&diffStream,decompressPlugin);
+}

deps/HDiffPatch/bsdiff_wrapper/bsdiff_wrapper.h

@@ -0,0 +1,73 @@
+// bsdiff_wrapper.h
+// HDiffPatch
+/*
+ The MIT License (MIT)
+ Copyright (c) 2021 HouSisong
+ 
+ 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 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 hdiff_bsdiff_wrapper_h
+#define hdiff_bsdiff_wrapper_h
+#include "../libHDiffPatch/HDiff/diff.h"
+
+// create diffFile compatible with bsdiff4
+void create_bsdiff(const unsigned char* newData,const unsigned char* newData_end,
+                   const unsigned char* oldData,const unsigned char* oldData_end,
+                   const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin,
+                   int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                   bool isUseBigCacheMatch=false,ICoverLinesListener* coverLinesListener=0,
+                   size_t threadNum=1);
+void create_bsdiff(const hpatch_TStreamInput* newData,const hpatch_TStreamInput* oldData,
+                   const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin,
+                   int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                   bool isUseBigCacheMatch=false,ICoverLinesListener* coverLinesListener=0,
+                   size_t threadNum=1);
+
+// create diffFile by stream compatible with bsdiff4
+void create_bsdiff_stream(const hpatch_TStreamInput* newData,const hpatch_TStreamInput* oldData,
+                          const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin,
+                          size_t kMatchBlockSize=kMatchBlockSize_default,const hdiff_TMTSets_s* mtsets=0);
+
+bool check_bsdiff(const hpatch_TStreamInput* newData,const hpatch_TStreamInput* oldData,
+                  const hpatch_TStreamInput* diffData,hpatch_TDecompress* decompressPlugin);
+bool check_bsdiff(const unsigned char* newData,const unsigned char* newData_end,
+                  const unsigned char* oldData,const unsigned char* oldData_end,
+                  const unsigned char* diffData,const unsigned char* diffData_end,
+                  hpatch_TDecompress* decompressPlugin);
+
+#include "../libHDiffPatch/HDiff/match_block.h"
+
+void create_bsdiff_block(unsigned char* newData,unsigned char* newData_end,
+                         unsigned char* oldData,unsigned char* oldData_end,
+                         const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin,
+                         int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                         bool isUseBigCacheMatch=false,
+                         size_t matchBlockSize=kDefaultFastMatchBlockSize,
+                         size_t threadNum=1);
+void create_bsdiff_block(const hpatch_TStreamInput* newData,const hpatch_TStreamInput* oldData,
+                         const hpatch_TStreamOutput* out_diff,const hdiff_TCompress* compressPlugin,
+                         int kMinSingleMatchScore=kMinSingleMatchScore_default,
+                         bool isUseBigCacheMatch=false,
+                         size_t matchBlockSize=kDefaultFastMatchBlockSize,
+                         size_t threadNum=1);
+
+#endif

deps/HDiffPatch/bsdiff_wrapper/bspatch_wrapper.c

@@ -0,0 +1,244 @@
+// bspatch_wrapper.c
+// HDiffPatch
+/*
+ The MIT License (MIT)
+ Copyright (c) 2021 HouSisong
+ 
+ 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 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.
+ */
+#include "bspatch_wrapper.h"
+#include "../libHDiffPatch/HPatch/patch_types.h"
+#include "../libHDiffPatch/HPatch/patch_private.h"
+#include <string.h>
+#define _hpatch_FALSE   hpatch_FALSE
+//hpatch_uint __debug_check_false_x=0; //for debug
+//#define _hpatch_FALSE (1/__debug_check_false_x)
+
+#ifndef _IS_RUN_MEM_SAFE_CHECK
+#   define _IS_RUN_MEM_SAFE_CHECK  1
+#endif
+
+#if (_IS_RUN_MEM_SAFE_CHECK)
+//__RUN_MEM_SAFE_CHECK用来启动内存访问越界检查,用以防御可能被意外或故意损坏的数据.
+#   define __RUN_MEM_SAFE_CHECK
+#endif
+
+static const char* kBsDiffVersionType = "BSDIFF40";
+#define            kBsDiffVersionTypeLen 8  // ==strlen(kBsDiffVersionType);
+#define            kBsDiffHeadLen       (kBsDiffVersionTypeLen+3*8)
+
+static hpatch_inline hpatch_uint32_t _readUInt32(const unsigned char* buf){
+    return buf[0] | (((hpatch_uint32_t)buf[1])<<8)  |
+           (((hpatch_uint32_t)buf[2])<<16)  | (((hpatch_uint32_t)buf[3])<<24) ;
+}
+static hpatch_inline hpatch_uint64_t readUInt64(const unsigned char* buf){
+    return _readUInt32(buf) | (((hpatch_uint64_t)_readUInt32(buf+4))<<32);
+}
+
+#define _clip_readUInt64(_clip,_result) { \
+    const unsigned char* buf=_TStreamCacheClip_readData(_clip,8); \
+    if (buf!=0) *(_result)=readUInt64(buf); \
+    else return _hpatch_FALSE; \
+}
+
+hpatch_BOOL getBsDiffInfo(hpatch_BsDiffInfo* out_diffinfo,const hpatch_TStreamInput* diffStream){
+    unsigned char _buf[kBsDiffHeadLen];
+    unsigned char* buf=&_buf[0];
+    if (diffStream->streamSize<kBsDiffHeadLen)
+        return _hpatch_FALSE;
+    if (!diffStream->read(diffStream,0,buf,buf+kBsDiffHeadLen))
+        return _hpatch_FALSE;
+    if (0!=memcmp(buf,kBsDiffVersionType,kBsDiffVersionTypeLen))
+        return _hpatch_FALSE;
+    buf+=kBsDiffVersionTypeLen;
+    out_diffinfo->headSize=kBsDiffHeadLen;
+    out_diffinfo->ctrlDataSize=readUInt64(buf);
+    out_diffinfo->subDataSize =readUInt64(buf+8);
+    out_diffinfo->newDataSize =readUInt64(buf+8*2);
+    return (out_diffinfo->ctrlDataSize<diffStream->streamSize)&&
+           (out_diffinfo->subDataSize<diffStream->streamSize)&&
+           (kBsDiffHeadLen+out_diffinfo->ctrlDataSize+out_diffinfo->subDataSize<diffStream->streamSize);
+}
+
+hpatch_BOOL getBsDiffInfo_mem(hpatch_BsDiffInfo* out_diffinfo,const unsigned char* diffData,const unsigned char* diffData_end){
+    hpatch_TStreamInput diffStream;
+    mem_as_hStreamInput(&diffStream,diffData,diffData_end);
+    return getBsDiffInfo(out_diffinfo,&diffStream);
+}
+
+hpatch_BOOL getIsBsDiff(const hpatch_TStreamInput* diffData){
+    hpatch_BsDiffInfo diffinfo;
+    return getBsDiffInfo(&diffinfo,diffData);
+}
+
+hpatch_BOOL getIsBsDiff_mem(const unsigned char* diffData,const unsigned char* diffData_end){
+    hpatch_TStreamInput diffStream;
+    mem_as_hStreamInput(&diffStream,diffData,diffData_end);
+    return getIsBsDiff(&diffStream);
+}
+
+static hpatch_BOOL _patch_add_old_with_sub(_TOutStreamCache* outCache,TStreamCacheClip* subClip,
+                                           const hpatch_TStreamInput* old,hpatch_uint64_t oldPos,
+                                           hpatch_uint64_t addLength,unsigned char* aCache,hpatch_size_t aCacheSize){
+    while (addLength>0){
+        hpatch_size_t decodeStep=aCacheSize;
+        if (decodeStep>addLength)
+            decodeStep=(hpatch_size_t)addLength;
+        if (!old->read(old,oldPos,aCache,aCache+decodeStep)) return _hpatch_FALSE;
+        if (!_TStreamCacheClip_addDataTo(subClip,aCache,decodeStep)) return _hpatch_FALSE;
+        if (!_TOutStreamCache_write(outCache,aCache,decodeStep)) return _hpatch_FALSE;
+        oldPos+=decodeStep;
+        addLength-=decodeStep;
+    }
+    return hpatch_TRUE;
+}
+
+hpatch_BOOL bspatchByClip(_TOutStreamCache* outCache,const hpatch_TStreamInput* oldData,
+                          TStreamCacheClip* ctrlClip,TStreamCacheClip* subClip,TStreamCacheClip* newDataDiffClip,
+                          unsigned char* temp_cache,hpatch_size_t cache_size){
+    const hpatch_uint64_t newDataSize=_TOutStreamCache_leaveSize(outCache);
+#ifdef __RUN_MEM_SAFE_CHECK
+    const hpatch_uint64_t oldDataSize=oldData->streamSize;
+#endif
+    hpatch_uint64_t     newPosBack=0;
+    hpatch_uint64_t     oldPosBack=0;
+    assert(cache_size>=8);
+    
+    while (newPosBack<newDataSize){
+        hpatch_uint64_t coverLen;
+        hpatch_uint64_t skipNewLen;
+        hpatch_uint64_t skipOldLen;
+        {//read ctrl
+            _clip_readUInt64(ctrlClip,&coverLen);
+            _clip_readUInt64(ctrlClip,&skipNewLen);
+            _clip_readUInt64(ctrlClip,&skipOldLen);
+            if ((skipOldLen>>63)!=0)
+                skipOldLen=-(skipOldLen&((((hpatch_uint64_t)1)<<63)-1));
+        }
+#ifdef __RUN_MEM_SAFE_CHECK
+        if (coverLen>(hpatch_uint64_t)(newDataSize-newPosBack)) return _hpatch_FALSE;
+        if (oldPosBack>oldDataSize) return _hpatch_FALSE;
+        if (coverLen>(hpatch_uint64_t)(oldDataSize-oldPosBack)) return _hpatch_FALSE;
+#endif
+        if (!_patch_add_old_with_sub(outCache,subClip,oldData,oldPosBack,coverLen,
+                                     temp_cache,cache_size)) return _hpatch_FALSE;
+        oldPosBack+=coverLen+skipOldLen;
+        newPosBack+=coverLen;
+        if (skipNewLen){
+#ifdef __RUN_MEM_SAFE_CHECK
+            if (skipNewLen>(hpatch_uint64_t)(newDataSize-newPosBack)) return _hpatch_FALSE;
+#endif
+            if (!_TOutStreamCache_copyFromClip(outCache,newDataDiffClip,skipNewLen)) return _hpatch_FALSE;
+            newPosBack+=skipNewLen;
+        }
+    }
+
+    if (!_TOutStreamCache_flush(outCache))
+        return _hpatch_FALSE;
+    if (_TOutStreamCache_isFinish(outCache)
+        && (newPosBack==newDataSize) )
+        return hpatch_TRUE;
+    else
+        return _hpatch_FALSE;
+}
+
+
+#define _kCacheBsDecCount 5
+
+static const hpatch_uint64_t _kUnknowMaxSize=~(hpatch_uint64_t)0;
+#define _clear_return(exitValue) {  result=exitValue; goto clear; }
+
+hpatch_BOOL bspatch_with_cache(const hpatch_TStreamOutput* out_newData,
+                               const hpatch_TStreamInput*  oldData,
+                               const hpatch_TStreamInput*  compressedDiff,
+                               hpatch_TDecompress* decompressPlugin,
+                               unsigned char* temp_cache,unsigned char* temp_cache_end){
+    hpatch_BsDiffInfo diffInfo;
+    TStreamCacheClip  ctrlClip;
+    TStreamCacheClip  subClip;
+    TStreamCacheClip  newDataDiffClip;
+    _TDecompressInputStream decompressers[3];
+    hpatch_size_t           i;
+    hpatch_BOOL  result=hpatch_TRUE;
+    hpatch_StreamPos_t  diffPos0;
+    hpatch_TStreamInput  _oldDataCache;
+    hpatch_size_t cacheSize;
+    assert(decompressPlugin!=0);
+    assert(out_newData!=0);
+    assert(out_newData->write!=0);
+    assert(oldData!=0);
+    assert(oldData->read!=0);
+    assert(compressedDiff!=0);
+    assert(compressedDiff->read!=0);
+    if (!getBsDiffInfo(&diffInfo,compressedDiff)) 
+        return _hpatch_FALSE;
+    if (out_newData->streamSize!=diffInfo.newDataSize)
+        return _hpatch_FALSE;
+    for (i=0;i<sizeof(decompressers)/sizeof(_TDecompressInputStream);++i)
+        decompressers[i].decompressHandle=0;
+
+    cacheSize=(temp_cache_end-temp_cache);
+    if (cacheSize>=(oldData->streamSize+_kCacheBsDecCount*hpatch_kStreamCacheSize)){//can cache old?
+        cacheSize=(hpatch_size_t)oldData->streamSize;
+        if (!oldData->read(oldData,0,temp_cache,temp_cache+cacheSize))
+            return _hpatch_FALSE;
+        mem_as_hStreamInput(&_oldDataCache,temp_cache,temp_cache+cacheSize);
+        oldData=&_oldDataCache;
+        temp_cache+=cacheSize;
+        cacheSize=(temp_cache_end-temp_cache);
+    }
+    cacheSize=cacheSize/_kCacheBsDecCount;
+    if (cacheSize<8) return _hpatch_FALSE;
+
+    diffPos0=diffInfo.headSize;
+    if (!getStreamClip(&ctrlClip,&decompressers[0],
+                       _kUnknowMaxSize,diffInfo.ctrlDataSize,compressedDiff,&diffPos0,
+                       decompressPlugin,temp_cache,cacheSize)) _clear_return(_hpatch_FALSE);
+    temp_cache+=cacheSize;
+    if (!getStreamClip(&subClip,&decompressers[1],
+                       _kUnknowMaxSize,diffInfo.subDataSize,compressedDiff,&diffPos0,
+                       decompressPlugin,temp_cache,cacheSize)) _clear_return(_hpatch_FALSE);
+    temp_cache+=cacheSize;
+    if (!getStreamClip(&newDataDiffClip,&decompressers[2],
+                       _kUnknowMaxSize,compressedDiff->streamSize-diffPos0,compressedDiff,&diffPos0,
+                       decompressPlugin,temp_cache,cacheSize)) _clear_return(_hpatch_FALSE);
+    temp_cache+=cacheSize;
+    assert(diffPos0==compressedDiff->streamSize);
+
+    {
+        _TOutStreamCache outCache;
+        _TOutStreamCache_init(&outCache,out_newData,temp_cache,cacheSize);
+        temp_cache+=cacheSize;
+        result=bspatchByClip(&outCache,oldData,&ctrlClip,&subClip,&newDataDiffClip,
+                            temp_cache,cacheSize);
+    }
+
+clear:
+    for (i=0;i<sizeof(decompressers)/sizeof(_TDecompressInputStream);++i) {
+        if (decompressers[i].decompressHandle){
+            if (!decompressPlugin->close(decompressPlugin,decompressers[i].decompressHandle))
+                result=_hpatch_FALSE;
+            decompressers[i].decompressHandle=0;
+        }
+    }
+    return result;
+}

deps/HDiffPatch/bsdiff_wrapper/bspatch_wrapper.h

@@ -0,0 +1,57 @@
+// bspatch_wrapper.h
+// HDiffPatch
+/*
+ The MIT License (MIT)
+ Copyright (c) 2021 HouSisong
+ 
+ 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 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 hpatch_bspatch_wrapper_h
+#define hpatch_bspatch_wrapper_h
+#include "../libHDiffPatch/HPatch/patch_types.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct hpatch_BsDiffInfo{
+    hpatch_StreamPos_t  headSize;
+    hpatch_StreamPos_t  ctrlDataSize;
+    hpatch_StreamPos_t  subDataSize;
+    hpatch_StreamPos_t  newDataSize;
+} hpatch_BsDiffInfo;
+
+hpatch_BOOL getIsBsDiff(const hpatch_TStreamInput* diffData);
+hpatch_BOOL getIsBsDiff_mem(const unsigned char* diffData,const unsigned char* diffData_end);
+
+hpatch_BOOL getBsDiffInfo(hpatch_BsDiffInfo* out_diffinfo,const hpatch_TStreamInput* diffStream);
+hpatch_BOOL getBsDiffInfo_mem(hpatch_BsDiffInfo* out_diffinfo,const unsigned char* diffData,const unsigned char* diffData_end);
+
+hpatch_BOOL bspatch_with_cache(const hpatch_TStreamOutput* out_newData,
+                               const hpatch_TStreamInput*  oldData,
+                               const hpatch_TStreamInput*  compressedDiff, //create by bsdiff4 or hdiffz -BSD
+                               hpatch_TDecompress* decompressPlugin, // ==&_bz2DecompressPlugin_unsz in "decompress_plugin_demo.h"
+                               unsigned char* temp_cache,unsigned char* temp_cache_end);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

deps/HDiffPatch/builds/android_ndk_jni_mk/Android.mk

@@ -0,0 +1,128 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := hpatchz
+
+# args
+ZSTD  := 1
+# if open BSD,must open BZIP2
+BSD   := 0
+VCD   := 0
+BZIP2 := 0
+LZMA  := 1
+
+ifeq ($(BZIP2),0)
+  Bz2_Files :=
+else
+  # http://www.bzip.org  https://github.com/sisong/bzip2
+  BZ2_PATH  :=  $(LOCAL_PATH)/../../../bzip2/
+  Bz2_Files :=  $(BZ2_PATH)/blocksort.c \
+  				$(BZ2_PATH)/bzlib.c \
+  				$(BZ2_PATH)/compress.c \
+  				$(BZ2_PATH)/crctable.c \
+  				$(BZ2_PATH)/decompress.c \
+  				$(BZ2_PATH)/huffman.c \
+  				$(BZ2_PATH)/randtable.c
+endif
+
+ifeq ($(LZMA),0)
+  Lzma_Files :=
+else
+  # https://github.com/sisong/lzma
+  LZMA_PATH  := $(LOCAL_PATH)/../../../lzma/C/
+  Lzma_Files := $(LZMA_PATH)/LzmaDec.c \
+                $(LZMA_PATH)/Lzma2Dec.c
+ ifeq ($(TARGET_ARCH_ABI),arm64-v8a)
+  Lzma_Files += $(LZMA_PATH)/../Asm/arm64/LzmaDecOpt.S
+ endif
+  ifeq ($(VCD),0)
+  else
+    Lzma_Files+=$(LZMA_PATH)/7zCrc.c \
+				$(LZMA_PATH)/7zCrcOpt.c \
+				$(LZMA_PATH)/Bra.c \
+				$(LZMA_PATH)/Bra86.c \
+				$(LZMA_PATH)/BraIA64.c \
+				$(LZMA_PATH)/Delta.c \
+				$(LZMA_PATH)/Sha256.c \
+				$(LZMA_PATH)/Sha256Opt.c \
+				$(LZMA_PATH)/Xz.c \
+				$(LZMA_PATH)/XzCrc64.c \
+				$(LZMA_PATH)/XzCrc64Opt.c \
+				$(LZMA_PATH)/XzDec.c \
+				$(LZMA_PATH)/CpuArch.c
+  endif
+endif
+
+ifeq ($(ZSTD),0)
+  Zstd_Files :=
+else
+  # https://github.com/sisong/zstd
+  ZSTD_PATH  := $(LOCAL_PATH)/../../../zstd/lib/
+  Zstd_Files := $(ZSTD_PATH)/common/debug.c \
+  				$(ZSTD_PATH)/common/entropy_common.c \
+  				$(ZSTD_PATH)/common/error_private.c \
+  				$(ZSTD_PATH)/common/fse_decompress.c \
+  				$(ZSTD_PATH)/common/xxhash.c \
+  				$(ZSTD_PATH)/common/zstd_common.c \
+  				$(ZSTD_PATH)/decompress/huf_decompress.c \
+  				$(ZSTD_PATH)/decompress/zstd_ddict.c \
+  				$(ZSTD_PATH)/decompress/zstd_decompress.c \
+  				$(ZSTD_PATH)/decompress/zstd_decompress_block.c
+endif
+
+HDP_PATH  := $(LOCAL_PATH)/../../
+Hdp_Files := $(HDP_PATH)/file_for_patch.c \
+             $(HDP_PATH)/libHDiffPatch/HPatch/patch.c
+ifeq ($(BSD),0)
+else
+  Hdp_Files += $(HDP_PATH)/bsdiff_wrapper/bspatch_wrapper.c
+endif
+ifeq ($(VCD),0)
+else
+  Hdp_Files += $(HDP_PATH)/vcdiff_wrapper/vcpatch_wrapper.c
+  Hdp_Files += $(HDP_PATH)/libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.c
+endif
+
+Src_Files := $(LOCAL_PATH)/hpatch_jni.c \
+             $(LOCAL_PATH)/hpatch.c
+
+DEF_FLAGS := -D_IS_NEED_CACHE_OLD_BY_COVERS=0 -D_IS_NEED_DEFAULT_CompressPlugin=0
+DEF_FLAGS += -D_CompressPlugin_zlib
+ifeq ($(BSD),0)
+  DEF_FLAGS += -D_IS_NEED_BSDIFF=0
+else
+  DEF_FLAGS += -D_IS_NEED_BSDIFF=1
+endif
+ifeq ($(VCD),0)
+  DEF_FLAGS += -D_IS_NEED_VCDIFF=0
+else
+  DEF_FLAGS += -D_IS_NEED_VCDIFF=1
+endif
+ifeq ($(BZIP2),0)
+else
+  DEF_FLAGS += -D_CompressPlugin_bz2 -DBZ_NO_STDIO -I$(BZ2_PATH)
+endif
+ifeq ($(LZMA),0)
+else
+  DEF_FLAGS += -D_CompressPlugin_lzma -D_CompressPlugin_lzma2 -D_7ZIP_ST -I$(LZMA_PATH)
+  ifeq ($(TARGET_ARCH_ABI),arm64-v8a)
+    DEF_FLAGS += -D_LZMA_DEC_OPT
+  endif
+  ifeq ($(VCD),0)
+  else
+    DEF_FLAGS += -D_CompressPlugin_7zXZ
+  endif
+endif
+ifeq ($(ZSTD),0)
+else
+  DEF_FLAGS += -D_CompressPlugin_zstd -I$(ZSTD_PATH) -I$(ZSTD_PATH)/common -I$(ZSTD_PATH)/decompress \
+        -DZSTD_HAVE_WEAK_SYMBOLS=0 -DZSTD_TRACE=0 -DZSTD_DISABLE_ASM=1 -DZSTDLIB_VISIBLE= -DZSTDLIB_HIDDEN= \
+		-DDYNAMIC_BMI2=0 -DZSTD_LEGACY_SUPPORT=0 -DZSTD_LIB_DEPRECATED=0 -DHUF_FORCE_DECOMPRESS_X1=1 \
+		-DZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT=1 -DZSTD_NO_INLINE=1 -DZSTD_STRIP_ERROR_STRINGS=1
+endif
+
+LOCAL_SRC_FILES  := $(Src_Files) $(Bz2_Files) $(Lzma_Files) $(Zstd_Files) $(Hdp_Files)
+LOCAL_LDLIBS     := -llog -lz
+LOCAL_CFLAGS     := -Os -DANDROID_NDK -DNDEBUG -D_LARGEFILE_SOURCE $(DEF_FLAGS)
+include $(BUILD_SHARED_LIBRARY)
+

deps/HDiffPatch/builds/android_ndk_jni_mk/Application.mk

@@ -0,0 +1,7 @@
+APP_PLATFORM := android-14
+APP_CFLAGS += -Wno-error=format-security
+APP_CFLAGS += -fvisibility=hidden -fvisibility-inlines-hidden
+APP_CFLAGS += -ffunction-sections -fdata-sections
+APP_LDFLAGS += -Wl,--gc-sections
+APP_BUILD_SCRIPT := Android.mk
+APP_ABI := armeabi armeabi-v7a arm64-v8a x86 x86_64

deps/HDiffPatch/builds/android_ndk_jni_mk/build_libs.bat

@@ -0,0 +1 @@
+ndk-build NDK_PROJECT_PATH=.  APP_BUILD_SCRIPT=Android.mk  NDK_APPLICATION_MK=Application.mk

deps/HDiffPatch/builds/android_ndk_jni_mk/build_libs.sh

@@ -0,0 +1 @@
+ndk-build NDK_PROJECT_PATH=.  APP_BUILD_SCRIPT=Android.mk  NDK_APPLICATION_MK=Application.mk

deps/HDiffPatch/builds/android_ndk_jni_mk/build_libs_patchers.bat

@@ -0,0 +1 @@
+ndk-build NDK_PROJECT_PATH=.  APP_BUILD_SCRIPT=Android.mk  NDK_APPLICATION_MK=Application.mk BSD=1 VCD=1 BZIP2=1

deps/HDiffPatch/builds/android_ndk_jni_mk/build_libs_patchers.sh

@@ -0,0 +1 @@
+ndk-build NDK_PROJECT_PATH=.  APP_BUILD_SCRIPT=Android.mk  NDK_APPLICATION_MK=Application.mk BSD=1 VCD=1 BZIP2=1

deps/HDiffPatch/builds/android_ndk_jni_mk/hpatch.c

@@ -0,0 +1,35 @@
+// hpatch.c
+// Created by sisong on 2019-12-30.
+#include "hpatch.h"
+
+#ifndef _IS_USED_MULTITHREAD
+#define _IS_USED_MULTITHREAD            0
+#endif
+#define _IS_NEED_DIR_DIFF_PATCH         0
+#define _IS_NEED_MAIN                   0
+#define _IS_NEED_CMDLINE                0
+#define _IS_NEED_SFX                    0
+#define _IS_NEED_ALL_CompressPlugin     0
+#include "../../hpatchz.c"
+
+#ifdef _CompressPlugin_bz2
+# ifdef BZ_NO_STDIO
+#ifdef __cplusplus
+extern "C" {
+#endif
+void bz_internal_error(int errcode){
+    fprintf(stderr,"\n\nbzip2 v%s: internal error number %d.\n",
+            BZ2_bzlibVersion(),errcode);
+    exit(3);
+}
+#ifdef __cplusplus
+}
+#endif
+# endif
+#endif
+
+int hpatchz(const char *oldFileName,const char *diffFileName,
+            const char *outNewFileName, size_t cacheMemory){
+    return hpatch(oldFileName,diffFileName,outNewFileName,
+                  hpatch_FALSE,cacheMemory,0,0,1);
+}

deps/HDiffPatch/builds/android_ndk_jni_mk/hpatch.h

@@ -0,0 +1,20 @@
+// hpatch.h
+// Created by sisong on 2019-12-30.
+#ifndef hpatch_h
+#define hpatch_h
+#include <assert.h>
+#include <string.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+    #define H_PATCH_EXPORT __attribute__((visibility("default")))
+    
+    // return THPatchResult, 0 is ok
+    //  'diffFileName' file is create by hdiffz app,or by create_compressed_diff(),create_compressed_diff_stream()
+    int hpatchz(const char *oldFileName,const char *diffFileName,
+                const char *outNewFileName, size_t cacheMemory) H_PATCH_EXPORT;
+
+#ifdef __cplusplus
+}
+#endif
+#endif // hpatch_h

deps/HDiffPatch/builds/android_ndk_jni_mk/hpatch_jni.c

@@ -0,0 +1,48 @@
+// hpatch_jni.c
+// Created by sisong on 2019-09-30.
+#include <jni.h>
+#include "hpatch.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+    #define HPATCH_OPTIONS_ERROR 1
+    #define _check_rt(v)              do { if (!(v)) { result=HPATCH_OPTIONS_ERROR; goto _clear; }; } while(0)
+    #define __j2cstr_(jstr,cstr)      do { (cstr)=(*jenv)->GetStringUTFChars(jenv,jstr,NULL); _check_rt(cstr); } while(0)
+    #define _check_j2cstr(jstr,cstr)  do { _check_rt(jstr); __j2cstr_(jstr,cstr); } while(0)
+    #define _check_jn2cstr(jstr,cstr) do { if (jstr) __j2cstr_(jstr,cstr); else (cstr)=0; } while(0)
+    #define _jrelease_cstr(jstr,cstr) do { if (cstr) (*jenv)->ReleaseStringUTFChars(jenv,jstr,cstr); } while(0)
+
+
+    static size_t getCacheMemory(jlong cacheMemory){
+        #define kPatchCacheSize_default  (1024*256)
+        #define kPatchCacheSize_max ((jlong)((size_t)(~(size_t)0)))
+        if (cacheMemory<0) return kPatchCacheSize_default;
+        if (sizeof(jlong)<=sizeof(size_t)) return (size_t)cacheMemory;
+        return (size_t)((cacheMemory<kPatchCacheSize_max)?cacheMemory:kPatchCacheSize_max);
+    }
+
+    JNIEXPORT int
+    Java_com_github_sisong_HPatch_patch(JNIEnv* jenv,jobject jobj,
+                                        jstring oldFileName,jstring diffFileName,
+                                        jstring outNewFileName,jlong cacheMemory){
+        const char* cOldFileName   =0;
+        const char* cDiffFileName  =0;
+        const char* cOutNewFileName=0;
+        size_t cCacheMemory=getCacheMemory(cacheMemory);
+        int result=0;
+
+        _check_jn2cstr(oldFileName,cOldFileName);
+        _check_j2cstr(diffFileName,cDiffFileName);
+        _check_j2cstr(outNewFileName,cOutNewFileName);
+        result=hpatchz(cOldFileName,cDiffFileName,cOutNewFileName,cCacheMemory);
+    _clear:
+        _jrelease_cstr(outNewFileName,cOutNewFileName);
+        _jrelease_cstr(diffFileName,cDiffFileName);
+        _jrelease_cstr(oldFileName,cOldFileName);
+        return result;
+    }
+    
+#ifdef __cplusplus
+}
+#endif
+

deps/HDiffPatch/builds/android_ndk_jni_mk/java/com/github/sisong/HPatch.java

@@ -0,0 +1,23 @@
+package com.github.sisong;
+
+public class HPatch{
+
+    // auto load libhpatchz.so ?
+    // static { System.loadLibrary("hpatchz"); }
+
+    // return THPatchResult, 0 is ok
+    //  different cacheMemory only affects patch speed, if cacheMemory<0 then default 256*1024;
+    //  if diffFile created by hdiffz,hdiffz -SD,hdiffz -VCD,bsdiff4,hdiffz -BSD,
+    //     then cacheMemory recommended 256*1024,1024*1024,...
+    //  if diffFile created by xdelta3(-S,-S lzma),open-vcdiff, and patch very slow,
+    //     then cacheMemory recommended sourceWindowSize+targetWindowSize+256*1024;
+    //       ( window sizes is set when diff, C API getVcDiffInfo() can got values. )
+    //  if diffFile created by bsdiff4, and patch very slow,
+    //     then cacheMemory recommended oldFileSize+256*1024;
+    public static native int patch(String oldFileName,String diffFileName,
+                                   String outNewFileName,long cacheMemory);
+
+    public static int patch(String oldFileName,String diffFileName,String outNewFileName){
+        return patch(oldFileName,diffFileName,outNewFileName,-1);
+    }
+}

deps/HDiffPatch/builds/codeblocks/HDiffPatch.workspace

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_workspace_file>
+	<Workspace title="HDiffPatch_Workspace">
+		<Project filename="hdiffz.cbp" />
+		<Project filename="hpatchz.cbp" />
+		<Project filename="unitTest.cbp" />
+	</Workspace>
+</CodeBlocks_workspace_file>

deps/HDiffPatch/builds/codeblocks/HDiffZ.cbp

@@ -0,0 +1,380 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="6" />
+	<Project>
+		<Option title="hdiffz" />
+		<Option pch_mode="2" />
+		<Option compiler="gcc" />
+		<Build>
+			<Target title="Debug">
+				<Option output="bin/Debug/hdiffz" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Debug/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-g" />
+				</Compiler>
+			</Target>
+			<Target title="Release">
+				<Option output="bin/Release/hdiffz" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Release/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-O3" />
+					<Add option="-Wno-error=format-security" />
+					<Add option="-fvisibility=hidden -fvisibility-inlines-hidden" />
+					<Add option="-ffunction-sections -fdata-sections" />
+					<Add option="-ffat-lto-objects -flto" />
+					<Add option="-DNDEBUG" />
+				</Compiler>
+				<Linker>
+					<Add option="-s" />
+					<Add option="-Wl,--gc-sections,--as-needed" />
+				</Linker>
+			</Target>
+			<Target title="Release_x86">
+				<Option output="bin/Release_x86/hdiffz" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Release_x86/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-march=i586" />
+					<Add option="-O3" />
+					<Add option="-m32" />
+					<Add option="-Wno-error=format-security" />
+					<Add option="-fvisibility=hidden -fvisibility-inlines-hidden" />
+					<Add option="-ffunction-sections -fdata-sections" />
+					<Add option="-ffat-lto-objects -flto" />
+					<Add option="-DNDEBUG" />
+				</Compiler>
+				<Linker>
+					<Add option="-s" />
+					<Add option="-m32" />
+					<Add option="-Wl,--gc-sections,--as-needed" />
+				</Linker>
+			</Target>
+		</Build>
+		<Compiler>
+			<Add option="-Wall" />
+			<Add option="-fexceptions" />
+			<Add option="-D_LARGEFILE_SOURCE" />
+			<Add option="-D_FILE_OFFSET_BITS=64" />
+			<Add option="-D_IS_USED_PTHREAD=1" />
+			<Add option="-D_ChecksumPlugin_md5" />
+			<Add option="-DZSTD_MULTITHREAD=1" />
+			<Add option="-DZSTD_HAVE_WEAK_SYMBOLS=0" />
+			<Add option="-DZSTD_TRACE=0" />
+			<Add option="-DZSTD_DISABLE_ASM=1" />
+			<Add option="-DZSTDLIB_VISIBLE=" />
+			<Add option="-DZSTDLIB_HIDDEN=" />
+			<Add directory="../../../lzma/C/" />
+			<Add directory="../../../zstd/lib" />
+			<Add directory="../../../libmd5" />
+		</Compiler>
+		<Linker>
+			<Add library="pthread" />
+		</Linker>
+		<Unit filename="../../../bzip2/blocksort.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../bzip2/bzlib.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../bzip2/bzlib.h" />
+		<Unit filename="../../../bzip2/compress.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../bzip2/crctable.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../bzip2/decompress.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../bzip2/huffman.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../bzip2/randtable.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../libmd5/md5.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../libmd5/md5.h" />
+		<Unit filename="../../../lzma/C/7zCrc.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/7zCrcOpt.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/Alloc.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/Bra.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/Bra86.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/BraIA64.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/CpuArch.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/Delta.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/LzFind.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/LzFindMt.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/LzFindOpt.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/Lzma2Dec.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/Lzma2DecMt.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/Lzma2Enc.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/LzmaDec.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/LzmaEnc.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/MtCoder.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/MtDec.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/Sha256.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/Threads.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/Xz.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/XzCrc64.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/XzDec.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/XzEnc.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zlib/adler32.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zlib/crc32.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zlib/deflate.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zlib/inffast.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zlib/inflate.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zlib/inftrees.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zlib/trees.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zlib/zlib.h" />
+		<Unit filename="../../../zlib/zutil.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/common/bitstream.h" />
+		<Unit filename="../../../zstd/lib/common/compiler.h" />
+		<Unit filename="../../../zstd/lib/common/cpu.h" />
+		<Unit filename="../../../zstd/lib/common/debug.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/common/debug.h" />
+		<Unit filename="../../../zstd/lib/common/entropy_common.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/common/error_private.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/common/error_private.h" />
+		<Unit filename="../../../zstd/lib/common/fse.h" />
+		<Unit filename="../../../zstd/lib/common/fse_decompress.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/common/huf.h" />
+		<Unit filename="../../../zstd/lib/common/mem.h" />
+		<Unit filename="../../../zstd/lib/common/pool.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/common/pool.h" />
+		<Unit filename="../../../zstd/lib/common/threading.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/common/threading.h" />
+		<Unit filename="../../../zstd/lib/common/xxhash.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/common/xxhash.h" />
+		<Unit filename="../../../zstd/lib/common/zstd_common.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/common/zstd_deps.h" />
+		<Unit filename="../../../zstd/lib/common/zstd_internal.h" />
+		<Unit filename="../../../zstd/lib/common/zstd_trace.h" />
+		<Unit filename="../../../zstd/lib/compress/fse_compress.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/compress/hist.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/compress/hist.h" />
+		<Unit filename="../../../zstd/lib/compress/huf_compress.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/compress/zstd_compress.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/compress/zstd_compress_internal.h" />
+		<Unit filename="../../../zstd/lib/compress/zstd_compress_literals.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/compress/zstd_compress_literals.h" />
+		<Unit filename="../../../zstd/lib/compress/zstd_compress_sequences.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/compress/zstd_compress_sequences.h" />
+		<Unit filename="../../../zstd/lib/compress/zstd_compress_superblock.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/compress/zstd_compress_superblock.h" />
+		<Unit filename="../../../zstd/lib/compress/zstd_cwksp.h" />
+		<Unit filename="../../../zstd/lib/compress/zstd_double_fast.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/compress/zstd_double_fast.h" />
+		<Unit filename="../../../zstd/lib/compress/zstd_fast.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/compress/zstd_fast.h" />
+		<Unit filename="../../../zstd/lib/compress/zstd_lazy.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/compress/zstd_lazy.h" />
+		<Unit filename="../../../zstd/lib/compress/zstd_ldm.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/compress/zstd_ldm.h" />
+		<Unit filename="../../../zstd/lib/compress/zstd_ldm_geartab.h" />
+		<Unit filename="../../../zstd/lib/compress/zstd_opt.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/compress/zstd_opt.h" />
+		<Unit filename="../../../zstd/lib/compress/zstdmt_compress.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/compress/zstdmt_compress.h" />
+		<Unit filename="../../../zstd/lib/decompress/huf_decompress.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/decompress/zstd_ddict.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/decompress/zstd_ddict.h" />
+		<Unit filename="../../../zstd/lib/decompress/zstd_decompress.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/decompress/zstd_decompress_block.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/decompress/zstd_decompress_block.h" />
+		<Unit filename="../../../zstd/lib/decompress/zstd_decompress_internal.h" />
+		<Unit filename="../../bsdiff_wrapper/bsdiff_wrapper.cpp" />
+		<Unit filename="../../bsdiff_wrapper/bspatch_wrapper.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../compress_parallel.cpp" />
+		<Unit filename="../../compress_parallel.h" />
+		<Unit filename="../../dirDiffPatch/dir_diff/dir_diff.cpp" />
+		<Unit filename="../../dirDiffPatch/dir_diff/dir_diff.h" />
+		<Unit filename="../../dirDiffPatch/dir_diff/dir_diff_tools.cpp" />
+		<Unit filename="../../dirDiffPatch/dir_diff/dir_manifest.cpp" />
+		<Unit filename="../../dirDiffPatch/dir_patch/dir_patch.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../dirDiffPatch/dir_patch/dir_patch.h" />
+		<Unit filename="../../dirDiffPatch/dir_patch/dir_patch_tools.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../dirDiffPatch/dir_patch/new_dir_output.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../dirDiffPatch/dir_patch/new_stream.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../dirDiffPatch/dir_patch/new_stream.h" />
+		<Unit filename="../../dirDiffPatch/dir_patch/ref_stream.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../dirDiffPatch/dir_patch/ref_stream.h" />
+		<Unit filename="../../dirDiffPatch/dir_patch/res_handle_limit.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../dirDiffPatch/dir_patch/res_handle_limit.h" />
+		<Unit filename="../../dirDiffPatch/file_for_dirDiff.h" />
+		<Unit filename="../../dirDiffPatch/file_for_dirPatch.h" />
+		<Unit filename="../../file_for_patch.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../hdiffz.cpp" />
+		<Unit filename="../../hdiffz_import_patch.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../libHDiffPatch/HDiff/diff.cpp" />
+		<Unit filename="../../libHDiffPatch/HDiff/match_block.cpp" />
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/bytes_rle.cpp" />
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/compress_detect.cpp" />
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/libdivsufsort/divsufsort.cpp" />
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/libdivsufsort/divsufsort64.cpp" />
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/limit_mem_diff/digest_matcher.cpp" />
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/limit_mem_diff/stream_serialize.cpp" />
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/suffix_string.cpp" />
+		<Unit filename="../../libHDiffPatch/HPatch/patch.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../libHDiffPatch/HPatchLite/hpatch_lite.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../libParallel/parallel_channel.cpp" />
+		<Unit filename="../../libParallel/parallel_channel.h" />
+		<Unit filename="../../libParallel/parallel_import.cpp" />
+		<Unit filename="../../libParallel/parallel_import.h" />
+		<Unit filename="../../vcdiff_wrapper/vcdiff_wrapper.cpp" />
+		<Unit filename="../../vcdiff_wrapper/vcpatch_wrapper.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Extensions>
+			<envvars />
+			<code_completion />
+			<lib_finder disable_auto="1" />
+			<debugger />
+		</Extensions>
+	</Project>
+</CodeBlocks_project_file>

deps/HDiffPatch/builds/codeblocks/HPatchZ.cbp

@@ -0,0 +1,255 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="6" />
+	<Project>
+		<Option title="hpatchz" />
+		<Option pch_mode="2" />
+		<Option compiler="gcc" />
+		<Build>
+			<Target title="Debug">
+				<Option output="bin/Debug/hpatchz" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Debug/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-g" />
+				</Compiler>
+			</Target>
+			<Target title="Release">
+				<Option output="bin/Release/hpatchz" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Release/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-fomit-frame-pointer" />
+					<Add option="-O3" />
+					<Add option="-Wno-error=format-security" />
+					<Add option="-fvisibility=hidden" />
+					<Add option="-ffunction-sections -fdata-sections" />
+					<Add option="-ffat-lto-objects -flto" />
+					<Add option="-DNDEBUG" />
+				</Compiler>
+				<Linker>
+					<Add option="-s" />
+					<Add option="-Wl,--gc-sections,--as-needed" />
+				</Linker>
+			</Target>
+			<Target title="Release_x86">
+				<Option output="bin/Release_x86/hpatchz" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Release_x86/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-fomit-frame-pointer" />
+					<Add option="-O3" />
+					<Add option="-m32" />
+					<Add option="-Wno-error=format-security" />
+					<Add option="-fvisibility=hidden" />
+					<Add option="-ffunction-sections -fdata-sections" />
+					<Add option="-ffat-lto-objects -flto" />
+					<Add option="-DNDEBUG" />
+				</Compiler>
+				<Linker>
+					<Add option="-s" />
+					<Add option="-m32" />
+					<Add option="-Wl,--gc-sections,--as-needed" />
+				</Linker>
+			</Target>
+		</Build>
+		<Compiler>
+			<Add option="-Wall" />
+			<Add option="-fexceptions" />
+			<Add option="-D_LARGEFILE_SOURCE" />
+			<Add option="-D_FILE_OFFSET_BITS=64" />
+			<Add option="-D_ChecksumPlugin_md5" />
+			<Add option="-DZSTD_HAVE_WEAK_SYMBOLS=0" />
+			<Add option="-DZSTD_TRACE=0" />
+			<Add option="-DZSTD_DISABLE_ASM=1" />
+			<Add option="-DZSTDLIB_VISIBLE=" />
+			<Add option="-DZSTDLIB_HIDDEN=" />
+			<Add directory="../../../lzma/C/" />
+			<Add directory="../../../zstd/lib" />
+			<Add directory="../../../libmd5" />
+		</Compiler>
+		<Unit filename="../../../bzip2/blocksort.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../bzip2/bzlib.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../bzip2/bzlib.h" />
+		<Unit filename="../../../bzip2/compress.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../bzip2/crctable.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../bzip2/decompress.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../bzip2/huffman.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../bzip2/randtable.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../libmd5/md5.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../libmd5/md5.h" />
+		<Unit filename="../../../lzma/C/7zCrc.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/7zCrcOpt.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/Bra.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/Bra86.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/BraIA64.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/CpuArch.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/Delta.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/Lzma2Dec.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/LzmaDec.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/Sha256.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/Xz.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/XzCrc64.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../lzma/C/XzDec.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zlib/adler32.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zlib/crc32.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zlib/inffast.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zlib/inflate.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zlib/inftrees.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zlib/trees.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zlib/zlib.h" />
+		<Unit filename="../../../zlib/zutil.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/common/bitstream.h" />
+		<Unit filename="../../../zstd/lib/common/compiler.h" />
+		<Unit filename="../../../zstd/lib/common/cpu.h" />
+		<Unit filename="../../../zstd/lib/common/debug.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/common/debug.h" />
+		<Unit filename="../../../zstd/lib/common/entropy_common.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/common/error_private.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/common/error_private.h" />
+		<Unit filename="../../../zstd/lib/common/fse.h" />
+		<Unit filename="../../../zstd/lib/common/fse_decompress.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/common/huf.h" />
+		<Unit filename="../../../zstd/lib/common/mem.h" />
+		<Unit filename="../../../zstd/lib/common/xxhash.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/common/xxhash.h" />
+		<Unit filename="../../../zstd/lib/common/zstd_common.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/common/zstd_deps.h" />
+		<Unit filename="../../../zstd/lib/common/zstd_internal.h" />
+		<Unit filename="../../../zstd/lib/common/zstd_trace.h" />
+		<Unit filename="../../../zstd/lib/decompress/huf_decompress.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/decompress/zstd_ddict.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/decompress/zstd_ddict.h" />
+		<Unit filename="../../../zstd/lib/decompress/zstd_decompress.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/decompress/zstd_decompress_block.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../../zstd/lib/decompress/zstd_decompress_block.h" />
+		<Unit filename="../../../zstd/lib/decompress/zstd_decompress_internal.h" />
+		<Unit filename="../../../zstd/lib/zstd.h" />
+		<Unit filename="../../bsdiff_wrapper/bspatch_wrapper.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../dirDiffPatch/dir_patch/dir_patch.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../dirDiffPatch/dir_patch/dir_patch.h" />
+		<Unit filename="../../dirDiffPatch/dir_patch/dir_patch_tools.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../dirDiffPatch/dir_patch/new_dir_output.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../dirDiffPatch/dir_patch/new_stream.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../dirDiffPatch/dir_patch/new_stream.h" />
+		<Unit filename="../../dirDiffPatch/dir_patch/ref_stream.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../dirDiffPatch/dir_patch/ref_stream.h" />
+		<Unit filename="../../dirDiffPatch/dir_patch/res_handle_limit.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../dirDiffPatch/dir_patch/res_handle_limit.h" />
+		<Unit filename="../../file_for_patch.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../hpatchz.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.h" />
+		<Unit filename="../../libHDiffPatch/HPatch/patch.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../vcdiff_wrapper/vcpatch_wrapper.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Extensions>
+			<envvars />
+			<code_completion />
+			<lib_finder disable_auto="1" />
+			<debugger />
+		</Extensions>
+	</Project>
+</CodeBlocks_project_file>

deps/HDiffPatch/builds/codeblocks/unitTest.cbp

@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
+<CodeBlocks_project_file>
+	<FileVersion major="1" minor="6" />
+	<Project>
+		<Option title="unitTest" />
+		<Option pch_mode="2" />
+		<Option compiler="gcc" />
+		<Build>
+			<Target title="Debug">
+				<Option output="bin/Debug/unitTest" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Debug/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-g" />
+				</Compiler>
+			</Target>
+			<Target title="Release">
+				<Option output="bin/Release/unitTest" prefix_auto="1" extension_auto="1" />
+				<Option object_output="obj/Release/" />
+				<Option type="1" />
+				<Option compiler="gcc" />
+				<Compiler>
+					<Add option="-O2" />
+				</Compiler>
+				<Linker>
+					<Add option="-s" />
+				</Linker>
+			</Target>
+		</Build>
+		<Compiler>
+			<Add option="-Wall" />
+			<Add option="-fexceptions" />
+		</Compiler>
+		<Linker>
+			<Add library="libz" />
+			<Add library="libbz2" />
+			<Add library="libpthread" />
+		</Linker>
+		<Unit filename="../../libHDiffPatch/HDiff/diff.cpp" />
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/bytes_rle.cpp" />
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/compress_detect.cpp" />
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/libdivsufsort/divsufsort.cpp" />
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/libdivsufsort/divsufsort64.cpp" />
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/limit_mem_diff/digest_matcher.cpp" />
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/limit_mem_diff/stream_serialize.cpp" />
+		<Unit filename="../../libHDiffPatch/HDiff/private_diff/suffix_string.cpp" />
+		<Unit filename="../../libHDiffPatch/HPatch/patch.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../libHDiffPatch/HPatchLite/hpatch_lite.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="../../libParallel/parallel_channel.cpp" />
+		<Unit filename="../../libParallel/parallel_import.cpp" />
+		<Unit filename="../../test/unit_test.cpp" />
+		<Extensions>
+			<envvars />
+			<code_completion />
+			<lib_finder disable_auto="1" />
+			<debugger />
+		</Extensions>
+	</Project>
+</CodeBlocks_project_file>

deps/HDiffPatch/builds/vc/HDiffPatch.sln

@@ -0,0 +1,173 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.31402.337
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "hdiffz", "hdiffz.vcxproj", "{63934A83-25F5-4161-B19D-DFBAB1C257F1}"
+	ProjectSection(ProjectDependencies) = postProject
+		{16415855-B9F4-4A5D-A096-C3380CFC6008} = {16415855-B9F4-4A5D-A096-C3380CFC6008}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "hpatchz", "hpatchz.vcxproj", "{F912761C-2C5B-4EB9-8666-C2320A9AF407}"
+	ProjectSection(ProjectDependencies) = postProject
+		{16415855-B9F4-4A5D-A096-C3380CFC6008} = {16415855-B9F4-4A5D-A096-C3380CFC6008}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "unitTest", "unitTest.vcxproj", "{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}"
+	ProjectSection(ProjectDependencies) = postProject
+		{35ED7715-6B17-4225-8171-C954968D8F8C} = {35ED7715-6B17-4225-8171-C954968D8F8C}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "zstd", "zstd.vcxproj", "{16415855-B9F4-4A5D-A096-C3380CFC6008}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "bzip2", "bzip2.vcxproj", "{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "lzma", "lzma.vcxproj", "{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "zlib", "zlib.vcxproj", "{35ED7715-6B17-4225-8171-C954968D8F8C}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testHashClash", "testHashClash.vcxproj", "{22873560-BDA7-4915-8C7D-DF7C380B4E55}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|ARM = Debug|ARM
+		Debug|ARM64 = Debug|ARM64
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|ARM = Release|ARM
+		Release|ARM64 = Release|ARM64
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{63934A83-25F5-4161-B19D-DFBAB1C257F1}.Debug|ARM.ActiveCfg = Debug|ARM
+		{63934A83-25F5-4161-B19D-DFBAB1C257F1}.Debug|ARM.Build.0 = Debug|ARM
+		{63934A83-25F5-4161-B19D-DFBAB1C257F1}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{63934A83-25F5-4161-B19D-DFBAB1C257F1}.Debug|ARM64.Build.0 = Debug|ARM64
+		{63934A83-25F5-4161-B19D-DFBAB1C257F1}.Debug|x64.ActiveCfg = Debug|x64
+		{63934A83-25F5-4161-B19D-DFBAB1C257F1}.Debug|x64.Build.0 = Debug|x64
+		{63934A83-25F5-4161-B19D-DFBAB1C257F1}.Debug|x86.ActiveCfg = Debug|Win32
+		{63934A83-25F5-4161-B19D-DFBAB1C257F1}.Debug|x86.Build.0 = Debug|Win32
+		{63934A83-25F5-4161-B19D-DFBAB1C257F1}.Release|ARM.ActiveCfg = Release|ARM
+		{63934A83-25F5-4161-B19D-DFBAB1C257F1}.Release|ARM.Build.0 = Release|ARM
+		{63934A83-25F5-4161-B19D-DFBAB1C257F1}.Release|ARM64.ActiveCfg = Release|ARM64
+		{63934A83-25F5-4161-B19D-DFBAB1C257F1}.Release|ARM64.Build.0 = Release|ARM64
+		{63934A83-25F5-4161-B19D-DFBAB1C257F1}.Release|x64.ActiveCfg = Release|x64
+		{63934A83-25F5-4161-B19D-DFBAB1C257F1}.Release|x64.Build.0 = Release|x64
+		{63934A83-25F5-4161-B19D-DFBAB1C257F1}.Release|x86.ActiveCfg = Release|Win32
+		{63934A83-25F5-4161-B19D-DFBAB1C257F1}.Release|x86.Build.0 = Release|Win32
+		{F912761C-2C5B-4EB9-8666-C2320A9AF407}.Debug|ARM.ActiveCfg = Debug|ARM
+		{F912761C-2C5B-4EB9-8666-C2320A9AF407}.Debug|ARM.Build.0 = Debug|ARM
+		{F912761C-2C5B-4EB9-8666-C2320A9AF407}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{F912761C-2C5B-4EB9-8666-C2320A9AF407}.Debug|ARM64.Build.0 = Debug|ARM64
+		{F912761C-2C5B-4EB9-8666-C2320A9AF407}.Debug|x64.ActiveCfg = Debug|x64
+		{F912761C-2C5B-4EB9-8666-C2320A9AF407}.Debug|x64.Build.0 = Debug|x64
+		{F912761C-2C5B-4EB9-8666-C2320A9AF407}.Debug|x86.ActiveCfg = Debug|Win32
+		{F912761C-2C5B-4EB9-8666-C2320A9AF407}.Debug|x86.Build.0 = Debug|Win32
+		{F912761C-2C5B-4EB9-8666-C2320A9AF407}.Release|ARM.ActiveCfg = Release|ARM
+		{F912761C-2C5B-4EB9-8666-C2320A9AF407}.Release|ARM.Build.0 = Release|ARM
+		{F912761C-2C5B-4EB9-8666-C2320A9AF407}.Release|ARM64.ActiveCfg = Release|ARM64
+		{F912761C-2C5B-4EB9-8666-C2320A9AF407}.Release|ARM64.Build.0 = Release|ARM64
+		{F912761C-2C5B-4EB9-8666-C2320A9AF407}.Release|x64.ActiveCfg = Release|x64
+		{F912761C-2C5B-4EB9-8666-C2320A9AF407}.Release|x64.Build.0 = Release|x64
+		{F912761C-2C5B-4EB9-8666-C2320A9AF407}.Release|x86.ActiveCfg = Release|Win32
+		{F912761C-2C5B-4EB9-8666-C2320A9AF407}.Release|x86.Build.0 = Release|Win32
+		{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}.Debug|ARM.ActiveCfg = Debug|ARM
+		{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}.Debug|ARM.Build.0 = Debug|ARM
+		{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}.Debug|ARM64.Build.0 = Debug|ARM64
+		{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}.Debug|x64.ActiveCfg = Debug|x64
+		{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}.Debug|x64.Build.0 = Debug|x64
+		{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}.Debug|x86.ActiveCfg = Debug|Win32
+		{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}.Debug|x86.Build.0 = Debug|Win32
+		{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}.Release|ARM.ActiveCfg = Release|ARM
+		{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}.Release|ARM.Build.0 = Release|ARM
+		{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}.Release|ARM64.ActiveCfg = Release|ARM64
+		{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}.Release|ARM64.Build.0 = Release|ARM64
+		{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}.Release|x64.ActiveCfg = Release|x64
+		{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}.Release|x64.Build.0 = Release|x64
+		{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}.Release|x86.ActiveCfg = Release|Win32
+		{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}.Release|x86.Build.0 = Release|Win32
+		{16415855-B9F4-4A5D-A096-C3380CFC6008}.Debug|ARM.ActiveCfg = Debug|ARM
+		{16415855-B9F4-4A5D-A096-C3380CFC6008}.Debug|ARM.Build.0 = Debug|ARM
+		{16415855-B9F4-4A5D-A096-C3380CFC6008}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{16415855-B9F4-4A5D-A096-C3380CFC6008}.Debug|ARM64.Build.0 = Debug|ARM64
+		{16415855-B9F4-4A5D-A096-C3380CFC6008}.Debug|x64.ActiveCfg = Debug|x64
+		{16415855-B9F4-4A5D-A096-C3380CFC6008}.Debug|x64.Build.0 = Debug|x64
+		{16415855-B9F4-4A5D-A096-C3380CFC6008}.Debug|x86.ActiveCfg = Debug|Win32
+		{16415855-B9F4-4A5D-A096-C3380CFC6008}.Debug|x86.Build.0 = Debug|Win32
+		{16415855-B9F4-4A5D-A096-C3380CFC6008}.Release|ARM.ActiveCfg = Release|ARM
+		{16415855-B9F4-4A5D-A096-C3380CFC6008}.Release|ARM.Build.0 = Release|ARM
+		{16415855-B9F4-4A5D-A096-C3380CFC6008}.Release|ARM64.ActiveCfg = Release|ARM64
+		{16415855-B9F4-4A5D-A096-C3380CFC6008}.Release|ARM64.Build.0 = Release|ARM64
+		{16415855-B9F4-4A5D-A096-C3380CFC6008}.Release|x64.ActiveCfg = Release|x64
+		{16415855-B9F4-4A5D-A096-C3380CFC6008}.Release|x64.Build.0 = Release|x64
+		{16415855-B9F4-4A5D-A096-C3380CFC6008}.Release|x86.ActiveCfg = Release|Win32
+		{16415855-B9F4-4A5D-A096-C3380CFC6008}.Release|x86.Build.0 = Release|Win32
+		{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}.Debug|ARM.ActiveCfg = Debug|ARM
+		{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}.Debug|ARM.Build.0 = Debug|ARM
+		{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}.Debug|ARM64.Build.0 = Debug|ARM64
+		{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}.Debug|x64.ActiveCfg = Debug|x64
+		{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}.Debug|x64.Build.0 = Debug|x64
+		{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}.Debug|x86.ActiveCfg = Debug|Win32
+		{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}.Debug|x86.Build.0 = Debug|Win32
+		{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}.Release|ARM.ActiveCfg = Release|ARM
+		{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}.Release|ARM.Build.0 = Release|ARM
+		{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}.Release|ARM64.ActiveCfg = Release|ARM64
+		{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}.Release|ARM64.Build.0 = Release|ARM64
+		{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}.Release|x64.ActiveCfg = Release|x64
+		{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}.Release|x64.Build.0 = Release|x64
+		{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}.Release|x86.ActiveCfg = Release|Win32
+		{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}.Release|x86.Build.0 = Release|Win32
+		{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}.Debug|ARM.ActiveCfg = Debug|ARM
+		{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}.Debug|ARM.Build.0 = Debug|ARM
+		{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}.Debug|ARM64.Build.0 = Debug|ARM64
+		{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}.Debug|x64.ActiveCfg = Debug|x64
+		{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}.Debug|x64.Build.0 = Debug|x64
+		{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}.Debug|x86.ActiveCfg = Debug|Win32
+		{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}.Debug|x86.Build.0 = Debug|Win32
+		{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}.Release|ARM.ActiveCfg = Release|ARM
+		{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}.Release|ARM.Build.0 = Release|ARM
+		{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}.Release|ARM64.ActiveCfg = Release|ARM64
+		{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}.Release|ARM64.Build.0 = Release|ARM64
+		{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}.Release|x64.ActiveCfg = Release|x64
+		{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}.Release|x64.Build.0 = Release|x64
+		{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}.Release|x86.ActiveCfg = Release|Win32
+		{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}.Release|x86.Build.0 = Release|Win32
+		{35ED7715-6B17-4225-8171-C954968D8F8C}.Debug|ARM.ActiveCfg = Debug|ARM
+		{35ED7715-6B17-4225-8171-C954968D8F8C}.Debug|ARM.Build.0 = Debug|ARM
+		{35ED7715-6B17-4225-8171-C954968D8F8C}.Debug|ARM64.ActiveCfg = Debug|ARM64
+		{35ED7715-6B17-4225-8171-C954968D8F8C}.Debug|ARM64.Build.0 = Debug|ARM64
+		{35ED7715-6B17-4225-8171-C954968D8F8C}.Debug|x64.ActiveCfg = Debug|x64
+		{35ED7715-6B17-4225-8171-C954968D8F8C}.Debug|x64.Build.0 = Debug|x64
+		{35ED7715-6B17-4225-8171-C954968D8F8C}.Debug|x86.ActiveCfg = Debug|Win32
+		{35ED7715-6B17-4225-8171-C954968D8F8C}.Debug|x86.Build.0 = Debug|Win32
+		{35ED7715-6B17-4225-8171-C954968D8F8C}.Release|ARM.ActiveCfg = Release|ARM
+		{35ED7715-6B17-4225-8171-C954968D8F8C}.Release|ARM.Build.0 = Release|ARM
+		{35ED7715-6B17-4225-8171-C954968D8F8C}.Release|ARM64.ActiveCfg = Release|ARM64
+		{35ED7715-6B17-4225-8171-C954968D8F8C}.Release|ARM64.Build.0 = Release|ARM64
+		{35ED7715-6B17-4225-8171-C954968D8F8C}.Release|x64.ActiveCfg = Release|x64
+		{35ED7715-6B17-4225-8171-C954968D8F8C}.Release|x64.Build.0 = Release|x64
+		{35ED7715-6B17-4225-8171-C954968D8F8C}.Release|x86.ActiveCfg = Release|Win32
+		{35ED7715-6B17-4225-8171-C954968D8F8C}.Release|x86.Build.0 = Release|Win32
+		{22873560-BDA7-4915-8C7D-DF7C380B4E55}.Debug|ARM.ActiveCfg = Debug|Win32
+		{22873560-BDA7-4915-8C7D-DF7C380B4E55}.Debug|ARM64.ActiveCfg = Debug|Win32
+		{22873560-BDA7-4915-8C7D-DF7C380B4E55}.Debug|x64.ActiveCfg = Debug|x64
+		{22873560-BDA7-4915-8C7D-DF7C380B4E55}.Debug|x64.Build.0 = Debug|x64
+		{22873560-BDA7-4915-8C7D-DF7C380B4E55}.Debug|x86.ActiveCfg = Debug|Win32
+		{22873560-BDA7-4915-8C7D-DF7C380B4E55}.Debug|x86.Build.0 = Debug|Win32
+		{22873560-BDA7-4915-8C7D-DF7C380B4E55}.Release|ARM.ActiveCfg = Release|Win32
+		{22873560-BDA7-4915-8C7D-DF7C380B4E55}.Release|ARM64.ActiveCfg = Release|Win32
+		{22873560-BDA7-4915-8C7D-DF7C380B4E55}.Release|x64.ActiveCfg = Release|x64
+		{22873560-BDA7-4915-8C7D-DF7C380B4E55}.Release|x64.Build.0 = Release|x64
+		{22873560-BDA7-4915-8C7D-DF7C380B4E55}.Release|x86.ActiveCfg = Release|Win32
+		{22873560-BDA7-4915-8C7D-DF7C380B4E55}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {C607FBBC-78A7-4BD3-A48A-9B562DA11F4D}
+	EndGlobalSection
+EndGlobal

deps/HDiffPatch/builds/vc/HDiffZ.vcxproj

@@ -0,0 +1,421 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{63934A83-25F5-4161-B19D-DFBAB1C257F1}</ProjectGuid>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <Keyword>ManagedCProj</Keyword>
+    <RootNamespace>hdiffz</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;..\..\..\lzham_codec\include;..\..\..\brotli\c\include;..\..\..\libmd5;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;..\..\..\lzham_codec\include;..\..\..\brotli\c\include;..\..\..\libmd5;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;..\..\..\lzham_codec\include;..\..\..\brotli\c\include;..\..\..\libmd5;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;..\..\..\lzham_codec\include;..\..\..\brotli\c\include;..\..\..\libmd5;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;..\..\..\lzham_codec\include;..\..\..\brotli\c\include;..\..\..\libmd5;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <LinkIncremental>false</LinkIncremental>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;..\..\..\lzham_codec\include;..\..\..\brotli\c\include;..\..\..\libmd5;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <LinkIncremental>false</LinkIncremental>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;..\..\..\lzham_codec\include;..\..\..\brotli\c\include;..\..\..\libmd5;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;..\..\..\lzham_codec\include;..\..\..\brotli\c\include;..\..\..\libmd5;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_ChecksumPlugin_md5;_CRT_SECURE_NO_WARNINGS;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <ObjectFileName>$(IntDir)/obj/_/_/_/%(RelativeDir)/</ObjectFileName>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_ChecksumPlugin_md5;_CRT_SECURE_NO_WARNINGS;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <ObjectFileName>$(IntDir)/obj/_/_/_/%(RelativeDir)/</ObjectFileName>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_ChecksumPlugin_md5;_CRT_SECURE_NO_WARNINGS;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <ObjectFileName>$(IntDir)/obj/_/_/_/%(RelativeDir)/</ObjectFileName>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_ChecksumPlugin_md5;_CRT_SECURE_NO_WARNINGS;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <ObjectFileName>$(IntDir)/obj/_/_/_/%(RelativeDir)/</ObjectFileName>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_ChecksumPlugin_md5;_CRT_SECURE_NO_WARNINGS;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <FloatingPointModel>Fast</FloatingPointModel>
+      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <ObjectFileName>$(IntDir)/obj/_/_/_/%(RelativeDir)/</ObjectFileName>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_ChecksumPlugin_md5;_CRT_SECURE_NO_WARNINGS;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <FloatingPointModel>Fast</FloatingPointModel>
+      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <ObjectFileName>$(IntDir)/obj/_/_/_/%(RelativeDir)/</ObjectFileName>
+      <StringPooling>true</StringPooling>
+      <CallingConvention>FastCall</CallingConvention>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_ChecksumPlugin_md5;_CRT_SECURE_NO_WARNINGS;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <FloatingPointModel>Fast</FloatingPointModel>
+      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <ObjectFileName>$(IntDir)/obj/_/_/_/%(RelativeDir)/</ObjectFileName>
+      <StringPooling>true</StringPooling>
+      <CallingConvention>FastCall</CallingConvention>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_ChecksumPlugin_md5;_CRT_SECURE_NO_WARNINGS;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <FloatingPointModel>Fast</FloatingPointModel>
+      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <CallingConvention>FastCall</CallingConvention>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <ObjectFileName>$(IntDir)</ObjectFileName>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\libmd5\md5.c" />
+    <ClCompile Include="..\..\bsdiff_wrapper\bsdiff_wrapper.cpp" />
+    <ClCompile Include="..\..\bsdiff_wrapper\bspatch_wrapper.c" />
+    <ClCompile Include="..\..\compress_parallel.cpp" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_diff\dir_diff.cpp" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_diff\dir_diff_tools.cpp" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_diff\dir_manifest.cpp" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\dir_patch.c" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\dir_patch_tools.c" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\new_dir_output.c" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\new_stream.c" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\ref_stream.c" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\res_handle_limit.c" />
+    <ClCompile Include="..\..\file_for_patch.c" />
+    <ClCompile Include="..\..\hdiffz.cpp" />
+    <ClCompile Include="..\..\hdiffz_import_patch.c" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\diff.cpp" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\match_block.cpp" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\bytes_rle.cpp" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\compress_detect.cpp" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\libdivsufsort\divsufsort.cpp" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\libdivsufsort\divsufsort64.cpp" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\limit_mem_diff\adler_roll.c" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\limit_mem_diff\digest_matcher.cpp" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\limit_mem_diff\stream_serialize.cpp" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\suffix_string.cpp" />
+    <ClCompile Include="..\..\libHDiffPatch\HPatchLite\hpatch_lite.c" />
+    <ClCompile Include="..\..\libHDiffPatch\HPatch\patch.c" />
+    <ClCompile Include="..\..\libParallel\parallel_channel.cpp" />
+    <ClCompile Include="..\..\libParallel\parallel_import.cpp" />
+    <ClCompile Include="..\..\vcdiff_wrapper\vcdiff_wrapper.cpp" />
+    <ClCompile Include="..\..\vcdiff_wrapper\vcpatch_wrapper.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\libHDiffPatch\HDiff\diff.h" />
+    <ClInclude Include="..\..\libHDiffPatch\HPatch\patch.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="bzip2.vcxproj">
+      <Project>{61ff6ece-a15b-4be1-a78b-62de892ae25c}</Project>
+    </ProjectReference>
+    <ProjectReference Include="lzma.vcxproj">
+      <Project>{0849cd0e-1b9b-44eb-8937-a278b6a7e2cf}</Project>
+    </ProjectReference>
+    <ProjectReference Include="zlib.vcxproj">
+      <Project>{35ed7715-6b17-4225-8171-c954968d8f8c}</Project>
+    </ProjectReference>
+    <ProjectReference Include="zstd.vcxproj">
+      <Project>{16415855-b9f4-4a5d-a096-c3380cfc6008}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

deps/HDiffPatch/builds/vc/HPatchZ.vcxproj

@@ -0,0 +1,404 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{F912761C-2C5B-4EB9-8666-C2320A9AF407}</ProjectGuid>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <Keyword>ManagedCProj</Keyword>
+    <RootNamespace>hpatchz</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;..\..\..\lzham_codec\include;..\..\..\brotli\c\include;..\..\..\libmd5;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;..\..\..\lzham_codec\include;..\..\..\brotli\c\include;..\..\..\libmd5;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;..\..\..\lzham_codec\include;..\..\..\brotli\c\include;..\..\..\libmd5;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;..\..\..\lzham_codec\include;..\..\..\brotli\c\include;..\..\..\libmd5;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;..\..\..\lzham_codec\include;..\..\..\brotli\c\include;..\..\..\libmd5;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <LinkIncremental>false</LinkIncremental>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;..\..\..\lzham_codec\include;..\..\..\brotli\c\include;..\..\..\libmd5;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <LinkIncremental>false</LinkIncremental>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;..\..\..\lzham_codec\include;..\..\..\brotli\c\include;..\..\..\libmd5;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;..\..\..\lzham_codec\include;..\..\..\brotli\c\include;..\..\..\libmd5;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_ChecksumPlugin_md5;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <ObjectFileName>$(IntDir)/obj/_/_/_/%(RelativeDir)/</ObjectFileName>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_ChecksumPlugin_md5;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <ObjectFileName>$(IntDir)/obj/_/_/_/%(RelativeDir)/</ObjectFileName>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_ChecksumPlugin_md5;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <ObjectFileName>$(IntDir)/obj/_/_/_/%(RelativeDir)/</ObjectFileName>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_ChecksumPlugin_md5;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <ObjectFileName>$(IntDir)/obj/_/_/_/%(RelativeDir)/</ObjectFileName>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_ChecksumPlugin_md5;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <FloatingPointModel>Fast</FloatingPointModel>
+      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <ObjectFileName>$(IntDir)/obj/_/_/_/%(RelativeDir)/</ObjectFileName>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_ChecksumPlugin_md5;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <FloatingPointModel>Fast</FloatingPointModel>
+      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <ObjectFileName>$(IntDir)/obj/_/_/_/%(RelativeDir)/</ObjectFileName>
+      <StringPooling>true</StringPooling>
+      <CallingConvention>FastCall</CallingConvention>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_ChecksumPlugin_md5;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <FloatingPointModel>Fast</FloatingPointModel>
+      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <ObjectFileName>$(IntDir)/obj/_/_/_/%(RelativeDir)/</ObjectFileName>
+      <StringPooling>true</StringPooling>
+      <CallingConvention>FastCall</CallingConvention>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_ChecksumPlugin_md5;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <FloatingPointModel>Fast</FloatingPointModel>
+      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <CallingConvention>FastCall</CallingConvention>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <ObjectFileName>$(IntDir)</ObjectFileName>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\libmd5\md5.c" />
+    <ClCompile Include="..\..\bsdiff_wrapper\bspatch_wrapper.c" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\dir_patch.c" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\dir_patch_tools.c" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\new_dir_output.c" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\new_stream.c" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\ref_stream.c" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\res_handle_limit.c" />
+    <ClCompile Include="..\..\file_for_patch.c" />
+    <ClCompile Include="..\..\hpatchz.c" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\limit_mem_diff\adler_roll.c" />
+    <ClCompile Include="..\..\libHDiffPatch\HPatch\patch.c" />
+    <ClCompile Include="..\..\vcdiff_wrapper\vcpatch_wrapper.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\dirDiffPatch\file_for_dirPatch.h" />
+    <ClInclude Include="..\..\file_for_patch.h" />
+    <ClInclude Include="..\..\libHDiffPatch\HDiff\private_diff\limit_mem_diff\adler_roll.h" />
+    <ClInclude Include="..\..\libHDiffPatch\HPatch\patch.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="bzip2.vcxproj">
+      <Project>{61ff6ece-a15b-4be1-a78b-62de892ae25c}</Project>
+    </ProjectReference>
+    <ProjectReference Include="lzma.vcxproj">
+      <Project>{0849cd0e-1b9b-44eb-8937-a278b6a7e2cf}</Project>
+    </ProjectReference>
+    <ProjectReference Include="zlib.vcxproj">
+      <Project>{35ed7715-6b17-4225-8171-c954968d8f8c}</Project>
+    </ProjectReference>
+    <ProjectReference Include="zstd.vcxproj">
+      <Project>{16415855-b9f4-4a5d-a096-c3380cfc6008}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

deps/HDiffPatch/builds/vc/bzip2.vcxproj

@@ -0,0 +1,302 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{61FF6ECE-A15B-4BE1-A78B-62DE892AE25C}</ProjectGuid>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <Keyword>ManagedCProj</Keyword>
+    <RootNamespace>bzip2</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\bzip2\blocksort.c" />
+    <ClCompile Include="..\..\..\bzip2\bzlib.c" />
+    <ClCompile Include="..\..\..\bzip2\compress.c" />
+    <ClCompile Include="..\..\..\bzip2\crctable.c" />
+    <ClCompile Include="..\..\..\bzip2\decompress.c" />
+    <ClCompile Include="..\..\..\bzip2\huffman.c" />
+    <ClCompile Include="..\..\..\bzip2\randtable.c" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

deps/HDiffPatch/builds/vc/hpatchz_test.vcxproj

@@ -0,0 +1,216 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{2F086480-0C7D-47FF-8289-31E0559974E4}</ProjectGuid>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <Keyword>ManagedCProj</Keyword>
+    <RootNamespace>hpatchz_test</RootNamespace>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <IncludePath>..\..\..\zlib;..\..\..\bzip2;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;..\..\..\lz4\lib;..\..\..\lzma\C;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+    <GenerateManifest>false</GenerateManifest>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <FavorSizeOrSpeed>Size</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <FloatingPointModel>Fast</FloatingPointModel>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <Optimization>MinSpace</Optimization>
+      <StringPooling>true</StringPooling>
+      <ExceptionHandling>false</ExceptionHandling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <RandomizedBaseAddress>false</RandomizedBaseAddress>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <CompileAs>Default</CompileAs>
+      <FavorSizeOrSpeed>Size</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <FloatingPointModel>Fast</FloatingPointModel>
+      <CallingConvention>FastCall</CallingConvention>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <Optimization>MinSpace</Optimization>
+      <ExceptionHandling>false</ExceptionHandling>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+      <RandomizedBaseAddress>false</RandomizedBaseAddress>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\bzip2\blocksort.c" />
+    <ClCompile Include="..\..\..\bzip2\bzlib.c" />
+    <ClCompile Include="..\..\..\bzip2\compress.c" />
+    <ClCompile Include="..\..\..\bzip2\crctable.c" />
+    <ClCompile Include="..\..\..\bzip2\decompress.c" />
+    <ClCompile Include="..\..\..\bzip2\huffman.c" />
+    <ClCompile Include="..\..\..\bzip2\randtable.c" />
+    <ClCompile Include="..\..\..\lzma\C\Lzma2Dec.c" />
+    <ClCompile Include="..\..\..\lzma\C\LzmaDec.c" />
+    <ClCompile Include="..\..\..\zlib\adler32.c" />
+    <ClCompile Include="..\..\..\zlib\crc32.c" />
+    <ClCompile Include="..\..\..\zlib\inffast.c" />
+    <ClCompile Include="..\..\..\zlib\inflate.c" />
+    <ClCompile Include="..\..\..\zlib\inftrees.c" />
+    <ClCompile Include="..\..\..\zlib\trees.c" />
+    <ClCompile Include="..\..\..\zlib\zutil.c" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\dir_patch.c" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\dir_patch_tools.c" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\new_dir_output.c" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\new_stream.c" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\ref_stream.c" />
+    <ClCompile Include="..\..\dirDiffPatch\dir_patch\res_handle_limit.c" />
+    <ClCompile Include="..\..\file_for_patch.c" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\limit_mem_diff\adler_roll.c" />
+    <ClCompile Include="..\..\libHDiffPatch\HPatch\patch.c" />
+    <ClCompile Include="..\..\test\hpatchz_test.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\dirDiffPatch\file_for_dirPatch.h" />
+    <ClInclude Include="..\..\file_for_patch.h" />
+    <ClInclude Include="..\..\libHDiffPatch\HDiff\private_diff\limit_mem_diff\adler_roll.h" />
+    <ClInclude Include="..\..\libHDiffPatch\HPatch\patch.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

deps/HDiffPatch/builds/vc/lzma.vcxproj

@@ -0,0 +1,349 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{0849CD0E-1B9B-44EB-8937-A278B6A7E2CF}</ProjectGuid>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <Keyword>ManagedCProj</Keyword>
+    <RootNamespace>lzma</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+    <Import Project="$(VCTargetsPath)\BuildCustomizations\masm.props" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;_LZMA_DEC_OPT;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <WholeProgramOptimization>true</WholeProgramOptimization>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\lzma\C\7zCrc.c" />
+    <ClCompile Include="..\..\..\lzma\C\7zCrcOpt.c" />
+    <ClCompile Include="..\..\..\lzma\C\Bra.c" />
+    <ClCompile Include="..\..\..\lzma\C\Bra86.c" />
+    <ClCompile Include="..\..\..\lzma\C\BraIA64.c" />
+    <ClCompile Include="..\..\..\lzma\C\CpuArch.c" />
+    <ClCompile Include="..\..\..\lzma\C\Delta.c" />
+    <ClCompile Include="..\..\..\lzma\C\LzFindOpt.c">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
+    </ClCompile>
+    <ClCompile Include="..\..\..\lzma\C\LzmaDec.c" />
+    <ClCompile Include="..\..\..\lzma\C\Lzma2Dec.c" />
+    <ClCompile Include="..\..\..\lzma\C\Alloc.c" />
+    <ClCompile Include="..\..\..\lzma\C\LzFind.c" />
+    <ClCompile Include="..\..\..\lzma\C\LzFindMt.c" />
+    <ClCompile Include="..\..\..\lzma\C\Lzma2DecMt.c" />
+    <ClCompile Include="..\..\..\lzma\C\Lzma2Enc.c" />
+    <ClCompile Include="..\..\..\lzma\C\LzmaEnc.c" />
+    <ClCompile Include="..\..\..\lzma\C\MtCoder.c" />
+    <ClCompile Include="..\..\..\lzma\C\MtDec.c" />
+    <ClCompile Include="..\..\..\lzma\C\Sha256.c" />
+    <ClCompile Include="..\..\..\lzma\C\Sha256Opt.c" />
+    <ClCompile Include="..\..\..\lzma\C\Threads.c" />
+    <ClCompile Include="..\..\..\lzma\C\Xz.c" />
+    <ClCompile Include="..\..\..\lzma\C\XzCrc64.c" />
+    <ClCompile Include="..\..\..\lzma\C\XzCrc64Opt.c" />
+    <ClCompile Include="..\..\..\lzma\C\XzDec.c" />
+    <ClCompile Include="..\..\..\lzma\C\XzEnc.c" />
+  </ItemGroup>
+  <ItemGroup>
+    <MASM Include="..\..\..\lzma\Asm\x86\LzFindOpt.asm">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">true</ExcludedFromBuild>
+    </MASM>
+    <MASM Include="..\..\..\lzma\Asm\x86\LzmaDecOpt.asm">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">true</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">true</ExcludedFromBuild>
+    </MASM>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="$(VCTargetsPath)\BuildCustomizations\masm.targets" />
+  </ImportGroup>
+</Project>

deps/HDiffPatch/builds/vc/testHashClash.vcxproj

@@ -0,0 +1,164 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>16.0</VCProjectVersion>
+    <Keyword>Win32Proj</Keyword>
+    <ProjectGuid>{22873560-bda7-4915-8c7d-df7c380b4e55}</ProjectGuid>
+    <RootNamespace>testHashClash</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\..\..\zlib;$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>..\..\..\zlib;$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+    <IncludePath>..\..\..\zlib;$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>..\..\..\zlib;$(IncludePath)</IncludePath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\limit_mem_diff\adler_roll.c" />
+    <ClCompile Include="..\..\test\testHashClash.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\libHDiffPatch\HDiff\private_diff\limit_mem_diff\adler_roll.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="zlib.vcxproj">
+      <Project>{35ed7715-6b17-4225-8171-c954968d8f8c}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

deps/HDiffPatch/builds/vc/unitTest.vcxproj

@@ -0,0 +1,369 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{EF32F56D-E3CF-4D51-BCCC-9184E13ED0AD}</ProjectGuid>
+    <RootNamespace>unitTest</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <IncludePath>..\..\..\zlib;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <IncludePath>..\..\..\zlib;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <IncludePath>..\..\..\zlib;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;$(IncludePath)</IncludePath>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <IncludePath>..\..\..\zlib;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;$(IncludePath)</IncludePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <IncludePath>..\..\..\zlib;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;$(IncludePath)</IncludePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <IncludePath>..\..\..\zlib;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;$(IncludePath)</IncludePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <IncludePath>..\..\..\zlib;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;$(IncludePath)</IncludePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ReferencePath>$(ReferencePath)</ReferencePath>
+    <IncludePath>..\..\..\zlib;..\..\..\zstd\lib;..\..\..\zstd\lib\common;..\..\..\zstd\lib\compress;..\..\..\zstd\lib\decompress;$(IncludePath)</IncludePath>
+    <OutDir>$(Configuration)\$(Platform)\</OutDir>
+    <IntDir>$(Configuration)\$(Platform)\obj\</IntDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <CompileAs>Default</CompileAs>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PreprocessorDefinitions>_IS_NEED_DIR_DIFF_PATCH=0;_UNICODE;UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>$(SolutionDir)$(Platform)\$(Configuration)\zlib.lib</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <CompileAs>Default</CompileAs>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PreprocessorDefinitions>_IS_NEED_DIR_DIFF_PATCH=0;_ARM64_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE=1;%(ClCompile.PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>$(SolutionDir)$(Platform)\$(Configuration)\zlib.lib</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <CompileAs>Default</CompileAs>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PreprocessorDefinitions>_IS_NEED_DIR_DIFF_PATCH=0;_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE=1;%(ClCompile.PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>$(SolutionDir)$(Platform)\$(Configuration)\zlib.lib</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <CompileAs>Default</CompileAs>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PreprocessorDefinitions>_IS_NEED_DIR_DIFF_PATCH=0;_UNICODE;UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>$(SolutionDir)$(Platform)\$(Configuration)\zlib.lib</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <CompileAs>Default</CompileAs>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <StringPooling>true</StringPooling>
+      <PreprocessorDefinitions>_IS_NEED_DIR_DIFF_PATCH=0;_UNICODE;UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <Profile>true</Profile>
+      <AdditionalDependencies>$(SolutionDir)$(Platform)\$(Configuration)\zlib.lib</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <CompileAs>Default</CompileAs>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <StringPooling>true</StringPooling>
+      <PreprocessorDefinitions>_IS_NEED_DIR_DIFF_PATCH=0;_ARM64_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE=1;%(ClCompile.PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <Profile>true</Profile>
+      <AdditionalDependencies>$(SolutionDir)$(Platform)\$(Configuration)\zlib.lib</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <CompileAs>Default</CompileAs>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <StringPooling>true</StringPooling>
+      <PreprocessorDefinitions>_IS_NEED_DIR_DIFF_PATCH=0;_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE=1;%(ClCompile.PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <Profile>true</Profile>
+      <AdditionalDependencies>$(SolutionDir)$(Platform)\$(Configuration)\zlib.lib</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <CompileAs>Default</CompileAs>
+      <AdditionalOptions>/wd4819 %(AdditionalOptions)</AdditionalOptions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <StringPooling>true</StringPooling>
+      <PreprocessorDefinitions>_IS_NEED_DIR_DIFF_PATCH=0;_UNICODE;UNICODE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <Profile>true</Profile>
+      <AdditionalDependencies>$(SolutionDir)$(Platform)\$(Configuration)\zlib.lib</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\dirDiffPatch\dir_diff\dir_diff_tools.cpp" />
+    <ClCompile Include="..\..\file_for_patch.c" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\diff.cpp" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\bytes_rle.cpp" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\compress_detect.cpp" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\libdivsufsort\divsufsort.cpp" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\libdivsufsort\divsufsort64.cpp" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\limit_mem_diff\adler_roll.c" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\limit_mem_diff\digest_matcher.cpp" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\limit_mem_diff\stream_serialize.cpp" />
+    <ClCompile Include="..\..\libHDiffPatch\HDiff\private_diff\suffix_string.cpp" />
+    <ClCompile Include="..\..\libHDiffPatch\HPatchLite\hpatch_lite.c" />
+    <ClCompile Include="..\..\libHDiffPatch\HPatch\patch.c">
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">CompileAsC</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">CompileAsC</CompileAs>
+      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">CompileAsC</CompileAs>
+    </ClCompile>
+    <ClCompile Include="..\..\libhsync\sync_client\match_in_old.cpp" />
+    <ClCompile Include="..\..\libhsync\sync_client\sync_client.cpp" />
+    <ClCompile Include="..\..\libhsync\sync_client\sync_diff_data.cpp" />
+    <ClCompile Include="..\..\libhsync\sync_client\sync_info_client.cpp" />
+    <ClCompile Include="..\..\libhsync\sync_make\match_in_new.cpp" />
+    <ClCompile Include="..\..\libhsync\sync_make\sync_info_make.cpp" />
+    <ClCompile Include="..\..\libhsync\sync_make\sync_make.cpp" />
+    <ClCompile Include="..\..\libParallel\parallel_channel.cpp" />
+    <ClCompile Include="..\..\libParallel\parallel_import.cpp" />
+    <ClCompile Include="..\..\test\unit_test.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\libHDiffPatch\HPatch\patch.h" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

deps/HDiffPatch/builds/vc/zlib.vcxproj

@@ -0,0 +1,315 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{35ED7715-6B17-4225-8171-C954968D8F8C}</ProjectGuid>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <Keyword>ManagedCProj</Keyword>
+    <RootNamespace>zlib</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>$(Platform)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>$(Platform)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <LinkIncremental>true</LinkIncremental>
+    <OutDir>$(Platform)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <OutDir>$(Platform)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <LinkIncremental>false</LinkIncremental>
+    <OutDir>$(Platform)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <LinkIncremental>false</LinkIncremental>
+    <OutDir>$(Platform)\$(Configuration)\</OutDir>
+    <IntDir>$(Platform)\$(Configuration)\obj\</IntDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;UNALIGNED_OK;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;UNALIGNED_OK;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;UNALIGNED_OK;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;UNALIGNED_OK;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\zlib\adler32.c" />
+    <ClCompile Include="..\..\..\zlib\crc32.c" />
+    <ClCompile Include="..\..\..\zlib\deflate.c" />
+    <ClCompile Include="..\..\..\zlib\inffast.c" />
+    <ClCompile Include="..\..\..\zlib\inflate.c" />
+    <ClCompile Include="..\..\..\zlib\inftrees.c" />
+    <ClCompile Include="..\..\..\zlib\trees.c" />
+    <ClCompile Include="..\..\..\zlib\zutil.c" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

deps/HDiffPatch/builds/vc/zstd.vcxproj

@@ -0,0 +1,357 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|ARM">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|ARM64">
+      <Configuration>Debug</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM">
+      <Configuration>Release</Configuration>
+      <Platform>ARM</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|ARM64">
+      <Configuration>Release</Configuration>
+      <Platform>ARM64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{16415855-B9F4-4A5D-A096-C3380CFC6008}</ProjectGuid>
+    <RootNamespace>zstd</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <CLRSupport>false</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;ZSTD_MULTITHREAD=1;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;ZSTD_MULTITHREAD=1;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|ARM'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;ZSTD_MULTITHREAD=1;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;ZSTD_MULTITHREAD=1;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;ZSTD_MULTITHREAD=1;ZSTD_HAVE_WEAK_SYMBOLS=0;ZSTD_TRACE=0;ZSTD_DISABLE_ASM=1;ZSTDLIB_VISIBLE=;ZSTDLIB_HIDDEN=;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;ZSTD_MULTITHREAD=1;ZSTD_HAVE_WEAK_SYMBOLS=0;ZSTD_TRACE=0;ZSTD_DISABLE_ASM=1;ZSTDLIB_VISIBLE=;ZSTDLIB_HIDDEN=;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|ARM'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;ZSTD_MULTITHREAD=1;ZSTD_HAVE_WEAK_SYMBOLS=0;ZSTD_TRACE=0;ZSTD_DISABLE_ASM=1;ZSTDLIB_VISIBLE=;ZSTDLIB_HIDDEN=;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;ZSTD_MULTITHREAD=1;ZSTD_HAVE_WEAK_SYMBOLS=0;ZSTD_TRACE=0;ZSTD_DISABLE_ASM=1;ZSTDLIB_VISIBLE=;ZSTDLIB_HIDDEN=;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <PrecompiledHeaderFile>
+      </PrecompiledHeaderFile>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <StringPooling>true</StringPooling>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>
+      </AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="..\..\..\zstd\lib\common\bitstream.h" />
+    <ClInclude Include="..\..\..\zstd\lib\common\compiler.h" />
+    <ClInclude Include="..\..\..\zstd\lib\common\cpu.h" />
+    <ClInclude Include="..\..\..\zstd\lib\common\debug.h" />
+    <ClInclude Include="..\..\..\zstd\lib\common\error_private.h" />
+    <ClInclude Include="..\..\..\zstd\lib\common\fse.h" />
+    <ClInclude Include="..\..\..\zstd\lib\common\huf.h" />
+    <ClInclude Include="..\..\..\zstd\lib\common\mem.h" />
+    <ClInclude Include="..\..\..\zstd\lib\common\pool.h" />
+    <ClInclude Include="..\..\..\zstd\lib\common\threading.h" />
+    <ClInclude Include="..\..\..\zstd\lib\common\xxhash.h" />
+    <ClInclude Include="..\..\..\zstd\lib\common\zstd_deps.h" />
+    <ClInclude Include="..\..\..\zstd\lib\common\zstd_errors.h" />
+    <ClInclude Include="..\..\..\zstd\lib\common\zstd_internal.h" />
+    <ClInclude Include="..\..\..\zstd\lib\compress\hist.h" />
+    <ClInclude Include="..\..\..\zstd\lib\compress\zstdmt_compress.h" />
+    <ClInclude Include="..\..\..\zstd\lib\compress\zstd_compress_internal.h" />
+    <ClInclude Include="..\..\..\zstd\lib\compress\zstd_compress_literals.h" />
+    <ClInclude Include="..\..\..\zstd\lib\compress\zstd_compress_sequences.h" />
+    <ClInclude Include="..\..\..\zstd\lib\compress\zstd_compress_superblock.h" />
+    <ClInclude Include="..\..\..\zstd\lib\compress\zstd_cwksp.h" />
+    <ClInclude Include="..\..\..\zstd\lib\compress\zstd_double_fast.h" />
+    <ClInclude Include="..\..\..\zstd\lib\compress\zstd_fast.h" />
+    <ClInclude Include="..\..\..\zstd\lib\compress\zstd_lazy.h" />
+    <ClInclude Include="..\..\..\zstd\lib\compress\zstd_ldm.h" />
+    <ClInclude Include="..\..\..\zstd\lib\compress\zstd_opt.h" />
+    <ClInclude Include="..\..\..\zstd\lib\decompress\zstd_ddict.h" />
+    <ClInclude Include="..\..\..\zstd\lib\decompress\zstd_decompress_block.h" />
+    <ClInclude Include="..\..\..\zstd\lib\decompress\zstd_decompress_internal.h" />
+    <ClInclude Include="..\..\..\zstd\lib\zstd.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\..\..\zstd\lib\common\debug.c" />
+    <ClCompile Include="..\..\..\zstd\lib\common\entropy_common.c" />
+    <ClCompile Include="..\..\..\zstd\lib\common\error_private.c" />
+    <ClCompile Include="..\..\..\zstd\lib\common\fse_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\lib\common\pool.c" />
+    <ClCompile Include="..\..\..\zstd\lib\common\threading.c" />
+    <ClCompile Include="..\..\..\zstd\lib\common\xxhash.c" />
+    <ClCompile Include="..\..\..\zstd\lib\common\zstd_common.c" />
+    <ClCompile Include="..\..\..\zstd\lib\compress\fse_compress.c" />
+    <ClCompile Include="..\..\..\zstd\lib\compress\hist.c" />
+    <ClCompile Include="..\..\..\zstd\lib\compress\huf_compress.c" />
+    <ClCompile Include="..\..\..\zstd\lib\compress\zstdmt_compress.c" />
+    <ClCompile Include="..\..\..\zstd\lib\compress\zstd_compress.c" />
+    <ClCompile Include="..\..\..\zstd\lib\compress\zstd_compress_literals.c" />
+    <ClCompile Include="..\..\..\zstd\lib\compress\zstd_compress_sequences.c" />
+    <ClCompile Include="..\..\..\zstd\lib\compress\zstd_compress_superblock.c" />
+    <ClCompile Include="..\..\..\zstd\lib\compress\zstd_double_fast.c" />
+    <ClCompile Include="..\..\..\zstd\lib\compress\zstd_fast.c" />
+    <ClCompile Include="..\..\..\zstd\lib\compress\zstd_lazy.c" />
+    <ClCompile Include="..\..\..\zstd\lib\compress\zstd_ldm.c" />
+    <ClCompile Include="..\..\..\zstd\lib\compress\zstd_opt.c" />
+    <ClCompile Include="..\..\..\zstd\lib\decompress\huf_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\lib\decompress\zstd_ddict.c" />
+    <ClCompile Include="..\..\..\zstd\lib\decompress\zstd_decompress.c" />
+    <ClCompile Include="..\..\..\zstd\lib\decompress\zstd_decompress_block.c" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

deps/HDiffPatch/builds/xcode/HDiffPatch.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "group:hdiffz.xcodeproj">
+   </FileRef>
+   <FileRef
+      location = "group:hpatchz.xcodeproj">
+   </FileRef>
+   <Group
+      location = "container:"
+      name = "test">
+      <FileRef
+         location = "group:testHashClash.xcodeproj">
+      </FileRef>
+      <FileRef
+         location = "group:unitTest.xcodeproj">
+      </FileRef>
+      <FileRef
+         location = "group:bestParams.xcodeproj">
+      </FileRef>
+   </Group>
+   <Group
+      location = "container:"
+      name = "lib">
+      <FileRef
+         location = "group:zstd.xcodeproj">
+      </FileRef>
+      <FileRef
+         location = "group:lzma.xcodeproj">
+      </FileRef>
+   </Group>
+</Workspace>

deps/HDiffPatch/builds/xcode/HDiffPatch.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

deps/HDiffPatch/builds/xcode/bestParams.xcodeproj/project.pbxproj

@@ -0,0 +1,447 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		0D7FEAB2283124970029772D /* hpatch_lite.c in Sources */ = {isa = PBXBuildFile; fileRef = 0D7FEAAF283124970029772D /* hpatch_lite.c */; };
+		0DD93B1B28F16B5D0097699C /* parallel_channel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0DD93B1728F16B5D0097699C /* parallel_channel.cpp */; };
+		0DD93B1C28F16B5D0097699C /* parallel_import.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0DD93B1928F16B5D0097699C /* parallel_import.cpp */; };
+		80D1B2A4199A40A700F6B3A8 /* diff.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 80D1B298199A40A700F6B3A8 /* diff.cpp */; };
+		80D1B2A5199A40A700F6B3A8 /* bytes_rle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 80D1B29B199A40A700F6B3A8 /* bytes_rle.cpp */; };
+		80D1B2A6199A40A700F6B3A8 /* suffix_string.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 80D1B29F199A40A700F6B3A8 /* suffix_string.cpp */; };
+		80D1B2A7199A40A700F6B3A8 /* patch.c in Sources */ = {isa = PBXBuildFile; fileRef = 80D1B2A2199A40A700F6B3A8 /* patch.c */; };
+		D6241ACD21DA5C9600E2846A /* liblzma.a in Frameworks */ = {isa = PBXBuildFile; fileRef = D6EF751F21C13CE4000EBBCC /* liblzma.a */; };
+		D639ACDE208B458500811BB3 /* _private_searchBestParams.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D639ACDD208B458500811BB3 /* _private_searchBestParams.cpp */; };
+		D66166271E189F5A005C570A /* divsufsort.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D661661E1E189F5A005C570A /* divsufsort.cpp */; };
+		D66166281E189F5A005C570A /* divsufsort64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D66166211E189F5A005C570A /* divsufsort64.cpp */; };
+		D68CD9151F469DDB00A61337 /* adler_roll.c in Sources */ = {isa = PBXBuildFile; fileRef = D68CD90D1F469DDB00A61337 /* adler_roll.c */; };
+		D68CD9161F469DDB00A61337 /* digest_matcher.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D68CD9111F469DDB00A61337 /* digest_matcher.cpp */; };
+		D68CD9171F469DDB00A61337 /* stream_serialize.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D68CD9131F469DDB00A61337 /* stream_serialize.cpp */; };
+		D6E150B41F23B66D00C2AD3D /* libbz2.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = D6E150B21F23B66D00C2AD3D /* libbz2.tbd */; };
+		D6E150B51F23B66D00C2AD3D /* libz.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = D6E150B31F23B66D00C2AD3D /* libz.tbd */; };
+		D6EE50601F2990AD002854A2 /* compress_detect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D6EE505E1F2990AD002854A2 /* compress_detect.cpp */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		D6CB335F1664FD2900AB34B7 /* CopyFiles */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = /usr/share/man/man1/;
+			dstSubfolderSpec = 0;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 1;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		0D7FEAAE283124970029772D /* hpatch_lite.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = hpatch_lite.h; sourceTree = "<group>"; };
+		0D7FEAAF283124970029772D /* hpatch_lite.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = hpatch_lite.c; sourceTree = "<group>"; };
+		0D7FEAB0283124970029772D /* hpatch_lite_input_cache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = hpatch_lite_input_cache.h; sourceTree = "<group>"; };
+		0D7FEAB1283124970029772D /* hpatch_lite_types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = hpatch_lite_types.h; sourceTree = "<group>"; };
+		0DD93B1728F16B5D0097699C /* parallel_channel.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = parallel_channel.cpp; sourceTree = "<group>"; };
+		0DD93B1828F16B5D0097699C /* parallel_import.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = parallel_import.h; sourceTree = "<group>"; };
+		0DD93B1928F16B5D0097699C /* parallel_import.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = parallel_import.cpp; sourceTree = "<group>"; };
+		0DD93B1A28F16B5D0097699C /* parallel_channel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = parallel_channel.h; sourceTree = "<group>"; };
+		80D1B298199A40A700F6B3A8 /* diff.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = diff.cpp; sourceTree = "<group>"; };
+		80D1B299199A40A700F6B3A8 /* diff.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = diff.h; sourceTree = "<group>"; };
+		80D1B29B199A40A700F6B3A8 /* bytes_rle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bytes_rle.cpp; sourceTree = "<group>"; };
+		80D1B29C199A40A700F6B3A8 /* bytes_rle.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bytes_rle.h; sourceTree = "<group>"; };
+		80D1B29D199A40A700F6B3A8 /* pack_uint.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pack_uint.h; sourceTree = "<group>"; };
+		80D1B29E199A40A700F6B3A8 /* sais.hxx */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = sais.hxx; sourceTree = "<group>"; };
+		80D1B29F199A40A700F6B3A8 /* suffix_string.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = suffix_string.cpp; sourceTree = "<group>"; };
+		80D1B2A0199A40A700F6B3A8 /* suffix_string.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = suffix_string.h; sourceTree = "<group>"; };
+		80D1B2A2199A40A700F6B3A8 /* patch.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = patch.c; sourceTree = "<group>"; };
+		80D1B2A3199A40A700F6B3A8 /* patch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = patch.h; sourceTree = "<group>"; };
+		D639ACDD208B458500811BB3 /* _private_searchBestParams.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = _private_searchBestParams.cpp; path = ../../test/_private_searchBestParams.cpp; sourceTree = "<group>"; };
+		D661661D1E189F5A005C570A /* config.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = config.h; sourceTree = "<group>"; };
+		D661661E1E189F5A005C570A /* divsufsort.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = divsufsort.cpp; sourceTree = "<group>"; };
+		D661661F1E189F5A005C570A /* divsufsort.c.inc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = divsufsort.c.inc.h; sourceTree = "<group>"; };
+		D66166201E189F5A005C570A /* divsufsort.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = divsufsort.h; sourceTree = "<group>"; };
+		D66166211E189F5A005C570A /* divsufsort64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = divsufsort64.cpp; sourceTree = "<group>"; };
+		D66166221E189F5A005C570A /* divsufsort64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = divsufsort64.h; sourceTree = "<group>"; };
+		D66166231E189F5A005C570A /* divsufsort_private.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = divsufsort_private.h; sourceTree = "<group>"; };
+		D66166241E189F5A005C570A /* sssort.c.inc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sssort.c.inc.h; sourceTree = "<group>"; };
+		D66166251E189F5A005C570A /* trsort.c.inc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = trsort.c.inc.h; sourceTree = "<group>"; };
+		D66166261E189F5A005C570A /* utils.c.inc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utils.c.inc.h; sourceTree = "<group>"; };
+		D68CD90D1F469DDB00A61337 /* adler_roll.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = adler_roll.c; sourceTree = "<group>"; };
+		D68CD90E1F469DDB00A61337 /* adler_roll.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = adler_roll.h; sourceTree = "<group>"; };
+		D68CD90F1F469DDB00A61337 /* bloom_filter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bloom_filter.h; sourceTree = "<group>"; };
+		D68CD9101F469DDB00A61337 /* covers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = covers.h; sourceTree = "<group>"; };
+		D68CD9111F469DDB00A61337 /* digest_matcher.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = digest_matcher.cpp; sourceTree = "<group>"; };
+		D68CD9121F469DDB00A61337 /* digest_matcher.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = digest_matcher.h; sourceTree = "<group>"; };
+		D68CD9131F469DDB00A61337 /* stream_serialize.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stream_serialize.cpp; sourceTree = "<group>"; };
+		D68CD9141F469DDB00A61337 /* stream_serialize.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stream_serialize.h; sourceTree = "<group>"; };
+		D6CB33611664FD2900AB34B7 /* bestParams */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = bestParams; sourceTree = BUILT_PRODUCTS_DIR; };
+		D6E150B21F23B66D00C2AD3D /* libbz2.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libbz2.tbd; path = usr/lib/libbz2.tbd; sourceTree = SDKROOT; };
+		D6E150B31F23B66D00C2AD3D /* libz.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libz.tbd; path = usr/lib/libz.tbd; sourceTree = SDKROOT; };
+		D6EE505E1F2990AD002854A2 /* compress_detect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = compress_detect.cpp; sourceTree = "<group>"; };
+		D6EE505F1F2990AD002854A2 /* compress_detect.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = compress_detect.h; sourceTree = "<group>"; };
+		D6EF751F21C13CE4000EBBCC /* liblzma.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; path = liblzma.a; sourceTree = BUILT_PRODUCTS_DIR; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		D6CB335E1664FD2900AB34B7 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				D6241ACD21DA5C9600E2846A /* liblzma.a in Frameworks */,
+				D6E150B41F23B66D00C2AD3D /* libbz2.tbd in Frameworks */,
+				D6E150B51F23B66D00C2AD3D /* libz.tbd in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		0D7FEAAD283124970029772D /* HPatchLite */ = {
+			isa = PBXGroup;
+			children = (
+				0D7FEAAE283124970029772D /* hpatch_lite.h */,
+				0D7FEAAF283124970029772D /* hpatch_lite.c */,
+				0D7FEAB0283124970029772D /* hpatch_lite_input_cache.h */,
+				0D7FEAB1283124970029772D /* hpatch_lite_types.h */,
+			);
+			path = HPatchLite;
+			sourceTree = "<group>";
+		};
+		0DD93B1628F16B5D0097699C /* libParallel */ = {
+			isa = PBXGroup;
+			children = (
+				0DD93B1728F16B5D0097699C /* parallel_channel.cpp */,
+				0DD93B1828F16B5D0097699C /* parallel_import.h */,
+				0DD93B1928F16B5D0097699C /* parallel_import.cpp */,
+				0DD93B1A28F16B5D0097699C /* parallel_channel.h */,
+			);
+			name = libParallel;
+			path = ../../libParallel;
+			sourceTree = "<group>";
+		};
+		80D1B296199A40A700F6B3A8 /* libHDiffPatch */ = {
+			isa = PBXGroup;
+			children = (
+				0D7FEAAD283124970029772D /* HPatchLite */,
+				80D1B297199A40A700F6B3A8 /* HDiff */,
+				80D1B2A1199A40A700F6B3A8 /* HPatch */,
+			);
+			name = libHDiffPatch;
+			path = ../../libHDiffPatch;
+			sourceTree = "<group>";
+		};
+		80D1B297199A40A700F6B3A8 /* HDiff */ = {
+			isa = PBXGroup;
+			children = (
+				80D1B298199A40A700F6B3A8 /* diff.cpp */,
+				80D1B299199A40A700F6B3A8 /* diff.h */,
+				80D1B29A199A40A700F6B3A8 /* private_diff */,
+			);
+			path = HDiff;
+			sourceTree = "<group>";
+		};
+		80D1B29A199A40A700F6B3A8 /* private_diff */ = {
+			isa = PBXGroup;
+			children = (
+				D68CD90C1F469DDB00A61337 /* limit_mem_diff */,
+				D6EE505E1F2990AD002854A2 /* compress_detect.cpp */,
+				D6EE505F1F2990AD002854A2 /* compress_detect.h */,
+				D661661C1E189F5A005C570A /* libdivsufsort */,
+				80D1B29B199A40A700F6B3A8 /* bytes_rle.cpp */,
+				80D1B29C199A40A700F6B3A8 /* bytes_rle.h */,
+				80D1B29D199A40A700F6B3A8 /* pack_uint.h */,
+				80D1B29E199A40A700F6B3A8 /* sais.hxx */,
+				80D1B29F199A40A700F6B3A8 /* suffix_string.cpp */,
+				80D1B2A0199A40A700F6B3A8 /* suffix_string.h */,
+			);
+			path = private_diff;
+			sourceTree = "<group>";
+		};
+		80D1B2A1199A40A700F6B3A8 /* HPatch */ = {
+			isa = PBXGroup;
+			children = (
+				80D1B2A2199A40A700F6B3A8 /* patch.c */,
+				80D1B2A3199A40A700F6B3A8 /* patch.h */,
+			);
+			path = HPatch;
+			sourceTree = "<group>";
+		};
+		D661661C1E189F5A005C570A /* libdivsufsort */ = {
+			isa = PBXGroup;
+			children = (
+				D661661D1E189F5A005C570A /* config.h */,
+				D661661E1E189F5A005C570A /* divsufsort.cpp */,
+				D661661F1E189F5A005C570A /* divsufsort.c.inc.h */,
+				D66166201E189F5A005C570A /* divsufsort.h */,
+				D66166211E189F5A005C570A /* divsufsort64.cpp */,
+				D66166221E189F5A005C570A /* divsufsort64.h */,
+				D66166231E189F5A005C570A /* divsufsort_private.h */,
+				D66166241E189F5A005C570A /* sssort.c.inc.h */,
+				D66166251E189F5A005C570A /* trsort.c.inc.h */,
+				D66166261E189F5A005C570A /* utils.c.inc.h */,
+			);
+			path = libdivsufsort;
+			sourceTree = "<group>";
+		};
+		D68CD90C1F469DDB00A61337 /* limit_mem_diff */ = {
+			isa = PBXGroup;
+			children = (
+				D68CD90D1F469DDB00A61337 /* adler_roll.c */,
+				D68CD90E1F469DDB00A61337 /* adler_roll.h */,
+				D68CD90F1F469DDB00A61337 /* bloom_filter.h */,
+				D68CD9101F469DDB00A61337 /* covers.h */,
+				D68CD9111F469DDB00A61337 /* digest_matcher.cpp */,
+				D68CD9121F469DDB00A61337 /* digest_matcher.h */,
+				D68CD9131F469DDB00A61337 /* stream_serialize.cpp */,
+				D68CD9141F469DDB00A61337 /* stream_serialize.h */,
+			);
+			path = limit_mem_diff;
+			sourceTree = "<group>";
+		};
+		D690A7B21F0E6F260089DC57 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				D6EF751F21C13CE4000EBBCC /* liblzma.a */,
+				D6E150B21F23B66D00C2AD3D /* libbz2.tbd */,
+				D6E150B31F23B66D00C2AD3D /* libz.tbd */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+		D6CB33581664FD2900AB34B7 = {
+			isa = PBXGroup;
+			children = (
+				D639ACDD208B458500811BB3 /* _private_searchBestParams.cpp */,
+				0DD93B1628F16B5D0097699C /* libParallel */,
+				80D1B296199A40A700F6B3A8 /* libHDiffPatch */,
+				D6CB33621664FD2900AB34B7 /* Products */,
+				D690A7B21F0E6F260089DC57 /* Frameworks */,
+			);
+			sourceTree = "<group>";
+		};
+		D6CB33621664FD2900AB34B7 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				D6CB33611664FD2900AB34B7 /* bestParams */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		D6CB33601664FD2900AB34B7 /* bestParams */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = D6CB336A1664FD2900AB34B7 /* Build configuration list for PBXNativeTarget "bestParams" */;
+			buildPhases = (
+				D6CB335D1664FD2900AB34B7 /* Sources */,
+				D6CB335E1664FD2900AB34B7 /* Frameworks */,
+				D6CB335F1664FD2900AB34B7 /* CopyFiles */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = bestParams;
+			productName = bestParams;
+			productReference = D6CB33611664FD2900AB34B7 /* bestParams */;
+			productType = "com.apple.product-type.tool";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		D6CB33591664FD2900AB34B7 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 1030;
+				ORGANIZATIONNAME = HouSisong;
+			};
+			buildConfigurationList = D6CB335C1664FD2900AB34B7 /* Build configuration list for PBXProject "bestParams" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = D6CB33581664FD2900AB34B7;
+			productRefGroup = D6CB33621664FD2900AB34B7 /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				D6CB33601664FD2900AB34B7 /* bestParams */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXSourcesBuildPhase section */
+		D6CB335D1664FD2900AB34B7 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				D639ACDE208B458500811BB3 /* _private_searchBestParams.cpp in Sources */,
+				D6EE50601F2990AD002854A2 /* compress_detect.cpp in Sources */,
+				D66166281E189F5A005C570A /* divsufsort64.cpp in Sources */,
+				D68CD9161F469DDB00A61337 /* digest_matcher.cpp in Sources */,
+				0DD93B1B28F16B5D0097699C /* parallel_channel.cpp in Sources */,
+				0DD93B1C28F16B5D0097699C /* parallel_import.cpp in Sources */,
+				80D1B2A5199A40A700F6B3A8 /* bytes_rle.cpp in Sources */,
+				80D1B2A6199A40A700F6B3A8 /* suffix_string.cpp in Sources */,
+				D66166271E189F5A005C570A /* divsufsort.cpp in Sources */,
+				0D7FEAB2283124970029772D /* hpatch_lite.c in Sources */,
+				80D1B2A4199A40A700F6B3A8 /* diff.cpp in Sources */,
+				80D1B2A7199A40A700F6B3A8 /* patch.c in Sources */,
+				D68CD9151F469DDB00A61337 /* adler_roll.c in Sources */,
+				D68CD9171F469DDB00A61337 /* stream_serialize.cpp in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		D6CB33681664FD2900AB34B7 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "c++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				GCC_C_LANGUAGE_STANDARD = "compiler-default";
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_ENABLE_OBJC_EXCEPTIONS = YES;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_STRICT_ALIASING = YES;
+				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = (
+					../../../lz4/lib/,
+					../../../zstd/lib/,
+					../../../lzma/C/,
+				);
+				MACOSX_DEPLOYMENT_TARGET = 10.9;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = macosx;
+			};
+			name = Debug;
+		};
+		D6CB33691664FD2900AB34B7 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "c++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				COPY_PHASE_STRIP = YES;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = "compiler-default";
+				GCC_ENABLE_OBJC_EXCEPTIONS = YES;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_PREPROCESSOR_DEFINITIONS = "";
+				GCC_STRICT_ALIASING = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = (
+					../../../lz4/lib/,
+					../../../zstd/lib/,
+					../../../lzma/C/,
+				);
+				MACOSX_DEPLOYMENT_TARGET = 10.9;
+				SDKROOT = macosx;
+			};
+			name = Release;
+		};
+		D6CB336B1664FD2900AB34B7 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Debug;
+		};
+		D6CB336C1664FD2900AB34B7 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		D6CB335C1664FD2900AB34B7 /* Build configuration list for PBXProject "bestParams" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				D6CB33681664FD2900AB34B7 /* Debug */,
+				D6CB33691664FD2900AB34B7 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		D6CB336A1664FD2900AB34B7 /* Build configuration list for PBXNativeTarget "bestParams" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				D6CB336B1664FD2900AB34B7 /* Debug */,
+				D6CB336C1664FD2900AB34B7 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = D6CB33591664FD2900AB34B7 /* Project object */;
+}

deps/HDiffPatch/builds/xcode/bestParams.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:bestParams.xcodeproj">
+   </FileRef>
+</Workspace>

deps/HDiffPatch/builds/xcode/hdiffz.xcodeproj/project.pbxproj

@@ -0,0 +1,644 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		0D571A64275CEB3B00672D57 /* liblzma.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0D571A63275CEB3B00672D57 /* liblzma.a */; };
+		0D571A66275CEB3B00672D57 /* libzstd.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0D571A65275CEB3B00672D57 /* libzstd.a */; };
+		0D571A69275CF68900672D57 /* match_block.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0D571A68275CF68900672D57 /* match_block.cpp */; };
+		0D571A6F275CF71A00672D57 /* bspatch_wrapper.c in Sources */ = {isa = PBXBuildFile; fileRef = 0D571A6B275CF71A00672D57 /* bspatch_wrapper.c */; };
+		0D571A70275CF71A00672D57 /* bsdiff_wrapper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0D571A6E275CF71A00672D57 /* bsdiff_wrapper.cpp */; };
+		0D571A72275CF75B00672D57 /* hdiffz.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0D571A71275CF75B00672D57 /* hdiffz.cpp */; };
+		0D7FEAB8283124A20029772D /* hpatch_lite.c in Sources */ = {isa = PBXBuildFile; fileRef = 0D7FEAB5283124A20029772D /* hpatch_lite.c */; };
+		0DA2A8EE292B9880000E86E1 /* vcdiff_wrapper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0DA2A8E9292B9880000E86E1 /* vcdiff_wrapper.cpp */; };
+		0DA2A8EF292B9880000E86E1 /* vcpatch_wrapper.c in Sources */ = {isa = PBXBuildFile; fileRef = 0DA2A8EB292B9880000E86E1 /* vcpatch_wrapper.c */; };
+		D61DE5472344D16900F6FCCF /* dir_diff_tools.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D61DE5462344D16900F6FCCF /* dir_diff_tools.cpp */; };
+		D621352323DC521F00EC4FA4 /* new_dir_output.c in Sources */ = {isa = PBXBuildFile; fileRef = D621352123DC521F00EC4FA4 /* new_dir_output.c */; };
+		D6241AE221DE47D200E2846A /* new_stream.c in Sources */ = {isa = PBXBuildFile; fileRef = D6241AE021DE47D200E2846A /* new_stream.c */; };
+		D67D3BDC21CBCD5D0050632A /* dir_diff.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D67D3BD521CBCD5D0050632A /* dir_diff.cpp */; };
+		D67D3BDD21CBCD5D0050632A /* ref_stream.c in Sources */ = {isa = PBXBuildFile; fileRef = D67D3BD921CBCD5D0050632A /* ref_stream.c */; };
+		D67D3BE121D11DF70050632A /* dir_patch.c in Sources */ = {isa = PBXBuildFile; fileRef = D67D3BE021D11DF70050632A /* dir_patch.c */; };
+		D68CD8F21F4426B100A61337 /* stream_serialize.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D68CD8F01F4426B100A61337 /* stream_serialize.cpp */; };
+		D690AB9C1F20792A0089DC57 /* hdiffz_import_patch.c in Sources */ = {isa = PBXBuildFile; fileRef = D690AB9B1F20792A0089DC57 /* hdiffz_import_patch.c */; };
+		D690ABB71F2079E80089DC57 /* diff.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D690ABA01F2079E80089DC57 /* diff.cpp */; };
+		D690ABB81F2079E80089DC57 /* bytes_rle.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D690ABA31F2079E80089DC57 /* bytes_rle.cpp */; };
+		D690ABB91F2079E80089DC57 /* divsufsort.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D690ABA71F2079E80089DC57 /* divsufsort.cpp */; };
+		D690ABBA1F2079E80089DC57 /* divsufsort64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D690ABAA1F2079E80089DC57 /* divsufsort64.cpp */; };
+		D690ABBB1F2079E80089DC57 /* suffix_string.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D690ABB21F2079E80089DC57 /* suffix_string.cpp */; };
+		D690ABBC1F2079E80089DC57 /* patch.c in Sources */ = {isa = PBXBuildFile; fileRef = D690ABB51F2079E80089DC57 /* patch.c */; };
+		D690AEFB1F2097C90089DC57 /* libbz2.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = D690AEFA1F2097C90089DC57 /* libbz2.tbd */; };
+		D690AEFD1F2097D30089DC57 /* libz.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = D690AEFC1F2097D30089DC57 /* libz.tbd */; };
+		D69EECD9220BD8E2001EF085 /* compress_parallel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D69EECD8220BD8E2001EF085 /* compress_parallel.cpp */; };
+		D69EECDF220C49DE001EF085 /* parallel_channel.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D69EECDB220C49DE001EF085 /* parallel_channel.cpp */; };
+		D69EECE0220C49DE001EF085 /* parallel_import.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D69EECDD220C49DE001EF085 /* parallel_import.cpp */; };
+		D6B240B021E5C21300993A81 /* res_handle_limit.c in Sources */ = {isa = PBXBuildFile; fileRef = D6B240AE21E5C21300993A81 /* res_handle_limit.c */; };
+		D6BF3A5D21E97A0B00833537 /* file_for_patch.c in Sources */ = {isa = PBXBuildFile; fileRef = D6BF3A5C21E97A0A00833537 /* file_for_patch.c */; };
+		D6C9A98E23CBF37D00AC50F8 /* dir_manifest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D6C9A98C23CBF37D00AC50F8 /* dir_manifest.cpp */; };
+		D6C9A9AC23D04F3900AC50F8 /* dir_patch_tools.c in Sources */ = {isa = PBXBuildFile; fileRef = D6C9A9AA23D04F3900AC50F8 /* dir_patch_tools.c */; };
+		D6DD68E01F4015A900A1B22B /* digest_matcher.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D6DD68DE1F4015A900A1B22B /* digest_matcher.cpp */; };
+		D6DD68E31F40163200A1B22B /* adler_roll.c in Sources */ = {isa = PBXBuildFile; fileRef = D6DD68E21F40163200A1B22B /* adler_roll.c */; };
+		D6EE505D1F287234002854A2 /* compress_detect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = D6EE505B1F287234002854A2 /* compress_detect.cpp */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		D690AB8F1F2078A40089DC57 /* CopyFiles */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = /usr/share/man/man1/;
+			dstSubfolderSpec = 0;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 1;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		0D571A63275CEB3B00672D57 /* liblzma.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; path = liblzma.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		0D571A65275CEB3B00672D57 /* libzstd.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; path = libzstd.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		0D571A68275CF68900672D57 /* match_block.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = match_block.cpp; sourceTree = "<group>"; };
+		0D571A6B275CF71A00672D57 /* bspatch_wrapper.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = bspatch_wrapper.c; path = ../../bsdiff_wrapper/bspatch_wrapper.c; sourceTree = "<group>"; };
+		0D571A6C275CF71A00672D57 /* bspatch_wrapper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = bspatch_wrapper.h; path = ../../bsdiff_wrapper/bspatch_wrapper.h; sourceTree = "<group>"; };
+		0D571A6D275CF71A00672D57 /* bsdiff_wrapper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = bsdiff_wrapper.h; path = ../../bsdiff_wrapper/bsdiff_wrapper.h; sourceTree = "<group>"; };
+		0D571A6E275CF71A00672D57 /* bsdiff_wrapper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = bsdiff_wrapper.cpp; path = ../../bsdiff_wrapper/bsdiff_wrapper.cpp; sourceTree = "<group>"; };
+		0D571A71275CF75B00672D57 /* hdiffz.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = hdiffz.cpp; path = ../../hdiffz.cpp; sourceTree = "<group>"; };
+		0D7FEAB4283124A20029772D /* hpatch_lite.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = hpatch_lite.h; sourceTree = "<group>"; };
+		0D7FEAB5283124A20029772D /* hpatch_lite.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = hpatch_lite.c; sourceTree = "<group>"; };
+		0D7FEAB6283124A20029772D /* hpatch_lite_input_cache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = hpatch_lite_input_cache.h; sourceTree = "<group>"; };
+		0D7FEAB7283124A20029772D /* hpatch_lite_types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = hpatch_lite_types.h; sourceTree = "<group>"; };
+		0DA2A8E9292B9880000E86E1 /* vcdiff_wrapper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = vcdiff_wrapper.cpp; sourceTree = "<group>"; };
+		0DA2A8EA292B9880000E86E1 /* vcpatch_code_table.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vcpatch_code_table.h; sourceTree = "<group>"; };
+		0DA2A8EB292B9880000E86E1 /* vcpatch_wrapper.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = vcpatch_wrapper.c; sourceTree = "<group>"; };
+		0DA2A8EC292B9880000E86E1 /* vcdiff_wrapper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vcdiff_wrapper.h; sourceTree = "<group>"; };
+		0DA2A8ED292B9880000E86E1 /* vcpatch_wrapper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vcpatch_wrapper.h; sourceTree = "<group>"; };
+		D61DE5252342DE3B00F6FCCF /* _dir_ignore.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = _dir_ignore.h; path = ../../_dir_ignore.h; sourceTree = "<group>"; };
+		D61DE52D234391CF00F6FCCF /* dir_diff_tools.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dir_diff_tools.h; sourceTree = "<group>"; };
+		D61DE5462344D16900F6FCCF /* dir_diff_tools.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = dir_diff_tools.cpp; sourceTree = "<group>"; };
+		D621352123DC521F00EC4FA4 /* new_dir_output.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = new_dir_output.c; sourceTree = "<group>"; };
+		D621352223DC521F00EC4FA4 /* new_dir_output.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = new_dir_output.h; sourceTree = "<group>"; };
+		D6241ADF21DDA11500E2846A /* file_for_dirDiff.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = file_for_dirDiff.h; sourceTree = "<group>"; };
+		D6241AE021DE47D200E2846A /* new_stream.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = new_stream.c; sourceTree = "<group>"; };
+		D6241AE121DE47D200E2846A /* new_stream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = new_stream.h; sourceTree = "<group>"; };
+		D6367E4D21A65CB20032B717 /* _clock_for_demo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = _clock_for_demo.h; path = ../../_clock_for_demo.h; sourceTree = "<group>"; };
+		D6367E4E21A65CB20032B717 /* _atosize.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = _atosize.h; path = ../../_atosize.h; sourceTree = "<group>"; };
+		D671B71A204983F7002D17A7 /* diff_types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = diff_types.h; sourceTree = "<group>"; };
+		D67D3BD521CBCD5D0050632A /* dir_diff.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = dir_diff.cpp; sourceTree = "<group>"; };
+		D67D3BD821CBCD5D0050632A /* ref_stream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ref_stream.h; sourceTree = "<group>"; };
+		D67D3BD921CBCD5D0050632A /* ref_stream.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = ref_stream.c; sourceTree = "<group>"; };
+		D67D3BDB21CBCD5D0050632A /* dir_diff.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dir_diff.h; sourceTree = "<group>"; };
+		D67D3BDE21CC96740050632A /* mem_buf.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = mem_buf.h; sourceTree = "<group>"; };
+		D67D3BDF21D11DF70050632A /* dir_patch.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = dir_patch.h; sourceTree = "<group>"; };
+		D67D3BE021D11DF70050632A /* dir_patch.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = dir_patch.c; sourceTree = "<group>"; };
+		D68CD8EF1F43B11C00A61337 /* covers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = covers.h; sourceTree = "<group>"; };
+		D68CD8F01F4426B100A61337 /* stream_serialize.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = stream_serialize.cpp; sourceTree = "<group>"; };
+		D68CD8F11F4426B100A61337 /* stream_serialize.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stream_serialize.h; sourceTree = "<group>"; };
+		D68CD8FF1F45D22C00A61337 /* file_for_patch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = file_for_patch.h; path = ../../file_for_patch.h; sourceTree = "<group>"; };
+		D690AB911F2078A40089DC57 /* hdiffz */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = hdiffz; sourceTree = BUILT_PRODUCTS_DIR; };
+		D690AB9B1F20792A0089DC57 /* hdiffz_import_patch.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = hdiffz_import_patch.c; path = ../../hdiffz_import_patch.c; sourceTree = "<group>"; };
+		D690ABA01F2079E80089DC57 /* diff.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = diff.cpp; sourceTree = "<group>"; };
+		D690ABA11F2079E80089DC57 /* diff.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = diff.h; sourceTree = "<group>"; };
+		D690ABA31F2079E80089DC57 /* bytes_rle.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = bytes_rle.cpp; sourceTree = "<group>"; };
+		D690ABA41F2079E80089DC57 /* bytes_rle.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bytes_rle.h; sourceTree = "<group>"; };
+		D690ABA61F2079E80089DC57 /* config.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = config.h; sourceTree = "<group>"; };
+		D690ABA71F2079E80089DC57 /* divsufsort.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = divsufsort.cpp; sourceTree = "<group>"; };
+		D690ABA81F2079E80089DC57 /* divsufsort.c.inc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = divsufsort.c.inc.h; sourceTree = "<group>"; };
+		D690ABA91F2079E80089DC57 /* divsufsort.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = divsufsort.h; sourceTree = "<group>"; };
+		D690ABAA1F2079E80089DC57 /* divsufsort64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = divsufsort64.cpp; sourceTree = "<group>"; };
+		D690ABAB1F2079E80089DC57 /* divsufsort64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = divsufsort64.h; sourceTree = "<group>"; };
+		D690ABAC1F2079E80089DC57 /* divsufsort_private.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = divsufsort_private.h; sourceTree = "<group>"; };
+		D690ABAD1F2079E80089DC57 /* sssort.c.inc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sssort.c.inc.h; sourceTree = "<group>"; };
+		D690ABAE1F2079E80089DC57 /* trsort.c.inc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = trsort.c.inc.h; sourceTree = "<group>"; };
+		D690ABAF1F2079E80089DC57 /* utils.c.inc.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = utils.c.inc.h; sourceTree = "<group>"; };
+		D690ABB01F2079E80089DC57 /* pack_uint.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pack_uint.h; sourceTree = "<group>"; };
+		D690ABB11F2079E80089DC57 /* sais.hxx */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = sais.hxx; sourceTree = "<group>"; };
+		D690ABB21F2079E80089DC57 /* suffix_string.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = suffix_string.cpp; sourceTree = "<group>"; };
+		D690ABB31F2079E80089DC57 /* suffix_string.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = suffix_string.h; sourceTree = "<group>"; };
+		D690ABB51F2079E80089DC57 /* patch.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = patch.c; sourceTree = "<group>"; };
+		D690ABB61F2079E80089DC57 /* patch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = patch.h; sourceTree = "<group>"; };
+		D690AEFA1F2097C90089DC57 /* libbz2.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libbz2.tbd; path = usr/lib/libbz2.tbd; sourceTree = SDKROOT; };
+		D690AEFC1F2097D30089DC57 /* libz.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libz.tbd; path = usr/lib/libz.tbd; sourceTree = SDKROOT; };
+		D69A372B21AED4B2000A0A93 /* patch_private.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = patch_private.h; sourceTree = "<group>"; };
+		D69EECD7220BD149001EF085 /* compress_parallel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = compress_parallel.h; path = ../../compress_parallel.h; sourceTree = "<group>"; };
+		D69EECD8220BD8E2001EF085 /* compress_parallel.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = compress_parallel.cpp; path = ../../compress_parallel.cpp; sourceTree = "<group>"; };
+		D69EECDB220C49DE001EF085 /* parallel_channel.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = parallel_channel.cpp; sourceTree = "<group>"; };
+		D69EECDC220C49DE001EF085 /* parallel_import.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = parallel_import.h; sourceTree = "<group>"; };
+		D69EECDD220C49DE001EF085 /* parallel_import.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = parallel_import.cpp; sourceTree = "<group>"; };
+		D69EECDE220C49DE001EF085 /* parallel_channel.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = parallel_channel.h; sourceTree = "<group>"; };
+		D6B04412221158720015E8CA /* dir_patch_types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dir_patch_types.h; sourceTree = "<group>"; };
+		D6B240AE21E5C21300993A81 /* res_handle_limit.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = res_handle_limit.c; sourceTree = "<group>"; };
+		D6B240AF21E5C21300993A81 /* res_handle_limit.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = res_handle_limit.h; sourceTree = "<group>"; };
+		D6BF3A5C21E97A0A00833537 /* file_for_patch.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = file_for_patch.c; path = ../../file_for_patch.c; sourceTree = "<group>"; };
+		D6BF3A6121EDD5A000833537 /* dir_patch_private.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dir_patch_private.h; sourceTree = "<group>"; };
+		D6BF3A6421EE17EB00833537 /* checksum_plugin_demo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checksum_plugin_demo.h; path = ../../checksum_plugin_demo.h; sourceTree = "<group>"; };
+		D6BF3A6521EE18BB00833537 /* checksum_plugin.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = checksum_plugin.h; sourceTree = "<group>"; };
+		D6C9A98C23CBF37D00AC50F8 /* dir_manifest.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = dir_manifest.cpp; sourceTree = "<group>"; };
+		D6C9A98D23CBF37D00AC50F8 /* dir_manifest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dir_manifest.h; sourceTree = "<group>"; };
+		D6C9A9AA23D04F3900AC50F8 /* dir_patch_tools.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = dir_patch_tools.c; sourceTree = "<group>"; };
+		D6C9A9AB23D04F3900AC50F8 /* dir_patch_tools.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dir_patch_tools.h; sourceTree = "<group>"; };
+		D6DD68DE1F4015A900A1B22B /* digest_matcher.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = digest_matcher.cpp; sourceTree = "<group>"; };
+		D6DD68DF1F4015A900A1B22B /* digest_matcher.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = digest_matcher.h; sourceTree = "<group>"; };
+		D6DD68E11F40163200A1B22B /* adler_roll.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = adler_roll.h; sourceTree = "<group>"; };
+		D6DD68E21F40163200A1B22B /* adler_roll.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = adler_roll.c; sourceTree = "<group>"; };
+		D6DD68E41F41307900A1B22B /* bloom_filter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = bloom_filter.h; sourceTree = "<group>"; };
+		D6E150941F21A95200C2AD3D /* patch_types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = patch_types.h; sourceTree = "<group>"; };
+		D6E150981F223B2700C2AD3D /* compress_plugin_demo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = compress_plugin_demo.h; path = ../../compress_plugin_demo.h; sourceTree = "<group>"; };
+		D6E1509A1F223DC100C2AD3D /* decompress_plugin_demo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = decompress_plugin_demo.h; path = ../../decompress_plugin_demo.h; sourceTree = "<group>"; };
+		D6EE505B1F287234002854A2 /* compress_detect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = compress_detect.cpp; sourceTree = "<group>"; };
+		D6EE505C1F287234002854A2 /* compress_detect.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = compress_detect.h; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		D690AB8E1F2078A40089DC57 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				0D571A66275CEB3B00672D57 /* libzstd.a in Frameworks */,
+				0D571A64275CEB3B00672D57 /* liblzma.a in Frameworks */,
+				D690AEFD1F2097D30089DC57 /* libz.tbd in Frameworks */,
+				D690AEFB1F2097C90089DC57 /* libbz2.tbd in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		0D571A6A275CF6F000672D57 /* bsdiff_wrapper */ = {
+			isa = PBXGroup;
+			children = (
+				0D571A6E275CF71A00672D57 /* bsdiff_wrapper.cpp */,
+				0D571A6D275CF71A00672D57 /* bsdiff_wrapper.h */,
+				0D571A6B275CF71A00672D57 /* bspatch_wrapper.c */,
+				0D571A6C275CF71A00672D57 /* bspatch_wrapper.h */,
+			);
+			name = bsdiff_wrapper;
+			sourceTree = "<group>";
+		};
+		0D7FEAB3283124A20029772D /* HPatchLite */ = {
+			isa = PBXGroup;
+			children = (
+				0D7FEAB4283124A20029772D /* hpatch_lite.h */,
+				0D7FEAB5283124A20029772D /* hpatch_lite.c */,
+				0D7FEAB6283124A20029772D /* hpatch_lite_input_cache.h */,
+				0D7FEAB7283124A20029772D /* hpatch_lite_types.h */,
+			);
+			path = HPatchLite;
+			sourceTree = "<group>";
+		};
+		0DA2A8E8292B9880000E86E1 /* vcdiff_wrapper */ = {
+			isa = PBXGroup;
+			children = (
+				0DA2A8E9292B9880000E86E1 /* vcdiff_wrapper.cpp */,
+				0DA2A8EA292B9880000E86E1 /* vcpatch_code_table.h */,
+				0DA2A8EB292B9880000E86E1 /* vcpatch_wrapper.c */,
+				0DA2A8EC292B9880000E86E1 /* vcdiff_wrapper.h */,
+				0DA2A8ED292B9880000E86E1 /* vcpatch_wrapper.h */,
+			);
+			name = vcdiff_wrapper;
+			path = ../../vcdiff_wrapper;
+			sourceTree = "<group>";
+		};
+		D67D3BD421CBCD5D0050632A /* dirDiffPatch */ = {
+			isa = PBXGroup;
+			children = (
+				D67D3BD621CBCD5D0050632A /* dir_diff */,
+				D67D3BD721CBCD5D0050632A /* dir_patch */,
+			);
+			name = dirDiffPatch;
+			path = ../../dirDiffPatch;
+			sourceTree = "<group>";
+		};
+		D67D3BD621CBCD5D0050632A /* dir_diff */ = {
+			isa = PBXGroup;
+			children = (
+				D6C9A98C23CBF37D00AC50F8 /* dir_manifest.cpp */,
+				D6C9A98D23CBF37D00AC50F8 /* dir_manifest.h */,
+				D67D3BD521CBCD5D0050632A /* dir_diff.cpp */,
+				D67D3BDB21CBCD5D0050632A /* dir_diff.h */,
+				D6241ADF21DDA11500E2846A /* file_for_dirDiff.h */,
+				D61DE52D234391CF00F6FCCF /* dir_diff_tools.h */,
+				D61DE5462344D16900F6FCCF /* dir_diff_tools.cpp */,
+			);
+			path = dir_diff;
+			sourceTree = "<group>";
+		};
+		D67D3BD721CBCD5D0050632A /* dir_patch */ = {
+			isa = PBXGroup;
+			children = (
+				D6B04412221158720015E8CA /* dir_patch_types.h */,
+				D6B240AE21E5C21300993A81 /* res_handle_limit.c */,
+				D6B240AF21E5C21300993A81 /* res_handle_limit.h */,
+				D6241AE021DE47D200E2846A /* new_stream.c */,
+				D6241AE121DE47D200E2846A /* new_stream.h */,
+				D67D3BD821CBCD5D0050632A /* ref_stream.h */,
+				D67D3BD921CBCD5D0050632A /* ref_stream.c */,
+				D6BF3A6121EDD5A000833537 /* dir_patch_private.h */,
+				D6C9A9AB23D04F3900AC50F8 /* dir_patch_tools.h */,
+				D6C9A9AA23D04F3900AC50F8 /* dir_patch_tools.c */,
+				D621352123DC521F00EC4FA4 /* new_dir_output.c */,
+				D621352223DC521F00EC4FA4 /* new_dir_output.h */,
+				D67D3BDF21D11DF70050632A /* dir_patch.h */,
+				D67D3BE021D11DF70050632A /* dir_patch.c */,
+			);
+			path = dir_patch;
+			sourceTree = "<group>";
+		};
+		D690AB881F2078A40089DC57 = {
+			isa = PBXGroup;
+			children = (
+				0DA2A8E8292B9880000E86E1 /* vcdiff_wrapper */,
+				0D571A6A275CF6F000672D57 /* bsdiff_wrapper */,
+				D69EECDA220C49DE001EF085 /* libParallel */,
+				D67D3BD421CBCD5D0050632A /* dirDiffPatch */,
+				D690AB9E1F2079E80089DC57 /* libHDiffPatch */,
+				D6E150981F223B2700C2AD3D /* compress_plugin_demo.h */,
+				D6E1509A1F223DC100C2AD3D /* decompress_plugin_demo.h */,
+				D69EECD7220BD149001EF085 /* compress_parallel.h */,
+				D69EECD8220BD8E2001EF085 /* compress_parallel.cpp */,
+				D6BF3A6421EE17EB00833537 /* checksum_plugin_demo.h */,
+				D6BF3A5C21E97A0A00833537 /* file_for_patch.c */,
+				D68CD8FF1F45D22C00A61337 /* file_for_patch.h */,
+				D61DE5252342DE3B00F6FCCF /* _dir_ignore.h */,
+				D6367E4E21A65CB20032B717 /* _atosize.h */,
+				D6367E4D21A65CB20032B717 /* _clock_for_demo.h */,
+				D690AB9B1F20792A0089DC57 /* hdiffz_import_patch.c */,
+				0D571A71275CF75B00672D57 /* hdiffz.cpp */,
+				D690AB921F2078A40089DC57 /* Products */,
+				D690ABBD1F20832E0089DC57 /* Frameworks */,
+			);
+			sourceTree = "<group>";
+		};
+		D690AB921F2078A40089DC57 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				D690AB911F2078A40089DC57 /* hdiffz */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		D690AB9E1F2079E80089DC57 /* libHDiffPatch */ = {
+			isa = PBXGroup;
+			children = (
+				0D7FEAB3283124A20029772D /* HPatchLite */,
+				D690AB9F1F2079E80089DC57 /* HDiff */,
+				D690ABB41F2079E80089DC57 /* HPatch */,
+			);
+			name = libHDiffPatch;
+			path = ../../libHDiffPatch;
+			sourceTree = "<group>";
+		};
+		D690AB9F1F2079E80089DC57 /* HDiff */ = {
+			isa = PBXGroup;
+			children = (
+				0D571A68275CF68900672D57 /* match_block.cpp */,
+				D671B71A204983F7002D17A7 /* diff_types.h */,
+				D690ABA01F2079E80089DC57 /* diff.cpp */,
+				D690ABA11F2079E80089DC57 /* diff.h */,
+				D690ABA21F2079E80089DC57 /* private_diff */,
+			);
+			path = HDiff;
+			sourceTree = "<group>";
+		};
+		D690ABA21F2079E80089DC57 /* private_diff */ = {
+			isa = PBXGroup;
+			children = (
+				D6DD68DD1F4015A900A1B22B /* limit_mem_diff */,
+				D690ABA31F2079E80089DC57 /* bytes_rle.cpp */,
+				D690ABA41F2079E80089DC57 /* bytes_rle.h */,
+				D690ABA51F2079E80089DC57 /* libdivsufsort */,
+				D690ABB01F2079E80089DC57 /* pack_uint.h */,
+				D690ABB11F2079E80089DC57 /* sais.hxx */,
+				D690ABB21F2079E80089DC57 /* suffix_string.cpp */,
+				D690ABB31F2079E80089DC57 /* suffix_string.h */,
+				D6EE505B1F287234002854A2 /* compress_detect.cpp */,
+				D6EE505C1F287234002854A2 /* compress_detect.h */,
+				D67D3BDE21CC96740050632A /* mem_buf.h */,
+			);
+			path = private_diff;
+			sourceTree = "<group>";
+		};
+		D690ABA51F2079E80089DC57 /* libdivsufsort */ = {
+			isa = PBXGroup;
+			children = (
+				D690ABA61F2079E80089DC57 /* config.h */,
+				D690ABA71F2079E80089DC57 /* divsufsort.cpp */,
+				D690ABA81F2079E80089DC57 /* divsufsort.c.inc.h */,
+				D690ABA91F2079E80089DC57 /* divsufsort.h */,
+				D690ABAA1F2079E80089DC57 /* divsufsort64.cpp */,
+				D690ABAB1F2079E80089DC57 /* divsufsort64.h */,
+				D690ABAC1F2079E80089DC57 /* divsufsort_private.h */,
+				D690ABAD1F2079E80089DC57 /* sssort.c.inc.h */,
+				D690ABAE1F2079E80089DC57 /* trsort.c.inc.h */,
+				D690ABAF1F2079E80089DC57 /* utils.c.inc.h */,
+			);
+			path = libdivsufsort;
+			sourceTree = "<group>";
+		};
+		D690ABB41F2079E80089DC57 /* HPatch */ = {
+			isa = PBXGroup;
+			children = (
+				D6BF3A6521EE18BB00833537 /* checksum_plugin.h */,
+				D69A372B21AED4B2000A0A93 /* patch_private.h */,
+				D690ABB51F2079E80089DC57 /* patch.c */,
+				D690ABB61F2079E80089DC57 /* patch.h */,
+				D6E150941F21A95200C2AD3D /* patch_types.h */,
+			);
+			path = HPatch;
+			sourceTree = "<group>";
+		};
+		D690ABBD1F20832E0089DC57 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				0D571A63275CEB3B00672D57 /* liblzma.a */,
+				0D571A65275CEB3B00672D57 /* libzstd.a */,
+				D690AEFC1F2097D30089DC57 /* libz.tbd */,
+				D690AEFA1F2097C90089DC57 /* libbz2.tbd */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+		D69EECDA220C49DE001EF085 /* libParallel */ = {
+			isa = PBXGroup;
+			children = (
+				D69EECDE220C49DE001EF085 /* parallel_channel.h */,
+				D69EECDB220C49DE001EF085 /* parallel_channel.cpp */,
+				D69EECDC220C49DE001EF085 /* parallel_import.h */,
+				D69EECDD220C49DE001EF085 /* parallel_import.cpp */,
+			);
+			name = libParallel;
+			path = ../../libParallel;
+			sourceTree = "<group>";
+		};
+		D6DD68DD1F4015A900A1B22B /* limit_mem_diff */ = {
+			isa = PBXGroup;
+			children = (
+				D6DD68DE1F4015A900A1B22B /* digest_matcher.cpp */,
+				D6DD68DF1F4015A900A1B22B /* digest_matcher.h */,
+				D68CD8F01F4426B100A61337 /* stream_serialize.cpp */,
+				D68CD8F11F4426B100A61337 /* stream_serialize.h */,
+				D68CD8EF1F43B11C00A61337 /* covers.h */,
+				D6DD68E41F41307900A1B22B /* bloom_filter.h */,
+				D6DD68E11F40163200A1B22B /* adler_roll.h */,
+				D6DD68E21F40163200A1B22B /* adler_roll.c */,
+			);
+			path = limit_mem_diff;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		D690AB901F2078A40089DC57 /* hdiffz */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = D690AB981F2078A40089DC57 /* Build configuration list for PBXNativeTarget "hdiffz" */;
+			buildPhases = (
+				D690AB8D1F2078A40089DC57 /* Sources */,
+				D690AB8E1F2078A40089DC57 /* Frameworks */,
+				D690AB8F1F2078A40089DC57 /* CopyFiles */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = hdiffz;
+			productName = hdiffz;
+			productReference = D690AB911F2078A40089DC57 /* hdiffz */;
+			productType = "com.apple.product-type.tool";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		D690AB891F2078A40089DC57 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 1030;
+				ORGANIZATIONNAME = housisong;
+				TargetAttributes = {
+					D690AB901F2078A40089DC57 = {
+						CreatedOnToolsVersion = 8.3.3;
+						ProvisioningStyle = Automatic;
+					};
+				};
+			};
+			buildConfigurationList = D690AB8C1F2078A40089DC57 /* Build configuration list for PBXProject "hdiffz" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = D690AB881F2078A40089DC57;
+			productRefGroup = D690AB921F2078A40089DC57 /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				D690AB901F2078A40089DC57 /* hdiffz */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXSourcesBuildPhase section */
+		D690AB8D1F2078A40089DC57 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				D6C9A9AC23D04F3900AC50F8 /* dir_patch_tools.c in Sources */,
+				0D571A70275CF71A00672D57 /* bsdiff_wrapper.cpp in Sources */,
+				D621352323DC521F00EC4FA4 /* new_dir_output.c in Sources */,
+				0D571A72275CF75B00672D57 /* hdiffz.cpp in Sources */,
+				D69EECD9220BD8E2001EF085 /* compress_parallel.cpp in Sources */,
+				0D571A6F275CF71A00672D57 /* bspatch_wrapper.c in Sources */,
+				D6BF3A5D21E97A0B00833537 /* file_for_patch.c in Sources */,
+				0D7FEAB8283124A20029772D /* hpatch_lite.c in Sources */,
+				0DA2A8EE292B9880000E86E1 /* vcdiff_wrapper.cpp in Sources */,
+				D67D3BDC21CBCD5D0050632A /* dir_diff.cpp in Sources */,
+				D67D3BE121D11DF70050632A /* dir_patch.c in Sources */,
+				0DA2A8EF292B9880000E86E1 /* vcpatch_wrapper.c in Sources */,
+				D6C9A98E23CBF37D00AC50F8 /* dir_manifest.cpp in Sources */,
+				D6EE505D1F287234002854A2 /* compress_detect.cpp in Sources */,
+				D6DD68E01F4015A900A1B22B /* digest_matcher.cpp in Sources */,
+				D6241AE221DE47D200E2846A /* new_stream.c in Sources */,
+				D69EECE0220C49DE001EF085 /* parallel_import.cpp in Sources */,
+				D690ABBC1F2079E80089DC57 /* patch.c in Sources */,
+				D6B240B021E5C21300993A81 /* res_handle_limit.c in Sources */,
+				D690ABB81F2079E80089DC57 /* bytes_rle.cpp in Sources */,
+				D690ABBB1F2079E80089DC57 /* suffix_string.cpp in Sources */,
+				0D571A69275CF68900672D57 /* match_block.cpp in Sources */,
+				D67D3BDD21CBCD5D0050632A /* ref_stream.c in Sources */,
+				D61DE5472344D16900F6FCCF /* dir_diff_tools.cpp in Sources */,
+				D69EECDF220C49DE001EF085 /* parallel_channel.cpp in Sources */,
+				D690ABB71F2079E80089DC57 /* diff.cpp in Sources */,
+				D690ABBA1F2079E80089DC57 /* divsufsort64.cpp in Sources */,
+				D690ABB91F2079E80089DC57 /* divsufsort.cpp in Sources */,
+				D690AB9C1F20792A0089DC57 /* hdiffz_import_patch.c in Sources */,
+				D690AB9C1F20792A0089DC57 /* hdiffz_import_patch.c in Sources */,
+				D68CD8F21F4426B100A61337 /* stream_serialize.cpp in Sources */,
+				D6DD68E31F40163200A1B22B /* adler_roll.c in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		D690AB961F2078A40089DC57 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "c++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = NO;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = NO;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				CODE_SIGN_IDENTITY = "-";
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				GCC_C_LANGUAGE_STANDARD = "compiler-default";
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = (
+					../../../lz4/lib/,
+					../../../zstd/lib/,
+					../../../lzma/C/,
+				);
+				MACOSX_DEPLOYMENT_TARGET = 10.9;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = macosx;
+			};
+			name = Debug;
+		};
+		D690AB971F2078A40089DC57 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
+				CLANG_CXX_LANGUAGE_STANDARD = "c++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = NO;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_DOCUMENTATION_COMMENTS = NO;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				CODE_SIGN_IDENTITY = "-";
+				DEAD_CODE_STRIPPING = YES;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				DEPLOYMENT_POSTPROCESSING = YES;
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = "compiler-default";
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = s;
+				GCC_PREPROCESSOR_DEFINITIONS = NDEBUG;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = (
+					../../../lz4/lib/,
+					../../../zstd/lib/,
+					../../../lzma/C/,
+				);
+				MACOSX_DEPLOYMENT_TARGET = 10.9;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = macosx;
+			};
+			name = Release;
+		};
+		D690AB991F2078A40089DC57 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				MACOSX_DEPLOYMENT_TARGET = 10.9;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Debug;
+		};
+		D690AB9A1F2078A40089DC57 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				MACOSX_DEPLOYMENT_TARGET = 10.9;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		D690AB8C1F2078A40089DC57 /* Build configuration list for PBXProject "hdiffz" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				D690AB961F2078A40089DC57 /* Debug */,
+				D690AB971F2078A40089DC57 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		D690AB981F2078A40089DC57 /* Build configuration list for PBXNativeTarget "hdiffz" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				D690AB991F2078A40089DC57 /* Debug */,
+				D690AB9A1F2078A40089DC57 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = D690AB891F2078A40089DC57 /* Project object */;
+}

deps/HDiffPatch/builds/xcode/hdiffz.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:HDiffZ.xcodeproj">
+   </FileRef>
+</Workspace>

deps/HDiffPatch/builds/xcode/hdiffz.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

deps/HDiffPatch/builds/xcode/hpatchz.xcodeproj/project.pbxproj

@@ -0,0 +1,394 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		0D571A5C275CE9CE00672D57 /* libzstd.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 0D571A5B275CE9CE00672D57 /* libzstd.a */; };
+		0D571A5D275CE9CE00672D57 /* liblzma.a in Frameworks */ = {isa = PBXBuildFile; fileRef = D64B4BFE2077B9240039C38B /* liblzma.a */; };
+		0D571A62275CEAE900672D57 /* bspatch_wrapper.c in Sources */ = {isa = PBXBuildFile; fileRef = 0D571A61275CEAE900672D57 /* bspatch_wrapper.c */; };
+		0DA2A8E52910E70D000E86E1 /* vcpatch_wrapper.c in Sources */ = {isa = PBXBuildFile; fileRef = 0DA2A8E42910E70D000E86E1 /* vcpatch_wrapper.c */; };
+		D6241AE521DE47EC00E2846A /* new_stream.c in Sources */ = {isa = PBXBuildFile; fileRef = D6241AE321DE47EC00E2846A /* new_stream.c */; };
+		D64B4BEF2077AAAA0039C38B /* hpatchz.c in Sources */ = {isa = PBXBuildFile; fileRef = D64B4BEE2077AAAA0039C38B /* hpatchz.c */; };
+		D64B4BF92077B9090039C38B /* libz.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = D64B4BF82077B9090039C38B /* libz.tbd */; };
+		D64B4BFB2077B91A0039C38B /* libbz2.tbd in Frameworks */ = {isa = PBXBuildFile; fileRef = D64B4BFA2077B91A0039C38B /* libbz2.tbd */; };
+		D67D3BF421D3C5870050632A /* ref_stream.c in Sources */ = {isa = PBXBuildFile; fileRef = D67D3BF121D3C5870050632A /* ref_stream.c */; };
+		D67D3BF521D3C5870050632A /* dir_patch.c in Sources */ = {isa = PBXBuildFile; fileRef = D67D3BF221D3C5870050632A /* dir_patch.c */; };
+		D6BAF70321F2F61B00C30C0A /* adler_roll.c in Sources */ = {isa = PBXBuildFile; fileRef = D6BAF70121F2F61B00C30C0A /* adler_roll.c */; };
+		D6BD9BCE17578601004886DE /* patch.c in Sources */ = {isa = PBXBuildFile; fileRef = D6BD9BCA17578601004886DE /* patch.c */; };
+		D6BF3A5721E8CDC300833537 /* res_handle_limit.c in Sources */ = {isa = PBXBuildFile; fileRef = D6BF3A5621E8CDC300833537 /* res_handle_limit.c */; };
+		D6BF3A5921E95F4200833537 /* file_for_patch.c in Sources */ = {isa = PBXBuildFile; fileRef = D6BF3A5821E95F4200833537 /* file_for_patch.c */; };
+		D6C9A9A623D03F4B00AC50F8 /* dir_patch_tools.c in Sources */ = {isa = PBXBuildFile; fileRef = D6C9A9A423D03F4B00AC50F8 /* dir_patch_tools.c */; };
+		D6C9A9AF23D3CC2500AC50F8 /* new_dir_output.c in Sources */ = {isa = PBXBuildFile; fileRef = D6C9A9AD23D3CC2500AC50F8 /* new_dir_output.c */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		D6553CB1165FA1A9009D4C44 /* CopyFiles */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = /usr/share/man/man1/;
+			dstSubfolderSpec = 0;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 1;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		0D571A5B275CE9CE00672D57 /* libzstd.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; path = libzstd.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		0D571A61275CEAE900672D57 /* bspatch_wrapper.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = bspatch_wrapper.c; path = ../../bsdiff_wrapper/bspatch_wrapper.c; sourceTree = "<group>"; };
+		0DA2A8E42910E70D000E86E1 /* vcpatch_wrapper.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = vcpatch_wrapper.c; path = ../../vcdiff_wrapper/vcpatch_wrapper.c; sourceTree = "<group>"; };
+		D6241AE321DE47EC00E2846A /* new_stream.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = new_stream.c; sourceTree = "<group>"; };
+		D6241AE421DE47EC00E2846A /* new_stream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = new_stream.h; sourceTree = "<group>"; };
+		D639ACD9208334A800811BB3 /* _atosize.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = _atosize.h; path = ../../_atosize.h; sourceTree = "<group>"; };
+		D64B4BEE2077AAAA0039C38B /* hpatchz.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = hpatchz.c; path = ../../hpatchz.c; sourceTree = "<group>"; };
+		D64B4BF02077AB290039C38B /* patch_types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = patch_types.h; sourceTree = "<group>"; };
+		D64B4BF12077AB2A0039C38B /* patch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = patch.h; sourceTree = "<group>"; };
+		D64B4BF22077AB550039C38B /* _clock_for_demo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = _clock_for_demo.h; path = ../../_clock_for_demo.h; sourceTree = "<group>"; };
+		D64B4BF32077AB550039C38B /* decompress_plugin_demo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = decompress_plugin_demo.h; path = ../../decompress_plugin_demo.h; sourceTree = "<group>"; };
+		D64B4BF42077AB550039C38B /* file_for_patch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = file_for_patch.h; path = ../../file_for_patch.h; sourceTree = "<group>"; };
+		D64B4BF82077B9090039C38B /* libz.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libz.tbd; path = usr/lib/libz.tbd; sourceTree = SDKROOT; };
+		D64B4BFA2077B91A0039C38B /* libbz2.tbd */ = {isa = PBXFileReference; lastKnownFileType = "sourcecode.text-based-dylib-definition"; name = libbz2.tbd; path = usr/lib/libbz2.tbd; sourceTree = SDKROOT; };
+		D64B4BFE2077B9240039C38B /* liblzma.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; path = liblzma.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		D6553CB3165FA1A9009D4C44 /* hpatchz */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = hpatchz; sourceTree = BUILT_PRODUCTS_DIR; };
+		D67D3BF021D3C5870050632A /* dir_patch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dir_patch.h; sourceTree = "<group>"; };
+		D67D3BF121D3C5870050632A /* ref_stream.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = ref_stream.c; sourceTree = "<group>"; };
+		D67D3BF221D3C5870050632A /* dir_patch.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = dir_patch.c; sourceTree = "<group>"; };
+		D67D3BF321D3C5870050632A /* ref_stream.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ref_stream.h; sourceTree = "<group>"; };
+		D67D3BF621D48DCB0050632A /* patch_private.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = patch_private.h; sourceTree = "<group>"; };
+		D6BAF6F221F2E08000C30C0A /* checksum_plugin.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = checksum_plugin.h; sourceTree = "<group>"; };
+		D6BAF6F521F2E34600C30C0A /* checksum_plugin_demo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checksum_plugin_demo.h; path = ../../checksum_plugin_demo.h; sourceTree = "<group>"; };
+		D6BAF70121F2F61B00C30C0A /* adler_roll.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = adler_roll.c; path = ../../libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.c; sourceTree = "<group>"; };
+		D6BAF70221F2F61B00C30C0A /* adler_roll.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = adler_roll.h; path = ../../libHDiffPatch/HDiff/private_diff/limit_mem_diff/adler_roll.h; sourceTree = "<group>"; };
+		D6BAF70721F7F53600C30C0A /* hpatch_dir_listener.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = hpatch_dir_listener.h; path = ../../hpatch_dir_listener.h; sourceTree = "<group>"; };
+		D6BD9BCA17578601004886DE /* patch.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = patch.c; sourceTree = "<group>"; };
+		D6BF3A5521E8CDC300833537 /* res_handle_limit.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = res_handle_limit.h; sourceTree = "<group>"; };
+		D6BF3A5621E8CDC300833537 /* res_handle_limit.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = res_handle_limit.c; sourceTree = "<group>"; };
+		D6BF3A5821E95F4200833537 /* file_for_patch.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = file_for_patch.c; path = ../../file_for_patch.c; sourceTree = "<group>"; };
+		D6BF3A6221EDD5A900833537 /* dir_patch_private.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dir_patch_private.h; sourceTree = "<group>"; };
+		D6C9A9A323D03F4B00AC50F8 /* dir_patch_types.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dir_patch_types.h; sourceTree = "<group>"; };
+		D6C9A9A423D03F4B00AC50F8 /* dir_patch_tools.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = dir_patch_tools.c; sourceTree = "<group>"; };
+		D6C9A9A523D03F4B00AC50F8 /* dir_patch_tools.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = dir_patch_tools.h; sourceTree = "<group>"; };
+		D6C9A9AD23D3CC2500AC50F8 /* new_dir_output.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = new_dir_output.c; sourceTree = "<group>"; };
+		D6C9A9AE23D3CC2500AC50F8 /* new_dir_output.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = new_dir_output.h; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		D6553CB0165FA1A9009D4C44 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				0D571A5D275CE9CE00672D57 /* liblzma.a in Frameworks */,
+				0D571A5C275CE9CE00672D57 /* libzstd.a in Frameworks */,
+				D64B4BFB2077B91A0039C38B /* libbz2.tbd in Frameworks */,
+				D64B4BF92077B9090039C38B /* libz.tbd in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		D64B4BF72077B9090039C38B /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				0D571A5B275CE9CE00672D57 /* libzstd.a */,
+				D64B4BFE2077B9240039C38B /* liblzma.a */,
+				D64B4BFA2077B91A0039C38B /* libbz2.tbd */,
+				D64B4BF82077B9090039C38B /* libz.tbd */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+		D6553CAA165FA1A9009D4C44 = {
+			isa = PBXGroup;
+			children = (
+				D6BAF70021F2F60500C30C0A /* adler_roll */,
+				D67D3BEF21D3C5870050632A /* dir_patch */,
+				D6BD9BC917578601004886DE /* HPatch */,
+				0D571A61275CEAE900672D57 /* bspatch_wrapper.c */,
+				0DA2A8E42910E70D000E86E1 /* vcpatch_wrapper.c */,
+				D64B4BF32077AB550039C38B /* decompress_plugin_demo.h */,
+				D6BAF6F521F2E34600C30C0A /* checksum_plugin_demo.h */,
+				D64B4BF22077AB550039C38B /* _clock_for_demo.h */,
+				D639ACD9208334A800811BB3 /* _atosize.h */,
+				D6BF3A5821E95F4200833537 /* file_for_patch.c */,
+				D64B4BF42077AB550039C38B /* file_for_patch.h */,
+				D6BAF70721F7F53600C30C0A /* hpatch_dir_listener.h */,
+				D64B4BEE2077AAAA0039C38B /* hpatchz.c */,
+				D6553CB4165FA1A9009D4C44 /* Products */,
+				D64B4BF72077B9090039C38B /* Frameworks */,
+			);
+			sourceTree = "<group>";
+		};
+		D6553CB4165FA1A9009D4C44 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				D6553CB3165FA1A9009D4C44 /* hpatchz */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		D67D3BEF21D3C5870050632A /* dir_patch */ = {
+			isa = PBXGroup;
+			children = (
+				D6BF3A5621E8CDC300833537 /* res_handle_limit.c */,
+				D6BF3A5521E8CDC300833537 /* res_handle_limit.h */,
+				D6241AE321DE47EC00E2846A /* new_stream.c */,
+				D6241AE421DE47EC00E2846A /* new_stream.h */,
+				D67D3BF121D3C5870050632A /* ref_stream.c */,
+				D67D3BF321D3C5870050632A /* ref_stream.h */,
+				D6BF3A6221EDD5A900833537 /* dir_patch_private.h */,
+				D6C9A9A323D03F4B00AC50F8 /* dir_patch_types.h */,
+				D6C9A9A423D03F4B00AC50F8 /* dir_patch_tools.c */,
+				D6C9A9A523D03F4B00AC50F8 /* dir_patch_tools.h */,
+				D6C9A9AD23D3CC2500AC50F8 /* new_dir_output.c */,
+				D6C9A9AE23D3CC2500AC50F8 /* new_dir_output.h */,
+				D67D3BF021D3C5870050632A /* dir_patch.h */,
+				D67D3BF221D3C5870050632A /* dir_patch.c */,
+			);
+			name = dir_patch;
+			path = ../../dirDiffPatch/dir_patch;
+			sourceTree = "<group>";
+		};
+		D6BAF70021F2F60500C30C0A /* adler_roll */ = {
+			isa = PBXGroup;
+			children = (
+				D6BAF70121F2F61B00C30C0A /* adler_roll.c */,
+				D6BAF70221F2F61B00C30C0A /* adler_roll.h */,
+			);
+			name = adler_roll;
+			sourceTree = "<group>";
+		};
+		D6BD9BC917578601004886DE /* HPatch */ = {
+			isa = PBXGroup;
+			children = (
+				D6BAF6F221F2E08000C30C0A /* checksum_plugin.h */,
+				D67D3BF621D48DCB0050632A /* patch_private.h */,
+				D64B4BF02077AB290039C38B /* patch_types.h */,
+				D64B4BF12077AB2A0039C38B /* patch.h */,
+				D6BD9BCA17578601004886DE /* patch.c */,
+			);
+			name = HPatch;
+			path = ../../libHDiffPatch/HPatch;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		D6553CB2165FA1A9009D4C44 /* hpatchz */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = D6553CBC165FA1A9009D4C44 /* Build configuration list for PBXNativeTarget "hpatchz" */;
+			buildPhases = (
+				D6553CAF165FA1A9009D4C44 /* Sources */,
+				D6553CB0165FA1A9009D4C44 /* Frameworks */,
+				D6553CB1165FA1A9009D4C44 /* CopyFiles */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = hpatchz;
+			productName = hpatch;
+			productReference = D6553CB3165FA1A9009D4C44 /* hpatchz */;
+			productType = "com.apple.product-type.tool";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		D6553CAB165FA1A9009D4C44 /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastUpgradeCheck = 1030;
+				ORGANIZATIONNAME = HouSisong;
+			};
+			buildConfigurationList = D6553CAE165FA1A9009D4C44 /* Build configuration list for PBXProject "hpatchz" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = D6553CAA165FA1A9009D4C44;
+			productRefGroup = D6553CB4165FA1A9009D4C44 /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				D6553CB2165FA1A9009D4C44 /* hpatchz */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXSourcesBuildPhase section */
+		D6553CAF165FA1A9009D4C44 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				D6C9A9AF23D3CC2500AC50F8 /* new_dir_output.c in Sources */,
+				D6BD9BCE17578601004886DE /* patch.c in Sources */,
+				D67D3BF421D3C5870050632A /* ref_stream.c in Sources */,
+				0D571A62275CEAE900672D57 /* bspatch_wrapper.c in Sources */,
+				D67D3BF521D3C5870050632A /* dir_patch.c in Sources */,
+				D6BF3A5721E8CDC300833537 /* res_handle_limit.c in Sources */,
+				D6241AE521DE47EC00E2846A /* new_stream.c in Sources */,
+				D6BF3A5921E95F4200833537 /* file_for_patch.c in Sources */,
+				D6BAF70321F2F61B00C30C0A /* adler_roll.c in Sources */,
+				D64B4BEF2077AAAA0039C38B /* hpatchz.c in Sources */,
+				D6C9A9A623D03F4B00AC50F8 /* dir_patch_tools.c in Sources */,
+				0DA2A8E52910E70D000E86E1 /* vcpatch_wrapper.c in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		D6553CBA165FA1A9009D4C44 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "compiler-default";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				GCC_C_LANGUAGE_STANDARD = "compiler-default";
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_ENABLE_OBJC_EXCEPTIONS = YES;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_STRICT_ALIASING = YES;
+				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = (
+					../../../lz4/lib/,
+					../../../zstd/lib/,
+					../../../lzma/C/,
+				);
+				MACOSX_DEPLOYMENT_TARGET = 10.9;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = macosx;
+			};
+			name = Debug;
+		};
+		D6553CBB165FA1A9009D4C44 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "compiler-default";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				DEAD_CODE_STRIPPING = YES;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				DEPLOYMENT_POSTPROCESSING = YES;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_C_LANGUAGE_STANDARD = "compiler-default";
+				GCC_ENABLE_OBJC_EXCEPTIONS = YES;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = s;
+				GCC_PREPROCESSOR_DEFINITIONS = NDEBUG;
+				GCC_STRICT_ALIASING = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				HEADER_SEARCH_PATHS = (
+					../../../lz4/lib/,
+					../../../zstd/lib/,
+					../../../lzma/C/,
+				);
+				MACOSX_DEPLOYMENT_TARGET = 10.9;
+				SDKROOT = macosx;
+			};
+			name = Release;
+		};
+		D6553CBD165FA1A9009D4C44 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				MACOSX_DEPLOYMENT_TARGET = 10.9;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Debug;
+		};
+		D6553CBE165FA1A9009D4C44 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				CLANG_ENABLE_OBJC_WEAK = YES;
+				MACOSX_DEPLOYMENT_TARGET = 10.9;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		D6553CAE165FA1A9009D4C44 /* Build configuration list for PBXProject "hpatchz" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				D6553CBA165FA1A9009D4C44 /* Debug */,
+				D6553CBB165FA1A9009D4C44 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		D6553CBC165FA1A9009D4C44 /* Build configuration list for PBXNativeTarget "hpatchz" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				D6553CBD165FA1A9009D4C44 /* Debug */,
+				D6553CBE165FA1A9009D4C44 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = D6553CAB165FA1A9009D4C44 /* Project object */;
+}