[ { "path": ".buckconfig", "content": "[cxx]\n cppflags = -DXXH_NAMESPACE=ZSTD_ -DZSTD_LEGACY_SUPPORT=4\n cflags = -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow -Wstrict-aliasing=1 -Wswitch-enum -Wdeclaration-after-statement -Wstrict-prototypes -Wundef -Wpointer-arith\n cxxppflags = -DXXH_NAMESPACE=ZSTD_ -DZSTD_LEGACY_SUPPORT=4\n cxxflags = -std=c++11 -Wno-deprecated-declarations\n gtest_dep = //contrib/pzstd:gtest\n\n[httpserver]\n port = 0\n" }, { "path": ".buckversion", "content": "c8dec2e8da52d483f6dd7c6cd2ad694e8e6fed2b\n" }, { "path": ".cirrus.yml", "content": "task:\n name: FreeBSD (make check)\n freebsd_instance:\n matrix:\n image_family: freebsd-15-0-amd64-zfs\n install_script: pkg install -y gmake coreutils\n script: |\n MOREFLAGS=\"-Werror\" gmake -j all\n gmake check\n" }, { "path": ".gitattributes", "content": "# Set the default behavior\n* text eol=lf\n\n# Explicitly declare source files\n*.c text eol=lf\n*.h text eol=lf\n\n# Denote files that should not be modified.\n*.odt binary\n*.png binary\n\n# Visual Studio\n*.sln text eol=crlf\n*.vcxproj* text eol=crlf\n*.vcproj* text eol=crlf\n*.suo binary\n*.rc text eol=crlf\n\n# Windows\n*.bat text eol=crlf\n*.cmd text eol=crlf\n" }, { "path": ".github/ISSUE_TEMPLATE/bug_report.md", "content": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n**Describe the bug**\nA clear and concise description of what the bug is.\n\n**To Reproduce**\nSteps to reproduce the behavior:\n1. Downloads data '...'\n2. Run '...' with flags '...'\n3. Scroll up on the log to '....'\n4. See error\n\n**Expected behavior**\nA clear and concise description of what you expected to happen.\n\n**Screenshots and charts**\nIf applicable, add screenshots and charts to help explain your problem.\n\n**Desktop (please complete the following information):**\n - OS: [e.g. Mac]\n - Version [e.g. 22]\n - Compiler [e.g. gcc]\n - Flags [e.g. O2]\n - Other relevant hardware specs [e.g. Dual-core]\n - Build system [e.g. Makefile]\n\n**Additional context**\nAdd any other context about the problem here.\n" }, { "path": ".github/ISSUE_TEMPLATE/feature_request.md", "content": "---\nname: Feature request\nabout: Suggest an idea for this project\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n**Is your feature request related to a problem? Please describe.**\nA clear and concise description of what the problem is. Ex. I'm always frustrated when [...]\n\n**Describe the solution you'd like**\nA clear and concise description of what you want to happen.\n\n**Describe alternatives you've considered**\nA clear and concise description of any alternative solutions or features you've considered.\n\n**Additional context**\nAdd any other context or screenshots about the feature request here.\n" }, { "path": ".github/dependabot.yml", "content": "version: 2\nupdates:\n - package-ecosystem: \"github-actions\"\n directory: \"/\"\n schedule:\n interval: \"monthly\"\n" }, { "path": ".github/workflows/android-ndk-build.yml", "content": "name: Android NDK Build\n\non:\n pull_request:\n branches: [ dev, release, actionsTest ]\n push:\n branches: [ actionsTest, '*ndk*' ]\n\npermissions: read-all\n\njobs:\n build:\n runs-on: ubuntu-latest\n\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n\n - name: Set up JDK 17\n uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0\n with:\n java-version: '17'\n distribution: 'temurin'\n\n - name: Setup Android SDK\n uses: android-actions/setup-android@9fc6c4e9069bf8d3d10b2204b1fb8f6ef7065407 # v3.2.2\n\n - name: Install Android NDK\n run: |\n sdkmanager --install \"ndk;27.0.12077973\"\n echo \"ANDROID_NDK_HOME=$ANDROID_SDK_ROOT/ndk/27.0.12077973\" >> $GITHUB_ENV\n\n - name: Build with NDK\n run: |\n export PATH=$ANDROID_NDK_HOME/toolchains/llvm/prebuilt/linux-x86_64/bin:$PATH\n make CC=aarch64-linux-android21-clang \\\n AR=llvm-ar \\\n RANLIB=llvm-ranlib \\\n STRIP=llvm-strip\n\n - name: Build with CMake and NDK\n run: |\n mkdir -p build-android\n cd build-android\n cmake --version\n cmake ../build/cmake \\\n -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_HOME/build/cmake/android.toolchain.cmake \\\n -DANDROID_ABI=arm64-v8a \\\n -DANDROID_PLATFORM=android-21 \\\n -DCMAKE_BUILD_TYPE=Release\n cmake --build . --parallel\n" }, { "path": ".github/workflows/cmake-tests.yml", "content": "name: cmake-tests\n# CMake-specific build and test workflows\n# This workflow validates zstd builds across different CMake configurations,\n# platforms, and edge cases to ensure broad compatibility.\n\nconcurrency:\n group: cmake-${{ github.ref }}\n cancel-in-progress: true\n\non:\n pull_request:\n branches: [ dev, release, actionsTest ]\n\npermissions: read-all\n\nenv:\n # Centralized test timeouts for consistency\n QUICK_TEST_TIME: \"30s\"\n STANDARD_TEST_TIME: \"1mn\"\n # Common CMake flags\n COMMON_CMAKE_FLAGS: \"-DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DZSTD_BUILD_TESTS=ON\"\n\njobs:\n # Basic cmake build using the root CMakeLists.txt\n # Provides a lightweight sanity check that the top-level project config builds\n # with the default Unix Makefiles generator driven purely through cmake commands\n cmake-root-basic:\n name: \"CMake Root Build\"\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: Configure (Root)\n run: |\n cmake -S . -B cmake-build -DCMAKE_BUILD_TYPE=Release ${{ env.COMMON_CMAKE_FLAGS }}\n - name: Build (Root)\n run: |\n cmake --build cmake-build --config Release\n\n # Ubuntu-based cmake build using make wrapper\n # This test uses the make-driven cmake build to ensure compatibility\n # with the existing build system integration\n cmake-ubuntu-basic:\n name: \"CMake build using make wrapper\"\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: Install dependencies\n run: |\n sudo apt install liblzma-dev # Required for compression algorithms\n - name: CMake build and test via make\n run: |\n # Use make wrapper for cmake build with quick test timeouts\n FUZZERTEST=-T${{ env.STANDARD_TEST_TIME }} ZSTREAM_TESTTIME=-T${{ env.STANDARD_TEST_TIME }} make cmakebuild V=1\n\n # Cross-platform cmake build with edge case: source paths containing spaces\n # This test ensures cmake handles filesystem paths with spaces correctly\n # across different operating systems and build generators\n cmake-cross-platform-spaces:\n name: \"CMake Cross-Platform (Spaces in Path)\"\n runs-on: ${{ matrix.os }}\n strategy:\n matrix:\n include:\n - os: ubuntu-latest\n generator: \"Unix Makefiles\"\n name: \"Linux\"\n - os: windows-latest\n generator: \"NMake Makefiles\"\n name: \"Windows NMake\"\n - os: macos-latest\n generator: \"Unix Makefiles\"\n name: \"macOS\"\n env:\n SRC_DIR: \"source directory with spaces\"\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n with:\n path: \"${{ env.SRC_DIR }}\"\n - uses: ilammy/msvc-dev-cmd@0b201ec74fa43914dc39ae48a89fd1d8cb592756 # v1.13.0\n if: ${{ matrix.generator == 'NMake Makefiles' }}\n - name: \"CMake build and install (${{ matrix.name }})\"\n run: |\n # Test Release build with installation to verify packaging\n cmake -S \"${{ env.SRC_DIR }}/build/cmake\" -B build -DBUILD_TESTING=ON -G \"${{ matrix.generator }}\" -DCMAKE_BUILD_TYPE=Release --install-prefix \"${{ runner.temp }}/install\"\n cmake --build build --config Release\n cmake --install build --config Release\n\n # Windows-specific cmake testing with Visual Studio 2022\n # Tests multiple generators and toolchains to ensure broad Windows compatibility\n # including MSVC (x64, Win32, ARM64), MinGW, and Clang-CL with various architectures and optimizations\n cmake-windows-comprehensive:\n name: \"CMake Windows VS2022 (${{ matrix.name }})\"\n runs-on: ${{ matrix.runner }}\n strategy:\n fail-fast: false\n matrix:\n include:\n - generator: \"Visual Studio 17 2022\"\n flags: \"-A x64\"\n name: \"MSVC x64\"\n runner: \"windows-2022\"\n cmake_extra_flags: \"-DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DZSTD_BUILD_TESTS=ON\"\n - generator: \"Visual Studio 17 2022\"\n flags: \"-A Win32\"\n name: \"MSVC Win32\"\n runner: \"windows-2022\"\n cmake_extra_flags: \"-DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DZSTD_BUILD_TESTS=ON\"\n - generator: \"Visual Studio 17 2022\"\n flags: \"-A x64\"\n name: \"MSVC x64 (No ZSTD_BUILD_TESTS)\"\n runner: \"windows-2022\"\n # Intentionally omit ZSTD_BUILD_TESTS to reproduce the CXX language configuration bug\n cmake_extra_flags: \"-DCMAKE_COMPILE_WARNING_AS_ERROR=ON\"\n - generator: \"Visual Studio 17 2022\"\n flags: \"-A ARM64\"\n name: \"MSVC ARM64\"\n runner: \"windows-11-arm\" # githuh runner for WOA instance\n - generator: \"MinGW Makefiles\"\n flags: \"\"\n name: \"MinGW\"\n runner: \"windows-2022\"\n cmake_extra_flags: \"-DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DZSTD_BUILD_TESTS=ON\"\n - generator: \"Visual Studio 17 2022\"\n flags: \"-T ClangCL\"\n name: \"Clang-CL\"\n runner: \"windows-2022\"\n cmake_extra_flags: \"-DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DZSTD_BUILD_TESTS=ON\"\n - generator: \"Visual Studio 17 2022\"\n flags: \"-T ClangCL -A x64 -DCMAKE_C_FLAGS=/arch:AVX2\"\n name: \"Clang-CL AVX2\"\n runner: \"windows-2022\"\n cmake_extra_flags: \"-DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DZSTD_BUILD_TESTS=ON\"\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: Add MSBuild to PATH\n uses: microsoft/setup-msbuild@6fb02220983dee41ce7ae257b6f4d8f9bf5ed4ce # tag=v2.0.0\n - name: \"Configure CMake (${{ matrix.name }})\"\n run: |\n cd build\\cmake\n mkdir build\n cd build\n cmake.exe -G \"${{matrix.generator}}\" ${{matrix.flags}} -DCMAKE_BUILD_TYPE=Debug ${{ matrix.cmake_extra_flags }} -DZSTD_ZSTREAM_FLAGS=-T${{ env.QUICK_TEST_TIME }} -DZSTD_FUZZER_FLAGS=-T${{ env.QUICK_TEST_TIME }} -DZSTD_FULLBENCH_FLAGS=-i0 ..\n - name: \"Build (${{ matrix.name }})\"\n run: |\n cd build\\cmake\\build\n cmake.exe --build .\n - name: \"Test (${{ matrix.name }})\"\n run: |\n cd build\\cmake\\build\n ctest.exe -V -C Debug\n\n # macOS ARM64 (Apple Silicon) specific cmake testing\n # Validates zstd builds and runs correctly on Apple Silicon architecture\n # Uses native ARM64 hardware for optimal performance and compatibility testing\n cmake-macos-arm64:\n name: \"CMake macOS ARM64 (Apple Silicon)\"\n runs-on: macos-14 # ARM64 runner\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: \"CMake build and test (ARM64)\"\n run: |\n # Configure and build with ARM64-specific optimizations\n cd build/cmake\n mkdir build\n cd build\n cmake -DCMAKE_BUILD_TYPE=Release ${{ env.COMMON_CMAKE_FLAGS }} -DZSTD_ZSTREAM_FLAGS=-T${{ env.QUICK_TEST_TIME }} -DZSTD_FUZZER_FLAGS=-T${{ env.QUICK_TEST_TIME }} -DZSTD_FULLBENCH_FLAGS=-i1 ..\n make -j$(sysctl -n hw.ncpu)\n ctest -V\n" }, { "path": ".github/workflows/commit.yml", "content": "name: facebook/zstd/commit\non:\n push:\n branches:\n - dev\n pull_request:\n branches:\n - dev\n\npermissions: read-all\n\njobs:\n short-tests-0:\n runs-on: ubuntu-latest\n services:\n docker:\n image: fbopensource/zstd-circleci-primary:0.0.1\n options: --entrypoint /bin/bash\n steps:\n - uses: actions/checkout@v6.0.2\n - name: Install Dependencies\n run: |\n sudo apt-get update\n sudo apt-get install libcurl4-gnutls-dev\n - name: Test\n run: |\n ./tests/test-license.py\n cc -v\n CFLAGS=\"-O0 -Werror -pedantic\" make allmost; make clean\n make c99build; make clean\n make c11build; make clean\n make -j regressiontest; make clean\n make check; make clean\n make cxxtest; make clean\n\n short-tests-1:\n runs-on: ubuntu-latest\n services:\n docker:\n image: fbopensource/zstd-circleci-primary:0.0.1\n options: --entrypoint /bin/bash\n steps:\n - uses: actions/checkout@v6.0.2\n - name: Install Dependencies\n run: |\n sudo apt-get update\n sudo apt-get install gcc-powerpc-linux-gnu gcc-arm-linux-gnueabi gcc-aarch64-linux-gnu libc6-dev-ppc64-powerpc-cross libcurl4-gnutls-dev lib64gcc-13-dev-powerpc-cross\n - name: gnu90 build\n run: make gnu90build && make clean\n - name: gnu99 build\n run: make gnu99build && make clean\n - name: ppc64 build\n run: make ppc64build V=1 && make clean\n - name: ppc build\n run: make ppcbuild V=1 && make clean\n - name: arm build\n run: make armbuild V=1 && make clean\n - name: aarch64 build\n run: make aarch64build V=1 && make clean\n - name: test-legacy\n run: make -C tests test-legacy V=1 && make clean\n - name: test-longmatch\n run: make -C tests test-longmatch V=1 && make clean\n - name: libzstd-nomt build\n run: make -C lib libzstd-nomt V=1 && make clean\n\n regression-test:\n runs-on: ubuntu-latest\n services:\n docker:\n image: fbopensource/zstd-circleci-primary:0.0.1\n options: --entrypoint /bin/bash\n env:\n CIRCLE_ARTIFACTS: \"/tmp/circleci-artifacts\"\n steps:\n - uses: actions/checkout@v6.0.2\n - name: restore_cache\n uses: actions/cache@v5\n with:\n key: regression-cache-{{ checksum \"tests/regression/data.c\" }}-v0\n path: tests/regression/cache\n restore-keys: regression-cache-{{ checksum \"tests/regression/data.c\" }}-v0\n - name: Install Dependencies\n run: |\n sudo apt-get update\n sudo apt-get install libcurl4-gnutls-dev\n - name: Regression Test\n run: |\n make -C programs zstd\n make -C tests/regression test\n mkdir -p $CIRCLE_ARTIFACTS\n ./tests/regression/test \\\n --cache tests/regression/cache \\\n --output $CIRCLE_ARTIFACTS/results.csv \\\n --zstd programs/zstd\n echo \"NOTE: The new results.csv is uploaded as an artifact to this job\"\n echo \" If this fails, go to the Artifacts pane in CircleCI, \"\n echo \" download /tmp/circleci-artifacts/results.csv, and if they \"\n echo \" are still good, copy it into the repo and commit it.\"\n echo \"> diff tests/regression/results.csv $CIRCLE_ARTIFACTS/results.csv\"\n diff tests/regression/results.csv $CIRCLE_ARTIFACTS/results.csv\n - uses: actions/upload-artifact@v7.0.0\n with:\n path: \"/tmp/circleci-artifacts\"\n" }, { "path": ".github/workflows/dev-long-tests.yml", "content": "name: dev-long-tests\n# Tests generally longer than 10mn\n\nconcurrency:\n group: long-${{ github.ref }}\n cancel-in-progress: true\n\non:\n pull_request:\n branches: [ dev, release, actionsTest ]\n\npermissions: read-all\n\njobs:\n # lasts ~7mn\n make-all:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: make all\n run: make all\n\n # lasts ~19mn\n make-test:\n runs-on: ubuntu-latest\n env:\n DEVNULLRIGHTS: 1\n READFROMBLOCKDEVICE: 1\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: make test\n run: |\n make test\n make -j zstd\n ./tests/test_process_substitution.bash ./zstd\n\n # lasts ~16mn\n make-test-macos:\n runs-on: macos-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: make test on macos\n run: make test\n\n # lasts ~10mn\n make-test-32bit:\n runs-on: ubuntu-latest\n env:\n DEVNULLRIGHTS: 1\n READFROMBLOCKDEVICE: 1\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: make test # note: `make -j test success` seems to require a clean state\n run: |\n sudo apt-get -qqq update\n make libc6install\n make clean\n CFLAGS=\"-m32 -O2\" make -j test V=1\n\n # lasts ~7mn\n test-largeDictionary:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: largeDictionary\n run: |\n CFLAGS=\"-Werror -O3\" make -j -C tests test-largeDictionary\n\n # lasts ~9mn\n no-intrinsics-fuzztest:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: no intrinsics fuzztest\n run: MOREFLAGS=\"-DZSTD_NO_INTRINSICS\" make -C tests fuzztest\n\n # lasts ~8mn\n tsan-zstreamtest:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: thread sanitizer zstreamtest\n run: CC=clang ZSTREAM_TESTTIME=-T3mn make tsan-test-zstream\n\n uasan-zstreamtest:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: ub + address sanitizer on zstreamtest\n run: CC=clang make uasan-test-zstream\n\n # lasts ~11mn\n tsan-fuzztest:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: thread sanitizer fuzztest\n run: CC=clang make tsan-fuzztest\n\n big-tests-zstreamtest32:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: zstream tests in 32bit mode, with big tests\n run: |\n sudo apt-get -qqq update\n make libc6install\n CC=clang make -C tests test-zstream32 FUZZER_FLAGS=\"--big-tests\"\n\n # lasts ~13mn\n gcc-8-asan-ubsan-testzstd:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: gcc-8 + ASan + UBSan + Test Zstd\n # See https://askubuntu.com/a/1428822\n run: |\n echo \"deb [arch=amd64] http://archive.ubuntu.com/ubuntu focal main universe\" | sudo tee -a /etc/apt/sources.list\n sudo apt-get -qqq update\n make gcc8install\n CC=gcc-8 make -j uasan-test-zstd cross.ini <\n msbuild \"build\\VS2010\\zstd.sln\" /m /verbosity:minimal /property:PlatformToolset=${{matrix.toolset}}\n /t:Clean,Build /p:Platform=${{matrix.platform}} /p:Configuration=${{matrix.configuration}} /warnaserror\n - name: Build ${{matrix.name}}\n working-directory: ${{env.GITHUB_WORKSPACE}}\n # See https://docs.microsoft.com/visualstudio/msbuild/msbuild-command-line-reference\n if: ${{ matrix.arch != '' }}\n run: >\n msbuild \"build\\VS2010\\zstd.sln\" /m /verbosity:minimal /property:PlatformToolset=${{matrix.toolset}}\n /t:Clean,Build /p:Platform=${{matrix.platform}} /p:Configuration=${{matrix.configuration}} /warnaserror\n /p:InstructionSet=${{matrix.arch}}\n\n # This tests that we don't accidentally grow the size too much.\n # If the size grows intentionally, you can raise these numbers.\n # But we do need to think about binary size, since it is a concern.\n libzstd-size:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: libzstd size test\n run: |\n make clean && make -j -C lib libzstd && ./tests/check_size.py lib/libzstd.so 1100000\n make clean && make -j -C lib libzstd ZSTD_LIB_COMPRESSION=0 ZSTD_LIB_DICTBUILDER=0 && ./tests/check_size.py lib/libzstd.so 400000\n make clean && make -j -C lib libzstd ZSTD_LIB_MINIFY=1 && ./tests/check_size.py lib/libzstd.so 300000\n make clean && make -j -C lib libzstd ZSTD_LIB_MINIFY=1 ZSTD_LIB_COMPRESSION=0 ZSTD_LIB_DICTBUILDER=0 && ./tests/check_size.py lib/libzstd.so 80000\n\n minimal-decompressor-macros:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: minimal decompressor macros\n run: |\n make clean && make -j all ZSTD_LIB_MINIFY=1 MOREFLAGS=\"-Werror\"\n make clean && make check ZSTD_LIB_MINIFY=1 MOREFLAGS=\"-Werror\"\n make clean && make -j all MOREFLAGS=\"-Werror -DHUF_FORCE_DECOMPRESS_X1 -DZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT\"\n make clean && make check MOREFLAGS=\"-Werror -DHUF_FORCE_DECOMPRESS_X1 -DZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT\"\n make clean && make -j all MOREFLAGS=\"-Werror -DHUF_FORCE_DECOMPRESS_X2 -DZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG\"\n make clean && make check MOREFLAGS=\"-Werror -DHUF_FORCE_DECOMPRESS_X2 -DZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG\"\n make clean && make -j all MOREFLAGS=\"-Werror -DZSTD_NO_INLINE -DZSTD_STRIP_ERROR_STRINGS\"\n make clean && make check MOREFLAGS=\"-Werror -DZSTD_NO_INLINE -DZSTD_STRIP_ERROR_STRINGS\"\n make clean && make check ZSTD_LIB_EXCLUDE_COMPRESSORS_DFAST_AND_UP=1 MOREFLAGS=\"-Werror\"\n make clean && make check ZSTD_LIB_EXCLUDE_COMPRESSORS_GREEDY_AND_UP=1 MOREFLAGS=\"-Werror\"\n\n dynamic-bmi2:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: dynamic bmi2 tests\n run: |\n make clean && make -j check MOREFLAGS=\"-O0 -Werror -mbmi2\"\n make clean && make -j check MOREFLAGS=\"-O0 -Werror -DDYNAMIC_BMI2=1\"\n make clean && make -j check MOREFLAGS=\"-O0 -Werror -DDYNAMIC_BMI2=1 -mbmi2\"\n make clean && make -j check MOREFLAGS=\"-O0 -Werror -DDYNAMIC_BMI2=0\"\n make clean && make -j check MOREFLAGS=\"-O0 -Werror -DDYNAMIC_BMI2=0 -mbmi2\"\n\n test-variants:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: make all variants & validate\n run: |\n make -j -C programs allVariants MOREFLAGS=-O0\n ./tests/test-variants.sh\n\n qemu-consistency:\n name: QEMU ${{ matrix.name }}\n runs-on: ubuntu-24.04\n strategy:\n fail-fast: false # 'false' means Don't stop matrix workflows even if some matrix failed.\n matrix:\n include: [\n { name: ARM, xcc_pkg: gcc-arm-linux-gnueabi, xcc: arm-linux-gnueabi-gcc, xemu_pkg: qemu-system-arm, xemu: qemu-arm-static },\n { name: ARM64, xcc_pkg: gcc-aarch64-linux-gnu, xcc: aarch64-linux-gnu-gcc, xemu_pkg: qemu-system-aarch64,xemu: qemu-aarch64-static },\n { name: PPC, xcc_pkg: gcc-powerpc-linux-gnu, xcc: powerpc-linux-gnu-gcc, xemu_pkg: qemu-system-ppc, xemu: qemu-ppc-static },\n { name: PPC64LE, xcc_pkg: gcc-powerpc64le-linux-gnu, xcc: powerpc64le-linux-gnu-gcc, xemu_pkg: qemu-system-ppc, xemu: qemu-ppc64le-static },\n { name: S390X, xcc_pkg: gcc-s390x-linux-gnu, xcc: s390x-linux-gnu-gcc, xemu_pkg: qemu-system-s390x, xemu: qemu-s390x-static },\n { name: MIPS, xcc_pkg: gcc-mips-linux-gnu, xcc: mips-linux-gnu-gcc, xemu_pkg: qemu-system-mips, xemu: qemu-mips-static },\n { name: RISC-V, xcc_pkg: gcc-14-riscv64-linux-gnu, xcc: riscv64-linux-gnu-gcc-14, xemu_pkg: qemu-system-riscv64,xemu: qemu-riscv64-static },\n { name: M68K, xcc_pkg: gcc-m68k-linux-gnu, xcc: m68k-linux-gnu-gcc, xemu_pkg: qemu-system-m68k, xemu: qemu-m68k-static },\n { name: SPARC, xcc_pkg: gcc-sparc64-linux-gnu, xcc: sparc64-linux-gnu-gcc, xemu_pkg: qemu-system-sparc, xemu: qemu-sparc64-static },\n ]\n env: # Set environment variables\n XCC: ${{ matrix.xcc }}\n XEMU: ${{ matrix.xemu }}\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: apt update & install\n run: |\n sudo apt-get update\n sudo apt-get install gcc-multilib g++-multilib qemu-utils qemu-user-static\n sudo apt-get install ${{ matrix.xcc_pkg }} ${{ matrix.xemu_pkg }}\n - name: Environment info\n run: |\n echo && which $XCC\n echo && $XCC --version\n echo && $XCC -v # Show built-in specs\n echo && which $XEMU\n echo && $XEMU --version\n - name: ARM\n if: ${{ matrix.name == 'ARM' }}\n run: |\n LDFLAGS=\"-static\" CC=$XCC QEMU_SYS=$XEMU make clean check\n - name: ARM64\n if: ${{ matrix.name == 'ARM64' }}\n run: |\n make clean\n LDFLAGS=\"-static\" CC=$XCC QEMU_SYS=$XEMU make -j check\n LDFLAGS=\"-static\" CC=$XCC QEMU_SYS=$XEMU make -j -C tests test-cli-tests\n CFLAGS=\"-O3 -march=armv8.2-a+sve2\" LDFLAGS=\"-static\" CC=$XCC QEMU_SYS=$XEMU make -j check\n CFLAGS=\"-O3 -march=armv8.2-a+sve2\" LDFLAGS=\"-static\" CC=$XCC QEMU_SYS=$XEMU make -j -C tests test-cli-tests\n# This test is only compatible with standard libraries that support BTI (Branch Target Identification).\n# Unfortunately, the standard library provided on Ubuntu 24.04 does not have this feature enabled.\n# make clean\n# LDFLAGS=\"-static -z force-bti\" MOREFLAGS=\"-mbranch-protection=standard\" CC=$XCC QEMU_SYS=$XEMU make check V=1\n - name: PPC\n if: ${{ matrix.name == 'PPC' }}\n run: |\n LDFLAGS=\"-static\" CC=$XCC QEMU_SYS=$XEMU make clean check\n - name: PPC64LE\n if: ${{ matrix.name == 'PPC64LE' }}\n run: |\n LDFLAGS=\"-static\" CC=$XCC QEMU_SYS=$XEMU make clean check\n - name: S390X\n if: ${{ matrix.name == 'S390X' }}\n run: |\n LDFLAGS=\"-static\" CC=$XCC QEMU_SYS=$XEMU make clean check\n - name: MIPS\n if: ${{ matrix.name == 'MIPS' }}\n run: |\n LDFLAGS=\"-static\" CC=$XCC QEMU_SYS=$XEMU make clean check\n - name: RISC-V\n if: ${{ matrix.name == 'RISC-V' }}\n run: |\n LDFLAGS=\"-static\" CC=$XCC QEMU_SYS=$XEMU make clean check\n CFLAGS=\"-march=rv64gcv -O3\" LDFLAGS=\"-static -DMEM_FORCE_MEMORY_ACCESS=0\" CC=$XCC QEMU_SYS=\"$XEMU -cpu rv64,v=true,vlen=128\" make clean check\n CFLAGS=\"-march=rv64gcv -O3\" LDFLAGS=\"-static -DMEM_FORCE_MEMORY_ACCESS=0\" CC=$XCC QEMU_SYS=\"$XEMU -cpu rv64,v=true,vlen=256\" make clean check\n CFLAGS=\"-march=rv64gcv -O3\" LDFLAGS=\"-static -DMEM_FORCE_MEMORY_ACCESS=0\" CC=$XCC QEMU_SYS=\"$XEMU -cpu rv64,v=true,vlen=512\" make clean check\n - name: M68K\n if: ${{ matrix.name == 'M68K' }}\n run: |\n LDFLAGS=\"-static\" CC=$XCC QEMU_SYS=$XEMU make clean check\n - name: SPARC\n if: ${{ matrix.name == 'SPARC' }}\n run: |\n LDFLAGS=\"-static\" CC=$XCC QEMU_SYS=$XEMU make clean check\n\n mingw-short-test:\n runs-on: windows-latest\n strategy:\n fail-fast: false # 'false' means Don't stop matrix workflows even if some matrix failed.\n matrix:\n include: [\n { compiler: gcc, msystem: MINGW32, cflags: \"-Werror\"},\n { compiler: gcc, msystem: MINGW64, cflags: \"-Werror\"},\n { compiler: clang, msystem: MINGW64, cflags: \"--target=x86_64-w64-mingw32 -Werror -Wconversion -Wno-sign-conversion -Wno-unused-command-line-argument\"},\n ]\n defaults:\n run:\n shell: msys2 {0}\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - uses: msys2/setup-msys2@4f806de0a5a7294ffabaff804b38a9b435a73bda # tag=v2.30.0\n with:\n msystem: ${{ matrix.msystem }}\n install: make diffutils\n update: true\n # Based on https://ariya.io/2020/07/on-github-actions-with-msys2\n - name: install mingw gcc i686\n if: ${{ (matrix.msystem == 'MINGW32') && (matrix.compiler == 'gcc') }}\n run: pacman --noconfirm -S mingw-w64-i686-gcc\n - name: install mingw gcc x86_64\n if: ${{ (matrix.msystem == 'MINGW64') && (matrix.compiler == 'gcc') }}\n run: pacman --noconfirm -S mingw-w64-x86_64-gcc\n - name: install mingw clang i686\n if: ${{ (matrix.msystem == 'MINGW32') && (matrix.compiler == 'clang') }}\n run: pacman --noconfirm -S mingw-w64-i686-clang\n - name: install mingw clang x86_64\n if: ${{ (matrix.msystem == 'MINGW64') && (matrix.compiler == 'clang') }}\n run: pacman --noconfirm -S mingw-w64-x86_64-clang\n - name: run mingw tests\n run: |\n make -v\n export CC=${{ matrix.compiler }}\n $CC --version\n CFLAGS=\"${{ matrix.cflags }}\" make -j allzstd\n echo \"Testing $CC ${{ matrix.msystem }}\"\n make clean\n MSYS=\"\" make check\n\n visual-runtime-tests:\n runs-on: windows-latest\n strategy:\n matrix:\n platform: [x64, Win32]\n configuration: [Release]\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: Add MSBuild to PATH\n uses: microsoft/setup-msbuild@6fb02220983dee41ce7ae257b6f4d8f9bf5ed4ce # tag=v2.0.0\n - name: Build and run tests\n working-directory: ${{env.GITHUB_WORKSPACE}}\n env:\n ZSTD_BIN: ./zstd.exe\n DATAGEN_BIN: ./datagen.exe\n # See https://docs.microsoft.com/visualstudio/msbuild/msbuild-command-line-reference\n run: |\n msbuild \"build\\VS2010\\zstd.sln\" /m /verbosity:minimal /property:PlatformToolset=v142 /t:Clean,Build /p:Platform=${{matrix.platform}} /p:Configuration=${{matrix.configuration}}\n COPY build\\VS2010\\bin\\${{matrix.platform}}_${{matrix.configuration}}\\*.exe tests\\\n CD tests\n sh -e playTests.sh\n .\\fuzzer.exe -T2m\n\n # Following instructions at: https://github.com/marketplace/actions/install-cygwin-action\n cygwin-tests:\n runs-on: windows-latest\n steps:\n - run: git config --global core.autocrlf input\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - uses: cygwin/cygwin-install-action@711d29f3da23c9f4a1798e369a6f01198c13b11a # tag=v6\n with:\n platform: x86_64\n packages: >-\n autoconf,\n automake,\n gcc-g++,\n make,\n mingw64-x86_64-gcc-g++,\n patch,\n perl\n - name: cygwin tests\n shell: C:\\cygwin\\bin\\bash.exe --noprofile --norc -eo pipefail '{0}'\n run: >-\n export PATH=/usr/bin:$(cygpath ${SYSTEMROOT})/system32 &&\n export CFLAGS=\"-Werror -O1\" &&\n ls &&\n make -j allzstd &&\n make -C tests fuzzer &&\n ./tests/fuzzer.exe -v -T1m\n - name: cygwin install test\n shell: C:\\cygwin\\bin\\bash.exe --noprofile --norc -eo pipefail '{0}'\n run: >-\n make -j &&\n make install\n\n pkg-config:\n runs-on: ubuntu-latest\n container:\n image: debian:testing\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: Install dependencies\n run: |\n apt -y update\n apt -y install --no-install-recommends gcc libc6-dev make pkg-config\n - name: Build and install\n run: make -C lib install\n - name: Test pkg-config\n run: |\n cc -Wall -Wextra -Wpedantic -Werror -o simple examples/simple_compression.c $(pkg-config --cflags --libs libzstd)\n ./simple LICENSE\n\n versions-compatibility:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: Versions Compatibility Test\n run: |\n make -C tests versionsTest\n\n clangbuild:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: make clangbuild\n run: |\n make clangbuild\n\n gcc-pgo:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: Build PGO Zstd with GCC\n env:\n CC: gcc\n run: |\n make -C programs zstd-pgo\n ./programs/zstd -b\n\n clang-pgo:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: Build PGO Zstd with Clang\n env:\n CC: clang\n run: |\n sudo apt install -y llvm\n llvm-profdata --version\n make -C programs zstd-pgo\n ./programs/zstd -b\n\n musl-build:\n runs-on: ubuntu-22.04\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: Install musl-tools\n run: |\n sudo apt install -y musl-tools\n - name: Compile with musl-gcc and test-zstd\n run: |\n CC=musl-gcc CFLAGS=\"-Werror -O3\" CPPFLAGS=-DZDICT_QSORT=ZDICT_QSORT_C90 make -j -C tests test-zstd V=1\n\n intel-cet-compatibility:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: Build Zstd\n run: |\n make -j zstd V=1\n readelf -n zstd\n - name: Get Intel SDE\n run: |\n curl -LO https://downloadmirror.intel.com/813591/sde-external-9.33.0-2024-01-07-lin.tar.xz\n tar xJvf sde-external-9.33.0-2024-01-07-lin.tar.xz\n - name: Configure Permissions\n run: |\n echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope\n - name: Run Under SDE\n run: |\n sde-external-9.33.0-2024-01-07-lin/sde -cet -cet-raise 0 -cet-endbr-exe -cet-stderr -cet-abort -- ./zstd -b3\n\n icx:\n # install instructions: https://www.intel.com/content/www/us/en/docs/oneapi/installation-guide-linux/2025-0/apt-005.html\n name: icx-check\n runs-on: ubuntu-latest\n steps:\n - name: install icx\n run: |\n # download the key to system keyring\n wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB \\\n | gpg --dearmor | sudo tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null\n\n # add signed entry to apt sources and configure the APT client to use Intel repository:\n echo \"deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main\" | sudo tee /etc/apt/sources.list.d/oneAPI.list\n sudo apt-get update\n sudo apt-get install -y intel-basekit intel-hpckit\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n - name: make check\n run: |\n source /opt/intel/oneapi/setvars.sh\n make CC=icx check\n make CC=icx -C tests test-cli-tests\n" }, { "path": ".github/workflows/nightly.yml", "content": "name: facebook/zstd/nightly\non:\n schedule:\n - cron: '0 0 * * *'\n push:\n branches:\n - release\n - dev\n - '*nightly*'\npermissions: read-all\njobs:\n regression-test:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v6.0.2\n - name: Install dependencies\n run: sudo apt-get update && sudo apt-get install -y libcurl4-openssl-dev\n - name: Regression Test\n run: |\n make -C programs zstd\n make -C tests/regression test\n\n# Longer tests\n #- make -C tests test-zstd-nolegacy && make clean\n #- pyenv global 3.4.4; make -C tests versionsTest && make clean\n #- make zlibwrapper && make clean\n #- gcc -v; make -C tests test32 MOREFLAGS=\"-I/usr/include/x86_64-linux-gnu\" && make clean\n #- make uasan && make clean\n #- make asan32 && make clean\n #- make -C tests test32 CC=clang MOREFLAGS=\"-g -fsanitize=address -I/usr/include/x86_64-linux-gnu\"\n# Valgrind tests\n #- CFLAGS=\"-O1 -g\" make -C zlibWrapper valgrindTest && make clean\n #- make -C tests valgrindTest && make clean\n# ARM, AArch64, PowerPC, PowerPC64 tests\n #- make ppctest && make clean\n #- make ppc64test && make clean\n #- make armtest && make clean\n #- make aarch64test && make clean\n" }, { "path": ".github/workflows/publish-release-artifacts.yml", "content": "name: publish-release-artifacts\n\non:\n release:\n types:\n - published\n\npermissions: read-all\n\njobs:\n publish-release-artifacts:\n permissions:\n contents: write # to fetch code and upload artifacts\n\n runs-on: ubuntu-latest\n if: startsWith(github.ref, 'refs/tags/')\n\n steps:\n - name: Checkout\n uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n\n - name: Archive\n env:\n RELEASE_SIGNING_KEY: ${{ secrets.RELEASE_SIGNING_KEY }}\n RELEASE_SIGNING_KEY_PASSPHRASE: ${{ secrets.RELEASE_SIGNING_KEY_PASSPHRASE }}\n run: |\n # compute file name\n export TAG=\"$(echo \"$GITHUB_REF\" | sed -n 's_^refs/tags/__p')\"\n if [ -z \"$TAG\" ]; then\n echo \"action must be run on a tag. GITHUB_REF is not a tag: $GITHUB_REF\"\n exit 1\n fi\n # Attempt to extract \"1.2.3\" from \"v1.2.3\" to maintain artifact name backwards compat.\n # Otherwise, degrade to using full tag.\n export VERSION=\"$(echo \"$TAG\" | sed 's_^v\\([0-9]\\+\\.[0-9]\\+\\.[0-9]\\+\\)$_\\1_')\"\n export ZSTD_VERSION=\"zstd-$VERSION\"\n\n # archive\n git archive $TAG \\\n --prefix $ZSTD_VERSION/ \\\n --format tar \\\n -o $ZSTD_VERSION.tar\n\n # Do the rest of the work in a sub-dir so we can glob everything we want to publish.\n mkdir artifacts/\n mv $ZSTD_VERSION.tar artifacts/\n cd artifacts/\n\n # compress\n zstd -k -19 $ZSTD_VERSION.tar\n gzip -k -9 $ZSTD_VERSION.tar\n\n # we only publish the compressed tarballs\n rm $ZSTD_VERSION.tar\n\n # hash\n sha256sum $ZSTD_VERSION.tar.zst > $ZSTD_VERSION.tar.zst.sha256\n sha256sum $ZSTD_VERSION.tar.gz > $ZSTD_VERSION.tar.gz.sha256\n\n # sign\n if [ -n \"$RELEASE_SIGNING_KEY\" ]; then\n export GPG_BATCH_OPTS=\"--batch --no-use-agent --pinentry-mode loopback --no-tty --yes\"\n echo \"$RELEASE_SIGNING_KEY\" | gpg $GPG_BATCH_OPTS --import\n gpg $GPG_BATCH_OPTS --armor --sign --sign-with signing@zstd.net --detach-sig --passphrase \"$RELEASE_SIGNING_KEY_PASSPHRASE\" --output $ZSTD_VERSION.tar.zst.sig $ZSTD_VERSION.tar.zst\n gpg $GPG_BATCH_OPTS --armor --sign --sign-with signing@zstd.net --detach-sig --passphrase \"$RELEASE_SIGNING_KEY_PASSPHRASE\" --output $ZSTD_VERSION.tar.gz.sig $ZSTD_VERSION.tar.gz\n fi\n\n - name: Publish\n uses: skx/github-action-publish-binaries@b9ca5643b2f1d7371a6cba7f35333f1461bbc703 # tag=release-2.0\n env:\n GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n with:\n args: artifacts/*\n" }, { "path": ".github/workflows/release_check.yml", "content": "name: release_checks\n\non:\n push:\n branches:\n - release\n pull_request:\n branches:\n - release\n\npermissions: read-all\n\njobs:\n verify-manual:\n runs-on: ubuntu-latest\n steps:\n - name: Check out repository\n uses: actions/checkout@v6.0.2\n\n - name: Save current manual\n run: mv doc/zstd_manual.html doc/zstd_manual_saved.html\n\n - name: Generate new manual\n run: make manual\n\n - name: Compare manuals\n run: |\n if ! cmp -s doc/zstd_manual.html doc/zstd_manual_saved.html; then\n echo \"The API manual was not updated before release !\"\n exit 1\n fi\n\n verify-man-pages:\n runs-on: ubuntu-latest\n steps:\n - name: Check out repository\n uses: actions/checkout@v6.0.2\n\n - name: Install dependencies\n run: |\n sudo apt-get update\n sudo apt-get install -y ruby ruby-dev\n sudo gem install ronn\n\n - name: Display ronn version\n run: ronn --version\n\n - name: Save current man pages\n run: |\n mv programs/zstd.1 programs/zstd.1.saved\n mv programs/zstdgrep.1 programs/zstdgrep.1.saved\n mv programs/zstdless.1 programs/zstdless.1.saved\n\n - name: Generate new manual pages\n run: make -C programs man\n\n - name: Compare man pages\n run: |\n for file in zstd.1 zstdgrep.1 zstdless.1; do\n if ! cmp -s programs/$file programs/$file.saved; then\n echo \"The man page $file should have been updated.\"\n exit 1\n fi\n done\n" }, { "path": ".github/workflows/scorecards.yml", "content": "name: Scorecards supply-chain security\non:\n # Only the default branch is supported.\n branch_protection_rule:\n schedule:\n - cron: '22 21 * * 2'\n push:\n # TODO: Add release branch when supported?\n branches: [ \"dev\" ]\n\n# Declare default permissions as read only.\npermissions: read-all\n\njobs:\n analysis:\n name: Scorecards analysis\n if: github.repository == 'facebook/zstd'\n runs-on: ubuntu-latest\n permissions:\n # Needed to upload the results to code-scanning dashboard.\n security-events: write\n # Used to receive a badge.\n id-token: write\n # Needs for private repositories.\n contents: read\n actions: read\n\n steps:\n - name: \"Checkout code\"\n uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n with:\n persist-credentials: false\n\n - name: \"Run analysis\"\n uses: ossf/scorecard-action@f49aabe0b5af0936a0987cfb85d86b75731b0186 # tag=v2.4.1\n with:\n results_file: results.sarif\n results_format: sarif\n # (Optional) Read-only PAT token. Uncomment the `repo_token` line below if:\n # - you want to enable the Branch-Protection check on a *public* repository, or\n # - you are installing Scorecards on a *private* repository\n # To create the PAT, follow the steps in https://github.com/ossf/scorecard-action#authentication-with-pat.\n # repo_token: ${{ secrets.SCORECARD_READ_TOKEN }}\n\n # Publish the results for public repositories to enable scorecard badges. For more details, see\n # https://github.com/ossf/scorecard-action#publishing-results.\n # For private repositories, `publish_results` will automatically be set to `false`, regardless\n # of the value entered here.\n publish_results: true\n\n # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF\n # format to the repository Actions tab.\n - name: \"Upload artifact\"\n uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # tag=v7.0.0\n with:\n name: SARIF file\n path: results.sarif\n retention-days: 5\n\n # Upload the results to GitHub's code scanning dashboard.\n - name: \"Upload to code-scanning\"\n uses: github/codeql-action/upload-sarif@0499de31b99561a6d14a36a5f662c2a54f91beee # tag=v4.31.2\n with:\n sarif_file: results.sarif\n" }, { "path": ".github/workflows/windows-artifacts.yml", "content": "name: windows-artifacts\n\non:\n push:\n branches: [ test_artifacts, win_artifacts, release ]\n release:\n types:\n - published\n\npermissions: read-all\n\njobs:\n windows-artifacts:\n permissions:\n contents: write # to fetch code and upload artifacts\n # For msys2, see https://ariya.io/2020/07/on-github-actions-with-msys2\n runs-on: ${{ matrix.shell == 'cmake' && 'windows-11-arm' || 'windows-latest' }}\n strategy:\n # For msys2, see https://github.com/msys2/setup-msys2\n matrix:\n include:\n - { msystem: mingw64, env: x86_64, ziparch: win64, shell: msys2 }\n - { msystem: mingw32, env: i686, ziparch: win32, shell: msys2 }\n - { msystem: null, env: arm64, ziparch: win-arm64, shell: cmake }\n\n defaults:\n run:\n shell: ${{ matrix.shell == 'cmake' && 'pwsh' || 'msys2 {0}' }}\n\n steps:\n - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # tag=v6.0.2\n\n # MSYS2 setup\n - uses: msys2/setup-msys2@4f806de0a5a7294ffabaff804b38a9b435a73bda # tag=v2.30.0\n if: matrix.shell == 'msys2'\n with:\n msystem: ${{ matrix.msystem }}\n install: make p7zip git mingw-w64-${{matrix.env}}-gcc\n update: true\n\n - name: display versions (MSYS2)\n if: matrix.shell == 'msys2'\n run: |\n make -v\n cc -v\n\n - name: display versions (CMake)\n if: matrix.shell == 'cmake'\n run: |\n cmake --version\n\n # Build dependencies (MSYS2 only)\n - name: Building zlib to static link\n if: matrix.shell == 'msys2'\n run: |\n git clone --depth 1 --branch v1.3.1 https://github.com/madler/zlib\n make -C zlib -f win32/Makefile.gcc libz.a\n\n - name: Building lz4 to static link\n if: matrix.shell == 'msys2'\n run: |\n git clone --depth 1 --branch v1.10.0 https://github.com/lz4/lz4\n # ensure both libraries use the same version of libxxhash\n cp lib/common/xxhash.* lz4/lib\n CPPFLAGS=-DXXH_NAMESPACE=LZ4_ make -C lz4/lib liblz4.a V=1\n\n # Build zstd\n - name: Building zstd programs\n if: matrix.shell == 'msys2'\n run: |\n CPPFLAGS=\"-I../zlib -I../lz4/lib\" LDFLAGS=-static make -j allzstd V=1 HAVE_ZLIB=1 HAVE_LZ4=1 HAVE_LZMA=0 LDLIBS=\"../zlib/libz.a ../lz4/lib/liblz4.a\"\n\n - name: Build zstd (CMake ARM64)\n if: matrix.shell == 'cmake'\n run: |\n cd build\\cmake\n mkdir build\n cd build\n cmake.exe -G \"Visual Studio 17 2022\" -A ARM64 -DCMAKE_BUILD_TYPE=Release -DZSTD_BUILD_PROGRAMS=ON -DZSTD_BUILD_SHARED=ON -DZSTD_BUILD_STATIC=ON ..\n cmake.exe --build . --config Release --parallel\n\n - name: Create artifacts (MSYS2)\n if: matrix.shell == 'msys2'\n run: |\n ./lib/dll/example/build_package.bat || exit 1\n mv bin/ zstd-${{ github.ref_name }}-${{matrix.ziparch}}/\n\n - name: Create artifacts (CMake)\n if: matrix.shell == 'cmake'\n run: |\n .\\lib\\dll\\example\\build_package.bat\n if ($LASTEXITCODE -ne 0) { exit 1 }\n mv bin/ zstd-${{ github.ref_name }}-${{matrix.ziparch}}/\n\n - name: Publish zstd-$VERSION-${{matrix.ziparch}}.zip for manual inspection\n uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # tag=v7.0.0\n with:\n compression-level: 9 # maximum compression\n if-no-files-found: error # defaults to `warn`\n path: ${{ github.workspace }}/zstd-${{ github.ref_name }}-${{matrix.ziparch}}/\n name: zstd-${{ github.ref_name }}-${{matrix.ziparch}}\n\n - name: Package artifact for upload (MSYS2)\n if: matrix.shell == 'msys2'\n run: |\n 7z a -tzip -mx9 \"$(cygpath -u '${{ github.workspace }}/zstd-${{ github.ref_name }}-${{ matrix.ziparch }}.zip')\" \"$(cygpath -u '${{ github.workspace }}/zstd-${{ github.ref_name }}-${{ matrix.ziparch }}')\"\n\n - name: Package artifact for upload (CMake)\n if: matrix.shell == 'cmake'\n run: |\n Compress-Archive -Path \"zstd-${{ github.ref_name }}-${{ matrix.ziparch }}\" -DestinationPath \"zstd-${{ github.ref_name }}-${{ matrix.ziparch }}.zip\" -CompressionLevel Optimal\n\n - name: Upload release asset\n if: github.event_name == 'release'\n shell: pwsh\n env:\n GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n run: |\n gh release upload \"${{ github.ref_name }}\" \"$env:GITHUB_WORKSPACE/zstd-${{ github.ref_name }}-${{ matrix.ziparch }}.zip\" --clobber" }, { "path": ".gitignore", "content": "# Object files\n*.o\n*.ko\n*.dSYM\n\n# Libraries\n*.lib\n*.a\n\n# Shared objects (inc. Windows DLLs)\n*.dll\n*.so\n*.so.*\n*.dylib\n*.framework\n*.xcframework\n\n# Executables\n/zstd\nzstdmt\n*.exe\n*.out\n*.app\n\n# Build artefacts\ncontrib/linux-kernel/linux/\nprojects/\nbin/\n.buckd/\nbuck-out/\nbuild-*\n*.gcda\ncmakebuild/\ncmake-build/\n\n# Test artefacts\ntmp*\n*.zst\n*.zstd\ndictionary.\ndictionary\nNUL\ninstall/\n\n# IDE\n.clang_complete\ncompile_flags.txt\n.clang-format\n\n# Other files\n.directory\n_codelite/\n_zstdbench/\n*.idea\n*.swp\n.DS_Store\ngoogletest/\n*.d\n*.vscode\n*.code-workspace\ncompile_commands.json\n.clangd\nperf.data\nperf.data.old\n" }, { "path": "CHANGELOG", "content": "v1.6.0 (Dec 2025)\napi: legacy format support is now disabled by default\nbuild: `ZSTD_LEGACY_SUPPORT` defaults to `0` in Makefile and CMake\n\nV1.5.7 (Feb 2025)\nfix: compression bug in 32-bit mode associated with long-lasting sessions\napi: new method `ZSTD_compressSequencesAndLiterals()` (#4217, #4232)\napi: `ZSTD_getFrameHeader()` works on skippable frames (#4228)\nperf: substantial compression speed improvements (up to +30%) on small data, by @TocarIP (#4144) and @cyan4973 (#4165)\nperf: improved compression speed (~+5%) for dictionary compression at low levels (#4170)\nperf: much faster speed for `--patch-from` at high compression levels (#4276)\nperf: higher `--patch-from` compression ratios, notably at high levels (#4288)\nperf: better speed for binaries on Windows (@pps83) and when compiled with Visual Studio (@MessyHack)\nperf: slight compression ratio improvement thanks to better block boundaries (#4136, #4176, #4178)\nperf: slight compression ratio improvement for `dfast`, aka levels 3 and 4 (#4171)\nperf: runtime bmi2 detection enabled on x86 32-bit mode (#4251)\ncli: multi-threading as default CLI setting, by @daniellerozenblit\ncli: new `--max` command (#4290)\nbuild: improve `msbuild` version autodetection, support VS2022, by @ManuelBlanc\nbuild: fix `meson` build by @artem and @Victor-C-Zhang, and on Windows by @bgilbert\nbuild: compatibility with Apple Framework, by @Treata11\nbuild: improve icc/icx compatibility, by @josepho0918 and @luau-project\nbuild: improve compatibility with Android NDK, by Adenilson Cavalcanti\nportability: linux kernel branch, with improved support for Sequence producers (@embg, @gcabiddu, @cyan4973)\nportability: improved qnx compatibility, suggested by @rainbowball\nportability: improved install script for FreeBSD, by @sunpoet\nportability: fixed test suite compatibility with gnu hurd, by @diegonc\ndoc: clarify specification, by @elasota\nmisc: improved tests/decodecorpus validation tool (#4102), by antmicro\n\nV1.5.6 (Mar 2024)\napi: Promote `ZSTD_c_targetCBlockSize` to Stable API by @felixhandte\napi: new `ZSTD_d_maxBlockSize` experimental parameter, to reduce streaming decompression memory, by @terrelln\nperf: improve performance of param `ZSTD_c_targetCBlockSize`, by @Cyan4973\nperf: improved compression of arrays of integers at high compression, by @Cyan4973\nlib: reduce binary size with selective build-time exclusion, by @felixhandte\nlib: improved huffman speed on small data and linux kernel, by @terrelln\nlib: accept dictionaries with partial literal tables, by @terrelln\nlib: fix CCtx size estimation with external sequence producer, by @embg\nlib: fix corner case decoder behaviors, by @Cyan4973 and @aimuz\nlib: fix zdict prototype mismatch in static_only mode, by @ldv-alt\nlib: fix several bugs in magicless-format decoding, by @embg\ncli: add common compressed file types to `--exclude-compressed`` by @daniellerozenblit\ncli: fix mixing `-c` and `-o` commands with `--rm`, by @Cyan4973\ncli: fix erroneous exclusion of hidden files with `--output-dir-mirror` by @felixhandte\ncli: improved time accuracy on BSD, by @felixhandte\ncli: better errors on argument parsing, by @KapJI\ntests: better compatibility with older versions of `grep`, by @Cyan4973\ntests: lorem ipsum generator as default backup content, by @Cyan4973\nbuild: cmake improvements by @terrelln, @sighingnow, @gjasny, @JohanMabille, @Saverio976, @gruenich, @teo-tsirpanis\nbuild: bazel support, by @jondo2010\nbuild: fix cross-compiling for AArch64 with lld by @jcelerier\nbuild: fix Apple platform compatibility, by @nidhijaju\nbuild: fix Visual 2012 and lower compatibility, by @Cyan4973\nbuild: improve win32 support, by @DimitriPapadopoulos\nbuild: better C90 compliance for zlibWrapper, by @emaste\nport: make: fat binaries on macos, by @mredig\nport: ARM64EC compatibility for Windows, by @dunhor\nport: QNX support by @klausholstjacobsen\nport: MSYS2 and Cygwin makefile installation and test support, by @QBos07\nport: risc-v support validation in CI, by @Cyan4973\nport: sparc64 support validation in CI, by @Cyan4973\nport: AIX compatibility, by @likema\nport: HP-UX compatibility, by @likema\ndoc: Improved specification accuracy, by @elasota\nbug: Fix and deprecate ZSTD_generateSequences (#3981)\n\nv1.5.5 (Apr 2023)\nfix: fix rare corruption bug affecting the high compression mode, reported by @danlark1 (#3517, @terrelln)\nperf: improve mid-level compression speed (#3529, #3533, #3543, @yoniko and #3552, @terrelln)\nlib: deprecated bufferless block-level API (#3534) by @terrelln\ncli: mmap large dictionaries to save memory, by @daniellerozenblit\ncli: improve speed of --patch-from mode (~+50%) (#3545) by @daniellerozenblit\ncli: improve i/o speed (~+10%) when processing lots of small files (#3479) by @felixhandte\ncli: zstd no longer crashes when requested to write into write-protected directory (#3541) by @felixhandte\ncli: fix decompression into block device using -o, reported by @georgmu (#3583)\nbuild: fix zstd CLI compiled with lzma support but not zlib support (#3494) by @Hello71\nbuild: fix cmake does no longer require 3.18 as minimum version (#3510) by @kou\nbuild: fix MSVC+ClangCL linking issue (#3569) by @tru\nbuild: fix zstd-dll, version of zstd CLI that links to the dynamic library (#3496) by @yoniko\nbuild: fix MSVC warnings (#3495) by @embg\ndoc: updated zstd specification to clarify corner cases, by @Cyan4973\ndoc: document how to create fat binaries for macos (#3568) by @rickmark\nmisc: improve seekable format ingestion speed (~+100%) for very small chunk sizes (#3544) by @Cyan4973\nmisc: tests/fullbench can benchmark multiple files (#3516) by @dloidolt\n\nv1.5.4 (Feb 2023)\nperf: +20% faster huffman decompression for targets that can't compile x64 assembly (#3449, @terrelln)\nperf: up to +10% faster streaming compression at levels 1-2 (#3114, @embg)\nperf: +4-13% for levels 5-12 by optimizing function generation (#3295, @terrelln)\npref: +3-11% compression speed for `arm` target (#3199, #3164, #3145, #3141, #3138, @JunHe77 and #3139, #3160, @danlark1)\nperf: +5-30% faster dictionary compression at levels 1-4 (#3086, #3114, #3152, @embg)\nperf: +10-20% cold dict compression speed by prefetching CDict tables (#3177, @embg)\nperf: +1% faster compression by removing a branch in ZSTD_fast_noDict (#3129, @felixhandte)\nperf: Small compression ratio improvements in high compression mode (#2983, #3391, @Cyan4973 and #3285, #3302, @daniellerozenblit)\nperf: small speed improvement by better detecting `STATIC_BMI2` for `clang` (#3080, @TocarIP)\nperf: Improved streaming performance when `ZSTD_c_stableInBuffer` is set (#2974, @Cyan4973)\ncli: Asynchronous I/O for improved cli speed (#2975, #2985, #3021, #3022, @yoniko)\ncli: Change `zstdless` behavior to align with `zless` (#2909, @binhdvo)\ncli: Keep original file if `-c` or `--stdout` is given (#3052, @dirkmueller)\ncli: Keep original files when result is concatenated into a single output with `-o` (#3450, @Cyan4973)\ncli: Preserve Permissions and Ownership of regular files (#3432, @felixhandte)\ncli: Print zlib/lz4/lzma library versions with `-vv` (#3030, @terrelln)\ncli: Print checksum value for single frame files with `-lv` (#3332, @Cyan4973)\ncli: Print `dictID` when present with `-lv` (#3184, @htnhan)\ncli: when `stderr` is *not* the console, disable status updates, but preserve final summary (#3458, @Cyan4973)\ncli: support `--best` and `--no-name` in `gzip` compatibility mode (#3059, @dirkmueller)\ncli: support for `posix` high resolution timer `clock_gettime()`, for improved benchmark accuracy (#3423, @Cyan4973)\ncli: improved help/usage (`-h`, `-H`) formatting (#3094, @dirkmueller and #3385, @jonpalmisc)\ncli: Fix better handling of bogus numeric values (#3268, @ctkhanhly)\ncli: Fix input consists of multiple files _and_ `stdin` (#3222, @yoniko)\ncli: Fix tiny files passthrough (#3215, @cgbur)\ncli: Fix for `-r` on empty directory (#3027, @brailovich)\ncli: Fix empty string as argument for `--output-dir-*` (#3220, @embg)\ncli: Fix decompression memory usage reported by `-vv --long` (#3042, @u1f35c, and #3232, @zengyijing)\ncli: Fix infinite loop when empty input is passed to trainer (#3081, @terrelln)\ncli: Fix `--adapt` doesn't work when `--no-progress` is also set (#3354, @terrelln)\napi: Support for Block-Level Sequence Producer (#3333, @embg)\napi: Support for in-place decompression (#3432, @terrelln)\napi: New `ZSTD_CCtx_setCParams()` function, set all parameters defined in a `ZSTD_compressionParameters` structure (#3403, @Cyan4973)\napi: Streaming decompression detects incorrect header ID sooner (#3175, @Cyan4973)\napi: Window size resizing optimization for edge case (#3345, @daniellerozenblit)\napi: More accurate error codes for busy-loop scenarios (#3413, #3455, @Cyan4973)\napi: Fix limit overflow in `compressBound` and `decompressBound` (#3362, #3373, Cyan4973) reported by @nigeltao\napi: Deprecate several advanced experimental functions: streaming (#3408, @embg), copy (#3196, @mileshu)\nbug: Fix corruption that rarely occurs in 32-bit mode with wlog=25 (#3361, @terrelln)\nbug: Fix for block-splitter (#3033, @Cyan4973)\nbug: Fixes for Sequence Compression API (#3023, #3040, @Cyan4973)\nbug: Fix leaking thread handles on Windows (#3147, @animalize)\nbug: Fix timing issues with cmake/meson builds (#3166, #3167, #3170, @Cyan4973)\nbuild: Allow user to select legacy level for cmake (#3050, @shadchin)\nbuild: Enable legacy support by default in cmake (#3079, @niamster)\nbuild: Meson build script improvements (#3039, #3120, #3122, #3327, #3357, @eli-schwartz and #3276, @neheb)\nbuild: Add aarch64 to supported architectures for zstd_trace (#3054, @ooosssososos)\nbuild: support AIX architecture (#3219, @qiongsiwu)\nbuild: Fix `ZSTD_LIB_MINIFY` build macro, which now reduces static library size by half (#3366, @terrelln)\nbuild: Fix Windows issues with Multithreading translation layer (#3364, #3380, @yoniko) and ARM64 target (#3320, @cwoffenden)\nbuild: Fix `cmake` script (#3382, #3392, @terrelln and #3252 @Tachi107 and #3167 @Cyan4973)\ndoc: Updated man page, providing more details for `--train` mode (#3112, @Cyan4973)\ndoc: Add decompressor errata document (#3092, @terrelln)\nmisc: Enable Intel CET (#2992, #2994, @hjl-tools)\nmisc: Fix `contrib/` seekable format (#3058, @yhoogstrate and #3346, @daniellerozenblit)\nmisc: Improve speed of the one-file library generator (#3241, @wahern and #3005, @cwoffenden)\n\nv1.5.3 (dev version, unpublished)\n\nv1.5.2 (Jan, 2022)\nperf: Regain Minimal memset()-ing During Reuse of Compression Contexts (@Cyan4973, #2969)\nbuild: Build Zstd with `noexecstack` on All Architectures (@felixhandte, #2964)\ndoc: Clarify Licensing (@terrelln, #2981)\n\nv1.5.1 (Dec, 2021)\nperf: rebalanced compression levels, to better match the intended speed/level curve, by @senhuang42\nperf: faster huffman decoder, using x64 assembly, by @terrelln\nperf: slightly faster high speed modes (strategies fast & dfast), by @felixhandte\nperf: improved binary size and faster compilation times, by @terrelln\nperf: new row64 mode, used notably in level 12, by @senhuang42\nperf: faster mid-level compression speed in presence of highly repetitive patterns, by @senhuang42\nperf: minor compression ratio improvements for small data at high levels, by @cyan4973\nperf: reduced stack usage (mostly useful for Linux Kernel), by @terrelln\nperf: faster compression speed on incompressible data, by @bindhvo\nperf: on-demand reduced ZSTD_DCtx state size, using build macro ZSTD_DECODER_INTERNAL_BUFFER, at a small cost of performance, by @bindhvo\nbuild: allows hiding static symbols in the dynamic library, using build macro, by @skitt\nbuild: support for m68k (Motorola 68000's), by @cyan4973\nbuild: improved AIX support, by @Helflym\nbuild: improved meson unofficial build, by @eli-schwartz\ncli : custom memory limit when training dictionary (#2925), by @embg\ncli : report advanced parameters information when compressing in very verbose mode (`-vv`), by @Svetlitski-FB\n\nv1.5.0 (May 11, 2021)\napi: Various functions promoted from experimental to stable API: (#2579-2581, @senhuang42)\n `ZSTD_defaultCLevel()`\n `ZSTD_getDictID_fromCDict()`\napi: Several experimental functions have been deprecated and will emit a compiler warning (#2582, @senhuang42)\n `ZSTD_compress_advanced()`\n `ZSTD_compress_usingCDict_advanced()`\n `ZSTD_compressBegin_advanced()`\n `ZSTD_compressBegin_usingCDict_advanced()`\n `ZSTD_initCStream_srcSize()`\n `ZSTD_initCStream_usingDict()`\n `ZSTD_initCStream_usingCDict()`\n `ZSTD_initCStream_advanced()`\n `ZSTD_initCStream_usingCDict_advanced()`\n `ZSTD_resetCStream()`\napi: ZSTDMT_NBWORKERS_MAX reduced to 64 for 32-bit environments (@Cyan4973)\nperf: Significant speed improvements for middle compression levels (#2494, @senhuang42 @terrelln)\nperf: Block splitter to improve compression ratio, enabled by default for high compression levels (#2447, @senhuang42)\nperf: Decompression loop refactor, speed improvements on `clang` and for `--long` modes (#2614 #2630, @Cyan4973)\nperf: Reduced stack usage during compression and decompression entropy stage (#2522 #2524, @terrelln)\nbug: Improve setting permissions of created files (#2525, @felixhandte)\nbug: Fix large dictionary non-determinism (#2607, @terrelln)\nbug: Fix non-determinism test failures on Linux i686 (#2606, @terrelln)\nbug: Fix various dedicated dictionary search bugs (#2540 #2586, @senhuang42 @felixhandte)\nbug: Ensure `ZSTD_estimateCCtxSize*() `monotonically increases with compression level (#2538, @senhuang42)\nbug: Fix --patch-from mode parameter bound bug with small files (#2637, @occivink)\nbug: Fix UBSAN error in decompression (#2625, @terrelln)\nbug: Fix superblock compression divide by zero bug (#2592, @senhuang42)\nbug: Make the number of physical CPU cores detection more robust (#2517, @PaulBone)\ndoc: Improve `zdict.h` dictionary training API documentation (#2622, @terrelln)\ndoc: Note that public `ZSTD_free*()` functions accept NULL pointers (#2521, @animalize)\ndoc: Add style guide docs for open source contributors (#2626, @Cyan4973)\ntests: Better regression test coverage for different dictionary modes (#2559, @senhuang42)\ntests: Better test coverage of index reduction (#2603, @terrelln)\ntests: OSS-Fuzz coverage for seekable format (#2617, @senhuang42)\ntests: Test coverage for ZSTD threadpool API (#2604, @senhuang42)\nbuild: Dynamic library built multithreaded by default (#2584, @senhuang42)\nbuild: Move `zstd_errors.h` and `zdict.h` to `lib/` root (#2597, @terrelln)\nbuild: Allow `ZSTDMT_JOBSIZE_MIN` to be configured at compile-time, reduce default to 512KB (#2611, @Cyan4973)\nbuild: Single file library build script moved to `build/` directory (#2618, @felixhandte)\nbuild: `ZBUFF_*()` is no longer built by default (#2583, @senhuang42)\nbuild: Fixed Meson build (#2548, @SupervisedThinking @kloczek)\nbuild: Fix excessive compiler warnings with clang-cl and CMake (#2600, @nickhutchinson)\nbuild: Detect presence of `md5` on Darwin (#2609, @felixhandte)\nbuild: Avoid SIGBUS on armv6 (#2633, @bmwiedmann)\ncli: `--progress` flag added to always display progress bar (#2595, @senhuang42)\ncli: Allow reading from block devices with `--force` (#2613, @felixhandte)\ncli: Fix CLI filesize display bug (#2550, @Cyan4973)\ncli: Fix windows CLI `--filelist` end-of-line bug (#2620, @Cyan4973)\ncontrib: Various fixes for linux kernel patch (#2539, @terrelln)\ncontrib: Seekable format - Decompression hanging edge case fix (#2516, @senhuang42)\ncontrib: Seekable format - New seek table-only API (#2113 #2518, @mdittmer @Cyan4973)\ncontrib: Seekable format - Fix seek table descriptor check when loading (#2534, @foxeng)\ncontrib: Seekable format - Decompression fix for large offsets, (#2594, @azat)\nmisc: Automatically published release tarballs available on Github (#2535, @felixhandte)\n\nv1.4.9 (Mar 1, 2021)\nbug: Use `umask()` to Constrain Created File Permissions (#2495, @felixhandte)\nbug: Make Simple Single-Pass Functions Ignore Advanced Parameters (#2498, @terrelln)\napi: Add (De)Compression Tracing Functionality (#2482, @terrelln)\napi: Support References to Multiple DDicts (#2446, @senhuang42)\napi: Add Function to Generate Skippable Frame (#2439, @senhuang42)\nperf: New Algorithms for the Long Distance Matcher (#2483, @mpu)\nperf: Performance Improvements for Long Distance Matcher (#2464, @mpu)\nperf: Don't Shrink Window Log when Streaming with a Dictionary (#2451, @terrelln)\ncli: Fix `--output-dir-mirror` rejection of `..` -containing paths (#2512, @felixhandte)\ncli: Allow Input From Console When `-f`/`--force` is Passed (#2466, @felixhandte)\ncli: Improve Help Message (#2500, @senhuang42)\ntests: Remove Flaky Tests (#2455, #2486, #2445, @Cyan4973)\ntests: Correctly Invoke md5 Utility on NetBSD (#2492, @niacat)\ntests: Avoid Using `stat -c` on NetBSD (#2513, @felixhandte)\nbuild: Zstd CLI Can Now be Linked to Dynamic `libzstd` (#2457, #2454 @Cyan4973)\nbuild: Hide and Avoid Using Static-Only Symbols (#2501, #2504, @skitt)\nbuild: CMake: Enable Only C for lib/ and programs/ Projects (#2498, @concatime)\nbuild: CMake: Use `configure_file()` to Create the `.pc` File (#2462, @lazka)\nbuild: Fix Fuzzer Compiler Detection & Update UBSAN Flags (#2503, @terrelln)\nbuild: Add Guards for `_LARGEFILE_SOURCE` and `_LARGEFILE64_SOURCE` (#2444, @indygreg)\nbuild: Improve `zlibwrapper` Makefile (#2437, @Cyan4973)\ncontrib: Add `recover_directory` Program (#2473, @terrelln)\ndoc: Change License Year to 2021 (#2452 & #2465, @terrelln & @senhuang42)\ndoc: Fix Typos (#2459, @ThomasWaldmann)\n\nv1.4.8 (Dec 18, 2020)\nhotfix: wrong alignment of an internal buffer\n\nv1.4.7 (Dec 16, 2020)\nperf: stronger --long mode at high compression levels, by @senhuang42\nperf: stronger --patch-from at high compression levels, thanks to --long improvements\nperf: faster dictionary compression at medium compression levels, by @felixhandte\nperf: small speed & memory usage improvements for ZSTD_compress2(), by @terrelln\nperf: improved fast compression speeds with Visual Studio, by @animalize\ncli : Set nb of threads with environment variable ZSTD_NBTHREADS, by @senhuang42\ncli : accept decompressing files with *.zstd suffix\ncli : provide a condensed summary by default when processing multiple files\ncli : fix : stdin input no longer confused as user prompt\ncli : improve accuracy of several error messages\napi : new sequence ingestion API, by @senhuang42\napi : shared thread pool: control total nb of threads used by multiple compression jobs, by @marxin\napi : new ZSTD_getDictID_fromCDict(), by @LuAPi\napi : zlibWrapper only uses public API, and is compatible with dynamic library, by @terrelln\napi : fix : multithreaded compression has predictable output even in special cases (see #2327) (issue not accessible from cli)\napi : fix : dictionary compression correctly respects dictionary compression level (see #2303) (issue not accessible from cli)\nbuild: fix cmake script when using path with spaces, by @terrelln\nbuild: improved compile-time detection of aarch64/neon platforms, by @bsdimp\nbuild: Fix building on AIX 5.1, by @likema\nbuild: compile paramgrill with cmake on Windows, requested by @mirh\ndoc : clarify repcode updates in format specification, by @felixhandte\n\nv1.4.6\nfix : Always return dstSize_tooSmall when that is the case\nfix : Fix ZSTD_initCStream_advanced() with static allocation and no dictionary\nperf: Improve small block decompression speed by 20%+, by @terrelln\nperf: Reduce compression stack usage by 1 KB, by @terrelln\nperf: Improve decompression speed by improving ZSTD_wildcopy, by @helloguo (#2252, #2256)\nperf: Improve histogram construction, by @cyan4973 (#2253)\ncli : Add --output-dir-mirror option, by @xxie24 (#2219)\ncli : Warn when (de)compressing multiple files into a single output, by @senhuang42 (#2279)\ncli : Improved progress bar and status summary when (de)compressing multiple files, by @senhuang42 (#2283)\ncli : Call stat less often, by @felixhandte (#2262)\ncli : Allow --patch-from XXX and --filelist XXX in addition to --patch-from=XXX and --filelist=XXX, by @cyan4973 (#2250)\ncli : Allow --patch-from to compress stdin with --stream-size, by @bimbashrestha (#2206)\napi : Do not install zbuff.h, since it has long been deprecated, by @cyan4973 (#2166).\napi : Fix ZSTD_CCtx_setParameter() with ZSTD_c_compressionLevel to make 0 mean default level, by @i-do-cpp (#2291)\napi : Rename ZSTDMT_NBTHREADS_MAX to ZSTDMT_NBWORKERS_MAX, by @marxin (#2228).\nbuild: Install pkg-config file with CMake and MinGW, by @tonytheodore (#2183)\nbuild: Install DLL with CMake on Windows, by @BioDataAnalysis (#2221)\nbuild: Fix DLL install location with CMake, by @xantares and @bimbashrestha (#2186)\nbuild: Add ZSTD_NO_UNUSED_FUNCTIONS macro to hide unused functions\nbuild: Add ZSTD_NO_INTRINSICS macro to avoid explicit intrinsics\nbuild: Add STATIC_BMI2 macro for compile time detection of BMI2 on MSVC, by @Niadb (#2258)\nbuild: Fix -Wcomma warnings, by @cwoffenden\nbuild: Remove distutils requirement for meson build, by @neheb (#2197)\nbuild: Fix cli compilation with uclibc\nbuild: Fix cli compilation without st_mtime, by @ffontaine (#2246)\nbuild: Fix shadowing warnings in library\nbuild: Fix single file library compilation with Enscripten, by @yoshihitoh (#2227)\nmisc: Improve single file library and include dictBuilder, by @cwoffenden\nmisc: Allow compression dictionaries with missing symbols\nmisc: Add freestanding translation script in contrib/freestanding_lib\nmisc: Collect all of zstd's libc dependencies into zstd_deps.h\ndoc : Add ZSTD_versionString() to manual, by @animalize\ndoc : Fix documentation for ZSTD_CCtxParams_setParameter(), by @felixhandte (#2270)\n\nv1.4.5 (May 22, 2020)\nfix : Compression ratio regression on huge files (> 3 GB) using high levels (--ultra) and multithreading, by @terrelln\nperf: Improved decompression speed: x64 : +10% (clang) / +5% (gcc); ARM : from +15% to +50%, depending on SoC, by @terrelln\nperf: Automatically downsizes ZSTD_DCtx when too large for too long (#2069, by @bimbashreshta)\nperf: Improved fast compression speed on aarch64 (#2040, ~+3%, by @caoyzh)\nperf: Small level 1 compression speed gains (depending on compiler)\ncli : New --patch-from command, create and apply patches from files, by @bimbashreshta\ncli : New --filelist= : Provide a list of files to operate upon from a file\ncli : -b -d command can now benchmark decompression on multiple files\ncli : New --no-content-size command\ncli : New --show-default-cparams information command\napi : ZDICT_finalizeDictionary() is promoted to stable (#2111)\napi : new experimental parameter ZSTD_d_stableOutBuffer (#2094)\nbuild: Generate a single-file libzstd library (#2065, by @cwoffenden)\nbuild: Relative includes no longer require -I compiler flags for zstd lib subdirs (#2103, by @felixhandte)\nbuild: zstd now compiles cleanly under -pedantic (#2099)\nbuild: zstd now compiles with make-4.3\nbuild: Support mingw cross-compilation from Linux, by @Ericson2314\nbuild: Meson multi-thread build fix on windows\nbuild: Some misc icc fixes backed by new ci test on travis\nmisc: bitflip analyzer tool, by @felixhandte\nmisc: Extend largeNbDicts benchmark to compression\nmisc: Edit-distance match finder in contrib/\ndoc : Improved beginner CONTRIBUTING.md docs\ndoc : New issue templates for zstd\n\nv1.4.4 (Nov 6, 2019)\nperf: Improved decompression speed, by > 10%, by @terrelln\nperf: Better compression speed when re-using a context, by @felixhandte\nperf: Fix compression ratio when compressing large files with small dictionary, by @senhuang42\nperf: zstd reference encoder can generate RLE blocks, by @bimbashrestha\nperf: minor generic speed optimization, by @davidbolvansky\napi: new ability to extract sequences from the parser for analysis, by @bimbashrestha\napi: fixed decoding of magic-less frames, by @terrelln\napi: fixed ZSTD_initCStream_advanced() performance with fast modes, reported by @QrczakMK\ncli: Named pipes support, by @bimbashrestha\ncli: short tar's extension support, by @stokito\ncli: command --output-dir-flat= , generates target files into requested directory, by @senhuang42\ncli: commands --stream-size=# and --size-hint=#, by @nmagerko\ncli: command --exclude-compressed, by @shashank0791\ncli: faster `-t` test mode\ncli: improved some error messages, by @vangyzen\ncli: fix command `-D dictionary` on Windows, reported by @artyompetrov\ncli: fix rare deadlock condition within dictionary builder, by @terrelln\nbuild: single-file decoder with emscripten compilation script, by @cwoffenden\nbuild: fixed zlibWrapper compilation on Visual Studio, reported by @bluenlive\nbuild: fixed deprecation warning for certain gcc version, reported by @jasonma163\nbuild: fix compilation on old gcc versions, by @cemeyer\nbuild: improved installation directories for cmake script, by Dmitri Shubin\npack: modified pkgconfig, for better integration into openwrt, requested by @neheb\nmisc: Improved documentation : ZSTD_CLEVEL, DYNAMIC_BMI2, ZSTD_CDict, function deprecation, zstd format\nmisc: fixed educational decoder : accept larger literals section, and removed UNALIGNED() macro\n\nv1.4.3 (Aug 20, 2019)\nbug: Fix Dictionary Compression Ratio Regression by @cyan4973 (#1709)\nbug: Fix Buffer Overflow in legacy v0.3 decompression by @felixhandte (#1722)\nbuild: Add support for IAR C/C++ Compiler for Arm by @joseph0918 (#1705)\n\nv1.4.2 (Jul 26, 2019)\nbug: Fix bug in zstd-0.5 decoder by @terrelln (#1696)\nbug: Fix seekable decompression in-memory API by @iburinoc (#1695)\nmisc: Validate blocks are smaller than size limit by @vivekmg (#1685)\nmisc: Restructure source files by @ephiepark (#1679)\n\nv1.4.1 (Jul 20, 2019)\nbug: Fix data corruption in niche use cases by @terrelln (#1659)\nbug: Fuzz legacy modes, fix uncovered bugs by @terrelln (#1593, #1594, #1595)\nbug: Fix out of bounds read by @terrelln (#1590)\nperf: Improve decode speed by ~7% @mgrice (#1668)\nperf: Slightly improved compression ratio of level 3 and 4 (ZSTD_dfast) by @cyan4973 (#1681)\nperf: Slightly faster compression speed when re-using a context by @cyan4973 (#1658)\nperf: Improve compression ratio for small windowLog by @cyan4973 (#1624)\nperf: Faster compression speed in high compression mode for repetitive data by @terrelln (#1635)\napi: Add parameter to generate smaller dictionaries by @tyler-tran (#1656)\ncli: Recognize symlinks when built in C99 mode by @felixhandte (#1640)\ncli: Expose cpu load indicator for each file on -vv mode by @ephiepark (#1631)\ncli: Restrict read permissions on destination files by @chungy (#1644)\ncli: zstdgrep: handle -f flag by @felixhandte (#1618)\ncli: zstdcat: follow symlinks by @vejnar (#1604)\ndoc: Remove extra size limit on compressed blocks by @felixhandte (#1689)\ndoc: Fix typo by @yk-tanigawa (#1633)\ndoc: Improve documentation on streaming buffer sizes by @cyan4973 (#1629)\nbuild: CMake: support building with LZ4 @leeyoung624 (#1626)\nbuild: CMake: install zstdless and zstdgrep by @leeyoung624 (#1647)\nbuild: CMake: respect existing uninstall target by @j301scott (#1619)\nbuild: Make: skip multithread tests when built without support by @michaelforney (#1620)\nbuild: Make: Fix examples/ test target by @sjnam (#1603)\nbuild: Meson: rename options out of deprecated namespace by @lzutao (#1665)\nbuild: Meson: fix build by @lzutao (#1602)\nbuild: Visual Studio: don't export symbols in static lib by @scharan (#1650)\nbuild: Visual Studio: fix linking by @absotively (#1639)\nbuild: Fix MinGW-W64 build by @myzhang1029 (#1600)\nmisc: Expand decodecorpus coverage by @ephiepark (#1664)\n\nv1.4.0 (Apr 17, 2019)\nperf: Improve level 1 compression speed in most scenarios by 6% by @gbtucker and @terrelln\napi: Move the advanced API, including all functions in the staging section, to the stable section\napi: Make ZSTD_e_flush and ZSTD_e_end block for maximum forward progress\napi: Rename ZSTD_CCtxParam_getParameter to ZSTD_CCtxParams_getParameter\napi: Rename ZSTD_CCtxParam_setParameter to ZSTD_CCtxParams_setParameter\napi: Don't export ZSTDMT functions from the shared library by default\napi: Require ZSTD_MULTITHREAD to be defined to use ZSTDMT\napi: Add ZSTD_decompressBound() to provide an upper bound on decompressed size by @shakeelrao\napi: Fix ZSTD_decompressDCtx() corner cases with a dictionary\napi: Move ZSTD_getDictID_*() functions to the stable section\napi: Add ZSTD_c_literalCompressionMode flag to enable or disable literal compression by @terrelln\napi: Allow compression parameters to be set when a dictionary is used\napi: Allow setting parameters before or after ZSTD_CCtx_loadDictionary() is called\napi: Fix ZSTD_estimateCStreamSize_usingCCtxParams()\napi: Setting ZSTD_d_maxWindowLog to 0 means use the default\ncli: Ensure that a dictionary is not used to compress itself by @shakeelrao\ncli: Add --[no-]compress-literals flag to enable or disable literal compression\ndoc: Update the examples to use the advanced API\ndoc: Explain how to transition from old streaming functions to the advanced API in the header\nbuild: Improve the Windows release packages\nbuild: Improve CMake build by @hjmjohnson\nbuild: Build fixes for FreeBSD by @lwhsu\nbuild: Remove redundant warnings by @thatsafunnyname\nbuild: Fix tests on OpenBSD by @bket\nbuild: Extend fuzzer build system to work with the new clang engine\nbuild: CMake now creates the libzstd.so.1 symlink\nbuild: Improve Menson build by @lzutao\nmisc: Fix symbolic link detection on FreeBSD\nmisc: Use physical core count for -T0 on FreeBSD by @cemeyer\nmisc: Fix zstd --list on truncated files by @kostmo\nmisc: Improve logging in debug mode by @felixhandte\nmisc: Add CirrusCI tests by @lwhsu\nmisc: Optimize dictionary memory usage in corner cases\nmisc: Improve the dictionary builder on small or homogeneous data\nmisc: Fix spelling across the repo by @jsoref\n\nv1.3.8 (Dec 28, 2018)\nperf: better decompression speed on large files (+7%) and cold dictionaries (+15%)\nperf: slightly better compression ratio at high compression modes\napi : finalized advanced API, last stage before \"stable\" status\napi : new --rsyncable mode, by @terrelln\napi : support decompression of empty frames into NULL (used to be an error) (#1385)\nbuild: new set of macros to build a minimal size decoder, by @felixhandte\nbuild: fix compilation on MIPS32, reported by @clbr (#1441)\nbuild: fix compilation with multiple -arch flags, by @ryandesign\nbuild: highly upgraded meson build, by @lzutao\nbuild: improved buck support, by @obelisk\nbuild: fix cmake script : can create debug build, by @pitrou\nbuild: Makefile : grep works on both colored consoles and systems without color support\nbuild: fixed zstd-pgo, by @bmwiedemann\ncli : support ZSTD_CLEVEL environment variable, by @yijinfb (#1423)\ncli : --no-progress flag, preserving final summary (#1371), by @terrelln\ncli : ensure destination file is not source file (#1422)\ncli : clearer error messages, especially when input file not present\ndoc : clarified zstd_compression_format.md, by @ulikunitz\nmisc: fixed zstdgrep, returns 1 on failure, by @lzutao\nmisc: NEWS renamed as CHANGELOG, in accordance with fboss\n\nv1.3.7 (Oct 20, 2018)\nperf: slightly better decompression speed on clang (depending on hardware target)\nfix : performance of dictionary compression for small input < 4 KB at levels 9 and 10\nbuild: no longer build backtrace by default in release mode; restrict further automatic mode\nbuild: control backtrace support through build macro BACKTRACE\nmisc: added man pages for zstdless and zstdgrep, by @samrussell\n\nv1.3.6 (Oct 6, 2018)\nperf: much faster dictionary builder, by @jenniferliu\nperf: faster dictionary compression on small data when using multiple contexts, by @felixhandte\nperf: faster dictionary decompression when using a very large number of dictionaries simultaneously\ncli : fix : does no longer overwrite destination when source does not exist (#1082)\ncli : new command --adapt, for automatic compression level adaptation\napi : fix : block api can be streamed with > 4 GB, reported by @catid\napi : reduced ZSTD_DDict size by 2 KB\napi : minimum negative compression level is defined, and can be queried using ZSTD_minCLevel().\nbuild: support Haiku target, by @korli\nbuild: Read Legacy format is limited to v0.5+ by default. Can be changed at compile time with macro ZSTD_LEGACY_SUPPORT.\ndoc : zstd_compression_format.md updated to match wording in IETF RFC 8478\nmisc: tests/paramgrill, a parameter optimizer, by @GeorgeLu97\n\nv1.3.5 (Jun 29, 2018)\nperf: much faster dictionary compression, by @felixhandte\nperf: small quality improvement for dictionary generation, by @terrelln\nperf: slightly improved high compression levels (notably level 19)\nmem : automatic memory release for long duration contexts\ncli : fix : overlapLog can be manually set\ncli : fix : decoding invalid lz4 frames\napi : fix : performance degradation for dictionary compression when using advanced API, by @terrelln\napi : change : clarify ZSTD_CCtx_reset() vs ZSTD_CCtx_resetParameters(), by @terrelln\nbuild: select custom libzstd scope through control macros, by @GeorgeLu97\nbuild: OpenBSD patch, by @bket\nbuild: make and make all are compatible with -j\ndoc : clarify zstd_compression_format.md, updated for IETF RFC process\nmisc: pzstd compatible with reproducible compilation, by @lamby\n\nv1.3.4 (Mar 27, 2018)\nperf: faster speed (especially decoding speed) on recent cpus (haswell+)\nperf: much better performance associating --long with multi-threading, by @terrelln\nperf: better compression at levels 13-15\ncli : asynchronous compression by default, for faster experience (use --single-thread for former behavior)\ncli : smoother status report in multi-threading mode\ncli : added command --fast=#, for faster compression modes\ncli : fix crash when not overwriting existing files, by Pádraig Brady (@pixelb)\napi : `nbThreads` becomes `nbWorkers` : 1 triggers asynchronous mode\napi : compression levels can be negative, for even more speed\napi : ZSTD_getFrameProgression() : get precise progress status of ZSTDMT anytime\napi : ZSTDMT can accept new compression parameters during compression\napi : implemented all advanced dictionary decompression prototypes\nbuild: improved meson recipe, by Shawn Landden (@shawnl)\nbuild: VS2017 scripts, by @HaydnTrigg\nmisc: all /contrib projects fixed\nmisc: added /contrib/docker script by @gyscos\n\nv1.3.3 (Dec 21, 2017)\nperf: faster zstd_opt strategy (levels 16-19)\nfix : bug #944 : multithreading with shared dictionary and large data, reported by @gsliepen\ncli : fix : content size written in header by default\ncli : fix : improved LZ4 format support, by @felixhandte\ncli : new : hidden command `-S`, to benchmark multiple files while generating one result per file\napi : fix : support large skippable frames, by @terrelln\napi : fix : streaming interface was adding a useless 3-bytes null block to small frames\napi : change : when setting `pledgedSrcSize`, use `ZSTD_CONTENTSIZE_UNKNOWN` macro value to mean \"unknown\"\nbuild: fix : compilation under rhel6 and centos6, reported by @pixelb\nbuild: added `check` target\n\nv1.3.2 (Oct 10, 2017)\nnew : long range mode, using --long command, by Stella Lau (@stellamplau)\nnew : ability to generate and decode magicless frames (#591)\nchanged : maximum nb of threads reduced to 200, to avoid address space exhaustion in 32-bits mode\nfix : multi-threading compression works with custom allocators\nfix : ZSTD_sizeof_CStream() was over-evaluating memory usage\nfix : a rare compression bug when compression generates very large distances and bunch of other conditions (only possible at --ultra -22)\nfix : 32-bits build can now decode large offsets (levels 21+)\ncli : added LZ4 frame support by default, by Felix Handte (@felixhandte)\ncli : improved --list output\ncli : new : can split input file for dictionary training, using command -B#\ncli : new : clean operation artefact on Ctrl-C interruption\ncli : fix : do not change /dev/null permissions when using command -t with root access, reported by @mike155 (#851)\ncli : fix : write file size in header in multiple-files mode\napi : added macro ZSTD_COMPRESSBOUND() for static allocation\napi : experimental : new advanced decompression API\napi : fix : sizeof_CCtx() used to over-estimate\nbuild: fix : no-multithread variant compiles without pool.c dependency, reported by Mitchell Blank Jr (@mitchblank) (#819)\nbuild: better compatibility with reproducible builds, by Bernhard M. Wiedemann (@bmwiedemann) (#818)\nexample : added streaming_memory_usage\nlicense : changed /examples license to BSD + GPLv2\nlicense : fix a few header files to reflect new license (#825)\n\nv1.3.1 (Aug 21, 2017)\nNew license : BSD + GPLv2\nperf: substantially decreased memory usage in Multi-threading mode, thanks to reports by Tino Reichardt (@mcmilk)\nperf: Multi-threading supports up to 256 threads. Cap at 256 when more are requested (#760)\ncli : improved and fixed --list command, by @ib (#772)\ncli : command -vV to list supported formats, by @ib (#771)\nbuild : fixed binary variants, reported by @svenha (#788)\nbuild : fix Visual compilation for non x86/x64 targets, reported by Greg Slazinski (@GregSlazinski) (#718)\nAPI exp : breaking change : ZSTD_getframeHeader() provides more information\nAPI exp : breaking change : pinned down values of error codes\ndoc : fixed huffman example, by Ulrich Kunitz (@ulikunitz)\nnew : contrib/adaptive-compression, I/O driven compression strength, by Paul Cruz (@paulcruz74)\nnew : contrib/long_distance_matching, statistics by Stella Lau (@stellamplau)\nupdated : contrib/linux-kernel, by Nick Terrell (@terrelln)\n\nv1.3.0 (Jul 6, 2017)\ncli : new : `--list` command, by Paul Cruz\ncli : changed : xz/lzma support enabled by default\ncli : changed : `-t *` continue processing list after a decompression error\nAPI : added : ZSTD_versionString()\nAPI : promoted to stable status : ZSTD_getFrameContentSize(), by Sean Purcell\nAPI exp : new advanced API : ZSTD_compress_generic(), ZSTD_CCtx_setParameter()\nAPI exp : new : API for static or external allocation : ZSTD_initStatic?Ctx()\nAPI exp : added : ZSTD_decompressBegin_usingDDict(), requested by Guy Riddle (#700)\nAPI exp : clarified memory estimation / measurement functions.\nAPI exp : changed : strongest strategy renamed ZSTD_btultra, fastest strategy ZSTD_fast set to 1\ntools : decodecorpus can generate random dictionary-compressed samples, by Paul Cruz\nnew : contrib/seekable_format, demo and API, by Sean Purcell\nchanged : contrib/linux-kernel, updated version and license, by Nick Terrell\n\nv1.2.0 (May 5, 2017)\ncli : changed : Multithreading enabled by default (use target zstd-nomt or HAVE_THREAD=0 to disable)\ncli : new : command -T0 means \"detect and use nb of cores\", by Sean Purcell\ncli : new : zstdmt symlink hardwired to `zstd -T0`\ncli : new : command --threads=# (#671)\ncli : changed : cover dictionary builder by default, for improved quality, by Nick Terrell\ncli : new : commands --train-cover and --train-legacy, to select dictionary algorithm and parameters\ncli : experimental targets `zstd4` and `xzstd4`, with support for lz4 format, by Sean Purcell\ncli : fix : does not output compressed data on console\ncli : fix : ignore symbolic links unless --force specified,\nAPI : breaking change : ZSTD_createCDict_advanced(), only use compressionParameters as argument\nAPI : added : prototypes ZSTD_*_usingCDict_advanced(), for direct control over frameParameters.\nAPI : improved: ZSTDMT_compressCCtx() reduced memory usage\nAPI : fix : ZSTDMT_compressCCtx() now provides srcSize in header (#634)\nAPI : fix : src size stored in frame header is controlled at end of frame\nAPI : fix : enforced consistent rules for pledgedSrcSize==0 (#641)\nAPI : fix : error code \"GENERIC\" replaced by \"dstSizeTooSmall\" when appropriate\nbuild: improved cmake script, by @Majlen\nbuild: enabled Multi-threading support for *BSD, by Baptiste Daroussin\ntools: updated Paramgrill. Command -O# provides best parameters for sample and speed target.\nnew : contrib/linux-kernel version, by Nick Terrell\n\nv1.1.4 (Mar 18, 2017)\ncli : new : can compress in *.gz format, using --format=gzip command, by Przemyslaw Skibinski\ncli : new : advanced benchmark command --priority=rt\ncli : fix : write on sparse-enabled file systems in 32-bits mode, by @ds77\ncli : fix : --rm remains silent when input is stdin\ncli : experimental : xzstd, with support for xz/lzma decoding, by Przemyslaw Skibinski\nspeed : improved decompression speed in streaming mode for single shot scenarios (+5%)\nmemory: DDict (decompression dictionary) memory usage down from 150 KB to 20 KB\narch: 32-bits variant able to generate and decode very long matches (>32 MB), by Sean Purcell\nAPI : new : ZSTD_findFrameCompressedSize(), ZSTD_getFrameContentSize(), ZSTD_findDecompressedSize()\nAPI : changed : dropped support of legacy versions <= v0.3 (can be changed by modifying ZSTD_LEGACY_SUPPORT value)\nbuild : new: meson build system in contrib/meson, by Dima Krasner\nbuild : improved cmake script, by @Majlen\nbuild : added -Wformat-security flag, as recommended by Padraig Brady\ndoc : new : educational decoder, by Sean Purcell\n\nv1.1.3 (Feb 7, 2017)\ncli : zstd can decompress .gz files (can be disabled with `make zstd-nogz` or `make HAVE_ZLIB=0`)\ncli : new : experimental target `make zstdmt`, with multi-threading support\ncli : new : improved dictionary builder \"cover\" (experimental), by Nick Terrell, based on prior work by Giuseppe Ottaviano.\ncli : new : advanced commands for detailed parameters, by Przemyslaw Skibinski\ncli : fix zstdless on Mac OS-X, by Andrew Janke\ncli : fix #232 \"compress non-files\"\ndictBuilder : improved dictionary generation quality, thanks to Nick Terrell\nAPI : new : lib/compress/ZSTDMT_compress.h multithreading API (experimental)\nAPI : new : ZSTD_create?Dict_byReference(), requested by Bartosz Taudul\nAPI : new : ZDICT_finalizeDictionary()\nAPI : fix : ZSTD_initCStream_usingCDict() properly writes dictID into frame header, by Gregory Szorc (#511)\nAPI : fix : all symbols properly exposed in libzstd, by Nick Terrell\nbuild : support for Solaris target, by Przemyslaw Skibinski\ndoc : clarified specification, by Sean Purcell\n\nv1.1.2 (Dec 15, 2016)\nAPI : streaming : decompression : changed : automatic implicit reset when chain-decoding new frames without init\nAPI : experimental : added : dictID retrieval functions, and ZSTD_initCStream_srcSize()\nAPI : zbuff : changed : prototypes now generate deprecation warnings\nlib : improved : faster decompression speed at ultra compression settings and 32-bits mode\nlib : changed : only public ZSTD_ symbols are now exposed\nlib : changed : reduced usage of stack memory\nlib : fixed : several corner case bugs, by Nick Terrell\ncli : new : gzstd, experimental version able to decode .gz files, by Przemyslaw Skibinski\ncli : new : preserve file attributes\ncli : new : added zstdless and zstdgrep tools\ncli : fixed : status displays total amount decoded, even for file consisting of multiple frames (like pzstd)\ncli : fixed : zstdcat\nzlib_wrapper : added support for gz* functions, by Przemyslaw Skibinski\ninstall : better compatibility with FreeBSD, by Dimitry Andric\nsource tree : changed : zbuff source files moved to lib/deprecated\n\nv1.1.1 (Nov 2, 2016)\nNew : command -M#, --memory=, --memlimit=, --memlimit-decompress= to limit allowed memory consumption\nNew : doc/zstd_manual.html, by Przemyslaw Skibinski\nImproved : slightly better compression ratio at --ultra levels (>= 20)\nImproved : better memory usage when using streaming compression API, thanks to @Rogier-5 report\nAdded : API : ZSTD_initCStream_usingCDict(), ZSTD_initDStream_usingDDict() (experimental section)\nAdded : example/multiple_streaming_compression.c\nChanged : zstd_errors.h is now installed within /include (and replaces errors_public.h)\nUpdated man page\nFixed : zstd-small, zstd-compress and zstd-decompress compilation targets\n\nv1.1.0 (Sep 28, 2016)\nNew : contrib/pzstd, parallel version of zstd, by Nick Terrell\nadded : NetBSD install target (#338)\nImproved : speed for batches of small files\nImproved : speed of zlib wrapper, by Przemyslaw Skibinski\nChanged : libzstd on Windows supports legacy formats, by Christophe Chevalier\nFixed : CLI -d output to stdout by default when input is stdin (#322)\nFixed : CLI correctly detects console on Mac OS-X\nFixed : CLI supports recursive mode `-r` on Mac OS-X\nFixed : Legacy decoders use unified error codes, reported by benrg (#341), fixed by Przemyslaw Skibinski\nFixed : compatibility with OpenBSD, reported by Juan Francisco Cantero Hurtado (#319)\nFixed : compatibility with Hurd, by Przemyslaw Skibinski (#365)\nFixed : zstd-pgo, reported by octoploid (#329)\n\nv1.0.0 (Sep 1, 2016)\nChange Licensing, all project is now BSD, Copyright Facebook\nSmall decompression speed improvement\nAPI : Streaming API supports legacy format\nAPI : ZDICT_getDictID(), ZSTD_sizeof_{CCtx, DCtx, CStream, DStream}(), ZSTD_setDStreamParameter()\nCLI supports legacy formats v0.4+\nFixed : compression fails on certain huge files, reported by Jesse McGrew\nEnhanced documentation, by Przemyslaw Skibinski\n\nv0.8.1 (Aug 18, 2016)\nNew streaming API\nChanged : --ultra now enables levels beyond 19\nChanged : -i# now selects benchmark time in second\nFixed : ZSTD_compress* can now compress > 4 GB in a single pass, reported by Nick Terrell\nFixed : speed regression on specific patterns (#272)\nFixed : support for Z_SYNC_FLUSH, by Dmitry Krot (#291)\nFixed : ICC compilation, by Przemyslaw Skibinski\n\nv0.8.0 (Aug 2, 2016)\nImproved : better speed on clang and gcc -O2, thanks to Eric Biggers\nNew : Build on FreeBSD and DragonFly, thanks to JrMarino\nChanged : modified API : ZSTD_compressEnd()\nFixed : legacy mode with ZSTD_HEAPMODE=0, by Christopher Bergqvist\nFixed : premature end of frame when zero-sized raw block, reported by Eric Biggers\nFixed : large dictionaries (> 384 KB), reported by Ilona Papava\nFixed : checksum correctly checked in single-pass mode\nFixed : combined --test amd --rm, reported by Andreas M. Nilsson\nModified : minor compression level adaptations\nUpdated : compression format specification to v0.2.0\nchanged : zstd.h moved to /lib directory\n\nv0.7.5 (Aug 1, 2016)\nTransition version, supporting decoding of v0.8.x\n\nv0.7.4 (Jul 17, 2016)\nAdded : homebrew for Mac, by Daniel Cade\nAdded : more examples\nFixed : segfault when using small dictionaries, reported by Felix Handte\nModified : default compression level for CLI is now 3\nUpdated : specification, to v0.1.1\n\nv0.7.3 (Jul 9, 2016)\nNew : compression format specification\nNew : `--` separator, stating that all following arguments are file names. Suggested by Chip Turner.\nNew : `ZSTD_getDecompressedSize()`\nNew : OpenBSD target, by Juan Francisco Cantero Hurtado\nNew : `examples` directory\nfixed : dictBuilder using HC levels, reported by Bartosz Taudul\nfixed : legacy support from ZSTD_decompress_usingDDict(), reported by Felix Handte\nfixed : multi-blocks decoding with intermediate uncompressed blocks, reported by Greg Slazinski\nmodified : removed \"mem.h\" and \"error_public.h\" dependencies from \"zstd.h\" (experimental section)\nmodified : legacy functions no longer need magic number\n\nv0.7.2 (Jul 4, 2016)\nfixed : ZSTD_decompressBlock() using multiple consecutive blocks. Reported by Greg Slazinski.\nfixed : potential segfault on very large files (many gigabytes). Reported by Chip Turner.\nfixed : CLI displays system error message when destination file cannot be created (#231). Reported by Chip Turner.\n\nv0.7.1 (Jun 23, 2016)\nfixed : ZBUFF_compressEnd() called multiple times with too small `dst` buffer, reported by Christophe Chevalier\nfixed : dictBuilder fails if first sample is too small, reported by Руслан Ковалёв\nfixed : corruption issue, reported by cj\nmodified : checksum enabled by default in command line mode\n\nv0.7.0 (Jun 17, 2016)\nNew : Support for directory compression, using `-r`, thanks to Przemyslaw Skibinski\nNew : Command `--rm`, to remove source file after successful de/compression\nNew : Visual build scripts, by Christophe Chevalier\nNew : Support for Sparse File-systems (do not use space for zero-filled sectors)\nNew : Frame checksum support\nNew : Support pass-through mode (when using `-df`)\nAPI : more efficient Dictionary API : `ZSTD_compress_usingCDict()`, `ZSTD_decompress_usingDDict()`\nAPI : create dictionary files from custom content, by Giuseppe Ottaviano\nAPI : support for custom malloc/free functions\nNew : controllable Dictionary ID\nNew : Support for skippable frames\n\nv0.6.1 (May 13, 2016)\nNew : zlib wrapper API, thanks to Przemyslaw Skibinski\nNew : Ability to compile compressor / decompressor separately\nChanged : new lib directory structure\nFixed : Legacy codec v0.5 compatible with dictionary decompression\nFixed : Decoder corruption error (#173)\nFixed : null-string roundtrip (#176)\nNew : benchmark mode can select directory as input\nExperimental : midipix support, VMS support\n\nv0.6.0 (Apr 13, 2016)\nStronger high compression modes, thanks to Przemyslaw Skibinski\nAPI : ZSTD_getFrameParams() provides size of decompressed content\nNew : highest compression modes require `--ultra` command to fully unleash their capacity\nFixed : zstd cli return error code > 0 and removes dst file artifact when decompression fails, thanks to Chip Turner\n\nv0.5.1 (Feb 18, 2016)\nNew : Optimal parsing => Very high compression modes, thanks to Przemyslaw Skibinski\nChanged : Dictionary builder integrated into libzstd and zstd cli\nChanged (!) : zstd cli now uses \"multiple input files\" as default mode. See `zstd -h`.\nFix : high compression modes for big-endian platforms\nNew : zstd cli : `-t` | `--test` command\n\nv0.5.0 (Feb 5, 2016)\nNew : dictionary builder utility\nChanged : streaming & dictionary API\nImproved : better compression of small data\n\nv0.4.7 (Jan 22, 2016)\nImproved : small compression speed improvement in HC mode\nChanged : `zstd_decompress.c` has ZSTD_LEGACY_SUPPORT to 0 by default\nfix : bt search bug\n\nv0.4.6 (Jan 13, 2016)\nfix : fast compression mode on Windows\nNew : cmake configuration file, thanks to Artyom Dymchenko\nImproved : high compression mode on repetitive data\nNew : block-level API\nNew : ZSTD_duplicateCCtx()\n\nv0.4.5 (Dec 18, 2015)\nnew : -m/--multiple : compress/decompress multiple files\n\nv0.4.4 (Dec 14, 2015)\nFixed : high compression modes for Windows 32 bits\nnew : external dictionary API extended to buffered mode and accessible through command line\nnew : windows DLL project, thanks to Christophe Chevalier\n\nv0.4.3 (Dec 7, 2015)\nnew : external dictionary API\nnew : zstd-frugal\n\nv0.4.2 (Dec 2, 2015)\nGeneric minor improvements for small blocks\nFixed : big-endian compatibility, by Peter Harris (#85)\n\nv0.4.1 (Dec 1, 2015)\nFixed : ZSTD_LEGACY_SUPPORT=0 build mode (reported by Luben)\nremoved `zstd.c`\n\nv0.4.0 (Nov 29, 2015)\nCommand line utility compatible with high compression levels\nRemoved zstdhc => merged into zstd\nAdded : ZBUFF API (see zstd_buffered.h)\nRolling buffer support\n\nv0.3.6 (Nov 10, 2015)\nsmall blocks params\n\nv0.3.5 (Nov 9, 2015)\nminor generic compression improvements\n\nv0.3.4 (Nov 6, 2015)\nFaster fast cLevels\n\nv0.3.3 (Nov 5, 2015)\nSmall compression ratio improvement\n\nv0.3.2 (Nov 2, 2015)\nFixed Visual Studio\n\nv0.3.1 (Nov 2, 2015)\nSmall compression ratio improvement\n\nv0.3 (Oct 30, 2015)\nHC mode : compression levels 2-26\n\nv0.2.2 (Oct 28, 2015)\nFix : Visual Studio 2013 & 2015 release compilation, by Christophe Chevalier\n\nv0.2.1 (Oct 24, 2015)\nFix : Read errors, advanced fuzzer tests, by Hanno Böck\n\nv0.2.0 (Oct 22, 2015)\n**Breaking format change**\nFaster decompression speed\nCan still decode v0.1 format\n\nv0.1.3 (Oct 15, 2015)\nfix uninitialization warning, reported by Evan Nemerson\n\nv0.1.2 (Sep 11, 2015)\nframe concatenation support\n\nv0.1.1 (Aug 27, 2015)\nfix compression bug\ndetects write-flush errors\n\nv0.1.0 (Aug 25, 2015)\nfirst release\n" }, { "path": "CMakeLists.txt", "content": "cmake_minimum_required(VERSION 3.10)\n\n# Thin wrapper so `cmake -S .` behaves like `cmake -S build/cmake`.\n# Policy lives in build/cmake; keep parent project language-less.\nproject(zstd-superbuild LANGUAGES NONE)\n\nif(CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)\n message(FATAL_ERROR \"In-source builds are not supported. Specify -B .\")\nendif()\n\nadd_subdirectory(build/cmake)\n" }, { "path": "CODE_OF_CONDUCT.md", "content": "# Code of Conduct\n\nFacebook has adopted a Code of Conduct that we expect project participants to adhere to.\nPlease read the [full text](https://code.fb.com/codeofconduct/)\nso that you can understand what actions will and will not be tolerated.\n" }, { "path": "CONTRIBUTING.md", "content": "# Contributing to Zstandard\nWe want to make contributing to this project as easy and transparent as\npossible.\n\n## Our Development Process\nNew versions are being developed in the \"dev\" branch,\nor in their own feature branch.\nWhen they are deemed ready for a release, they are merged into \"release\".\n\nAs a consequence, all contributions must stage first through \"dev\"\nor their own feature branch.\n\n## Pull Requests\nWe actively welcome your pull requests.\n\n1. Fork the repo and create your branch from `dev`.\n2. If you've added code that should be tested, add tests.\n3. If you've changed APIs, update the documentation.\n4. Ensure the test suite passes.\n5. Make sure your code lints.\n6. If you haven't already, complete the Contributor License Agreement (\"CLA\").\n\n## Contributor License Agreement (\"CLA\")\nIn order to accept your pull request, we need you to submit a CLA. You only need\nto do this once to work on any of Facebook's open source projects.\n\nComplete your CLA here: \n\n## Workflow\nZstd uses a branch-based workflow for making changes to the codebase. Typically, zstd\nwill use a new branch per sizable topic. For smaller changes, it is okay to lump multiple\nrelated changes into a branch.\n\nOur contribution process works in three main stages:\n1. Local development\n * Update:\n * Checkout your fork of zstd if you have not already\n ```\n git checkout https://github.com//zstd\n cd zstd\n ```\n * Update your local dev branch\n ```\n git pull https://github.com/facebook/zstd dev\n git push origin dev\n ```\n * Topic and development:\n * Make a new branch on your fork about the topic you're developing for\n ```\n # branch names should be concise but sufficiently informative\n git checkout -b \n git push origin \n ```\n * Make commits and push\n ```\n # make some changes =\n git add -u && git commit -m \n git push origin \n ```\n * Note: run local tests to ensure that your changes didn't break existing functionality\n * Quick check\n ```\n make check\n ```\n * Longer check\n ```\n make test\n ```\n2. Code Review and CI tests\n * Ensure CI tests pass:\n * Before sharing anything to the community, create a pull request in your own fork against the dev branch\n and make sure that all GitHub Actions CI tests pass. See the Continuous Integration section below for more information.\n * Ensure that static analysis passes on your development machine. See the Static Analysis section\n below to see how to do this.\n * Create a pull request:\n * When you are ready to share you changes to the community, create a pull request from your branch\n to facebook:dev. You can do this very easily by clicking 'Create Pull Request' on your fork's home\n page.\n * From there, select the branch where you made changes as your source branch and facebook:dev\n as the destination.\n * Examine the diff presented between the two branches to make sure there is nothing unexpected.\n * Write a good pull request description:\n * While there is no strict template that our contributors follow, we would like them to\n sufficiently summarize and motivate the changes they are proposing. We recommend all pull requests,\n at least indirectly, address the following points.\n * Is this pull request important and why?\n * Is it addressing an issue? If so, what issue? (provide links for convenience please)\n * Is this a new feature? If so, why is it useful and/or necessary?\n * Are there background references and documents that reviewers should be aware of to properly assess this change?\n * Note: make sure to point out any design and architectural decisions that you made and the rationale behind them.\n * Note: if you have been working with a specific user and would like them to review your work, make sure you mention them using (@)\n * Submit the pull request and iterate with feedback.\n3. Merge and Release\n * Getting approval:\n * You will have to iterate on your changes with feedback from other collaborators to reach a point\n where your pull request can be safely merged.\n * To avoid too many comments on style and convention, make sure that you have a\n look at our style section below before creating a pull request.\n * Eventually, someone from the zstd team will approve your pull request and not long after merge it into\n the dev branch.\n * Housekeeping:\n * Most PRs are linked with one or more Github issues. If this is the case for your PR, make sure\n the corresponding issue is mentioned. If your change 'fixes' or completely addresses the\n issue at hand, then please indicate this by requesting that an issue be closed by commenting.\n * Just because your changes have been merged does not mean the topic or larger issue is complete. Remember\n that the change must make it to an official zstd release for it to be meaningful. We recommend\n that contributors track the activity on their pull request and corresponding issue(s) page(s) until\n their change makes it to the next release of zstd. Users will often discover bugs in your code or\n suggest ways to refine and improve your initial changes even after the pull request is merged.\n\n## Static Analysis\nStatic analysis is a process for examining the correctness or validity of a program without actually\nexecuting it. It usually helps us find many simple bugs. Zstd uses clang's `scan-build` tool for\nstatic analysis. You can install it by following the instructions for your OS on https://clang-analyzer.llvm.org/scan-build.\n\nOnce installed, you can ensure that our static analysis tests pass on your local development machine\nby running:\n```\nmake staticAnalyze\n```\n\nIn general, you can use `scan-build` to static analyze any build script. For example, to static analyze\njust `contrib/largeNbDicts` and nothing else, you can run:\n\n```\nscan-build make -C contrib/largeNbDicts largeNbDicts\n```\n\n### Pitfalls of static analysis\n`scan-build` is part of our regular CI suite. Other static analyzers are not.\n\nIt can be useful to look at additional static analyzers once in a while (and we do), but it's not a good idea to multiply the nb of analyzers run continuously at each commit and PR. The reasons are :\n\n- Static analyzers are full of false positive. The signal to noise ratio is actually pretty low.\n- A good CI policy is \"zero-warning tolerance\". That means that all issues must be solved, including false positives. This quickly becomes a tedious workload.\n- Multiple static analyzers will feature multiple kind of false positives, sometimes applying to the same code but in different ways leading to :\n + tortuous code, trying to please multiple constraints, hurting readability and therefore maintenance. Sometimes, such complexity introduce other more subtle bugs, that are just out of scope of the analyzers.\n + sometimes, these constraints are mutually exclusive : if one try to solve one, the other static analyzer will complain, they can't be both happy at the same time.\n- As if that was not enough, the list of false positives change with each version. It's hard enough to follow one static analyzer, but multiple ones with their own update agenda, this quickly becomes a massive velocity reducer.\n\nThis is different from running a static analyzer once in a while, looking at the output, and __cherry picking__ a few warnings that seem helpful, either because they detected a genuine risk of bug, or because it helps expressing the code in a way which is more readable or more difficult to misuse. These kinds of reports can be useful, and are accepted.\n\n## Continuous Integration\nCI tests run every time a pull request (PR) is created or updated. The exact tests\nthat get run will depend on the destination branch you specify. Some tests take\nlonger to run than others. Currently, our CI is set up to run a short\nseries of tests when creating a PR to the dev branch and a longer series of tests\nwhen creating a PR to the release branch. You can look in the configuration files\nof the respective CI platform for more information on what gets run when.\n\nMost people will just want to create a PR with the destination set to their local dev\nbranch of zstd. You can then find the status of the tests on the PR's page. You can also\nre-run tests and cancel running tests from the PR page or from the respective CI's dashboard.\n\nAlmost all of zstd's CI runs on GitHub Actions (configured at `.github/workflows`), which will automatically run on PRs to your\nown fork. A small number of tests run on other services (e.g. Travis CI, Circle CI, Appveyor).\nThese require work to set up on your local fork, and (at least for Travis CI) cost money.\nTherefore, if the PR on your local fork passes GitHub Actions, feel free to submit a PR\nagainst the main repo.\n\n### Third-party CI\nA small number of tests cannot run on GitHub Actions, or have yet to be migrated.\nFor these, we use a variety of third-party services (listed below). It is not necessary to set\nthese up on your fork in order to contribute to zstd; however, we do link to instructions for those\nwho want earlier signal.\n\n| Service | Purpose | Setup Links | Config Path |\n|-----------|------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------|\n| Travis CI | Used for testing on non-x86 architectures such as PowerPC | https://docs.travis-ci.com/user/tutorial/#to-get-started-with-travis-ci-using-github
https://github.com/marketplace/travis-ci | `.travis.yml` |\n| AppVeyor | Used for some Windows testing (e.g. cygwin, mingw) | https://www.appveyor.com/blog/2018/10/02/github-apps-integration/
https://github.com/marketplace/appveyor | `appveyor.yml` |\n| Cirrus CI | Used for testing on FreeBSD | https://github.com/marketplace/cirrus-ci/ | `.cirrus.yml` |\n| Circle CI | Historically was used to provide faster signal,
but we may be able to migrate these to Github Actions | https://circleci.com/docs/2.0/getting-started/#setting-up-circleci
https://youtu.be/Js3hMUsSZ2c
https://circleci.com/docs/2.0/enable-checks/ | `.circleci/config.yml` |\n\nNote: the instructions linked above mostly cover how to set up a repository with CI from scratch.\nThe general idea should be the same for setting up CI on your fork of zstd, but you may have to\nfollow slightly different steps. In particular, please ignore any instructions related to setting up\nconfig files (since zstd already has configs for each of these services).\n\n## Performance\nPerformance is extremely important for zstd and we only merge pull requests whose performance\nlandscape and corresponding trade-offs have been adequately analyzed, reproduced, and presented.\nThis high bar for performance means that every PR which has the potential to\nimpact performance takes a very long time for us to properly review. That being said, we\nalways welcome contributions to improve performance (or worsen performance for the trade-off of\nsomething else). Please keep the following in mind before submitting a performance related PR:\n\n1. Zstd isn't as old as gzip but it has been around for time now and its evolution is\nvery well documented via past Github issues and pull requests. It may be the case that your\nparticular performance optimization has already been considered in the past. Please take some\ntime to search through old issues and pull requests using keywords specific to your\nwould-be PR. Of course, just because a topic has already been discussed (and perhaps rejected\non some grounds) in the past, doesn't mean it isn't worth bringing up again. But even in that case,\nit will be helpful for you to have context from that topic's history before contributing.\n2. The distinction between noise and actual performance gains can unfortunately be very subtle\nespecially when microbenchmarking extremely small wins or losses. The only remedy to getting\nsomething subtle merged is extensive benchmarking. You will be doing us a great favor if you\ntake the time to run extensive, long-duration, and potentially cross-(os, platform, process, etc)\nbenchmarks on your end before submitting a PR. Of course, you will not be able to benchmark\nyour changes on every single processor and os out there (and neither will we) but do that best\nyou can:) We've added some things to think about when benchmarking below in the Benchmarking\nPerformance section which might be helpful for you.\n3. Optimizing performance for a certain OS, processor vendor, compiler, or network system is a perfectly\nlegitimate thing to do as long as it does not harm the overall performance health of Zstd.\nThis is a hard balance to strike but please keep in mind other aspects of Zstd when\nsubmitting changes that are clang-specific, windows-specific, etc.\n\n## Benchmarking Performance\nPerformance microbenchmarking is a tricky subject but also essential for Zstd. We value empirical\ntesting over theoretical speculation. This guide it not perfect but for most scenarios, it\nis a good place to start.\n\n### Stability\nUnfortunately, the most important aspect in being able to benchmark reliably is to have a stable\nbenchmarking machine. A virtual machine, a machine with shared resources, or your laptop\nwill typically not be stable enough to obtain reliable benchmark results. If you can get your\nhands on a desktop, this is usually a better scenario.\n\nOf course, benchmarking can be done on non-hyper-stable machines as well. You will just have to\ndo a little more work to ensure that you are in fact measuring the changes you've made and not\nnoise. Here are some things you can do to make your benchmarks more stable:\n\n1. The most simple thing you can do to drastically improve the stability of your benchmark is\nto run it multiple times and then aggregate the results of those runs. As a general rule of\nthumb, the smaller the change you are trying to measure, the more samples of benchmark runs\nyou will have to aggregate over to get reliable results. Here are some additional things to keep in\nmind when running multiple trials:\n * How you aggregate your samples are important. You might be tempted to use the mean of your\n results. While this is certainly going to be a more stable number than a raw single sample\n benchmark number, you might have more luck by taking the median. The mean is not robust to\n outliers whereas the median is. Better still, you could simply take the fastest speed your\n benchmark achieved on each run since that is likely the fastest your process will be\n capable of running your code. In our experience, this (aggregating by just taking the sample\n with the fastest running time) has been the most stable approach.\n * The more samples you have, the more stable your benchmarks should be. You can verify\n your improved stability by looking at the size of your confidence intervals as you\n increase your sample count. These should get smaller and smaller. Eventually hopefully\n smaller than the performance win you are expecting.\n * Most processors will take some time to get `hot` when running anything. The observations\n you collect during that time period will very different from the true performance number. Having\n a very large number of sample will help alleviate this problem slightly but you can also\n address is directly by simply not including the first `n` iterations of your benchmark in\n your aggregations. You can determine `n` by simply looking at the results from each iteration\n and then hand picking a good threshold after which the variance in results seems to stabilize.\n2. You cannot really get reliable benchmarks if your host machine is simultaneously running\nanother cpu/memory-intensive application in the background. If you are running benchmarks on your\npersonal laptop for instance, you should close all applications (including your code editor and\nbrowser) before running your benchmarks. You might also have invisible background applications\nrunning. You can see what these are by looking at either Activity Monitor on Mac or Task Manager\non Windows. You will get more stable benchmark results of you end those processes as well.\n * If you have multiple cores, you can even run your benchmark on a reserved core to prevent\n pollution from other OS and user processes. There are a number of ways to do this depending\n on your OS:\n * On linux boxes, you have use https://github.com/lpechacek/cpuset.\n * On Windows, you can \"Set Processor Affinity\" using https://www.thewindowsclub.com/processor-affinity-windows\n * On Mac, you can try to use their dedicated affinity API https://developer.apple.com/library/archive/releasenotes/Performance/RN-AffinityAPI/#//apple_ref/doc/uid/TP40006635-CH1-DontLinkElementID_2\n3. To benchmark, you will likely end up writing a separate c/c++ program that will link libzstd.\nDynamically linking your library will introduce some added variation (not a large amount but\ndefinitely some). Statically linking libzstd will be more stable. Static libraries should\nbe enabled by default when building zstd.\n4. Use a profiler with a good high resolution timer. See the section below on profiling for\ndetails on this.\n5. Disable frequency scaling, turbo boost and address space randomization (this will vary by OS)\n6. Try to avoid storage. On some systems you can use tmpfs. Putting the program, inputs and outputs on\ntmpfs avoids touching a real storage system, which can have a pretty big variability.\n\nAlso check our LLVM's guide on benchmarking here: https://llvm.org/docs/Benchmarking.html\n\n### Zstd benchmark\nThe fastest signal you can get regarding your performance changes is via the in-build zstd cli\nbench option. You can run Zstd as you typically would for your scenario using some set of options\nand then additionally also specify the `-b#` option. Doing this will run our benchmarking pipeline\nfor that options you have just provided. If you want to look at the internals of how this\nbenchmarking script works, you can check out programs/benchzstd.c\n\nFor example: say you have made a change that you believe improves the speed of zstd level 1. The\nvery first thing you should use to assess whether you actually achieved any sort of improvement\nis `zstd -b`. You might try to do something like this. Note: you can use the `-i` option to\nspecify a running time for your benchmark in seconds (default is 3 seconds).\nUsually, the longer the running time, the more stable your results will be.\n\n```\n$ git checkout \n$ make && cp zstd zstd-old\n$ git checkout \n$ make && cp zstd zstd-new\n$ zstd-old -i5 -b1 \n 1 : 8990 -> 3992 (2.252), 302.6 MB/s , 626.4 MB/s\n$ zstd-new -i5 -b1 \n 1 : 8990 -> 3992 (2.252), 302.8 MB/s , 628.4 MB/s\n```\n\nUnless your performance win is large enough to be visible despite the intrinsic noise\non your computer, benchzstd alone will likely not be enough to validate the impact of your\nchanges. For example, the results of the example above indicate that effectively nothing\nchanged but there could be a small <3% improvement that the noise on the host machine\nobscured. So unless you see a large performance win (10-15% consistently) using just\nthis method of evaluation will not be sufficient.\n\n### Profiling\nThere are a number of great profilers out there. We're going to briefly mention how you can\nprofile your code using `instruments` on mac, `perf` on linux and `visual studio profiler`\non Windows.\n\nSay you have an idea for a change that you think will provide some good performance gains\nfor level 1 compression on Zstd. Typically this means, you have identified a section of\ncode that you think can be made to run faster.\n\nThe first thing you will want to do is make sure that the piece of code is actually taking up\na notable amount of time to run. It is usually not worth optimizing something which accounts for less than\n0.0001% of the total running time. Luckily, there are tools to help with this.\nProfilers will let you see how much time your code spends inside a particular function.\nIf your target code snippet is only part of a function, it might be worth trying to\nisolate that snippet by moving it to its own function (this is usually not necessary but\nmight be).\n\nMost profilers (including the profilers discussed below) will generate a call graph of\nfunctions for you. Your goal will be to find your function of interest in this call graph\nand then inspect the time spent inside of it. You might also want to look at the annotated\nassembly which most profilers will provide you with.\n\n#### Instruments\nWe will once again consider the scenario where you think you've identified a piece of code\nwhose performance can be improved upon. Follow these steps to profile your code using\nInstruments.\n\n1. Open Instruments\n2. Select `Time Profiler` from the list of standard templates\n3. Close all other applications except for your instruments window and your terminal\n4. Run your benchmarking script from your terminal window\n * You will want a benchmark that runs for at least a few seconds (5 seconds will\n usually be long enough). This way the profiler will have something to work with\n and you will have ample time to attach your profiler to this process:)\n * I will just use benchzstd as my benchmarmking script for this example:\n```\n$ zstd -b1 -i5 # this will run for 5 seconds\n```\n5. Once you run your benchmarking script, switch back over to instruments and attach your\nprocess to the time profiler. You can do this by:\n * Clicking on the `All Processes` drop down in the top left of the toolbar.\n * Selecting your process from the dropdown. In my case, it is just going to be labeled\n `zstd`\n * Hitting the bright red record circle button on the top left of the toolbar\n6. You profiler will now start collecting metrics from your benchmarking script. Once\nyou think you have collected enough samples (usually this is the case after 3 seconds of\nrecording), stop your profiler.\n7. Make sure that in toolbar of the bottom window, `profile` is selected.\n8. You should be able to see your call graph.\n * If you don't see the call graph or an incomplete call graph, make sure you have compiled\n zstd and your benchmarking script using debug flags. On mac and linux, this just means\n you will have to supply the `-g` flag alone with your build script. You might also\n have to provide the `-fno-omit-frame-pointer` flag\n9. Dig down the graph to find your function call and then inspect it by double clicking\nthe list item. You will be able to see the annotated source code and the assembly side by\nside.\n\n#### Perf\n\nThis wiki has a pretty detailed tutorial on getting started working with perf so we'll\nleave you to check that out of you're getting started:\n\nhttps://perf.wiki.kernel.org/index.php/Tutorial\n\nSome general notes on perf:\n* Use `perf stat -r # ` to quickly get some relevant timing and\ncounter statistics. Perf uses a high resolution timer and this is likely one\nof the first things your team will run when assessing your PR.\n* Perf has a long list of hardware counters that can be viewed with `perf --list`.\nWhen measuring optimizations, something worth trying is to make sure the hardware\ncounters you expect to be impacted by your change are in fact being so. For example,\nif you expect the L1 cache misses to decrease with your change, you can look at the\ncounter `L1-dcache-load-misses`\n* Perf hardware counters will not work on a virtual machine.\n\n#### Visual Studio\n\nBuild Zstd with symbols first (for example `cmake -B build -S build/cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo && ninja -C build zstd`) so the profiler resolves call stacks.\n\n* Launch Visual Studio’s Performance Profiler (`Alt+F2`), enable CPU Usage (optionally Instrumentation), and point it at the `programs/zstd` benchmark you want to run.\n* If you prefer to start the benchmark from a terminal, use “Attach to running process” to latch onto it mid-run; keep frame pointers (`-fno-omit-frame-pointer`) for clean stacks.\n* When you stop the capture, review the call tree, hot path, and annotated source panes\n* Microsoft’s [Performance Profiling docs](https://learn.microsoft.com/en-us/visualstudio/profiling/?view=vs-2022) cover deeper sampling, ETW, and collection options if required.\n\n## Issues\nWe use GitHub issues to track public bugs. Please ensure your description is\nclear and has sufficient instructions to be able to reproduce the issue.\n\nFacebook has a [bounty program](https://www.facebook.com/whitehat/) for the safe\ndisclosure of security bugs. In those cases, please go through the process\noutlined on that page and do not file a public issue.\n\n## Coding Style\nIt's a pretty long topic, which is difficult to summarize in a single paragraph.\nAs a rule of thumbs, try to imitate the coding style of\nsimilar lines of codes around your contribution.\nThe following is a non-exhaustive list of rules employed in zstd code base:\n\n### C90\nThis code base is following strict C90 standard,\nwith 2 extensions : 64-bit `long long` types, and variadic macros.\nThis rule is applied strictly to code within `lib/` and `programs/`.\nSub-project in `contrib/` are allowed to use other conventions.\n\n### C++ direct compatibility : symbol mangling\nAll public symbol declarations must be wrapped in `extern “C” { … }`,\nso that this project can be compiled as C++98 code,\nand linked into C++ applications.\n\n### Minimal Frugal\nThis design requirement is fundamental to preserve the portability of the code base.\n#### Dependencies\n- Reduce dependencies to the minimum possible level.\n Any dependency should be considered “bad” by default,\n and only tolerated because it provides a service in a better way than can be achieved locally.\n The only external dependencies this repository tolerates are\n standard C libraries, and in rare cases, system level headers.\n- Within `lib/`, this policy is even more drastic.\n The only external dependencies allowed are ``, ``, ``,\n and even then, not directly.\n In particular, no function shall ever allocate on heap directly,\n and must use instead `ZSTD_malloc()` and equivalent.\n Other accepted non-symbol headers are `` and ``.\n- Within the project, there is a strict hierarchy of dependencies that must be respected.\n `programs/` is allowed to depend on `lib/`, but only its public API.\n Within `lib/`, `lib/common` doesn't depend on any other directory.\n `lib/compress` and `lib/decompress` shall not depend on each other.\n `lib/dictBuilder` can depend on `lib/common` and `lib/compress`, but not `lib/decompress`.\n#### Resources\n- Functions in `lib/` must use very little stack space,\n several dozens of bytes max.\n Everything larger must use the heap allocator,\n or require a scratch buffer to be emplaced manually.\n\n### Naming\n* All public symbols are prefixed with `ZSTD_`\n + private symbols, with a scope limited to their own unit, are free of this restriction.\n However, since `libzstd` source code can be amalgamated,\n each symbol name must attempt to be (and remain) unique.\n Avoid too generic names that could become ground for future collisions.\n This generally implies usage of some form of prefix.\n* For symbols (functions and variables), naming convention is `PREFIX_camelCase`.\n + In some advanced cases, one can also find :\n - `PREFIX_prefix2_camelCase`\n - `PREFIX_camelCase_extendedQualifier`\n* Multi-words names generally consist of an action followed by object:\n - for example : `ZSTD_createCCtx()`\n* Prefer positive actions\n - `goBackward` rather than `notGoForward`\n* Type names (`struct`, etc.) follow similar convention,\n except that they are allowed and even invited to start by an Uppercase letter.\n Example : `ZSTD_CCtx`, `ZSTD_CDict`\n* Macro names are all Capital letters.\n The same composition rules (`PREFIX_NAME_QUALIFIER`) apply.\n* File names are all lowercase letters.\n The convention is `snake_case`.\n File names **must** be unique across the entire code base,\n even when they stand in clearly separated directories.\n\n### Qualifiers\n* This code base is `const` friendly, if not `const` fanatical.\n Any variable that can be `const` (aka. read-only) **must** be `const`.\n Any pointer which content will not be modified must be `const`.\n This property is then controlled at compiler level.\n `const` variables are an important signal to readers that this variable isn't modified.\n Conversely, non-const variables are a signal to readers to watch out for modifications later on in the function.\n* If a function must be inlined, mention it explicitly,\n using project's own portable macros, such as `FORCE_INLINE_ATTR`,\n defined in `lib/common/compiler.h`.\n\n### Debugging\n* **Assertions** are welcome, and should be used very liberally,\n to control any condition the code expects for its correct execution.\n These assertion checks will be run in debug builds, and disabled in production.\n* For traces, this project provides its own debug macros,\n in particular `DEBUGLOG(level, ...)`, defined in `lib/common/debug.h`.\n\n### Code documentation\n* Avoid code documentation that merely repeats what the code is already stating.\n Whenever applicable, prefer employing the code as the primary way to convey explanations.\n Example 1 : `int nbTokens = n;` instead of `int i = n; /* i is a nb of tokens *./`.\n Example 2 : `assert(size > 0);` instead of `/* here, size should be positive */`.\n* At declaration level, the documentation explains how to use the function or variable\n and when applicable why it's needed, of the scenarios where it can be useful.\n* At implementation level, the documentation explains the general outline of the algorithm employed,\n and when applicable why this specific choice was preferred.\n\n### General layout\n* 4 spaces for indentation rather than tabs\n* Code documentation shall directly precede function declaration or implementation\n* Function implementations and its code documentation should be preceded and followed by an empty line\n\n\n## License\nBy contributing to Zstandard, you agree that your contributions will be licensed\nunder both the [LICENSE](LICENSE) file and the [COPYING](COPYING) file in the root directory of this source tree.\n" }, { "path": "COPYING", "content": " GNU GENERAL PUBLIC LICENSE\n Version 2, June 1991\n\n Copyright (C) 1989, 1991 Free Software Foundation, Inc.,\n 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n Preamble\n\n The licenses for most software are designed to take away your\nfreedom to share and change it. By contrast, the GNU General Public\nLicense is intended to guarantee your freedom to share and change free\nsoftware--to make sure the software is free for all its users. This\nGeneral Public License applies to most of the Free Software\nFoundation's software and to any other program whose authors commit to\nusing it. (Some other Free Software Foundation software is covered by\nthe GNU Lesser General Public License instead.) You can apply it to\nyour programs, too.\n\n When we speak of free software, we are referring to freedom, not\nprice. Our General Public Licenses are designed to make sure that you\nhave the freedom to distribute copies of free software (and charge for\nthis service if you wish), that you receive source code or can get it\nif you want it, that you can change the software or use pieces of it\nin new free programs; and that you know you can do these things.\n\n To protect your rights, we need to make restrictions that forbid\nanyone to deny you these rights or to ask you to surrender the rights.\nThese restrictions translate to certain responsibilities for you if you\ndistribute copies of the software, or if you modify it.\n\n For example, if you distribute copies of such a program, whether\ngratis or for a fee, you must give the recipients all the rights that\nyou have. You must make sure that they, too, receive or can get the\nsource code. And you must show them these terms so they know their\nrights.\n\n We protect your rights with two steps: (1) copyright the software, and\n(2) offer you this license which gives you legal permission to copy,\ndistribute and/or modify the software.\n\n Also, for each author's protection and ours, we want to make certain\nthat everyone understands that there is no warranty for this free\nsoftware. If the software is modified by someone else and passed on, we\nwant its recipients to know that what they have is not the original, so\nthat any problems introduced by others will not reflect on the original\nauthors' reputations.\n\n Finally, any free program is threatened constantly by software\npatents. We wish to avoid the danger that redistributors of a free\nprogram will individually obtain patent licenses, in effect making the\nprogram proprietary. To prevent this, we have made it clear that any\npatent must be licensed for everyone's free use or not licensed at all.\n\n The precise terms and conditions for copying, distribution and\nmodification follow.\n\n GNU GENERAL PUBLIC LICENSE\n TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n 0. This License applies to any program or other work which contains\na notice placed by the copyright holder saying it may be distributed\nunder the terms of this General Public License. The \"Program\", below,\nrefers to any such program or work, and a \"work based on the Program\"\nmeans either the Program or any derivative work under copyright law:\nthat is to say, a work containing the Program or a portion of it,\neither verbatim or with modifications and/or translated into another\nlanguage. (Hereinafter, translation is included without limitation in\nthe term \"modification\".) Each licensee is addressed as \"you\".\n\nActivities other than copying, distribution and modification are not\ncovered by this License; they are outside its scope. The act of\nrunning the Program is not restricted, and the output from the Program\nis covered only if its contents constitute a work based on the\nProgram (independent of having been made by running the Program).\nWhether that is true depends on what the Program does.\n\n 1. You may copy and distribute verbatim copies of the Program's\nsource code as you receive it, in any medium, provided that you\nconspicuously and appropriately publish on each copy an appropriate\ncopyright notice and disclaimer of warranty; keep intact all the\nnotices that refer to this License and to the absence of any warranty;\nand give any other recipients of the Program a copy of this License\nalong with the Program.\n\nYou may charge a fee for the physical act of transferring a copy, and\nyou may at your option offer warranty protection in exchange for a fee.\n\n 2. You may modify your copy or copies of the Program or any portion\nof it, thus forming a work based on the Program, and copy and\ndistribute such modifications or work under the terms of Section 1\nabove, provided that you also meet all of these conditions:\n\n a) You must cause the modified files to carry prominent notices\n stating that you changed the files and the date of any change.\n\n b) You must cause any work that you distribute or publish, that in\n whole or in part contains or is derived from the Program or any\n part thereof, to be licensed as a whole at no charge to all third\n parties under the terms of this License.\n\n c) If the modified program normally reads commands interactively\n when run, you must cause it, when started running for such\n interactive use in the most ordinary way, to print or display an\n announcement including an appropriate copyright notice and a\n notice that there is no warranty (or else, saying that you provide\n a warranty) and that users may redistribute the program under\n these conditions, and telling the user how to view a copy of this\n License. (Exception: if the Program itself is interactive but\n does not normally print such an announcement, your work based on\n the Program is not required to print an announcement.)\n\nThese requirements apply to the modified work as a whole. If\nidentifiable sections of that work are not derived from the Program,\nand can be reasonably considered independent and separate works in\nthemselves, then this License, and its terms, do not apply to those\nsections when you distribute them as separate works. But when you\ndistribute the same sections as part of a whole which is a work based\non the Program, the distribution of the whole must be on the terms of\nthis License, whose permissions for other licensees extend to the\nentire whole, and thus to each and every part regardless of who wrote it.\n\nThus, it is not the intent of this section to claim rights or contest\nyour rights to work written entirely by you; rather, the intent is to\nexercise the right to control the distribution of derivative or\ncollective works based on the Program.\n\nIn addition, mere aggregation of another work not based on the Program\nwith the Program (or with a work based on the Program) on a volume of\na storage or distribution medium does not bring the other work under\nthe scope of this License.\n\n 3. You may copy and distribute the Program (or a work based on it,\nunder Section 2) in object code or executable form under the terms of\nSections 1 and 2 above provided that you also do one of the following:\n\n a) Accompany it with the complete corresponding machine-readable\n source code, which must be distributed under the terms of Sections\n 1 and 2 above on a medium customarily used for software interchange; or,\n\n b) Accompany it with a written offer, valid for at least three\n years, to give any third party, for a charge no more than your\n cost of physically performing source distribution, a complete\n machine-readable copy of the corresponding source code, to be\n distributed under the terms of Sections 1 and 2 above on a medium\n customarily used for software interchange; or,\n\n c) Accompany it with the information you received as to the offer\n to distribute corresponding source code. (This alternative is\n allowed only for noncommercial distribution and only if you\n received the program in object code or executable form with such\n an offer, in accord with Subsection b above.)\n\nThe source code for a work means the preferred form of the work for\nmaking modifications to it. For an executable work, complete source\ncode means all the source code for all modules it contains, plus any\nassociated interface definition files, plus the scripts used to\ncontrol compilation and installation of the executable. However, as a\nspecial exception, the source code distributed need not include\nanything that is normally distributed (in either source or binary\nform) with the major components (compiler, kernel, and so on) of the\noperating system on which the executable runs, unless that component\nitself accompanies the executable.\n\nIf distribution of executable or object code is made by offering\naccess to copy from a designated place, then offering equivalent\naccess to copy the source code from the same place counts as\ndistribution of the source code, even though third parties are not\ncompelled to copy the source along with the object code.\n\n 4. You may not copy, modify, sublicense, or distribute the Program\nexcept as expressly provided under this License. Any attempt\notherwise to copy, modify, sublicense or distribute the Program is\nvoid, and will automatically terminate your rights under this License.\nHowever, parties who have received copies, or rights, from you under\nthis License will not have their licenses terminated so long as such\nparties remain in full compliance.\n\n 5. You are not required to accept this License, since you have not\nsigned it. However, nothing else grants you permission to modify or\ndistribute the Program or its derivative works. These actions are\nprohibited by law if you do not accept this License. Therefore, by\nmodifying or distributing the Program (or any work based on the\nProgram), you indicate your acceptance of this License to do so, and\nall its terms and conditions for copying, distributing or modifying\nthe Program or works based on it.\n\n 6. Each time you redistribute the Program (or any work based on the\nProgram), the recipient automatically receives a license from the\noriginal licensor to copy, distribute or modify the Program subject to\nthese terms and conditions. You may not impose any further\nrestrictions on the recipients' exercise of the rights granted herein.\nYou are not responsible for enforcing compliance by third parties to\nthis License.\n\n 7. If, as a consequence of a court judgment or allegation of patent\ninfringement or for any other reason (not limited to patent issues),\nconditions are imposed on you (whether by court order, agreement or\notherwise) that contradict the conditions of this License, they do not\nexcuse you from the conditions of this License. If you cannot\ndistribute so as to satisfy simultaneously your obligations under this\nLicense and any other pertinent obligations, then as a consequence you\nmay not distribute the Program at all. For example, if a patent\nlicense would not permit royalty-free redistribution of the Program by\nall those who receive copies directly or indirectly through you, then\nthe only way you could satisfy both it and this License would be to\nrefrain entirely from distribution of the Program.\n\nIf any portion of this section is held invalid or unenforceable under\nany particular circumstance, the balance of the section is intended to\napply and the section as a whole is intended to apply in other\ncircumstances.\n\nIt is not the purpose of this section to induce you to infringe any\npatents or other property right claims or to contest validity of any\nsuch claims; this section has the sole purpose of protecting the\nintegrity of the free software distribution system, which is\nimplemented by public license practices. Many people have made\ngenerous contributions to the wide range of software distributed\nthrough that system in reliance on consistent application of that\nsystem; it is up to the author/donor to decide if he or she is willing\nto distribute software through any other system and a licensee cannot\nimpose that choice.\n\nThis section is intended to make thoroughly clear what is believed to\nbe a consequence of the rest of this License.\n\n 8. If the distribution and/or use of the Program is restricted in\ncertain countries either by patents or by copyrighted interfaces, the\noriginal copyright holder who places the Program under this License\nmay add an explicit geographical distribution limitation excluding\nthose countries, so that distribution is permitted only in or among\ncountries not thus excluded. In such case, this License incorporates\nthe limitation as if written in the body of this License.\n\n 9. The Free Software Foundation may publish revised and/or new versions\nof the General Public License from time to time. Such new versions will\nbe similar in spirit to the present version, but may differ in detail to\naddress new problems or concerns.\n\nEach version is given a distinguishing version number. If the Program\nspecifies a version number of this License which applies to it and \"any\nlater version\", you have the option of following the terms and conditions\neither of that version or of any later version published by the Free\nSoftware Foundation. If the Program does not specify a version number of\nthis License, you may choose any version ever published by the Free Software\nFoundation.\n\n 10. If you wish to incorporate parts of the Program into other free\nprograms whose distribution conditions are different, write to the author\nto ask for permission. For software which is copyrighted by the Free\nSoftware Foundation, write to the Free Software Foundation; we sometimes\nmake exceptions for this. Our decision will be guided by the two goals\nof preserving the free status of all derivatives of our free software and\nof promoting the sharing and reuse of software generally.\n\n NO WARRANTY\n\n 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\nFOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN\nOTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES\nPROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED\nOR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\nMERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS\nTO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE\nPROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,\nREPAIR OR CORRECTION.\n\n 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\nWILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR\nREDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,\nINCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING\nOUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\nTO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\nYOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\nPROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\nPOSSIBILITY OF SUCH DAMAGES.\n\n END OF TERMS AND CONDITIONS\n\n How to Apply These Terms to Your New Programs\n\n If you develop a new program, and you want it to be of the greatest\npossible use to the public, the best way to achieve this is to make it\nfree software which everyone can redistribute and change under these terms.\n\n To do so, attach the following notices to the program. It is safest\nto attach them to the start of each source file to most effectively\nconvey the exclusion of warranty; and each file should have at least\nthe \"copyright\" line and a pointer to where the full notice is found.\n\n \n Copyright (C) \n\n This program is free software; you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation; either version 2 of the License, or\n (at your option) any later version.\n\n This program is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU General Public License for more details.\n\n You should have received a copy of the GNU General Public License along\n with this program; if not, write to the Free Software Foundation, Inc.,\n 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.\n\nAlso add information on how to contact you by electronic and paper mail.\n\nIf the program is interactive, make it output a short notice like this\nwhen it starts in an interactive mode:\n\n Gnomovision version 69, Copyright (C) year name of author\n Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.\n This is free software, and you are welcome to redistribute it\n under certain conditions; type `show c' for details.\n\nThe hypothetical commands `show w' and `show c' should show the appropriate\nparts of the General Public License. Of course, the commands you use may\nbe called something other than `show w' and `show c'; they could even be\nmouse-clicks or menu items--whatever suits your program.\n\nYou should also get your employer (if you work as a programmer) or your\nschool, if any, to sign a \"copyright disclaimer\" for the program, if\nnecessary. Here is a sample; alter the names:\n\n Yoyodyne, Inc., hereby disclaims all copyright interest in the program\n `Gnomovision' (which makes passes at compilers) written by James Hacker.\n\n , 1 April 1989\n Ty Coon, President of Vice\n\nThis General Public License does not permit incorporating your program into\nproprietary programs. If your program is a subroutine library, you may\nconsider it more useful to permit linking proprietary applications with the\nlibrary. If this is what you want to do, use the GNU Lesser General\nPublic License instead of this License." }, { "path": "LICENSE", "content": "BSD License\n\nFor Zstandard software\n\nCopyright (c) Meta Platforms, Inc. and affiliates. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification,\nare permitted provided that the following conditions are met:\n\n * Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n * Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n * Neither the name Facebook, nor Meta, nor the names of its contributors may\n be used to endorse or promote products derived from this software without\n specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR\nANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON\nANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n" }, { "path": "Makefile", "content": "# ################################################################\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n# All rights reserved.\n#\n# This source code is licensed under both the BSD-style license (found in the\n# LICENSE file in the root directory of this source tree) and the GPLv2 (found\n# in the COPYING file in the root directory of this source tree).\n# You may select, at your option, one of the above-listed licenses.\n# ################################################################\n\n# verbose mode (print commands) on V=1 or VERBOSE=1\nQ = $(if $(filter 1,$(V) $(VERBOSE)),,@)\n\nPRGDIR = programs\nZSTDDIR = lib\nBUILDIR = build\nZWRAPDIR = zlibWrapper\nTESTDIR = tests\nFUZZDIR = $(TESTDIR)/fuzz\n\n# Define nul output\nVOID = /dev/null\n\n# When cross-compiling from linux to windows, you might\n# need to specify this as \"Windows.\" Fedora build fails\n# without it.\n#\n# Note: mingw-w64 build from linux to windows does not\n# fail on other tested distros (ubuntu, debian) even\n# without manually specifying the TARGET_SYSTEM.\nTARGET_SYSTEM ?= $(OS)\nCP ?= cp\n\nifneq (,$(filter Windows%,$(TARGET_SYSTEM)))\n EXT =.exe\nelse\n EXT =\nendif\n\n## default: Build lib-release and zstd-release\n.PHONY: default\ndefault: lib-release zstd-release\n\n.PHONY: all\nall: allmost examples manual contrib\n\n.PHONY: allmost\nallmost: allzstd zlibwrapper\n\n# skip zwrapper, can't build that on alternate architectures without the proper zlib installed\n.PHONY: allzstd\nallzstd: lib\n\t$(Q)$(MAKE) -C $(PRGDIR) all\n\t$(Q)$(MAKE) -C $(TESTDIR) all\n\n.PHONY: all32\nall32:\n\t$(MAKE) -C $(PRGDIR) zstd32\n\t$(MAKE) -C $(TESTDIR) all32\n\n.PHONY: lib lib-release lib-mt lib-nomt\nlib lib-release lib-mt lib-nomt:\n\t$(Q)$(MAKE) -C $(ZSTDDIR) $@\n\n.PHONY: zstd zstd-release\nzstd zstd-release:\n\t$(Q)$(MAKE) -C $(PRGDIR) $@\n\t$(Q)ln -sf $(PRGDIR)/zstd$(EXT) zstd$(EXT)\n\n.PHONY: zstdmt\nzstdmt:\n\t$(Q)$(MAKE) -C $(PRGDIR) $@\n\t$(Q)$(CP) $(PRGDIR)/zstd$(EXT) ./zstdmt$(EXT)\n\n.PHONY: zlibwrapper\nzlibwrapper: lib\n\t$(MAKE) -C $(ZWRAPDIR) all\n\n## test: run long-duration tests\n.PHONY: test\nDEBUGLEVEL ?= 1\ntest: MOREFLAGS += -g -Werror\ntest:\n\tDEBUGLEVEL=$(DEBUGLEVEL) MOREFLAGS=\"$(MOREFLAGS)\" $(MAKE) -j -C $(PRGDIR) allVariants\n\t$(MAKE) -C $(TESTDIR) $@\n\tZSTD=../../programs/zstd $(MAKE) -C doc/educational_decoder $@\n\n## check: run basic tests for `zstd` cli\n.PHONY: check\ncheck:\n\t$(Q)$(MAKE) -C $(TESTDIR) $@\n\n.PHONY: automated_benchmarking\nautomated_benchmarking:\n\t$(MAKE) -C $(TESTDIR) $@\n\n.PHONY: benchmarking\nbenchmarking: automated_benchmarking\n\n## examples: build all examples in `examples/` directory\n.PHONY: examples\nexamples: lib\n\t$(MAKE) -C examples all\n\n## manual: generate API documentation in html format\n.PHONY: manual\nmanual:\n\t$(MAKE) -C contrib/gen_html $@\n\n## man: generate man page\n.PHONY: man\nman:\n\t$(MAKE) -C programs $@\n\n## contrib: build all supported projects in `/contrib` directory\n.PHONY: contrib\ncontrib: lib\n\t$(MAKE) -C contrib/pzstd all\n\t$(MAKE) -C contrib/seekable_format/examples all\n\t$(MAKE) -C contrib/seekable_format/tests test\n\t$(MAKE) -C contrib/largeNbDicts all\n\t$(MAKE) -C contrib/externalSequenceProducer all\n\tcd build/single_file_libs/ ; ./build_decoder_test.sh\n\tcd build/single_file_libs/ ; ./build_library_test.sh\n\n.PHONY: cleanTabs\ncleanTabs:\n\tcd contrib; ./cleanTabs\n\n.PHONY: clean\nclean:\n\t$(Q)$(MAKE) -C $(ZSTDDIR) $@ > $(VOID)\n\t$(Q)$(MAKE) -C $(PRGDIR) $@ > $(VOID)\n\t$(Q)$(MAKE) -C $(TESTDIR) $@ > $(VOID)\n\t$(Q)$(MAKE) -C $(ZWRAPDIR) $@ > $(VOID)\n\t$(Q)$(MAKE) -C examples/ $@ > $(VOID)\n\t$(Q)$(MAKE) -C contrib/gen_html $@ > $(VOID)\n\t$(Q)$(MAKE) -C contrib/pzstd $@ > $(VOID)\n\t$(Q)$(MAKE) -C contrib/seekable_format/examples $@ > $(VOID)\n\t$(Q)$(MAKE) -C contrib/seekable_format/tests $@ > $(VOID)\n\t$(Q)$(MAKE) -C contrib/largeNbDicts $@ > $(VOID)\n\t$(Q)$(MAKE) -C contrib/externalSequenceProducer $@ > $(VOID)\n\t$(Q)$(RM) zstd$(EXT) zstdmt$(EXT) tmp*\n\t$(Q)$(RM) -r lz4 cmakebuild mesonbuild install\n\t@echo Cleaning completed\n\nLIBZSTD_MK_DIR = $(ZSTDDIR)\ninclude $(LIBZSTD_MK_DIR)/install_oses.mk # UNAME, INSTALL_OS_LIST\n\n#------------------------------------------------------------------------------\n# make install is validated only for Linux, macOS, Hurd and some BSD targets\n#------------------------------------------------------------------------------\nifneq (,$(filter $(INSTALL_OS_LIST),$(UNAME)))\n\nHOST_OS = POSIX\n\nMKDIR ?= mkdir -p\n\nHAVE_COLORNEVER = $(shell echo a | egrep --color=never a > /dev/null 2> /dev/null && echo 1 || echo 0)\nEGREP_OPTIONS ?=\nifeq ($(HAVE_COLORNEVER), 1)\nEGREP_OPTIONS += --color=never\nendif\nEGREP = egrep $(EGREP_OPTIONS)\n\n# Print a two column output of targets and their description. To add a target description, put a\n# comment in the Makefile with the format \"## : \". For example:\n#\n## list: Print all targets and their descriptions (if provided)\n.PHONY: list\nlist:\n\t$(Q)TARGETS=$$($(MAKE) -pRrq -f $(lastword $(MAKEFILE_LIST)) : 2>/dev/null \\\n\t\t| awk -v RS= -F: '/^# File/,/^# Finished Make data base/ {if ($$1 !~ \"^[#.]\") {print $$1}}' \\\n\t\t| $(EGREP) -v -e '^[^[:alnum:]]' | sort); \\\n\t{ \\\n\t printf \"Target Name\\tDescription\\n\"; \\\n\t printf \"%0.s-\" {1..16}; printf \"\\t\"; printf \"%0.s-\" {1..40}; printf \"\\n\"; \\\n\t for target in $$TARGETS; do \\\n\t line=$$($(EGREP) \"^##[[:space:]]+$$target:\" $(lastword $(MAKEFILE_LIST))); \\\n\t description=$$(echo $$line | awk '{i=index($$0,\":\"); print substr($$0,i+1)}' | xargs); \\\n\t printf \"$$target\\t$$description\\n\"; \\\n\t done \\\n\t} | column -t -s $$'\\t'\n\n.PHONY: install armtest usan asan uasan msan asan32\ninstall:\n\t$(Q)$(MAKE) -C $(ZSTDDIR) $@\n\t$(Q)$(MAKE) -C $(PRGDIR) $@\n\n.PHONY: uninstall\nuninstall:\n\t$(Q)$(MAKE) -C $(ZSTDDIR) $@\n\t$(Q)$(MAKE) -C $(PRGDIR) $@\n\n.PHONY: travis-install\ntravis-install:\n\t$(MAKE) install PREFIX=~/install_test_dir\n\n.PHONY: clangbuild-darwin-fat\nclangbuild-darwin-fat: clean\n\tclang -v\n\tCXX=clang++ CC=clang CFLAGS+=\"-Werror -Wconversion -Wno-sign-conversion -Wdocumentation -arch arm64\" $(MAKE) zstd-release\n\tmv programs/zstd programs/zstd_arm64\n\tCXX=clang++ CC=clang CFLAGS+=\"-Werror -Wconversion -Wno-sign-conversion -Wdocumentation -arch x86_64\" $(MAKE) zstd-release\n\tmv programs/zstd programs/zstd_x64\n\tlipo -create programs/zstd_x64 programs/zstd_arm64 -output programs/zstd\n\n.PHONY: gcc5build gcc6build gcc7build clangbuild m32build armbuild aarch64build ppcbuild ppc64build\ngcc5build: clean\n\tgcc-5 -v\n\tCC=gcc-5 $(MAKE) all MOREFLAGS=\"-Werror $(MOREFLAGS)\"\n\ngcc6build: clean\n\tgcc-6 -v\n\tCC=gcc-6 $(MAKE) all MOREFLAGS=\"-Werror $(MOREFLAGS)\"\n\ngcc7build: clean\n\tgcc-7 -v\n\tCC=gcc-7 $(MAKE) all MOREFLAGS=\"-Werror $(MOREFLAGS)\"\n\nclangbuild: clean\n\tclang -v\n\tCXX=clang++ CC=clang CFLAGS=\"-Werror -Wconversion -Wno-sign-conversion -Wdocumentation\" $(MAKE) all\n\nm32build: clean\n\tgcc -v\n\t$(MAKE) all32\n\narmbuild: clean\n\tCC=arm-linux-gnueabi-gcc CFLAGS=\"-Werror\" $(MAKE) allzstd\n\naarch64build: clean\n\tCC=aarch64-linux-gnu-gcc CFLAGS=\"-Werror -O0\" $(MAKE) allzstd\n\nppcbuild: clean\n\tCC=powerpc-linux-gnu-gcc CFLAGS=\"-m32 -Wno-attributes -Werror\" $(MAKE) -j allzstd\n\nppc64build: clean\n\tCC=powerpc-linux-gnu-gcc CFLAGS=\"-m64 -Werror\" $(MAKE) -j allzstd\n\n.PHONY: armfuzz aarch64fuzz ppcfuzz ppc64fuzz\narmfuzz: clean\n\tCC=arm-linux-gnueabi-gcc QEMU_SYS=qemu-arm-static MOREFLAGS=\"-static $(MOREFLAGS)\" FUZZER_FLAGS=\"--no-big-tests $(FUZZER_FLAGS)\" $(MAKE) -C $(TESTDIR) fuzztest\n\naarch64fuzz: clean\n\tld -v\n\tCC=aarch64-linux-gnu-gcc QEMU_SYS=qemu-aarch64-static MOREFLAGS=\"-static $(MOREFLAGS)\" FUZZER_FLAGS=\"--no-big-tests $(FUZZER_FLAGS)\" $(MAKE) -C $(TESTDIR) fuzztest\n\nppcfuzz: clean\n\tCC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc-static MOREFLAGS=\"-static $(MOREFLAGS)\" FUZZER_FLAGS=\"--no-big-tests $(FUZZER_FLAGS)\" $(MAKE) -C $(TESTDIR) fuzztest\n\nppc64fuzz: clean\n\tCC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc64-static MOREFLAGS=\"-m64 -static $(MOREFLAGS)\" FUZZER_FLAGS=\"--no-big-tests $(FUZZER_FLAGS)\" $(MAKE) -C $(TESTDIR) fuzztest\n\n.PHONY: cxxtest gcc5test gcc6test armtest aarch64test ppctest ppc64test\ncxxtest: CXXFLAGS += -Wall -Wextra -Wundef -Wshadow -Wcast-align -Werror\ncxxtest: clean\n\t$(MAKE) -C $(PRGDIR) all CC=\"$(CXX) -Wno-deprecated\" CFLAGS=\"$(CXXFLAGS)\" # adding -Wno-deprecated to avoid clang++ warning on dealing with C files directly\n\ngcc5test: clean\n\tgcc-5 -v\n\t$(MAKE) all CC=gcc-5 MOREFLAGS=\"-Werror $(MOREFLAGS)\"\n\ngcc6test: clean\n\tgcc-6 -v\n\t$(MAKE) all CC=gcc-6 MOREFLAGS=\"-Werror $(MOREFLAGS)\"\n\narmtest: clean\n\t$(MAKE) -C $(TESTDIR) datagen # use native, faster\n\t$(MAKE) -C $(TESTDIR) test CC=arm-linux-gnueabi-gcc QEMU_SYS=qemu-arm-static ZSTDRTTEST= MOREFLAGS=\"-Werror -static $(MOREFLAGS)\" FUZZER_FLAGS=\"--no-big-tests $(FUZZER_FLAGS)\"\n\naarch64test:\n\t$(MAKE) -C $(TESTDIR) datagen # use native, faster\n\t$(MAKE) -C $(TESTDIR) test CC=aarch64-linux-gnu-gcc QEMU_SYS=qemu-aarch64-static ZSTDRTTEST= MOREFLAGS=\"-Werror -static $(MOREFLAGS)\" FUZZER_FLAGS=\"--no-big-tests $(FUZZER_FLAGS)\"\n\nppctest: clean\n\t$(MAKE) -C $(TESTDIR) datagen # use native, faster\n\t$(MAKE) -C $(TESTDIR) test CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc-static ZSTDRTTEST= MOREFLAGS=\"-Werror -Wno-attributes -static $(MOREFLAGS)\" FUZZER_FLAGS=\"--no-big-tests $(FUZZER_FLAGS)\"\n\nppc64test: clean\n\t$(MAKE) -C $(TESTDIR) datagen # use native, faster\n\t$(MAKE) -C $(TESTDIR) test CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc64-static ZSTDRTTEST= MOREFLAGS=\"-m64 -static $(MOREFLAGS)\" FUZZER_FLAGS=\"--no-big-tests $(FUZZER_FLAGS)\"\n\n.PHONY: arm-ppc-compilation\narm-ppc-compilation:\n\t$(MAKE) -C $(PRGDIR) clean zstd CC=arm-linux-gnueabi-gcc QEMU_SYS=qemu-arm-static ZSTDRTTEST= MOREFLAGS=\"-Werror -static $(MOREFLAGS)\"\n\t$(MAKE) -C $(PRGDIR) clean zstd CC=aarch64-linux-gnu-gcc QEMU_SYS=qemu-aarch64-static ZSTDRTTEST= MOREFLAGS=\"-Werror -static $(MOREFLAGS)\"\n\t$(MAKE) -C $(PRGDIR) clean zstd CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc-static ZSTDRTTEST= MOREFLAGS=\"-Werror -Wno-attributes -static $(MOREFLAGS)\"\n\t$(MAKE) -C $(PRGDIR) clean zstd CC=powerpc-linux-gnu-gcc QEMU_SYS=qemu-ppc64-static ZSTDRTTEST= MOREFLAGS=\"-m64 -static $(MOREFLAGS)\"\n\nregressiontest:\n\t$(MAKE) -C $(FUZZDIR) regressiontest\n\nuasanregressiontest:\n\t$(MAKE) -C $(FUZZDIR) regressiontest CC=clang CXX=clang++ CFLAGS=\"-O3 -fsanitize=address,undefined -Werror\" CXXFLAGS=\"-O3 -fsanitize=address,undefined -Werror\"\n\nmsanregressiontest:\n\t$(MAKE) -C $(FUZZDIR) regressiontest CC=clang CXX=clang++ CFLAGS=\"-O3 -fsanitize=memory -Werror\" CXXFLAGS=\"-O3 -fsanitize=memory -Werror\"\n\nupdate_regressionResults : REGRESS_RESULTS_DIR := /tmp/regress_results_dir/\nupdate_regressionResults:\n\t$(MAKE) -j -C programs zstd\n\t$(MAKE) -j -C tests/regression test\n\t$(RM) -r $(REGRESS_RESULTS_DIR)\n\t$(MKDIR) $(REGRESS_RESULTS_DIR)\n\t./tests/regression/test \\\n --cache tests/regression/cache \\\n --output $(REGRESS_RESULTS_DIR)/results.csv \\\n --zstd programs/zstd\n\techo \"Showing results differences\"\n\t! diff tests/regression/results.csv $(REGRESS_RESULTS_DIR)/results.csv\n\techo \"Updating results.csv\"\n\t$(CP) $(REGRESS_RESULTS_DIR)/results.csv tests/regression/results.csv\n\n\n# run UBsan with -fsanitize-recover=pointer-overflow\n# this only works with recent compilers such as gcc 8+\nusan: clean\n\t$(MAKE) test CC=clang MOREFLAGS=\"-g -fno-sanitize-recover=all -fsanitize=undefined -Werror $(MOREFLAGS)\"\n\nasan: clean\n\t$(MAKE) test CC=clang MOREFLAGS=\"-g -fsanitize=address -Werror $(MOREFLAGS)\"\n\nasan-%: clean\n\tLDFLAGS=-fuse-ld=gold MOREFLAGS=\"-g -fno-sanitize-recover=all -fsanitize=address -Werror $(MOREFLAGS)\" $(MAKE) -C $(TESTDIR) $*\n\nmsan: clean\n\t$(MAKE) test CC=clang MOREFLAGS=\"-g -fsanitize=memory -fno-omit-frame-pointer -Werror $(MOREFLAGS)\" HAVE_LZMA=0 # datagen.c fails this test for no obvious reason\n\nmsan-%:\n\t$(MAKE) clean\n\tLDFLAGS=-fuse-ld=gold MOREFLAGS=\"-g -fno-sanitize-recover=all -fsanitize=memory -fno-omit-frame-pointer -Werror $(MOREFLAGS)\" FUZZER_FLAGS=\"--no-big-tests $(FUZZER_FLAGS)\" $(MAKE) -j -C $(TESTDIR) HAVE_LZMA=0 $*\n\nasan32: clean\n\t$(MAKE) -C $(TESTDIR) test32 CC=clang MOREFLAGS=\"-g -fsanitize=address $(MOREFLAGS)\"\n\nuasan: clean\n\t$(MAKE) test CC=clang MOREFLAGS=\"-g -fno-sanitize-recover=all -fsanitize=address,undefined -Werror $(MOREFLAGS)\"\n\nuasan-%: clean\n\tLDFLAGS=-fuse-ld=gold MOREFLAGS=\"-g -fno-sanitize-recover=all -fsanitize=address,undefined -Werror $(MOREFLAGS)\" $(MAKE) -C $(TESTDIR) $*\n\ntsan-%: clean\n\tLDFLAGS=-fuse-ld=gold MOREFLAGS=\"-g -fno-sanitize-recover=all -fsanitize=thread -Werror $(MOREFLAGS)\" $(MAKE) -C $(TESTDIR) $* FUZZER_FLAGS=\"--no-big-tests $(FUZZER_FLAGS)\"\n\n.PHONY: apt-install\napt-install:\n\t# TODO: uncomment once issue 3011 is resolved and remove hack from Github Actions .yml\n\t# sudo apt-get update\n\tsudo apt-get -yq --no-install-suggests --no-install-recommends --force-yes install $(APT_PACKAGES)\n\n.PHONY: apt-add-repo\napt-add-repo:\n\tsudo add-apt-repository -y ppa:ubuntu-toolchain-r/test\n\tsudo apt-get update -y -qq\n\n.PHONY: ppcinstall arminstall valgrindinstall libc6install gcc6install gcc7install gcc8install gpp6install clang38install\nppcinstall:\n\tAPT_PACKAGES=\"qemu-system-ppc qemu-user-static gcc-powerpc-linux-gnu\" $(MAKE) apt-install\n\narminstall:\n\tAPT_PACKAGES=\"qemu-system-arm qemu-user-static gcc-arm-linux-gnueabi libc6-dev-armel-cross gcc-aarch64-linux-gnu libc6-dev-arm64-cross\" $(MAKE) apt-install\n\nvalgrindinstall:\n\tAPT_PACKAGES=\"valgrind\" $(MAKE) apt-install\n\nlibc6install:\n\tAPT_PACKAGES=\"libc6-dev-i386 gcc-multilib\" $(MAKE) apt-install\n\ngcc6install: apt-add-repo\n\tAPT_PACKAGES=\"libc6-dev-i386 gcc-multilib gcc-6 gcc-6-multilib\" $(MAKE) apt-install\n\ngcc7install: apt-add-repo\n\tAPT_PACKAGES=\"libc6-dev-i386 gcc-multilib gcc-7 gcc-7-multilib\" $(MAKE) apt-install\n\ngcc8install: apt-add-repo\n\tAPT_PACKAGES=\"libc6-dev-i386 gcc-multilib gcc-8 gcc-8-multilib\" $(MAKE) apt-install\n\ngpp6install: apt-add-repo\n\tAPT_PACKAGES=\"libc6-dev-i386 g++-multilib gcc-6 g++-6 g++-6-multilib\" $(MAKE) apt-install\n\nclang38install:\n\tAPT_PACKAGES=\"clang-3.8\" $(MAKE) apt-install\n\nendif\n\n\nifneq (,$(filter MSYS%,$(shell sh -c 'MSYSTEM=\"MSYS\" uname') ))\nHOST_OS = MSYS\nendif\n\n#------------------------------------------------------------------------\n# target specific tests\n#------------------------------------------------------------------------\nifneq (,$(filter MSYS POSIX,$(HOST_OS)))\n\nCMAKE ?= cmake\nCMAKE_PARAMS = -DZSTD_BUILD_CONTRIB:BOOL=ON -DZSTD_BUILD_STATIC:BOOL=ON -DZSTD_BUILD_TESTS:BOOL=ON -DZSTD_ZLIB_SUPPORT:BOOL=ON -DZSTD_LZMA_SUPPORT:BOOL=ON\n\nifneq (,$(filter MSYS%,$(shell sh -c 'MSYSTEM=\"MSYS\" uname')))\nCMAKE_PARAMS = -G\"MSYS Makefiles\" -DZSTD_MULTITHREAD_SUPPORT:BOOL=OFF -DZSTD_BUILD_STATIC:BOOL=ON -DZSTD_BUILD_TESTS:BOOL=ON\nendif\n\n.PHONY: cmakebuild\ncmakebuild:\n\t$(CMAKE) --version\n\t$(RM) -r cmakebuild install\n\t$(MKDIR) cmakebuild install\n\tcd cmakebuild; $(CMAKE) -Wdev -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_FLAGS=\"-Werror -O0\" -DCMAKE_INSTALL_PREFIX=install $(CMAKE_PARAMS) ../build/cmake\n\t$(CMAKE) --build cmakebuild --target install -- -j V=1\n\tcd cmakebuild; ctest -V -L Medium\n\nMESON ?= meson\nNINJA ?= ninja\n\n.PHONY: mesonbuild\nmesonbuild:\n\t$(MESON) setup \\\n\t\t--buildtype=debugoptimized \\\n\t\t-Db_lundef=false \\\n\t\t-Dauto_features=enabled \\\n\t\t-Dbin_programs=true \\\n\t\t-Dbin_tests=true \\\n\t\t-Dbin_contrib=true \\\n\t\t-Ddefault_library=both \\\n\t\tbuild/meson mesonbuild\n\t$(NINJA) -C mesonbuild/\n\t$(MESON) test -C mesonbuild/ --print-errorlogs\n\t$(MESON) install -C mesonbuild --destdir staging/\n\n.PHONY: c89build gnu90build c99build gnu99build c11build bmix64build bmix32build bmi32build staticAnalyze\nc89build: clean\n\t$(CC) -v\n\tCFLAGS=\"-std=c89 -Werror -Wno-attributes -Wpedantic -Wno-long-long -Wno-variadic-macros -O0\" $(MAKE) lib zstd\n\ngnu90build: clean\n\t$(CC) -v\n\tCFLAGS=\"-std=gnu90 -Werror -O0\" $(MAKE) allmost\n\nc99build: clean\n\t$(CC) -v\n\tCFLAGS=\"-std=c99 -Werror -O0\" $(MAKE) allmost\n\ngnu99build: clean\n\t$(CC) -v\n\tCFLAGS=\"-std=gnu99 -Werror -O0\" $(MAKE) allmost\n\nc11build: clean\n\t$(CC) -v\n\tCFLAGS=\"-std=c11 -Werror -O0\" $(MAKE) allmost\n\nbmix64build: clean\n\t$(CC) -v\n\tCFLAGS=\"-O3 -mbmi -Werror\" $(MAKE) -C $(TESTDIR) test\n\nbmix32build: clean\n\t$(CC) -v\n\tCFLAGS=\"-O3 -mbmi -mx32 -Werror\" $(MAKE) -C $(TESTDIR) test\n\nbmi32build: clean\n\t$(CC) -v\n\tCFLAGS=\"-O3 -mbmi -m32 -Werror\" $(MAKE) -C $(TESTDIR) test\n\n# static analyzer test uses clang's scan-build\n# does not analyze zlibWrapper, due to detected issues in zlib source code\nstaticAnalyze: SCANBUILD ?= scan-build\nstaticAnalyze:\n\t$(CC) -v\n\tCC=$(CC) CPPFLAGS=-g $(SCANBUILD) --status-bugs -v $(MAKE) zstd\nendif\n" }, { "path": "Package.swift", "content": "// swift-tools-version:5.0\n// The swift-tools-version declares the minimum version of Swift required to build this package.\n\nimport PackageDescription\n\nlet package = Package(\n name: \"zstd\",\n platforms: [\n .macOS(.v10_10), .iOS(.v9), .tvOS(.v9)\n ],\n products: [\n // Products define the executables and libraries a package produces, and make them visible to other packages.\n .library(\n name: \"libzstd\",\n targets: [ \"libzstd\" ])\n ],\n dependencies: [\n // Dependencies declare other packages that this package depends on.\n // .package(url: /* package url */, from: \"1.0.0\"),\n ],\n targets: [\n // Targets are the basic building blocks of a package. A target can define a module or a test suite.\n // Targets can depend on other targets in this package, and on products in packages this package depends on.\n .target(\n name: \"libzstd\",\n path: \"lib\",\n sources: [ \"common\", \"compress\", \"decompress\", \"dictBuilder\" ],\n publicHeadersPath: \".\",\n cSettings: [\n .headerSearchPath(\".\")\n ])\n ],\n swiftLanguageVersions: [.v5],\n cLanguageStandard: .gnu11,\n cxxLanguageStandard: .gnucxx14\n)\n" }, { "path": "README.md", "content": "

\"Zstandard\"

\n\n__Zstandard__, or `zstd` as short version, is a fast lossless compression algorithm,\ntargeting real-time compression scenarios at zlib-level and better compression ratios.\nIt's backed by a very fast entropy stage, provided by [Huff0 and FSE library](https://github.com/Cyan4973/FiniteStateEntropy).\n\nZstandard's format is stable and documented in [RFC8878](https://datatracker.ietf.org/doc/html/rfc8878). Multiple independent implementations are already available.\nThis repository represents the reference implementation, provided as an open-source dual [BSD](LICENSE) OR [GPLv2](COPYING) licensed **C** library,\nand a command line utility producing and decoding `.zst`, `.gz`, `.xz` and `.lz4` files.\nShould your project require another programming language,\na list of known ports and bindings is provided on [Zstandard homepage](https://facebook.github.io/zstd/#other-languages).\n\n**Development branch status:**\n\n[![Build Status][travisDevBadge]][travisLink]\n[![Build status][CircleDevBadge]][CircleLink]\n[![Build status][CirrusDevBadge]][CirrusLink]\n[![Fuzzing Status][OSSFuzzBadge]][OSSFuzzLink]\n\n[travisDevBadge]: https://api.travis-ci.com/facebook/zstd.svg?branch=dev \"Continuous Integration test suite\"\n[travisLink]: https://travis-ci.com/facebook/zstd\n[CircleDevBadge]: https://circleci.com/gh/facebook/zstd/tree/dev.svg?style=shield \"Short test suite\"\n[CircleLink]: https://circleci.com/gh/facebook/zstd\n[CirrusDevBadge]: https://api.cirrus-ci.com/github/facebook/zstd.svg?branch=dev\n[CirrusLink]: https://cirrus-ci.com/github/facebook/zstd\n[OSSFuzzBadge]: https://oss-fuzz-build-logs.storage.googleapis.com/badges/zstd.svg\n[OSSFuzzLink]: https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:zstd\n\n## Benchmarks\n\nFor reference, several fast compression algorithms were tested and compared\non a desktop featuring a Core i7-9700K CPU @ 4.9GHz\nand running Ubuntu 24.04 (`Linux 6.8.0-53-generic`),\nusing [lzbench], an open-source in-memory benchmark by @inikep\ncompiled with [gcc] 14.2.0,\non the [Silesia compression corpus].\n\n[lzbench]: https://github.com/inikep/lzbench\n[Silesia compression corpus]: https://sun.aei.polsl.pl//~sdeor/index.php?page=silesia\n[gcc]: https://gcc.gnu.org/\n\n| Compressor name | Ratio | Compression| Decompress.|\n| --------------- | ------| -----------| ---------- |\n| **zstd 1.5.7 -1** | 2.896 | 510 MB/s | 1550 MB/s |\n| brotli 1.1.0 -1 | 2.883 | 290 MB/s | 425 MB/s |\n| [zlib] 1.3.1 -1 | 2.743 | 105 MB/s | 390 MB/s |\n| **zstd 1.5.7 --fast=1** | 2.439 | 545 MB/s | 1850 MB/s |\n| quicklz 1.5.0 -1 | 2.238 | 520 MB/s | 750 MB/s |\n| **zstd 1.5.7 --fast=4** | 2.146 | 665 MB/s | 2050 MB/s |\n| lzo1x 2.10 -1 | 2.106 | 650 MB/s | 780 MB/s |\n| [lz4] 1.10.0 | 2.101 | 675 MB/s | 3850 MB/s |\n| snappy 1.2.1 | 2.089 | 520 MB/s | 1500 MB/s |\n| lzf 3.6 -1 | 2.077 | 410 MB/s | 820 MB/s |\n\n[zlib]: https://www.zlib.net/\n[lz4]: https://lz4.github.io/lz4/\n\nThe negative compression levels, specified with `--fast=#`,\noffer faster compression and decompression speed\nat the cost of compression ratio.\n\nZstd can also offer stronger compression ratios at the cost of compression speed.\nSpeed vs Compression trade-off is configurable by small increments.\nDecompression speed is preserved and remains roughly the same at all settings,\na property shared by most LZ compression algorithms, such as [zlib] or lzma.\n\nThe following tests were run\non a server running Linux Debian (`Linux version 4.14.0-3-amd64`)\nwith a Core i7-6700K CPU @ 4.0GHz,\nusing [lzbench], an open-source in-memory benchmark by @inikep\ncompiled with [gcc] 7.3.0,\non the [Silesia compression corpus].\n\nCompression Speed vs Ratio | Decompression Speed\n---------------------------|--------------------\n![Compression Speed vs Ratio](doc/images/CSpeed2.png \"Compression Speed vs Ratio\") | ![Decompression Speed](doc/images/DSpeed3.png \"Decompression Speed\")\n\nA few other algorithms can produce higher compression ratios at slower speeds, falling outside of the graph.\nFor a larger picture including slow modes, [click on this link](doc/images/DCspeed5.png).\n\n\n## The case for Small Data compression\n\nPrevious charts provide results applicable to typical file and stream scenarios (several MB). Small data comes with different perspectives.\n\nThe smaller the amount of data to compress, the more difficult it is to compress. This problem is common to all compression algorithms, and reason is, compression algorithms learn from past data how to compress future data. But at the beginning of a new data set, there is no \"past\" to build upon.\n\nTo solve this situation, Zstd offers a __training mode__, which can be used to tune the algorithm for a selected type of data.\nTraining Zstandard is achieved by providing it with a few samples (one file per sample). The result of this training is stored in a file called \"dictionary\", which must be loaded before compression and decompression.\nUsing this dictionary, the compression ratio achievable on small data improves dramatically.\n\nThe following example uses the `github-users` [sample set](https://github.com/facebook/zstd/releases/tag/v1.1.3), created from [github public API](https://developer.github.com/v3/users/#get-all-users).\nIt consists of roughly 10K records weighing about 1KB each.\n\nCompression Ratio | Compression Speed | Decompression Speed\n------------------|-------------------|--------------------\n![Compression Ratio](doc/images/dict-cr.png \"Compression Ratio\") | ![Compression Speed](doc/images/dict-cs.png \"Compression Speed\") | ![Decompression Speed](doc/images/dict-ds.png \"Decompression Speed\")\n\n\nThese compression gains are achieved while simultaneously providing _faster_ compression and decompression speeds.\n\nTraining works if there is some correlation in a family of small data samples. The more data-specific a dictionary is, the more efficient it is (there is no _universal dictionary_).\nHence, deploying one dictionary per type of data will provide the greatest benefits.\nDictionary gains are mostly effective in the first few KB. Then, the compression algorithm will gradually use previously decoded content to better compress the rest of the file.\n\n### Dictionary compression How To:\n\n1. Create the dictionary\n\n `zstd --train FullPathToTrainingSet/* -o dictionaryName`\n\n2. Compress with dictionary\n\n `zstd -D dictionaryName FILE`\n\n3. Decompress with dictionary\n\n `zstd -D dictionaryName --decompress FILE.zst`\n\n\n## Build instructions\n\n`make` is the main build system of this project.\nIt is the reference, and other build systems are periodically updated to stay compatible.\nHowever, small drifts and feature differences can be present, since perfect synchronization is difficult.\nFor this reason, when your build system allows it, prefer employing `make`.\n\n### Makefile\n\nAssuming your system supports standard `make` (or `gmake`),\njust invoking `make` in root directory generates `zstd` cli at root,\nand also generates `libzstd` into `lib/`.\n\nOther standard targets include:\n- `make install` : install zstd cli, library and man pages\n- `make check` : run `zstd`, test its essential behavior on local platform\n\nThe `Makefile` follows the [GNU Standard Makefile conventions](https://www.gnu.org/prep/standards/html_node/Makefile-Conventions.html),\nallowing staged install, standard compilation flags, directory variables and command variables.\n\nFor advanced use cases, specialized flags which control binary generation and installation paths are documented\nin [`lib/README.md`](lib/README.md#modular-build) for the `libzstd` library\nand in [`programs/README.md`](programs/README.md#compilation-variables) for the `zstd` CLI.\n\n### cmake\n\nA `cmake` project generator is available for generating Makefiles or other build scripts\nto create the `zstd` binary as well as `libzstd` dynamic and static libraries.\nThe repository root now contains a minimal `CMakeLists.txt` that forwards to `build/cmake`,\nso you can configure the project with a standard `cmake -S .` invocation,\nwhile the historical `cmake -S build/cmake` entry point remains fully supported.\n\n```bash\ncmake -S . -B build-cmake\ncmake --build build-cmake\n```\n\nBy default, `CMAKE_BUILD_TYPE` is set to `Release`.\n\n#### Support for Fat (Universal2) Output\n\n`zstd` can be built and installed with support for both Apple Silicon (M1/M2) as well as Intel by using CMake's Universal2 support.\nTo perform a Fat/Universal2 build and install use the following commands:\n\n```bash\ncmake -S . -B build-cmake-debug -G Ninja -DCMAKE_OSX_ARCHITECTURES=\"x86_64;x86_64h;arm64\"\ncd build-cmake-debug\nninja\nsudo ninja install\n```\n\n### Meson\n\nA Meson project is provided within [`build/meson`](build/meson). Follow\nbuild instructions in that directory.\n\nYou can also take a look at [`.travis.yml`](.travis.yml) file for an\nexample about how Meson is used to build this project.\n\nNote that default build type is **release**.\n\n### VCPKG\nYou can build and install zstd [vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager:\n\n git clone https://github.com/Microsoft/vcpkg.git\n cd vcpkg\n ./bootstrap-vcpkg.sh\n ./vcpkg integrate install\n ./vcpkg install zstd\n\nThe zstd port in vcpkg is kept up to date by Microsoft team members and community contributors.\nIf the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.\n\n### Conan\n\nYou can install pre-built binaries for zstd or build it from source using [Conan](https://conan.io/). Use the following command:\n\n```bash\nconan install --requires=\"zstd/[*]\" --build=missing\n```\n\nThe zstd Conan recipe is kept up to date by Conan maintainers and community contributors.\nIf the version is out of date, please [create an issue or pull request](https://github.com/conan-io/conan-center-index) on the ConanCenterIndex repository.\n\n### Visual Studio (Windows)\n\nGoing into `build` directory, you will find additional possibilities:\n- Projects for Visual Studio 2008 and 2010.\n + VS2010 project is compatible with VS2012, VS2013, VS2015 and VS2017.\n- Automated build scripts for Visual compiler by [@KrzysFR](https://github.com/KrzysFR), in `build/VS_scripts`,\n which will build `zstd` cli and `libzstd` library without any need to open Visual Studio solution.\n- It is now recommended to generate Visual Studio solutions from `cmake`\n\n### Buck\n\nYou can build the zstd binary via buck by executing: `buck build programs:zstd` from the root of the repo.\nThe output binary will be in `buck-out/gen/programs/`.\n\n### Bazel\n\nYou can integrate zstd into your Bazel project by using the module hosted on the [Bazel Central Repository](https://registry.bazel.build/modules/zstd).\n\n## Testing\n\nYou can run quick local smoke tests by running `make check`.\nIf you can't use `make`, execute the `playTest.sh` script from the `src/tests` directory.\nTwo env variables `$ZSTD_BIN` and `$DATAGEN_BIN` are needed for the test script to locate the `zstd` and `datagen` binary.\nFor information on CI testing, please refer to `TESTING.md`.\n\n## Status\n\nZstandard is deployed within Meta and many other large cloud infrastructures,\nto compress humongous amounts of data in various formats and use cases.\nIt is also continuously fuzzed for security issues by Google's [oss-fuzz](https://github.com/google/oss-fuzz/tree/master/projects/zstd) program.\n\n## License\n\nZstandard is dual-licensed under [BSD](LICENSE) OR [GPLv2](COPYING).\n\n## Contributing\n\nThe `dev` branch is the one where all contributions are merged before reaching `release`.\nDirect commit to `release` are not permitted.\nFor more information, please read [CONTRIBUTING](CONTRIBUTING.md).\n" }, { "path": "SECURITY.md", "content": "# Reporting and Fixing Security Issues\n\nPlease do not open GitHub issues or pull requests - this makes the problem immediately visible to everyone, including malicious actors. Security issues in this open source project can be safely reported via the Meta Bug Bounty program:\n\nhttps://www.facebook.com/whitehat\n\nMeta's security team will triage your report and determine whether or not is it eligible for a bounty under our program.\n\n# Receiving Vulnerability Notifications\n\nIn the case that a significant security vulnerability is reported to us or discovered by us---without being publicly known---we will, at our discretion, notify high-profile, high-exposure users of Zstandard ahead of our public disclosure of the issue and associated fix.\n\nIf you believe your project would benefit from inclusion in this list, please reach out to one of the maintainers.\n\n\n" }, { "path": "TESTING.md", "content": "Testing\n=======\n\nZstandard CI testing is split up into three sections:\nshort, medium, and long tests.\n\nShort Tests\n-----------\nShort tests run on CircleCI for new commits on every branch and pull request.\nThey consist of the following tests:\n- Compilation on all supported targets (x86, x86_64, ARM, AArch64, PowerPC, and PowerPC64)\n- Compilation on various versions of gcc, clang, and g++\n- `tests/playTests.sh` on x86_64, without the tests on long data (CLI tests)\n- Small tests (`tests/legacy.c`, `tests/longmatch.c`) on x64_64\n\nMedium Tests\n------------\nMedium tests run on every commit and pull request to `dev` branch, on TravisCI.\nThey consist of the following tests:\n- The following tests run with UBsan and Asan on x86_64 and x86, as well as with\n Msan on x86_64\n - `tests/playTests.sh --test-large-data`\n - Fuzzer tests: `tests/fuzzer.c`, `tests/zstreamtest.c`, and `tests/decodecorpus.c`\n- `tests/zstreamtest.c` under Tsan (streaming mode, including multithreaded mode)\n- Valgrind Test (`make -C tests test-valgrind`) (testing CLI and fuzzer under `valgrind`)\n- Fuzzer tests (see above) on ARM, AArch64, PowerPC, and PowerPC64\n\nLong Tests\n----------\nLong tests run on all commits to `release` branch,\nand once a day on the current version of `dev` branch,\non TravisCI.\nThey consist of the following tests:\n- Entire test suite (including fuzzers and some other specialized tests) on:\n - x86_64 and x86 with UBsan and Asan\n - x86_64 with Msan\n - ARM, AArch64, PowerPC, and PowerPC64\n- Streaming mode fuzzer with Tsan (for the `zstdmt` testing)\n- ZlibWrapper tests, including under valgrind\n- Versions test (ensuring `zstd` can decode files from all previous versions)\n- `pzstd` with asan and tsan, as well as in 32-bits mode\n- Testing `zstd` with legacy mode off\n- Entire test suite and make install on macOS\n" }, { "path": "contrib/VS2005/README.md", "content": "## Project Support Notice\n\nThe VS2005 Project directory has been moved to the contrib directory in order to indicate that it will no longer be supported.\n" }, { "path": "contrib/VS2005/fullbench/fullbench.vcproj", "content": "\r\n\r\n\t\r\n\t\t\r\n\t\t\r\n\t\r\n\t\r\n\t\r\n\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\r\n\t\r\n\t\r\n\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\r\n\t\r\n\t\r\n\r\n" }, { "path": "contrib/VS2005/fuzzer/fuzzer.vcproj", "content": "\r\n\r\n\t\r\n\t\t\r\n\t\t\r\n\t\r\n\t\r\n\t\r\n\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\r\n\t\r\n\t\r\n\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\r\n\t\r\n\t\r\n\r\n" }, { "path": "contrib/VS2005/zstd/zstd.vcproj", "content": "\r\n\r\n\t\r\n\t\t\r\n\t\t\r\n\t\r\n\t\r\n\t\r\n\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\r\n\t\r\n\t\r\n\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n \r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\r\n\t\r\n\t\r\n\r\n" }, { "path": "contrib/VS2005/zstd.sln", "content": "Microsoft Visual Studio Solution File, Format Version 9.00\r\n# Visual C++ Express 2005\r\nProject(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \"zstd\", \"zstd\\zstd.vcproj\", \"{1A2AB08E-5CE7-4C5B-BE55-458157C14051}\"\r\nEndProject\r\nProject(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \"fuzzer\", \"fuzzer\\fuzzer.vcproj\", \"{A62E89D2-9DDE-42BA-8F9B-9DA74889A6B0}\"\r\nEndProject\r\nProject(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \"fullbench\", \"fullbench\\fullbench.vcproj\", \"{CC8F1D1B-BA2F-43E3-A71F-FA415D81AAD3}\"\r\nEndProject\r\nProject(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \"zstdlib\", \"zstdlib\\zstdlib.vcproj\", \"{99DE2A79-7298-4004-A0ED-030D7A3796CA}\"\r\nEndProject\r\nGlobal\r\n\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\r\n\t\tDebug|Win32 = Debug|Win32\r\n\t\tDebug|x64 = Debug|x64\r\n\t\tRelease|Win32 = Release|Win32\r\n\t\tRelease|x64 = Release|x64\r\n\tEndGlobalSection\r\n\tGlobalSection(ProjectConfigurationPlatforms) = postSolution\r\n\t\t{1A2AB08E-5CE7-4C5B-BE55-458157C14051}.Debug|Win32.ActiveCfg = Debug|Win32\r\n\t\t{1A2AB08E-5CE7-4C5B-BE55-458157C14051}.Debug|Win32.Build.0 = Debug|Win32\r\n\t\t{1A2AB08E-5CE7-4C5B-BE55-458157C14051}.Debug|x64.ActiveCfg = Debug|x64\r\n\t\t{1A2AB08E-5CE7-4C5B-BE55-458157C14051}.Debug|x64.Build.0 = Debug|x64\r\n\t\t{1A2AB08E-5CE7-4C5B-BE55-458157C14051}.Release|Win32.ActiveCfg = Release|Win32\r\n\t\t{1A2AB08E-5CE7-4C5B-BE55-458157C14051}.Release|Win32.Build.0 = Release|Win32\r\n\t\t{1A2AB08E-5CE7-4C5B-BE55-458157C14051}.Release|x64.ActiveCfg = Release|x64\r\n\t\t{1A2AB08E-5CE7-4C5B-BE55-458157C14051}.Release|x64.Build.0 = Release|x64\r\n\t\t{A62E89D2-9DDE-42BA-8F9B-9DA74889A6B0}.Debug|Win32.ActiveCfg = Debug|Win32\r\n\t\t{A62E89D2-9DDE-42BA-8F9B-9DA74889A6B0}.Debug|Win32.Build.0 = Debug|Win32\r\n\t\t{A62E89D2-9DDE-42BA-8F9B-9DA74889A6B0}.Debug|x64.ActiveCfg = Debug|x64\r\n\t\t{A62E89D2-9DDE-42BA-8F9B-9DA74889A6B0}.Debug|x64.Build.0 = Debug|x64\r\n\t\t{A62E89D2-9DDE-42BA-8F9B-9DA74889A6B0}.Release|Win32.ActiveCfg = Release|Win32\r\n\t\t{A62E89D2-9DDE-42BA-8F9B-9DA74889A6B0}.Release|Win32.Build.0 = Release|Win32\r\n\t\t{A62E89D2-9DDE-42BA-8F9B-9DA74889A6B0}.Release|x64.ActiveCfg = Release|x64\r\n\t\t{A62E89D2-9DDE-42BA-8F9B-9DA74889A6B0}.Release|x64.Build.0 = Release|x64\r\n\t\t{CC8F1D1B-BA2F-43E3-A71F-FA415D81AAD3}.Debug|Win32.ActiveCfg = Debug|Win32\r\n\t\t{CC8F1D1B-BA2F-43E3-A71F-FA415D81AAD3}.Debug|Win32.Build.0 = Debug|Win32\r\n\t\t{CC8F1D1B-BA2F-43E3-A71F-FA415D81AAD3}.Debug|x64.ActiveCfg = Debug|x64\r\n\t\t{CC8F1D1B-BA2F-43E3-A71F-FA415D81AAD3}.Debug|x64.Build.0 = Debug|x64\r\n\t\t{CC8F1D1B-BA2F-43E3-A71F-FA415D81AAD3}.Release|Win32.ActiveCfg = Release|Win32\r\n\t\t{CC8F1D1B-BA2F-43E3-A71F-FA415D81AAD3}.Release|Win32.Build.0 = Release|Win32\r\n\t\t{CC8F1D1B-BA2F-43E3-A71F-FA415D81AAD3}.Release|x64.ActiveCfg = Release|x64\r\n\t\t{CC8F1D1B-BA2F-43E3-A71F-FA415D81AAD3}.Release|x64.Build.0 = Release|x64\r\n\t\t{99DE2A79-7298-4004-A0ED-030D7A3796CA}.Debug|Win32.ActiveCfg = Debug|Win32\r\n\t\t{99DE2A79-7298-4004-A0ED-030D7A3796CA}.Debug|Win32.Build.0 = Debug|Win32\r\n\t\t{99DE2A79-7298-4004-A0ED-030D7A3796CA}.Debug|x64.ActiveCfg = Debug|x64\r\n\t\t{99DE2A79-7298-4004-A0ED-030D7A3796CA}.Debug|x64.Build.0 = Debug|x64\r\n\t\t{99DE2A79-7298-4004-A0ED-030D7A3796CA}.Release|Win32.ActiveCfg = Release|Win32\r\n\t\t{99DE2A79-7298-4004-A0ED-030D7A3796CA}.Release|Win32.Build.0 = Release|Win32\r\n\t\t{99DE2A79-7298-4004-A0ED-030D7A3796CA}.Release|x64.ActiveCfg = Release|x64\r\n\t\t{99DE2A79-7298-4004-A0ED-030D7A3796CA}.Release|x64.Build.0 = Release|x64\r\n\tEndGlobalSection\r\n\tGlobalSection(SolutionProperties) = preSolution\r\n\t\tHideSolutionNode = FALSE\r\n\tEndGlobalSection\r\nEndGlobal\r\n" }, { "path": "contrib/VS2005/zstdlib/zstdlib.vcproj", "content": "\r\n\r\n\t\r\n\t\t\r\n\t\t\r\n\t\r\n\t\r\n\t\r\n\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\r\n\t\r\n\t\r\n\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\t\r\n\t\t\r\n\t\t\r\n\t\t\r\n\t\r\n\t\r\n\t\r\n\r\n" }, { "path": "contrib/cleanTabs", "content": "#!/bin/sh\nsed -i '' $'s/\\t/ /g' ../lib/**/*.{h,c} ../programs/*.{h,c} ../tests/*.c ./**/*.{h,cpp} ../examples/*.c ../zlibWrapper/*.{h,c}\n" }, { "path": "contrib/diagnose_corruption/.gitignore", "content": "check_flipped_bits\n" }, { "path": "contrib/diagnose_corruption/Makefile", "content": "# ################################################################\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n# All rights reserved.\n#\n# This source code is licensed under both the BSD-style license (found in the\n# LICENSE file in the root directory of this source tree) and the GPLv2 (found\n# in the COPYING file in the root directory of this source tree).\n# ################################################################\n\n.PHONY: all\nall: check_flipped_bits\n\nZSTDLIBDIR ?= ../../lib\n\nCFLAGS ?= -O3\nCFLAGS += -I$(ZSTDLIBDIR) -I$(ZSTDLIBDIR)/common -I$(ZSTDLIBDIR)/compress \\\n -I$(ZSTDLIBDIR)/decompress\nCFLAGS += -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \\\n -Wstrict-aliasing=1 -Wswitch-enum -Wdeclaration-after-statement \\\n -Wstrict-prototypes -Wundef \\\n -Wvla -Wformat=2 -Winit-self -Wfloat-equal -Wwrite-strings \\\n -Wredundant-decls -Wmissing-prototypes\nCFLAGS += $(DEBUGFLAGS) $(MOREFLAGS)\nFLAGS = $(CPPFLAGS) $(CFLAGS) $(LDFLAGS)\n\n.PHONY: $(ZSTDLIBDIR)/libzstd.a\n$(ZSTDLIBDIR)/libzstd.a:\n\t$(MAKE) -C $(ZSTDLIBDIR) libzstd.a\n\ncheck_flipped_bits: check_flipped_bits.c $(ZSTDLIBDIR)/libzstd.a\n\t$(CC) $(FLAGS) $< -o $@$(EXT) $(ZSTDLIBDIR)/libzstd.a\n\n.PHONY: clean\nclean:\n\trm -f check_flipped_bits\n" }, { "path": "contrib/diagnose_corruption/check_flipped_bits.c", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#define ZSTD_STATIC_LINKING_ONLY\n#include \"zstd.h\"\n#include \"zstd_errors.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n\ntypedef struct {\n char *input;\n size_t input_size;\n\n char *perturbed; /* same size as input */\n\n char *output;\n size_t output_size;\n\n const char *dict_file_name;\n const char *dict_file_dir_name;\n int32_t dict_id;\n char *dict;\n size_t dict_size;\n ZSTD_DDict* ddict;\n\n ZSTD_DCtx* dctx;\n\n int success_count;\n int error_counts[ZSTD_error_maxCode];\n} stuff_t;\n\nstatic void free_stuff(stuff_t* stuff) {\n free(stuff->input);\n free(stuff->output);\n ZSTD_freeDDict(stuff->ddict);\n free(stuff->dict);\n ZSTD_freeDCtx(stuff->dctx);\n}\n\nstatic void usage(void) {\n fprintf(stderr, \"check_flipped_bits input_filename [-d dict] [-D dict_dir]\\n\");\n fprintf(stderr, \"\\n\");\n fprintf(stderr, \"Arguments:\\n\");\n fprintf(stderr, \" -d file: path to a dictionary file to use.\\n\");\n fprintf(stderr, \" -D dir : path to a directory, with files containing dictionaries, of the\\n\"\n \" form DICTID.zstd-dict, e.g., 12345.zstd-dict.\\n\");\n exit(1);\n}\n\nstatic void print_summary(stuff_t* stuff) {\n int error_code;\n fprintf(stderr, \"%9d successful decompressions\\n\", stuff->success_count);\n for (error_code = 0; error_code < ZSTD_error_maxCode; error_code++) {\n int count = stuff->error_counts[error_code];\n if (count) {\n fprintf(\n stderr, \"%9d failed decompressions with message: %s\\n\",\n count, ZSTD_getErrorString(error_code));\n }\n }\n}\n\nstatic char* readFile(const char* filename, size_t* size) {\n struct stat statbuf;\n int ret;\n FILE* f;\n char *buf;\n size_t bytes_read;\n\n ret = stat(filename, &statbuf);\n if (ret != 0) {\n fprintf(stderr, \"stat failed: %m\\n\");\n return NULL;\n }\n if ((statbuf.st_mode & S_IFREG) != S_IFREG) {\n fprintf(stderr, \"Input must be regular file\\n\");\n return NULL;\n }\n\n *size = statbuf.st_size;\n\n f = fopen(filename, \"r\");\n if (f == NULL) {\n fprintf(stderr, \"fopen failed: %m\\n\");\n return NULL;\n }\n\n buf = malloc(*size);\n if (buf == NULL) {\n fprintf(stderr, \"malloc failed\\n\");\n fclose(f);\n return NULL;\n }\n\n bytes_read = fread(buf, 1, *size, f);\n if (bytes_read != *size) {\n fprintf(stderr, \"failed to read whole file\\n\");\n fclose(f);\n free(buf);\n return NULL;\n }\n\n ret = fclose(f);\n if (ret != 0) {\n fprintf(stderr, \"fclose failed: %m\\n\");\n free(buf);\n return NULL;\n }\n\n return buf;\n}\n\nstatic ZSTD_DDict* readDict(const char* filename, char **buf, size_t* size, int32_t* dict_id) {\n ZSTD_DDict* ddict;\n *buf = readFile(filename, size);\n if (*buf == NULL) {\n fprintf(stderr, \"Opening dictionary file '%s' failed\\n\", filename);\n return NULL;\n }\n\n ddict = ZSTD_createDDict_advanced(*buf, *size, ZSTD_dlm_byRef, ZSTD_dct_auto, ZSTD_defaultCMem);\n if (ddict == NULL) {\n fprintf(stderr, \"Failed to create ddict.\\n\");\n return NULL;\n }\n if (dict_id != NULL) {\n *dict_id = ZSTD_getDictID_fromDDict(ddict);\n }\n return ddict;\n}\n\nstatic ZSTD_DDict* readDictByID(stuff_t *stuff, int32_t dict_id, char **buf, size_t* size) {\n if (stuff->dict_file_dir_name == NULL) {\n return NULL;\n } else {\n size_t dir_name_len = strlen(stuff->dict_file_dir_name);\n int dir_needs_separator = 0;\n size_t dict_file_name_alloc_size = dir_name_len + 1 /* '/' */ + 10 /* max int32_t len */ + strlen(\".zstd-dict\") + 1 /* '\\0' */;\n char *dict_file_name = malloc(dict_file_name_alloc_size);\n ZSTD_DDict* ddict;\n int32_t read_dict_id;\n if (dict_file_name == NULL) {\n fprintf(stderr, \"malloc failed.\\n\");\n return 0;\n }\n\n if (dir_name_len > 0 && stuff->dict_file_dir_name[dir_name_len - 1] != '/') {\n dir_needs_separator = 1;\n }\n\n snprintf(\n dict_file_name,\n dict_file_name_alloc_size,\n \"%s%s%u.zstd-dict\",\n stuff->dict_file_dir_name,\n dir_needs_separator ? \"/\" : \"\",\n dict_id);\n\n /* fprintf(stderr, \"Loading dict %u from '%s'.\\n\", dict_id, dict_file_name); */\n\n ddict = readDict(dict_file_name, buf, size, &read_dict_id);\n if (ddict == NULL) {\n fprintf(stderr, \"Failed to create ddict from '%s'.\\n\", dict_file_name);\n free(dict_file_name);\n return 0;\n }\n if (read_dict_id != dict_id) {\n fprintf(stderr, \"Read dictID (%u) does not match expected (%u).\\n\", read_dict_id, dict_id);\n free(dict_file_name);\n ZSTD_freeDDict(ddict);\n return 0;\n }\n\n free(dict_file_name);\n return ddict;\n }\n}\n\nstatic int init_stuff(stuff_t* stuff, int argc, char *argv[]) {\n const char* input_filename;\n\n if (argc < 2) {\n usage();\n }\n\n input_filename = argv[1];\n stuff->input_size = 0;\n stuff->input = readFile(input_filename, &stuff->input_size);\n if (stuff->input == NULL) {\n fprintf(stderr, \"Failed to read input file.\\n\");\n return 0;\n }\n\n stuff->perturbed = malloc(stuff->input_size);\n if (stuff->perturbed == NULL) {\n fprintf(stderr, \"malloc failed.\\n\");\n return 0;\n }\n memcpy(stuff->perturbed, stuff->input, stuff->input_size);\n\n stuff->output_size = ZSTD_DStreamOutSize();\n stuff->output = malloc(stuff->output_size);\n if (stuff->output == NULL) {\n fprintf(stderr, \"malloc failed.\\n\");\n return 0;\n }\n\n stuff->dict_file_name = NULL;\n stuff->dict_file_dir_name = NULL;\n stuff->dict_id = 0;\n stuff->dict = NULL;\n stuff->dict_size = 0;\n stuff->ddict = NULL;\n\n if (argc > 2) {\n if (!strcmp(argv[2], \"-d\")) {\n if (argc > 3) {\n stuff->dict_file_name = argv[3];\n } else {\n usage();\n }\n } else\n if (!strcmp(argv[2], \"-D\")) {\n if (argc > 3) {\n stuff->dict_file_dir_name = argv[3];\n } else {\n usage();\n }\n } else {\n usage();\n }\n }\n\n if (stuff->dict_file_dir_name) {\n int32_t dict_id = ZSTD_getDictID_fromFrame(stuff->input, stuff->input_size);\n if (dict_id != 0) {\n stuff->ddict = readDictByID(stuff, dict_id, &stuff->dict, &stuff->dict_size);\n if (stuff->ddict == NULL) {\n fprintf(stderr, \"Failed to create cached ddict.\\n\");\n return 0;\n }\n stuff->dict_id = dict_id;\n }\n } else\n if (stuff->dict_file_name) {\n stuff->ddict = readDict(stuff->dict_file_name, &stuff->dict, &stuff->dict_size, &stuff->dict_id);\n if (stuff->ddict == NULL) {\n fprintf(stderr, \"Failed to create ddict from '%s'.\\n\", stuff->dict_file_name);\n return 0;\n }\n }\n\n stuff->dctx = ZSTD_createDCtx();\n if (stuff->dctx == NULL) {\n return 0;\n }\n\n stuff->success_count = 0;\n memset(stuff->error_counts, 0, sizeof(stuff->error_counts));\n\n return 1;\n}\n\nstatic int test_decompress(stuff_t* stuff) {\n size_t ret;\n ZSTD_inBuffer in = {stuff->perturbed, stuff->input_size, 0};\n ZSTD_outBuffer out = {stuff->output, stuff->output_size, 0};\n ZSTD_DCtx* dctx = stuff->dctx;\n int32_t custom_dict_id = ZSTD_getDictID_fromFrame(in.src, in.size);\n char *custom_dict = NULL;\n size_t custom_dict_size = 0;\n ZSTD_DDict* custom_ddict = NULL;\n\n if (custom_dict_id != 0 && custom_dict_id != stuff->dict_id) {\n /* fprintf(stderr, \"Instead of dict %u, this perturbed blob wants dict %u.\\n\", stuff->dict_id, custom_dict_id); */\n custom_ddict = readDictByID(stuff, custom_dict_id, &custom_dict, &custom_dict_size);\n }\n\n ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only);\n\n if (custom_ddict != NULL) {\n ZSTD_DCtx_refDDict(dctx, custom_ddict);\n } else {\n ZSTD_DCtx_refDDict(dctx, stuff->ddict);\n }\n\n while (in.pos != in.size) {\n out.pos = 0;\n ret = ZSTD_decompressStream(dctx, &out, &in);\n\n if (ZSTD_isError(ret)) {\n unsigned int code = ZSTD_getErrorCode(ret);\n if (code >= ZSTD_error_maxCode) {\n fprintf(stderr, \"Received unexpected error code!\\n\");\n exit(1);\n }\n stuff->error_counts[code]++;\n /*\n fprintf(\n stderr, \"Decompression failed: %s\\n\", ZSTD_getErrorName(ret));\n */\n if (custom_ddict != NULL) {\n ZSTD_freeDDict(custom_ddict);\n free(custom_dict);\n }\n return 0;\n }\n }\n\n stuff->success_count++;\n\n if (custom_ddict != NULL) {\n ZSTD_freeDDict(custom_ddict);\n free(custom_dict);\n }\n return 1;\n}\n\nstatic int perturb_bits(stuff_t* stuff) {\n size_t pos;\n size_t bit;\n for (pos = 0; pos < stuff->input_size; pos++) {\n unsigned char old_val = stuff->input[pos];\n if (pos % 1000 == 0) {\n fprintf(stderr, \"Perturbing byte %zu / %zu\\n\", pos, stuff->input_size);\n }\n for (bit = 0; bit < 8; bit++) {\n unsigned char new_val = old_val ^ (1 << bit);\n stuff->perturbed[pos] = new_val;\n if (test_decompress(stuff)) {\n fprintf(\n stderr,\n \"Flipping byte %zu bit %zu (0x%02x -> 0x%02x) \"\n \"produced a successful decompression!\\n\",\n pos, bit, old_val, new_val);\n }\n }\n stuff->perturbed[pos] = old_val;\n }\n return 1;\n}\n\nstatic int perturb_bytes(stuff_t* stuff) {\n size_t pos;\n size_t new_val;\n for (pos = 0; pos < stuff->input_size; pos++) {\n unsigned char old_val = stuff->input[pos];\n if (pos % 1000 == 0) {\n fprintf(stderr, \"Perturbing byte %zu / %zu\\n\", pos, stuff->input_size);\n }\n for (new_val = 0; new_val < 256; new_val++) {\n stuff->perturbed[pos] = new_val;\n if (test_decompress(stuff)) {\n fprintf(\n stderr,\n \"Changing byte %zu (0x%02x -> 0x%02x) \"\n \"produced a successful decompression!\\n\",\n pos, old_val, (unsigned char)new_val);\n }\n }\n stuff->perturbed[pos] = old_val;\n }\n return 1;\n}\n\nint main(int argc, char* argv[]) {\n stuff_t stuff;\n\n if(!init_stuff(&stuff, argc, argv)) {\n fprintf(stderr, \"Failed to init.\\n\");\n return 1;\n }\n\n if (test_decompress(&stuff)) {\n fprintf(stderr, \"Blob already decompresses successfully!\\n\");\n return 1;\n }\n\n perturb_bits(&stuff);\n\n perturb_bytes(&stuff);\n\n print_summary(&stuff);\n\n free_stuff(&stuff);\n\n return 0;\n}\n" }, { "path": "contrib/docker/Dockerfile", "content": "# Dockerfile\n# First image to build the binary\nFROM alpine@sha256:69665d02cb32192e52e07644d76bc6f25abeb5410edc1c7a81a10ba3f0efb90a as builder\n\nRUN apk --no-cache add make gcc libc-dev\nCOPY . /src\nRUN mkdir /pkg && cd /src && make && make DESTDIR=/pkg install\n\n# Second minimal image to only keep the built binary\nFROM alpine@sha256:69665d02cb32192e52e07644d76bc6f25abeb5410edc1c7a81a10ba3f0efb90a\n\n# Copy the built files\nCOPY --from=builder /pkg /\n\n# Copy the license as well\nRUN mkdir -p /usr/local/share/licenses/zstd\nCOPY --from=builder /src/LICENSE /usr/local/share/licences/zstd/\n\n# Just run `zstd` if no other command is given\nCMD [\"/usr/local/bin/zstd\"]\n" }, { "path": "contrib/docker/README.md", "content": "\n## Requirement\n\nThe `Dockerfile` script requires a version of `docker` >= 17.05\n\n## Installing docker\n\nThe official docker install docs use a ppa with a modern version available:\nhttps://docs.docker.com/install/linux/docker-ce/ubuntu/\n\n## How to run\n\n`docker build -t zstd .`\n\n## test\n\n```\necho foo | docker run -i --rm zstd | docker run -i --rm zstd zstdcat\nfoo\n```\n" }, { "path": "contrib/freestanding_lib/freestanding.py", "content": "#!/usr/bin/env python3\n# ################################################################\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n# All rights reserved.\n#\n# This source code is licensed under both the BSD-style license (found in the\n# LICENSE file in the root directory of this source tree) and the GPLv2 (found\n# in the COPYING file in the root directory of this source tree).\n# You may select, at your option, one of the above-listed licenses.\n# ##########################################################################\n\nimport argparse\nimport contextlib\nimport os\nimport re\nimport shutil\nimport sys\nfrom typing import Optional\n\n\nINCLUDED_SUBDIRS = [\"common\", \"compress\", \"decompress\"]\n\nSKIPPED_FILES = [\n \"common/mem.h\",\n \"common/zstd_deps.h\",\n \"common/pool.c\",\n \"common/pool.h\",\n \"common/threading.c\",\n \"common/threading.h\",\n \"common/zstd_trace.h\",\n \"compress/zstdmt_compress.h\",\n \"compress/zstdmt_compress.c\",\n]\n\nXXHASH_FILES = [\n \"common/xxhash.c\",\n \"common/xxhash.h\",\n]\n\n\nclass FileLines(object):\n def __init__(self, filename):\n self.filename = filename\n with open(self.filename, \"r\") as f:\n self.lines = f.readlines()\n\n def write(self):\n with open(self.filename, \"w\") as f:\n f.write(\"\".join(self.lines))\n\n\nclass PartialPreprocessor(object):\n \"\"\"\n Looks for simple ifdefs and ifndefs and replaces them.\n Handles && and ||.\n Has fancy logic to handle translating elifs to ifs.\n Only looks for macros in the first part of the expression with no\n parens.\n Does not handle multi-line macros (only looks in first line).\n \"\"\"\n def __init__(self, defs: [(str, Optional[str])], replaces: [(str, str)], undefs: [str]):\n MACRO_GROUP = r\"(?P[a-zA-Z_][a-zA-Z_0-9]*)\"\n ELIF_GROUP = r\"(?Pel)?\"\n OP_GROUP = r\"(?P&&|\\|\\|)?\"\n\n self._defs = {macro:value for macro, value in defs}\n self._replaces = {macro:value for macro, value in replaces}\n self._defs.update(self._replaces)\n self._undefs = set(undefs)\n\n self._define = re.compile(r\"\\s*#\\s*define\")\n self._if = re.compile(r\"\\s*#\\s*if\")\n self._elif = re.compile(r\"\\s*#\\s*(?Pel)if\")\n self._else = re.compile(r\"\\s*#\\s*(?Pelse)\")\n self._endif = re.compile(r\"\\s*#\\s*endif\")\n\n self._ifdef = re.compile(fr\"\\s*#\\s*if(?Pn)?def {MACRO_GROUP}\\s*\")\n self._if_defined = re.compile(\n fr\"\\s*#\\s*{ELIF_GROUP}if\\s+(?P!)?\\s*defined\\s*\\(\\s*{MACRO_GROUP}\\s*\\)\\s*{OP_GROUP}\"\n )\n self._if_defined_value = re.compile(\n fr\"\\s*#\\s*{ELIF_GROUP}if\\s+defined\\s*\\(\\s*{MACRO_GROUP}\\s*\\)\\s*\"\n fr\"(?P&&)\\s*\"\n fr\"(?P\\()?\\s*\"\n fr\"(?P[a-zA-Z_][a-zA-Z_0-9]*)\\s*\"\n fr\"(?P[=>[0-9]*)\\s*\"\n fr\"(?P\\))?\\s*\"\n )\n self._if_true = re.compile(\n fr\"\\s*#\\s*{ELIF_GROUP}if\\s+{MACRO_GROUP}\\s*{OP_GROUP}\"\n )\n\n self._c_comment = re.compile(r\"/\\*.*?\\*/\")\n self._cpp_comment = re.compile(r\"//\")\n\n def _log(self, *args, **kwargs):\n print(*args, **kwargs)\n\n def _strip_comments(self, line):\n # First strip c-style comments (may include //)\n while True:\n m = self._c_comment.search(line)\n if m is None:\n break\n line = line[:m.start()] + line[m.end():]\n\n # Then strip cpp-style comments\n m = self._cpp_comment.search(line)\n if m is not None:\n line = line[:m.start()]\n\n return line\n\n def _fixup_indentation(self, macro, replace: [str]):\n if len(replace) == 0:\n return replace\n if len(replace) == 1 and self._define.match(replace[0]) is None:\n # If there is only one line, only replace defines\n return replace\n\n\n all_pound = True\n for line in replace:\n if not line.startswith('#'):\n all_pound = False\n if all_pound:\n replace = [line[1:] for line in replace]\n\n min_spaces = len(replace[0])\n for line in replace:\n spaces = 0\n for i, c in enumerate(line):\n if c != ' ':\n # Non-preprocessor line ==> skip the fixup\n if not all_pound and c != '#':\n return replace\n spaces = i\n break\n min_spaces = min(min_spaces, spaces)\n\n replace = [line[min_spaces:] for line in replace]\n\n if all_pound:\n replace = [\"#\" + line for line in replace]\n\n return replace\n\n def _handle_if_block(self, macro, idx, is_true, prepend):\n \"\"\"\n Remove the #if or #elif block starting on this line.\n \"\"\"\n REMOVE_ONE = 0\n KEEP_ONE = 1\n REMOVE_REST = 2\n\n if is_true:\n state = KEEP_ONE\n else:\n state = REMOVE_ONE\n\n line = self._inlines[idx]\n is_if = self._if.match(line) is not None\n assert is_if or self._elif.match(line) is not None\n depth = 0\n\n start_idx = idx\n\n idx += 1\n replace = prepend\n finished = False\n while idx < len(self._inlines):\n line = self._inlines[idx]\n # Nested if statement\n if self._if.match(line):\n depth += 1\n idx += 1\n continue\n # We're inside a nested statement\n if depth > 0:\n if self._endif.match(line):\n depth -= 1\n idx += 1\n continue\n\n # We're at the original depth\n\n # Looking only for an endif.\n # We've found a true statement, but haven't\n # completely elided the if block, so we just\n # remove the remainder.\n if state == REMOVE_REST:\n if self._endif.match(line):\n if is_if:\n # Remove the endif because we took the first if\n idx += 1\n finished = True\n break\n idx += 1\n continue\n\n if state == KEEP_ONE:\n m = self._elif.match(line)\n if self._endif.match(line):\n replace += self._inlines[start_idx + 1:idx]\n idx += 1\n finished = True\n break\n if self._elif.match(line) or self._else.match(line):\n replace += self._inlines[start_idx + 1:idx]\n state = REMOVE_REST\n idx += 1\n continue\n\n if state == REMOVE_ONE:\n m = self._elif.match(line)\n if m is not None:\n if is_if:\n idx += 1\n b = m.start('elif')\n e = m.end('elif')\n assert e - b == 2\n replace.append(line[:b] + line[e:])\n finished = True\n break\n m = self._else.match(line)\n if m is not None:\n if is_if:\n idx += 1\n while self._endif.match(self._inlines[idx]) is None:\n replace.append(self._inlines[idx])\n idx += 1\n idx += 1\n finished = True\n break\n if self._endif.match(line):\n if is_if:\n # Remove the endif because no other elifs\n idx += 1\n finished = True\n break\n idx += 1\n continue\n if not finished:\n raise RuntimeError(\"Unterminated if block!\")\n\n replace = self._fixup_indentation(macro, replace)\n\n self._log(f\"\\tHardwiring {macro}\")\n if start_idx > 0:\n self._log(f\"\\t\\t {self._inlines[start_idx - 1][:-1]}\")\n for x in range(start_idx, idx):\n self._log(f\"\\t\\t- {self._inlines[x][:-1]}\")\n for line in replace:\n self._log(f\"\\t\\t+ {line[:-1]}\")\n if idx < len(self._inlines):\n self._log(f\"\\t\\t {self._inlines[idx][:-1]}\")\n\n return idx, replace\n\n def _preprocess_once(self):\n outlines = []\n idx = 0\n changed = False\n while idx < len(self._inlines):\n line = self._inlines[idx]\n sline = self._strip_comments(line)\n m = self._ifdef.fullmatch(sline)\n if_true = False\n if m is None:\n m = self._if_defined_value.fullmatch(sline)\n if m is None:\n m = self._if_defined.match(sline)\n if m is None:\n m = self._if_true.match(sline)\n if_true = (m is not None)\n if m is None:\n outlines.append(line)\n idx += 1\n continue\n\n groups = m.groupdict()\n macro = groups['macro']\n op = groups.get('op')\n\n if not (macro in self._defs or macro in self._undefs):\n outlines.append(line)\n idx += 1\n continue\n\n defined = macro in self._defs\n\n # Needed variables set:\n # resolved: Is the statement fully resolved?\n # is_true: If resolved, is the statement true?\n ifdef = False\n if if_true:\n if not defined:\n outlines.append(line)\n idx += 1\n continue\n\n defined_value = self._defs[macro]\n is_int = True\n try:\n defined_value = int(defined_value)\n except TypeError:\n is_int = False\n except ValueError:\n is_int = False\n\n resolved = is_int\n is_true = (defined_value != 0)\n\n if resolved and op is not None:\n if op == '&&':\n resolved = not is_true\n else:\n assert op == '||'\n resolved = is_true\n\n else:\n ifdef = groups.get('not') is None\n elseif = groups.get('elif') is not None\n\n macro2 = groups.get('macro2')\n cmp = groups.get('cmp')\n value = groups.get('value')\n openp = groups.get('openp')\n closep = groups.get('closep')\n\n is_true = (ifdef == defined)\n resolved = True\n if op is not None:\n if op == '&&':\n resolved = not is_true\n else:\n assert op == '||'\n resolved = is_true\n\n if macro2 is not None and not resolved:\n assert ifdef and defined and op == '&&' and cmp is not None\n # If the statement is true, but we have a single value check, then\n # check the value.\n defined_value = self._defs[macro]\n are_ints = True\n try:\n defined_value = int(defined_value)\n value = int(value)\n except TypeError:\n are_ints = False\n except ValueError:\n are_ints = False\n if (\n macro == macro2 and\n ((openp is None) == (closep is None)) and\n are_ints\n ):\n resolved = True\n if cmp == '<':\n is_true = defined_value < value\n elif cmp == '<=':\n is_true = defined_value <= value\n elif cmp == '==':\n is_true = defined_value == value\n elif cmp == '!=':\n is_true = defined_value != value\n elif cmp == '>=':\n is_true = defined_value >= value\n elif cmp == '>':\n is_true = defined_value > value\n else:\n resolved = False\n\n if op is not None and not resolved:\n # Remove the first op in the line + spaces\n if op == '&&':\n opre = op\n else:\n assert op == '||'\n opre = r'\\|\\|'\n needle = re.compile(fr\"(?P\\s*#\\s*(el)?if\\s+).*?(?P{opre}\\s*)\")\n match = needle.match(line)\n assert match is not None\n newline = line[:match.end('if')] + line[match.end('op'):]\n\n self._log(f\"\\tHardwiring partially resolved {macro}\")\n self._log(f\"\\t\\t- {line[:-1]}\")\n self._log(f\"\\t\\t+ {newline[:-1]}\")\n\n outlines.append(newline)\n idx += 1\n continue\n\n # Skip any statements we cannot fully compute\n if not resolved:\n outlines.append(line)\n idx += 1\n continue\n\n prepend = []\n if macro in self._replaces:\n assert not ifdef\n assert op is None\n value = self._replaces.pop(macro)\n prepend = [f\"#define {macro} {value}\\n\"]\n\n idx, replace = self._handle_if_block(macro, idx, is_true, prepend)\n outlines += replace\n changed = True\n\n return changed, outlines\n\n def preprocess(self, filename):\n with open(filename, 'r') as f:\n self._inlines = f.readlines()\n changed = True\n iters = 0\n while changed:\n iters += 1\n changed, outlines = self._preprocess_once()\n self._inlines = outlines\n\n with open(filename, 'w') as f:\n f.write(''.join(self._inlines))\n\n\nclass Freestanding(object):\n def __init__(\n self, zstd_deps: str, mem: str, source_lib: str, output_lib: str,\n external_xxhash: bool, xxh64_state: Optional[str],\n xxh64_prefix: Optional[str], rewritten_includes: [(str, str)],\n defs: [(str, Optional[str])], replaces: [(str, str)],\n undefs: [str], excludes: [str], seds: [str], spdx: bool,\n ):\n self._zstd_deps = zstd_deps\n self._mem = mem\n self._src_lib = source_lib\n self._dst_lib = output_lib\n self._external_xxhash = external_xxhash\n self._xxh64_state = xxh64_state\n self._xxh64_prefix = xxh64_prefix\n self._rewritten_includes = rewritten_includes\n self._defs = defs\n self._replaces = replaces\n self._undefs = undefs\n self._excludes = excludes\n self._seds = seds\n self._spdx = spdx\n\n def _dst_lib_file_paths(self):\n \"\"\"\n Yields all the file paths in the dst_lib.\n \"\"\"\n for root, dirname, filenames in os.walk(self._dst_lib):\n for filename in filenames:\n filepath = os.path.join(root, filename)\n yield filepath\n\n def _log(self, *args, **kwargs):\n print(*args, **kwargs)\n\n def _copy_file(self, lib_path):\n suffixes = [\".c\", \".h\", \".S\"]\n if not any((lib_path.endswith(suffix) for suffix in suffixes)):\n return\n if lib_path in SKIPPED_FILES:\n self._log(f\"\\tSkipping file: {lib_path}\")\n return\n if self._external_xxhash and lib_path in XXHASH_FILES:\n self._log(f\"\\tSkipping xxhash file: {lib_path}\")\n return\n\n src_path = os.path.join(self._src_lib, lib_path)\n dst_path = os.path.join(self._dst_lib, lib_path)\n self._log(f\"\\tCopying: {src_path} -> {dst_path}\")\n shutil.copyfile(src_path, dst_path)\n\n def _copy_source_lib(self):\n self._log(\"Copying source library into output library\")\n\n assert os.path.exists(self._src_lib)\n os.makedirs(self._dst_lib, exist_ok=True)\n self._copy_file(\"zstd.h\")\n self._copy_file(\"zstd_errors.h\")\n for subdir in INCLUDED_SUBDIRS:\n src_dir = os.path.join(self._src_lib, subdir)\n dst_dir = os.path.join(self._dst_lib, subdir)\n\n assert os.path.exists(src_dir)\n os.makedirs(dst_dir, exist_ok=True)\n\n for filename in os.listdir(src_dir):\n lib_path = os.path.join(subdir, filename)\n self._copy_file(lib_path)\n\n def _copy_zstd_deps(self):\n dst_zstd_deps = os.path.join(self._dst_lib, \"common\", \"zstd_deps.h\")\n self._log(f\"Copying zstd_deps: {self._zstd_deps} -> {dst_zstd_deps}\")\n shutil.copyfile(self._zstd_deps, dst_zstd_deps)\n\n def _copy_mem(self):\n dst_mem = os.path.join(self._dst_lib, \"common\", \"mem.h\")\n self._log(f\"Copying mem: {self._mem} -> {dst_mem}\")\n shutil.copyfile(self._mem, dst_mem)\n\n def _hardwire_preprocessor(self, name: str, value: Optional[str] = None, undef=False):\n \"\"\"\n If value=None then hardwire that it is defined, but not what the value is.\n If undef=True then value must be None.\n If value='' then the macro is defined to '' exactly.\n \"\"\"\n assert not (undef and value is not None)\n for filepath in self._dst_lib_file_paths():\n file = FileLines(filepath)\n\n def _hardwire_defines(self):\n self._log(\"Hardwiring macros\")\n partial_preprocessor = PartialPreprocessor(self._defs, self._replaces, self._undefs)\n for filepath in self._dst_lib_file_paths():\n partial_preprocessor.preprocess(filepath)\n\n def _remove_excludes(self):\n self._log(\"Removing excluded sections\")\n for exclude in self._excludes:\n self._log(f\"\\tRemoving excluded sections for: {exclude}\")\n begin_re = re.compile(f\"BEGIN {exclude}\")\n end_re = re.compile(f\"END {exclude}\")\n for filepath in self._dst_lib_file_paths():\n file = FileLines(filepath)\n outlines = []\n skipped = []\n emit = True\n for line in file.lines:\n if emit and begin_re.search(line) is not None:\n assert end_re.search(line) is None\n emit = False\n if emit:\n outlines.append(line)\n else:\n skipped.append(line)\n if end_re.search(line) is not None:\n assert begin_re.search(line) is None\n self._log(f\"\\t\\tRemoving excluded section: {exclude}\")\n for s in skipped:\n self._log(f\"\\t\\t\\t- {s}\")\n emit = True\n skipped = []\n if not emit:\n raise RuntimeError(\"Excluded section unfinished!\")\n file.lines = outlines\n file.write()\n\n def _rewrite_include(self, original, rewritten):\n self._log(f\"\\tRewriting include: {original} -> {rewritten}\")\n regex = re.compile(f\"\\\\s*#\\\\s*include\\\\s*(?P{original})\")\n for filepath in self._dst_lib_file_paths():\n file = FileLines(filepath)\n for i, line in enumerate(file.lines):\n match = regex.match(line)\n if match is None:\n continue\n s = match.start('include')\n e = match.end('include')\n file.lines[i] = line[:s] + rewritten + line[e:]\n file.write()\n\n def _rewrite_includes(self):\n self._log(\"Rewriting includes\")\n for original, rewritten in self._rewritten_includes:\n self._rewrite_include(original, rewritten)\n\n def _replace_xxh64_prefix(self):\n if self._xxh64_prefix is None:\n return\n self._log(f\"Replacing XXH64 prefix with {self._xxh64_prefix}\")\n replacements = []\n if self._xxh64_state is not None:\n replacements.append(\n (re.compile(r\"([^\\w]|^)(?PXXH64_state_t)([^\\w]|$)\"), self._xxh64_state)\n )\n if self._xxh64_prefix is not None:\n replacements.append(\n (re.compile(r\"([^\\w]|^)(?PXXH64)[\\(_]\"), self._xxh64_prefix)\n )\n for filepath in self._dst_lib_file_paths():\n file = FileLines(filepath)\n for i, line in enumerate(file.lines):\n modified = False\n for regex, replacement in replacements:\n match = regex.search(line)\n while match is not None:\n modified = True\n b = match.start('orig')\n e = match.end('orig')\n line = line[:b] + replacement + line[e:]\n match = regex.search(line)\n if modified:\n self._log(f\"\\t- {file.lines[i][:-1]}\")\n self._log(f\"\\t+ {line[:-1]}\")\n file.lines[i] = line\n file.write()\n\n def _parse_sed(self, sed):\n assert sed[0] == 's'\n delim = sed[1]\n match = re.fullmatch(f's{delim}(.+){delim}(.*){delim}(.*)', sed)\n assert match is not None\n regex = re.compile(match.group(1))\n format_str = match.group(2)\n is_global = match.group(3) == 'g'\n return regex, format_str, is_global\n\n def _process_sed(self, sed):\n self._log(f\"Processing sed: {sed}\")\n regex, format_str, is_global = self._parse_sed(sed)\n\n for filepath in self._dst_lib_file_paths():\n file = FileLines(filepath)\n for i, line in enumerate(file.lines):\n modified = False\n while True:\n match = regex.search(line)\n if match is None:\n break\n replacement = format_str.format(match.groups(''), match.groupdict(''))\n b = match.start()\n e = match.end()\n line = line[:b] + replacement + line[e:]\n modified = True\n if not is_global:\n break\n if modified:\n self._log(f\"\\t- {file.lines[i][:-1]}\")\n self._log(f\"\\t+ {line[:-1]}\")\n file.lines[i] = line\n file.write()\n\n def _process_seds(self):\n self._log(\"Processing seds\")\n for sed in self._seds:\n self._process_sed(sed)\n\n def _process_spdx(self):\n if not self._spdx:\n return\n self._log(\"Processing spdx\")\n SPDX_C = \"// SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause\\n\"\n SPDX_H_S = \"/* SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause */\\n\"\n for filepath in self._dst_lib_file_paths():\n file = FileLines(filepath)\n if file.lines[0] == SPDX_C or file.lines[0] == SPDX_H_S:\n continue\n for line in file.lines:\n if \"SPDX-License-Identifier\" in line:\n raise RuntimeError(f\"Unexpected SPDX license identifier: {file.filename} {repr(line)}\")\n if file.filename.endswith(\".c\"):\n file.lines.insert(0, SPDX_C)\n elif file.filename.endswith(\".h\") or file.filename.endswith(\".S\"):\n file.lines.insert(0, SPDX_H_S)\n else:\n raise RuntimeError(f\"Unexpected file extension: {file.filename}\")\n file.write()\n\n\n\n def go(self):\n self._copy_source_lib()\n self._copy_zstd_deps()\n self._copy_mem()\n self._hardwire_defines()\n self._remove_excludes()\n self._rewrite_includes()\n self._replace_xxh64_prefix()\n self._process_seds()\n self._process_spdx()\n\n\ndef parse_optional_pair(defines: [str]) -> [(str, Optional[str])]:\n output = []\n for define in defines:\n parsed = define.split('=')\n if len(parsed) == 1:\n output.append((parsed[0], None))\n elif len(parsed) == 2:\n output.append((parsed[0], parsed[1]))\n else:\n raise RuntimeError(f\"Bad define: {define}\")\n return output\n\n\ndef parse_pair(rewritten_includes: [str]) -> [(str, str)]:\n output = []\n for rewritten_include in rewritten_includes:\n parsed = rewritten_include.split('=')\n if len(parsed) == 2:\n output.append((parsed[0], parsed[1]))\n else:\n raise RuntimeError(f\"Bad rewritten include: {rewritten_include}\")\n return output\n\n\n\ndef main(name, args):\n parser = argparse.ArgumentParser(prog=name)\n parser.add_argument(\"--zstd-deps\", default=\"zstd_deps.h\", help=\"Zstd dependencies file\")\n parser.add_argument(\"--mem\", default=\"mem.h\", help=\"Memory module\")\n parser.add_argument(\"--source-lib\", default=\"../../lib\", help=\"Location of the zstd library\")\n parser.add_argument(\"--output-lib\", default=\"./freestanding_lib\", help=\"Where to output the freestanding zstd library\")\n parser.add_argument(\"--xxhash\", default=None, help=\"Alternate external xxhash include e.g. --xxhash=''. If set xxhash is not included.\")\n parser.add_argument(\"--xxh64-state\", default=None, help=\"Alternate XXH64 state type (excluding _) e.g. --xxh64-state='struct xxh64_state'\")\n parser.add_argument(\"--xxh64-prefix\", default=None, help=\"Alternate XXH64 function prefix (excluding _) e.g. --xxh64-prefix=xxh64\")\n parser.add_argument(\"--rewrite-include\", default=[], dest=\"rewritten_includes\", action=\"append\", help=\"Rewrite an include REGEX=NEW (e.g. '=')\")\n parser.add_argument(\"--sed\", default=[], dest=\"seds\", action=\"append\", help=\"Apply a sed replacement. Format: `s/REGEX/FORMAT/[g]`. REGEX is a Python regex. FORMAT is a Python format string formatted by the regex dict.\")\n parser.add_argument(\"--spdx\", action=\"store_true\", help=\"Add SPDX License Identifiers\")\n parser.add_argument(\"-D\", \"--define\", default=[], dest=\"defs\", action=\"append\", help=\"Pre-define this macro (can be passed multiple times)\")\n parser.add_argument(\"-U\", \"--undefine\", default=[], dest=\"undefs\", action=\"append\", help=\"Pre-undefine this macro (can be passed multiple times)\")\n parser.add_argument(\"-R\", \"--replace\", default=[], dest=\"replaces\", action=\"append\", help=\"Pre-define this macro and replace the first ifndef block with its definition\")\n parser.add_argument(\"-E\", \"--exclude\", default=[], dest=\"excludes\", action=\"append\", help=\"Exclude all lines between 'BEGIN ' and 'END '\")\n args = parser.parse_args(args)\n\n # Always remove threading\n if \"ZSTD_MULTITHREAD\" not in args.undefs:\n args.undefs.append(\"ZSTD_MULTITHREAD\")\n\n args.defs = parse_optional_pair(args.defs)\n for name, _ in args.defs:\n if name in args.undefs:\n raise RuntimeError(f\"{name} is both defined and undefined!\")\n\n # Always set tracing to 0\n if \"ZSTD_NO_TRACE\" not in (arg[0] for arg in args.defs):\n args.defs.append((\"ZSTD_NO_TRACE\", None))\n args.defs.append((\"ZSTD_TRACE\", \"0\"))\n\n args.replaces = parse_pair(args.replaces)\n for name, _ in args.replaces:\n if name in args.undefs or name in args.defs:\n raise RuntimeError(f\"{name} is both replaced and (un)defined!\")\n\n args.rewritten_includes = parse_pair(args.rewritten_includes)\n\n external_xxhash = False\n if args.xxhash is not None:\n external_xxhash = True\n args.rewritten_includes.append(('\"(\\\\.\\\\./common/)?xxhash.h\"', args.xxhash))\n\n if args.xxh64_prefix is not None:\n if not external_xxhash:\n raise RuntimeError(\"--xxh64-prefix may only be used with --xxhash provided\")\n\n if args.xxh64_state is not None:\n if not external_xxhash:\n raise RuntimeError(\"--xxh64-state may only be used with --xxhash provided\")\n\n Freestanding(\n args.zstd_deps,\n args.mem,\n args.source_lib,\n args.output_lib,\n external_xxhash,\n args.xxh64_state,\n args.xxh64_prefix,\n args.rewritten_includes,\n args.defs,\n args.replaces,\n args.undefs,\n args.excludes,\n args.seds,\n args.spdx,\n ).go()\n\nif __name__ == \"__main__\":\n main(sys.argv[0], sys.argv[1:])\n" }, { "path": "contrib/linux-kernel/.gitignore", "content": "!lib/zstd\n!lib/zstd/*\n*.o\n*.a\n" }, { "path": "contrib/linux-kernel/Makefile", "content": "# ################################################################\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n# All rights reserved.\n#\n# This source code is licensed under both the BSD-style license (found in the\n# LICENSE file in the root directory of this source tree) and the GPLv2 (found\n# in the COPYING file in the root directory of this source tree).\n# You may select, at your option, one of the above-listed licenses.\n# ################################################################\n\n.PHONY: libzstd\nlibzstd:\n\trm -rf linux\n\tmkdir -p linux\n\tmkdir -p linux/include/linux\n\tmkdir -p linux/lib/zstd\n\t../freestanding_lib/freestanding.py \\\n\t\t--source-lib ../../lib \\\n\t\t--output-lib linux/lib/zstd \\\n\t\t--xxhash '' \\\n\t\t--xxh64-state 'struct xxh64_state' \\\n\t\t--xxh64-prefix 'xxh64' \\\n\t\t--rewrite-include '=' \\\n\t\t--rewrite-include '=' \\\n\t\t--rewrite-include '\"\\.\\./zstd.h\"=' \\\n\t\t--rewrite-include '\"(\\.\\./)?zstd_errors.h\"=' \\\n\t\t--sed 's,/\\*\\*\\*,/* *,g' \\\n\t\t--sed 's,/\\*\\*,/*,g' \\\n\t\t--spdx \\\n\t\t-DZSTD_NO_INTRINSICS \\\n\t\t-DZSTD_NO_UNUSED_FUNCTIONS \\\n\t\t-DZSTD_LEGACY_SUPPORT=0 \\\n\t\t-DZSTD_STATIC_LINKING_ONLY \\\n\t\t-DFSE_STATIC_LINKING_ONLY \\\n\t\t-DXXH_STATIC_LINKING_ONLY \\\n\t\t-D__GNUC__ \\\n\t\t-D__linux__=1 \\\n\t\t-DSTATIC_BMI2=0 \\\n\t\t-DZSTD_ADDRESS_SANITIZER=0 \\\n\t\t-DZSTD_MEMORY_SANITIZER=0 \\\n\t\t-DZSTD_DATAFLOW_SANITIZER=0 \\\n\t\t-DZSTD_COMPRESS_HEAPMODE=1 \\\n\t\t-UNO_PREFETCH \\\n\t\t-U__cplusplus \\\n\t\t-UZSTD_DLL_EXPORT \\\n\t\t-UZSTD_DLL_IMPORT \\\n\t\t-U__ICCARM__ \\\n\t\t-UZSTD_MULTITHREAD \\\n\t\t-U_MSC_VER \\\n\t\t-U_WIN32 \\\n\t\t-RZSTDLIB_VISIBLE= \\\n\t\t-RZSTDERRORLIB_VISIBLE= \\\n\t\t-RZSTD_FALLTHROUGH=fallthrough \\\n\t\t-DZSTD_HAVE_WEAK_SYMBOLS=0 \\\n\t\t-DZSTD_TRACE=0 \\\n\t\t-DZSTD_NO_TRACE \\\n\t\t-DZSTD_DISABLE_ASM \\\n\t\t-DZSTD_LINUX_KERNEL\n\trm linux/lib/zstd/decompress/huf_decompress_amd64.S\n\tmv linux/lib/zstd/zstd.h linux/include/linux/zstd_lib.h\n\tmv linux/lib/zstd/zstd_errors.h linux/include/linux/\n\tcp linux_zstd.h linux/include/linux/zstd.h\n\tcp zstd_common_module.c linux/lib/zstd\n\tcp zstd_compress_module.c linux/lib/zstd\n\tcp zstd_decompress_module.c linux/lib/zstd\n\tcp decompress_sources.h linux/lib/zstd\n\tcp linux.mk linux/lib/zstd/Makefile\n\nLINUX ?= $(HOME)/repos/linux\n\n.PHONY: import\nimport: libzstd\n\trm -f $(LINUX)/include/linux/zstd.h\n\trm -f $(LINUX)/include/linux/zstd_errors.h\n\trm -rf $(LINUX)/lib/zstd\n\tcp linux/include/linux/zstd.h $(LINUX)/include/linux\n\tcp linux/include/linux/zstd_lib.h $(LINUX)/include/linux\n\tcp linux/include/linux/zstd_errors.h $(LINUX)/include/linux\n\tcp -r linux/lib/zstd $(LINUX)/lib\n\nimport-upstream:\n\trm -rf $(LINUX)/lib/zstd\n\tmkdir $(LINUX)/lib/zstd\n\tcp ../../lib/zstd.h $(LINUX)/include/linux/zstd_lib.h\n\tcp -r ../../lib/common $(LINUX)/lib/zstd\n\tcp -r ../../lib/compress $(LINUX)/lib/zstd\n\tcp -r ../../lib/decompress $(LINUX)/lib/zstd\n\tmv $(LINUX)/lib/zstd/zstd_errors.h $(LINUX)/include/linux\n\trm $(LINUX)/lib/zstd/common/threading.*\n\trm $(LINUX)/lib/zstd/common/pool.*\n\trm $(LINUX)/lib/zstd/common/xxhash.*\n\trm $(LINUX)/lib/zstd/compress/zstdmt_*\n\nDEBUGFLAGS= -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \\\n -Wstrict-aliasing=1 -Wswitch-enum -Wdeclaration-after-statement \\\n -Wstrict-prototypes -Wundef -Wpointer-arith \\\n -Wvla -Wformat=2 -Winit-self -Wfloat-equal -Wwrite-strings \\\n -Wredundant-decls -Wmissing-prototypes -Wc++-compat \\\n\t -Wimplicit-fallthrough\n\n.PHONY: test\ntest: libzstd\n\t$(MAKE) -C test run-test CFLAGS=\"-O3 $(CFLAGS) $(DEBUGFLAGS) -Werror\" -j\n\n.PHONY: clean\nclean:\n\t$(RM) -rf linux\n\t$(MAKE) -C test clean\n" }, { "path": "contrib/linux-kernel/README.md", "content": "# Zstd in the Linux Kernel\n\nThis directory contains the scripts needed to transform upstream zstd into the version imported into the kernel. All the transforms are automated and tested by our continuous integration.\n\n## Upgrading Zstd in the Linux Kernel\n\n1. `cd` into this directory.\n2. Run `make libzstd` and read the output. Make sure that all the diffs printed and changes made by the script are correct.\n3. Run `make test` and ensure that it passes.\n4. Import zstd into the Linux Kernel `make import LINUX=/path/to/linux/repo`\n5. Inspect the diff for sanity.\n6. Check the Linux Kernel history for zstd. If any patches were made to the kernel version of zstd, but not to upstream zstd, then port them upstream if necessary.\n7. Test the diff. Benchmark if necessary. Make sure to test multiple architectures: At least x86, i386, and arm.\n8. Submit the patch to the LKML.\n" }, { "path": "contrib/linux-kernel/btrfs-benchmark.sh", "content": "# !/bin/sh\nset -e\n\n# Benchmarks run on a Ubuntu 14.04 VM with 2 cores and 4 GiB of RAM.\n# The VM is running on a Macbook Pro with a 3.1 GHz Intel Core i7 processor and\n# 16 GB of RAM and an SSD.\n\n# silesia is a directory that can be downloaded from\n# http://mattmahoney.net/dc/silesia.html\n# ls -l silesia/\n# total 203M\n# -rwxr-xr-x 1 terrelln 9.8M Apr 12 2002 dickens\n# -rwxr-xr-x 1 terrelln 49M May 31 2002 mozilla\n# -rwxr-xr-x 1 terrelln 9.6M Mar 20 2003 mr\n# -rwxr-xr-x 1 terrelln 32M Apr 2 2002 nci\n# -rwxr-xr-x 1 terrelln 5.9M Jul 4 2002 ooffice\n# -rwxr-xr-x 1 terrelln 9.7M Apr 11 2002 osdb\n# -rwxr-xr-x 1 terrelln 6.4M Apr 2 2002 reymont\n# -rwxr-xr-x 1 terrelln 21M Mar 25 2002 samba\n# -rwxr-xr-x 1 terrelln 7.0M Mar 24 2002 sao\n# -rwxr-xr-x 1 terrelln 40M Mar 25 2002 webster\n# -rwxr-xr-x 1 terrelln 8.1M Apr 4 2002 x-ray\n# -rwxr-xr-x 1 terrelln 5.1M Nov 30 2000 xml\n\n# $HOME is on a ext4 filesystem\nBENCHMARK_DIR=\"$HOME/silesia/\"\nN=10\n\n# Normalize the environment\nsudo umount /mnt/btrfs 2> /dev/null > /dev/null || true\nsudo mount -t btrfs $@ /dev/sda3 /mnt/btrfs\nsudo rm -rf /mnt/btrfs/*\nsync\nsudo umount /mnt/btrfs\nsudo mount -t btrfs $@ /dev/sda3 /mnt/btrfs\n\n# Run the benchmark\necho \"Compression\"\ntime sh -c \"for i in \\$(seq $N); do sudo cp -r $BENCHMARK_DIR /mnt/btrfs/\\$i; done; sync\"\n\necho \"Approximate compression ratio\"\nprintf \"%d / %d\\n\" \\\n $(df /mnt/btrfs --output=used -B 1 | tail -n 1) \\\n $(sudo du /mnt/btrfs -b -d 0 | tr '\\t' '\\n' | head -n 1);\n\n# Unmount and remount to avoid any caching\nsudo umount /mnt/btrfs\nsudo mount -t btrfs $@ /dev/sda3 /mnt/btrfs\n\necho \"Decompression\"\ntime sudo tar -c /mnt/btrfs 2> /dev/null | wc -c > /dev/null\n\nsudo rm -rf /mnt/btrfs/*\nsudo umount /mnt/btrfs\n\n# Run for each of -o compress-force={none, lzo, zlib, zstd} 5 times and take the\n# min time and ratio.\n# Ran zstd with compression levels {1, 3, 6, 9, 12, 15}.\n# Original size: 2119415342 B (using du /mnt/btrfs)\n\n# none\n# compress: 4.205 s\n# decompress: 3.090 s\n# ratio: 0.99\n\n# lzo\n# compress: 5.328 s\n# decompress: 4.793 s\n# ratio: 1.66\n\n# zlib\n# compress: 32.588 s\n# decompress: 8.791 s\n# ratio : 2.58\n\n# zstd 1\n# compress: 8.147 s\n# decompress: 5.527 s\n# ratio : 2.57\n\n# zstd 3\n# compress: 12.207 s\n# decompress: 5.195 s\n# ratio : 2.71\n\n# zstd 6\n# compress: 30.253 s\n# decompress: 5.324 s\n# ratio : 2.87\n\n# zstd 9\n# compress: 49.659 s\n# decompress: 5.220 s\n# ratio : 2.92\n\n# zstd 12\n# compress: 99.245 s\n# decompress: 5.193 s\n# ratio : 2.93\n\n# zstd 15\n# compress: 196.997 s\n# decompress: 5.992 s\n# ratio : 3.01\n" }, { "path": "contrib/linux-kernel/btrfs-extract-benchmark.sh", "content": "# !/bin/sh\nset -e\n\n# Benchmarks run on a Ubuntu 14.04 VM with 2 cores and 4 GiB of RAM.\n# The VM is running on a Macbook Pro with a 3.1 GHz Intel Core i7 processor and\n# 16 GB of RAM and an SSD.\n\n# silesia is a directory that can be downloaded from\n# http://mattmahoney.net/dc/silesia.html\n# ls -l silesia/\n# total 203M\n# -rwxr-xr-x 1 terrelln 9.8M Apr 12 2002 dickens\n# -rwxr-xr-x 1 terrelln 49M May 31 2002 mozilla\n# -rwxr-xr-x 1 terrelln 9.6M Mar 20 2003 mr\n# -rwxr-xr-x 1 terrelln 32M Apr 2 2002 nci\n# -rwxr-xr-x 1 terrelln 5.9M Jul 4 2002 ooffice\n# -rwxr-xr-x 1 terrelln 9.7M Apr 11 2002 osdb\n# -rwxr-xr-x 1 terrelln 6.4M Apr 2 2002 reymont\n# -rwxr-xr-x 1 terrelln 21M Mar 25 2002 samba\n# -rwxr-xr-x 1 terrelln 7.0M Mar 24 2002 sao\n# -rwxr-xr-x 1 terrelln 40M Mar 25 2002 webster\n# -rwxr-xr-x 1 terrelln 8.1M Apr 4 2002 x-ray\n# -rwxr-xr-x 1 terrelln 5.1M Nov 30 2000 xml\n\n# $HOME is on a ext4 filesystem\nBENCHMARK_FILE=\"linux-4.11.6.tar\"\nBENCHMARK_DIR=\"$HOME/$BENCHMARK_FILE\"\n\n# Normalize the environment\nsudo umount /mnt/btrfs 2> /dev/null > /dev/null || true\nsudo mount -t btrfs $@ /dev/sda3 /mnt/btrfs\nsudo rm -rf /mnt/btrfs/*\nsync\nsudo umount /mnt/btrfs\nsudo mount -t btrfs $@ /dev/sda3 /mnt/btrfs\n\n# Run the benchmark\necho \"Copy\"\ntime sh -c \"sudo cp -r $BENCHMARK_DIR /mnt/btrfs/$BENCHMARK_FILE && sync\"\n\necho \"Approximate tarred compression ratio\"\nprintf \"%d / %d\\n\" \\\n $(df /mnt/btrfs --output=used -B 1 | tail -n 1) \\\n $(sudo du /mnt/btrfs -b -d 0 | tr '\\t' '\\n' | head -n 1);\n\n# Unmount and remount to avoid any caching\nsudo umount /mnt/btrfs\nsudo mount -t btrfs $@ /dev/sda3 /mnt/btrfs\n\necho \"Extract\"\ntime sh -c \"sudo tar -C /mnt/btrfs -xf /mnt/btrfs/$BENCHMARK_FILE && sync\"\n\n# Remove the tarball, leaving only the extracted data\nsudo rm /mnt/btrfs/$BENCHMARK_FILE\n# Unmount and remount to avoid any caching\nsudo umount /mnt/btrfs\nsudo mount -t btrfs $@ /dev/sda3 /mnt/btrfs\n\necho \"Approximate extracted compression ratio\"\nprintf \"%d / %d\\n\" \\\n $(df /mnt/btrfs --output=used -B 1 | tail -n 1) \\\n $(sudo du /mnt/btrfs -b -d 0 | tr '\\t' '\\n' | head -n 1);\n\necho \"Read\"\ntime sudo tar -c /mnt/btrfs 2> /dev/null | wc -c > /dev/null\n\nsudo rm -rf /mnt/btrfs/*\nsudo umount /mnt/btrfs\n\n# Run for each of -o compress-force={none, lzo, zlib, zstd} 5 times and take the\n# min time and ratio.\n\n# none\n# copy: 0.981 s\n# extract: 5.501 s\n# read: 8.807 s\n# tarball ratio: 0.97\n# extracted ratio: 0.78\n\n# lzo\n# copy: 1.631 s\n# extract: 8.458 s\n# read: 8.585 s\n# tarball ratio: 2.06\n# extracted ratio: 1.38\n\n# zlib\n# copy: 7.750 s\n# extract: 21.544 s\n# read: 11.744 s\n# tarball ratio : 3.40\n# extracted ratio: 1.86\n\n# zstd 1\n# copy: 2.579 s\n# extract: 11.479 s\n# read: 9.389 s\n# tarball ratio : 3.57\n# extracted ratio: 1.85\n" }, { "path": "contrib/linux-kernel/decompress_sources.h", "content": "/* SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause */\n/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/*\n * This file includes every .c file needed for decompression.\n * It is used by lib/decompress_unzstd.c to include the decompression\n * source into the translation-unit, so it can be used for kernel\n * decompression.\n */\n\n/*\n * Disable the ASM Huffman implementation because we need to\n * include all the sources.\n */\n#define ZSTD_DISABLE_ASM 1\n\n#include \"common/debug.c\"\n#include \"common/entropy_common.c\"\n#include \"common/error_private.c\"\n#include \"common/fse_decompress.c\"\n#include \"common/zstd_common.c\"\n#include \"decompress/huf_decompress.c\"\n#include \"decompress/zstd_ddict.c\"\n#include \"decompress/zstd_decompress.c\"\n#include \"decompress/zstd_decompress_block.c\"\n#include \"zstd_decompress_module.c\"\n" }, { "path": "contrib/linux-kernel/linux.mk", "content": "# SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause\n# ################################################################\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n# All rights reserved.\n#\n# This source code is licensed under both the BSD-style license (found in the\n# LICENSE file in the root directory of this source tree) and the GPLv2 (found\n# in the COPYING file in the root directory of this source tree).\n# You may select, at your option, one of the above-listed licenses.\n# ################################################################\nobj-$(CONFIG_ZSTD_COMPRESS) += zstd_compress.o\nobj-$(CONFIG_ZSTD_DECOMPRESS) += zstd_decompress.o\nobj-$(CONFIG_ZSTD_COMMON) += zstd_common.o\n\nzstd_compress-y := \\\n\t\tzstd_compress_module.o \\\n\t\tcompress/fse_compress.o \\\n\t\tcompress/hist.o \\\n\t\tcompress/huf_compress.o \\\n\t\tcompress/zstd_compress.o \\\n\t\tcompress/zstd_compress_literals.o \\\n\t\tcompress/zstd_compress_sequences.o \\\n\t\tcompress/zstd_compress_superblock.o \\\n\t\tcompress/zstd_double_fast.o \\\n\t\tcompress/zstd_fast.o \\\n\t\tcompress/zstd_lazy.o \\\n\t\tcompress/zstd_ldm.o \\\n\t\tcompress/zstd_opt.o \\\n\t\tcompress/zstd_preSplit.o \\\n\nzstd_decompress-y := \\\n\t\tzstd_decompress_module.o \\\n\t\tdecompress/huf_decompress.o \\\n\t\tdecompress/zstd_ddict.o \\\n\t\tdecompress/zstd_decompress.o \\\n\t\tdecompress/zstd_decompress_block.o \\\n\nzstd_common-y := \\\n\t\tzstd_common_module.o \\\n\t\tcommon/debug.o \\\n\t\tcommon/entropy_common.o \\\n\t\tcommon/error_private.o \\\n\t\tcommon/fse_decompress.o \\\n\t\tcommon/zstd_common.o \\\n" }, { "path": "contrib/linux-kernel/linux_zstd.h", "content": "/* SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause */\n/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of https://github.com/facebook/zstd) and\n * the GPLv2 (found in the COPYING file in the root directory of\n * https://github.com/facebook/zstd). You may select, at your option, one of the\n * above-listed licenses.\n */\n\n#ifndef LINUX_ZSTD_H\n#define LINUX_ZSTD_H\n\n/**\n * This is a kernel-style API that wraps the upstream zstd API, which cannot be\n * used directly because the symbols aren't exported. It exposes the minimal\n * functionality which is currently required by users of zstd in the kernel.\n * Expose extra functions from lib/zstd/zstd.h as needed.\n */\n\n/* ====== Dependency ====== */\n#include \n#include \n#include \n\n/* ====== Helper Functions ====== */\n/**\n * zstd_compress_bound() - maximum compressed size in worst case scenario\n * @src_size: The size of the data to compress.\n *\n * Return: The maximum compressed size in the worst case scenario.\n */\nsize_t zstd_compress_bound(size_t src_size);\n\n/**\n * zstd_is_error() - tells if a size_t function result is an error code\n * @code: The function result to check for error.\n *\n * Return: Non-zero iff the code is an error.\n */\nunsigned int zstd_is_error(size_t code);\n\n/**\n * enum zstd_error_code - zstd error codes\n */\ntypedef ZSTD_ErrorCode zstd_error_code;\n\n/**\n * zstd_get_error_code() - translates an error function result to an error code\n * @code: The function result for which zstd_is_error(code) is true.\n *\n * Return: A unique error code for this error.\n */\nzstd_error_code zstd_get_error_code(size_t code);\n\n/**\n * zstd_get_error_name() - translates an error function result to a string\n * @code: The function result for which zstd_is_error(code) is true.\n *\n * Return: An error string corresponding to the error code.\n */\nconst char *zstd_get_error_name(size_t code);\n\n/**\n * zstd_min_clevel() - minimum allowed compression level\n *\n * Return: The minimum allowed compression level.\n */\nint zstd_min_clevel(void);\n\n/**\n * zstd_max_clevel() - maximum allowed compression level\n *\n * Return: The maximum allowed compression level.\n */\nint zstd_max_clevel(void);\n\n/**\n * zstd_default_clevel() - default compression level\n *\n * Return: Default compression level.\n */\nint zstd_default_clevel(void);\n\n/**\n * struct zstd_custom_mem - custom memory allocation\n */\ntypedef ZSTD_customMem zstd_custom_mem;\n\n/**\n * struct zstd_dict_load_method - Dictionary load method.\n * See zstd_lib.h.\n */\ntypedef ZSTD_dictLoadMethod_e zstd_dict_load_method;\n\n/**\n * struct zstd_dict_content_type - Dictionary context type.\n * See zstd_lib.h.\n */\ntypedef ZSTD_dictContentType_e zstd_dict_content_type;\n\n/* ====== Parameter Selection ====== */\n\n/**\n * enum zstd_strategy - zstd compression search strategy\n *\n * From faster to stronger. See zstd_lib.h.\n */\ntypedef ZSTD_strategy zstd_strategy;\n\n/**\n * struct zstd_compression_parameters - zstd compression parameters\n * @windowLog: Log of the largest match distance. Larger means more\n * compression, and more memory needed during decompression.\n * @chainLog: Fully searched segment. Larger means more compression,\n * slower, and more memory (useless for fast).\n * @hashLog: Dispatch table. Larger means more compression,\n * slower, and more memory.\n * @searchLog: Number of searches. Larger means more compression and slower.\n * @searchLength: Match length searched. Larger means faster decompression,\n * sometimes less compression.\n * @targetLength: Acceptable match size for optimal parser (only). Larger means\n * more compression, and slower.\n * @strategy: The zstd compression strategy.\n *\n * See zstd_lib.h.\n */\ntypedef ZSTD_compressionParameters zstd_compression_parameters;\n\n/**\n * struct zstd_frame_parameters - zstd frame parameters\n * @contentSizeFlag: Controls whether content size will be present in the\n * frame header (when known).\n * @checksumFlag: Controls whether a 32-bit checksum is generated at the\n * end of the frame for error detection.\n * @noDictIDFlag: Controls whether dictID will be saved into the frame\n * header when using dictionary compression.\n *\n * The default value is all fields set to 0. See zstd_lib.h.\n */\ntypedef ZSTD_frameParameters zstd_frame_parameters;\n\n/**\n * struct zstd_parameters - zstd parameters\n * @cParams: The compression parameters.\n * @fParams: The frame parameters.\n */\ntypedef ZSTD_parameters zstd_parameters;\n\n/**\n * zstd_get_params() - returns zstd_parameters for selected level\n * @level: The compression level\n * @estimated_src_size: The estimated source size to compress or 0\n * if unknown.\n *\n * Return: The selected zstd_parameters.\n */\nzstd_parameters zstd_get_params(int level,\n\tunsigned long long estimated_src_size);\n\n/**\n * zstd_get_cparams() - returns zstd_compression_parameters for selected level\n * @level: The compression level\n * @estimated_src_size: The estimated source size to compress or 0\n * if unknown.\n * @dict_size: Dictionary size.\n *\n * Return: The selected zstd_compression_parameters.\n */\nzstd_compression_parameters zstd_get_cparams(int level,\n\tunsigned long long estimated_src_size, size_t dict_size);\n\ntypedef ZSTD_CCtx zstd_cctx;\ntypedef ZSTD_cParameter zstd_cparameter;\n\n/**\n * zstd_cctx_set_param() - sets a compression parameter\n * @cctx: The context. Must have been initialized with zstd_init_cctx().\n * @param: The parameter to set.\n * @value: The value to set the parameter to.\n *\n * Return: Zero or an error, which can be checked using zstd_is_error().\n */\nsize_t zstd_cctx_set_param(zstd_cctx *cctx, zstd_cparameter param, int value);\n\n/* ====== Single-pass Compression ====== */\n\n/**\n * zstd_cctx_workspace_bound() - max memory needed to initialize a zstd_cctx\n * @parameters: The compression parameters to be used.\n *\n * If multiple compression parameters might be used, the caller must call\n * zstd_cctx_workspace_bound() for each set of parameters and use the maximum\n * size.\n *\n * Return: A lower bound on the size of the workspace that is passed to\n * zstd_init_cctx().\n */\nsize_t zstd_cctx_workspace_bound(const zstd_compression_parameters *parameters);\n\n/**\n * zstd_cctx_workspace_bound_with_ext_seq_prod() - max memory needed to\n * initialize a zstd_cctx when using the block-level external sequence\n * producer API.\n * @parameters: The compression parameters to be used.\n *\n * If multiple compression parameters might be used, the caller must call\n * this function for each set of parameters and use the maximum size.\n *\n * Return: A lower bound on the size of the workspace that is passed to\n * zstd_init_cctx().\n */\nsize_t zstd_cctx_workspace_bound_with_ext_seq_prod(const zstd_compression_parameters *parameters);\n\n/**\n * zstd_init_cctx() - initialize a zstd compression context\n * @workspace: The workspace to emplace the context into. It must outlive\n * the returned context.\n * @workspace_size: The size of workspace. Use zstd_cctx_workspace_bound() to\n * determine how large the workspace must be.\n *\n * Return: A zstd compression context or NULL on error.\n */\nzstd_cctx *zstd_init_cctx(void *workspace, size_t workspace_size);\n\n/**\n * zstd_compress_cctx() - compress src into dst with the initialized parameters\n * @cctx: The context. Must have been initialized with zstd_init_cctx().\n * @dst: The buffer to compress src into.\n * @dst_capacity: The size of the destination buffer. May be any size, but\n * ZSTD_compressBound(srcSize) is guaranteed to be large enough.\n * @src: The data to compress.\n * @src_size: The size of the data to compress.\n * @parameters: The compression parameters to be used.\n *\n * Return: The compressed size or an error, which can be checked using\n * zstd_is_error().\n */\nsize_t zstd_compress_cctx(zstd_cctx *cctx, void *dst, size_t dst_capacity,\n\tconst void *src, size_t src_size, const zstd_parameters *parameters);\n\n/**\n * zstd_create_cctx_advanced() - Create compression context\n * @custom_mem: Custom allocator.\n *\n * Return: NULL on error, pointer to compression context otherwise.\n */\nzstd_cctx *zstd_create_cctx_advanced(zstd_custom_mem custom_mem);\n\n/**\n * zstd_free_cctx() - Free compression context\n * @cdict: Pointer to compression context.\n *\n * Return: Always 0.\n */\nsize_t zstd_free_cctx(zstd_cctx* cctx);\n\n/**\n * struct zstd_cdict - Compression dictionary.\n * See zstd_lib.h.\n */\ntypedef ZSTD_CDict zstd_cdict;\n\n/**\n * zstd_create_cdict_byreference() - Create compression dictionary\n * @dict: Pointer to dictionary buffer.\n * @dict_size: Size of the dictionary buffer.\n * @dict_load_method: Dictionary load method.\n * @dict_content_type: Dictionary content type.\n * @custom_mem: Memory allocator.\n *\n * Note, this uses @dict by reference (ZSTD_dlm_byRef), so it should be\n * free before zstd_cdict is destroyed.\n *\n * Return: NULL on error, pointer to compression dictionary\n * otherwise.\n */\nzstd_cdict *zstd_create_cdict_byreference(const void *dict, size_t dict_size,\n\t\t\t\t\t zstd_compression_parameters cparams,\n\t\t\t\t\t zstd_custom_mem custom_mem);\n\n/**\n * zstd_free_cdict() - Free compression dictionary\n * @cdict: Pointer to compression dictionary.\n *\n * Return: Always 0.\n */\nsize_t zstd_free_cdict(zstd_cdict* cdict);\n\n/**\n * zstd_compress_using_cdict() - compress src into dst using a dictionary\n * @cctx: The context. Must have been initialized with zstd_init_cctx().\n * @dst: The buffer to compress src into.\n * @dst_capacity: The size of the destination buffer. May be any size, but\n * ZSTD_compressBound(srcSize) is guaranteed to be large enough.\n * @src: The data to compress.\n * @src_size: The size of the data to compress.\n * @cdict: The dictionary to be used.\n *\n * Return: The compressed size or an error, which can be checked using\n * zstd_is_error().\n */\nsize_t zstd_compress_using_cdict(zstd_cctx *cctx, void *dst,\n\tsize_t dst_capacity, const void *src, size_t src_size,\n\tconst zstd_cdict *cdict);\n\n/* ====== Single-pass Decompression ====== */\n\ntypedef ZSTD_DCtx zstd_dctx;\n\n/**\n * zstd_dctx_workspace_bound() - max memory needed to initialize a zstd_dctx\n *\n * Return: A lower bound on the size of the workspace that is passed to\n * zstd_init_dctx().\n */\nsize_t zstd_dctx_workspace_bound(void);\n\n/**\n * zstd_init_dctx() - initialize a zstd decompression context\n * @workspace: The workspace to emplace the context into. It must outlive\n * the returned context.\n * @workspace_size: The size of workspace. Use zstd_dctx_workspace_bound() to\n * determine how large the workspace must be.\n *\n * Return: A zstd decompression context or NULL on error.\n */\nzstd_dctx *zstd_init_dctx(void *workspace, size_t workspace_size);\n\n/**\n * zstd_decompress_dctx() - decompress zstd compressed src into dst\n * @dctx: The decompression context.\n * @dst: The buffer to decompress src into.\n * @dst_capacity: The size of the destination buffer. Must be at least as large\n * as the decompressed size. If the caller cannot upper bound the\n * decompressed size, then it's better to use the streaming API.\n * @src: The zstd compressed data to decompress. Multiple concatenated\n * frames and skippable frames are allowed.\n * @src_size: The exact size of the data to decompress.\n *\n * Return: The decompressed size or an error, which can be checked using\n * zstd_is_error().\n */\nsize_t zstd_decompress_dctx(zstd_dctx *dctx, void *dst, size_t dst_capacity,\n\tconst void *src, size_t src_size);\n\n/**\n * struct zstd_ddict - Decompression dictionary.\n * See zstd_lib.h.\n */\ntypedef ZSTD_DDict zstd_ddict;\n\n/**\n * zstd_create_ddict_byreference() - Create decompression dictionary\n * @dict: Pointer to dictionary buffer.\n * @dict_size: Size of the dictionary buffer.\n * @dict_load_method: Dictionary load method.\n * @dict_content_type: Dictionary content type.\n * @custom_mem: Memory allocator.\n *\n * Note, this uses @dict by reference (ZSTD_dlm_byRef), so it should be\n * free before zstd_ddict is destroyed.\n *\n * Return: NULL on error, pointer to decompression dictionary\n * otherwise.\n */\nzstd_ddict *zstd_create_ddict_byreference(const void *dict, size_t dict_size,\n\t\t\t\t\t zstd_custom_mem custom_mem);\n/**\n * zstd_free_ddict() - Free decompression dictionary\n * @dict: Pointer to the dictionary.\n *\n * Return: Always 0.\n */\nsize_t zstd_free_ddict(zstd_ddict *ddict);\n\n/**\n * zstd_create_dctx_advanced() - Create decompression context\n * @custom_mem: Custom allocator.\n *\n * Return: NULL on error, pointer to decompression context otherwise.\n */\nzstd_dctx *zstd_create_dctx_advanced(zstd_custom_mem custom_mem);\n\n/**\n * zstd_free_dctx() -- Free decompression context\n * @dctx: Pointer to decompression context.\n * Return: Always 0.\n */\nsize_t zstd_free_dctx(zstd_dctx *dctx);\n\n/**\n * zstd_decompress_using_ddict() - decompress src into dst using a dictionary\n * @dctx: The decompression context.\n * @dst: The buffer to decompress src into.\n * @dst_capacity: The size of the destination buffer. Must be at least as large\n * as the decompressed size. If the caller cannot upper bound the\n * decompressed size, then it's better to use the streaming API.\n * @src: The zstd compressed data to decompress. Multiple concatenated\n * frames and skippable frames are allowed.\n * @src_size: The exact size of the data to decompress.\n * @ddict: The dictionary to be used.\n *\n * Return: The decompressed size or an error, which can be checked using\n * zstd_is_error().\n */\nsize_t zstd_decompress_using_ddict(zstd_dctx *dctx,\n\tvoid *dst, size_t dst_capacity, const void *src, size_t src_size,\n\tconst zstd_ddict *ddict);\n\n\n/* ====== Streaming Buffers ====== */\n\n/**\n * struct zstd_in_buffer - input buffer for streaming\n * @src: Start of the input buffer.\n * @size: Size of the input buffer.\n * @pos: Position where reading stopped. Will be updated.\n * Necessarily 0 <= pos <= size.\n *\n * See zstd_lib.h.\n */\ntypedef ZSTD_inBuffer zstd_in_buffer;\n\n/**\n * struct zstd_out_buffer - output buffer for streaming\n * @dst: Start of the output buffer.\n * @size: Size of the output buffer.\n * @pos: Position where writing stopped. Will be updated.\n * Necessarily 0 <= pos <= size.\n *\n * See zstd_lib.h.\n */\ntypedef ZSTD_outBuffer zstd_out_buffer;\n\n/* ====== Streaming Compression ====== */\n\ntypedef ZSTD_CStream zstd_cstream;\n\n/**\n * zstd_cstream_workspace_bound() - memory needed to initialize a zstd_cstream\n * @cparams: The compression parameters to be used for compression.\n *\n * Return: A lower bound on the size of the workspace that is passed to\n * zstd_init_cstream().\n */\nsize_t zstd_cstream_workspace_bound(const zstd_compression_parameters *cparams);\n\n/**\n * zstd_cstream_workspace_bound_with_ext_seq_prod() - memory needed to initialize\n * a zstd_cstream when using the block-level external sequence producer API.\n * @cparams: The compression parameters to be used for compression.\n *\n * Return: A lower bound on the size of the workspace that is passed to\n * zstd_init_cstream().\n */\nsize_t zstd_cstream_workspace_bound_with_ext_seq_prod(const zstd_compression_parameters *cparams);\n\n/**\n * zstd_init_cstream() - initialize a zstd streaming compression context\n * @parameters The zstd parameters to use for compression.\n * @pledged_src_size: If params.fParams.contentSizeFlag == 1 then the caller\n * must pass the source size (zero means empty source).\n * Otherwise, the caller may optionally pass the source\n * size, or zero if unknown.\n * @workspace: The workspace to emplace the context into. It must outlive\n * the returned context.\n * @workspace_size: The size of workspace.\n * Use zstd_cstream_workspace_bound(params->cparams) to\n * determine how large the workspace must be.\n *\n * Return: The zstd streaming compression context or NULL on error.\n */\nzstd_cstream *zstd_init_cstream(const zstd_parameters *parameters,\n\tunsigned long long pledged_src_size, void *workspace, size_t workspace_size);\n\n/**\n * zstd_reset_cstream() - reset the context using parameters from creation\n * @cstream: The zstd streaming compression context to reset.\n * @pledged_src_size: Optionally the source size, or zero if unknown.\n *\n * Resets the context using the parameters from creation. Skips dictionary\n * loading, since it can be reused. If `pledged_src_size` is non-zero the frame\n * content size is always written into the frame header.\n *\n * Return: Zero or an error, which can be checked using\n * zstd_is_error().\n */\nsize_t zstd_reset_cstream(zstd_cstream *cstream,\n\tunsigned long long pledged_src_size);\n\n/**\n * zstd_compress_stream() - streaming compress some of input into output\n * @cstream: The zstd streaming compression context.\n * @output: Destination buffer. `output->pos` is updated to indicate how much\n * compressed data was written.\n * @input: Source buffer. `input->pos` is updated to indicate how much data\n * was read. Note that it may not consume the entire input, in which\n * case `input->pos < input->size`, and it's up to the caller to\n * present remaining data again.\n *\n * The `input` and `output` buffers may be any size. Guaranteed to make some\n * forward progress if `input` and `output` are not empty.\n *\n * Return: A hint for the number of bytes to use as the input for the next\n * function call or an error, which can be checked using\n * zstd_is_error().\n */\nsize_t zstd_compress_stream(zstd_cstream *cstream, zstd_out_buffer *output,\n\tzstd_in_buffer *input);\n\n/**\n * zstd_flush_stream() - flush internal buffers into output\n * @cstream: The zstd streaming compression context.\n * @output: Destination buffer. `output->pos` is updated to indicate how much\n * compressed data was written.\n *\n * zstd_flush_stream() must be called until it returns 0, meaning all the data\n * has been flushed. Since zstd_flush_stream() causes a block to be ended,\n * calling it too often will degrade the compression ratio.\n *\n * Return: The number of bytes still present within internal buffers or an\n * error, which can be checked using zstd_is_error().\n */\nsize_t zstd_flush_stream(zstd_cstream *cstream, zstd_out_buffer *output);\n\n/**\n * zstd_end_stream() - flush internal buffers into output and end the frame\n * @cstream: The zstd streaming compression context.\n * @output: Destination buffer. `output->pos` is updated to indicate how much\n * compressed data was written.\n *\n * zstd_end_stream() must be called until it returns 0, meaning all the data has\n * been flushed and the frame epilogue has been written.\n *\n * Return: The number of bytes still present within internal buffers or an\n * error, which can be checked using zstd_is_error().\n */\nsize_t zstd_end_stream(zstd_cstream *cstream, zstd_out_buffer *output);\n\n/* ====== Streaming Decompression ====== */\n\ntypedef ZSTD_DStream zstd_dstream;\n\n/**\n * zstd_dstream_workspace_bound() - memory needed to initialize a zstd_dstream\n * @max_window_size: The maximum window size allowed for compressed frames.\n *\n * Return: A lower bound on the size of the workspace that is passed\n * to zstd_init_dstream().\n */\nsize_t zstd_dstream_workspace_bound(size_t max_window_size);\n\n/**\n * zstd_init_dstream() - initialize a zstd streaming decompression context\n * @max_window_size: The maximum window size allowed for compressed frames.\n * @workspace: The workspace to emplace the context into. It must outlive\n * the returned context.\n * @workspaceSize: The size of workspace.\n * Use zstd_dstream_workspace_bound(max_window_size) to\n * determine how large the workspace must be.\n *\n * Return: The zstd streaming decompression context.\n */\nzstd_dstream *zstd_init_dstream(size_t max_window_size, void *workspace,\n\tsize_t workspace_size);\n\n/**\n * zstd_reset_dstream() - reset the context using parameters from creation\n * @dstream: The zstd streaming decompression context to reset.\n *\n * Resets the context using the parameters from creation. Skips dictionary\n * loading, since it can be reused.\n *\n * Return: Zero or an error, which can be checked using zstd_is_error().\n */\nsize_t zstd_reset_dstream(zstd_dstream *dstream);\n\n/**\n * zstd_decompress_stream() - streaming decompress some of input into output\n * @dstream: The zstd streaming decompression context.\n * @output: Destination buffer. `output.pos` is updated to indicate how much\n * decompressed data was written.\n * @input: Source buffer. `input.pos` is updated to indicate how much data was\n * read. Note that it may not consume the entire input, in which case\n * `input.pos < input.size`, and it's up to the caller to present\n * remaining data again.\n *\n * The `input` and `output` buffers may be any size. Guaranteed to make some\n * forward progress if `input` and `output` are not empty.\n * zstd_decompress_stream() will not consume the last byte of the frame until\n * the entire frame is flushed.\n *\n * Return: Returns 0 iff a frame is completely decoded and fully flushed.\n * Otherwise returns a hint for the number of bytes to use as the\n * input for the next function call or an error, which can be checked\n * using zstd_is_error(). The size hint will never load more than the\n * frame.\n */\nsize_t zstd_decompress_stream(zstd_dstream *dstream, zstd_out_buffer *output,\n\tzstd_in_buffer *input);\n\n/* ====== Frame Inspection Functions ====== */\n\n/**\n * zstd_find_frame_compressed_size() - returns the size of a compressed frame\n * @src: Source buffer. It should point to the start of a zstd encoded\n * frame or a skippable frame.\n * @src_size: The size of the source buffer. It must be at least as large as the\n * size of the frame.\n *\n * Return: The compressed size of the frame pointed to by `src` or an error,\n * which can be check with zstd_is_error().\n * Suitable to pass to ZSTD_decompress() or similar functions.\n */\nsize_t zstd_find_frame_compressed_size(const void *src, size_t src_size);\n\n/**\n * zstd_register_sequence_producer() - exposes the zstd library function\n * ZSTD_registerSequenceProducer(). This is used for the block-level external\n * sequence producer API. See upstream zstd.h for detailed documentation.\n */\ntypedef ZSTD_sequenceProducer_F zstd_sequence_producer_f;\nvoid zstd_register_sequence_producer(\n zstd_cctx *cctx,\n void* sequence_producer_state,\n zstd_sequence_producer_f sequence_producer\n);\n\n/**\n * struct zstd_frame_params - zstd frame parameters stored in the frame header\n * @frameContentSize: The frame content size, or ZSTD_CONTENTSIZE_UNKNOWN if not\n * present.\n * @windowSize: The window size, or 0 if the frame is a skippable frame.\n * @blockSizeMax: The maximum block size.\n * @frameType: The frame type (zstd or skippable)\n * @headerSize: The size of the frame header.\n * @dictID: The dictionary id, or 0 if not present.\n * @checksumFlag: Whether a checksum was used.\n *\n * See zstd_lib.h.\n */\ntypedef ZSTD_FrameHeader zstd_frame_header;\n\n/**\n * zstd_get_frame_header() - extracts parameters from a zstd or skippable frame\n * @params: On success the frame parameters are written here.\n * @src: The source buffer. It must point to a zstd or skippable frame.\n * @src_size: The size of the source buffer.\n *\n * Return: 0 on success. If more data is required it returns how many bytes\n * must be provided to make forward progress. Otherwise it returns\n * an error, which can be checked using zstd_is_error().\n */\nsize_t zstd_get_frame_header(zstd_frame_header *params, const void *src,\n\tsize_t src_size);\n\n/**\n * struct zstd_sequence - a sequence of literals or a match\n *\n * @offset: The offset of the match\n * @litLength: The literal length of the sequence\n * @matchLength: The match length of the sequence\n * @rep: Represents which repeat offset is used\n */\ntypedef ZSTD_Sequence zstd_sequence;\n\n/**\n * zstd_compress_sequences_and_literals() - compress an array of zstd_sequence and literals\n *\n * @cctx: The zstd compression context.\n * @dst: The buffer to compress the data into.\n * @dst_capacity: The size of the destination buffer.\n * @in_seqs: The array of zstd_sequence to compress.\n * @in_seqs_size: The number of sequences in in_seqs.\n * @literals: The literals associated to the sequences to be compressed.\n * @lit_size: The size of the literals in the literals buffer.\n * @lit_capacity: The size of the literals buffer.\n * @decompressed_size: The size of the input data\n *\n * Return: The compressed size or an error, which can be checked using\n * \t zstd_is_error().\n */\nsize_t zstd_compress_sequences_and_literals(zstd_cctx *cctx, void* dst, size_t dst_capacity,\n\t\t\t\t\t const zstd_sequence *in_seqs, size_t in_seqs_size,\n\t\t\t\t\t const void* literals, size_t lit_size, size_t lit_capacity,\n\t\t\t\t\t size_t decompressed_size);\n\n#endif /* LINUX_ZSTD_H */\n" }, { "path": "contrib/linux-kernel/mem.h", "content": "/* SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause */\n/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef MEM_H_MODULE\n#define MEM_H_MODULE\n\n/*-****************************************\n* Dependencies\n******************************************/\n#include /* get_unaligned, put_unaligned* */\n#include /* inline */\n#include /* swab32, swab64 */\n#include /* size_t, ptrdiff_t */\n#include \"debug.h\" /* DEBUG_STATIC_ASSERT */\n\n/*-****************************************\n* Compiler specifics\n******************************************/\n#undef MEM_STATIC /* may be already defined from common/compiler.h */\n#define MEM_STATIC static inline\n\n/*-**************************************************************\n* Basic Types\n*****************************************************************/\ntypedef uint8_t BYTE;\ntypedef uint8_t U8;\ntypedef int8_t S8;\ntypedef uint16_t U16;\ntypedef int16_t S16;\ntypedef uint32_t U32;\ntypedef int32_t S32;\ntypedef uint64_t U64;\ntypedef int64_t S64;\n\n/*-**************************************************************\n* Memory I/O API\n*****************************************************************/\n/*=== Static platform detection ===*/\nMEM_STATIC unsigned MEM_32bits(void);\nMEM_STATIC unsigned MEM_64bits(void);\nMEM_STATIC unsigned MEM_isLittleEndian(void);\n\n/*=== Native unaligned read/write ===*/\nMEM_STATIC U16 MEM_read16(const void* memPtr);\nMEM_STATIC U32 MEM_read32(const void* memPtr);\nMEM_STATIC U64 MEM_read64(const void* memPtr);\nMEM_STATIC size_t MEM_readST(const void* memPtr);\n\nMEM_STATIC void MEM_write16(void* memPtr, U16 value);\nMEM_STATIC void MEM_write32(void* memPtr, U32 value);\nMEM_STATIC void MEM_write64(void* memPtr, U64 value);\n\n/*=== Little endian unaligned read/write ===*/\nMEM_STATIC U16 MEM_readLE16(const void* memPtr);\nMEM_STATIC U32 MEM_readLE24(const void* memPtr);\nMEM_STATIC U32 MEM_readLE32(const void* memPtr);\nMEM_STATIC U64 MEM_readLE64(const void* memPtr);\nMEM_STATIC size_t MEM_readLEST(const void* memPtr);\n\nMEM_STATIC void MEM_writeLE16(void* memPtr, U16 val);\nMEM_STATIC void MEM_writeLE24(void* memPtr, U32 val);\nMEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32);\nMEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64);\nMEM_STATIC void MEM_writeLEST(void* memPtr, size_t val);\n\n/*=== Big endian unaligned read/write ===*/\nMEM_STATIC U32 MEM_readBE32(const void* memPtr);\nMEM_STATIC U64 MEM_readBE64(const void* memPtr);\nMEM_STATIC size_t MEM_readBEST(const void* memPtr);\n\nMEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32);\nMEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64);\nMEM_STATIC void MEM_writeBEST(void* memPtr, size_t val);\n\n/*=== Byteswap ===*/\nMEM_STATIC U32 MEM_swap32(U32 in);\nMEM_STATIC U64 MEM_swap64(U64 in);\nMEM_STATIC size_t MEM_swapST(size_t in);\n\n/*-**************************************************************\n* Memory I/O Implementation\n*****************************************************************/\nMEM_STATIC unsigned MEM_32bits(void)\n{\n return sizeof(size_t) == 4;\n}\n\nMEM_STATIC unsigned MEM_64bits(void)\n{\n return sizeof(size_t) == 8;\n}\n\n#if defined(__LITTLE_ENDIAN)\n#define MEM_LITTLE_ENDIAN 1\n#else\n#define MEM_LITTLE_ENDIAN 0\n#endif\n\nMEM_STATIC unsigned MEM_isLittleEndian(void)\n{\n return MEM_LITTLE_ENDIAN;\n}\n\nMEM_STATIC U16 MEM_read16(const void *memPtr)\n{\n return get_unaligned((const U16 *)memPtr);\n}\n\nMEM_STATIC U32 MEM_read32(const void *memPtr)\n{\n return get_unaligned((const U32 *)memPtr);\n}\n\nMEM_STATIC U64 MEM_read64(const void *memPtr)\n{\n return get_unaligned((const U64 *)memPtr);\n}\n\nMEM_STATIC size_t MEM_readST(const void *memPtr)\n{\n return get_unaligned((const size_t *)memPtr);\n}\n\nMEM_STATIC void MEM_write16(void *memPtr, U16 value)\n{\n put_unaligned(value, (U16 *)memPtr);\n}\n\nMEM_STATIC void MEM_write32(void *memPtr, U32 value)\n{\n put_unaligned(value, (U32 *)memPtr);\n}\n\nMEM_STATIC void MEM_write64(void *memPtr, U64 value)\n{\n put_unaligned(value, (U64 *)memPtr);\n}\n\n/*=== Little endian r/w ===*/\n\nMEM_STATIC U16 MEM_readLE16(const void *memPtr)\n{\n return get_unaligned_le16(memPtr);\n}\n\nMEM_STATIC void MEM_writeLE16(void *memPtr, U16 val)\n{\n put_unaligned_le16(val, memPtr);\n}\n\nMEM_STATIC U32 MEM_readLE24(const void *memPtr)\n{\n return MEM_readLE16(memPtr) + (((const BYTE *)memPtr)[2] << 16);\n}\n\nMEM_STATIC void MEM_writeLE24(void *memPtr, U32 val)\n{\n\tMEM_writeLE16(memPtr, (U16)val);\n\t((BYTE *)memPtr)[2] = (BYTE)(val >> 16);\n}\n\nMEM_STATIC U32 MEM_readLE32(const void *memPtr)\n{\n return get_unaligned_le32(memPtr);\n}\n\nMEM_STATIC void MEM_writeLE32(void *memPtr, U32 val32)\n{\n put_unaligned_le32(val32, memPtr);\n}\n\nMEM_STATIC U64 MEM_readLE64(const void *memPtr)\n{\n return get_unaligned_le64(memPtr);\n}\n\nMEM_STATIC void MEM_writeLE64(void *memPtr, U64 val64)\n{\n put_unaligned_le64(val64, memPtr);\n}\n\nMEM_STATIC size_t MEM_readLEST(const void *memPtr)\n{\n\tif (MEM_32bits())\n\t\treturn (size_t)MEM_readLE32(memPtr);\n\telse\n\t\treturn (size_t)MEM_readLE64(memPtr);\n}\n\nMEM_STATIC void MEM_writeLEST(void *memPtr, size_t val)\n{\n\tif (MEM_32bits())\n\t\tMEM_writeLE32(memPtr, (U32)val);\n\telse\n\t\tMEM_writeLE64(memPtr, (U64)val);\n}\n\n/*=== Big endian r/w ===*/\n\nMEM_STATIC U32 MEM_readBE32(const void *memPtr)\n{\n return get_unaligned_be32(memPtr);\n}\n\nMEM_STATIC void MEM_writeBE32(void *memPtr, U32 val32)\n{\n put_unaligned_be32(val32, memPtr);\n}\n\nMEM_STATIC U64 MEM_readBE64(const void *memPtr)\n{\n return get_unaligned_be64(memPtr);\n}\n\nMEM_STATIC void MEM_writeBE64(void *memPtr, U64 val64)\n{\n put_unaligned_be64(val64, memPtr);\n}\n\nMEM_STATIC size_t MEM_readBEST(const void *memPtr)\n{\n\tif (MEM_32bits())\n\t\treturn (size_t)MEM_readBE32(memPtr);\n\telse\n\t\treturn (size_t)MEM_readBE64(memPtr);\n}\n\nMEM_STATIC void MEM_writeBEST(void *memPtr, size_t val)\n{\n\tif (MEM_32bits())\n\t\tMEM_writeBE32(memPtr, (U32)val);\n\telse\n\t\tMEM_writeBE64(memPtr, (U64)val);\n}\n\nMEM_STATIC U32 MEM_swap32(U32 in)\n{\n return swab32(in);\n}\n\nMEM_STATIC U64 MEM_swap64(U64 in)\n{\n return swab64(in);\n}\n\nMEM_STATIC size_t MEM_swapST(size_t in)\n{\n if (MEM_32bits())\n return (size_t)MEM_swap32((U32)in);\n else\n return (size_t)MEM_swap64((U64)in);\n}\n\n#endif /* MEM_H_MODULE */\n" }, { "path": "contrib/linux-kernel/squashfs-benchmark.sh", "content": "# !/bin/sh\nset -e\n\n# Benchmarks run on a Ubuntu 14.04 VM with 2 cores and 4 GiB of RAM.\n# The VM is running on a Macbook Pro with a 3.1 GHz Intel Core i7 processor and\n# 16 GB of RAM and an SSD.\n\n# $BENCHMARK_DIR is generated with the following commands, from the Ubuntu image\n# ubuntu-16.10-desktop-amd64.iso.\n# > mkdir mnt\n# > sudo mount -o loop ubuntu-16.10-desktop-amd64.iso mnt\n# > cp mnt/casper/filesystem.squashfs .\n# > sudo unsquashfs filesystem.squashfs\n\n# $HOME is on a ext4 filesystem\nBENCHMARK_DIR=\"$HOME/squashfs-root/\"\nBENCHMARK_FS=\"$HOME/filesystem.squashfs\"\n\n# Normalize the environment\nsudo rm -f $BENCHMARK_FS 2> /dev/null > /dev/null || true\nsudo umount /mnt/squashfs 2> /dev/null > /dev/null || true\n\n# Run the benchmark\necho \"Compression\"\necho \"sudo mksquashfs $BENCHMARK_DIR $BENCHMARK_FS $@\"\ntime sudo mksquashfs $BENCHMARK_DIR $BENCHMARK_FS $@ 2> /dev/null > /dev/null\n\necho \"Approximate compression ratio\"\nprintf \"%d / %d\\n\" \\\n $(sudo du -sx --block-size=1 $BENCHMARK_DIR | cut -f1) \\\n $(sudo du -sx --block-size=1 $BENCHMARK_FS | cut -f1);\n\n# Mount the filesystem\nsudo mount -t squashfs $BENCHMARK_FS /mnt/squashfs\n\necho \"Decompression\"\ntime sudo tar -c /mnt/squashfs 2> /dev/null | wc -c > /dev/null\n\nsudo umount /mnt/squashfs\n" }, { "path": "contrib/linux-kernel/test/Makefile", "content": "# ################################################################\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n# All rights reserved.\n#\n# This source code is licensed under both the BSD-style license (found in the\n# LICENSE file in the root directory of this source tree) and the GPLv2 (found\n# in the COPYING file in the root directory of this source tree).\n# You may select, at your option, one of the above-listed licenses.\n# ################################################################\n\nLINUX := ../linux\nLINUX_ZSTDLIB := $(LINUX)/lib/zstd\n\nCPPFLAGS += -I$(LINUX)/include -I$(LINUX_ZSTDLIB) -Iinclude -DNDEBUG -Wno-deprecated-declarations\n# Don't poison the workspace, it currently doesn't work with static allocation and workspace reuse\nCPPFLAGS += -DZSTD_ASAN_DONT_POISON_WORKSPACE\n\nLINUX_ZSTD_MODULE := $(wildcard $(LINUX_ZSTDLIB)/*.c)\nLINUX_ZSTD_COMMON := $(wildcard $(LINUX_ZSTDLIB)/common/*.c)\nLINUX_ZSTD_COMPRESS := $(wildcard $(LINUX_ZSTDLIB)/compress/*.c)\nLINUX_ZSTD_DECOMPRESS := $(wildcard $(LINUX_ZSTDLIB)/decompress/*.c $(LINUX_ZSTDLIB)/decompress/*.S)\nLINUX_ZSTD_FILES := $(LINUX_ZSTD_MODULE) $(LINUX_ZSTD_COMMON) $(LINUX_ZSTD_COMPRESS) $(LINUX_ZSTD_DECOMPRESS)\nLINUX_ZSTD_OBJECTS0 := $(LINUX_ZSTD_FILES:.c=.o)\nLINUX_ZSTD_OBJECTS := $(LINUX_ZSTD_OBJECTS0:.S=.o)\n\n%.o: %.S\n\t$(COMPILE.S) $(OUTPUT_OPTION) $<\n\nliblinuxzstd.a: $(LINUX_ZSTD_OBJECTS)\n\t$(AR) $(ARFLAGS) $@ $^\n\ntest: test.c liblinuxzstd.a\n\t$(CC) $(LDFLAGS) $(CPPFLAGS) $(CFLAGS) $^ -o $@\n\nstatic_test: static_test.c\n\t$(CC) $(LDFLAGS) $(CPPFLAGS) $(CFLAGS) $^ -o $@\n\nrun-test: test static_test\n\t./macro-test.sh\n\t./test\n\t./static_test\n\n.PHONY:\nclean:\n\t$(RM) -f $(LINUX_ZSTDLIB)/*.o\n\t$(RM) -f $(LINUX_ZSTDLIB)/**/*.o\n\t$(RM) -f *.o *.a\n\t$(RM) -f static_test\n\t$(RM) -f test\n" }, { "path": "contrib/linux-kernel/test/include/linux/compiler.h", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n#ifndef LINUX_COMPILER_H\n#define LINUX_COMPILER_H\n\n#ifndef inline\n#define inline __inline __attribute__((unused))\n#endif\n\n#ifndef noinline\n#define noinline __attribute__((noinline))\n#endif\n\n#define fallthrough __attribute__((__fallthrough__))\n\n#endif\n" }, { "path": "contrib/linux-kernel/test/include/linux/errno.h", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n#ifndef LINUX_ERRNO_H\n#define LINUX_ERRNO_H\n\n#define EINVAL 22\n\n#endif\n" }, { "path": "contrib/linux-kernel/test/include/linux/kernel.h", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n#ifndef LINUX_KERNEL_H\n#define LINUX_KERNEL_H\n\n#define WARN_ON(x)\n\n#define PTR_ALIGN(p, a) (typeof(p))ALIGN((unsigned long long)(p), (a))\n#define ALIGN(x, a) ALIGN_MASK((x), (a) - 1)\n#define ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask))\n\n#endif\n" }, { "path": "contrib/linux-kernel/test/include/linux/limits.h", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n#ifndef LINUX_LIMITS_H\n#define LINUX_LIMITS_H\n\n#include \n\n#endif\n" }, { "path": "contrib/linux-kernel/test/include/linux/math64.h", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n#ifndef LINUX_MATH64_H\n#define LINUX_MATH64_H\n\n#define div_u64(dividend, divisor) ((dividend) / (divisor))\n\n#endif\n" }, { "path": "contrib/linux-kernel/test/include/linux/module.h", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n#ifndef LINUX_MODULE_H\n#define LINUX_MODULE_H\n\n#define EXPORT_SYMBOL(symbol) \\\n void* __##symbol = symbol\n#define EXPORT_SYMBOL_GPL(symbol) \\\n void* __##symbol = symbol\n#define MODULE_LICENSE(license)\n#define MODULE_DESCRIPTION(description)\n\n#endif\n" }, { "path": "contrib/linux-kernel/test/include/linux/printk.h", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n#ifndef LINUX_PRINTK_H\n#define LINUX_PRINTK_H\n\n#define pr_debug(...)\n\n#endif\n" }, { "path": "contrib/linux-kernel/test/include/linux/stddef.h", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n#ifndef LINUX_STDDEF_H\n#define LINUX_STDDEF_H\n\n#include \n\n#endif\n" }, { "path": "contrib/linux-kernel/test/include/linux/swab.h", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n#ifndef LINUX_SWAB_H\n#define LINUX_SWAB_H\n\n#define swab32(x) __builtin_bswap32((x))\n#define swab64(x) __builtin_bswap64((x))\n\n#endif\n" }, { "path": "contrib/linux-kernel/test/include/linux/types.h", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n#ifndef LINUX_TYPES_H\n#define LINUX_TYPES_H\n\n#include \n#include \n\n#endif\n" }, { "path": "contrib/linux-kernel/test/include/linux/unaligned.h", "content": "#ifndef ASM_UNALIGNED_H\n#define ASM_UNALIGNED_H\n\n#include \n#include \n\n#ifndef __LITTLE_ENDIAN\n# if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || defined(__LITTLE_ENDIAN__)\n# define __LITTLE_ENDIAN 1\n# endif\n#endif\n\n#ifdef __LITTLE_ENDIAN\n# define _IS_LITTLE_ENDIAN 1\n#else\n# define _IS_LITTLE_ENDIAN 0\n#endif\n\nstatic unsigned _isLittleEndian(void)\n{\n const union { uint32_t u; uint8_t c[4]; } one = { 1 };\n assert(_IS_LITTLE_ENDIAN == one.c[0]);\n (void)one;\n return _IS_LITTLE_ENDIAN;\n}\n\nstatic uint16_t _swap16(uint16_t in)\n{\n return ((in & 0xF) << 8) + ((in & 0xF0) >> 8);\n}\n\nstatic uint32_t _swap32(uint32_t in)\n{\n return __builtin_bswap32(in);\n}\n\nstatic uint64_t _swap64(uint64_t in)\n{\n return __builtin_bswap64(in);\n}\n\n/* Little endian */\nstatic uint16_t get_unaligned_le16(const void* memPtr)\n{\n uint16_t val;\n __builtin_memcpy(&val, memPtr, sizeof(val));\n if (!_isLittleEndian()) _swap16(val);\n return val;\n}\n\nstatic uint32_t get_unaligned_le32(const void* memPtr)\n{\n uint32_t val;\n __builtin_memcpy(&val, memPtr, sizeof(val));\n if (!_isLittleEndian()) _swap32(val);\n return val;\n}\n\nstatic uint64_t get_unaligned_le64(const void* memPtr)\n{\n uint64_t val;\n __builtin_memcpy(&val, memPtr, sizeof(val));\n if (!_isLittleEndian()) _swap64(val);\n return val;\n}\n\nstatic void put_unaligned_le16(uint16_t value, void* memPtr)\n{\n if (!_isLittleEndian()) value = _swap16(value);\n __builtin_memcpy(memPtr, &value, sizeof(value));\n}\n\nstatic void put_unaligned_le32(uint32_t value, void* memPtr)\n{\n if (!_isLittleEndian()) value = _swap32(value);\n __builtin_memcpy(memPtr, &value, sizeof(value));\n}\n\nstatic void put_unaligned_le64(uint64_t value, void* memPtr)\n{\n if (!_isLittleEndian()) value = _swap64(value);\n __builtin_memcpy(memPtr, &value, sizeof(value));\n}\n\n/* big endian */\nstatic uint32_t get_unaligned_be32(const void* memPtr)\n{\n uint32_t val;\n __builtin_memcpy(&val, memPtr, sizeof(val));\n if (_isLittleEndian()) _swap32(val);\n return val;\n}\n\nstatic uint64_t get_unaligned_be64(const void* memPtr)\n{\n uint64_t val;\n __builtin_memcpy(&val, memPtr, sizeof(val));\n if (_isLittleEndian()) _swap64(val);\n return val;\n}\n\nstatic void put_unaligned_be32(uint32_t value, void* memPtr)\n{\n if (_isLittleEndian()) value = _swap32(value);\n __builtin_memcpy(memPtr, &value, sizeof(value));\n}\n\nstatic void put_unaligned_be64(uint64_t value, void* memPtr)\n{\n if (_isLittleEndian()) value = _swap64(value);\n __builtin_memcpy(memPtr, &value, sizeof(value));\n}\n\n/* generic */\nextern void __bad_unaligned_access_size(void);\n\n#define __get_unaligned_le(ptr) ((typeof(*(ptr)))({ \\\n __builtin_choose_expr(sizeof(*(ptr)) == 1, *(ptr), \\\n __builtin_choose_expr(sizeof(*(ptr)) == 2, get_unaligned_le16((ptr)), \\\n __builtin_choose_expr(sizeof(*(ptr)) == 4, get_unaligned_le32((ptr)), \\\n __builtin_choose_expr(sizeof(*(ptr)) == 8, get_unaligned_le64((ptr)), \\\n __bad_unaligned_access_size())))); \\\n }))\n\n#define __get_unaligned_be(ptr) ((typeof(*(ptr)))({ \\\n __builtin_choose_expr(sizeof(*(ptr)) == 1, *(ptr), \\\n __builtin_choose_expr(sizeof(*(ptr)) == 2, get_unaligned_be16((ptr)), \\\n __builtin_choose_expr(sizeof(*(ptr)) == 4, get_unaligned_be32((ptr)), \\\n __builtin_choose_expr(sizeof(*(ptr)) == 8, get_unaligned_be64((ptr)), \\\n __bad_unaligned_access_size())))); \\\n }))\n\n#define __put_unaligned_le(val, ptr) \\\n ({ \\\n void *__gu_p = (ptr); \\\n switch (sizeof(*(ptr))) { \\\n case 1: \\\n *(uint8_t *)__gu_p = (uint8_t)(val); \\\n break; \\\n case 2: \\\n put_unaligned_le16((uint16_t)(val), __gu_p); \\\n break; \\\n case 4: \\\n put_unaligned_le32((uint32_t)(val), __gu_p); \\\n break; \\\n case 8: \\\n put_unaligned_le64((uint64_t)(val), __gu_p); \\\n break; \\\n default: \\\n __bad_unaligned_access_size(); \\\n break; \\\n } \\\n (void)0; \\\n })\n\n#define __put_unaligned_be(val, ptr) \\\n ({ \\\n void *__gu_p = (ptr); \\\n switch (sizeof(*(ptr))) { \\\n case 1: \\\n *(uint8_t *)__gu_p = (uint8_t)(val); \\\n break; \\\n case 2: \\\n put_unaligned_be16((uint16_t)(val), __gu_p); \\\n break; \\\n case 4: \\\n put_unaligned_be32((uint32_t)(val), __gu_p); \\\n break; \\\n case 8: \\\n put_unaligned_be64((uint64_t)(val), __gu_p); \\\n break; \\\n default: \\\n __bad_unaligned_access_size(); \\\n break; \\\n } \\\n (void)0; \\\n })\n\n#if _IS_LITTLE_ENDIAN\n# define get_unaligned __get_unaligned_le\n# define put_unaligned __put_unaligned_le\n#else\n# define get_unaligned __get_unaligned_be\n# define put_unaligned __put_unaligned_be\n#endif\n\n#endif // ASM_UNALIGNED_H\n" }, { "path": "contrib/linux-kernel/test/include/linux/xxhash.h", "content": "/*\n * xxHash - Extremely Fast Hash algorithm\n * Copyright (C) 2012-2016, Yann Collet.\n *\n * BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php)\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following disclaimer\n * in the documentation and/or other materials provided with the\n * distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *\n * This program is free software; you can redistribute it and/or modify it under\n * the terms of the GNU General Public License version 2 as published by the\n * Free Software Foundation. This program is dual-licensed; you may select\n * either version 2 of the GNU General Public License (\"GPL\") or BSD license\n * (\"BSD\").\n *\n * You can contact the author at:\n * - xxHash homepage: https://cyan4973.github.io/xxHash/\n * - xxHash source repository: https://github.com/Cyan4973/xxHash\n */\n\n/*\n * Notice extracted from xxHash homepage:\n *\n * xxHash is an extremely fast Hash algorithm, running at RAM speed limits.\n * It also successfully passes all tests from the SMHasher suite.\n *\n * Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2\n * Duo @3GHz)\n *\n * Name Speed Q.Score Author\n * xxHash 5.4 GB/s 10\n * CrapWow 3.2 GB/s 2 Andrew\n * MumurHash 3a 2.7 GB/s 10 Austin Appleby\n * SpookyHash 2.0 GB/s 10 Bob Jenkins\n * SBox 1.4 GB/s 9 Bret Mulvey\n * Lookup3 1.2 GB/s 9 Bob Jenkins\n * SuperFastHash 1.2 GB/s 1 Paul Hsieh\n * CityHash64 1.05 GB/s 10 Pike & Alakuijala\n * FNV 0.55 GB/s 5 Fowler, Noll, Vo\n * CRC32 0.43 GB/s 9\n * MD5-32 0.33 GB/s 10 Ronald L. Rivest\n * SHA1-32 0.28 GB/s 10\n *\n * Q.Score is a measure of quality of the hash function.\n * It depends on successfully passing SMHasher test set.\n * 10 is a perfect score.\n *\n * A 64-bits version, named xxh64 offers much better speed,\n * but for 64-bits applications only.\n * Name Speed on 64 bits Speed on 32 bits\n * xxh64 13.8 GB/s 1.9 GB/s\n * xxh32 6.8 GB/s 6.0 GB/s\n */\n\n#ifndef XXHASH_H\n#define XXHASH_H\n\n#include \n\n#define XXH_API static inline __attribute__((unused))\n/*-****************************\n * Simple Hash Functions\n *****************************/\n\n/**\n * xxh32() - calculate the 32-bit hash of the input with a given seed.\n *\n * @input: The data to hash.\n * @length: The length of the data to hash.\n * @seed: The seed can be used to alter the result predictably.\n *\n * Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s\n *\n * Return: The 32-bit hash of the data.\n */\nXXH_API uint32_t xxh32(const void *input, size_t length, uint32_t seed);\n\n/**\n * xxh64() - calculate the 64-bit hash of the input with a given seed.\n *\n * @input: The data to hash.\n * @length: The length of the data to hash.\n * @seed: The seed can be used to alter the result predictably.\n *\n * This function runs 2x faster on 64-bit systems, but slower on 32-bit systems.\n *\n * Return: The 64-bit hash of the data.\n */\nXXH_API uint64_t xxh64(const void *input, size_t length, uint64_t seed);\n\n/**\n * xxhash() - calculate wordsize hash of the input with a given seed\n * @input: The data to hash.\n * @length: The length of the data to hash.\n * @seed: The seed can be used to alter the result predictably.\n *\n * If the hash does not need to be comparable between machines with\n * different word sizes, this function will call whichever of xxh32()\n * or xxh64() is faster.\n *\n * Return: wordsize hash of the data.\n */\n\nstatic inline unsigned long xxhash(const void *input, size_t length,\n\t\t\t\t uint64_t seed)\n{\n\tif (sizeof(size_t) == 8)\n\t\treturn xxh64(input, length, seed);\n\telse\n\t\treturn xxh32(input, length, seed);\n}\n\n/*-****************************\n * Streaming Hash Functions\n *****************************/\n\n/*\n * These definitions are only meant to allow allocation of XXH state\n * statically, on stack, or in a struct for example.\n * Do not use members directly.\n */\n\n/**\n * struct xxh32_state - private xxh32 state, do not use members directly\n */\nstruct xxh32_state {\n\tuint32_t total_len_32;\n\tuint32_t large_len;\n\tuint32_t v1;\n\tuint32_t v2;\n\tuint32_t v3;\n\tuint32_t v4;\n\tuint32_t mem32[4];\n\tuint32_t memsize;\n};\n\n/**\n * struct xxh32_state - private xxh64 state, do not use members directly\n */\nstruct xxh64_state {\n\tuint64_t total_len;\n\tuint64_t v1;\n\tuint64_t v2;\n\tuint64_t v3;\n\tuint64_t v4;\n\tuint64_t mem64[4];\n\tuint32_t memsize;\n};\n\n/**\n * xxh32_reset() - reset the xxh32 state to start a new hashing operation\n *\n * @state: The xxh32 state to reset.\n * @seed: Initialize the hash state with this seed.\n *\n * Call this function on any xxh32_state to prepare for a new hashing operation.\n */\nXXH_API void xxh32_reset(struct xxh32_state *state, uint32_t seed);\n\n/**\n * xxh32_update() - hash the data given and update the xxh32 state\n *\n * @state: The xxh32 state to update.\n * @input: The data to hash.\n * @length: The length of the data to hash.\n *\n * After calling xxh32_reset() call xxh32_update() as many times as necessary.\n *\n * Return: Zero on success, otherwise an error code.\n */\nXXH_API int xxh32_update(struct xxh32_state *state, const void *input, size_t length);\n\n/**\n * xxh32_digest() - produce the current xxh32 hash\n *\n * @state: Produce the current xxh32 hash of this state.\n *\n * A hash value can be produced at any time. It is still possible to continue\n * inserting input into the hash state after a call to xxh32_digest(), and\n * generate new hashes later on, by calling xxh32_digest() again.\n *\n * Return: The xxh32 hash stored in the state.\n */\nXXH_API uint32_t xxh32_digest(const struct xxh32_state *state);\n\n/**\n * xxh64_reset() - reset the xxh64 state to start a new hashing operation\n *\n * @state: The xxh64 state to reset.\n * @seed: Initialize the hash state with this seed.\n */\nXXH_API void xxh64_reset(struct xxh64_state *state, uint64_t seed);\n\n/**\n * xxh64_update() - hash the data given and update the xxh64 state\n * @state: The xxh64 state to update.\n * @input: The data to hash.\n * @length: The length of the data to hash.\n *\n * After calling xxh64_reset() call xxh64_update() as many times as necessary.\n *\n * Return: Zero on success, otherwise an error code.\n */\nXXH_API int xxh64_update(struct xxh64_state *state, const void *input, size_t length);\n\n/**\n * xxh64_digest() - produce the current xxh64 hash\n *\n * @state: Produce the current xxh64 hash of this state.\n *\n * A hash value can be produced at any time. It is still possible to continue\n * inserting input into the hash state after a call to xxh64_digest(), and\n * generate new hashes later on, by calling xxh64_digest() again.\n *\n * Return: The xxh64 hash stored in the state.\n */\nXXH_API uint64_t xxh64_digest(const struct xxh64_state *state);\n\n/*-**************************\n * Utils\n ***************************/\n\n/**\n * xxh32_copy_state() - copy the source state into the destination state\n *\n * @src: The source xxh32 state.\n * @dst: The destination xxh32 state.\n */\nXXH_API void xxh32_copy_state(struct xxh32_state *dst, const struct xxh32_state *src);\n\n/**\n * xxh64_copy_state() - copy the source state into the destination state\n *\n * @src: The source xxh64 state.\n * @dst: The destination xxh64 state.\n */\nXXH_API void xxh64_copy_state(struct xxh64_state *dst, const struct xxh64_state *src);\n\n/*\n * xxHash - Extremely Fast Hash algorithm\n * Copyright (C) 2012-2016, Yann Collet.\n *\n * BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php)\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are\n * met:\n *\n * * Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n * * Redistributions in binary form must reproduce the above\n * copyright notice, this list of conditions and the following disclaimer\n * in the documentation and/or other materials provided with the\n * distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *\n * This program is free software; you can redistribute it and/or modify it under\n * the terms of the GNU General Public License version 2 as published by the\n * Free Software Foundation. This program is dual-licensed; you may select\n * either version 2 of the GNU General Public License (\"GPL\") or BSD license\n * (\"BSD\").\n *\n * You can contact the author at:\n * - xxHash homepage: https://cyan4973.github.io/xxHash/\n * - xxHash source repository: https://github.com/Cyan4973/xxHash\n */\n\n#include \n#include \n#include \n#include \n#include \n\n/*-*************************************\n * Macros\n **************************************/\n#define xxh_rotl32(x, r) ((x << r) | (x >> (32 - r)))\n#define xxh_rotl64(x, r) ((x << r) | (x >> (64 - r)))\n\n#ifdef __LITTLE_ENDIAN\n# define XXH_CPU_LITTLE_ENDIAN 1\n#else\n# define XXH_CPU_LITTLE_ENDIAN 0\n#endif\n\n/*-*************************************\n * Constants\n **************************************/\nstatic const uint32_t PRIME32_1 = 2654435761U;\nstatic const uint32_t PRIME32_2 = 2246822519U;\nstatic const uint32_t PRIME32_3 = 3266489917U;\nstatic const uint32_t PRIME32_4 = 668265263U;\nstatic const uint32_t PRIME32_5 = 374761393U;\n\nstatic const uint64_t PRIME64_1 = 11400714785074694791ULL;\nstatic const uint64_t PRIME64_2 = 14029467366897019727ULL;\nstatic const uint64_t PRIME64_3 = 1609587929392839161ULL;\nstatic const uint64_t PRIME64_4 = 9650029242287828579ULL;\nstatic const uint64_t PRIME64_5 = 2870177450012600261ULL;\n\n/*-**************************\n * Utils\n ***************************/\nXXH_API void xxh32_copy_state(struct xxh32_state *dst, const struct xxh32_state *src)\n{\n\t__builtin_memcpy(dst, src, sizeof(*dst));\n}\n\nXXH_API void xxh64_copy_state(struct xxh64_state *dst, const struct xxh64_state *src)\n{\n\t__builtin_memcpy(dst, src, sizeof(*dst));\n}\n\n/*-***************************\n * Simple Hash Functions\n ****************************/\nstatic uint32_t xxh32_round(uint32_t seed, const uint32_t input)\n{\n\tseed += input * PRIME32_2;\n\tseed = xxh_rotl32(seed, 13);\n\tseed *= PRIME32_1;\n\treturn seed;\n}\n\nXXH_API uint32_t xxh32(const void *input, const size_t len, const uint32_t seed)\n{\n\tconst uint8_t *p = (const uint8_t *)input;\n\tconst uint8_t *b_end = p + len;\n\tuint32_t h32;\n\n\tif (len >= 16) {\n\t\tconst uint8_t *const limit = b_end - 16;\n\t\tuint32_t v1 = seed + PRIME32_1 + PRIME32_2;\n\t\tuint32_t v2 = seed + PRIME32_2;\n\t\tuint32_t v3 = seed + 0;\n\t\tuint32_t v4 = seed - PRIME32_1;\n\n\t\tdo {\n\t\t\tv1 = xxh32_round(v1, get_unaligned_le32(p));\n\t\t\tp += 4;\n\t\t\tv2 = xxh32_round(v2, get_unaligned_le32(p));\n\t\t\tp += 4;\n\t\t\tv3 = xxh32_round(v3, get_unaligned_le32(p));\n\t\t\tp += 4;\n\t\t\tv4 = xxh32_round(v4, get_unaligned_le32(p));\n\t\t\tp += 4;\n\t\t} while (p <= limit);\n\n\t\th32 = xxh_rotl32(v1, 1) + xxh_rotl32(v2, 7) +\n\t\t\txxh_rotl32(v3, 12) + xxh_rotl32(v4, 18);\n\t} else {\n\t\th32 = seed + PRIME32_5;\n\t}\n\n\th32 += (uint32_t)len;\n\n\twhile (p + 4 <= b_end) {\n\t\th32 += get_unaligned_le32(p) * PRIME32_3;\n\t\th32 = xxh_rotl32(h32, 17) * PRIME32_4;\n\t\tp += 4;\n\t}\n\n\twhile (p < b_end) {\n\t\th32 += (*p) * PRIME32_5;\n\t\th32 = xxh_rotl32(h32, 11) * PRIME32_1;\n\t\tp++;\n\t}\n\n\th32 ^= h32 >> 15;\n\th32 *= PRIME32_2;\n\th32 ^= h32 >> 13;\n\th32 *= PRIME32_3;\n\th32 ^= h32 >> 16;\n\n\treturn h32;\n}\n\nstatic uint64_t xxh64_round(uint64_t acc, const uint64_t input)\n{\n\tacc += input * PRIME64_2;\n\tacc = xxh_rotl64(acc, 31);\n\tacc *= PRIME64_1;\n\treturn acc;\n}\n\nstatic uint64_t xxh64_merge_round(uint64_t acc, uint64_t val)\n{\n\tval = xxh64_round(0, val);\n\tacc ^= val;\n\tacc = acc * PRIME64_1 + PRIME64_4;\n\treturn acc;\n}\n\nXXH_API uint64_t xxh64(const void *input, const size_t len, const uint64_t seed)\n{\n\tconst uint8_t *p = (const uint8_t *)input;\n\tconst uint8_t *const b_end = p + len;\n\tuint64_t h64;\n\n\tif (len >= 32) {\n\t\tconst uint8_t *const limit = b_end - 32;\n\t\tuint64_t v1 = seed + PRIME64_1 + PRIME64_2;\n\t\tuint64_t v2 = seed + PRIME64_2;\n\t\tuint64_t v3 = seed + 0;\n\t\tuint64_t v4 = seed - PRIME64_1;\n\n\t\tdo {\n\t\t\tv1 = xxh64_round(v1, get_unaligned_le64(p));\n\t\t\tp += 8;\n\t\t\tv2 = xxh64_round(v2, get_unaligned_le64(p));\n\t\t\tp += 8;\n\t\t\tv3 = xxh64_round(v3, get_unaligned_le64(p));\n\t\t\tp += 8;\n\t\t\tv4 = xxh64_round(v4, get_unaligned_le64(p));\n\t\t\tp += 8;\n\t\t} while (p <= limit);\n\n\t\th64 = xxh_rotl64(v1, 1) + xxh_rotl64(v2, 7) +\n\t\t\txxh_rotl64(v3, 12) + xxh_rotl64(v4, 18);\n\t\th64 = xxh64_merge_round(h64, v1);\n\t\th64 = xxh64_merge_round(h64, v2);\n\t\th64 = xxh64_merge_round(h64, v3);\n\t\th64 = xxh64_merge_round(h64, v4);\n\n\t} else {\n\t\th64 = seed + PRIME64_5;\n\t}\n\n\th64 += (uint64_t)len;\n\n\twhile (p + 8 <= b_end) {\n\t\tconst uint64_t k1 = xxh64_round(0, get_unaligned_le64(p));\n\n\t\th64 ^= k1;\n\t\th64 = xxh_rotl64(h64, 27) * PRIME64_1 + PRIME64_4;\n\t\tp += 8;\n\t}\n\n\tif (p + 4 <= b_end) {\n\t\th64 ^= (uint64_t)(get_unaligned_le32(p)) * PRIME64_1;\n\t\th64 = xxh_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;\n\t\tp += 4;\n\t}\n\n\twhile (p < b_end) {\n\t\th64 ^= (*p) * PRIME64_5;\n\t\th64 = xxh_rotl64(h64, 11) * PRIME64_1;\n\t\tp++;\n\t}\n\n\th64 ^= h64 >> 33;\n\th64 *= PRIME64_2;\n\th64 ^= h64 >> 29;\n\th64 *= PRIME64_3;\n\th64 ^= h64 >> 32;\n\n\treturn h64;\n}\n\n/*-**************************************************\n * Advanced Hash Functions\n ***************************************************/\nXXH_API void xxh32_reset(struct xxh32_state *statePtr, const uint32_t seed)\n{\n\t/* use a local state for memcpy() to avoid strict-aliasing warnings */\n\tstruct xxh32_state state;\n\n\t__builtin_memset(&state, 0, sizeof(state));\n\tstate.v1 = seed + PRIME32_1 + PRIME32_2;\n\tstate.v2 = seed + PRIME32_2;\n\tstate.v3 = seed + 0;\n\tstate.v4 = seed - PRIME32_1;\n\t__builtin_memcpy(statePtr, &state, sizeof(state));\n}\n\nXXH_API void xxh64_reset(struct xxh64_state *statePtr, const uint64_t seed)\n{\n\t/* use a local state for memcpy() to avoid strict-aliasing warnings */\n\tstruct xxh64_state state;\n\n\t__builtin_memset(&state, 0, sizeof(state));\n\tstate.v1 = seed + PRIME64_1 + PRIME64_2;\n\tstate.v2 = seed + PRIME64_2;\n\tstate.v3 = seed + 0;\n\tstate.v4 = seed - PRIME64_1;\n\t__builtin_memcpy(statePtr, &state, sizeof(state));\n}\n\nXXH_API int xxh32_update(struct xxh32_state *state, const void *input, const size_t len)\n{\n\tconst uint8_t *p = (const uint8_t *)input;\n\tconst uint8_t *const b_end = p + len;\n\n\tif (input == NULL)\n\t\treturn -EINVAL;\n\n\tstate->total_len_32 += (uint32_t)len;\n\tstate->large_len |= (len >= 16) | (state->total_len_32 >= 16);\n\n\tif (state->memsize + len < 16) { /* fill in tmp buffer */\n\t\t__builtin_memcpy((uint8_t *)(state->mem32) + state->memsize, input, len);\n\t\tstate->memsize += (uint32_t)len;\n\t\treturn 0;\n\t}\n\n\tif (state->memsize) { /* some data left from previous update */\n\t\tconst uint32_t *p32 = state->mem32;\n\n\t\t__builtin_memcpy((uint8_t *)(state->mem32) + state->memsize, input,\n\t\t\t16 - state->memsize);\n\n\t\tstate->v1 = xxh32_round(state->v1, get_unaligned_le32(p32));\n\t\tp32++;\n\t\tstate->v2 = xxh32_round(state->v2, get_unaligned_le32(p32));\n\t\tp32++;\n\t\tstate->v3 = xxh32_round(state->v3, get_unaligned_le32(p32));\n\t\tp32++;\n\t\tstate->v4 = xxh32_round(state->v4, get_unaligned_le32(p32));\n\t\tp32++;\n\n\t\tp += 16-state->memsize;\n\t\tstate->memsize = 0;\n\t}\n\n\tif (p <= b_end - 16) {\n\t\tconst uint8_t *const limit = b_end - 16;\n\t\tuint32_t v1 = state->v1;\n\t\tuint32_t v2 = state->v2;\n\t\tuint32_t v3 = state->v3;\n\t\tuint32_t v4 = state->v4;\n\n\t\tdo {\n\t\t\tv1 = xxh32_round(v1, get_unaligned_le32(p));\n\t\t\tp += 4;\n\t\t\tv2 = xxh32_round(v2, get_unaligned_le32(p));\n\t\t\tp += 4;\n\t\t\tv3 = xxh32_round(v3, get_unaligned_le32(p));\n\t\t\tp += 4;\n\t\t\tv4 = xxh32_round(v4, get_unaligned_le32(p));\n\t\t\tp += 4;\n\t\t} while (p <= limit);\n\n\t\tstate->v1 = v1;\n\t\tstate->v2 = v2;\n\t\tstate->v3 = v3;\n\t\tstate->v4 = v4;\n\t}\n\n\tif (p < b_end) {\n\t\t__builtin_memcpy(state->mem32, p, (size_t)(b_end-p));\n\t\tstate->memsize = (uint32_t)(b_end-p);\n\t}\n\n\treturn 0;\n}\n\nXXH_API uint32_t xxh32_digest(const struct xxh32_state *state)\n{\n\tconst uint8_t *p = (const uint8_t *)state->mem32;\n\tconst uint8_t *const b_end = (const uint8_t *)(state->mem32) +\n\t\tstate->memsize;\n\tuint32_t h32;\n\n\tif (state->large_len) {\n\t\th32 = xxh_rotl32(state->v1, 1) + xxh_rotl32(state->v2, 7) +\n\t\t\txxh_rotl32(state->v3, 12) + xxh_rotl32(state->v4, 18);\n\t} else {\n\t\th32 = state->v3 /* == seed */ + PRIME32_5;\n\t}\n\n\th32 += state->total_len_32;\n\n\twhile (p + 4 <= b_end) {\n\t\th32 += get_unaligned_le32(p) * PRIME32_3;\n\t\th32 = xxh_rotl32(h32, 17) * PRIME32_4;\n\t\tp += 4;\n\t}\n\n\twhile (p < b_end) {\n\t\th32 += (*p) * PRIME32_5;\n\t\th32 = xxh_rotl32(h32, 11) * PRIME32_1;\n\t\tp++;\n\t}\n\n\th32 ^= h32 >> 15;\n\th32 *= PRIME32_2;\n\th32 ^= h32 >> 13;\n\th32 *= PRIME32_3;\n\th32 ^= h32 >> 16;\n\n\treturn h32;\n}\n\nXXH_API int xxh64_update(struct xxh64_state *state, const void *input, const size_t len)\n{\n\tconst uint8_t *p = (const uint8_t *)input;\n\tconst uint8_t *const b_end = p + len;\n\n\tif (input == NULL)\n\t\treturn -EINVAL;\n\n\tstate->total_len += len;\n\n\tif (state->memsize + len < 32) { /* fill in tmp buffer */\n\t\t__builtin_memcpy(((uint8_t *)state->mem64) + state->memsize, input, len);\n\t\tstate->memsize += (uint32_t)len;\n\t\treturn 0;\n\t}\n\n\tif (state->memsize) { /* tmp buffer is full */\n\t\tuint64_t *p64 = state->mem64;\n\n\t\t__builtin_memcpy(((uint8_t *)p64) + state->memsize, input,\n\t\t\t32 - state->memsize);\n\n\t\tstate->v1 = xxh64_round(state->v1, get_unaligned_le64(p64));\n\t\tp64++;\n\t\tstate->v2 = xxh64_round(state->v2, get_unaligned_le64(p64));\n\t\tp64++;\n\t\tstate->v3 = xxh64_round(state->v3, get_unaligned_le64(p64));\n\t\tp64++;\n\t\tstate->v4 = xxh64_round(state->v4, get_unaligned_le64(p64));\n\n\t\tp += 32 - state->memsize;\n\t\tstate->memsize = 0;\n\t}\n\n\tif (p + 32 <= b_end) {\n\t\tconst uint8_t *const limit = b_end - 32;\n\t\tuint64_t v1 = state->v1;\n\t\tuint64_t v2 = state->v2;\n\t\tuint64_t v3 = state->v3;\n\t\tuint64_t v4 = state->v4;\n\n\t\tdo {\n\t\t\tv1 = xxh64_round(v1, get_unaligned_le64(p));\n\t\t\tp += 8;\n\t\t\tv2 = xxh64_round(v2, get_unaligned_le64(p));\n\t\t\tp += 8;\n\t\t\tv3 = xxh64_round(v3, get_unaligned_le64(p));\n\t\t\tp += 8;\n\t\t\tv4 = xxh64_round(v4, get_unaligned_le64(p));\n\t\t\tp += 8;\n\t\t} while (p <= limit);\n\n\t\tstate->v1 = v1;\n\t\tstate->v2 = v2;\n\t\tstate->v3 = v3;\n\t\tstate->v4 = v4;\n\t}\n\n\tif (p < b_end) {\n\t\t__builtin_memcpy(state->mem64, p, (size_t)(b_end-p));\n\t\tstate->memsize = (uint32_t)(b_end - p);\n\t}\n\n\treturn 0;\n}\n\nXXH_API uint64_t xxh64_digest(const struct xxh64_state *state)\n{\n\tconst uint8_t *p = (const uint8_t *)state->mem64;\n\tconst uint8_t *const b_end = (const uint8_t *)state->mem64 +\n\t\tstate->memsize;\n\tuint64_t h64;\n\n\tif (state->total_len >= 32) {\n\t\tconst uint64_t v1 = state->v1;\n\t\tconst uint64_t v2 = state->v2;\n\t\tconst uint64_t v3 = state->v3;\n\t\tconst uint64_t v4 = state->v4;\n\n\t\th64 = xxh_rotl64(v1, 1) + xxh_rotl64(v2, 7) +\n\t\t\txxh_rotl64(v3, 12) + xxh_rotl64(v4, 18);\n\t\th64 = xxh64_merge_round(h64, v1);\n\t\th64 = xxh64_merge_round(h64, v2);\n\t\th64 = xxh64_merge_round(h64, v3);\n\t\th64 = xxh64_merge_round(h64, v4);\n\t} else {\n\t\th64 = state->v3 + PRIME64_5;\n\t}\n\n\th64 += (uint64_t)state->total_len;\n\n\twhile (p + 8 <= b_end) {\n\t\tconst uint64_t k1 = xxh64_round(0, get_unaligned_le64(p));\n\n\t\th64 ^= k1;\n\t\th64 = xxh_rotl64(h64, 27) * PRIME64_1 + PRIME64_4;\n\t\tp += 8;\n\t}\n\n\tif (p + 4 <= b_end) {\n\t\th64 ^= (uint64_t)(get_unaligned_le32(p)) * PRIME64_1;\n\t\th64 = xxh_rotl64(h64, 23) * PRIME64_2 + PRIME64_3;\n\t\tp += 4;\n\t}\n\n\twhile (p < b_end) {\n\t\th64 ^= (*p) * PRIME64_5;\n\t\th64 = xxh_rotl64(h64, 11) * PRIME64_1;\n\t\tp++;\n\t}\n\n\th64 ^= h64 >> 33;\n\th64 *= PRIME64_2;\n\th64 ^= h64 >> 29;\n\th64 *= PRIME64_3;\n\th64 ^= h64 >> 32;\n\n\treturn h64;\n}\n\n#endif /* XXHASH_H */\n" }, { "path": "contrib/linux-kernel/test/macro-test.sh", "content": "#!/usr/bin/env sh\n\nset -e\n\nSCRIPT_DIR=$(cd \"$(dirname \"$0\")\" && pwd)\nINCLUDE_DIR=\"$SCRIPT_DIR/../linux/include\"\nLIB_DIR=\"$SCRIPT_DIR/../linux/lib\"\n\n\nprint() {\n printf '%b' \"${*}\"\n}\n\nprintln() {\n printf '%b\\n' \"${*}\"\n}\n\ndie() {\n println \"$@\" 1>&2\n exit 1\n}\n\ntest_not_present() {\n print \"Testing that '$1' is not present... \"\n grep -r $1 \"$INCLUDE_DIR\" \"$LIB_DIR\" && die \"Fail!\"\n println \"Okay\"\n}\n\nprintln \"This test checks that the macro removal process worked as expected\"\nprintln \"If this test fails, then freestanding.py wasn't able to remove one of these\"\nprintln \"macros from the source code completely. You'll either need to rewrite the check\"\nprintln \"or improve freestanding.py.\"\nprintln \"\"\n\ntest_not_present \"ZSTD_NO_INTRINSICS\"\ntest_not_present \"ZSTD_NO_UNUSED_FUNCTIONS\"\ntest_not_present \"ZSTD_LEGACY_SUPPORT\"\ntest_not_present \"STATIC_BMI2\"\ntest_not_present \"ZSTD_DLL_EXPORT\"\ntest_not_present \"ZSTD_DLL_IMPORT\"\ntest_not_present \"__ICCARM__\"\ntest_not_present \"_MSC_VER\"\ntest_not_present \"_WIN32\"\ntest_not_present \"__linux__\"\n" }, { "path": "contrib/linux-kernel/test/static_test.c", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n#include \n#include \n#include \n#include \n\n#include \"decompress_sources.h\"\n#include \n\n#define CONTROL(x) \\\n do { \\\n if (!(x)) { \\\n fprintf(stderr, \"%s:%u: %s failed!\\n\", __FUNCTION__, __LINE__, #x); \\\n abort(); \\\n } \\\n } while (0)\n\n\nstatic const char kEmptyZstdFrame[] = {\n 0x28, 0xb5, 0x2f, 0xfd, 0x24, 0x00, 0x01, 0x00, 0x00, 0x99, 0xe9, 0xd8, 0x51\n};\n\nstatic void test_decompress_unzstd(void) {\n fprintf(stderr, \"Testing decompress unzstd... \");\n {\n size_t const wkspSize = zstd_dctx_workspace_bound();\n void* wksp = malloc(wkspSize);\n ZSTD_DCtx* dctx = zstd_init_dctx(wksp, wkspSize);\n CONTROL(wksp != NULL);\n CONTROL(dctx != NULL);\n {\n size_t const dSize = zstd_decompress_dctx(dctx, NULL, 0, kEmptyZstdFrame, sizeof(kEmptyZstdFrame));\n CONTROL(!zstd_is_error(dSize));\n CONTROL(dSize == 0);\n }\n free(wksp);\n }\n fprintf(stderr, \"Ok\\n\");\n}\n\nint main(void) {\n test_decompress_unzstd();\n return 0;\n}\n" }, { "path": "contrib/linux-kernel/test/test.c", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n#include \n#include \n#include \n#include \n\n#include \n\n#define CONTROL(x) \\\n do { \\\n if (!(x)) { \\\n fprintf(stderr, \"%s:%u: %s failed!\\n\", __FUNCTION__, __LINE__, #x); \\\n abort(); \\\n } \\\n } while (0)\n\ntypedef struct {\n char *data;\n char *data2;\n size_t dataSize;\n char *comp;\n size_t compSize;\n} test_data_t;\n\nstatic test_data_t create_test_data(void) {\n test_data_t data;\n data.dataSize = 128 * 1024;\n data.data = (char*)malloc(data.dataSize);\n CONTROL(data.data != NULL);\n data.data2 = (char*)malloc(data.dataSize);\n CONTROL(data.data2 != NULL);\n data.compSize = zstd_compress_bound(data.dataSize);\n data.comp = (char*)malloc(data.compSize);\n CONTROL(data.comp != NULL);\n memset(data.data, 0, data.dataSize);\n return data;\n}\n\nstatic void free_test_data(test_data_t const *data) {\n free(data->data);\n free(data->data2);\n free(data->comp);\n}\n\n#define MIN(a, b) ((a) < (b) ? (a) : (b))\n#define MAX(a, b) ((a) > (b) ? (a) : (b))\n\nstatic void test_btrfs(test_data_t const *data) {\n size_t const size = MIN(data->dataSize, 128 * 1024);\n fprintf(stderr, \"testing btrfs use cases... \");\n for (int level = -1; level < 16; ++level) {\n zstd_parameters params = zstd_get_params(level, size);\n size_t const workspaceSize =\n MAX(zstd_cstream_workspace_bound(¶ms.cParams),\n zstd_dstream_workspace_bound(size));\n void *workspace = malloc(workspaceSize);\n\n char const *ip = data->data;\n char const *iend = ip + size;\n char *op = data->comp;\n char *oend = op + data->compSize;\n\n CONTROL(params.cParams.windowLog <= 17);\n CONTROL(workspace != NULL);\n {\n zstd_cstream *cctx = zstd_init_cstream(¶ms, size, workspace, workspaceSize);\n zstd_out_buffer out = {NULL, 0, 0};\n zstd_in_buffer in = {NULL, 0, 0};\n CONTROL(cctx != NULL);\n for (;;) {\n if (in.pos == in.size) {\n in.src = ip;\n in.size = MIN(4096, iend - ip);\n in.pos = 0;\n ip += in.size;\n }\n\n if (out.pos == out.size) {\n out.dst = op;\n out.size = MIN(4096, oend - op);\n out.pos = 0;\n op += out.size;\n }\n\n if (ip != iend || in.pos < in.size) {\n CONTROL(!zstd_is_error(zstd_compress_stream(cctx, &out, &in)));\n } else {\n size_t const ret = zstd_end_stream(cctx, &out);\n CONTROL(!zstd_is_error(ret));\n if (ret == 0) {\n break;\n }\n }\n }\n op += out.pos;\n }\n\n ip = data->comp;\n iend = op;\n op = data->data2;\n oend = op + size;\n {\n zstd_dstream *dctx = zstd_init_dstream(1ULL << params.cParams.windowLog, workspace, workspaceSize);\n zstd_out_buffer out = {NULL, 0, 0};\n zstd_in_buffer in = {NULL, 0, 0};\n CONTROL(dctx != NULL);\n for (;;) {\n if (in.pos == in.size) {\n in.src = ip;\n in.size = MIN(4096, iend - ip);\n in.pos = 0;\n ip += in.size;\n }\n\n if (out.pos == out.size) {\n out.dst = op;\n out.size = MIN(4096, oend - op);\n out.pos = 0;\n op += out.size;\n }\n {\n size_t const ret = zstd_decompress_stream(dctx, &out, &in);\n CONTROL(!zstd_is_error(ret));\n if (ret == 0) {\n break;\n }\n }\n }\n }\n CONTROL((size_t)(op - data->data2) == data->dataSize);\n CONTROL(!memcmp(data->data, data->data2, data->dataSize));\n free(workspace);\n }\n fprintf(stderr, \"Ok\\n\");\n}\n\nstatic void test_decompress_unzstd(test_data_t const *data) {\n size_t cSize;\n fprintf(stderr, \"Testing decompress unzstd... \");\n {\n zstd_parameters params = zstd_get_params(19, 0);\n size_t const wkspSize = zstd_cctx_workspace_bound(¶ms.cParams);\n void* wksp = malloc(wkspSize);\n zstd_cctx* cctx = zstd_init_cctx(wksp, wkspSize);\n CONTROL(wksp != NULL);\n CONTROL(cctx != NULL);\n cSize = zstd_compress_cctx(cctx, data->comp, data->compSize, data->data, data->dataSize, ¶ms);\n CONTROL(!zstd_is_error(cSize));\n free(wksp);\n }\n {\n size_t const wkspSize = zstd_dctx_workspace_bound();\n void* wksp = malloc(wkspSize);\n zstd_dctx* dctx = zstd_init_dctx(wksp, wkspSize);\n CONTROL(wksp != NULL);\n CONTROL(dctx != NULL);\n {\n size_t const dSize = zstd_decompress_dctx(dctx, data->data2, data->dataSize, data->comp, cSize);\n CONTROL(!zstd_is_error(dSize));\n CONTROL(dSize == data->dataSize);\n }\n CONTROL(!memcmp(data->data, data->data2, data->dataSize));\n free(wksp);\n }\n fprintf(stderr, \"Ok\\n\");\n}\n\nstatic void test_f2fs(void) {\n fprintf(stderr, \"testing f2fs uses... \");\n CONTROL(zstd_min_clevel() < 0);\n CONTROL(zstd_max_clevel() == 22);\n fprintf(stderr, \"Ok\\n\");\n}\n\nstatic char *g_stack = NULL;\n\nstatic void __attribute__((noinline)) use(void *x) {\n asm volatile(\"\" : \"+r\"(x));\n}\n\nstatic void __attribute__((noinline)) fill_stack(void) {\n memset(g_stack, 0x33, 8192);\n}\n\nstatic void __attribute__((noinline)) set_stack(void) {\n\n char stack[8192];\n g_stack = stack;\n use(g_stack);\n}\n\nstatic void __attribute__((noinline)) check_stack(void) {\n size_t cleanStack = 0;\n while (cleanStack < 8192 && g_stack[cleanStack] == 0x33) {\n ++cleanStack;\n }\n {\n size_t const stackSize = 8192 - cleanStack;\n fprintf(stderr, \"Maximum stack size: %zu\\n\", stackSize);\n CONTROL(stackSize <= 2048 + 512);\n }\n}\n\nstatic void test_stack_usage(test_data_t const *data) {\n set_stack();\n fill_stack();\n test_f2fs();\n test_btrfs(data);\n test_decompress_unzstd(data);\n check_stack();\n}\n\nint main(void) {\n test_data_t data = create_test_data();\n test_f2fs();\n test_btrfs(&data);\n test_decompress_unzstd(&data);\n test_stack_usage(&data);\n free_test_data(&data);\n return 0;\n}\n" }, { "path": "contrib/linux-kernel/zstd_common_module.c", "content": "// SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause\n/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#include \n\n#include \"common/huf.h\"\n#include \"common/fse.h\"\n#include \"common/zstd_internal.h\"\n\n// Export symbols shared by compress and decompress into a common module\n\n#undef ZSTD_isError /* defined within zstd_internal.h */\nEXPORT_SYMBOL_GPL(FSE_readNCount);\nEXPORT_SYMBOL_GPL(HUF_readStats);\nEXPORT_SYMBOL_GPL(HUF_readStats_wksp);\nEXPORT_SYMBOL_GPL(ZSTD_isError);\nEXPORT_SYMBOL_GPL(ZSTD_getErrorName);\nEXPORT_SYMBOL_GPL(ZSTD_getErrorCode);\n\nMODULE_LICENSE(\"Dual BSD/GPL\");\nMODULE_DESCRIPTION(\"Zstd Common\");\n" }, { "path": "contrib/linux-kernel/zstd_compress_module.c", "content": "// SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause\n/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#include \n#include \n#include \n#include \n\n#include \"common/zstd_deps.h\"\n#include \"common/zstd_internal.h\"\n#include \"compress/zstd_compress_internal.h\"\n\n#define ZSTD_FORWARD_IF_ERR(ret) \\\n\tdo { \\\n\t\tsize_t const __ret = (ret); \\\n\t\tif (ZSTD_isError(__ret)) \\\n\t\t\treturn __ret; \\\n\t} while (0)\n\nstatic size_t zstd_cctx_init(zstd_cctx *cctx, const zstd_parameters *parameters,\n\tunsigned long long pledged_src_size)\n{\n\tZSTD_FORWARD_IF_ERR(ZSTD_CCtx_reset(\n\t\tcctx, ZSTD_reset_session_and_parameters));\n\tZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setPledgedSrcSize(\n\t\tcctx, pledged_src_size));\n\tZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(\n\t\tcctx, ZSTD_c_windowLog, parameters->cParams.windowLog));\n\tZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(\n\t\tcctx, ZSTD_c_hashLog, parameters->cParams.hashLog));\n\tZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(\n\t\tcctx, ZSTD_c_chainLog, parameters->cParams.chainLog));\n\tZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(\n\t\tcctx, ZSTD_c_searchLog, parameters->cParams.searchLog));\n\tZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(\n\t\tcctx, ZSTD_c_minMatch, parameters->cParams.minMatch));\n\tZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(\n\t\tcctx, ZSTD_c_targetLength, parameters->cParams.targetLength));\n\tZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(\n\t\tcctx, ZSTD_c_strategy, parameters->cParams.strategy));\n\tZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(\n\t\tcctx, ZSTD_c_contentSizeFlag, parameters->fParams.contentSizeFlag));\n\tZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(\n\t\tcctx, ZSTD_c_checksumFlag, parameters->fParams.checksumFlag));\n\tZSTD_FORWARD_IF_ERR(ZSTD_CCtx_setParameter(\n\t\tcctx, ZSTD_c_dictIDFlag, !parameters->fParams.noDictIDFlag));\n\treturn 0;\n}\n\nint zstd_min_clevel(void)\n{\n\treturn ZSTD_minCLevel();\n}\nEXPORT_SYMBOL(zstd_min_clevel);\n\nint zstd_max_clevel(void)\n{\n\treturn ZSTD_maxCLevel();\n}\nEXPORT_SYMBOL(zstd_max_clevel);\n\nint zstd_default_clevel(void)\n{\n\treturn ZSTD_defaultCLevel();\n}\nEXPORT_SYMBOL(zstd_default_clevel);\n\nsize_t zstd_compress_bound(size_t src_size)\n{\n\treturn ZSTD_compressBound(src_size);\n}\nEXPORT_SYMBOL(zstd_compress_bound);\n\nzstd_parameters zstd_get_params(int level,\n\tunsigned long long estimated_src_size)\n{\n\treturn ZSTD_getParams(level, estimated_src_size, 0);\n}\nEXPORT_SYMBOL(zstd_get_params);\n\nzstd_compression_parameters zstd_get_cparams(int level,\n\tunsigned long long estimated_src_size, size_t dict_size)\n{\n\treturn ZSTD_getCParams(level, estimated_src_size, dict_size);\n}\nEXPORT_SYMBOL(zstd_get_cparams);\n\nsize_t zstd_cctx_set_param(zstd_cctx *cctx, ZSTD_cParameter param, int value)\n{\n\treturn ZSTD_CCtx_setParameter(cctx, param, value);\n}\nEXPORT_SYMBOL(zstd_cctx_set_param);\n\nsize_t zstd_cctx_workspace_bound(const zstd_compression_parameters *cparams)\n{\n\treturn ZSTD_estimateCCtxSize_usingCParams(*cparams);\n}\nEXPORT_SYMBOL(zstd_cctx_workspace_bound);\n\n// Used by zstd_cctx_workspace_bound_with_ext_seq_prod()\nstatic size_t dummy_external_sequence_producer(\n\tvoid *sequenceProducerState,\n\tZSTD_Sequence *outSeqs, size_t outSeqsCapacity,\n\tconst void *src, size_t srcSize,\n\tconst void *dict, size_t dictSize,\n\tint compressionLevel,\n\tsize_t windowSize)\n{\n\t(void)sequenceProducerState;\n\t(void)outSeqs; (void)outSeqsCapacity;\n\t(void)src; (void)srcSize;\n\t(void)dict; (void)dictSize;\n\t(void)compressionLevel;\n\t(void)windowSize;\n\treturn ZSTD_SEQUENCE_PRODUCER_ERROR;\n}\n\nstatic void init_cctx_params_from_compress_params(\n\tZSTD_CCtx_params *cctx_params,\n\tconst zstd_compression_parameters *compress_params)\n{\n\tZSTD_parameters zstd_params;\n\tmemset(&zstd_params, 0, sizeof(zstd_params));\n\tzstd_params.cParams = *compress_params;\n\tZSTD_CCtxParams_init_advanced(cctx_params, zstd_params);\n}\n\nsize_t zstd_cctx_workspace_bound_with_ext_seq_prod(const zstd_compression_parameters *compress_params)\n{\n\tZSTD_CCtx_params cctx_params;\n\tinit_cctx_params_from_compress_params(&cctx_params, compress_params);\n\tZSTD_CCtxParams_registerSequenceProducer(&cctx_params, NULL, dummy_external_sequence_producer);\n\treturn ZSTD_estimateCCtxSize_usingCCtxParams(&cctx_params);\n}\nEXPORT_SYMBOL(zstd_cctx_workspace_bound_with_ext_seq_prod);\n\nsize_t zstd_cstream_workspace_bound_with_ext_seq_prod(const zstd_compression_parameters *compress_params)\n{\n\tZSTD_CCtx_params cctx_params;\n\tinit_cctx_params_from_compress_params(&cctx_params, compress_params);\n\tZSTD_CCtxParams_registerSequenceProducer(&cctx_params, NULL, dummy_external_sequence_producer);\n\treturn ZSTD_estimateCStreamSize_usingCCtxParams(&cctx_params);\n}\nEXPORT_SYMBOL(zstd_cstream_workspace_bound_with_ext_seq_prod);\n\nzstd_cctx *zstd_init_cctx(void *workspace, size_t workspace_size)\n{\n\tif (workspace == NULL)\n\t\treturn NULL;\n\treturn ZSTD_initStaticCCtx(workspace, workspace_size);\n}\nEXPORT_SYMBOL(zstd_init_cctx);\n\nzstd_cctx *zstd_create_cctx_advanced(zstd_custom_mem custom_mem)\n{\n\treturn ZSTD_createCCtx_advanced(custom_mem);\n}\nEXPORT_SYMBOL(zstd_create_cctx_advanced);\n\nsize_t zstd_free_cctx(zstd_cctx *cctx)\n{\n\treturn ZSTD_freeCCtx(cctx);\n}\nEXPORT_SYMBOL(zstd_free_cctx);\n\nzstd_cdict *zstd_create_cdict_byreference(const void *dict, size_t dict_size,\n\t\t\t\t\t zstd_compression_parameters cparams,\n\t\t\t\t\t zstd_custom_mem custom_mem)\n{\n\treturn ZSTD_createCDict_advanced(dict, dict_size, ZSTD_dlm_byRef,\n\t\t\t\t\t ZSTD_dct_auto, cparams, custom_mem);\n}\nEXPORT_SYMBOL(zstd_create_cdict_byreference);\n\nsize_t zstd_free_cdict(zstd_cdict *cdict)\n{\n\treturn ZSTD_freeCDict(cdict);\n}\nEXPORT_SYMBOL(zstd_free_cdict);\n\nsize_t zstd_compress_cctx(zstd_cctx *cctx, void *dst, size_t dst_capacity,\n\tconst void *src, size_t src_size, const zstd_parameters *parameters)\n{\n\tZSTD_FORWARD_IF_ERR(zstd_cctx_init(cctx, parameters, src_size));\n\treturn ZSTD_compress2(cctx, dst, dst_capacity, src, src_size);\n}\nEXPORT_SYMBOL(zstd_compress_cctx);\n\nsize_t zstd_compress_using_cdict(zstd_cctx *cctx, void *dst,\n\tsize_t dst_capacity, const void *src, size_t src_size,\n\tconst ZSTD_CDict *cdict)\n{\n\treturn ZSTD_compress_usingCDict(cctx, dst, dst_capacity,\n\t\t\t\t\tsrc, src_size, cdict);\n}\nEXPORT_SYMBOL(zstd_compress_using_cdict);\n\nsize_t zstd_cstream_workspace_bound(const zstd_compression_parameters *cparams)\n{\n\treturn ZSTD_estimateCStreamSize_usingCParams(*cparams);\n}\nEXPORT_SYMBOL(zstd_cstream_workspace_bound);\n\nzstd_cstream *zstd_init_cstream(const zstd_parameters *parameters,\n\tunsigned long long pledged_src_size, void *workspace, size_t workspace_size)\n{\n\tzstd_cstream *cstream;\n\n\tif (workspace == NULL)\n\t\treturn NULL;\n\n\tcstream = ZSTD_initStaticCStream(workspace, workspace_size);\n\tif (cstream == NULL)\n\t\treturn NULL;\n\n\t/* 0 means unknown in linux zstd API but means 0 in new zstd API */\n\tif (pledged_src_size == 0)\n\t\tpledged_src_size = ZSTD_CONTENTSIZE_UNKNOWN;\n\n\tif (ZSTD_isError(zstd_cctx_init(cstream, parameters, pledged_src_size)))\n\t\treturn NULL;\n\n\treturn cstream;\n}\nEXPORT_SYMBOL(zstd_init_cstream);\n\nsize_t zstd_reset_cstream(zstd_cstream *cstream,\n\tunsigned long long pledged_src_size)\n{\n\tif (pledged_src_size == 0)\n\t\tpledged_src_size = ZSTD_CONTENTSIZE_UNKNOWN;\n\tZSTD_FORWARD_IF_ERR( ZSTD_CCtx_reset(cstream, ZSTD_reset_session_only) );\n\tZSTD_FORWARD_IF_ERR( ZSTD_CCtx_setPledgedSrcSize(cstream, pledged_src_size) );\n\treturn 0;\n}\nEXPORT_SYMBOL(zstd_reset_cstream);\n\nsize_t zstd_compress_stream(zstd_cstream *cstream, zstd_out_buffer *output,\n\tzstd_in_buffer *input)\n{\n\treturn ZSTD_compressStream(cstream, output, input);\n}\nEXPORT_SYMBOL(zstd_compress_stream);\n\nsize_t zstd_flush_stream(zstd_cstream *cstream, zstd_out_buffer *output)\n{\n\treturn ZSTD_flushStream(cstream, output);\n}\nEXPORT_SYMBOL(zstd_flush_stream);\n\nsize_t zstd_end_stream(zstd_cstream *cstream, zstd_out_buffer *output)\n{\n\treturn ZSTD_endStream(cstream, output);\n}\nEXPORT_SYMBOL(zstd_end_stream);\n\nvoid zstd_register_sequence_producer(\n zstd_cctx *cctx,\n void* sequence_producer_state,\n zstd_sequence_producer_f sequence_producer\n) {\n\tZSTD_registerSequenceProducer(cctx, sequence_producer_state, sequence_producer);\n}\nEXPORT_SYMBOL(zstd_register_sequence_producer);\n\nsize_t zstd_compress_sequences_and_literals(zstd_cctx *cctx, void* dst, size_t dst_capacity,\n\t\t\t\t\t const zstd_sequence *in_seqs, size_t in_seqs_size,\n\t\t\t\t\t const void* literals, size_t lit_size, size_t lit_capacity,\n\t\t\t\t\t size_t decompressed_size)\n{\n\treturn ZSTD_compressSequencesAndLiterals(cctx, dst, dst_capacity, in_seqs,\n\t\t\t\t\t\t in_seqs_size, literals, lit_size,\n\t\t\t\t\t\t lit_capacity, decompressed_size);\n}\nEXPORT_SYMBOL(zstd_compress_sequences_and_literals);\n\nMODULE_LICENSE(\"Dual BSD/GPL\");\nMODULE_DESCRIPTION(\"Zstd Compressor\");\n" }, { "path": "contrib/linux-kernel/zstd_decompress_module.c", "content": "// SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause\n/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#include \n#include \n#include \n#include \n\n#include \"common/zstd_deps.h\"\n\n/* Common symbols. zstd_compress must depend on zstd_decompress. */\n\nunsigned int zstd_is_error(size_t code)\n{\n\treturn ZSTD_isError(code);\n}\nEXPORT_SYMBOL(zstd_is_error);\n\nzstd_error_code zstd_get_error_code(size_t code)\n{\n\treturn ZSTD_getErrorCode(code);\n}\nEXPORT_SYMBOL(zstd_get_error_code);\n\nconst char *zstd_get_error_name(size_t code)\n{\n\treturn ZSTD_getErrorName(code);\n}\nEXPORT_SYMBOL(zstd_get_error_name);\n\n/* Decompression symbols. */\n\nsize_t zstd_dctx_workspace_bound(void)\n{\n\treturn ZSTD_estimateDCtxSize();\n}\nEXPORT_SYMBOL(zstd_dctx_workspace_bound);\n\nzstd_dctx *zstd_create_dctx_advanced(zstd_custom_mem custom_mem)\n{\n\treturn ZSTD_createDCtx_advanced(custom_mem);\n}\nEXPORT_SYMBOL(zstd_create_dctx_advanced);\n\nsize_t zstd_free_dctx(zstd_dctx *dctx)\n{\n\treturn ZSTD_freeDCtx(dctx);\n}\nEXPORT_SYMBOL(zstd_free_dctx);\n\nzstd_ddict *zstd_create_ddict_byreference(const void *dict, size_t dict_size,\n\t\t\t\t\t zstd_custom_mem custom_mem)\n{\n\treturn ZSTD_createDDict_advanced(dict, dict_size, ZSTD_dlm_byRef,\n\t\t\t\t\t ZSTD_dct_auto, custom_mem);\n\n}\nEXPORT_SYMBOL(zstd_create_ddict_byreference);\n\nsize_t zstd_free_ddict(zstd_ddict *ddict)\n{\n\treturn ZSTD_freeDDict(ddict);\n}\nEXPORT_SYMBOL(zstd_free_ddict);\n\nzstd_dctx *zstd_init_dctx(void *workspace, size_t workspace_size)\n{\n\tif (workspace == NULL)\n\t\treturn NULL;\n\treturn ZSTD_initStaticDCtx(workspace, workspace_size);\n}\nEXPORT_SYMBOL(zstd_init_dctx);\n\nsize_t zstd_decompress_dctx(zstd_dctx *dctx, void *dst, size_t dst_capacity,\n\tconst void *src, size_t src_size)\n{\n\treturn ZSTD_decompressDCtx(dctx, dst, dst_capacity, src, src_size);\n}\nEXPORT_SYMBOL(zstd_decompress_dctx);\n\nsize_t zstd_decompress_using_ddict(zstd_dctx *dctx,\n\tvoid *dst, size_t dst_capacity, const void* src, size_t src_size,\n\tconst zstd_ddict* ddict)\n{\n\treturn ZSTD_decompress_usingDDict(dctx, dst, dst_capacity, src,\n\t\t\t\t\t src_size, ddict);\n}\nEXPORT_SYMBOL(zstd_decompress_using_ddict);\n\nsize_t zstd_dstream_workspace_bound(size_t max_window_size)\n{\n\treturn ZSTD_estimateDStreamSize(max_window_size);\n}\nEXPORT_SYMBOL(zstd_dstream_workspace_bound);\n\nzstd_dstream *zstd_init_dstream(size_t max_window_size, void *workspace,\n\tsize_t workspace_size)\n{\n\tif (workspace == NULL)\n\t\treturn NULL;\n\t(void)max_window_size;\n\treturn ZSTD_initStaticDStream(workspace, workspace_size);\n}\nEXPORT_SYMBOL(zstd_init_dstream);\n\nsize_t zstd_reset_dstream(zstd_dstream *dstream)\n{\n\treturn ZSTD_DCtx_reset(dstream, ZSTD_reset_session_only);\n}\nEXPORT_SYMBOL(zstd_reset_dstream);\n\nsize_t zstd_decompress_stream(zstd_dstream *dstream, zstd_out_buffer *output,\n\tzstd_in_buffer *input)\n{\n\treturn ZSTD_decompressStream(dstream, output, input);\n}\nEXPORT_SYMBOL(zstd_decompress_stream);\n\nsize_t zstd_find_frame_compressed_size(const void *src, size_t src_size)\n{\n\treturn ZSTD_findFrameCompressedSize(src, src_size);\n}\nEXPORT_SYMBOL(zstd_find_frame_compressed_size);\n\nsize_t zstd_get_frame_header(zstd_frame_header *header, const void *src,\n\tsize_t src_size)\n{\n\treturn ZSTD_getFrameHeader(header, src, src_size);\n}\nEXPORT_SYMBOL(zstd_get_frame_header);\n\nMODULE_LICENSE(\"Dual BSD/GPL\");\nMODULE_DESCRIPTION(\"Zstd Decompressor\");\n" }, { "path": "contrib/linux-kernel/zstd_deps.h", "content": "/* SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause */\n/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/*\n * This file provides common libc dependencies that zstd requires.\n * The purpose is to allow replacing this file with a custom implementation\n * to compile zstd without libc support.\n */\n\n/* Need:\n * NULL\n * INT_MAX\n * UINT_MAX\n * ZSTD_memcpy()\n * ZSTD_memset()\n * ZSTD_memmove()\n */\n#ifndef ZSTD_DEPS_COMMON\n#define ZSTD_DEPS_COMMON\n\n#include \n#include \n\n#define ZSTD_memcpy(d,s,n) __builtin_memcpy((d),(s),(n))\n#define ZSTD_memmove(d,s,n) __builtin_memmove((d),(s),(n))\n#define ZSTD_memset(d,s,n) __builtin_memset((d),(s),(n))\n\n#endif /* ZSTD_DEPS_COMMON */\n\n/*\n * Define malloc as always failing. That means the user must\n * either use ZSTD_customMem or statically allocate memory.\n * Need:\n * ZSTD_malloc()\n * ZSTD_free()\n * ZSTD_calloc()\n */\n#ifdef ZSTD_DEPS_NEED_MALLOC\n#ifndef ZSTD_DEPS_MALLOC\n#define ZSTD_DEPS_MALLOC\n\n#define ZSTD_malloc(s) ({ (void)(s); NULL; })\n#define ZSTD_free(p) ((void)(p))\n#define ZSTD_calloc(n,s) ({ (void)(n); (void)(s); NULL; })\n\n#endif /* ZSTD_DEPS_MALLOC */\n#endif /* ZSTD_DEPS_NEED_MALLOC */\n\n/*\n * Provides 64-bit math support.\n * Need:\n * U64 ZSTD_div64(U64 dividend, U32 divisor)\n */\n#ifdef ZSTD_DEPS_NEED_MATH64\n#ifndef ZSTD_DEPS_MATH64\n#define ZSTD_DEPS_MATH64\n\n#include \n\nstatic uint64_t ZSTD_div64(uint64_t dividend, uint32_t divisor) {\n return div_u64(dividend, divisor);\n}\n\n#endif /* ZSTD_DEPS_MATH64 */\n#endif /* ZSTD_DEPS_NEED_MATH64 */\n\n/*\n * This is only requested when DEBUGLEVEL >= 1, meaning\n * it is disabled in production.\n * Need:\n * assert()\n */\n#ifdef ZSTD_DEPS_NEED_ASSERT\n#ifndef ZSTD_DEPS_ASSERT\n#define ZSTD_DEPS_ASSERT\n\n#include \n\n#define assert(x) WARN_ON(!(x))\n\n#endif /* ZSTD_DEPS_ASSERT */\n#endif /* ZSTD_DEPS_NEED_ASSERT */\n\n/*\n * This is only requested when DEBUGLEVEL >= 2, meaning\n * it is disabled in production.\n * Need:\n * ZSTD_DEBUG_PRINT()\n */\n#ifdef ZSTD_DEPS_NEED_IO\n#ifndef ZSTD_DEPS_IO\n#define ZSTD_DEPS_IO\n\n#include \n\n#define ZSTD_DEBUG_PRINT(...) pr_debug(__VA_ARGS__)\n\n#endif /* ZSTD_DEPS_IO */\n#endif /* ZSTD_DEPS_NEED_IO */\n\n/*\n * Only requested when MSAN is enabled.\n * Need:\n * intptr_t\n */\n#ifdef ZSTD_DEPS_NEED_STDINT\n#ifndef ZSTD_DEPS_STDINT\n#define ZSTD_DEPS_STDINT\n\n/* intptr_t already provided by ZSTD_DEPS_COMMON */\n\n#endif /* ZSTD_DEPS_STDINT */\n#endif /* ZSTD_DEPS_NEED_STDINT */\n" }, { "path": "contrib/match_finders/README.md", "content": "## Edit Distance Match Finder\n\n```\n/* This match finder leverages techniques used in file comparison algorithms\n * to find matches between a dictionary and a source file.\n * \n * The original motivation for studying this approach was to try and optimize \n * Zstandard for the use case of patching: the most common scenario being \n * updating an existing software package with the next version. When patching,\n * the difference between the old version of the package and the new version \n * is generally tiny (most of the new file will be identical to \n * the old one). In more technical terms, the edit distance (the minimal number \n * of changes required to take one sequence of bytes to another) between the \n * files would be small relative to the size of the file. \n * \n * Various 'diffing' algorithms utilize this notion of edit distance and \n * the corresponding concept of a minimal edit script between two \n * sequences to identify the regions within two files where they differ. \n * The core algorithm used in this match finder is described in: \n * \n * \"An O(ND) Difference Algorithm and its Variations\", Eugene W. Myers,\n * Algorithmica Vol. 1, 1986, pp. 251-266,\n * .\n * \n * Additional algorithmic heuristics for speed improvement have also been included.\n * These we inspired from implementations of various regular and binary diffing \n * algorithms such as GNU diff, bsdiff, and Xdelta. \n * \n * Note: after some experimentation, this approach proved to not provide enough \n * utility to justify the additional CPU used in finding matches. The one area\n * where this approach consistently outperforms Zstandard even on level 19 is \n * when compressing small files (<10 KB) using an equally small dictionary that \n * is very similar to the source file. For the use case that this was intended,\n * (large similar files) this approach by itself took 5-10X longer than zstd-19 and \n * generally resulted in 2-3X larger files. The core advantage that zstd-19 has \n * over this approach for match finding is the overlapping matches. This approach \n * cannot find any. \n * \n * I'm leaving this in the contrib section in case this ever becomes interesting \n * to explore again.\n * */\n```\n" }, { "path": "contrib/match_finders/zstd_edist.c", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/*-*************************************\n* Dependencies\n***************************************/\n\n/* Currently relies on qsort when combining contiguous matches. This can probably \n * be avoided but would require changes to the algorithm. The qsort is far from \n * the bottleneck in this algorithm even for medium sized files so it's probably \n * not worth trying to address */ \n#include \n#include \n\n#include \"zstd_edist.h\"\n#include \"mem.h\"\n\n/*-*************************************\n* Constants\n***************************************/\n\n/* Just a sential for the entries of the diagonal matrix */\n#define ZSTD_EDIST_DIAG_MAX (S32)(1 << 30)\n\n/* How large should a snake be to be considered a 'big' snake. \n * For an explanation of what a 'snake' is with respect to the \n * edit distance matrix, see the linked paper in zstd_edist.h */\n#define ZSTD_EDIST_SNAKE_THRESH 20\n\n/* After how many iterations should we start to use the heuristic\n * based on 'big' snakes */\n#define ZSTD_EDIST_SNAKE_ITER_THRESH 200\n\n/* After how many iterations should be just give up and take \n * the best available edit script for this round */ \n#define ZSTD_EDIST_EXPENSIVE_THRESH 1024\n\n/*-*************************************\n* Structures\n***************************************/\n\ntypedef struct {\n U32 dictIdx;\n U32 srcIdx;\n U32 matchLength;\n} ZSTD_eDist_match;\n\ntypedef struct {\n const BYTE* dict;\n const BYTE* src;\n size_t dictSize;\n size_t srcSize;\n S32* forwardDiag; /* Entries of the forward diagonal stored here */\n S32* backwardDiag; /* Entries of the backward diagonal stored here.\n * Note: this buffer and the 'forwardDiag' buffer \n * are contiguous. See the ZSTD_eDist_genSequences */\n ZSTD_eDist_match* matches; /* Accumulate matches of length 1 in this buffer. \n * In a subsequence post-processing step, we combine \n * contiguous matches. */\n U32 nbMatches;\n} ZSTD_eDist_state;\n\ntypedef struct {\n S32 dictMid; /* The mid diagonal for the dictionary */\n S32 srcMid; /* The mid diagonal for the source */ \n int lowUseHeuristics; /* Should we use heuristics for the low part */\n int highUseHeuristics; /* Should we use heuristics for the high part */ \n} ZSTD_eDist_partition;\n\n/*-*************************************\n* Internal\n***************************************/\n\nstatic void ZSTD_eDist_diag(ZSTD_eDist_state* state,\n ZSTD_eDist_partition* partition,\n S32 dictLow, S32 dictHigh, S32 srcLow, \n S32 srcHigh, int useHeuristics)\n{\n S32* const forwardDiag = state->forwardDiag;\n S32* const backwardDiag = state->backwardDiag;\n const BYTE* const dict = state->dict;\n const BYTE* const src = state->src;\n\n S32 const diagMin = dictLow - srcHigh;\n S32 const diagMax = dictHigh - srcLow;\n S32 const forwardMid = dictLow - srcLow;\n S32 const backwardMid = dictHigh - srcHigh;\n\n S32 forwardMin = forwardMid;\n S32 forwardMax = forwardMid;\n S32 backwardMin = backwardMid;\n S32 backwardMax = backwardMid;\n int odd = (forwardMid - backwardMid) & 1;\n U32 iterations;\n\n forwardDiag[forwardMid] = dictLow;\n backwardDiag[backwardMid] = dictHigh;\n\n /* Main loop for updating diag entries. Unless useHeuristics is \n * set to false, this loop will run until it finds the minimal \n * edit script */ \n for (iterations = 1;;iterations++) {\n S32 diag;\n int bigSnake = 0;\n \n if (forwardMin > diagMin) {\n forwardMin--;\n forwardDiag[forwardMin - 1] = -1;\n } else {\n forwardMin++;\n }\n\n if (forwardMax < diagMax) {\n forwardMax++;\n forwardDiag[forwardMax + 1] = -1;\n } else {\n forwardMax--;\n }\n\n for (diag = forwardMax; diag >= forwardMin; diag -= 2) {\n S32 dictIdx;\n S32 srcIdx;\n S32 low = forwardDiag[diag - 1];\n S32 high = forwardDiag[diag + 1];\n S32 dictIdx0 = low < high ? high : low + 1;\n\n for (dictIdx = dictIdx0, srcIdx = dictIdx0 - diag;\n dictIdx < dictHigh && srcIdx < srcHigh && dict[dictIdx] == src[srcIdx];\n dictIdx++, srcIdx++) continue;\n\n if (dictIdx - dictIdx0 > ZSTD_EDIST_SNAKE_THRESH)\n bigSnake = 1;\n\n forwardDiag[diag] = dictIdx;\n\n if (odd && backwardMin <= diag && diag <= backwardMax && backwardDiag[diag] <= dictIdx) {\n partition->dictMid = dictIdx;\n partition->srcMid = srcIdx;\n partition->lowUseHeuristics = 0;\n partition->highUseHeuristics = 0;\n return;\n }\n }\n\n if (backwardMin > diagMin) {\n backwardMin--;\n backwardDiag[backwardMin - 1] = ZSTD_EDIST_DIAG_MAX;\n } else {\n backwardMin++;\n }\n\n if (backwardMax < diagMax) {\n backwardMax++;\n backwardDiag[backwardMax + 1] = ZSTD_EDIST_DIAG_MAX;\n } else {\n backwardMax--;\n }\n\n\n for (diag = backwardMax; diag >= backwardMin; diag -= 2) {\n S32 dictIdx;\n S32 srcIdx;\n S32 low = backwardDiag[diag - 1];\n S32 high = backwardDiag[diag + 1];\n S32 dictIdx0 = low < high ? low : high - 1;\n\n for (dictIdx = dictIdx0, srcIdx = dictIdx0 - diag;\n dictLow < dictIdx && srcLow < srcIdx && dict[dictIdx - 1] == src[srcIdx - 1];\n dictIdx--, srcIdx--) continue;\n\n if (dictIdx0 - dictIdx > ZSTD_EDIST_SNAKE_THRESH)\n bigSnake = 1;\n\n backwardDiag[diag] = dictIdx;\n\n if (!odd && forwardMin <= diag && diag <= forwardMax && dictIdx <= forwardDiag[diag]) {\n partition->dictMid = dictIdx;\n partition->srcMid = srcIdx;\n partition->lowUseHeuristics = 0;\n partition->highUseHeuristics = 0;\n return;\n }\n }\n\n if (!useHeuristics)\n continue;\n\n /* Everything under this point is a heuristic. Using these will \n * substantially speed up the match finding. In some cases, taking \n * the total match finding time from several minutes to seconds.\n * Of course, the caveat is that the edit script found may no longer \n * be optimal */ \n\n /* Big snake heuristic */ \n if (iterations > ZSTD_EDIST_SNAKE_ITER_THRESH && bigSnake) {\n {\n S32 best = 0;\n \n for (diag = forwardMax; diag >= forwardMin; diag -= 2) {\n S32 diagDiag = diag - forwardMid;\n S32 dictIdx = forwardDiag[diag];\n S32 srcIdx = dictIdx - diag;\n S32 v = (dictIdx - dictLow) * 2 - diagDiag;\n\n if (v > 12 * (iterations + (diagDiag < 0 ? -diagDiag : diagDiag))) {\n if (v > best \n && dictLow + ZSTD_EDIST_SNAKE_THRESH <= dictIdx && dictIdx <= dictHigh\n && srcLow + ZSTD_EDIST_SNAKE_THRESH <= srcIdx && srcIdx <= srcHigh) {\n S32 k;\n for (k = 1; dict[dictIdx - k] == src[srcIdx - k]; k++) {\n if (k == ZSTD_EDIST_SNAKE_THRESH) {\n best = v;\n partition->dictMid = dictIdx;\n partition->srcMid = srcIdx;\n break;\n }\n }\n }\n }\n }\n\n if (best > 0) {\n partition->lowUseHeuristics = 0;\n partition->highUseHeuristics = 1;\n return;\n }\n }\n\n {\n S32 best = 0;\n\n for (diag = backwardMax; diag >= backwardMin; diag -= 2) {\n S32 diagDiag = diag - backwardMid;\n S32 dictIdx = backwardDiag[diag];\n S32 srcIdx = dictIdx - diag;\n S32 v = (dictHigh - dictIdx) * 2 + diagDiag;\n\n if (v > 12 * (iterations + (diagDiag < 0 ? -diagDiag : diagDiag))) {\n if (v > best \n && dictLow < dictIdx && dictIdx <= dictHigh - ZSTD_EDIST_SNAKE_THRESH\n && srcLow < srcIdx && srcIdx <= srcHigh - ZSTD_EDIST_SNAKE_THRESH) {\n int k;\n for (k = 0; dict[dictIdx + k] == src[srcIdx + k]; k++) {\n if (k == ZSTD_EDIST_SNAKE_THRESH - 1) { \n best = v;\n partition->dictMid = dictIdx;\n partition->srcMid = srcIdx;\n break; \n }\n }\n }\n }\n }\n\n if (best > 0) {\n partition->lowUseHeuristics = 1;\n partition->highUseHeuristics = 0;\n return;\n }\n }\n }\n\n /* More general 'too expensive' heuristic */ \n if (iterations >= ZSTD_EDIST_EXPENSIVE_THRESH) {\n S32 forwardDictSrcBest;\n S32 forwardDictBest = 0;\n S32 backwardDictSrcBest;\n S32 backwardDictBest = 0;\n\n forwardDictSrcBest = -1;\n for (diag = forwardMax; diag >= forwardMin; diag -= 2) {\n S32 dictIdx = MIN(forwardDiag[diag], dictHigh);\n S32 srcIdx = dictIdx - diag;\n\n if (srcHigh < srcIdx) {\n dictIdx = srcHigh + diag;\n srcIdx = srcHigh;\n }\n\n if (forwardDictSrcBest < dictIdx + srcIdx) {\n forwardDictSrcBest = dictIdx + srcIdx;\n forwardDictBest = dictIdx;\n }\n }\n\n backwardDictSrcBest = ZSTD_EDIST_DIAG_MAX;\n for (diag = backwardMax; diag >= backwardMin; diag -= 2) {\n S32 dictIdx = MAX(dictLow, backwardDiag[diag]);\n S32 srcIdx = dictIdx - diag;\n\n if (srcIdx < srcLow) {\n dictIdx = srcLow + diag;\n srcIdx = srcLow;\n }\n\n if (dictIdx + srcIdx < backwardDictSrcBest) {\n backwardDictSrcBest = dictIdx + srcIdx;\n backwardDictBest = dictIdx;\n }\n }\n\n if ((dictHigh + srcHigh) - backwardDictSrcBest < forwardDictSrcBest - (dictLow + srcLow)) {\n partition->dictMid = forwardDictBest;\n partition->srcMid = forwardDictSrcBest - forwardDictBest;\n partition->lowUseHeuristics = 0;\n partition->highUseHeuristics = 1;\n } else {\n partition->dictMid = backwardDictBest;\n partition->srcMid = backwardDictSrcBest - backwardDictBest;\n partition->lowUseHeuristics = 1;\n partition->highUseHeuristics = 0;\n }\n return;\n }\n }\n}\n\nstatic void ZSTD_eDist_insertMatch(ZSTD_eDist_state* state, \n S32 const dictIdx, S32 const srcIdx)\n{\n state->matches[state->nbMatches].dictIdx = dictIdx;\n state->matches[state->nbMatches].srcIdx = srcIdx;\n state->matches[state->nbMatches].matchLength = 1;\n state->nbMatches++;\n}\n\nstatic int ZSTD_eDist_compare(ZSTD_eDist_state* state,\n S32 dictLow, S32 dictHigh, S32 srcLow,\n S32 srcHigh, int useHeuristics)\n{\n const BYTE* const dict = state->dict;\n const BYTE* const src = state->src;\n\n /* Found matches while traversing from the low end */ \n while (dictLow < dictHigh && srcLow < srcHigh && dict[dictLow] == src[srcLow]) {\n ZSTD_eDist_insertMatch(state, dictLow, srcLow);\n dictLow++;\n srcLow++;\n }\n\n /* Found matches while traversing from the high end */\n while (dictLow < dictHigh && srcLow < srcHigh && dict[dictHigh - 1] == src[srcHigh - 1]) {\n ZSTD_eDist_insertMatch(state, dictHigh - 1, srcHigh - 1);\n dictHigh--;\n srcHigh--;\n }\n \n /* If the low and high end end up touching. If we wanted to make \n * note of the differences like most diffing algorithms do, we would \n * do so here. In our case, we're only concerned with matches \n * Note: if you wanted to find the edit distance of the algorithm, \n * you could just accumulate the cost for an insertion/deletion \n * below. */ \n if (dictLow == dictHigh) {\n while (srcLow < srcHigh) {\n /* Reaching this point means inserting src[srcLow] into \n * the current position of dict */ \n srcLow++;\n }\n } else if (srcLow == srcHigh) {\n while (dictLow < dictHigh) {\n /* Reaching this point means deleting dict[dictLow] from \n * the current position of dict */ \n dictLow++;\n }\n } else {\n ZSTD_eDist_partition partition;\n partition.dictMid = 0;\n partition.srcMid = 0;\n ZSTD_eDist_diag(state, &partition, dictLow, dictHigh, \n srcLow, srcHigh, useHeuristics);\n if (ZSTD_eDist_compare(state, dictLow, partition.dictMid, \n srcLow, partition.srcMid, partition.lowUseHeuristics))\n return 1;\n if (ZSTD_eDist_compare(state, partition.dictMid, dictHigh,\n partition.srcMid, srcHigh, partition.highUseHeuristics))\n return 1;\n }\n\n return 0;\n}\n\nstatic int ZSTD_eDist_matchComp(const void* p, const void* q)\n{\n S32 const l = ((ZSTD_eDist_match*)p)->srcIdx;\n S32 const r = ((ZSTD_eDist_match*)q)->srcIdx;\n return (l - r);\n}\n\n/* The matches from the approach above will all be of the form \n * (dictIdx, srcIdx, 1). This method combines contiguous matches \n * of length MINMATCH or greater. Matches less than MINMATCH \n * are discarded */ \nstatic void ZSTD_eDist_combineMatches(ZSTD_eDist_state* state)\n{\n /* Create a new buffer to put the combined matches into \n * and memcpy to state->matches after */ \n ZSTD_eDist_match* combinedMatches = \n ZSTD_malloc(state->nbMatches * sizeof(ZSTD_eDist_match), \n ZSTD_defaultCMem);\n\n U32 nbCombinedMatches = 1;\n size_t i;\n\n /* Make sure that the srcIdx and dictIdx are in sorted order.\n * The combination step won't work otherwise */ \n qsort(state->matches, state->nbMatches, sizeof(ZSTD_eDist_match), ZSTD_eDist_matchComp);\n\n memcpy(combinedMatches, state->matches, sizeof(ZSTD_eDist_match));\n for (i = 1; i < state->nbMatches; i++) {\n ZSTD_eDist_match const match = state->matches[i];\n ZSTD_eDist_match const combinedMatch = \n combinedMatches[nbCombinedMatches - 1];\n if (combinedMatch.srcIdx + combinedMatch.matchLength == match.srcIdx && \n combinedMatch.dictIdx + combinedMatch.matchLength == match.dictIdx) {\n combinedMatches[nbCombinedMatches - 1].matchLength++;\n } else {\n /* Discard matches that are less than MINMATCH */\n if (combinedMatches[nbCombinedMatches - 1].matchLength < MINMATCH) {\n nbCombinedMatches--;\n }\n\n memcpy(combinedMatches + nbCombinedMatches, \n state->matches + i, sizeof(ZSTD_eDist_match));\n nbCombinedMatches++;\n }\n }\n memcpy(state->matches, combinedMatches, nbCombinedMatches * sizeof(ZSTD_eDist_match));\n state->nbMatches = nbCombinedMatches;\n ZSTD_free(combinedMatches, ZSTD_defaultCMem);\n}\n\nstatic size_t ZSTD_eDist_convertMatchesToSequences(ZSTD_Sequence* sequences, \n ZSTD_eDist_state* state)\n{\n const ZSTD_eDist_match* matches = state->matches;\n size_t const nbMatches = state->nbMatches;\n size_t const dictSize = state->dictSize;\n size_t nbSequences = 0;\n size_t i;\n for (i = 0; i < nbMatches; i++) {\n ZSTD_eDist_match const match = matches[i];\n U32 const litLength = !i ? match.srcIdx : \n match.srcIdx - (matches[i - 1].srcIdx + matches[i - 1].matchLength);\n U32 const offset = (match.srcIdx + dictSize) - match.dictIdx;\n U32 const matchLength = match.matchLength;\n sequences[nbSequences].offset = offset;\n sequences[nbSequences].litLength = litLength;\n sequences[nbSequences].matchLength = matchLength;\n nbSequences++;\n }\n return nbSequences;\n}\n\n/*-*************************************\n* Internal utils\n***************************************/\n\nstatic size_t ZSTD_eDist_hamingDist(const BYTE* const a,\n const BYTE* const b, size_t n)\n{\n size_t i;\n size_t dist = 0;\n for (i = 0; i < n; i++)\n dist += a[i] != b[i];\n return dist; \n}\n\n/* This is a pretty naive recursive implementation that should only\n * be used for quick tests obviously. Don't try and run this on a \n * GB file or something. There are faster implementations. Use those\n * if you need to run it for large files. */\nstatic size_t ZSTD_eDist_levenshteinDist(const BYTE* const s,\n size_t const sn, const BYTE* const t,\n size_t const tn)\n{\n size_t a, b, c;\n\n if (!sn)\n return tn;\n if (!tn)\n return sn;\n \n if (s[sn - 1] == t[tn - 1])\n return ZSTD_eDist_levenshteinDist(\n s, sn - 1, t, tn - 1);\n \n a = ZSTD_eDist_levenshteinDist(s, sn - 1, t, tn - 1);\n b = ZSTD_eDist_levenshteinDist(s, sn, t, tn - 1);\n c = ZSTD_eDist_levenshteinDist(s, sn - 1, t, tn);\n\n if (a > b)\n a = b;\n if (a > c)\n a = c;\n \n return a + 1;\n}\n\nstatic void ZSTD_eDist_validateMatches(ZSTD_eDist_match* matches,\n size_t const nbMatches, const BYTE* const dict,\n size_t const dictSize, const BYTE* const src,\n size_t const srcSize)\n{\n size_t i;\n for (i = 0; i < nbMatches; i++) {\n ZSTD_eDist_match match = matches[i];\n U32 const dictIdx = match.dictIdx;\n U32 const srcIdx = match.srcIdx;\n U32 const matchLength = match.matchLength;\n \n assert(dictIdx + matchLength < dictSize);\n assert(srcIdx + matchLength < srcSize);\n assert(!memcmp(dict + dictIdx, src + srcIdx, matchLength));\n }\n}\n\n/*-*************************************\n* API\n***************************************/\n\nsize_t ZSTD_eDist_genSequences(ZSTD_Sequence* sequences, \n const void* dict, size_t dictSize,\n const void* src, size_t srcSize,\n int useHeuristics)\n{\n size_t const nbDiags = dictSize + srcSize + 3;\n S32* buffer = ZSTD_malloc(nbDiags * 2 * sizeof(S32), ZSTD_defaultCMem);\n ZSTD_eDist_state state;\n size_t nbSequences = 0;\n\n state.dict = (const BYTE*)dict;\n state.src = (const BYTE*)src;\n state.dictSize = dictSize;\n state.srcSize = srcSize;\n state.forwardDiag = buffer;\n state.backwardDiag = buffer + nbDiags;\n state.forwardDiag += srcSize + 1;\n state.backwardDiag += srcSize + 1;\n state.matches = ZSTD_malloc(srcSize * sizeof(ZSTD_eDist_match), ZSTD_defaultCMem);\n state.nbMatches = 0;\n\n ZSTD_eDist_compare(&state, 0, dictSize, 0, srcSize, 1);\n ZSTD_eDist_combineMatches(&state);\n nbSequences = ZSTD_eDist_convertMatchesToSequences(sequences, &state);\n\n ZSTD_free(buffer, ZSTD_defaultCMem);\n ZSTD_free(state.matches, ZSTD_defaultCMem);\n\n return nbSequences;\n}\n" }, { "path": "contrib/match_finders/zstd_edist.h", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/* This match finder leverages techniques used in file comparison algorithms\n * to find matches between a dictionary and a source file.\n * \n * The original motivation for studying this approach was to try and optimize \n * Zstandard for the use case of patching: the most common scenario being \n * updating an existing software package with the next version. When patching,\n * the difference between the old version of the package and the new version \n * is generally tiny (most of the new file will be identical to \n * the old one). In more technical terms, the edit distance (the minimal number \n * of changes required to take one sequence of bytes to another) between the \n * files would be small relative to the size of the file. \n * \n * Various 'diffing' algorithms utilize this notion of edit distance and \n * the corresponding concept of a minimal edit script between two \n * sequences to identify the regions within two files where they differ. \n * The core algorithm used in this match finder is described in: \n * \n * \"An O(ND) Difference Algorithm and its Variations\", Eugene W. Myers,\n * Algorithmica Vol. 1, 1986, pp. 251-266,\n * .\n * \n * Additional algorithmic heuristics for speed improvement have also been included.\n * These we inspired from implementations of various regular and binary diffing \n * algorithms such as GNU diff, bsdiff, and Xdelta. \n * \n * Note: after some experimentation, this approach proved to not provide enough \n * utility to justify the additional CPU used in finding matches. The one area\n * where this approach consistently outperforms Zstandard even on level 19 is \n * when compressing small files (<10 KB) using an equally small dictionary that \n * is very similar to the source file. For the use case that this was intended,\n * (large similar files) this approach by itself took 5-10X longer than zstd-19 and \n * generally resulted in 2-3X larger files. The core advantage that zstd-19 has \n * over this approach for match finding is the overlapping matches. This approach \n * cannot find any. \n * \n * I'm leaving this in the contrib section in case this ever becomes interesting \n * to explore again.\n * */\n\n#ifndef ZSTD_EDIST_H\n#define ZSTD_EDIST_H\n\n/*-*************************************\n* Dependencies\n***************************************/\n\n#include \n#include \"zstd_internal.h\" /* ZSTD_Sequence */\n\n/*! ZSTD_eDist_genSequences() : \n * Will populate the provided ZSTD_Sequence buffer with sequences \n * based on the optimal or near-optimal (depending on 'useHeuristics')\n * edit script between 'dict' and 'src.' \n * @return : the number of sequences found */ \nsize_t ZSTD_eDist_genSequences(ZSTD_Sequence* sequences, \n const void* dict, size_t dictSize,\n const void* src, size_t srcSize,\n int useHeuristics);\n\n#endif\n" }, { "path": "contrib/premake/premake4.lua", "content": "-- Include zstd.lua in your GENie or premake4 file, which exposes a project_zstd function\ndofile('zstd.lua')\n\nsolution 'example'\n\tconfigurations { 'Debug', 'Release' }\n\tproject_zstd('../../lib/')\n" }, { "path": "contrib/premake/zstd.lua", "content": "-- This GENie/premake file copies the behavior of the Makefile in the lib folder.\n-- Basic usage: project_zstd(ZSTD_DIR)\n\nfunction project_zstd(dir, compression, decompression, deprecated, dictbuilder, legacy)\n\tif string.sub(dir, -1, 1) ~= '/' then dir = dir .. '/' end\n\tif compression == nil then compression = true end\n\tif decompression == nil then decompression = true end\n\tif deprecated == nil then deprecated = false end\n\tif dictbuilder == nil then dictbuilder = false end\n\n\tif legacy == nil then legacy = 0 end\n\n\tif not compression then\n\t\tdictbuilder = false\n\t\tdeprecated = false\n\tend\n\n\tif not decompression then\n\t\tlegacy = 0\n\t\tdeprecated = false\n\tend\n\n\tproject 'zstd'\n\t\tkind 'StaticLib'\n\t\tlanguage 'C'\n\n\t\tfiles {\n\t\t\tdir .. 'zstd.h',\n\t\t\tdir .. 'common/**.c',\n\t\t\tdir .. 'common/**.h'\n\t\t}\n\n\t\tif compression then\n\t\t\tfiles {\n\t\t\t\tdir .. 'compress/**.c',\n\t\t\t\tdir .. 'compress/**.h'\n\t\t\t}\n\t\tend\n\n\t\tif decompression then\n\t\t\tfiles {\n\t\t\t\tdir .. 'decompress/**.c',\n\t\t\t\tdir .. 'decompress/**.h'\n\t\t\t}\n\t\tend\n\n\t\tif dictbuilder then\n\t\t\tfiles {\n\t\t\t\tdir .. 'dictBuilder/**.c',\n\t\t\t\tdir .. 'dictBuilder/**.h'\n\t\t\t}\n\t\tend\n\n\t\tif deprecated then\n\t\t\tfiles {\n\t\t\t\tdir .. 'deprecated/**.c',\n\t\t\t\tdir .. 'deprecated/**.h'\n\t\t\t}\n\t\tend\n\n\t\tif legacy ~= 0 then\n\t\t\tif legacy >= 8 then\n\t\t\t\tfiles {\n\t\t\t\t\tdir .. 'legacy/zstd_v0' .. (legacy - 7) .. '.*'\n\t\t\t\t}\n\t\t\tend\n\t\t\tincludedirs {\n\t\t\t\tdir .. 'legacy'\n\t\t\t}\n\t\tend\n\n\t\tincludedirs {\n\t\t\tdir,\n\t\t\tdir .. 'common'\n\t\t}\n\n\t\tdefines {\n\t\t\t'XXH_NAMESPACE=ZSTD_',\n\t\t\t'ZSTD_LEGACY_SUPPORT=' .. legacy\n\t\t}\nend\n" }, { "path": "contrib/recovery/Makefile", "content": "# ################################################################\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n# All rights reserved.\n#\n# This source code is licensed under both the BSD-style license (found in the\n# LICENSE file in the root directory of this source tree) and the GPLv2 (found\n# in the COPYING file in the root directory of this source tree).\n# ################################################################\n\n.PHONY: all\nall: recover_directory\n\nZSTDLIBDIR ?= ../../lib\nPROGRAMDIR ?= ../../programs\n\nCFLAGS ?= -O3\nCFLAGS += -I$(ZSTDLIBDIR) -I$(PROGRAMDIR)\nCFLAGS += -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \\\n -Wstrict-aliasing=1 -Wswitch-enum \\\n -Wstrict-prototypes -Wundef \\\n -Wvla -Wformat=2 -Winit-self -Wfloat-equal -Wwrite-strings \\\n -Wredundant-decls -Wmissing-prototypes\nCFLAGS += $(DEBUGFLAGS) $(MOREFLAGS)\nFLAGS = $(CPPFLAGS) $(CFLAGS) $(LDFLAGS)\n\n.PHONY: $(ZSTDLIBDIR)/libzstd.a\n$(ZSTDLIBDIR)/libzstd.a:\n\t$(MAKE) -C $(ZSTDLIBDIR) libzstd.a\n\nrecover_directory: recover_directory.c $(ZSTDLIBDIR)/libzstd.a $(PROGRAMDIR)/util.c\n\t$(CC) $(FLAGS) $^ -o $@$(EXT)\n\n.PHONY: clean\nclean:\n\trm -f recover_directory\n" }, { "path": "contrib/recovery/recover_directory.c", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#include \n#include \n#include \n\n#define ZSTD_STATIC_LINKING_ONLY\n#include \"util.h\"\n#include \"zstd.h\"\n\n#define CHECK(cond, ...) \\\n do { \\\n if (!(cond)) { \\\n fprintf(stderr, \"%s:%d CHECK(%s) failed: \", __FILE__, __LINE__, #cond); \\\n fprintf(stderr, \"\" __VA_ARGS__); \\\n fprintf(stderr, \"\\n\"); \\\n exit(1); \\\n } \\\n } while (0)\n\nstatic void usage(char const *program) {\n fprintf(stderr, \"USAGE: %s FILE.zst PREFIX\\n\", program);\n fprintf(stderr, \"FILE.zst: A zstd compressed file with multiple frames\\n\");\n fprintf(stderr, \"PREFIX: The output prefix. Uncompressed files will be \"\n \"created named ${PREFIX}0 ${PREFIX}1...\\n\\n\");\n fprintf(stderr, \"This program takes concatenated zstd frames and \"\n \"decompresses them into individual files.\\n\");\n fprintf(stderr, \"E.g. files created with a command like: zstd -r directory \"\n \"-o file.zst\\n\");\n}\n\ntypedef struct {\n char *data;\n size_t size;\n size_t frames;\n size_t maxFrameSize;\n} ZstdFrames;\n\nstatic ZstdFrames readFile(char const *fileName) {\n U64 const fileSize = UTIL_getFileSize(fileName);\n CHECK(fileSize != UTIL_FILESIZE_UNKNOWN, \"Unknown file size!\");\n\n char *const data = (char *)malloc(fileSize);\n CHECK(data != NULL, \"Allocation failed\");\n\n FILE *file = fopen(fileName, \"rb\");\n CHECK(file != NULL, \"fopen failed\");\n\n size_t const readSize = fread(data, 1, fileSize, file);\n CHECK(readSize == fileSize, \"fread failed\");\n\n fclose(file);\n ZstdFrames frames;\n frames.data = (char *)data;\n frames.size = fileSize;\n frames.frames = 0;\n\n size_t index;\n size_t maxFrameSize = 0;\n for (index = 0; index < fileSize;) {\n size_t const frameSize =\n ZSTD_findFrameCompressedSize(data + index, fileSize - index);\n CHECK(!ZSTD_isError(frameSize), \"Bad zstd frame: %s\",\n ZSTD_getErrorName(frameSize));\n if (frameSize > maxFrameSize)\n maxFrameSize = frameSize;\n frames.frames += 1;\n index += frameSize;\n }\n CHECK(index == fileSize, \"Zstd file corrupt!\");\n frames.maxFrameSize = maxFrameSize;\n\n return frames;\n}\n\nstatic int computePadding(size_t numFrames) {\n return snprintf(NULL, 0, \"%u\", (unsigned)numFrames);\n}\n\nint main(int argc, char **argv) {\n if (argc != 3) {\n usage(argv[0]);\n exit(1);\n }\n char const *const zstdFile = argv[1];\n char const *const prefix = argv[2];\n\n ZstdFrames frames = readFile(zstdFile);\n\n if (frames.frames <= 1) {\n fprintf(\n stderr,\n \"%s only has %u zstd frame. Simply use `zstd -d` to decompress it.\\n\",\n zstdFile, (unsigned)frames.frames);\n exit(1);\n }\n\n int const padding = computePadding(frames.frames - 1);\n\n size_t const outFileNameSize = strlen(prefix) + padding + 1;\n char* outFileName = malloc(outFileNameSize);\n CHECK(outFileName != NULL, \"Allocation failure\");\n\n size_t const bufferSize = 128 * 1024;\n void *buffer = malloc(bufferSize);\n CHECK(buffer != NULL, \"Allocation failure\");\n\n ZSTD_DCtx* dctx = ZSTD_createDCtx();\n CHECK(dctx != NULL, \"Allocation failure\");\n\n fprintf(stderr, \"Recovering %u files...\\n\", (unsigned)frames.frames);\n\n size_t index;\n size_t frame = 0;\n for (index = 0; index < frames.size; ++frame) {\n size_t const frameSize =\n ZSTD_findFrameCompressedSize(frames.data + index, frames.size - index);\n\n int const ret = snprintf(outFileName, outFileNameSize, \"%s%0*u\", prefix, padding, (unsigned)frame);\n CHECK(ret >= 0 && (size_t)ret <= outFileNameSize, \"snprintf failed!\");\n\n FILE* outFile = fopen(outFileName, \"wb\");\n CHECK(outFile != NULL, \"fopen failed\");\n\n ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only);\n ZSTD_inBuffer in = {frames.data + index, frameSize, 0};\n while (in.pos < in.size) {\n ZSTD_outBuffer out = {buffer, bufferSize, 0};\n CHECK(!ZSTD_isError(ZSTD_decompressStream(dctx, &out, &in)), \"decompression failed\");\n size_t const writeSize = fwrite(out.dst, 1, out.pos, outFile);\n CHECK(writeSize == out.pos, \"fwrite failed\");\n }\n fclose(outFile);\n fprintf(stderr, \"Recovered %s\\n\", outFileName);\n index += frameSize;\n }\n fprintf(stderr, \"Complete\\n\");\n\n free(outFileName);\n ZSTD_freeDCtx(dctx);\n free(buffer);\n free(frames.data);\n return 0;\n}\n" }, { "path": "contrib/seekable_format/README.md", "content": "# Zstandard Seekable Format\n\nThe seekable format splits compressed data into a series of independent \"frames\",\neach compressed individually,\nso that decompression of a section in the middle of an archive\nonly requires zstd to decompress at most a frame's worth of extra data,\ninstead of the entire archive.\n\nThe frames are appended, so that the decompression of the entire payload\nstill regenerates the original content, using any compliant zstd decoder.\n\nOn top of that, the seekable format generates a jump table,\nwhich makes it possible to jump directly to the position of the relevant frame\nwhen requesting only a segment of the data.\nThe jump table is simply ignored by zstd decoders unaware of the seekable format.\n\nThe format is delivered with an API to create seekable archives\nand to retrieve arbitrary segments inside the archive.\n\n### Maximum Frame Size parameter\n\nWhen creating a seekable archive, the main parameter is the maximum frame size.\n\nAt compression time, user can manually select the boundaries between segments,\nbut they don't have to: long segments will be automatically split\nwhen larger than selected maximum frame size.\n\nSmall frame sizes reduce decompression cost when requesting small segments,\nbecause the decoder will nonetheless have to decompress an entire frame\nto recover just a single byte from it.\n\nA good rule of thumb is to select a maximum frame size roughly equivalent\nto the access pattern when it's known.\nFor example, if the application tends to request 4KB blocks,\nthen it's a good idea to set a maximum frame size in the vicinity of 4 KB.\n\nBut small frame sizes also reduce compression ratio,\nand increase the cost for the jump table,\nso there is a balance to find.\n\nIn general, try to avoid really tiny frame sizes (<1 KB),\nwhich would have a large negative impact on compression ratio.\n" }, { "path": "contrib/seekable_format/examples/.gitignore", "content": "seekable_compression\nseekable_decompression\nseekable_decompression_mem\nparallel_processing\nparallel_compression\n" }, { "path": "contrib/seekable_format/examples/Makefile", "content": "# ################################################################\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n# All rights reserved.\n#\n# This source code is licensed under both the BSD-style license (found in the\n# LICENSE file in the root directory of this source tree) and the GPLv2 (found\n# in the COPYING file in the root directory of this source tree).\n# ################################################################\n\n# This Makefile presumes libzstd is built, using `make` in / or /lib/\n\nZSTDLIB_PATH = ../../../lib\nZSTDLIB_NAME = libzstd.a\n# Parallel tools only make sense against multi-threaded libzstd\nZSTDLIB_TARGET = $(ZSTDLIB_NAME)-mt\nZSTDLIB = $(ZSTDLIB_PATH)/$(ZSTDLIB_NAME)\n\nCPPFLAGS += -DXXH_NAMESPACE=ZSTD_ -I../ -I../../../lib -I../../../lib/common\n\nCFLAGS ?= -O3\nCFLAGS += -g\n\nSEEKABLE_OBJS = ../zstdseek_compress.c ../zstdseek_decompress.c $(ZSTDLIB)\n\n.PHONY: default all clean test\n\ndefault: all\n\nall: seekable_compression seekable_decompression seekable_decompression_mem \\\n\tparallel_processing\n\n$(ZSTDLIB):\n\t$(MAKE) -C $(ZSTDLIB_PATH) $(ZSTDLIB_TARGET)\n\nseekable_compression : seekable_compression.c $(SEEKABLE_OBJS)\n\t$(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@\n\nseekable_decompression : seekable_decompression.c $(SEEKABLE_OBJS)\n\t$(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@\n\nseekable_decompression_mem : seekable_decompression_mem.c $(SEEKABLE_OBJS)\n\t$(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@\n\nparallel_processing : parallel_processing.c $(SEEKABLE_OBJS)\n\t$(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@ -pthread\n\nparallel_compression : parallel_compression.c $(SEEKABLE_OBJS)\n\t$(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@ -pthread\n\nclean:\n\t@rm -f core *.o tmp* result* *.zst \\\n\t\tseekable_compression seekable_decompression \\\n\t\tseekable_decompression_mem \\\n\t\tparallel_processing parallel_compression\n\t@echo Cleaning completed\n" }, { "path": "contrib/seekable_format/examples/parallel_compression.c", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n */\n\n#include // malloc, free, exit, atoi\n#include // fprintf, perror, feof, fopen, etc.\n#include // strlen, memset, strcat\n#define ZSTD_STATIC_LINKING_ONLY\n#include // presumes zstd library is installed\n#include \n#if defined(WIN32) || defined(_WIN32)\n# include \n# define SLEEP(x) Sleep(x)\n#else\n# include \n# define SLEEP(x) usleep(x * 1000)\n#endif\n\n#include \"xxhash.h\"\n\n#define ZSTD_MULTITHREAD 1\n#include \"threading.h\"\n#include \"pool.h\" // use zstd thread pool for demo\n\n#include \"../zstd_seekable.h\"\n\nstatic void* malloc_orDie(size_t size)\n{\n void* const buff = malloc(size);\n if (buff) return buff;\n /* error */\n perror(\"malloc:\");\n exit(1);\n}\n\nstatic FILE* fopen_orDie(const char *filename, const char *instruction)\n{\n FILE* const inFile = fopen(filename, instruction);\n if (inFile) return inFile;\n /* error */\n perror(filename);\n exit(3);\n}\n\nstatic size_t fread_orDie(void* buffer, size_t sizeToRead, FILE* file)\n{\n size_t const readSize = fread(buffer, 1, sizeToRead, file);\n if (readSize == sizeToRead) return readSize; /* good */\n if (feof(file)) return readSize; /* good, reached end of file */\n /* error */\n perror(\"fread\");\n exit(4);\n}\n\nstatic size_t fwrite_orDie(const void* buffer, size_t sizeToWrite, FILE* file)\n{\n size_t const writtenSize = fwrite(buffer, 1, sizeToWrite, file);\n if (writtenSize == sizeToWrite) return sizeToWrite; /* good */\n /* error */\n perror(\"fwrite\");\n exit(5);\n}\n\nstatic size_t fclose_orDie(FILE* file)\n{\n if (!fclose(file)) return 0;\n /* error */\n perror(\"fclose\");\n exit(6);\n}\n\nstruct state {\n FILE* fout;\n ZSTD_pthread_mutex_t mutex;\n size_t nextID;\n struct job* pending;\n ZSTD_frameLog* frameLog;\n const int compressionLevel;\n};\n\nstruct job {\n size_t id;\n struct job* next;\n struct state* state;\n\n void* src;\n size_t srcSize;\n void* dst;\n size_t dstSize;\n\n unsigned checksum;\n};\n\nstatic void addPending_inmutex(struct state* state, struct job* job)\n{\n struct job** p = &state->pending;\n while (*p && (*p)->id < job->id)\n p = &(*p)->next;\n job->next = *p;\n *p = job;\n}\n\nstatic void flushFrame(struct state* state, struct job* job)\n{\n fwrite_orDie(job->dst, job->dstSize, state->fout);\n free(job->dst);\n\n size_t ret = ZSTD_seekable_logFrame(state->frameLog, (unsigned)job->dstSize, (unsigned)job->srcSize, job->checksum);\n if (ZSTD_isError(ret)) {\n fprintf(stderr, \"ZSTD_seekable_logFrame() error : %s \\n\", ZSTD_getErrorName(ret));\n exit(12);\n }\n}\n\nstatic void flushPending_inmutex(struct state* state)\n{\n while (state->pending && state->pending->id == state->nextID) {\n struct job* p = state->pending;\n state->pending = p->next;\n flushFrame(state, p);\n free(p);\n state->nextID++;\n }\n}\n\nstatic void finishFrame(struct job* job)\n{\n struct state *state = job->state;\n ZSTD_pthread_mutex_lock(&state->mutex);\n addPending_inmutex(state, job);\n flushPending_inmutex(state);\n ZSTD_pthread_mutex_unlock(&state->mutex);\n}\n\nstatic void compressFrame(void* opaque)\n{\n struct job* job = opaque;\n\n job->checksum = (unsigned)XXH64(job->src, job->srcSize, 0);\n\n size_t ret = ZSTD_compress(job->dst, job->dstSize, job->src, job->srcSize, job->state->compressionLevel);\n if (ZSTD_isError(ret)) {\n fprintf(stderr, \"ZSTD_compress() error : %s \\n\", ZSTD_getErrorName(ret));\n exit(20);\n }\n job->dstSize = ret;\n\n // No longer need\n free(job->src);\n job->src = NULL;\n\n finishFrame(job);\n}\n\nstatic const char* createOutFilename_orDie(const char* filename)\n{\n size_t const inL = strlen(filename);\n size_t const outL = inL + 5;\n void* outSpace = malloc_orDie(outL);\n memset(outSpace, 0, outL);\n strcat(outSpace, filename);\n strcat(outSpace, \".zst\");\n return (const char*)outSpace;\n}\n\nstatic void openInOut_orDie(const char* fname, FILE** fin, FILE** fout) {\n if (strcmp(fname, \"-\") == 0) {\n *fin = stdin;\n *fout = stdout;\n } else {\n *fin = fopen_orDie(fname, \"rb\");\n const char* outName = createOutFilename_orDie(fname);\n *fout = fopen_orDie(outName, \"wb\");\n }\n}\n\nstatic void compressFile_orDie(const char* fname, int cLevel, unsigned frameSize, size_t nbThreads)\n{\n struct state state = {\n .nextID = 0,\n .pending = NULL,\n .compressionLevel = cLevel,\n };\n ZSTD_pthread_mutex_init(&state.mutex, NULL);\n state.frameLog = ZSTD_seekable_createFrameLog(1);\n if (state.frameLog == NULL) { fprintf(stderr, \"ZSTD_seekable_createFrameLog() failed \\n\"); exit(11); }\n\n POOL_ctx* pool = POOL_create(nbThreads, nbThreads);\n if (pool == NULL) { fprintf(stderr, \"POOL_create() error \\n\"); exit(9); }\n\n FILE* fin;\n openInOut_orDie(fname, &fin, &state.fout);\n\n if (ZSTD_compressBound(frameSize) > 0xFFFFFFFFU) { fprintf(stderr, \"Frame size too large \\n\"); exit(10); }\n size_t dstSize = ZSTD_compressBound(frameSize);\n\n for (size_t id = 0; 1; id++) {\n struct job* job = malloc_orDie(sizeof(struct job));\n job->id = id;\n job->next = NULL;\n job->state = &state;\n job->src = malloc_orDie(frameSize);\n job->dst = malloc_orDie(dstSize);\n job->srcSize = fread_orDie(job->src, frameSize, fin);\n job->dstSize = dstSize; \n POOL_add(pool, compressFrame, job);\n if (feof(fin))\n break;\n }\n\n POOL_joinJobs(pool);\n POOL_free(pool);\n if (state.pending) {\n fprintf(stderr, \"Unexpected leftover output blocks!\\n\");\n exit(13);\n }\n\n { unsigned char seekTableBuff[1024];\n ZSTD_outBuffer out = {seekTableBuff, 1024, 0};\n while (ZSTD_seekable_writeSeekTable(state.frameLog, &out) != 0) {\n fwrite_orDie(seekTableBuff, out.pos, state.fout);\n out.pos = 0;\n }\n fwrite_orDie(seekTableBuff, out.pos, state.fout);\n }\n\n ZSTD_seekable_freeFrameLog(state.frameLog);\n fclose_orDie(state.fout);\n fclose_orDie(fin);\n}\n\nint main(int argc, const char** argv) {\n const char* const exeName = argv[0];\n if (argc!=4) {\n printf(\"wrong arguments\\n\");\n printf(\"usage:\\n\");\n printf(\"%s FILE FRAME_SIZE NB_THREADS\\n\", exeName);\n return 1;\n }\n\n { const char* const inFileName = argv[1];\n unsigned const frameSize = (unsigned)atoi(argv[2]);\n size_t const nbThreads = (size_t)atoi(argv[3]);\n\n compressFile_orDie(inFileName, 5, frameSize, nbThreads);\n }\n\n return 0;\n}\n" }, { "path": "contrib/seekable_format/examples/parallel_processing.c", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n */\n\n/*\n * A simple demo that sums up all the bytes in the file in parallel using\n * seekable decompression and the zstd thread pool\n */\n\n#include // malloc, exit\n#include // fprintf, perror, feof\n#include // strerror\n#include // errno\n#define ZSTD_STATIC_LINKING_ONLY\n#include // presumes zstd library is installed\n#include \n#if defined(_WIN32)\n# include \n# define SLEEP(x) Sleep(x)\n#else\n# include \n# define SLEEP(x) usleep(x * 1000)\n#endif\n\n#include \"pool.h\" // use zstd thread pool for demo\n\n#include \"../zstd_seekable.h\"\n\n#define MIN(a, b) ((a) < (b) ? (a) : (b))\n\nstatic void* malloc_orDie(size_t size)\n{\n void* const buff = malloc(size);\n if (buff) return buff;\n /* error */\n perror(\"malloc\");\n exit(1);\n}\n\nstatic void* realloc_orDie(void* ptr, size_t size)\n{\n ptr = realloc(ptr, size);\n if (ptr) return ptr;\n /* error */\n perror(\"realloc\");\n exit(1);\n}\n\nstatic FILE* fopen_orDie(const char *filename, const char *instruction)\n{\n FILE* const inFile = fopen(filename, instruction);\n if (inFile) return inFile;\n /* error */\n perror(filename);\n exit(3);\n}\n\nstatic size_t fread_orDie(void* buffer, size_t sizeToRead, FILE* file)\n{\n size_t const readSize = fread(buffer, 1, sizeToRead, file);\n if (readSize == sizeToRead) return readSize; /* good */\n if (feof(file)) return readSize; /* good, reached end of file */\n /* error */\n perror(\"fread\");\n exit(4);\n}\n\nstatic size_t fwrite_orDie(const void* buffer, size_t sizeToWrite, FILE* file)\n{\n size_t const writtenSize = fwrite(buffer, 1, sizeToWrite, file);\n if (writtenSize == sizeToWrite) return sizeToWrite; /* good */\n /* error */\n perror(\"fwrite\");\n exit(5);\n}\n\nstatic size_t fclose_orDie(FILE* file)\n{\n if (!fclose(file)) return 0;\n /* error */\n perror(\"fclose\");\n exit(6);\n}\n\nstatic void fseek_orDie(FILE* file, long int offset, int origin) {\n if (!fseek(file, offset, origin)) {\n if (!fflush(file)) return;\n }\n /* error */\n perror(\"fseek\");\n exit(7);\n}\n\nstruct sum_job {\n const char* fname;\n unsigned long long sum;\n unsigned frameNb;\n};\n\nstatic void sumFrame(void* opaque)\n{\n struct sum_job* job = (struct sum_job*)opaque;\n\n FILE* const fin = fopen_orDie(job->fname, \"rb\");\n\n ZSTD_seekable* const seekable = ZSTD_seekable_create();\n if (seekable==NULL) { fprintf(stderr, \"ZSTD_seekable_create() error \\n\"); exit(10); }\n\n size_t const initResult = ZSTD_seekable_initFile(seekable, fin);\n if (ZSTD_isError(initResult)) { fprintf(stderr, \"ZSTD_seekable_init() error : %s \\n\", ZSTD_getErrorName(initResult)); exit(11); }\n\n size_t const frameSize = ZSTD_seekable_getFrameDecompressedSize(seekable, job->frameNb);\n unsigned char* data = malloc_orDie(frameSize);\n\n size_t result = ZSTD_seekable_decompressFrame(seekable, data, frameSize, job->frameNb);\n if (ZSTD_isError(result)) { fprintf(stderr, \"ZSTD_seekable_decompressFrame() error : %s \\n\", ZSTD_getErrorName(result)); exit(12); }\n\n unsigned long long sum = 0;\n size_t i;\n for (i = 0; i < frameSize; i++) {\n sum += data[i];\n }\n job->sum = sum;\n\n fclose(fin);\n ZSTD_seekable_free(seekable);\n free(data);\n}\n\nstatic void sumFile_orDie(const char* fname, int nbThreads)\n{\n POOL_ctx* pool = POOL_create(nbThreads, nbThreads);\n if (pool == NULL) { fprintf(stderr, \"POOL_create() error \\n\"); exit(9); }\n\n FILE* const fin = fopen_orDie(fname, \"rb\");\n\n ZSTD_seekable* const seekable = ZSTD_seekable_create();\n if (seekable==NULL) { fprintf(stderr, \"ZSTD_seekable_create() error \\n\"); exit(10); }\n\n size_t const initResult = ZSTD_seekable_initFile(seekable, fin);\n if (ZSTD_isError(initResult)) { fprintf(stderr, \"ZSTD_seekable_init() error : %s \\n\", ZSTD_getErrorName(initResult)); exit(11); }\n\n unsigned const numFrames = ZSTD_seekable_getNumFrames(seekable);\n struct sum_job* jobs = (struct sum_job*)malloc(numFrames * sizeof(struct sum_job));\n\n unsigned fnb;\n for (fnb = 0; fnb < numFrames; fnb++) {\n jobs[fnb] = (struct sum_job){ fname, 0, fnb };\n POOL_add(pool, sumFrame, &jobs[fnb]);\n }\n POOL_joinJobs(pool);\n\n unsigned long long total = 0;\n\n for (fnb = 0; fnb < numFrames; fnb++) {\n total += jobs[fnb].sum;\n }\n\n printf(\"Sum: %llu\\n\", total);\n\n POOL_free(pool);\n ZSTD_seekable_free(seekable);\n fclose(fin);\n free(jobs);\n}\n\n\nint main(int argc, const char** argv)\n{\n const char* const exeName = argv[0];\n\n if (argc!=3) {\n fprintf(stderr, \"wrong arguments\\n\");\n fprintf(stderr, \"usage:\\n\");\n fprintf(stderr, \"%s FILE NB_THREADS\\n\", exeName);\n return 1;\n }\n\n {\n const char* const inFilename = argv[1];\n int const nbThreads = atoi(argv[2]);\n sumFile_orDie(inFilename, nbThreads);\n }\n\n return 0;\n}\n" }, { "path": "contrib/seekable_format/examples/seekable_compression.c", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n */\n\n#include // malloc, free, exit, atoi\n#include // fprintf, perror, feof, fopen, etc.\n#include // strlen, memset, strcat\n#define ZSTD_STATIC_LINKING_ONLY\n#include // presumes zstd library is installed\n\n#include \"../zstd_seekable.h\"\n\nstatic void* malloc_orDie(size_t size)\n{\n void* const buff = malloc(size);\n if (buff) return buff;\n /* error */\n perror(\"malloc:\");\n exit(1);\n}\n\nstatic FILE* fopen_orDie(const char *filename, const char *instruction)\n{\n FILE* const inFile = fopen(filename, instruction);\n if (inFile) return inFile;\n /* error */\n perror(filename);\n exit(3);\n}\n\nstatic size_t fread_orDie(void* buffer, size_t sizeToRead, FILE* file)\n{\n size_t const readSize = fread(buffer, 1, sizeToRead, file);\n if (readSize == sizeToRead) return readSize; /* good */\n if (feof(file)) return readSize; /* good, reached end of file */\n /* error */\n perror(\"fread\");\n exit(4);\n}\n\nstatic size_t fwrite_orDie(const void* buffer, size_t sizeToWrite, FILE* file)\n{\n size_t const writtenSize = fwrite(buffer, 1, sizeToWrite, file);\n if (writtenSize == sizeToWrite) return sizeToWrite; /* good */\n /* error */\n perror(\"fwrite\");\n exit(5);\n}\n\nstatic size_t fclose_orDie(FILE* file)\n{\n if (!fclose(file)) return 0;\n /* error */\n perror(\"fclose\");\n exit(6);\n}\n\nstatic void compressFile_orDie(const char* fname, const char* outName, int cLevel, unsigned frameSize)\n{\n FILE* const fin = fopen_orDie(fname, \"rb\");\n FILE* const fout = fopen_orDie(outName, \"wb\");\n size_t const buffInSize = ZSTD_CStreamInSize(); /* can always read one full block */\n void* const buffIn = malloc_orDie(buffInSize);\n size_t const buffOutSize = ZSTD_CStreamOutSize(); /* can always flush a full block */\n void* const buffOut = malloc_orDie(buffOutSize);\n\n ZSTD_seekable_CStream* const cstream = ZSTD_seekable_createCStream();\n if (cstream==NULL) { fprintf(stderr, \"ZSTD_seekable_createCStream() error \\n\"); exit(10); }\n size_t const initResult = ZSTD_seekable_initCStream(cstream, cLevel, 1, frameSize);\n if (ZSTD_isError(initResult)) { fprintf(stderr, \"ZSTD_seekable_initCStream() error : %s \\n\", ZSTD_getErrorName(initResult)); exit(11); }\n\n size_t read, toRead = buffInSize;\n while( (read = fread_orDie(buffIn, toRead, fin)) ) {\n ZSTD_inBuffer input = { buffIn, read, 0 };\n while (input.pos < input.size) {\n ZSTD_outBuffer output = { buffOut, buffOutSize, 0 };\n toRead = ZSTD_seekable_compressStream(cstream, &output , &input); /* toRead is guaranteed to be <= ZSTD_CStreamInSize() */\n if (ZSTD_isError(toRead)) { fprintf(stderr, \"ZSTD_seekable_compressStream() error : %s \\n\", ZSTD_getErrorName(toRead)); exit(12); }\n if (toRead > buffInSize) toRead = buffInSize; /* Safely handle case when `buffInSize` is manually changed to a value < ZSTD_CStreamInSize()*/\n fwrite_orDie(buffOut, output.pos, fout);\n }\n }\n\n while (1) {\n ZSTD_outBuffer output = { buffOut, buffOutSize, 0 };\n size_t const remainingToFlush = ZSTD_seekable_endStream(cstream, &output); /* close stream */\n if (ZSTD_isError(remainingToFlush)) { fprintf(stderr, \"ZSTD_seekable_endStream() error : %s \\n\", ZSTD_getErrorName(remainingToFlush)); exit(13); }\n fwrite_orDie(buffOut, output.pos, fout);\n if (!remainingToFlush) break;\n }\n\n ZSTD_seekable_freeCStream(cstream);\n fclose_orDie(fout);\n fclose_orDie(fin);\n free(buffIn);\n free(buffOut);\n}\n\nstatic char* createOutFilename_orDie(const char* filename)\n{\n size_t const inL = strlen(filename);\n size_t const outL = inL + 5;\n void* outSpace = malloc_orDie(outL);\n memset(outSpace, 0, outL);\n strcat(outSpace, filename);\n strcat(outSpace, \".zst\");\n return (char*)outSpace;\n}\n\n#define CLEVEL_DEFAULT 5\nint main(int argc, const char** argv)\n{\n const char* const exeName = argv[0];\n if (argc<3 || argc>4) {\n printf(\"wrong arguments \\n\");\n printf(\"usage: \\n\");\n printf(\"%s FILE FRAME_SIZE [LEVEL] \\n\", exeName);\n return 1;\n }\n\n { const char* const inFileName = argv[1];\n unsigned const frameSize = (unsigned)atoi(argv[2]);\n int const cLevel = (argc==4) ? atoi(argv[3]) : CLEVEL_DEFAULT;\n\n char* const outFileName = createOutFilename_orDie(inFileName);\n compressFile_orDie(inFileName, outFileName, cLevel, frameSize);\n free(outFileName);\n }\n\n return 0;\n}\n" }, { "path": "contrib/seekable_format/examples/seekable_decompression.c", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n */\n\n\n#include // malloc, exit\n#include // fprintf, perror, feof\n#include // strerror\n#include // errno\n#define ZSTD_STATIC_LINKING_ONLY\n#include // presumes zstd library is installed\n#include \n\n#include \"../zstd_seekable.h\"\n\n#define MIN(a, b) ((a) < (b) ? (a) : (b))\n\nstatic void* malloc_orDie(size_t size)\n{\n void* const buff = malloc(size);\n if (buff) return buff;\n /* error */\n perror(\"malloc\");\n exit(1);\n}\n\nstatic void* realloc_orDie(void* ptr, size_t size)\n{\n ptr = realloc(ptr, size);\n if (ptr) return ptr;\n /* error */\n perror(\"realloc\");\n exit(1);\n}\n\nstatic FILE* fopen_orDie(const char *filename, const char *instruction)\n{\n FILE* const inFile = fopen(filename, instruction);\n if (inFile) return inFile;\n /* error */\n perror(filename);\n exit(3);\n}\n\nstatic size_t fread_orDie(void* buffer, size_t sizeToRead, FILE* file)\n{\n size_t const readSize = fread(buffer, 1, sizeToRead, file);\n if (readSize == sizeToRead) return readSize; /* good */\n if (feof(file)) return readSize; /* good, reached end of file */\n /* error */\n perror(\"fread\");\n exit(4);\n}\n\nstatic size_t fwrite_orDie(const void* buffer, size_t sizeToWrite, FILE* file)\n{\n size_t const writtenSize = fwrite(buffer, 1, sizeToWrite, file);\n if (writtenSize == sizeToWrite) return sizeToWrite; /* good */\n /* error */\n perror(\"fwrite\");\n exit(5);\n}\n\nstatic size_t fclose_orDie(FILE* file)\n{\n if (!fclose(file)) return 0;\n /* error */\n perror(\"fclose\");\n exit(6);\n}\n\nstatic void fseek_orDie(FILE* file, long int offset, int origin) {\n if (!fseek(file, offset, origin)) {\n if (!fflush(file)) return;\n }\n /* error */\n perror(\"fseek\");\n exit(7);\n}\n\n\nstatic void decompressFile_orDie(const char* fname, off_t startOffset, off_t endOffset)\n{\n FILE* const fin = fopen_orDie(fname, \"rb\");\n FILE* const fout = stdout;\n size_t const buffOutSize = ZSTD_DStreamOutSize(); /* Guarantee to successfully flush at least one complete compressed block in all circumstances. */\n void* const buffOut = malloc_orDie(buffOutSize);\n\n ZSTD_seekable* const seekable = ZSTD_seekable_create();\n if (seekable==NULL) { fprintf(stderr, \"ZSTD_seekable_create() error \\n\"); exit(10); }\n\n size_t const initResult = ZSTD_seekable_initFile(seekable, fin);\n if (ZSTD_isError(initResult)) { fprintf(stderr, \"ZSTD_seekable_init() error : %s \\n\", ZSTD_getErrorName(initResult)); exit(11); }\n\n while (startOffset < endOffset) {\n size_t const result = ZSTD_seekable_decompress(seekable, buffOut, MIN(endOffset - startOffset, buffOutSize), startOffset);\n if (!result) {\n break;\n }\n\n if (ZSTD_isError(result)) {\n fprintf(stderr, \"ZSTD_seekable_decompress() error : %s \\n\",\n ZSTD_getErrorName(result));\n exit(12);\n }\n fwrite_orDie(buffOut, result, fout);\n startOffset += result;\n }\n\n ZSTD_seekable_free(seekable);\n fclose_orDie(fin);\n fclose_orDie(fout);\n free(buffOut);\n}\n\n\nint main(int argc, const char** argv)\n{\n const char* const exeName = argv[0];\n\n if (argc!=4) {\n fprintf(stderr, \"wrong arguments\\n\");\n fprintf(stderr, \"usage:\\n\");\n fprintf(stderr, \"%s FILE START END\\n\", exeName);\n return 1;\n }\n\n {\n const char* const inFilename = argv[1];\n off_t const startOffset = atoll(argv[2]);\n off_t const endOffset = atoll(argv[3]);\n decompressFile_orDie(inFilename, startOffset, endOffset);\n }\n\n return 0;\n}\n" }, { "path": "contrib/seekable_format/examples/seekable_decompression_mem.c", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n */\n\n\n#include // malloc, exit\n#include // fprintf, perror, feof\n#include // strerror\n#include // errno\n#define ZSTD_STATIC_LINKING_ONLY\n#include // presumes zstd library is installed\n#include \n\n#include \"zstd_seekable.h\"\n\n#define MIN(a, b) ((a) < (b) ? (a) : (b))\n\n#define MAX_FILE_SIZE (8 * 1024 * 1024)\n\nstatic void* malloc_orDie(size_t size)\n{\n void* const buff = malloc(size);\n if (buff) return buff;\n /* error */\n perror(\"malloc\");\n exit(1);\n}\n\nstatic void* realloc_orDie(void* ptr, size_t size)\n{\n ptr = realloc(ptr, size);\n if (ptr) return ptr;\n /* error */\n perror(\"realloc\");\n exit(1);\n}\n\nstatic FILE* fopen_orDie(const char *filename, const char *instruction)\n{\n FILE* const inFile = fopen(filename, instruction);\n if (inFile) return inFile;\n /* error */\n perror(filename);\n exit(3);\n}\n\nstatic size_t fread_orDie(void* buffer, size_t sizeToRead, FILE* file)\n{\n size_t const readSize = fread(buffer, 1, sizeToRead, file);\n if (readSize == sizeToRead) return readSize; /* good */\n if (feof(file)) return readSize; /* good, reached end of file */\n /* error */\n perror(\"fread\");\n exit(4);\n}\n\nstatic size_t fwrite_orDie(const void* buffer, size_t sizeToWrite, FILE* file)\n{\n size_t const writtenSize = fwrite(buffer, 1, sizeToWrite, file);\n if (writtenSize == sizeToWrite) return sizeToWrite; /* good */\n /* error */\n perror(\"fwrite\");\n exit(5);\n}\n\nstatic size_t fclose_orDie(FILE* file)\n{\n if (!fclose(file)) return 0;\n /* error */\n perror(\"fclose\");\n exit(6);\n}\n\nstatic void fseek_orDie(FILE* file, long int offset, int origin) {\n if (!fseek(file, offset, origin)) {\n if (!fflush(file)) return;\n }\n /* error */\n perror(\"fseek\");\n exit(7);\n}\n\n\nstatic void decompressFile_orDie(const char* fname, off_t startOffset, off_t endOffset)\n{\n FILE* const fin = fopen_orDie(fname, \"rb\");\n FILE* const fout = stdout;\n // Just for demo purposes, assume file is <= MAX_FILE_SIZE\n void* const buffIn = malloc_orDie(MAX_FILE_SIZE);\n size_t const inSize = fread_orDie(buffIn, MAX_FILE_SIZE, fin);\n size_t const buffOutSize = ZSTD_DStreamOutSize(); /* Guarantee to successfully flush at least one complete compressed block in all circumstances. */\n void* const buffOut = malloc_orDie(buffOutSize);\n\n ZSTD_seekable* const seekable = ZSTD_seekable_create();\n if (seekable==NULL) { fprintf(stderr, \"ZSTD_seekable_create() error \\n\"); exit(10); }\n\n size_t const initResult = ZSTD_seekable_initBuff(seekable, buffIn, inSize);\n if (ZSTD_isError(initResult)) { fprintf(stderr, \"ZSTD_seekable_init() error : %s \\n\", ZSTD_getErrorName(initResult)); exit(11); }\n\n while (startOffset < endOffset) {\n size_t const result = ZSTD_seekable_decompress(seekable, buffOut, MIN(endOffset - startOffset, buffOutSize), startOffset);\n if (!result) {\n break;\n }\n\n if (ZSTD_isError(result)) {\n fprintf(stderr, \"ZSTD_seekable_decompress() error : %s \\n\",\n ZSTD_getErrorName(result));\n exit(12);\n }\n fwrite_orDie(buffOut, result, fout);\n startOffset += result;\n }\n\n ZSTD_seekable_free(seekable);\n fclose_orDie(fin);\n fclose_orDie(fout);\n free(buffIn);\n free(buffOut);\n}\n\n\nint main(int argc, const char** argv)\n{\n const char* const exeName = argv[0];\n\n if (argc!=4) {\n fprintf(stderr, \"wrong arguments\\n\");\n fprintf(stderr, \"usage:\\n\");\n fprintf(stderr, \"%s FILE START END\\n\", exeName);\n return 1;\n }\n\n {\n const char* const inFilename = argv[1];\n off_t const startOffset = atoll(argv[2]);\n off_t const endOffset = atoll(argv[3]);\n decompressFile_orDie(inFilename, startOffset, endOffset);\n }\n\n return 0;\n}\n" }, { "path": "contrib/seekable_format/tests/.gitignore", "content": "seekable_tests\ndata.txt\n" }, { "path": "contrib/seekable_format/tests/Makefile", "content": "# ################################################################\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n# All rights reserved.\n#\n# This source code is licensed under both the BSD-style license (found in the\n# LICENSE file in the root directory of this source tree) and the GPLv2 (found\n# in the COPYING file in the root directory of this source tree).\n# ################################################################\n\n# This Makefile presumes libzstd is built, using `make` in / or /lib/\n\nZSTDLIB_PATH = ../../../lib\nZSTDLIB_NAME = libzstd.a\nZSTDLIB = $(ZSTDLIB_PATH)/$(ZSTDLIB_NAME)\n\nCPPFLAGS += -DXXH_NAMESPACE=ZSTD_ -I../ -I$(ZSTDLIB_PATH) -I$(ZSTDLIB_PATH)/common\n\nCFLAGS ?= -O3\nCFLAGS += -g -Wall -Wextra -Wcast-qual -Wcast-align -Wconversion \\\n -Wformat=2 -Wstrict-aliasing=1\n\nSEEKABLE_OBJS = ../zstdseek_compress.c ../zstdseek_decompress.c $(ZSTDLIB)\n\n.PHONY: default clean test\ndefault: test\n\ntest: seekable_tests parallel_compression_test\n\t./seekable_tests\n\n$(ZSTDLIB):\n\t$(MAKE) -C $(ZSTDLIB_PATH) $(ZSTDLIB_NAME)\n\nseekable_tests : $(SEEKABLE_OBJS)\n\nEXAMPLES_PATH = ../examples\nPARALLEL_COMPRESSION = $(EXAMPLES_PATH)/parallel_compression\n\nDATAGEN_PATH = ../../../tests\nDATAGEN = $(DATAGEN_PATH)/datagen\n\n$(PARALLEL_COMPRESSION):\n\t$(MAKE) -C $(EXAMPLES_PATH) parallel_compression\n\n$(DATAGEN):\n\t$(MAKE) -C $(DATAGEN_PATH) datagen\n\ndata.txt: $(DATAGEN)\n\t$(DATAGEN) -g100M > $@\n\nparallel_compression_test: $(PARALLEL_COMPRESSION) data.txt\n\tulimit -Sv 102400; $(PARALLEL_COMPRESSION) data.txt 1048576 2\n\n.PHONY: parallel_compression_test parallel_comp\n\nclean:\n\t@$(RM) core *.o tmp* result* *.zst \\\n\t\tseekable_tests data.txt\n\t@echo Cleaning completed\n" }, { "path": "contrib/seekable_format/tests/seekable_tests.c", "content": "#include \n#include \n#include // malloc\n#include \n#include \n#include \n\n#include \"../zstd_seekable.h\"\n\n\n/* ZSTD_seekable_customFile implementation that reads/seeks a buffer while keeping track of total bytes read */\ntypedef struct {\n const void *ptr;\n size_t size;\n size_t pos;\n size_t totalRead;\n} buffWrapperWithTotal_t;\n\nstatic int readBuffWithTotal(void* opaque, void* buffer, size_t n)\n{\n buffWrapperWithTotal_t* const buff = (buffWrapperWithTotal_t*)opaque;\n assert(buff != NULL);\n if (buff->pos + n > buff->size) return -1;\n memcpy(buffer, (const char*)buff->ptr + buff->pos, n);\n buff->pos += n;\n buff->totalRead += n;\n return 0;\n}\n\nstatic int seekBuffWithTotal(void* opaque, long long offset, int origin)\n{\n buffWrapperWithTotal_t* const buff = (buffWrapperWithTotal_t*) opaque;\n unsigned long long newOffset;\n assert(buff != NULL);\n switch (origin) {\n case SEEK_SET:\n assert(offset >= 0);\n newOffset = (unsigned long long)offset;\n break;\n case SEEK_CUR:\n newOffset = (unsigned long long)((long long)buff->pos + offset);\n break;\n case SEEK_END:\n newOffset = (unsigned long long)((long long)buff->size + offset);\n break;\n default:\n assert(0); /* not possible */\n }\n if (newOffset > buff->size) {\n return -1;\n }\n buff->pos = newOffset;\n return 0;\n}\n\n/* Basic unit tests for zstd seekable format */\nint main(int argc, const char** argv)\n{\n unsigned testNb = 1;\n (void)argc; (void)argv;\n printf(\"Beginning zstd seekable format tests...\\n\");\n\n printf(\"Test %u - simple round trip: \", testNb++);\n { size_t const inSize = 4000;\n void* const inBuffer = malloc(inSize);\n assert(inBuffer != NULL);\n\n size_t const seekCapacity = 5000;\n void* const seekBuffer = malloc(seekCapacity);\n assert(seekBuffer != NULL);\n size_t seekSize;\n\n size_t const outCapacity = inSize;\n void* const outBuffer = malloc(outCapacity);\n assert(outBuffer != NULL);\n\n ZSTD_seekable_CStream* const zscs = ZSTD_seekable_createCStream();\n assert(zscs != NULL);\n\n { size_t const initStatus = ZSTD_seekable_initCStream(zscs, 9, 0 /* checksumFlag */, (unsigned)inSize /* maxFrameSize */);\n assert(!ZSTD_isError(initStatus));\n }\n\n { ZSTD_outBuffer outb = { .dst=seekBuffer, .pos=0, .size=seekCapacity };\n ZSTD_inBuffer inb = { .src=inBuffer, .pos=0, .size=inSize };\n\n size_t const cStatus = ZSTD_seekable_compressStream(zscs, &outb, &inb);\n assert(!ZSTD_isError(cStatus));\n assert(inb.pos == inb.size);\n\n size_t const endStatus = ZSTD_seekable_endStream(zscs, &outb);\n assert(!ZSTD_isError(endStatus));\n seekSize = outb.pos;\n }\n\n ZSTD_seekable* const stream = ZSTD_seekable_create();\n assert(stream != NULL);\n { size_t const initStatus = ZSTD_seekable_initBuff(stream, seekBuffer, seekSize);\n assert(!ZSTD_isError(initStatus)); }\n\n { size_t const decStatus = ZSTD_seekable_decompress(stream, outBuffer, outCapacity, 0);\n assert(decStatus == inSize); }\n\n /* unit test ZSTD_seekTable functions */\n ZSTD_seekTable* const zst = ZSTD_seekTable_create_fromSeekable(stream);\n assert(zst != NULL);\n\n unsigned const nbFrames = ZSTD_seekTable_getNumFrames(zst);\n assert(nbFrames > 0);\n\n unsigned long long const frame0Offset = ZSTD_seekTable_getFrameCompressedOffset(zst, 0);\n assert(frame0Offset == 0);\n\n unsigned long long const content0Offset = ZSTD_seekTable_getFrameDecompressedOffset(zst, 0);\n assert(content0Offset == 0);\n\n size_t const cSize = ZSTD_seekTable_getFrameCompressedSize(zst, 0);\n assert(!ZSTD_isError(cSize));\n assert(cSize <= seekCapacity);\n\n size_t const origSize = ZSTD_seekTable_getFrameDecompressedSize(zst, 0);\n assert(origSize == inSize);\n\n unsigned const fo1idx = ZSTD_seekTable_offsetToFrameIndex(zst, 1);\n assert(fo1idx == 0);\n\n free(inBuffer);\n free(seekBuffer);\n free(outBuffer);\n ZSTD_seekable_freeCStream(zscs);\n ZSTD_seekTable_free(zst);\n ZSTD_seekable_free(stream);\n }\n printf(\"Success!\\n\");\n\n\n printf(\"Test %u - check that seekable decompress does not hang: \", testNb++);\n { /* Github issue #2335 */\n const size_t compressed_size = 17;\n const uint8_t compressed_data[17] = {\n '^',\n '*',\n 'M',\n '\\x18',\n '\\t',\n '\\x00',\n '\\x00',\n '\\x00',\n '\\x00',\n '\\x00',\n '\\x00',\n '\\x00',\n (uint8_t)('\\x03'),\n (uint8_t)('\\xb1'),\n (uint8_t)('\\xea'),\n (uint8_t)('\\x92'),\n (uint8_t)('\\x8f'),\n };\n const size_t uncompressed_size = 32;\n uint8_t uncompressed_data[32];\n\n ZSTD_seekable* const stream = ZSTD_seekable_create();\n assert(stream != NULL);\n { size_t const status = ZSTD_seekable_initBuff(stream, compressed_data, compressed_size);\n if (ZSTD_isError(status)) {\n ZSTD_seekable_free(stream);\n goto _test_error;\n } }\n\n /* Should return an error, but not hang */\n { const size_t offset = 2;\n size_t const status = ZSTD_seekable_decompress(stream, uncompressed_data, uncompressed_size, offset);\n if (!ZSTD_isError(status)) {\n ZSTD_seekable_free(stream);\n goto _test_error;\n } }\n\n ZSTD_seekable_free(stream);\n }\n printf(\"Success!\\n\");\n\n printf(\"Test %u - check #2 that seekable decompress does not hang: \", testNb++);\n { /* Github issue #FIXME */\n const size_t compressed_size = 27;\n const uint8_t compressed_data[27] = {\n (uint8_t)'\\x28',\n (uint8_t)'\\xb5',\n (uint8_t)'\\x2f',\n (uint8_t)'\\xfd',\n (uint8_t)'\\x00',\n (uint8_t)'\\x32',\n (uint8_t)'\\x91',\n (uint8_t)'\\x00',\n (uint8_t)'\\x00',\n (uint8_t)'\\x00',\n (uint8_t)'\\x5e',\n (uint8_t)'\\x2a',\n (uint8_t)'\\x4d',\n (uint8_t)'\\x18',\n (uint8_t)'\\x09',\n (uint8_t)'\\x00',\n (uint8_t)'\\x00',\n (uint8_t)'\\x00',\n (uint8_t)'\\x00',\n (uint8_t)'\\x00',\n (uint8_t)'\\x00',\n (uint8_t)'\\x00',\n (uint8_t)'\\x00',\n (uint8_t)'\\xb1',\n (uint8_t)'\\xea',\n (uint8_t)'\\x92',\n (uint8_t)'\\x8f',\n };\n const size_t uncompressed_size = 400;\n uint8_t uncompressed_data[400];\n\n ZSTD_seekable* stream = ZSTD_seekable_create();\n size_t status = ZSTD_seekable_initBuff(stream, compressed_data, compressed_size);\n if (ZSTD_isError(status)) {\n ZSTD_seekable_free(stream);\n goto _test_error;\n }\n\n const size_t offset = 2;\n /* Should return an error, but not hang */\n status = ZSTD_seekable_decompress(stream, uncompressed_data, uncompressed_size, offset);\n if (!ZSTD_isError(status)) {\n ZSTD_seekable_free(stream);\n goto _test_error;\n }\n\n ZSTD_seekable_free(stream);\n }\n printf(\"Success!\\n\");\n\n\n printf(\"Test %u - check ZSTD magic in compressing empty string: \", testNb++);\n { // compressing empty string should return a zstd header\n size_t const capacity = 255;\n char* inBuffer = malloc(capacity);\n assert(inBuffer != NULL);\n inBuffer[0] = '\\0';\n void* const outBuffer = malloc(capacity);\n assert(outBuffer != NULL);\n\n ZSTD_seekable_CStream *s = ZSTD_seekable_createCStream();\n ZSTD_seekable_initCStream(s, 1, 1, 255);\n\n ZSTD_inBuffer input = { .src=inBuffer, .pos=0, .size=0 };\n ZSTD_outBuffer output = { .dst=outBuffer, .pos=0, .size=capacity };\n\n ZSTD_seekable_compressStream(s, &output, &input);\n ZSTD_seekable_endStream(s, &output);\n\n if((((char*)output.dst)[0] != '\\x28') | (((char*)output.dst)[1] != '\\xb5') | (((char*)output.dst)[2] != '\\x2f') | (((char*)output.dst)[3] != '\\xfd')) {\n printf(\"%#02x %#02x %#02x %#02x\\n\", ((char*)output.dst)[0], ((char*)output.dst)[1] , ((char*)output.dst)[2] , ((char*)output.dst)[3] );\n\n free(inBuffer);\n free(outBuffer);\n ZSTD_seekable_freeCStream(s);\n goto _test_error;\n }\n\n free(inBuffer);\n free(outBuffer);\n ZSTD_seekable_freeCStream(s);\n }\n printf(\"Success!\\n\");\n\n\n printf(\"Test %u - multiple decompress calls: \", testNb++);\n { char const inBuffer[] = \"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt\";\n size_t const inSize = sizeof(inBuffer);\n\n size_t const seekCapacity = 5000;\n void* const seekBuffer = malloc(seekCapacity);\n assert(seekBuffer != NULL);\n size_t seekSize;\n\n size_t const outCapacity = inSize;\n char* const outBuffer = malloc(outCapacity);\n assert(outBuffer != NULL);\n\n ZSTD_seekable_CStream* const zscs = ZSTD_seekable_createCStream();\n assert(zscs != NULL);\n\n /* compress test data with a small frame size to ensure multiple frames in the output */\n unsigned const maxFrameSize = 40;\n { size_t const initStatus = ZSTD_seekable_initCStream(zscs, 9, 0 /* checksumFlag */, maxFrameSize);\n assert(!ZSTD_isError(initStatus));\n }\n\n { ZSTD_outBuffer outb = { .dst=seekBuffer, .pos=0, .size=seekCapacity };\n ZSTD_inBuffer inb = { .src=inBuffer, .pos=0, .size=inSize };\n\n while (inb.pos < inb.size) {\n size_t const cStatus = ZSTD_seekable_compressStream(zscs, &outb, &inb);\n assert(!ZSTD_isError(cStatus));\n }\n\n size_t const endStatus = ZSTD_seekable_endStream(zscs, &outb);\n assert(!ZSTD_isError(endStatus));\n seekSize = outb.pos;\n }\n\n ZSTD_seekable* const stream = ZSTD_seekable_create();\n assert(stream != NULL);\n buffWrapperWithTotal_t buffWrapper = {seekBuffer, seekSize, 0, 0};\n { ZSTD_seekable_customFile srcFile = {&buffWrapper, &readBuffWithTotal, &seekBuffWithTotal};\n size_t const initStatus = ZSTD_seekable_initAdvanced(stream, srcFile);\n assert(!ZSTD_isError(initStatus)); }\n\n /* Perform a series of small reads and seeks (repeatedly read 1 byte and skip 1 byte)\n and check that we didn't reread input data unnecessarily */\n size_t pos;\n for (pos = 0; pos < inSize; pos += 2) {\n size_t const decStatus = ZSTD_seekable_decompress(stream, outBuffer, 1, pos);\n if (decStatus != 1 || outBuffer[0] != inBuffer[pos]) {\n free(seekBuffer);\n free(outBuffer);\n ZSTD_seekable_freeCStream(zscs);\n ZSTD_seekable_free(stream);\n goto _test_error;\n }\n }\n if (buffWrapper.totalRead > seekSize) {\n /* We read more than the compressed size, meaning there were some rereads.\n This is unneeded because we only seeked forward. */\n printf(\"Too much data read: %zu read, with compressed size %zu\\n\", buffWrapper.totalRead, seekSize);\n free(seekBuffer);\n free(outBuffer);\n ZSTD_seekable_freeCStream(zscs);\n ZSTD_seekable_free(stream);\n goto _test_error;\n }\n\n /* Perform some reads and seeks to ensure correctness */\n struct {\n size_t offset;\n size_t size;\n } const tests[] = { /* Assume the frame size is 40 */\n {20, 40}, /* read partial data from two frames */\n {60, 10}, /* continue reading from the same offset */\n {50, 20}, /* seek backward within the same frame */\n {10, 10}, /* seek backward to a different frame */\n {25, 10}, /* seek forward within the same frame */\n {60, 10}, /* seek forward to a different frame */\n };\n size_t idx;\n for (idx = 0; idx < sizeof(tests) / sizeof(tests[0]); idx++) {\n size_t const decStatus = ZSTD_seekable_decompress(stream, outBuffer, tests[idx].size, tests[idx].offset);\n if (decStatus != tests[idx].size || memcmp(outBuffer, inBuffer + tests[idx].offset, tests[idx].size) != 0) {\n free(seekBuffer);\n free(outBuffer);\n ZSTD_seekable_freeCStream(zscs);\n ZSTD_seekable_free(stream);\n goto _test_error;\n }\n }\n\n free(seekBuffer);\n free(outBuffer);\n ZSTD_seekable_freeCStream(zscs);\n ZSTD_seekable_free(stream);\n }\n printf(\"Success!\\n\");\n\n /* TODO: Add more tests */\n printf(\"Finished tests\\n\");\n return 0;\n\n_test_error:\n printf(\"test failed! Exiting..\\n\");\n return 1;\n}\n" }, { "path": "contrib/seekable_format/zstd_seekable.h", "content": "#ifndef SEEKABLE_H\n#define SEEKABLE_H\n\n#include \n#include \"zstd.h\" /* ZSTDLIB_API */\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n\n\n#define ZSTD_seekTableFooterSize 9\n\n#define ZSTD_SEEKABLE_MAGICNUMBER 0x8F92EAB1\n\n#define ZSTD_SEEKABLE_MAXFRAMES 0x8000000U\n\n/* Limit maximum size to avoid potential issues storing the compressed size */\n#define ZSTD_SEEKABLE_MAX_FRAME_DECOMPRESSED_SIZE 0x40000000U\n\n/*-****************************************************************************\n* Seekable Format\n*\n* The seekable format splits the compressed data into a series of \"frames\",\n* each compressed individually so that decompression of a section in the\n* middle of an archive only requires zstd to decompress at most a frame's\n* worth of extra data, instead of the entire archive.\n******************************************************************************/\n\ntypedef struct ZSTD_seekable_CStream_s ZSTD_seekable_CStream;\ntypedef struct ZSTD_seekable_s ZSTD_seekable;\ntypedef struct ZSTD_seekTable_s ZSTD_seekTable;\n\n/*-****************************************************************************\n* Seekable compression - HowTo\n* A ZSTD_seekable_CStream object is required to tracking streaming operation.\n* Use ZSTD_seekable_createCStream() and ZSTD_seekable_freeCStream() to create/\n* release resources.\n*\n* Streaming objects are reusable to avoid allocation and deallocation,\n* to start a new compression operation call ZSTD_seekable_initCStream() on the\n* compressor.\n*\n* Data streamed to the seekable compressor will automatically be split into\n* frames of size `maxFrameSize` (provided in ZSTD_seekable_initCStream()),\n* or if none is provided, will be cut off whenever ZSTD_seekable_endFrame() is\n* called or when the default maximum frame size (2GB) is reached.\n*\n* Use ZSTD_seekable_initCStream() to initialize a ZSTD_seekable_CStream object\n* for a new compression operation.\n* - `maxFrameSize` indicates the size at which to automatically start a new\n* seekable frame.\n* `maxFrameSize == 0` implies the default maximum size.\n* Smaller frame sizes allow faster decompression of small segments,\n* since retrieving a single byte requires decompression of\n* the full frame where the byte belongs.\n* In general, size the frames to roughly correspond to\n* the access granularity (when it's known).\n* But small sizes also reduce compression ratio.\n* Avoid really tiny frame sizes (< 1 KB),\n* that would hurt compression ratio considerably.\n* - `checksumFlag` indicates whether or not the seek table should include frame\n* checksums on the uncompressed data for verification.\n* @return : a size hint for input to provide for compression, or an error code\n* checkable with ZSTD_isError()\n*\n* Use ZSTD_seekable_compressStream() repetitively to consume input stream.\n* The function will automatically update both `pos` fields.\n* Note that it may not consume the entire input, in which case `pos < size`,\n* and it's up to the caller to present again remaining data.\n* @return : a size hint, preferred nb of bytes to use as input for next\n* function call or an error code, which can be tested using\n* ZSTD_isError().\n* Note 1 : it's just a hint, to help latency a little, any other\n* value will work fine.\n*\n* At any time, call ZSTD_seekable_endFrame() to end the current frame and\n* start a new one.\n*\n* ZSTD_seekable_endStream() will end the current frame, and then write the seek\n* table so that decompressors can efficiently find compressed frames.\n* ZSTD_seekable_endStream() may return a number > 0 if it was unable to flush\n* all the necessary data to `output`. In this case, it should be called again\n* until all remaining data is flushed out and 0 is returned.\n******************************************************************************/\n\n/*===== Seekable compressor management =====*/\nZSTDLIB_API ZSTD_seekable_CStream* ZSTD_seekable_createCStream(void);\nZSTDLIB_API size_t ZSTD_seekable_freeCStream(ZSTD_seekable_CStream* zcs);\n\n/*===== Seekable compression functions =====*/\nZSTDLIB_API size_t ZSTD_seekable_initCStream(ZSTD_seekable_CStream* zcs, int compressionLevel, int checksumFlag, unsigned maxFrameSize);\nZSTDLIB_API size_t ZSTD_seekable_compressStream(ZSTD_seekable_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input);\nZSTDLIB_API size_t ZSTD_seekable_endFrame(ZSTD_seekable_CStream* zcs, ZSTD_outBuffer* output);\nZSTDLIB_API size_t ZSTD_seekable_endStream(ZSTD_seekable_CStream* zcs, ZSTD_outBuffer* output);\n\n/*= Raw seek table API\n * These functions allow for the seek table to be constructed directly.\n * This table can then be appended to a file of concatenated frames.\n * This allows the frames to be compressed independently, even in parallel,\n * and compiled together afterward into a seekable archive.\n *\n * Use ZSTD_seekable_createFrameLog() to allocate and initialize a tracking\n * structure.\n *\n * Call ZSTD_seekable_logFrame() once for each frame in the archive.\n * checksum is optional, and will not be used if checksumFlag was 0 when the\n * frame log was created. If present, it should be the least significant 32\n * bits of the XXH64 hash of the uncompressed data.\n *\n * Call ZSTD_seekable_writeSeekTable to serialize the data into a seek table.\n * If the entire table was written, the return value will be 0. Otherwise,\n * it will be equal to the number of bytes left to write. */\ntypedef struct ZSTD_frameLog_s ZSTD_frameLog;\nZSTDLIB_API ZSTD_frameLog* ZSTD_seekable_createFrameLog(int checksumFlag);\nZSTDLIB_API size_t ZSTD_seekable_freeFrameLog(ZSTD_frameLog* fl);\nZSTDLIB_API size_t ZSTD_seekable_logFrame(ZSTD_frameLog* fl, unsigned compressedSize, unsigned decompressedSize, unsigned checksum);\nZSTDLIB_API size_t ZSTD_seekable_writeSeekTable(ZSTD_frameLog* fl, ZSTD_outBuffer* output);\n\n\n/*-****************************************************************************\n* Seekable decompression - HowTo\n* A ZSTD_seekable object is required to tracking the seekTable.\n*\n* Call ZSTD_seekable_init* to initialize a ZSTD_seekable object with the\n* the seek table provided in the input.\n* There are three modes for ZSTD_seekable_init:\n* - ZSTD_seekable_initBuff() : An in-memory API. The data contained in\n* `src` should be the entire seekable file, including the seek table.\n* `src` should be kept alive and unmodified until the ZSTD_seekable object\n* is freed or reset.\n* - ZSTD_seekable_initFile() : A simplified file API using stdio. fread and\n* fseek will be used to access the required data for building the seek\n* table and doing decompression operations. `src` should not be closed\n* or modified until the ZSTD_seekable object is freed or reset.\n* - ZSTD_seekable_initAdvanced() : A general API allowing the client to\n* provide its own read and seek callbacks.\n* + ZSTD_seekable_read() : read exactly `n` bytes into `buffer`.\n* Premature EOF should be treated as an error.\n* + ZSTD_seekable_seek() : seek the read head to `offset` from `origin`,\n* where origin is either SEEK_SET (beginning of\n* file), or SEEK_END (end of file).\n* Both functions should return a non-negative value in case of success, and a\n* negative value in case of failure. If implementing using this API and\n* stdio, be careful with files larger than 4GB and fseek. All of these\n* functions return an error code checkable with ZSTD_isError().\n*\n* Call ZSTD_seekable_decompress to decompress `dstSize` bytes at decompressed\n* offset `offset`. ZSTD_seekable_decompress may have to decompress the entire\n* prefix of the frame before the desired data if it has not already processed\n* this section. If ZSTD_seekable_decompress is called multiple times for a\n* consecutive range of data, it will efficiently retain the decompressor object\n* and avoid redecompressing frame prefixes. The return value is the number of\n* bytes decompressed, or an error code checkable with ZSTD_isError().\n*\n* The seek table access functions can be used to obtain the data contained\n* in the seek table. If frameIndex is larger than the value returned by\n* ZSTD_seekable_getNumFrames(), they will return error codes checkable with\n* ZSTD_isError(). Note that since the offset access functions return\n* unsigned long long instead of size_t, in this case they will instead return\n* the value ZSTD_SEEKABLE_FRAMEINDEX_TOOLARGE.\n******************************************************************************/\n\n/*===== Seekable decompressor management =====*/\nZSTDLIB_API ZSTD_seekable* ZSTD_seekable_create(void);\nZSTDLIB_API size_t ZSTD_seekable_free(ZSTD_seekable* zs);\n\n/*===== Seekable decompression functions =====*/\nZSTDLIB_API size_t ZSTD_seekable_initBuff(ZSTD_seekable* zs, const void* src, size_t srcSize);\nZSTDLIB_API size_t ZSTD_seekable_initFile(ZSTD_seekable* zs, FILE* src);\nZSTDLIB_API size_t ZSTD_seekable_decompress(ZSTD_seekable* zs, void* dst, size_t dstSize, unsigned long long offset);\nZSTDLIB_API size_t ZSTD_seekable_decompressFrame(ZSTD_seekable* zs, void* dst, size_t dstSize, unsigned frameIndex);\n\n#define ZSTD_SEEKABLE_FRAMEINDEX_TOOLARGE (0ULL-2)\n/*===== Seekable seek table access functions =====*/\nZSTDLIB_API unsigned ZSTD_seekable_getNumFrames(const ZSTD_seekable* zs);\nZSTDLIB_API unsigned long long ZSTD_seekable_getFrameCompressedOffset(const ZSTD_seekable* zs, unsigned frameIndex);\nZSTDLIB_API unsigned long long ZSTD_seekable_getFrameDecompressedOffset(const ZSTD_seekable* zs, unsigned frameIndex);\nZSTDLIB_API size_t ZSTD_seekable_getFrameCompressedSize(const ZSTD_seekable* zs, unsigned frameIndex);\nZSTDLIB_API size_t ZSTD_seekable_getFrameDecompressedSize(const ZSTD_seekable* zs, unsigned frameIndex);\nZSTDLIB_API unsigned ZSTD_seekable_offsetToFrameIndex(const ZSTD_seekable* zs, unsigned long long offset);\n\n\n/*-****************************************************************************\n* Direct exploitation of the seekTable\n*\n* Memory constrained use cases that manage multiple archives\n* benefit from retaining multiple archive seek tables\n* without retaining a ZSTD_seekable instance for each.\n*\n* Below API allow the above-mentioned use cases\n* to initialize a ZSTD_seekable, extract its (smaller) ZSTD_seekTable,\n* then throw the ZSTD_seekable away to save memory.\n*\n* Standard ZSTD operations can then be used\n* to decompress frames based on seek table offsets.\n******************************************************************************/\n\n/*===== Independent seek table management =====*/\nZSTDLIB_API ZSTD_seekTable* ZSTD_seekTable_create_fromSeekable(const ZSTD_seekable* zs);\nZSTDLIB_API size_t ZSTD_seekTable_free(ZSTD_seekTable* st);\n\n/*===== Direct seek table access functions =====*/\nZSTDLIB_API unsigned ZSTD_seekTable_getNumFrames(const ZSTD_seekTable* st);\nZSTDLIB_API unsigned long long ZSTD_seekTable_getFrameCompressedOffset(const ZSTD_seekTable* st, unsigned frameIndex);\nZSTDLIB_API unsigned long long ZSTD_seekTable_getFrameDecompressedOffset(const ZSTD_seekTable* st, unsigned frameIndex);\nZSTDLIB_API size_t ZSTD_seekTable_getFrameCompressedSize(const ZSTD_seekTable* st, unsigned frameIndex);\nZSTDLIB_API size_t ZSTD_seekTable_getFrameDecompressedSize(const ZSTD_seekTable* st, unsigned frameIndex);\nZSTDLIB_API unsigned ZSTD_seekTable_offsetToFrameIndex(const ZSTD_seekTable* st, unsigned long long offset);\n\n\n/*===== Seekable advanced I/O API =====*/\ntypedef int(ZSTD_seekable_read)(void* opaque, void* buffer, size_t n);\ntypedef int(ZSTD_seekable_seek)(void* opaque, long long offset, int origin);\ntypedef struct {\n void* opaque;\n ZSTD_seekable_read* read;\n ZSTD_seekable_seek* seek;\n} ZSTD_seekable_customFile;\nZSTDLIB_API size_t ZSTD_seekable_initAdvanced(ZSTD_seekable* zs, ZSTD_seekable_customFile src);\n\n#if defined (__cplusplus)\n}\n#endif\n\n#endif\n" }, { "path": "contrib/seekable_format/zstd_seekable_compression_format.md", "content": "# Zstandard Seekable Format\n\n### Notices\n\nCopyright (c) Meta Platforms, Inc. and affiliates.\n\nPermission is granted to copy and distribute this document\nfor any purpose and without charge,\nincluding translations into other languages\nand incorporation into compilations,\nprovided that the copyright notice and this notice are preserved,\nand that any substantive changes or deletions from the original\nare clearly marked.\nDistribution of this document is unlimited.\n\n### Version\n0.1.0 (11/04/17)\n\n## Introduction\nThis document defines a format for compressed data to be stored so that subranges of the data can be efficiently decompressed without requiring the entire document to be decompressed.\nThis is done by splitting up the input data into frames,\neach of which are compressed independently,\nand so can be decompressed independently.\nDecompression then takes advantage of a provided 'seek table', which allows the decompressor to immediately jump to the desired data. This is done in a way that is compatible with the original Zstandard format by placing the seek table in a Zstandard skippable frame.\n\n### Overall conventions\nIn this document:\n- square brackets i.e. `[` and `]` are used to indicate optional fields or parameters.\n- the naming convention for identifiers is `Mixed_Case_With_Underscores`\n- All numeric fields are little-endian unless specified otherwise\n\n## Format\n\nThe format consists of a number of frames (Zstandard compressed frames and skippable frames), followed by a final skippable frame at the end containing the seek table.\n\n### Seek Table Format\nThe structure of the seek table frame is as follows:\n\n|`Skippable_Magic_Number`|`Frame_Size`|`[Seek_Table_Entries]`|`Seek_Table_Footer`|\n|------------------------|------------|----------------------|-------------------|\n| 4 bytes | 4 bytes | 8-12 bytes each | 9 bytes |\n\n__`Skippable_Magic_Number`__\n\nValue : 0x184D2A5E.\nThis is for compatibility with [Zstandard skippable frames].\nSince it is legal for other Zstandard skippable frames to use the same\nmagic number, it is not recommended for a decoder to recognize frames\nsolely on this.\n\n__`Frame_Size`__\n\nThe total size of the skippable frame, not including the `Skippable_Magic_Number` or `Frame_Size`.\nThis is for compatibility with [Zstandard skippable frames].\n\n[Zstandard skippable frames]: https://github.com/facebook/zstd/blob/release/doc/zstd_compression_format.md#skippable-frames\n\n#### `Seek_Table_Footer`\nThe seek table footer format is as follows:\n\n|`Number_Of_Frames`|`Seek_Table_Descriptor`|`Seekable_Magic_Number`|\n|------------------|-----------------------|-----------------------|\n| 4 bytes | 1 byte | 4 bytes |\n\n__`Seekable_Magic_Number`__\n\nValue : 0x8F92EAB1.\nThis value must be the last bytes present in the compressed file so that decoders\ncan efficiently find it and determine if there is an actual seek table present.\n\n__`Number_Of_Frames`__\n\nThe number of stored frames in the data.\n\n__`Seek_Table_Descriptor`__\n\nA bitfield describing the format of the seek table.\n\n| Bit number | Field name |\n| ---------- | ---------- |\n| 7 | `Checksum_Flag` |\n| 6-2 | `Reserved_Bits` |\n| 1-0 | `Unused_Bits` |\n\nWhile only `Checksum_Flag` currently exists, there are 7 other bits in this field that can be used for future changes to the format,\nfor example the addition of inline dictionaries.\n\n__`Checksum_Flag`__\n\nIf the checksum flag is set, each of the seek table entries contains a 4 byte checksum of the uncompressed data contained in its frame.\n\n`Reserved_Bits` are not currently used but may be used in the future for breaking changes, so a compliant decoder should ensure they are set to 0. `Unused_Bits` may be used in the future for non-breaking changes, so a compliant decoder should not interpret these bits.\n\n#### __`Seek_Table_Entries`__\n\n`Seek_Table_Entries` consists of `Number_Of_Frames` (one for each frame in the data, not including the seek table frame) entries of the following form, in sequence:\n\n|`Compressed_Size`|`Decompressed_Size`|`[Checksum]`|\n|-----------------|-------------------|------------|\n| 4 bytes | 4 bytes | 4 bytes |\n\n__`Compressed_Size`__\n\nThe compressed size of the frame.\nThe cumulative sum of the `Compressed_Size` fields of frames `0` to `i` gives the offset in the compressed file of frame `i+1`.\n\n__`Decompressed_Size`__\n\nThe size of the decompressed data contained in the frame. For skippable or otherwise empty frames, this value is 0.\n\n__`Checksum`__\n\nOnly present if `Checksum_Flag` is set in the `Seek_Table_Descriptor`. Value : the least significant 32 bits of the XXH64 digest of the uncompressed data, stored in little-endian format.\n\n## Version Changes\n- 0.1.0: initial version\n" }, { "path": "contrib/seekable_format/zstdseek_compress.c", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n */\n\n#include /* malloc, free */\n#include /* UINT_MAX */\n#include \n\n#define XXH_STATIC_LINKING_ONLY\n#include \"xxhash.h\"\n\n#define ZSTD_STATIC_LINKING_ONLY\n#include \"zstd.h\"\n#include \"zstd_errors.h\"\n#include \"mem.h\"\n\n#include \"zstd_seekable.h\"\n\n#define CHECK_Z(f) { size_t const ret = (f); if (ret != 0) return ret; }\n\n#undef ERROR\n#define ERROR(name) ((size_t)-ZSTD_error_##name)\n\n#undef MIN\n#undef MAX\n#define MIN(a, b) ((a) < (b) ? (a) : (b))\n#define MAX(a, b) ((a) > (b) ? (a) : (b))\n\ntypedef struct {\n U32 cSize;\n U32 dSize;\n U32 checksum;\n} framelogEntry_t;\n\nstruct ZSTD_frameLog_s {\n framelogEntry_t* entries;\n U32 size;\n U32 capacity;\n\n int checksumFlag;\n\n /* for use when streaming out the seek table */\n U32 seekTablePos;\n U32 seekTableIndex;\n} framelog_t;\n\nstruct ZSTD_seekable_CStream_s {\n ZSTD_CStream* cstream;\n ZSTD_frameLog framelog;\n\n U32 frameCSize;\n U32 frameDSize;\n\n XXH64_state_t xxhState;\n\n U32 maxFrameSize;\n\n int writingSeekTable;\n};\n\nstatic size_t ZSTD_seekable_frameLog_allocVec(ZSTD_frameLog* fl)\n{\n /* allocate some initial space */\n size_t const FRAMELOG_STARTING_CAPACITY = 16;\n fl->entries = (framelogEntry_t*)malloc(\n sizeof(framelogEntry_t) * FRAMELOG_STARTING_CAPACITY);\n if (fl->entries == NULL) return ERROR(memory_allocation);\n fl->capacity = (U32)FRAMELOG_STARTING_CAPACITY;\n return 0;\n}\n\nstatic size_t ZSTD_seekable_frameLog_freeVec(ZSTD_frameLog* fl)\n{\n if (fl != NULL) free(fl->entries);\n return 0;\n}\n\nZSTD_frameLog* ZSTD_seekable_createFrameLog(int checksumFlag)\n{\n ZSTD_frameLog* const fl = (ZSTD_frameLog*)malloc(sizeof(ZSTD_frameLog));\n if (fl == NULL) return NULL;\n\n if (ZSTD_isError(ZSTD_seekable_frameLog_allocVec(fl))) {\n free(fl);\n return NULL;\n }\n\n fl->checksumFlag = checksumFlag;\n fl->seekTablePos = 0;\n fl->seekTableIndex = 0;\n fl->size = 0;\n\n return fl;\n}\n\nsize_t ZSTD_seekable_freeFrameLog(ZSTD_frameLog* fl)\n{\n ZSTD_seekable_frameLog_freeVec(fl);\n free(fl);\n return 0;\n}\n\nZSTD_seekable_CStream* ZSTD_seekable_createCStream(void)\n{\n ZSTD_seekable_CStream* const zcs = (ZSTD_seekable_CStream*)malloc(sizeof(ZSTD_seekable_CStream));\n if (zcs == NULL) return NULL;\n\n memset(zcs, 0, sizeof(*zcs));\n\n zcs->cstream = ZSTD_createCStream();\n if (zcs->cstream == NULL) goto failed1;\n\n if (ZSTD_isError(ZSTD_seekable_frameLog_allocVec(&zcs->framelog))) goto failed2;\n\n return zcs;\n\nfailed2:\n ZSTD_freeCStream(zcs->cstream);\nfailed1:\n free(zcs);\n return NULL;\n}\n\nsize_t ZSTD_seekable_freeCStream(ZSTD_seekable_CStream* zcs)\n{\n if (zcs == NULL) return 0; /* support free on null */\n ZSTD_freeCStream(zcs->cstream);\n ZSTD_seekable_frameLog_freeVec(&zcs->framelog);\n free(zcs);\n return 0;\n}\n\nsize_t ZSTD_seekable_initCStream(ZSTD_seekable_CStream* zcs,\n int compressionLevel,\n int checksumFlag,\n unsigned maxFrameSize)\n{\n zcs->framelog.size = 0;\n zcs->frameCSize = 0;\n zcs->frameDSize = 0;\n\n /* make sure maxFrameSize has a reasonable value */\n if (maxFrameSize > ZSTD_SEEKABLE_MAX_FRAME_DECOMPRESSED_SIZE) {\n return ERROR(frameParameter_unsupported);\n }\n\n zcs->maxFrameSize = maxFrameSize ?\n maxFrameSize : ZSTD_SEEKABLE_MAX_FRAME_DECOMPRESSED_SIZE;\n\n zcs->framelog.checksumFlag = checksumFlag;\n if (zcs->framelog.checksumFlag) {\n XXH64_reset(&zcs->xxhState, 0);\n }\n\n zcs->framelog.seekTablePos = 0;\n zcs->framelog.seekTableIndex = 0;\n zcs->writingSeekTable = 0;\n\n return ZSTD_initCStream(zcs->cstream, compressionLevel);\n}\n\nsize_t ZSTD_seekable_logFrame(ZSTD_frameLog* fl,\n unsigned compressedSize,\n unsigned decompressedSize,\n unsigned checksum)\n{\n if (fl->size == ZSTD_SEEKABLE_MAXFRAMES)\n return ERROR(frameIndex_tooLarge);\n\n /* grow the buffer if required */\n if (fl->size == fl->capacity) {\n /* exponential size increase for constant amortized runtime */\n size_t const newCapacity = fl->capacity * 2;\n framelogEntry_t* const newEntries = (framelogEntry_t*)realloc(fl->entries,\n sizeof(framelogEntry_t) * newCapacity);\n\n if (newEntries == NULL) return ERROR(memory_allocation);\n\n fl->entries = newEntries;\n assert(newCapacity <= UINT_MAX);\n fl->capacity = (U32)newCapacity;\n }\n\n fl->entries[fl->size] = (framelogEntry_t){\n compressedSize, decompressedSize, checksum\n };\n fl->size++;\n\n return 0;\n}\n\nsize_t ZSTD_seekable_endFrame(ZSTD_seekable_CStream* zcs, ZSTD_outBuffer* output)\n{\n size_t const prevOutPos = output->pos;\n /* end the frame */\n size_t ret = ZSTD_endStream(zcs->cstream, output);\n\n zcs->frameCSize += (U32)(output->pos - prevOutPos);\n\n /* need to flush before doing the rest */\n if (ret) return ret;\n\n /* frame done */\n\n /* store the frame data for later */\n ret = ZSTD_seekable_logFrame(\n &zcs->framelog, zcs->frameCSize, zcs->frameDSize,\n zcs->framelog.checksumFlag\n ? XXH64_digest(&zcs->xxhState) & 0xFFFFFFFFU\n : 0);\n if (ret) return ret;\n\n /* reset for the next frame */\n zcs->frameCSize = 0;\n zcs->frameDSize = 0;\n\n ZSTD_CCtx_reset(zcs->cstream, ZSTD_reset_session_only);\n if (zcs->framelog.checksumFlag) XXH64_reset(&zcs->xxhState, 0);\n\n return 0;\n}\n\nsize_t ZSTD_seekable_compressStream(ZSTD_seekable_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input)\n{\n const BYTE* const inBase = (const BYTE*) input->src + input->pos;\n size_t inLen = input->size - input->pos;\n\n assert(zcs->maxFrameSize < INT_MAX);\n ZSTD_CCtx_setParameter(zcs->cstream, ZSTD_c_srcSizeHint, (int)zcs->maxFrameSize);\n inLen = MIN(inLen, (size_t)(zcs->maxFrameSize - zcs->frameDSize));\n\n /* if we haven't finished flushing the last frame, don't start writing a new one */\n if (inLen > 0) {\n ZSTD_inBuffer inTmp = { inBase, inLen, 0 };\n size_t const prevOutPos = output->pos;\n\n size_t const ret = ZSTD_compressStream(zcs->cstream, output, &inTmp);\n\n if (zcs->framelog.checksumFlag) {\n XXH64_update(&zcs->xxhState, inBase, inTmp.pos);\n }\n\n zcs->frameCSize += (U32)(output->pos - prevOutPos);\n zcs->frameDSize += (U32)inTmp.pos;\n\n input->pos += inTmp.pos;\n\n if (ZSTD_isError(ret)) return ret;\n }\n\n if (zcs->maxFrameSize == zcs->frameDSize) {\n /* log the frame and start over */\n size_t const ret = ZSTD_seekable_endFrame(zcs, output);\n if (ZSTD_isError(ret)) return ret;\n\n /* get the client ready for the next frame */\n return (size_t)zcs->maxFrameSize;\n }\n\n return (size_t)(zcs->maxFrameSize - zcs->frameDSize);\n}\n\nstatic inline size_t ZSTD_seekable_seekTableSize(const ZSTD_frameLog* fl)\n{\n size_t const sizePerFrame = 8 + (fl->checksumFlag?4:0);\n size_t const seekTableLen = ZSTD_SKIPPABLEHEADERSIZE +\n sizePerFrame * fl->size +\n ZSTD_seekTableFooterSize;\n\n return seekTableLen;\n}\n\nstatic inline size_t ZSTD_stwrite32(ZSTD_frameLog* fl,\n ZSTD_outBuffer* output, U32 const value,\n U32 const offset)\n{\n if (fl->seekTablePos < offset + 4) {\n BYTE tmp[4]; /* so that we can work with buffers too small to write a whole word to */\n size_t const lenWrite =\n MIN(output->size - output->pos, offset + 4 - fl->seekTablePos);\n MEM_writeLE32(tmp, value);\n memcpy((BYTE*)output->dst + output->pos,\n tmp + (fl->seekTablePos - offset), lenWrite);\n output->pos += lenWrite;\n fl->seekTablePos += (U32)lenWrite;\n\n if (lenWrite < 4) return ZSTD_seekable_seekTableSize(fl) - fl->seekTablePos;\n }\n return 0;\n}\n\nsize_t ZSTD_seekable_writeSeekTable(ZSTD_frameLog* fl, ZSTD_outBuffer* output)\n{\n /* seekTableIndex: the current index in the table and\n * seekTableSize: the amount of the table written so far\n *\n * This function is written this way so that if it has to return early\n * because of a small buffer, it can keep going where it left off.\n */\n\n size_t const sizePerFrame = 8 + (fl->checksumFlag?4:0);\n size_t const seekTableLen = ZSTD_seekable_seekTableSize(fl);\n\n CHECK_Z(ZSTD_stwrite32(fl, output, ZSTD_MAGIC_SKIPPABLE_START | 0xE, 0));\n assert(seekTableLen <= (size_t)UINT_MAX);\n CHECK_Z(ZSTD_stwrite32(fl, output, (U32)seekTableLen - ZSTD_SKIPPABLEHEADERSIZE, 4));\n\n while (fl->seekTableIndex < fl->size) {\n unsigned long long const start = ZSTD_SKIPPABLEHEADERSIZE + sizePerFrame * fl->seekTableIndex;\n assert(start + 8 <= UINT_MAX);\n CHECK_Z(ZSTD_stwrite32(fl, output,\n fl->entries[fl->seekTableIndex].cSize,\n (U32)start + 0));\n\n CHECK_Z(ZSTD_stwrite32(fl, output,\n fl->entries[fl->seekTableIndex].dSize,\n (U32)start + 4));\n\n if (fl->checksumFlag) {\n CHECK_Z(ZSTD_stwrite32(\n fl, output, fl->entries[fl->seekTableIndex].checksum,\n (U32)start + 8));\n }\n\n fl->seekTableIndex++;\n }\n\n assert(seekTableLen <= UINT_MAX);\n CHECK_Z(ZSTD_stwrite32(fl, output, fl->size,\n (U32)seekTableLen - ZSTD_seekTableFooterSize));\n\n if (output->size - output->pos < 1) return seekTableLen - fl->seekTablePos;\n if (fl->seekTablePos < seekTableLen - 4) {\n BYTE const sfd = (BYTE)((fl->checksumFlag) << 7);\n\n ((BYTE*)output->dst)[output->pos] = sfd;\n output->pos++;\n fl->seekTablePos++;\n }\n\n CHECK_Z(ZSTD_stwrite32(fl, output, ZSTD_SEEKABLE_MAGICNUMBER,\n (U32)seekTableLen - 4));\n\n if (fl->seekTablePos != seekTableLen) return ERROR(GENERIC);\n return 0;\n}\n\nsize_t ZSTD_seekable_endStream(ZSTD_seekable_CStream* zcs, ZSTD_outBuffer* output)\n{\n if (!zcs->writingSeekTable) {\n const size_t endFrame = ZSTD_seekable_endFrame(zcs, output);\n if (ZSTD_isError(endFrame)) return endFrame;\n /* return an accurate size hint */\n if (endFrame) return endFrame + ZSTD_seekable_seekTableSize(&zcs->framelog);\n }\n\n zcs->writingSeekTable = 1;\n\n return ZSTD_seekable_writeSeekTable(&zcs->framelog, output);\n}\n" }, { "path": "contrib/seekable_format/zstdseek_decompress.c", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/* *********************************************************\n* Turn on Large Files support (>4GB) for 32-bit Linux/Unix\n***********************************************************/\n#if !defined(__64BIT__) || defined(__MINGW32__) /* No point defining Large file for 64 bit but MinGW-w64 requires it */\n# if !defined(_FILE_OFFSET_BITS)\n# define _FILE_OFFSET_BITS 64 /* turn off_t into a 64-bit type for ftello, fseeko */\n# endif\n# if !defined(_LARGEFILE_SOURCE) /* obsolete macro, replaced with _FILE_OFFSET_BITS */\n# define _LARGEFILE_SOURCE 1 /* Large File Support extension (LFS) - fseeko, ftello */\n# endif\n# if defined(_AIX) || defined(__hpux)\n# define _LARGE_FILES /* Large file support on 32-bits AIX and HP-UX */\n# endif\n#endif\n\n/* ************************************************************\n* Detect POSIX version\n* PLATFORM_POSIX_VERSION = 0 for non-Unix e.g. Windows\n* PLATFORM_POSIX_VERSION = 1 for Unix-like but non-POSIX\n* PLATFORM_POSIX_VERSION > 1 is equal to found _POSIX_VERSION\n* Value of PLATFORM_POSIX_VERSION can be forced on command line\n***************************************************************/\n#ifndef PLATFORM_POSIX_VERSION\n\n# if (defined(__APPLE__) && defined(__MACH__)) || defined(__SVR4) || defined(_AIX) || defined(__hpux) /* POSIX.1-2001 (SUSv3) conformant */ \\\n || defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) /* BSD distros */\n /* exception rule : force posix version to 200112L,\n * note: it's better to use unistd.h's _POSIX_VERSION whenever possible */\n# define PLATFORM_POSIX_VERSION 200112L\n\n/* try to determine posix version through official unistd.h's _POSIX_VERSION (https://pubs.opengroup.org/onlinepubs/7908799/xsh/unistd.h.html).\n * note : there is no simple way to know in advance if is present or not on target system,\n * Posix specification mandates its presence and its content, but target system must respect this spec.\n * It's necessary to _not_ #include whenever target OS is not unix-like\n * otherwise it will block preprocessing stage.\n * The following list of build macros tries to \"guess\" if target OS is likely unix-like, and therefore can #include \n */\n# elif !defined(_WIN32) \\\n && ( defined(__unix__) || defined(__unix) \\\n || defined(__midipix__) || defined(__VMS) || defined(__HAIKU__) )\n\n# if defined(__linux__) || defined(__linux) || defined(__CYGWIN__)\n# ifndef _POSIX_C_SOURCE\n# define _POSIX_C_SOURCE 200809L /* feature test macro : https://www.gnu.org/software/libc/manual/html_node/Feature-Test-Macros.html */\n# endif\n# endif\n# include /* declares _POSIX_VERSION */\n# if defined(_POSIX_VERSION) /* POSIX compliant */\n# define PLATFORM_POSIX_VERSION _POSIX_VERSION\n# else\n# define PLATFORM_POSIX_VERSION 1\n# endif\n\n# ifdef __UCLIBC__\n# ifndef __USE_MISC\n# define __USE_MISC /* enable st_mtim on uclibc */\n# endif\n# endif\n\n# else /* non-unix target platform (like Windows) */\n# define PLATFORM_POSIX_VERSION 0\n# endif\n\n#endif /* PLATFORM_POSIX_VERSION */\n\n\n/* ************************************************************\n* Avoid fseek()'s 2GiB barrier with MSVC, macOS, *BSD, MinGW\n***************************************************************/\n#if defined(LIBC_NO_FSEEKO)\n/* Some older libc implementations don't include these functions (e.g. Bionic < 24) */\n# define LONG_SEEK fseek\n#elif defined(_MSC_VER) && _MSC_VER >= 1400\n# define LONG_SEEK _fseeki64\n#elif !defined(__64BIT__) && (PLATFORM_POSIX_VERSION >= 200112L) /* No point defining Large file for 64 bit */\n# define LONG_SEEK fseeko\n#elif defined(__MINGW32__) && !defined(__STRICT_ANSI__) && !defined(__NO_MINGW_LFS) && defined(__MSVCRT__)\n# define LONG_SEEK fseeko64\n#elif defined(_WIN32) && !defined(__DJGPP__)\n# include \n static int LONG_SEEK(FILE* file, __int64 offset, int origin) {\n LARGE_INTEGER off;\n DWORD method;\n off.QuadPart = offset;\n if (origin == SEEK_END)\n method = FILE_END;\n else if (origin == SEEK_CUR)\n method = FILE_CURRENT;\n else\n method = FILE_BEGIN;\n\n if (SetFilePointerEx((HANDLE) _get_osfhandle(_fileno(file)), off, NULL, method))\n return 0;\n else\n return -1;\n }\n#else\n# define LONG_SEEK fseek\n#endif\n\n#include /* malloc, free */\n#include /* FILE* */\n#include /* UNIT_MAX */\n#include \n\n#define XXH_STATIC_LINKING_ONLY\n#include \"xxhash.h\"\n\n#define ZSTD_STATIC_LINKING_ONLY\n#include \"zstd.h\"\n#include \"zstd_errors.h\"\n#include \"mem.h\"\n#include \"zstd_seekable.h\"\n\n#undef ERROR\n#define ERROR(name) ((size_t)-ZSTD_error_##name)\n\n#define CHECK_IO(f) { int const errcod = (f); if (errcod < 0) return ERROR(seekableIO); }\n\n#undef MIN\n#undef MAX\n#define MIN(a, b) ((a) < (b) ? (a) : (b))\n#define MAX(a, b) ((a) > (b) ? (a) : (b))\n\n#define ZSTD_SEEKABLE_NO_OUTPUT_PROGRESS_MAX 16\n\n/* Special-case callbacks for FILE* and in-memory modes, so that we can treat\n * them the same way as the advanced API */\nstatic int ZSTD_seekable_read_FILE(void* opaque, void* buffer, size_t n)\n{\n size_t const result = fread(buffer, 1, n, (FILE*)opaque);\n if (result != n) {\n return -1;\n }\n return 0;\n}\n\nstatic int ZSTD_seekable_seek_FILE(void* opaque, long long offset, int origin)\n{\n int const ret = LONG_SEEK((FILE*)opaque, offset, origin);\n if (ret) return ret;\n return fflush((FILE*)opaque);\n}\n\ntypedef struct {\n const void *ptr;\n size_t size;\n size_t pos;\n} buffWrapper_t;\n\nstatic int ZSTD_seekable_read_buff(void* opaque, void* buffer, size_t n)\n{\n buffWrapper_t* const buff = (buffWrapper_t*)opaque;\n assert(buff != NULL);\n if (buff->pos + n > buff->size) return -1;\n memcpy(buffer, (const BYTE*)buff->ptr + buff->pos, n);\n buff->pos += n;\n return 0;\n}\n\nstatic int ZSTD_seekable_seek_buff(void* opaque, long long offset, int origin)\n{\n buffWrapper_t* const buff = (buffWrapper_t*) opaque;\n unsigned long long newOffset;\n assert(buff != NULL);\n switch (origin) {\n case SEEK_SET:\n assert(offset >= 0);\n newOffset = (unsigned long long)offset;\n break;\n case SEEK_CUR:\n newOffset = (unsigned long long)((long long)buff->pos + offset);\n break;\n case SEEK_END:\n newOffset = (unsigned long long)((long long)buff->size + offset);\n break;\n default:\n assert(0); /* not possible */\n }\n if (newOffset > buff->size) {\n return -1;\n }\n buff->pos = newOffset;\n return 0;\n}\n\ntypedef struct {\n U64 cOffset;\n U64 dOffset;\n U32 checksum;\n} seekEntry_t;\n\nstruct ZSTD_seekTable_s {\n seekEntry_t* entries;\n size_t tableLen;\n\n int checksumFlag;\n};\n\n#define SEEKABLE_BUFF_SIZE ZSTD_BLOCKSIZE_MAX\n\nstruct ZSTD_seekable_s {\n ZSTD_DStream* dstream;\n ZSTD_seekTable seekTable;\n ZSTD_seekable_customFile src;\n\n U64 decompressedOffset;\n U32 curFrame;\n\n BYTE inBuff[SEEKABLE_BUFF_SIZE]; /* need to do our own input buffering */\n BYTE outBuff[SEEKABLE_BUFF_SIZE]; /* so we can efficiently decompress the\n starts of chunks before we get to the\n desired section */\n ZSTD_inBuffer in; /* maintain continuity across ZSTD_seekable_decompress operations */\n buffWrapper_t buffWrapper; /* for `src.opaque` in in-memory mode */\n\n XXH64_state_t xxhState;\n};\n\nZSTD_seekable* ZSTD_seekable_create(void)\n{\n ZSTD_seekable* const zs = (ZSTD_seekable*)malloc(sizeof(ZSTD_seekable));\n if (zs == NULL) return NULL;\n\n /* also initializes stage to zsds_init */\n memset(zs, 0, sizeof(*zs));\n\n zs->dstream = ZSTD_createDStream();\n if (zs->dstream == NULL) {\n free(zs);\n return NULL;\n }\n\n return zs;\n}\n\nsize_t ZSTD_seekable_free(ZSTD_seekable* zs)\n{\n if (zs == NULL) return 0; /* support free on null */\n ZSTD_freeDStream(zs->dstream);\n free(zs->seekTable.entries);\n free(zs);\n return 0;\n}\n\nZSTD_seekTable* ZSTD_seekTable_create_fromSeekable(const ZSTD_seekable* zs)\n{\n assert(zs != NULL);\n if (zs->seekTable.entries == NULL) return NULL;\n ZSTD_seekTable* const st = (ZSTD_seekTable*)malloc(sizeof(ZSTD_seekTable));\n if (st==NULL) return NULL;\n\n st->checksumFlag = zs->seekTable.checksumFlag;\n st->tableLen = zs->seekTable.tableLen;\n\n /* Allocate an extra entry at the end to match logic of initial allocation */\n size_t const entriesSize = sizeof(seekEntry_t) * (zs->seekTable.tableLen + 1);\n seekEntry_t* const entries = (seekEntry_t*)malloc(entriesSize);\n if (entries==NULL) {\n free(st);\n return NULL;\n }\n\n memcpy(entries, zs->seekTable.entries, entriesSize);\n st->entries = entries;\n return st;\n}\n\nsize_t ZSTD_seekTable_free(ZSTD_seekTable* st)\n{\n if (st == NULL) return 0; /* support free on null */\n free(st->entries);\n free(st);\n return 0;\n}\n\n/** ZSTD_seekable_offsetToFrameIndex() :\n * Performs a binary search to find the last frame with a decompressed offset\n * <= pos\n * @return : the frame's index */\nunsigned ZSTD_seekable_offsetToFrameIndex(const ZSTD_seekable* zs, unsigned long long pos)\n{\n return ZSTD_seekTable_offsetToFrameIndex(&zs->seekTable, pos);\n}\n\nunsigned ZSTD_seekTable_offsetToFrameIndex(const ZSTD_seekTable* st, unsigned long long pos)\n{\n U32 lo = 0;\n U32 hi = (U32)st->tableLen;\n assert(st->tableLen <= UINT_MAX);\n\n if (pos >= st->entries[st->tableLen].dOffset) {\n return (unsigned)st->tableLen;\n }\n\n while (lo + 1 < hi) {\n U32 const mid = lo + ((hi - lo) >> 1);\n if (st->entries[mid].dOffset <= pos) {\n lo = mid;\n } else {\n hi = mid;\n }\n }\n return lo;\n}\n\nunsigned ZSTD_seekable_getNumFrames(const ZSTD_seekable* zs)\n{\n return ZSTD_seekTable_getNumFrames(&zs->seekTable);\n}\n\nunsigned ZSTD_seekTable_getNumFrames(const ZSTD_seekTable* st)\n{\n assert(st->tableLen <= UINT_MAX);\n return (unsigned)st->tableLen;\n}\n\nunsigned long long ZSTD_seekable_getFrameCompressedOffset(const ZSTD_seekable* zs, unsigned frameIndex)\n{\n return ZSTD_seekTable_getFrameCompressedOffset(&zs->seekTable, frameIndex);\n}\n\nunsigned long long ZSTD_seekTable_getFrameCompressedOffset(const ZSTD_seekTable* st, unsigned frameIndex)\n{\n if (frameIndex >= st->tableLen) return ZSTD_SEEKABLE_FRAMEINDEX_TOOLARGE;\n return st->entries[frameIndex].cOffset;\n}\n\nunsigned long long ZSTD_seekable_getFrameDecompressedOffset(const ZSTD_seekable* zs, unsigned frameIndex)\n{\n return ZSTD_seekTable_getFrameDecompressedOffset(&zs->seekTable, frameIndex);\n}\n\nunsigned long long ZSTD_seekTable_getFrameDecompressedOffset(const ZSTD_seekTable* st, unsigned frameIndex)\n{\n if (frameIndex >= st->tableLen) return ZSTD_SEEKABLE_FRAMEINDEX_TOOLARGE;\n return st->entries[frameIndex].dOffset;\n}\n\nsize_t ZSTD_seekable_getFrameCompressedSize(const ZSTD_seekable* zs, unsigned frameIndex)\n{\n return ZSTD_seekTable_getFrameCompressedSize(&zs->seekTable, frameIndex);\n}\n\nsize_t ZSTD_seekTable_getFrameCompressedSize(const ZSTD_seekTable* st, unsigned frameIndex)\n{\n if (frameIndex >= st->tableLen) return ERROR(frameIndex_tooLarge);\n return st->entries[frameIndex + 1].cOffset -\n st->entries[frameIndex].cOffset;\n}\n\nsize_t ZSTD_seekable_getFrameDecompressedSize(const ZSTD_seekable* zs, unsigned frameIndex)\n{\n return ZSTD_seekTable_getFrameDecompressedSize(&zs->seekTable, frameIndex);\n}\n\nsize_t ZSTD_seekTable_getFrameDecompressedSize(const ZSTD_seekTable* st, unsigned frameIndex)\n{\n if (frameIndex > st->tableLen) return ERROR(frameIndex_tooLarge);\n return st->entries[frameIndex + 1].dOffset -\n st->entries[frameIndex].dOffset;\n}\n\nstatic size_t ZSTD_seekable_loadSeekTable(ZSTD_seekable* zs)\n{\n int checksumFlag;\n ZSTD_seekable_customFile src = zs->src;\n /* read the footer, fixed size */\n CHECK_IO(src.seek(src.opaque, -(int)ZSTD_seekTableFooterSize, SEEK_END));\n CHECK_IO(src.read(src.opaque, zs->inBuff, ZSTD_seekTableFooterSize));\n\n if (MEM_readLE32(zs->inBuff + 5) != ZSTD_SEEKABLE_MAGICNUMBER) {\n return ERROR(prefix_unknown);\n }\n\n { BYTE const sfd = zs->inBuff[4];\n checksumFlag = sfd >> 7;\n\n /* check reserved bits */\n if ((sfd >> 2) & 0x1f) {\n return ERROR(corruption_detected);\n } }\n\n { U32 const numFrames = MEM_readLE32(zs->inBuff);\n U32 const sizePerEntry = 8 + (checksumFlag?4:0);\n U32 const tableSize = sizePerEntry * numFrames;\n U32 const frameSize = tableSize + ZSTD_seekTableFooterSize + ZSTD_SKIPPABLEHEADERSIZE;\n\n U32 remaining = frameSize - ZSTD_seekTableFooterSize; /* don't need to re-read footer */\n { U32 const toRead = MIN(remaining, SEEKABLE_BUFF_SIZE);\n CHECK_IO(src.seek(src.opaque, -(S64)frameSize, SEEK_END));\n CHECK_IO(src.read(src.opaque, zs->inBuff, toRead));\n remaining -= toRead;\n }\n\n if (MEM_readLE32(zs->inBuff) != (ZSTD_MAGIC_SKIPPABLE_START | 0xE)) {\n return ERROR(prefix_unknown);\n }\n if (MEM_readLE32(zs->inBuff+4) + ZSTD_SKIPPABLEHEADERSIZE != frameSize) {\n return ERROR(prefix_unknown);\n }\n\n { /* Allocate an extra entry at the end so that we can do size\n * computations on the last element without special case */\n seekEntry_t* const entries = (seekEntry_t*)malloc(sizeof(seekEntry_t) * (numFrames + 1));\n\n U32 idx = 0;\n U32 pos = 8;\n\n U64 cOffset = 0;\n U64 dOffset = 0;\n\n if (entries == NULL) return ERROR(memory_allocation);\n\n /* compute cumulative positions */\n for (; idx < numFrames; idx++) {\n if (pos + sizePerEntry > SEEKABLE_BUFF_SIZE) {\n U32 const offset = SEEKABLE_BUFF_SIZE - pos;\n U32 const toRead = MIN(remaining, SEEKABLE_BUFF_SIZE - offset);\n memmove(zs->inBuff, zs->inBuff + pos, offset); /* move any data we haven't read yet */\n CHECK_IO(src.read(src.opaque, zs->inBuff+offset, toRead));\n remaining -= toRead;\n pos = 0;\n }\n entries[idx].cOffset = cOffset;\n entries[idx].dOffset = dOffset;\n\n cOffset += MEM_readLE32(zs->inBuff + pos);\n pos += 4;\n dOffset += MEM_readLE32(zs->inBuff + pos);\n pos += 4;\n if (checksumFlag) {\n entries[idx].checksum = MEM_readLE32(zs->inBuff + pos);\n pos += 4;\n }\n }\n entries[numFrames].cOffset = cOffset;\n entries[numFrames].dOffset = dOffset;\n\n zs->seekTable.entries = entries;\n zs->seekTable.tableLen = numFrames;\n zs->seekTable.checksumFlag = checksumFlag;\n return 0;\n }\n }\n}\n\nsize_t ZSTD_seekable_initBuff(ZSTD_seekable* zs, const void* src, size_t srcSize)\n{\n zs->buffWrapper = (buffWrapper_t){src, srcSize, 0};\n { ZSTD_seekable_customFile srcFile = {&zs->buffWrapper,\n &ZSTD_seekable_read_buff,\n &ZSTD_seekable_seek_buff};\n return ZSTD_seekable_initAdvanced(zs, srcFile); }\n}\n\nsize_t ZSTD_seekable_initFile(ZSTD_seekable* zs, FILE* src)\n{\n ZSTD_seekable_customFile srcFile = {src, &ZSTD_seekable_read_FILE,\n &ZSTD_seekable_seek_FILE};\n return ZSTD_seekable_initAdvanced(zs, srcFile);\n}\n\nsize_t ZSTD_seekable_initAdvanced(ZSTD_seekable* zs, ZSTD_seekable_customFile src)\n{\n zs->src = src;\n\n { const size_t seekTableInit = ZSTD_seekable_loadSeekTable(zs);\n if (ZSTD_isError(seekTableInit)) return seekTableInit; }\n\n zs->decompressedOffset = (U64)-1;\n zs->curFrame = (U32)-1;\n\n { const size_t dstreamInit = ZSTD_initDStream(zs->dstream);\n if (ZSTD_isError(dstreamInit)) return dstreamInit; }\n return 0;\n}\n\nsize_t ZSTD_seekable_decompress(ZSTD_seekable* zs, void* dst, size_t len, unsigned long long offset)\n{\n unsigned long long const eos = zs->seekTable.entries[zs->seekTable.tableLen].dOffset;\n if (offset + len > eos) {\n len = eos - offset;\n }\n\n U32 targetFrame = ZSTD_seekable_offsetToFrameIndex(zs, offset);\n U32 noOutputProgressCount = 0;\n size_t srcBytesRead = 0;\n do {\n /* check if we can continue from a previous decompress job */\n if (targetFrame != zs->curFrame || offset < zs->decompressedOffset) {\n zs->decompressedOffset = zs->seekTable.entries[targetFrame].dOffset;\n zs->curFrame = targetFrame;\n\n assert(zs->seekTable.entries[targetFrame].cOffset < LLONG_MAX);\n CHECK_IO(zs->src.seek(zs->src.opaque,\n (long long)zs->seekTable.entries[targetFrame].cOffset,\n SEEK_SET));\n zs->in = (ZSTD_inBuffer){zs->inBuff, 0, 0};\n XXH64_reset(&zs->xxhState, 0);\n ZSTD_DCtx_reset(zs->dstream, ZSTD_reset_session_only);\n if (zs->buffWrapper.size && srcBytesRead > zs->buffWrapper.size) {\n return ERROR(seekableIO);\n }\n }\n\n while (zs->decompressedOffset < offset + len) {\n size_t toRead;\n ZSTD_outBuffer outTmp;\n size_t prevOutPos;\n size_t prevInPos;\n size_t forwardProgress;\n if (zs->decompressedOffset < offset) {\n /* dummy decompressions until we get to the target offset */\n outTmp = (ZSTD_outBuffer){zs->outBuff, (size_t) (MIN(SEEKABLE_BUFF_SIZE, offset - zs->decompressedOffset)), 0};\n } else {\n outTmp = (ZSTD_outBuffer){dst, len, (size_t) (zs->decompressedOffset - offset)};\n }\n\n prevOutPos = outTmp.pos;\n prevInPos = zs->in.pos;\n toRead = ZSTD_decompressStream(zs->dstream, &outTmp, &zs->in);\n if (ZSTD_isError(toRead)) {\n return toRead;\n }\n\n if (zs->seekTable.checksumFlag) {\n XXH64_update(&zs->xxhState, (BYTE*)outTmp.dst + prevOutPos,\n outTmp.pos - prevOutPos);\n }\n forwardProgress = outTmp.pos - prevOutPos;\n if (forwardProgress == 0) {\n if (noOutputProgressCount++ > ZSTD_SEEKABLE_NO_OUTPUT_PROGRESS_MAX) {\n return ERROR(seekableIO);\n }\n } else {\n noOutputProgressCount = 0;\n }\n zs->decompressedOffset += forwardProgress;\n srcBytesRead += zs->in.pos - prevInPos;\n\n if (toRead == 0) {\n /* frame complete */\n\n /* verify checksum */\n if (zs->seekTable.checksumFlag &&\n (XXH64_digest(&zs->xxhState) & 0xFFFFFFFFU) !=\n zs->seekTable.entries[targetFrame].checksum) {\n return ERROR(corruption_detected);\n }\n\n if (zs->decompressedOffset < offset + len) {\n /* go back to the start and force a reset of the stream */\n targetFrame = ZSTD_seekable_offsetToFrameIndex(zs, zs->decompressedOffset);\n /* in this case it will fail later with corruption_detected, since last block does not have checksum */\n assert(targetFrame != zs->seekTable.tableLen);\n }\n break;\n }\n\n /* read in more data if we're done with this buffer */\n if (zs->in.pos == zs->in.size) {\n toRead = MIN(toRead, SEEKABLE_BUFF_SIZE);\n CHECK_IO(zs->src.read(zs->src.opaque, zs->inBuff, toRead));\n zs->in.size = toRead;\n zs->in.pos = 0;\n }\n } /* while (zs->decompressedOffset < offset + len) */\n } while (zs->decompressedOffset != offset + len);\n\n return len;\n}\n\nsize_t ZSTD_seekable_decompressFrame(ZSTD_seekable* zs, void* dst, size_t dstSize, unsigned frameIndex)\n{\n if (frameIndex >= zs->seekTable.tableLen) {\n return ERROR(frameIndex_tooLarge);\n }\n\n { size_t const decompressedSize =\n zs->seekTable.entries[frameIndex + 1].dOffset -\n zs->seekTable.entries[frameIndex].dOffset;\n if (dstSize < decompressedSize) {\n return ERROR(dstSize_tooSmall);\n }\n return ZSTD_seekable_decompress(\n zs, dst, decompressedSize,\n zs->seekTable.entries[frameIndex].dOffset);\n }\n}\n" }, { "path": "contrib/seqBench/Makefile", "content": "# ################################################################\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n# All rights reserved.\n#\n# This source code is licensed under both the BSD-style license (found in the\n# LICENSE file in the root directory of this source tree) and the GPLv2 (found\n# in the COPYING file in the root directory of this source tree).\n# ################################################################\n\nPROGDIR = ../../programs\nLIBDIR = ../../lib\n\nLIBZSTD = $(LIBDIR)/libzstd.a\n\nCPPFLAGS+= -I$(LIBDIR) -I$(LIBDIR)/common -I$(LIBDIR)/dictBuilder -I$(PROGDIR)\n\nCFLAGS ?= -O3 -g\nCFLAGS += -std=gnu99\nDEBUGFLAGS= -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \\\n -Wstrict-aliasing=1 -Wswitch-enum \\\n -Wstrict-prototypes -Wundef -Wpointer-arith \\\n -Wvla -Wformat=2 -Winit-self -Wfloat-equal -Wwrite-strings \\\n -Wredundant-decls\nCFLAGS += $(DEBUGFLAGS) $(MOREFLAGS)\n\n\ndefault: seqBench\n\nall : seqBench\n\nseqBench: util.o timefn.o benchfn.o datagen.o xxhash.o seqBench.c $(LIBZSTD)\n\t$(CC) $(CPPFLAGS) $(CFLAGS) $^ $(LDFLAGS) -o $@\n\n.PHONY: $(LIBZSTD)\n$(LIBZSTD):\n\t$(MAKE) -C $(LIBDIR) libzstd.a CFLAGS=\"$(CFLAGS)\"\n\nbenchfn.o: $(PROGDIR)/benchfn.c\n\t$(CC) $(CPPFLAGS) $(CFLAGS) $^ -c\n\ntimefn.o: $(PROGDIR)/timefn.c\n\t$(CC) $(CPPFLAGS) $(CFLAGS) $^ -c\n\ndatagen.o: $(PROGDIR)/datagen.c\n\t$(CC) $(CPPFLAGS) $(CFLAGS) $^ -c\n\nutil.o: $(PROGDIR)/util.c\n\t$(CC) $(CPPFLAGS) $(CFLAGS) $^ -c\n\n\nxxhash.o : $(LIBDIR)/common/xxhash.c\n\t$(CC) $(CPPFLAGS) $(CFLAGS) $^ -c\n\n\nclean:\n\t$(RM) *.o\n\t$(MAKE) -C $(LIBDIR) clean > /dev/null\n\t$(RM) seqBench\n" }, { "path": "contrib/seqBench/seqBench.c", "content": "#define ZSTD_STATIC_LINKING_ONLY\n#include \n#include \n#include \n#include \n#include \n\nint main(int argc, char *argv[]) {\n ZSTD_CCtx* zc = ZSTD_createCCtx();\n\n if (argc != 2) {\n printf(\"Usage: seqBench \\n\"); // TODO provide the block delim option here\n return 1;\n }\n\n FILE *f = fopen(argv[1], \"rb\");\n fseek(f, 0, SEEK_END);\n long inBufSize = ftell(f);\n fseek(f, 0, SEEK_SET);\n\n char *inBuf = malloc(inBufSize + 1);\n fread(inBuf, inBufSize, 1, f);\n fclose(f);\n\n size_t seqsSize = ZSTD_sequenceBound(inBufSize);\n ZSTD_Sequence *seqs = (ZSTD_Sequence*)malloc(seqsSize * sizeof(ZSTD_Sequence));\n char *outBuf = malloc(ZSTD_compressBound(inBufSize));\n\n ZSTD_generateSequences(zc, seqs, seqsSize, inBuf, inBufSize);\n ZSTD_CCtx_setParameter(zc, ZSTD_c_blockDelimiters, ZSTD_sf_explicitBlockDelimiters);\n size_t outBufSize = ZSTD_compressSequences(zc, outBuf, inBufSize, seqs, seqsSize, inBuf, inBufSize);\n if (ZSTD_isError(outBufSize)) {\n printf(\"ERROR: %lu\\n\", outBufSize);\n return 1;\n }\n\n char *validationBuf = malloc(inBufSize);\n ZSTD_decompress(validationBuf, inBufSize, outBuf, outBufSize);\n\n if (memcmp(inBuf, validationBuf, inBufSize) == 0) {\n printf(\"Compression and decompression were successful!\\n\");\n } else {\n printf(\"ERROR: input and validation buffers don't match!\\n\");\n for (int i = 0; i < inBufSize; i++) {\n if (inBuf[i] != validationBuf[i]) {\n printf(\"First bad index: %d\\n\", i);\n break;\n }\n }\n }\n\n return 0;\n}\n" }, { "path": "contrib/snap/snapcraft.yaml", "content": "name: zstd\nversion: git\nsummary: Zstandard - Fast real-time compression algorithm\ndescription: |\n Zstandard, or zstd as short version, is a fast lossless compression\n algorithm, targeting real-time compression scenarios at zlib-level and better\n compression ratios. It's backed by a very fast entropy stage, provided by\n Huff0 and FSE library\n\ngrade: devel # must be 'stable' to release into candidate/stable channels\nconfinement: devmode # use 'strict' once you have the right plugs and slots\n\napps:\n zstd:\n command: usr/local/bin/zstd\n plugs: [home, removable-media]\n zstdgrep:\n command: usr/local/bin/zstdgrep\n plugs: [home, removable-media]\n zstdless:\n command: usr/local/bin/zstdless\n plugs: [home, removable-media]\n\nparts:\n zstd:\n source: .\n plugin: make\n build-packages: [g++]\n" }, { "path": "doc/README.md", "content": "Zstandard Documentation\n=======================\n\nThis directory contains material defining the Zstandard format,\nas well as detailed instructions to use `zstd` library.\n\n__`zstd_manual.html`__ : Documentation of `zstd.h` API, in html format.\nUnfortunately, Github doesn't display `html` files in parsed format, just as source code.\nFor a readable display of html API documentation of latest release,\nuse this link: [https://raw.githack.com/facebook/zstd/release/doc/zstd_manual.html](https://raw.githack.com/facebook/zstd/release/doc/zstd_manual.html) .\n\n__`zstd_compression_format.md`__ : This document defines the Zstandard compression format.\nCompliant decoders must adhere to this document,\nand compliant encoders must generate data that follows it.\n\nShould you look for resources to develop your own port of Zstandard algorithm,\nyou may find the following resources useful :\n\n__`educational_decoder`__ : This directory contains an implementation of a Zstandard decoder,\ncompliant with the Zstandard compression format.\nIt can be used, for example, to better understand the format,\nor as the basis for a separate implementation of Zstandard decoder.\n\n[__`decode_corpus`__](https://github.com/facebook/zstd/tree/dev/tests#decodecorpus---tool-to-generate-zstandard-frames-for-decoder-testing) :\nThis tool, stored in `/tests` directory, is able to generate random valid frames,\nwhich is useful if you wish to test your decoder and verify it fully supports the specification.\n" }, { "path": "doc/decompressor_errata.md", "content": "Decompressor Errata\n===================\n\nThis document captures known decompressor bugs, where the decompressor rejects a valid zstd frame.\nEach entry will contain:\n1. The last affected decompressor versions.\n2. The decompressor components affected.\n2. Whether the compressed frame could ever be produced by the reference compressor.\n3. An example frame (hexadecimal string when it can be short enough, link to golden file otherwise)\n4. A description of the bug.\n\nThe document is in reverse chronological order, with the bugs that affect the most recent zstd decompressor versions listed first.\n\n\nNo sequence using the 2-bytes format\n------------------------------------------------\n\n**Last affected version**: v1.5.5\n\n**Affected decompressor component(s)**: Library & CLI\n\n**Produced by the reference compressor**: No\n\n**Example Frame**: see zstd/tests/golden-decompression/zeroSeq_2B.zst\n\nThe zstd decoder incorrectly expects FSE tables when there are 0 sequences present in the block\nif the value 0 is encoded using the 2-bytes format.\nInstead, it should immediately end the sequence section, and move on to next block.\n\nThis situation was never generated by the reference compressor,\nbecause representing 0 sequences with the 2-bytes format is inefficient\n(the 1-byte format is always used in this case).\n\n\nCompressed block with a size of exactly 128 KB\n------------------------------------------------\n\n**Last affected version**: v1.5.2\n\n**Affected decompressor component(s)**: Library & CLI\n\n**Produced by the reference compressor**: No\n\n**Example Frame**: see zstd/tests/golden-decompression/block-128k.zst\n\nThe zstd decoder incorrectly rejected blocks of type `Compressed_Block` when their size was exactly 128 KB.\nNote that `128 KB - 1` was accepted, and `128 KB + 1` is forbidden by the spec.\n\nThis type of block was never generated by the reference compressor.\n\nThese blocks used to be disallowed by the spec up until spec version 0.3.2 when the restriction was lifted by [PR#1689](https://github.com/facebook/zstd/pull/1689).\n\n> A Compressed_Block has the extra restriction that Block_Size is always strictly less than the decompressed size. If this condition cannot be respected, the block must be sent uncompressed instead (Raw_Block).\n\n\nCompressed block with 0 literals and 0 sequences\n------------------------------------------------\n\n**Last affected version**: v1.5.2\n\n**Affected decompressor component(s)**: Library & CLI\n\n**Produced by the reference compressor**: No\n\n**Example Frame**: `28b5 2ffd 2000 1500 0000 00`\n\nThe zstd decoder incorrectly rejected blocks of type `Compressed_Block` that encodes literals as `Raw_Literals_Block` with no literals, and has no sequences.\n\nThis type of block was never generated by the reference compressor.\n\nAdditionally, these blocks were disallowed by the spec up until spec version 0.3.2 when the restriction was lifted by [PR#1689](https://github.com/facebook/zstd/pull/1689).\n\n> A Compressed_Block has the extra restriction that Block_Size is always strictly less than the decompressed size. If this condition cannot be respected, the block must be sent uncompressed instead (Raw_Block).\n\n\nFirst block is RLE block\n------------------------\n\n**Last affected version**: v1.4.3\n\n**Affected decompressor component(s)**: CLI only\n\n**Produced by the reference compressor**: No\n\n**Example Frame**: `28b5 2ffd a001 0002 0002 0010 000b 0000 00`\n\nThe zstd CLI decompressor rejected cases where the first block was an RLE block whose `Block_Size` is 131072, and the frame contains more than one block.\nThis only affected the zstd CLI, and not the library.\n\nThe example is an RLE block with 131072 bytes, followed by a second RLE block with 1 byte.\n\nThe compressor currently works around this limitation by explicitly avoiding producing RLE blocks as the first\nblock.\n\nhttps://github.com/facebook/zstd/blob/8814aa5bfa74f05a86e55e9d508da177a893ceeb/lib/compress/zstd_compress.c#L3527-L3535\n\n\nTiny FSE Table & Block\n----------------------\n\n**Last affected version**: v1.3.4\n\n**Affected decompressor component(s)**: Library & CLI\n\n**Produced by the reference compressor**: Possibly until version v1.3.4, but probably never\n\n**Example Frame**: `28b5 2ffd 2027 c500 0080 f3f1 f0ec ebc6 c5c7 f09d 4300 0000 e0e0 0658 0100 603e 52`\n\nThe zstd library rejected blocks of type `Compressed_Block` whose offset of the last table with type `FSE_Compressed_Mode` was less than 4 bytes from the end of the block.\n\nIn more depth, let `Last_Table_Offset` be the offset in the compressed block (excluding the header) that\nthe last table with type `FSE_Compressed_Mode` started. If `Block_Content - Last_Table_Offset < 4` then\nthe buggy zstd decompressor would reject the block. This occurs when the last serialized table is 2 bytes\nand the bitstream size is 1 byte.\n\nFor example:\n* There is 1 sequence in the block\n* `Literals_Lengths_Mode` is `FSE_Compressed_Mode` & the serialized table size is 2 bytes\n* `Offsets_Mode` is `Predefined_Mode`\n* `Match_Lengths_Mode` is `Predefined_Mode`\n* The bitstream is 1 byte. E.g. there is only one sequence and it fits in 1 byte.\n\nThe total `Block_Content` is `5` bytes, and `Last_Table_Offset` is `2`.\n\nSee the compressor workaround code:\n\nhttps://github.com/facebook/zstd/blob/8814aa5bfa74f05a86e55e9d508da177a893ceeb/lib/compress/zstd_compress.c#L2667-L2682\n\nMagicless format\n----------------------\n\n**Last affected version**: v1.5.5\n\n**Affected decompressor component(s)**: Library\n\n**Produced by the reference compressor**: Yes (example: https://gist.github.com/embg/9940726094f4cf2cef162cffe9319232)\n\n**Example Frame**: `27 b5 2f fd 00 03 19 00 00 66 6f 6f 3f ba c4 59`\n\nv1.5.6 fixes several bugs in which the magicless-format decoder rejects valid frames.\nThese include but are not limited to:\n* Valid frames that happen to begin with a legacy magic number (little-endian)\n* Valid frames that happen to begin with a skippable magic number (little-endian)\n\nIf you are affected by this issue and cannot update to v1.5.6 or later, there is a\nworkaround to recover affected data. Simply prepend the ZSTD magic number\n`0xFD2FB528` (little-endian) to your data and decompress using the standard-format\ndecoder.\n" }, { "path": "doc/decompressor_permissive.md", "content": "Decompressor Permissiveness to Invalid Data\n===========================================\n\nThis document describes the behavior of the reference decompressor in cases\nwhere it accepts formally invalid data instead of reporting an error.\n\nWhile the reference decompressor *must* decode any compliant frame following\nthe specification, its ability to detect erroneous data is on a best effort\nbasis: the decoder may accept input data that would be formally invalid,\nwhen it causes no risk to the decoder, and which detection would cost too much\ncomplexity or speed regression.\n\nIn practice, the vast majority of invalid data are detected, if only because\nmany corruption events are dangerous for the decoder process (such as\nrequesting an out-of-bound memory access) and many more are easy to check.\n\nThis document lists a few known cases where invalid data was formerly accepted\nby the decoder, and what has changed since.\n\n\nTruncated Huffman states\n------------------------\n\n**Last affected version**: v1.5.6\n\n**Produced by the reference compressor**: No\n\n**Example Frame**: `28b5 2ffd 0000 5500 0072 8001 0420 7e1f 02aa 00`\n\nWhen using FSE-compressed Huffman weights, the compressed weight bitstream\ncould contain fewer bits than necessary to decode the initial states.\n\nThe reference decompressor up to v1.5.6 will decode truncated or missing\ninitial states as zero, which can result in a valid Huffman tree if only\nthe second state is truncated.\n\nIn newer versions, truncated initial states are reported as a corruption\nerror by the decoder.\n\n\nOffset == 0\n-----------\n\n**Last affected version**: v1.5.5\n\n**Produced by the reference compressor**: No\n\n**Example Frame**: `28b5 2ffd 0000 4500 0008 0002 002f 430b ae`\n\nIf a sequence is decoded with `literals_length = 0` and `offset_value = 3`\nwhile `Repeated_Offset_1 = 1`, the computed offset will be `0`, which is\ninvalid.\n\nThe reference decompressor up to v1.5.5 processes this case as if the computed\noffset was `1`, including inserting `1` into the repeated offset list.\nThis prevents the output buffer from remaining uninitialized, thus denying a\npotential attack vector from an untrusted source.\nHowever, in the rare case where this scenario would be the outcome of a\ntransmission or storage error, the decoder relies on the checksum to detect\nthe error.\n\nIn newer versions, this case is always detected and reported as a corruption error.\n\n\nNon-zeroes reserved bits\n------------------------\n\n**Last affected version**: v1.5.5\n\n**Produced by the reference compressor**: No\n\nThe Sequences section of each block has a header, and one of its elements is a\nbyte, which describes the compression mode of each symbol.\nThis byte contains 2 reserved bits which must be set to zero.\n\nThe reference decompressor up to v1.5.5 just ignores these 2 bits.\nThis behavior has no consequence for the rest of the frame decoding process.\n\nIn newer versions, the 2 reserved bits are actively checked for value zero,\nand the decoder reports a corruption error if they are not.\n" }, { "path": "doc/educational_decoder/.gitignore", "content": "# Build artifacts\nharness\n" }, { "path": "doc/educational_decoder/Makefile", "content": "# ################################################################\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n# All rights reserved.\n#\n# This source code is licensed under both the BSD-style license (found in the\n# LICENSE file in the root directory of this source tree) and the GPLv2 (found\n# in the COPYING file in the root directory of this source tree).\n# You may select, at your option, one of the above-listed licenses.\n# ################################################################\n\nZSTD ?= zstd # note: requires zstd installation on local system\n\nUNAME?= $(shell sh -c 'MSYSTEM=\"MSYS\" uname') \nifeq ($(UNAME), SunOS)\nDIFF ?= gdiff\nelse\nDIFF ?= diff\nendif\n\nHARNESS_FILES=*.c\n\nMULTITHREAD_LDFLAGS = -pthread\nDEBUGFLAGS= -g -DZSTD_DEBUG=1\nCPPFLAGS += -I$(ZSTDDIR) -I$(ZSTDDIR)/common -I$(ZSTDDIR)/compress \\\n -I$(ZSTDDIR)/dictBuilder -I$(ZSTDDIR)/deprecated -I$(PRGDIR)\nCFLAGS ?= -O2\nCFLAGS += -Wall -Wextra -Wcast-qual -Wcast-align -Wshadow \\\n -Wstrict-aliasing=1 -Wswitch-enum \\\n -Wredundant-decls -Wstrict-prototypes -Wundef \\\n -Wvla -Wformat=2 -Winit-self -Wfloat-equal -Wwrite-strings \\\n -std=c99\nCFLAGS += $(DEBUGFLAGS)\nCFLAGS += $(MOREFLAGS)\nFLAGS = $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) $(MULTITHREAD_LDFLAGS)\n\nharness: $(HARNESS_FILES)\n\t$(CC) $(FLAGS) $^ -o $@\n\nclean:\n\t@$(RM) harness *.o\n\t@$(RM) -rf harness.dSYM # MacOS specific\n\ntest: harness\n\t#\n\t# Testing single-file decompression with educational decoder\n\t#\n\t@$(ZSTD) -f README.md -o tmp.zst\n\t@./harness tmp.zst tmp\n\t@$(DIFF) -s tmp README.md\n\t@$(RM) tmp*\n\t#\n\t# Testing dictionary decompression with education decoder\n\t#\n\t# note : files are presented multiple for training, to reach minimum threshold\n\t@$(ZSTD) --train harness.c zstd_decompress.c zstd_decompress.h README.md \\\n harness.c zstd_decompress.c zstd_decompress.h README.md \\\n harness.c zstd_decompress.c zstd_decompress.h README.md \\\n -o dictionary\n\t@$(ZSTD) -f README.md -D dictionary -o tmp.zst\n\t@./harness tmp.zst tmp dictionary\n\t@$(DIFF) -s tmp README.md\n\t@$(RM) tmp* dictionary\n" }, { "path": "doc/educational_decoder/README.md", "content": "Educational Decoder\n===================\n\n`zstd_decompress.c` is a self-contained implementation in C99 of a decoder,\naccording to the [Zstandard format specification].\nWhile it does not implement as many features as the reference decoder,\nsuch as the streaming API or content checksums, it is written to be easy to\nfollow and understand, to help understand how the Zstandard format works.\nIt's laid out to match the [format specification],\nso it can be used to understand how complex segments could be implemented.\nIt also contains implementations of Huffman and FSE table decoding.\n\n[Zstandard format specification]: https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md\n[format specification]: https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md\n\nWhile the library's primary objective is code clarity,\nit also happens to compile into a small object file.\nThe object file can be made even smaller by removing error messages,\nusing the macro directive `ZDEC_NO_MESSAGE` at compilation time.\nThis can be reduced even further by foregoing dictionary support,\nby defining `ZDEC_NO_DICTIONARY`.\n\n`harness.c` provides a simple test harness around the decoder:\n\n harness [dictionary]\n\nAs an additional resource to be used with this decoder,\nsee the `decodecorpus` tool in the [tests] directory.\nIt generates valid Zstandard frames that can be used to verify\na Zstandard decoder implementation.\nNote that to use the tool to verify this decoder implementation,\nthe --content-size flag should be set,\nas this decoder does not handle streaming decoding,\nand so it must know the decompressed size in advance.\n\n[tests]: https://github.com/facebook/zstd/blob/dev/tests/\n" }, { "path": "doc/educational_decoder/harness.c", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#include \n#include \n\n#include \"zstd_decompress.h\"\n\ntypedef unsigned char u8;\n\n// If the data doesn't have decompressed size with it, fallback on assuming the\n// compression ratio is at most 16\n#define MAX_COMPRESSION_RATIO (16)\n\n// Protect against allocating too much memory for output\n#define MAX_OUTPUT_SIZE ((size_t)1024 * 1024 * 1024)\n\n// Error message then exit\n#define ERR_OUT(...) { fprintf(stderr, __VA_ARGS__); exit(1); }\n\n\ntypedef struct {\n u8* address;\n size_t size;\n} buffer_s;\n\nstatic void freeBuffer(buffer_s b) { free(b.address); }\n\nstatic buffer_s read_file(const char *path)\n{\n FILE* const f = fopen(path, \"rb\");\n if (!f) ERR_OUT(\"failed to open file %s \\n\", path);\n\n fseek(f, 0L, SEEK_END);\n size_t const size = (size_t)ftell(f);\n rewind(f);\n\n void* const ptr = malloc(size);\n if (!ptr) ERR_OUT(\"failed to allocate memory to hold %s \\n\", path);\n\n size_t const read = fread(ptr, 1, size, f);\n if (read != size) ERR_OUT(\"error while reading file %s \\n\", path);\n\n fclose(f);\n buffer_s const b = { ptr, size };\n return b;\n}\n\nstatic void write_file(const char* path, const u8* ptr, size_t size)\n{\n FILE* const f = fopen(path, \"wb\");\n if (!f) ERR_OUT(\"failed to open file %s \\n\", path);\n\n size_t written = 0;\n while (written < size) {\n written += fwrite(ptr+written, 1, size, f);\n if (ferror(f)) ERR_OUT(\"error while writing file %s\\n\", path);\n }\n\n fclose(f);\n}\n\nint main(int argc, char **argv)\n{\n if (argc < 3)\n ERR_OUT(\"usage: %s [dictionary] \\n\", argv[0]);\n\n buffer_s const input = read_file(argv[1]);\n\n buffer_s dict = { NULL, 0 };\n if (argc >= 4) {\n dict = read_file(argv[3]);\n }\n\n size_t out_capacity = ZSTD_get_decompressed_size(input.address, input.size);\n if (out_capacity == (size_t)-1) {\n out_capacity = MAX_COMPRESSION_RATIO * input.size;\n fprintf(stderr, \"WARNING: Compressed data does not contain \"\n \"decompressed size, going to assume the compression \"\n \"ratio is at most %d (decompressed size of at most \"\n \"%u) \\n\",\n MAX_COMPRESSION_RATIO, (unsigned)out_capacity);\n }\n if (out_capacity > MAX_OUTPUT_SIZE)\n ERR_OUT(\"Required output size too large for this implementation \\n\");\n\n u8* const output = malloc(out_capacity);\n if (!output) ERR_OUT(\"failed to allocate memory \\n\");\n\n dictionary_t* const parsed_dict = create_dictionary();\n if (dict.size) {\n#if defined (ZDEC_NO_DICTIONARY)\n printf(\"dict.size = %zu \\n\", dict.size);\n ERR_OUT(\"no dictionary support \\n\");\n#else\n parse_dictionary(parsed_dict, dict.address, dict.size);\n#endif\n }\n size_t const decompressed_size =\n ZSTD_decompress_with_dict(output, out_capacity,\n input.address, input.size,\n parsed_dict);\n\n free_dictionary(parsed_dict);\n\n write_file(argv[2], output, decompressed_size);\n\n freeBuffer(input);\n freeBuffer(dict);\n free(output);\n return 0;\n}\n" }, { "path": "doc/educational_decoder/zstd_decompress.c", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/// Zstandard educational decoder implementation\n/// See https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md\n\n#include // uint8_t, etc.\n#include // malloc, free, exit\n#include // fprintf\n#include // memset, memcpy\n#include \"zstd_decompress.h\"\n\n\n/******* IMPORTANT CONSTANTS *********************************************/\n\n// Zstandard frame\n// \"Magic_Number\n// 4 Bytes, little-endian format. Value : 0xFD2FB528\"\n#define ZSTD_MAGIC_NUMBER 0xFD2FB528U\n\n// The size of `Block_Content` is limited by `Block_Maximum_Size`,\n#define ZSTD_BLOCK_SIZE_MAX ((size_t)128 * 1024)\n\n// literal blocks can't be larger than their block\n#define MAX_LITERALS_SIZE ZSTD_BLOCK_SIZE_MAX\n\n\n/******* UTILITY MACROS AND TYPES *********************************************/\n#define MAX(a, b) ((a) > (b) ? (a) : (b))\n#define MIN(a, b) ((a) < (b) ? (a) : (b))\n\n#if defined(ZDEC_NO_MESSAGE)\n#define MESSAGE(...)\n#else\n#define MESSAGE(...) fprintf(stderr, \"\" __VA_ARGS__)\n#endif\n\n/// This decoder calls exit(1) when it encounters an error, however a production\n/// library should propagate error codes\n#define ERROR(s) \\\n do { \\\n MESSAGE(\"Error: %s\\n\", s); \\\n exit(1); \\\n } while (0)\n#define INP_SIZE() \\\n ERROR(\"Input buffer smaller than it should be or input is \" \\\n \"corrupted\")\n#define OUT_SIZE() ERROR(\"Output buffer too small for output\")\n#define CORRUPTION() ERROR(\"Corruption detected while decompressing\")\n#define BAD_ALLOC() ERROR(\"Memory allocation error\")\n#define IMPOSSIBLE() ERROR(\"An impossibility has occurred\")\n\ntypedef uint8_t u8;\ntypedef uint16_t u16;\ntypedef uint32_t u32;\ntypedef uint64_t u64;\n\ntypedef int8_t i8;\ntypedef int16_t i16;\ntypedef int32_t i32;\ntypedef int64_t i64;\n/******* END UTILITY MACROS AND TYPES *****************************************/\n\n/******* IMPLEMENTATION PRIMITIVE PROTOTYPES **********************************/\n/// The implementations for these functions can be found at the bottom of this\n/// file. They implement low-level functionality needed for the higher level\n/// decompression functions.\n\n/*** IO STREAM OPERATIONS *************/\n\n/// ostream_t/istream_t are used to wrap the pointers/length data passed into\n/// ZSTD_decompress, so that all IO operations are safely bounds checked\n/// They are written/read forward, and reads are treated as little-endian\n/// They should be used opaquely to ensure safety\ntypedef struct {\n u8 *ptr;\n size_t len;\n} ostream_t;\n\ntypedef struct {\n const u8 *ptr;\n size_t len;\n\n // Input often reads a few bits at a time, so maintain an internal offset\n int bit_offset;\n} istream_t;\n\n/// The following two functions are the only ones that allow the istream to be\n/// non-byte aligned\n\n/// Reads `num` bits from a bitstream, and updates the internal offset\nstatic inline u64 IO_read_bits(istream_t *const in, const int num_bits);\n/// Backs-up the stream by `num` bits so they can be read again\nstatic inline void IO_rewind_bits(istream_t *const in, const int num_bits);\n/// If the remaining bits in a byte will be unused, advance to the end of the\n/// byte\nstatic inline void IO_align_stream(istream_t *const in);\n\n/// Write the given byte into the output stream\nstatic inline void IO_write_byte(ostream_t *const out, u8 symb);\n\n/// Returns the number of bytes left to be read in this stream. The stream must\n/// be byte aligned.\nstatic inline size_t IO_istream_len(const istream_t *const in);\n\n/// Advances the stream by `len` bytes, and returns a pointer to the chunk that\n/// was skipped. The stream must be byte aligned.\nstatic inline const u8 *IO_get_read_ptr(istream_t *const in, size_t len);\n/// Advances the stream by `len` bytes, and returns a pointer to the chunk that\n/// was skipped so it can be written to.\nstatic inline u8 *IO_get_write_ptr(ostream_t *const out, size_t len);\n\n/// Advance the inner state by `len` bytes. The stream must be byte aligned.\nstatic inline void IO_advance_input(istream_t *const in, size_t len);\n\n/// Returns an `ostream_t` constructed from the given pointer and length.\nstatic inline ostream_t IO_make_ostream(u8 *out, size_t len);\n/// Returns an `istream_t` constructed from the given pointer and length.\nstatic inline istream_t IO_make_istream(const u8 *in, size_t len);\n\n/// Returns an `istream_t` with the same base as `in`, and length `len`.\n/// Then, advance `in` to account for the consumed bytes.\n/// `in` must be byte aligned.\nstatic inline istream_t IO_make_sub_istream(istream_t *const in, size_t len);\n/*** END IO STREAM OPERATIONS *********/\n\n/*** BITSTREAM OPERATIONS *************/\n/// Read `num` bits (up to 64) from `src + offset`, where `offset` is in bits,\n/// and return them interpreted as a little-endian unsigned integer.\nstatic inline u64 read_bits_LE(const u8 *src, const int num_bits,\n const size_t offset);\n\n/// Read bits from the end of a HUF or FSE bitstream. `offset` is in bits, so\n/// it updates `offset` to `offset - bits`, and then reads `bits` bits from\n/// `src + offset`. If the offset becomes negative, the extra bits at the\n/// bottom are filled in with `0` bits instead of reading from before `src`.\nstatic inline u64 STREAM_read_bits(const u8 *src, const int bits,\n i64 *const offset);\n/*** END BITSTREAM OPERATIONS *********/\n\n/*** BIT COUNTING OPERATIONS **********/\n/// Returns the index of the highest set bit in `num`, or `-1` if `num == 0`\nstatic inline int highest_set_bit(const u64 num);\n/*** END BIT COUNTING OPERATIONS ******/\n\n/*** HUFFMAN PRIMITIVES ***************/\n// Table decode method uses exponential memory, so we need to limit depth\n#define HUF_MAX_BITS (16)\n\n// Limit the maximum number of symbols to 256 so we can store a symbol in a byte\n#define HUF_MAX_SYMBS (256)\n\n/// Structure containing all tables necessary for efficient Huffman decoding\ntypedef struct {\n u8 *symbols;\n u8 *num_bits;\n int max_bits;\n} HUF_dtable;\n\n/// Decode a single symbol and read in enough bits to refresh the state\nstatic inline u8 HUF_decode_symbol(const HUF_dtable *const dtable,\n u16 *const state, const u8 *const src,\n i64 *const offset);\n/// Read in a full state's worth of bits to initialize it\nstatic inline void HUF_init_state(const HUF_dtable *const dtable,\n u16 *const state, const u8 *const src,\n i64 *const offset);\n\n/// Decompresses a single Huffman stream, returns the number of bytes decoded.\n/// `src_len` must be the exact length of the Huffman-coded block.\nstatic size_t HUF_decompress_1stream(const HUF_dtable *const dtable,\n ostream_t *const out, istream_t *const in);\n/// Same as previous but decodes 4 streams, formatted as in the Zstandard\n/// specification.\n/// `src_len` must be the exact length of the Huffman-coded block.\nstatic size_t HUF_decompress_4stream(const HUF_dtable *const dtable,\n ostream_t *const out, istream_t *const in);\n\n/// Initialize a Huffman decoding table using the table of bit counts provided\nstatic void HUF_init_dtable(HUF_dtable *const table, const u8 *const bits,\n const int num_symbs);\n/// Initialize a Huffman decoding table using the table of weights provided\n/// Weights follow the definition provided in the Zstandard specification\nstatic void HUF_init_dtable_usingweights(HUF_dtable *const table,\n const u8 *const weights,\n const int num_symbs);\n\n/// Free the malloc'ed parts of a decoding table\nstatic void HUF_free_dtable(HUF_dtable *const dtable);\n/*** END HUFFMAN PRIMITIVES ***********/\n\n/*** FSE PRIMITIVES *******************/\n/// For more description of FSE see\n/// https://github.com/Cyan4973/FiniteStateEntropy/\n\n// FSE table decoding uses exponential memory, so limit the maximum accuracy\n#define FSE_MAX_ACCURACY_LOG (15)\n// Limit the maximum number of symbols so they can be stored in a single byte\n#define FSE_MAX_SYMBS (256)\n\n/// The tables needed to decode FSE encoded streams\ntypedef struct {\n u8 *symbols;\n u8 *num_bits;\n u16 *new_state_base;\n int accuracy_log;\n} FSE_dtable;\n\n/// Return the symbol for the current state\nstatic inline u8 FSE_peek_symbol(const FSE_dtable *const dtable,\n const u16 state);\n/// Read the number of bits necessary to update state, update, and shift offset\n/// back to reflect the bits read\nstatic inline void FSE_update_state(const FSE_dtable *const dtable,\n u16 *const state, const u8 *const src,\n i64 *const offset);\n\n/// Combine peek and update: decode a symbol and update the state\nstatic inline u8 FSE_decode_symbol(const FSE_dtable *const dtable,\n u16 *const state, const u8 *const src,\n i64 *const offset);\n\n/// Read bits from the stream to initialize the state and shift offset back\nstatic inline void FSE_init_state(const FSE_dtable *const dtable,\n u16 *const state, const u8 *const src,\n i64 *const offset);\n\n/// Decompress two interleaved bitstreams (e.g. compressed Huffman weights)\n/// using an FSE decoding table. `src_len` must be the exact length of the\n/// block.\nstatic size_t FSE_decompress_interleaved2(const FSE_dtable *const dtable,\n ostream_t *const out,\n istream_t *const in);\n\n/// Initialize a decoding table using normalized frequencies.\nstatic void FSE_init_dtable(FSE_dtable *const dtable,\n const i16 *const norm_freqs, const int num_symbs,\n const int accuracy_log);\n\n/// Decode an FSE header as defined in the Zstandard format specification and\n/// use the decoded frequencies to initialize a decoding table.\nstatic void FSE_decode_header(FSE_dtable *const dtable, istream_t *const in,\n const int max_accuracy_log);\n\n/// Initialize an FSE table that will always return the same symbol and consume\n/// 0 bits per symbol, to be used for RLE mode in sequence commands\nstatic void FSE_init_dtable_rle(FSE_dtable *const dtable, const u8 symb);\n\n/// Free the malloc'ed parts of a decoding table\nstatic void FSE_free_dtable(FSE_dtable *const dtable);\n/*** END FSE PRIMITIVES ***************/\n\n/******* END IMPLEMENTATION PRIMITIVE PROTOTYPES ******************************/\n\n/******* ZSTD HELPER STRUCTS AND PROTOTYPES ***********************************/\n\n/// A small structure that can be reused in various places that need to access\n/// frame header information\ntypedef struct {\n // The size of window that we need to be able to contiguously store for\n // references\n size_t window_size;\n // The total output size of this compressed frame\n size_t frame_content_size;\n\n // The dictionary id if this frame uses one\n u32 dictionary_id;\n\n // Whether or not the content of this frame has a checksum\n int content_checksum_flag;\n // Whether or not the output for this frame is in a single segment\n int single_segment_flag;\n} frame_header_t;\n\n/// The context needed to decode blocks in a frame\ntypedef struct {\n frame_header_t header;\n\n // The total amount of data available for backreferences, to determine if an\n // offset too large to be correct\n size_t current_total_output;\n\n const u8 *dict_content;\n size_t dict_content_len;\n\n // Entropy encoding tables so they can be repeated by future blocks instead\n // of retransmitting\n HUF_dtable literals_dtable;\n FSE_dtable ll_dtable;\n FSE_dtable ml_dtable;\n FSE_dtable of_dtable;\n\n // The last 3 offsets for the special \"repeat offsets\".\n u64 previous_offsets[3];\n} frame_context_t;\n\n/// The decoded contents of a dictionary so that it doesn't have to be repeated\n/// for each frame that uses it\nstruct dictionary_s {\n // Entropy tables\n HUF_dtable literals_dtable;\n FSE_dtable ll_dtable;\n FSE_dtable ml_dtable;\n FSE_dtable of_dtable;\n\n // Raw content for backreferences\n u8 *content;\n size_t content_size;\n\n // Offset history to prepopulate the frame's history\n u64 previous_offsets[3];\n\n u32 dictionary_id;\n};\n\n/// A tuple containing the parts necessary to decode and execute a ZSTD sequence\n/// command\ntypedef struct {\n u32 literal_length;\n u32 match_length;\n u32 offset;\n} sequence_command_t;\n\n/// The decoder works top-down, starting at the high level like Zstd frames, and\n/// working down to lower more technical levels such as blocks, literals, and\n/// sequences. The high-level functions roughly follow the outline of the\n/// format specification:\n/// https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md\n\n/// Before the implementation of each high-level function declared here, the\n/// prototypes for their helper functions are defined and explained\n\n/// Decode a single Zstd frame, or error if the input is not a valid frame.\n/// Accepts a dict argument, which may be NULL indicating no dictionary.\n/// See\n/// https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#frame-concatenation\nstatic void decode_frame(ostream_t *const out, istream_t *const in,\n const dictionary_t *const dict);\n\n// Decode data in a compressed block\nstatic void decompress_block(frame_context_t *const ctx, ostream_t *const out,\n istream_t *const in);\n\n// Decode the literals section of a block\nstatic size_t decode_literals(frame_context_t *const ctx, istream_t *const in,\n u8 **const literals);\n\n// Decode the sequences part of a block\nstatic size_t decode_sequences(frame_context_t *const ctx, istream_t *const in,\n sequence_command_t **const sequences);\n\n// Execute the decoded sequences on the literals block\nstatic void execute_sequences(frame_context_t *const ctx, ostream_t *const out,\n const u8 *const literals,\n const size_t literals_len,\n const sequence_command_t *const sequences,\n const size_t num_sequences);\n\n// Copies literals and returns the total literal length that was copied\nstatic u32 copy_literals(const size_t seq, istream_t *litstream,\n ostream_t *const out);\n\n// Given an offset code from a sequence command (either an actual offset value\n// or an index for previous offset), computes the correct offset and updates\n// the offset history\nstatic size_t compute_offset(sequence_command_t seq, u64 *const offset_hist);\n\n// Given an offset, match length, and total output, as well as the frame\n// context for the dictionary, determines if the dictionary is used and\n// executes the copy operation\nstatic void execute_match_copy(frame_context_t *const ctx, size_t offset,\n size_t match_length, size_t total_output,\n ostream_t *const out);\n\n/******* END ZSTD HELPER STRUCTS AND PROTOTYPES *******************************/\n\nsize_t ZSTD_decompress(void *const dst, const size_t dst_len,\n const void *const src, const size_t src_len) {\n dictionary_t* const uninit_dict = create_dictionary();\n size_t const decomp_size = ZSTD_decompress_with_dict(dst, dst_len, src,\n src_len, uninit_dict);\n free_dictionary(uninit_dict);\n return decomp_size;\n}\n\nsize_t ZSTD_decompress_with_dict(void *const dst, const size_t dst_len,\n const void *const src, const size_t src_len,\n dictionary_t* parsed_dict) {\n\n istream_t in = IO_make_istream(src, src_len);\n ostream_t out = IO_make_ostream(dst, dst_len);\n\n // \"A content compressed by Zstandard is transformed into a Zstandard frame.\n // Multiple frames can be appended into a single file or stream. A frame is\n // totally independent, has a defined beginning and end, and a set of\n // parameters which tells the decoder how to decompress it.\"\n\n /* this decoder assumes decompression of a single frame */\n decode_frame(&out, &in, parsed_dict);\n\n return (size_t)(out.ptr - (u8 *)dst);\n}\n\n/******* FRAME DECODING ******************************************************/\n\nstatic void decode_data_frame(ostream_t *const out, istream_t *const in,\n const dictionary_t *const dict);\nstatic void init_frame_context(frame_context_t *const context,\n istream_t *const in,\n const dictionary_t *const dict);\nstatic void free_frame_context(frame_context_t *const context);\nstatic void parse_frame_header(frame_header_t *const header,\n istream_t *const in);\nstatic void frame_context_apply_dict(frame_context_t *const ctx,\n const dictionary_t *const dict);\n\nstatic void decompress_data(frame_context_t *const ctx, ostream_t *const out,\n istream_t *const in);\n\nstatic void decode_frame(ostream_t *const out, istream_t *const in,\n const dictionary_t *const dict) {\n const u32 magic_number = (u32)IO_read_bits(in, 32);\n if (magic_number == ZSTD_MAGIC_NUMBER) {\n // ZSTD frame\n decode_data_frame(out, in, dict);\n\n return;\n }\n\n // not a real frame or a skippable frame\n ERROR(\"Tried to decode non-ZSTD frame\");\n}\n\n/// Decode a frame that contains compressed data. Not all frames do as there\n/// are skippable frames.\n/// See\n/// https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#general-structure-of-zstandard-frame-format\nstatic void decode_data_frame(ostream_t *const out, istream_t *const in,\n const dictionary_t *const dict) {\n frame_context_t ctx;\n\n // Initialize the context that needs to be carried from block to block\n init_frame_context(&ctx, in, dict);\n\n if (ctx.header.frame_content_size != 0 &&\n ctx.header.frame_content_size > out->len) {\n OUT_SIZE();\n }\n\n decompress_data(&ctx, out, in);\n\n free_frame_context(&ctx);\n}\n\n/// Takes the information provided in the header and dictionary, and initializes\n/// the context for this frame\nstatic void init_frame_context(frame_context_t *const context,\n istream_t *const in,\n const dictionary_t *const dict) {\n // Most fields in context are correct when initialized to 0\n memset(context, 0, sizeof(frame_context_t));\n\n // Parse data from the frame header\n parse_frame_header(&context->header, in);\n\n // Set up the offset history for the repeat offset commands\n context->previous_offsets[0] = 1;\n context->previous_offsets[1] = 4;\n context->previous_offsets[2] = 8;\n\n // Apply details from the dict if it exists\n frame_context_apply_dict(context, dict);\n}\n\nstatic void free_frame_context(frame_context_t *const context) {\n HUF_free_dtable(&context->literals_dtable);\n\n FSE_free_dtable(&context->ll_dtable);\n FSE_free_dtable(&context->ml_dtable);\n FSE_free_dtable(&context->of_dtable);\n\n memset(context, 0, sizeof(frame_context_t));\n}\n\nstatic void parse_frame_header(frame_header_t *const header,\n istream_t *const in) {\n // \"The first header's byte is called the Frame_Header_Descriptor. It tells\n // which other fields are present. Decoding this byte is enough to tell the\n // size of Frame_Header.\n //\n // Bit number Field name\n // 7-6 Frame_Content_Size_flag\n // 5 Single_Segment_flag\n // 4 Unused_bit\n // 3 Reserved_bit\n // 2 Content_Checksum_flag\n // 1-0 Dictionary_ID_flag\"\n const u8 descriptor = (u8)IO_read_bits(in, 8);\n\n // decode frame header descriptor into flags\n const u8 frame_content_size_flag = descriptor >> 6;\n const u8 single_segment_flag = (descriptor >> 5) & 1;\n const u8 reserved_bit = (descriptor >> 3) & 1;\n const u8 content_checksum_flag = (descriptor >> 2) & 1;\n const u8 dictionary_id_flag = descriptor & 3;\n\n if (reserved_bit != 0) {\n CORRUPTION();\n }\n\n header->single_segment_flag = single_segment_flag;\n header->content_checksum_flag = content_checksum_flag;\n\n // decode window size\n if (!single_segment_flag) {\n // \"Provides guarantees on maximum back-reference distance that will be\n // used within compressed data. This information is important for\n // decoders to allocate enough memory.\n //\n // Bit numbers 7-3 2-0\n // Field name Exponent Mantissa\"\n u8 window_descriptor = (u8)IO_read_bits(in, 8);\n u8 exponent = window_descriptor >> 3;\n u8 mantissa = window_descriptor & 7;\n\n // Use the algorithm from the specification to compute window size\n // https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#window_descriptor\n size_t window_base = (size_t)1 << (10 + exponent);\n size_t window_add = (window_base / 8) * mantissa;\n header->window_size = window_base + window_add;\n }\n\n // decode dictionary id if it exists\n if (dictionary_id_flag) {\n // \"This is a variable size field, which contains the ID of the\n // dictionary required to properly decode the frame. Note that this\n // field is optional. When it's not present, it's up to the caller to\n // make sure it uses the correct dictionary. Format is little-endian.\"\n const int bytes_array[] = {0, 1, 2, 4};\n const int bytes = bytes_array[dictionary_id_flag];\n\n header->dictionary_id = (u32)IO_read_bits(in, bytes * 8);\n } else {\n header->dictionary_id = 0;\n }\n\n // decode frame content size if it exists\n if (single_segment_flag || frame_content_size_flag) {\n // \"This is the original (uncompressed) size. This information is\n // optional. The Field_Size is provided according to value of\n // Frame_Content_Size_flag. The Field_Size can be equal to 0 (not\n // present), 1, 2, 4 or 8 bytes. Format is little-endian.\"\n //\n // if frame_content_size_flag == 0 but single_segment_flag is set, we\n // still have a 1 byte field\n const int bytes_array[] = {1, 2, 4, 8};\n const int bytes = bytes_array[frame_content_size_flag];\n\n header->frame_content_size = IO_read_bits(in, bytes * 8);\n if (bytes == 2) {\n // \"When Field_Size is 2, the offset of 256 is added.\"\n header->frame_content_size += 256;\n }\n } else {\n header->frame_content_size = 0;\n }\n\n if (single_segment_flag) {\n // \"The Window_Descriptor byte is optional. It is absent when\n // Single_Segment_flag is set. In this case, the maximum back-reference\n // distance is the content size itself, which can be any value from 1 to\n // 2^64-1 bytes (16 EB).\"\n header->window_size = header->frame_content_size;\n }\n}\n\n/// Decompress the data from a frame block by block\nstatic void decompress_data(frame_context_t *const ctx, ostream_t *const out,\n istream_t *const in) {\n // \"A frame encapsulates one or multiple blocks. Each block can be\n // compressed or not, and has a guaranteed maximum content size, which\n // depends on frame parameters. Unlike frames, each block depends on\n // previous blocks for proper decoding. However, each block can be\n // decompressed without waiting for its successor, allowing streaming\n // operations.\"\n int last_block = 0;\n do {\n // \"Last_Block\n //\n // The lowest bit signals if this block is the last one. Frame ends\n // right after this block.\n //\n // Block_Type and Block_Size\n //\n // The next 2 bits represent the Block_Type, while the remaining 21 bits\n // represent the Block_Size. Format is little-endian.\"\n last_block = (int)IO_read_bits(in, 1);\n const int block_type = (int)IO_read_bits(in, 2);\n const size_t block_len = IO_read_bits(in, 21);\n\n switch (block_type) {\n case 0: {\n // \"Raw_Block - this is an uncompressed block. Block_Size is the\n // number of bytes to read and copy.\"\n const u8 *const read_ptr = IO_get_read_ptr(in, block_len);\n u8 *const write_ptr = IO_get_write_ptr(out, block_len);\n\n // Copy the raw data into the output\n memcpy(write_ptr, read_ptr, block_len);\n\n ctx->current_total_output += block_len;\n break;\n }\n case 1: {\n // \"RLE_Block - this is a single byte, repeated N times. In which\n // case, Block_Size is the size to regenerate, while the\n // \"compressed\" block is just 1 byte (the byte to repeat).\"\n const u8 *const read_ptr = IO_get_read_ptr(in, 1);\n u8 *const write_ptr = IO_get_write_ptr(out, block_len);\n\n // Copy `block_len` copies of `read_ptr[0]` to the output\n memset(write_ptr, read_ptr[0], block_len);\n\n ctx->current_total_output += block_len;\n break;\n }\n case 2: {\n // \"Compressed_Block - this is a Zstandard compressed block,\n // detailed in another section of this specification. Block_Size is\n // the compressed size.\n\n // Create a sub-stream for the block\n istream_t block_stream = IO_make_sub_istream(in, block_len);\n decompress_block(ctx, out, &block_stream);\n break;\n }\n case 3:\n // \"Reserved - this is not a block. This value cannot be used with\n // current version of this specification.\"\n CORRUPTION();\n break;\n default:\n IMPOSSIBLE();\n }\n } while (!last_block);\n\n if (ctx->header.content_checksum_flag) {\n // This program does not support checking the checksum, so skip over it\n // if it's present\n IO_advance_input(in, 4);\n }\n}\n/******* END FRAME DECODING ***************************************************/\n\n/******* BLOCK DECOMPRESSION **************************************************/\nstatic void decompress_block(frame_context_t *const ctx, ostream_t *const out,\n istream_t *const in) {\n // \"A compressed block consists of 2 sections :\n //\n // Literals_Section\n // Sequences_Section\"\n\n\n // Part 1: decode the literals block\n u8 *literals = NULL;\n const size_t literals_size = decode_literals(ctx, in, &literals);\n\n // Part 2: decode the sequences block\n sequence_command_t *sequences = NULL;\n const size_t num_sequences =\n decode_sequences(ctx, in, &sequences);\n\n // Part 3: combine literals and sequence commands to generate output\n execute_sequences(ctx, out, literals, literals_size, sequences,\n num_sequences);\n free(literals);\n free(sequences);\n}\n/******* END BLOCK DECOMPRESSION **********************************************/\n\n/******* LITERALS DECODING ****************************************************/\nstatic size_t decode_literals_simple(istream_t *const in, u8 **const literals,\n const int block_type,\n const int size_format);\nstatic size_t decode_literals_compressed(frame_context_t *const ctx,\n istream_t *const in,\n u8 **const literals,\n const int block_type,\n const int size_format);\nstatic void decode_huf_table(HUF_dtable *const dtable, istream_t *const in);\nstatic void fse_decode_hufweights(ostream_t *weights, istream_t *const in,\n int *const num_symbs);\n\nstatic size_t decode_literals(frame_context_t *const ctx, istream_t *const in,\n u8 **const literals) {\n // \"Literals can be stored uncompressed or compressed using Huffman prefix\n // codes. When compressed, an optional tree description can be present,\n // followed by 1 or 4 streams.\"\n //\n // \"Literals_Section_Header\n //\n // Header is in charge of describing how literals are packed. It's a\n // byte-aligned variable-size bitfield, ranging from 1 to 5 bytes, using\n // little-endian convention.\"\n //\n // \"Literals_Block_Type\n //\n // This field uses 2 lowest bits of first byte, describing 4 different block\n // types\"\n //\n // size_format takes between 1 and 2 bits\n int block_type = (int)IO_read_bits(in, 2);\n int size_format = (int)IO_read_bits(in, 2);\n\n if (block_type <= 1) {\n // Raw or RLE literals block\n return decode_literals_simple(in, literals, block_type,\n size_format);\n } else {\n // Huffman compressed literals\n return decode_literals_compressed(ctx, in, literals, block_type,\n size_format);\n }\n}\n\n/// Decodes literals blocks in raw or RLE form\nstatic size_t decode_literals_simple(istream_t *const in, u8 **const literals,\n const int block_type,\n const int size_format) {\n size_t size;\n switch (size_format) {\n // These cases are in the form ?0\n // In this case, the ? bit is actually part of the size field\n case 0:\n case 2:\n // \"Size_Format uses 1 bit. Regenerated_Size uses 5 bits (0-31).\"\n IO_rewind_bits(in, 1);\n size = IO_read_bits(in, 5);\n break;\n case 1:\n // \"Size_Format uses 2 bits. Regenerated_Size uses 12 bits (0-4095).\"\n size = IO_read_bits(in, 12);\n break;\n case 3:\n // \"Size_Format uses 2 bits. Regenerated_Size uses 20 bits (0-1048575).\"\n size = IO_read_bits(in, 20);\n break;\n default:\n // Size format is in range 0-3\n IMPOSSIBLE();\n }\n\n if (size > MAX_LITERALS_SIZE) {\n CORRUPTION();\n }\n\n *literals = malloc(size);\n if (!*literals) {\n BAD_ALLOC();\n }\n\n switch (block_type) {\n case 0: {\n // \"Raw_Literals_Block - Literals are stored uncompressed.\"\n const u8 *const read_ptr = IO_get_read_ptr(in, size);\n memcpy(*literals, read_ptr, size);\n break;\n }\n case 1: {\n // \"RLE_Literals_Block - Literals consist of a single byte value repeated N times.\"\n const u8 *const read_ptr = IO_get_read_ptr(in, 1);\n memset(*literals, read_ptr[0], size);\n break;\n }\n default:\n IMPOSSIBLE();\n }\n\n return size;\n}\n\n/// Decodes Huffman compressed literals\nstatic size_t decode_literals_compressed(frame_context_t *const ctx,\n istream_t *const in,\n u8 **const literals,\n const int block_type,\n const int size_format) {\n size_t regenerated_size, compressed_size;\n // Only size_format=0 has 1 stream, so default to 4\n int num_streams = 4;\n switch (size_format) {\n case 0:\n // \"A single stream. Both Compressed_Size and Regenerated_Size use 10\n // bits (0-1023).\"\n num_streams = 1;\n // Fall through as it has the same size format\n /* fallthrough */\n case 1:\n // \"4 streams. Both Compressed_Size and Regenerated_Size use 10 bits\n // (0-1023).\"\n regenerated_size = IO_read_bits(in, 10);\n compressed_size = IO_read_bits(in, 10);\n break;\n case 2:\n // \"4 streams. Both Compressed_Size and Regenerated_Size use 14 bits\n // (0-16383).\"\n regenerated_size = IO_read_bits(in, 14);\n compressed_size = IO_read_bits(in, 14);\n break;\n case 3:\n // \"4 streams. Both Compressed_Size and Regenerated_Size use 18 bits\n // (0-262143).\"\n regenerated_size = IO_read_bits(in, 18);\n compressed_size = IO_read_bits(in, 18);\n break;\n default:\n // Impossible\n IMPOSSIBLE();\n }\n if (regenerated_size > MAX_LITERALS_SIZE) {\n CORRUPTION();\n }\n\n *literals = malloc(regenerated_size);\n if (!*literals) {\n BAD_ALLOC();\n }\n\n ostream_t lit_stream = IO_make_ostream(*literals, regenerated_size);\n istream_t huf_stream = IO_make_sub_istream(in, compressed_size);\n\n if (block_type == 2) {\n // Decode the provided Huffman table\n // \"This section is only present when Literals_Block_Type type is\n // Compressed_Literals_Block (2).\"\n\n HUF_free_dtable(&ctx->literals_dtable);\n decode_huf_table(&ctx->literals_dtable, &huf_stream);\n } else {\n // If the previous Huffman table is being repeated, ensure it exists\n if (!ctx->literals_dtable.symbols) {\n CORRUPTION();\n }\n }\n\n size_t symbols_decoded;\n if (num_streams == 1) {\n symbols_decoded = HUF_decompress_1stream(&ctx->literals_dtable, &lit_stream, &huf_stream);\n } else {\n symbols_decoded = HUF_decompress_4stream(&ctx->literals_dtable, &lit_stream, &huf_stream);\n }\n\n if (symbols_decoded != regenerated_size) {\n CORRUPTION();\n }\n\n return regenerated_size;\n}\n\n// Decode the Huffman table description\nstatic void decode_huf_table(HUF_dtable *const dtable, istream_t *const in) {\n // \"All literal values from zero (included) to last present one (excluded)\n // are represented by Weight with values from 0 to Max_Number_of_Bits.\"\n\n // \"This is a single byte value (0-255), which describes how to decode the list of weights.\"\n const u8 header = IO_read_bits(in, 8);\n\n u8 weights[HUF_MAX_SYMBS];\n memset(weights, 0, sizeof(weights));\n\n int num_symbs;\n\n if (header >= 128) {\n // \"This is a direct representation, where each Weight is written\n // directly as a 4 bits field (0-15). The full representation occupies\n // ((Number_of_Symbols+1)/2) bytes, meaning it uses a last full byte\n // even if Number_of_Symbols is odd. Number_of_Symbols = headerByte -\n // 127\"\n num_symbs = header - 127;\n const size_t bytes = (num_symbs + 1) / 2;\n\n const u8 *const weight_src = IO_get_read_ptr(in, bytes);\n\n for (int i = 0; i < num_symbs; i++) {\n // \"They are encoded forward, 2\n // weights to a byte with the first weight taking the top four bits\n // and the second taking the bottom four (e.g. the following\n // operations could be used to read the weights: Weight[0] =\n // (Byte[0] >> 4), Weight[1] = (Byte[0] & 0xf), etc.).\"\n if (i % 2 == 0) {\n weights[i] = weight_src[i / 2] >> 4;\n } else {\n weights[i] = weight_src[i / 2] & 0xf;\n }\n }\n } else {\n // The weights are FSE encoded, decode them before we can construct the\n // table\n istream_t fse_stream = IO_make_sub_istream(in, header);\n ostream_t weight_stream = IO_make_ostream(weights, HUF_MAX_SYMBS);\n fse_decode_hufweights(&weight_stream, &fse_stream, &num_symbs);\n }\n\n // Construct the table using the decoded weights\n HUF_init_dtable_usingweights(dtable, weights, num_symbs);\n}\n\nstatic void fse_decode_hufweights(ostream_t *weights, istream_t *const in,\n int *const num_symbs) {\n const int MAX_ACCURACY_LOG = 7;\n\n FSE_dtable dtable;\n\n // \"An FSE bitstream starts by a header, describing probabilities\n // distribution. It will create a Decoding Table. For a list of Huffman\n // weights, maximum accuracy is 7 bits.\"\n FSE_decode_header(&dtable, in, MAX_ACCURACY_LOG);\n\n // Decode the weights\n *num_symbs = FSE_decompress_interleaved2(&dtable, weights, in);\n\n FSE_free_dtable(&dtable);\n}\n/******* END LITERALS DECODING ************************************************/\n\n/******* SEQUENCE DECODING ****************************************************/\n/// The combination of FSE states needed to decode sequences\ntypedef struct {\n FSE_dtable ll_table;\n FSE_dtable of_table;\n FSE_dtable ml_table;\n\n u16 ll_state;\n u16 of_state;\n u16 ml_state;\n} sequence_states_t;\n\n/// Different modes to signal to decode_seq_tables what to do\ntypedef enum {\n seq_literal_length = 0,\n seq_offset = 1,\n seq_match_length = 2,\n} seq_part_t;\n\ntypedef enum {\n seq_predefined = 0,\n seq_rle = 1,\n seq_fse = 2,\n seq_repeat = 3,\n} seq_mode_t;\n\n/// The predefined FSE distribution tables for `seq_predefined` mode\nstatic const i16 SEQ_LITERAL_LENGTH_DEFAULT_DIST[36] = {\n 4, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 2, 2,\n 2, 2, 2, 2, 2, 2, 2, 3, 2, 1, 1, 1, 1, 1, -1, -1, -1, -1};\nstatic const i16 SEQ_OFFSET_DEFAULT_DIST[29] = {\n 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1,\n 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1};\nstatic const i16 SEQ_MATCH_LENGTH_DEFAULT_DIST[53] = {\n 1, 4, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1};\n\n/// The sequence decoding baseline and number of additional bits to read/add\n/// https://github.com/facebook/zstd/blob/dev/doc/zstd_compression_format.md#the-codes-for-literals-lengths-match-lengths-and-offsets\nstatic const u32 SEQ_LITERAL_LENGTH_BASELINES[36] = {\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,\n 12, 13, 14, 15, 16, 18, 20, 22, 24, 28, 32, 40,\n 48, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536};\nstatic const u8 SEQ_LITERAL_LENGTH_EXTRA_BITS[36] = {\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,\n 1, 1, 2, 2, 3, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};\n\nstatic const u32 SEQ_MATCH_LENGTH_BASELINES[53] = {\n 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,\n 31, 32, 33, 34, 35, 37, 39, 41, 43, 47, 51, 59, 67, 83,\n 99, 131, 259, 515, 1027, 2051, 4099, 8195, 16387, 32771, 65539};\nstatic const u8 SEQ_MATCH_LENGTH_EXTRA_BITS[53] = {\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,\n 2, 2, 3, 3, 4, 4, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};\n\n/// Offset decoding is simpler so we just need a maximum code value\nstatic const u8 SEQ_MAX_CODES[3] = {35, (u8)-1, 52};\n\nstatic void decompress_sequences(frame_context_t *const ctx,\n istream_t *const in,\n sequence_command_t *const sequences,\n const size_t num_sequences);\nstatic sequence_command_t decode_sequence(sequence_states_t *const state,\n const u8 *const src,\n i64 *const offset,\n int lastSequence);\nstatic void decode_seq_table(FSE_dtable *const table, istream_t *const in,\n const seq_part_t type, const seq_mode_t mode);\n\nstatic size_t decode_sequences(frame_context_t *const ctx, istream_t *in,\n sequence_command_t **const sequences) {\n // \"A compressed block is a succession of sequences . A sequence is a\n // literal copy command, followed by a match copy command. A literal copy\n // command specifies a length. It is the number of bytes to be copied (or\n // extracted) from the literal section. A match copy command specifies an\n // offset and a length. The offset gives the position to copy from, which\n // can be within a previous block.\"\n\n size_t num_sequences;\n\n // \"Number_of_Sequences\n //\n // This is a variable size field using between 1 and 3 bytes. Let's call its\n // first byte byte0.\"\n u8 header = IO_read_bits(in, 8);\n if (header < 128) {\n // \"Number_of_Sequences = byte0 . Uses 1 byte.\"\n num_sequences = header;\n } else if (header < 255) {\n // \"Number_of_Sequences = ((byte0-128) << 8) + byte1 . Uses 2 bytes.\"\n num_sequences = ((header - 128) << 8) + IO_read_bits(in, 8);\n } else {\n // \"Number_of_Sequences = byte1 + (byte2<<8) + 0x7F00 . Uses 3 bytes.\"\n num_sequences = IO_read_bits(in, 16) + 0x7F00;\n }\n\n if (num_sequences == 0) {\n // \"There are no sequences. The sequence section stops there.\"\n *sequences = NULL;\n return 0;\n }\n\n *sequences = malloc(num_sequences * sizeof(sequence_command_t));\n if (!*sequences) {\n BAD_ALLOC();\n }\n\n decompress_sequences(ctx, in, *sequences, num_sequences);\n return num_sequences;\n}\n\n/// Decompress the FSE encoded sequence commands\nstatic void decompress_sequences(frame_context_t *const ctx, istream_t *in,\n sequence_command_t *const sequences,\n const size_t num_sequences) {\n // \"The Sequences_Section regroup all symbols required to decode commands.\n // There are 3 symbol types : literals lengths, offsets and match lengths.\n // They are encoded together, interleaved, in a single bitstream.\"\n\n // \"Symbol compression modes\n //\n // This is a single byte, defining the compression mode of each symbol\n // type.\"\n //\n // Bit number : Field name\n // 7-6 : Literals_Lengths_Mode\n // 5-4 : Offsets_Mode\n // 3-2 : Match_Lengths_Mode\n // 1-0 : Reserved\n u8 compression_modes = IO_read_bits(in, 8);\n\n if ((compression_modes & 3) != 0) {\n // Reserved bits set\n CORRUPTION();\n }\n\n // \"Following the header, up to 3 distribution tables can be described. When\n // present, they are in this order :\n //\n // Literals lengths\n // Offsets\n // Match Lengths\"\n // Update the tables we have stored in the context\n decode_seq_table(&ctx->ll_dtable, in, seq_literal_length,\n (compression_modes >> 6) & 3);\n\n decode_seq_table(&ctx->of_dtable, in, seq_offset,\n (compression_modes >> 4) & 3);\n\n decode_seq_table(&ctx->ml_dtable, in, seq_match_length,\n (compression_modes >> 2) & 3);\n\n\n sequence_states_t states;\n\n // Initialize the decoding tables\n {\n states.ll_table = ctx->ll_dtable;\n states.of_table = ctx->of_dtable;\n states.ml_table = ctx->ml_dtable;\n }\n\n const size_t len = IO_istream_len(in);\n const u8 *const src = IO_get_read_ptr(in, len);\n\n // \"After writing the last bit containing information, the compressor writes\n // a single 1-bit and then fills the byte with 0-7 0 bits of padding.\"\n const int padding = 8 - highest_set_bit(src[len - 1]);\n // The offset starts at the end because FSE streams are read backwards\n i64 bit_offset = (i64)(len * 8 - (size_t)padding);\n\n // \"The bitstream starts with initial state values, each using the required\n // number of bits in their respective accuracy, decoded previously from\n // their normalized distribution.\n //\n // It starts by Literals_Length_State, followed by Offset_State, and finally\n // Match_Length_State.\"\n FSE_init_state(&states.ll_table, &states.ll_state, src, &bit_offset);\n FSE_init_state(&states.of_table, &states.of_state, src, &bit_offset);\n FSE_init_state(&states.ml_table, &states.ml_state, src, &bit_offset);\n\n for (size_t i = 0; i < num_sequences; i++) {\n // Decode sequences one by one\n sequences[i] = decode_sequence(&states, src, &bit_offset, i==num_sequences-1);\n }\n\n if (bit_offset != 0) {\n CORRUPTION();\n }\n}\n\n// Decode a single sequence and update the state\nstatic sequence_command_t decode_sequence(sequence_states_t *const states,\n const u8 *const src,\n i64 *const offset,\n int lastSequence) {\n // \"Each symbol is a code in its own context, which specifies Baseline and\n // Number_of_Bits to add. Codes are FSE compressed, and interleaved with raw\n // additional bits in the same bitstream.\"\n\n // Decode symbols, but don't update states\n const u8 of_code = FSE_peek_symbol(&states->of_table, states->of_state);\n const u8 ll_code = FSE_peek_symbol(&states->ll_table, states->ll_state);\n const u8 ml_code = FSE_peek_symbol(&states->ml_table, states->ml_state);\n\n // Offset doesn't need a max value as it's not decoded using a table\n if (ll_code > SEQ_MAX_CODES[seq_literal_length] ||\n ml_code > SEQ_MAX_CODES[seq_match_length]) {\n CORRUPTION();\n }\n\n // Read the interleaved bits\n sequence_command_t seq;\n // \"Decoding starts by reading the Number_of_Bits required to decode Offset.\n // It then does the same for Match_Length, and then for Literals_Length.\"\n seq.offset = ((u32)1 << of_code) + STREAM_read_bits(src, of_code, offset);\n\n seq.match_length =\n SEQ_MATCH_LENGTH_BASELINES[ml_code] +\n STREAM_read_bits(src, SEQ_MATCH_LENGTH_EXTRA_BITS[ml_code], offset);\n\n seq.literal_length =\n SEQ_LITERAL_LENGTH_BASELINES[ll_code] +\n STREAM_read_bits(src, SEQ_LITERAL_LENGTH_EXTRA_BITS[ll_code], offset);\n\n // \"If it is not the last sequence in the block, the next operation is to\n // update states. Using the rules pre-calculated in the decoding tables,\n // Literals_Length_State is updated, followed by Match_Length_State, and\n // then Offset_State.\"\n // If the stream is complete don't read bits to update state\n if (!lastSequence) {\n FSE_update_state(&states->ll_table, &states->ll_state, src, offset);\n FSE_update_state(&states->ml_table, &states->ml_state, src, offset);\n FSE_update_state(&states->of_table, &states->of_state, src, offset);\n }\n\n return seq;\n}\n\n/// Given a sequence part and table mode, decode the FSE distribution\n/// Errors if the mode is `seq_repeat` without a pre-existing table in `table`\nstatic void decode_seq_table(FSE_dtable *const table, istream_t *const in,\n const seq_part_t type, const seq_mode_t mode) {\n // Constant arrays indexed by seq_part_t\n const i16 *const default_distributions[] = {SEQ_LITERAL_LENGTH_DEFAULT_DIST,\n SEQ_OFFSET_DEFAULT_DIST,\n SEQ_MATCH_LENGTH_DEFAULT_DIST};\n const size_t default_distribution_lengths[] = {36, 29, 53};\n const size_t default_distribution_accuracies[] = {6, 5, 6};\n\n const size_t max_accuracies[] = {9, 8, 9};\n\n if (mode != seq_repeat) {\n // Free old one before overwriting\n FSE_free_dtable(table);\n }\n\n switch (mode) {\n case seq_predefined: {\n // \"Predefined_Mode : uses a predefined distribution table.\"\n const i16 *distribution = default_distributions[type];\n const size_t symbs = default_distribution_lengths[type];\n const size_t accuracy_log = default_distribution_accuracies[type];\n\n FSE_init_dtable(table, distribution, symbs, accuracy_log);\n break;\n }\n case seq_rle: {\n // \"RLE_Mode : it's a single code, repeated Number_of_Sequences times.\"\n const u8 symb = IO_get_read_ptr(in, 1)[0];\n FSE_init_dtable_rle(table, symb);\n break;\n }\n case seq_fse: {\n // \"FSE_Compressed_Mode : standard FSE compression. A distribution table\n // will be present \"\n FSE_decode_header(table, in, max_accuracies[type]);\n break;\n }\n case seq_repeat:\n // \"Repeat_Mode : reuse distribution table from previous compressed\n // block.\"\n // Nothing to do here, table will be unchanged\n if (!table->symbols) {\n // This mode is invalid if we don't already have a table\n CORRUPTION();\n }\n break;\n default:\n // Impossible, as mode is from 0-3\n IMPOSSIBLE();\n break;\n }\n\n}\n/******* END SEQUENCE DECODING ************************************************/\n\n/******* SEQUENCE EXECUTION ***************************************************/\nstatic void execute_sequences(frame_context_t *const ctx, ostream_t *const out,\n const u8 *const literals,\n const size_t literals_len,\n const sequence_command_t *const sequences,\n const size_t num_sequences) {\n istream_t litstream = IO_make_istream(literals, literals_len);\n\n u64 *const offset_hist = ctx->previous_offsets;\n size_t total_output = ctx->current_total_output;\n\n for (size_t i = 0; i < num_sequences; i++) {\n const sequence_command_t seq = sequences[i];\n {\n const u32 literals_size = copy_literals(seq.literal_length, &litstream, out);\n total_output += literals_size;\n }\n\n size_t const offset = compute_offset(seq, offset_hist);\n\n size_t const match_length = seq.match_length;\n\n execute_match_copy(ctx, offset, match_length, total_output, out);\n\n total_output += match_length;\n }\n\n // Copy any leftover literals\n {\n size_t len = IO_istream_len(&litstream);\n copy_literals(len, &litstream, out);\n total_output += len;\n }\n\n ctx->current_total_output = total_output;\n}\n\nstatic u32 copy_literals(const size_t literal_length, istream_t *litstream,\n ostream_t *const out) {\n // If the sequence asks for more literals than are left, the\n // sequence must be corrupted\n if (literal_length > IO_istream_len(litstream)) {\n CORRUPTION();\n }\n\n u8 *const write_ptr = IO_get_write_ptr(out, literal_length);\n const u8 *const read_ptr =\n IO_get_read_ptr(litstream, literal_length);\n // Copy literals to output\n memcpy(write_ptr, read_ptr, literal_length);\n\n return literal_length;\n}\n\nstatic size_t compute_offset(sequence_command_t seq, u64 *const offset_hist) {\n size_t offset;\n // Offsets are special, we need to handle the repeat offsets\n if (seq.offset <= 3) {\n // \"The first 3 values define a repeated offset and we will call\n // them Repeated_Offset1, Repeated_Offset2, and Repeated_Offset3.\n // They are sorted in recency order, with Repeated_Offset1 meaning\n // 'most recent one'\".\n\n // Use 0 indexing for the array\n u32 idx = seq.offset - 1;\n if (seq.literal_length == 0) {\n // \"There is an exception though, when current sequence's\n // literals length is 0. In this case, repeated offsets are\n // shifted by one, so Repeated_Offset1 becomes Repeated_Offset2,\n // Repeated_Offset2 becomes Repeated_Offset3, and\n // Repeated_Offset3 becomes Repeated_Offset1 - 1_byte.\"\n idx++;\n }\n\n if (idx == 0) {\n offset = offset_hist[0];\n } else {\n // If idx == 3 then literal length was 0 and the offset was 3,\n // as per the exception listed above\n offset = idx < 3 ? offset_hist[idx] : offset_hist[0] - 1;\n\n // If idx == 1 we don't need to modify offset_hist[2], since\n // we're using the second-most recent code\n if (idx > 1) {\n offset_hist[2] = offset_hist[1];\n }\n offset_hist[1] = offset_hist[0];\n offset_hist[0] = offset;\n }\n } else {\n // When it's not a repeat offset:\n // \"if (Offset_Value > 3) offset = Offset_Value - 3;\"\n offset = seq.offset - 3;\n\n // Shift back history\n offset_hist[2] = offset_hist[1];\n offset_hist[1] = offset_hist[0];\n offset_hist[0] = offset;\n }\n return offset;\n}\n\nstatic void execute_match_copy(frame_context_t *const ctx, size_t offset,\n size_t match_length, size_t total_output,\n ostream_t *const out) {\n u8 *write_ptr = IO_get_write_ptr(out, match_length);\n if (total_output <= ctx->header.window_size) {\n // In this case offset might go back into the dictionary\n if (offset > total_output + ctx->dict_content_len) {\n // The offset goes beyond even the dictionary\n CORRUPTION();\n }\n\n if (offset > total_output) {\n // \"The rest of the dictionary is its content. The content act\n // as a \"past\" in front of data to compress or decompress, so it\n // can be referenced in sequence commands.\"\n const size_t dict_copy =\n MIN(offset - total_output, match_length);\n const size_t dict_offset =\n ctx->dict_content_len - (offset - total_output);\n\n memcpy(write_ptr, ctx->dict_content + dict_offset, dict_copy);\n write_ptr += dict_copy;\n match_length -= dict_copy;\n }\n } else if (offset > ctx->header.window_size) {\n CORRUPTION();\n }\n\n // We must copy byte by byte because the match length might be larger\n // than the offset\n // ex: if the output so far was \"abc\", a command with offset=3 and\n // match_length=6 would produce \"abcabcabc\" as the new output\n for (size_t j = 0; j < match_length; j++) {\n *write_ptr = *(write_ptr - offset);\n write_ptr++;\n }\n}\n/******* END SEQUENCE EXECUTION ***********************************************/\n\n/******* OUTPUT SIZE COUNTING *************************************************/\n/// Get the decompressed size of an input stream so memory can be allocated in\n/// advance.\n/// This implementation assumes `src` points to a single ZSTD-compressed frame\nsize_t ZSTD_get_decompressed_size(const void *src, const size_t src_len) {\n istream_t in = IO_make_istream(src, src_len);\n\n // get decompressed size from ZSTD frame header\n {\n const u32 magic_number = (u32)IO_read_bits(&in, 32);\n\n if (magic_number == ZSTD_MAGIC_NUMBER) {\n // ZSTD frame\n frame_header_t header;\n parse_frame_header(&header, &in);\n\n if (header.frame_content_size == 0 && !header.single_segment_flag) {\n // Content size not provided, we can't tell\n return (size_t)-1;\n }\n\n return header.frame_content_size;\n } else {\n // not a real frame or skippable frame\n ERROR(\"ZSTD frame magic number did not match\");\n }\n }\n}\n/******* END OUTPUT SIZE COUNTING *********************************************/\n\n/******* DICTIONARY PARSING ***************************************************/\ndictionary_t* create_dictionary(void) {\n dictionary_t* const dict = calloc(1, sizeof(dictionary_t));\n if (!dict) {\n BAD_ALLOC();\n }\n return dict;\n}\n\n/// Free an allocated dictionary\nvoid free_dictionary(dictionary_t *const dict) {\n HUF_free_dtable(&dict->literals_dtable);\n FSE_free_dtable(&dict->ll_dtable);\n FSE_free_dtable(&dict->of_dtable);\n FSE_free_dtable(&dict->ml_dtable);\n\n free(dict->content);\n\n memset(dict, 0, sizeof(dictionary_t));\n\n free(dict);\n}\n\n\n#if !defined(ZDEC_NO_DICTIONARY)\n#define DICT_SIZE_ERROR() ERROR(\"Dictionary size cannot be less than 8 bytes\")\n#define NULL_SRC() ERROR(\"Tried to create dictionary with pointer to null src\");\n\nstatic void init_dictionary_content(dictionary_t *const dict,\n istream_t *const in);\n\nvoid parse_dictionary(dictionary_t *const dict, const void *src,\n size_t src_len) {\n const u8 *byte_src = (const u8 *)src;\n memset(dict, 0, sizeof(dictionary_t));\n if (src == NULL) { /* cannot initialize dictionary with null src */\n NULL_SRC();\n }\n if (src_len < 8) {\n DICT_SIZE_ERROR();\n }\n\n istream_t in = IO_make_istream(byte_src, src_len);\n\n const u32 magic_number = IO_read_bits(&in, 32);\n if (magic_number != 0xEC30A437) {\n // raw content dict\n IO_rewind_bits(&in, 32);\n init_dictionary_content(dict, &in);\n return;\n }\n\n dict->dictionary_id = IO_read_bits(&in, 32);\n\n // \"Entropy_Tables : following the same format as the tables in compressed\n // blocks. They are stored in following order : Huffman tables for literals,\n // FSE table for offsets, FSE table for match lengths, and FSE table for\n // literals lengths. It's finally followed by 3 offset values, populating\n // recent offsets (instead of using {1,4,8}), stored in order, 4-bytes\n // little-endian each, for a total of 12 bytes. Each recent offset must have\n // a value < dictionary size.\"\n decode_huf_table(&dict->literals_dtable, &in);\n decode_seq_table(&dict->of_dtable, &in, seq_offset, seq_fse);\n decode_seq_table(&dict->ml_dtable, &in, seq_match_length, seq_fse);\n decode_seq_table(&dict->ll_dtable, &in, seq_literal_length, seq_fse);\n\n // Read in the previous offset history\n dict->previous_offsets[0] = IO_read_bits(&in, 32);\n dict->previous_offsets[1] = IO_read_bits(&in, 32);\n dict->previous_offsets[2] = IO_read_bits(&in, 32);\n\n // Ensure the provided offsets aren't too large\n // \"Each recent offset must have a value < dictionary size.\"\n for (int i = 0; i < 3; i++) {\n if (dict->previous_offsets[i] > src_len) {\n ERROR(\"Dictionary corrupted\");\n }\n }\n\n // \"Content : The rest of the dictionary is its content. The content act as\n // a \"past\" in front of data to compress or decompress, so it can be\n // referenced in sequence commands.\"\n init_dictionary_content(dict, &in);\n}\n\nstatic void init_dictionary_content(dictionary_t *const dict,\n istream_t *const in) {\n // Copy in the content\n dict->content_size = IO_istream_len(in);\n dict->content = malloc(dict->content_size);\n if (!dict->content) {\n BAD_ALLOC();\n }\n\n const u8 *const content = IO_get_read_ptr(in, dict->content_size);\n\n memcpy(dict->content, content, dict->content_size);\n}\n\nstatic void HUF_copy_dtable(HUF_dtable *const dst,\n const HUF_dtable *const src) {\n if (src->max_bits == 0) {\n memset(dst, 0, sizeof(HUF_dtable));\n return;\n }\n\n const size_t size = (size_t)1 << src->max_bits;\n dst->max_bits = src->max_bits;\n\n dst->symbols = malloc(size);\n dst->num_bits = malloc(size);\n if (!dst->symbols || !dst->num_bits) {\n BAD_ALLOC();\n }\n\n memcpy(dst->symbols, src->symbols, size);\n memcpy(dst->num_bits, src->num_bits, size);\n}\n\nstatic void FSE_copy_dtable(FSE_dtable *const dst, const FSE_dtable *const src) {\n if (src->accuracy_log == 0) {\n memset(dst, 0, sizeof(FSE_dtable));\n return;\n }\n\n size_t size = (size_t)1 << src->accuracy_log;\n dst->accuracy_log = src->accuracy_log;\n\n dst->symbols = malloc(size);\n dst->num_bits = malloc(size);\n dst->new_state_base = malloc(size * sizeof(u16));\n if (!dst->symbols || !dst->num_bits || !dst->new_state_base) {\n BAD_ALLOC();\n }\n\n memcpy(dst->symbols, src->symbols, size);\n memcpy(dst->num_bits, src->num_bits, size);\n memcpy(dst->new_state_base, src->new_state_base, size * sizeof(u16));\n}\n\n/// A dictionary acts as initializing values for the frame context before\n/// decompression, so we implement it by applying it's predetermined\n/// tables and content to the context before beginning decompression\nstatic void frame_context_apply_dict(frame_context_t *const ctx,\n const dictionary_t *const dict) {\n // If the content pointer is NULL then it must be an empty dict\n if (!dict || !dict->content)\n return;\n\n // If the requested dictionary_id is non-zero, the correct dictionary must\n // be present\n if (ctx->header.dictionary_id != 0 &&\n ctx->header.dictionary_id != dict->dictionary_id) {\n ERROR(\"Wrong dictionary provided\");\n }\n\n // Copy the dict content to the context for references during sequence\n // execution\n ctx->dict_content = dict->content;\n ctx->dict_content_len = dict->content_size;\n\n // If it's a formatted dict copy the precomputed tables in so they can\n // be used in the table repeat modes\n if (dict->dictionary_id != 0) {\n // Deep copy the entropy tables so they can be freed independently of\n // the dictionary struct\n HUF_copy_dtable(&ctx->literals_dtable, &dict->literals_dtable);\n FSE_copy_dtable(&ctx->ll_dtable, &dict->ll_dtable);\n FSE_copy_dtable(&ctx->of_dtable, &dict->of_dtable);\n FSE_copy_dtable(&ctx->ml_dtable, &dict->ml_dtable);\n\n // Copy the repeated offsets\n memcpy(ctx->previous_offsets, dict->previous_offsets,\n sizeof(ctx->previous_offsets));\n }\n}\n\n#else // ZDEC_NO_DICTIONARY is defined\n\nstatic void frame_context_apply_dict(frame_context_t *const ctx,\n const dictionary_t *const dict) {\n (void)ctx;\n if (dict && dict->content) ERROR(\"dictionary not supported\");\n}\n\n#endif\n/******* END DICTIONARY PARSING ***********************************************/\n\n/******* IO STREAM OPERATIONS *************************************************/\n\n/// Reads `num` bits from a bitstream, and updates the internal offset\nstatic inline u64 IO_read_bits(istream_t *const in, const int num_bits) {\n if (num_bits > 64 || num_bits <= 0) {\n ERROR(\"Attempt to read an invalid number of bits\");\n }\n\n const size_t bytes = (num_bits + in->bit_offset + 7) / 8;\n const size_t full_bytes = (num_bits + in->bit_offset) / 8;\n if (bytes > in->len) {\n INP_SIZE();\n }\n\n const u64 result = read_bits_LE(in->ptr, num_bits, in->bit_offset);\n\n in->bit_offset = (num_bits + in->bit_offset) % 8;\n in->ptr += full_bytes;\n in->len -= full_bytes;\n\n return result;\n}\n\n/// If a non-zero number of bits have been read from the current byte, advance\n/// the offset to the next byte\nstatic inline void IO_rewind_bits(istream_t *const in, int num_bits) {\n if (num_bits < 0) {\n ERROR(\"Attempting to rewind stream by a negative number of bits\");\n }\n\n // move the offset back by `num_bits` bits\n const int new_offset = in->bit_offset - num_bits;\n // determine the number of whole bytes we have to rewind, rounding up to an\n // integer number (e.g. if `new_offset == -5`, `bytes == 1`)\n const i64 bytes = -(new_offset - 7) / 8;\n\n in->ptr -= bytes;\n in->len += bytes;\n // make sure the resulting `bit_offset` is positive, as mod in C does not\n // convert numbers from negative to positive (e.g. -22 % 8 == -6)\n in->bit_offset = ((new_offset % 8) + 8) % 8;\n}\n\n/// If the remaining bits in a byte will be unused, advance to the end of the\n/// byte\nstatic inline void IO_align_stream(istream_t *const in) {\n if (in->bit_offset != 0) {\n if (in->len == 0) {\n INP_SIZE();\n }\n in->ptr++;\n in->len--;\n in->bit_offset = 0;\n }\n}\n\n/// Write the given byte into the output stream\nstatic inline void IO_write_byte(ostream_t *const out, u8 symb) {\n if (out->len == 0) {\n OUT_SIZE();\n }\n\n out->ptr[0] = symb;\n out->ptr++;\n out->len--;\n}\n\n/// Returns the number of bytes left to be read in this stream. The stream must\n/// be byte aligned.\nstatic inline size_t IO_istream_len(const istream_t *const in) {\n return in->len;\n}\n\n/// Returns a pointer where `len` bytes can be read, and advances the internal\n/// state. The stream must be byte aligned.\nstatic inline const u8 *IO_get_read_ptr(istream_t *const in, size_t len) {\n if (len > in->len) {\n INP_SIZE();\n }\n if (in->bit_offset != 0) {\n ERROR(\"Attempting to operate on a non-byte aligned stream\");\n }\n const u8 *const ptr = in->ptr;\n in->ptr += len;\n in->len -= len;\n\n return ptr;\n}\n/// Returns a pointer to write `len` bytes to, and advances the internal state\nstatic inline u8 *IO_get_write_ptr(ostream_t *const out, size_t len) {\n if (len > out->len) {\n OUT_SIZE();\n }\n u8 *const ptr = out->ptr;\n out->ptr += len;\n out->len -= len;\n\n return ptr;\n}\n\n/// Advance the inner state by `len` bytes\nstatic inline void IO_advance_input(istream_t *const in, size_t len) {\n if (len > in->len) {\n INP_SIZE();\n }\n if (in->bit_offset != 0) {\n ERROR(\"Attempting to operate on a non-byte aligned stream\");\n }\n\n in->ptr += len;\n in->len -= len;\n}\n\n/// Returns an `ostream_t` constructed from the given pointer and length\nstatic inline ostream_t IO_make_ostream(u8 *out, size_t len) {\n return (ostream_t) { out, len };\n}\n\n/// Returns an `istream_t` constructed from the given pointer and length\nstatic inline istream_t IO_make_istream(const u8 *in, size_t len) {\n return (istream_t) { in, len, 0 };\n}\n\n/// Returns an `istream_t` with the same base as `in`, and length `len`\n/// Then, advance `in` to account for the consumed bytes\n/// `in` must be byte aligned\nstatic inline istream_t IO_make_sub_istream(istream_t *const in, size_t len) {\n // Consume `len` bytes of the parent stream\n const u8 *const ptr = IO_get_read_ptr(in, len);\n\n // Make a substream using the pointer to those `len` bytes\n return IO_make_istream(ptr, len);\n}\n/******* END IO STREAM OPERATIONS *********************************************/\n\n/******* BITSTREAM OPERATIONS *************************************************/\n/// Read `num` bits (up to 64) from `src + offset`, where `offset` is in bits\nstatic inline u64 read_bits_LE(const u8 *src, const int num_bits,\n const size_t offset) {\n if (num_bits > 64) {\n ERROR(\"Attempt to read an invalid number of bits\");\n }\n\n // Skip over bytes that aren't in range\n src += offset / 8;\n size_t bit_offset = offset % 8;\n u64 res = 0;\n\n int shift = 0;\n int left = num_bits;\n while (left > 0) {\n u64 mask = left >= 8 ? 0xff : (((u64)1 << left) - 1);\n // Read the next byte, shift it to account for the offset, and then mask\n // out the top part if we don't need all the bits\n res += (((u64)*src++ >> bit_offset) & mask) << shift;\n shift += 8 - bit_offset;\n left -= 8 - bit_offset;\n bit_offset = 0;\n }\n\n return res;\n}\n\n/// Read bits from the end of a HUF or FSE bitstream. `offset` is in bits, so\n/// it updates `offset` to `offset - bits`, and then reads `bits` bits from\n/// `src + offset`. If the offset becomes negative, the extra bits at the\n/// bottom are filled in with `0` bits instead of reading from before `src`.\nstatic inline u64 STREAM_read_bits(const u8 *const src, const int bits,\n i64 *const offset) {\n *offset = *offset - bits;\n size_t actual_off = *offset;\n size_t actual_bits = bits;\n // Don't actually read bits from before the start of src, so if `*offset <\n // 0` fix actual_off and actual_bits to reflect the quantity to read\n if (*offset < 0) {\n actual_bits += *offset;\n actual_off = 0;\n }\n u64 res = read_bits_LE(src, actual_bits, actual_off);\n\n if (*offset < 0) {\n // Fill in the bottom \"overflowed\" bits with 0's\n res = -*offset >= 64 ? 0 : (res << -*offset);\n }\n return res;\n}\n/******* END BITSTREAM OPERATIONS *********************************************/\n\n/******* BIT COUNTING OPERATIONS **********************************************/\n/// Returns `x`, where `2^x` is the largest power of 2 less than or equal to\n/// `num`, or `-1` if `num == 0`.\nstatic inline int highest_set_bit(const u64 num) {\n for (int i = 63; i >= 0; i--) {\n if (((u64)1 << i) <= num) {\n return i;\n }\n }\n return -1;\n}\n/******* END BIT COUNTING OPERATIONS ******************************************/\n\n/******* HUFFMAN PRIMITIVES ***************************************************/\nstatic inline u8 HUF_decode_symbol(const HUF_dtable *const dtable,\n u16 *const state, const u8 *const src,\n i64 *const offset) {\n // Look up the symbol and number of bits to read\n const u8 symb = dtable->symbols[*state];\n const u8 bits = dtable->num_bits[*state];\n const u16 rest = STREAM_read_bits(src, bits, offset);\n // Shift `bits` bits out of the state, keeping the low order bits that\n // weren't necessary to determine this symbol. Then add in the new bits\n // read from the stream.\n *state = ((*state << bits) + rest) & (((u16)1 << dtable->max_bits) - 1);\n\n return symb;\n}\n\nstatic inline void HUF_init_state(const HUF_dtable *const dtable,\n u16 *const state, const u8 *const src,\n i64 *const offset) {\n // Read in a full `dtable->max_bits` bits to initialize the state\n const u8 bits = dtable->max_bits;\n *state = STREAM_read_bits(src, bits, offset);\n}\n\nstatic size_t HUF_decompress_1stream(const HUF_dtable *const dtable,\n ostream_t *const out,\n istream_t *const in) {\n const size_t len = IO_istream_len(in);\n if (len == 0) {\n INP_SIZE();\n }\n const u8 *const src = IO_get_read_ptr(in, len);\n\n // \"Each bitstream must be read backward, that is starting from the end down\n // to the beginning. Therefore it's necessary to know the size of each\n // bitstream.\n //\n // It's also necessary to know exactly which bit is the latest. This is\n // detected by a final bit flag : the highest bit of latest byte is a\n // final-bit-flag. Consequently, a last byte of 0 is not possible. And the\n // final-bit-flag itself is not part of the useful bitstream. Hence, the\n // last byte contains between 0 and 7 useful bits.\"\n const int padding = 8 - highest_set_bit(src[len - 1]);\n\n // Offset starts at the end because HUF streams are read backwards\n i64 bit_offset = len * 8 - padding;\n u16 state;\n\n HUF_init_state(dtable, &state, src, &bit_offset);\n\n size_t symbols_written = 0;\n while (bit_offset > -dtable->max_bits) {\n // Iterate over the stream, decoding one symbol at a time\n IO_write_byte(out, HUF_decode_symbol(dtable, &state, src, &bit_offset));\n symbols_written++;\n }\n // \"The process continues up to reading the required number of symbols per\n // stream. If a bitstream is not entirely and exactly consumed, hence\n // reaching exactly its beginning position with all bits consumed, the\n // decoding process is considered faulty.\"\n\n // When all symbols have been decoded, the final state value shouldn't have\n // any data from the stream, so it should have \"read\" dtable->max_bits from\n // before the start of `src`\n // Therefore `offset`, the edge to start reading new bits at, should be\n // dtable->max_bits before the start of the stream\n if (bit_offset != -dtable->max_bits) {\n CORRUPTION();\n }\n\n return symbols_written;\n}\n\nstatic size_t HUF_decompress_4stream(const HUF_dtable *const dtable,\n ostream_t *const out, istream_t *const in) {\n // \"Compressed size is provided explicitly : in the 4-streams variant,\n // bitstreams are preceded by 3 unsigned little-endian 16-bits values. Each\n // value represents the compressed size of one stream, in order. The last\n // stream size is deducted from total compressed size and from previously\n // decoded stream sizes\"\n const size_t csize1 = IO_read_bits(in, 16);\n const size_t csize2 = IO_read_bits(in, 16);\n const size_t csize3 = IO_read_bits(in, 16);\n\n istream_t in1 = IO_make_sub_istream(in, csize1);\n istream_t in2 = IO_make_sub_istream(in, csize2);\n istream_t in3 = IO_make_sub_istream(in, csize3);\n istream_t in4 = IO_make_sub_istream(in, IO_istream_len(in));\n\n size_t total_output = 0;\n // Decode each stream independently for simplicity\n // If we wanted to we could decode all 4 at the same time for speed,\n // utilizing more execution units\n total_output += HUF_decompress_1stream(dtable, out, &in1);\n total_output += HUF_decompress_1stream(dtable, out, &in2);\n total_output += HUF_decompress_1stream(dtable, out, &in3);\n total_output += HUF_decompress_1stream(dtable, out, &in4);\n\n return total_output;\n}\n\n/// Initializes a Huffman table using canonical Huffman codes\n/// For more explanation on canonical Huffman codes see\n/// https://www.cs.scranton.edu/~mccloske/courses/cmps340/huff_canonical_dec2015.html\n/// Codes within a level are allocated in symbol order (i.e. smaller symbols get\n/// earlier codes)\nstatic void HUF_init_dtable(HUF_dtable *const table, const u8 *const bits,\n const int num_symbs) {\n memset(table, 0, sizeof(HUF_dtable));\n if (num_symbs > HUF_MAX_SYMBS) {\n ERROR(\"Too many symbols for Huffman\");\n }\n\n u8 max_bits = 0;\n u16 rank_count[HUF_MAX_BITS + 1];\n memset(rank_count, 0, sizeof(rank_count));\n\n // Count the number of symbols for each number of bits, and determine the\n // depth of the tree\n for (int i = 0; i < num_symbs; i++) {\n if (bits[i] > HUF_MAX_BITS) {\n ERROR(\"Huffman table depth too large\");\n }\n max_bits = MAX(max_bits, bits[i]);\n rank_count[bits[i]]++;\n }\n\n const size_t table_size = 1 << max_bits;\n table->max_bits = max_bits;\n table->symbols = malloc(table_size);\n table->num_bits = malloc(table_size);\n\n if (!table->symbols || !table->num_bits) {\n free(table->symbols);\n free(table->num_bits);\n BAD_ALLOC();\n }\n\n // \"Symbols are sorted by Weight. Within same Weight, symbols keep natural\n // order. Symbols with a Weight of zero are removed. Then, starting from\n // lowest weight, prefix codes are distributed in order.\"\n\n u32 rank_idx[HUF_MAX_BITS + 1];\n // Initialize the starting codes for each rank (number of bits)\n rank_idx[max_bits] = 0;\n for (int i = max_bits; i >= 1; i--) {\n rank_idx[i - 1] = rank_idx[i] + rank_count[i] * (1 << (max_bits - i));\n // The entire range takes the same number of bits so we can memset it\n memset(&table->num_bits[rank_idx[i]], i, rank_idx[i - 1] - rank_idx[i]);\n }\n\n if (rank_idx[0] != table_size) {\n CORRUPTION();\n }\n\n // Allocate codes and fill in the table\n for (int i = 0; i < num_symbs; i++) {\n if (bits[i] != 0) {\n // Allocate a code for this symbol and set its range in the table\n const u16 code = rank_idx[bits[i]];\n // Since the code doesn't care about the bottom `max_bits - bits[i]`\n // bits of state, it gets a range that spans all possible values of\n // the lower bits\n const u16 len = 1 << (max_bits - bits[i]);\n memset(&table->symbols[code], i, len);\n rank_idx[bits[i]] += len;\n }\n }\n}\n\nstatic void HUF_init_dtable_usingweights(HUF_dtable *const table,\n const u8 *const weights,\n const int num_symbs) {\n // +1 because the last weight is not transmitted in the header\n if (num_symbs + 1 > HUF_MAX_SYMBS) {\n ERROR(\"Too many symbols for Huffman\");\n }\n\n u8 bits[HUF_MAX_SYMBS];\n\n u64 weight_sum = 0;\n for (int i = 0; i < num_symbs; i++) {\n // Weights are in the same range as bit count\n if (weights[i] > HUF_MAX_BITS) {\n CORRUPTION();\n }\n weight_sum += weights[i] > 0 ? (u64)1 << (weights[i] - 1) : 0;\n }\n\n // Find the first power of 2 larger than the sum\n const int max_bits = highest_set_bit(weight_sum) + 1;\n const u64 left_over = ((u64)1 << max_bits) - weight_sum;\n // If the left over isn't a power of 2, the weights are invalid\n if (left_over & (left_over - 1)) {\n CORRUPTION();\n }\n\n // left_over is used to find the last weight as it's not transmitted\n // by inverting 2^(weight - 1) we can determine the value of last_weight\n const int last_weight = highest_set_bit(left_over) + 1;\n\n for (int i = 0; i < num_symbs; i++) {\n // \"Number_of_Bits = Number_of_Bits ? Max_Number_of_Bits + 1 - Weight : 0\"\n bits[i] = weights[i] > 0 ? (max_bits + 1 - weights[i]) : 0;\n }\n bits[num_symbs] =\n max_bits + 1 - last_weight; // Last weight is always non-zero\n\n HUF_init_dtable(table, bits, num_symbs + 1);\n}\n\nstatic void HUF_free_dtable(HUF_dtable *const dtable) {\n free(dtable->symbols);\n free(dtable->num_bits);\n memset(dtable, 0, sizeof(HUF_dtable));\n}\n/******* END HUFFMAN PRIMITIVES ***********************************************/\n\n/******* FSE PRIMITIVES *******************************************************/\n/// For more description of FSE see\n/// https://github.com/Cyan4973/FiniteStateEntropy/\n\n/// Allow a symbol to be decoded without updating state\nstatic inline u8 FSE_peek_symbol(const FSE_dtable *const dtable,\n const u16 state) {\n return dtable->symbols[state];\n}\n\n/// Consumes bits from the input and uses the current state to determine the\n/// next state\nstatic inline void FSE_update_state(const FSE_dtable *const dtable,\n u16 *const state, const u8 *const src,\n i64 *const offset) {\n const u8 bits = dtable->num_bits[*state];\n const u16 rest = STREAM_read_bits(src, bits, offset);\n *state = dtable->new_state_base[*state] + rest;\n}\n\n/// Decodes a single FSE symbol and updates the offset\nstatic inline u8 FSE_decode_symbol(const FSE_dtable *const dtable,\n u16 *const state, const u8 *const src,\n i64 *const offset) {\n const u8 symb = FSE_peek_symbol(dtable, *state);\n FSE_update_state(dtable, state, src, offset);\n return symb;\n}\n\nstatic inline void FSE_init_state(const FSE_dtable *const dtable,\n u16 *const state, const u8 *const src,\n i64 *const offset) {\n // Read in a full `accuracy_log` bits to initialize the state\n const u8 bits = dtable->accuracy_log;\n *state = STREAM_read_bits(src, bits, offset);\n}\n\nstatic size_t FSE_decompress_interleaved2(const FSE_dtable *const dtable,\n ostream_t *const out,\n istream_t *const in) {\n const size_t len = IO_istream_len(in);\n if (len == 0) {\n INP_SIZE();\n }\n const u8 *const src = IO_get_read_ptr(in, len);\n\n // \"Each bitstream must be read backward, that is starting from the end down\n // to the beginning. Therefore it's necessary to know the size of each\n // bitstream.\n //\n // It's also necessary to know exactly which bit is the latest. This is\n // detected by a final bit flag : the highest bit of latest byte is a\n // final-bit-flag. Consequently, a last byte of 0 is not possible. And the\n // final-bit-flag itself is not part of the useful bitstream. Hence, the\n // last byte contains between 0 and 7 useful bits.\"\n const int padding = 8 - highest_set_bit(src[len - 1]);\n i64 offset = len * 8 - padding;\n\n u16 state1, state2;\n // \"The first state (State1) encodes the even indexed symbols, and the\n // second (State2) encodes the odd indexes. State1 is initialized first, and\n // then State2, and they take turns decoding a single symbol and updating\n // their state.\"\n FSE_init_state(dtable, &state1, src, &offset);\n FSE_init_state(dtable, &state2, src, &offset);\n\n // Decode until we overflow the stream\n // Since we decode in reverse order, overflowing the stream is offset going\n // negative\n size_t symbols_written = 0;\n while (1) {\n // \"The number of symbols to decode is determined by tracking bitStream\n // overflow condition: If updating state after decoding a symbol would\n // require more bits than remain in the stream, it is assumed the extra\n // bits are 0. Then, the symbols for each of the final states are\n // decoded and the process is complete.\"\n IO_write_byte(out, FSE_decode_symbol(dtable, &state1, src, &offset));\n symbols_written++;\n if (offset < 0) {\n // There's still a symbol to decode in state2\n IO_write_byte(out, FSE_peek_symbol(dtable, state2));\n symbols_written++;\n break;\n }\n\n IO_write_byte(out, FSE_decode_symbol(dtable, &state2, src, &offset));\n symbols_written++;\n if (offset < 0) {\n // There's still a symbol to decode in state1\n IO_write_byte(out, FSE_peek_symbol(dtable, state1));\n symbols_written++;\n break;\n }\n }\n\n return symbols_written;\n}\n\nstatic void FSE_init_dtable(FSE_dtable *const dtable,\n const i16 *const norm_freqs, const int num_symbs,\n const int accuracy_log) {\n if (accuracy_log > FSE_MAX_ACCURACY_LOG) {\n ERROR(\"FSE accuracy too large\");\n }\n if (num_symbs > FSE_MAX_SYMBS) {\n ERROR(\"Too many symbols for FSE\");\n }\n\n dtable->accuracy_log = accuracy_log;\n\n const size_t size = (size_t)1 << accuracy_log;\n dtable->symbols = malloc(size * sizeof(u8));\n dtable->num_bits = malloc(size * sizeof(u8));\n dtable->new_state_base = malloc(size * sizeof(u16));\n\n if (!dtable->symbols || !dtable->num_bits || !dtable->new_state_base) {\n BAD_ALLOC();\n }\n\n // Used to determine how many bits need to be read for each state,\n // and where the destination range should start\n // Needs to be u16 because max value is 2 * max number of symbols,\n // which can be larger than a byte can store\n u16 state_desc[FSE_MAX_SYMBS];\n\n // \"Symbols are scanned in their natural order for \"less than 1\"\n // probabilities. Symbols with this probability are being attributed a\n // single cell, starting from the end of the table. These symbols define a\n // full state reset, reading Accuracy_Log bits.\"\n int high_threshold = size;\n for (int s = 0; s < num_symbs; s++) {\n // Scan for low probability symbols to put at the top\n if (norm_freqs[s] == -1) {\n dtable->symbols[--high_threshold] = s;\n state_desc[s] = 1;\n }\n }\n\n // \"All remaining symbols are sorted in their natural order. Starting from\n // symbol 0 and table position 0, each symbol gets attributed as many cells\n // as its probability. Cell allocation is spread, not linear.\"\n // Place the rest in the table\n const u16 step = (size >> 1) + (size >> 3) + 3;\n const u16 mask = size - 1;\n u16 pos = 0;\n for (int s = 0; s < num_symbs; s++) {\n if (norm_freqs[s] <= 0) {\n continue;\n }\n\n state_desc[s] = norm_freqs[s];\n\n for (int i = 0; i < norm_freqs[s]; i++) {\n // Give `norm_freqs[s]` states to symbol s\n dtable->symbols[pos] = s;\n // \"A position is skipped if already occupied, typically by a \"less\n // than 1\" probability symbol.\"\n do {\n pos = (pos + step) & mask;\n } while (pos >=\n high_threshold);\n // Note: no other collision checking is necessary as `step` is\n // coprime to `size`, so the cycle will visit each position exactly\n // once\n }\n }\n if (pos != 0) {\n CORRUPTION();\n }\n\n // Now we can fill baseline and num bits\n for (size_t i = 0; i < size; i++) {\n u8 symbol = dtable->symbols[i];\n u16 next_state_desc = state_desc[symbol]++;\n // Fills in the table appropriately, next_state_desc increases by symbol\n // over time, decreasing number of bits\n dtable->num_bits[i] = (u8)(accuracy_log - highest_set_bit(next_state_desc));\n // Baseline increases until the bit threshold is passed, at which point\n // it resets to 0\n dtable->new_state_base[i] =\n ((u16)next_state_desc << dtable->num_bits[i]) - size;\n }\n}\n\n/// Decode an FSE header as defined in the Zstandard format specification and\n/// use the decoded frequencies to initialize a decoding table.\nstatic void FSE_decode_header(FSE_dtable *const dtable, istream_t *const in,\n const int max_accuracy_log) {\n // \"An FSE distribution table describes the probabilities of all symbols\n // from 0 to the last present one (included) on a normalized scale of 1 <<\n // Accuracy_Log .\n //\n // It's a bitstream which is read forward, in little-endian fashion. It's\n // not necessary to know its exact size, since it will be discovered and\n // reported by the decoding process.\n if (max_accuracy_log > FSE_MAX_ACCURACY_LOG) {\n ERROR(\"FSE accuracy too large\");\n }\n\n // The bitstream starts by reporting on which scale it operates.\n // Accuracy_Log = low4bits + 5. Note that maximum Accuracy_Log for literal\n // and match lengths is 9, and for offsets is 8. Higher values are\n // considered errors.\"\n const int accuracy_log = 5 + IO_read_bits(in, 4);\n if (accuracy_log > max_accuracy_log) {\n ERROR(\"FSE accuracy too large\");\n }\n\n // \"Then follows each symbol value, from 0 to last present one. The number\n // of bits used by each field is variable. It depends on :\n //\n // Remaining probabilities + 1 : example : Presuming an Accuracy_Log of 8,\n // and presuming 100 probabilities points have already been distributed, the\n // decoder may read any value from 0 to 255 - 100 + 1 == 156 (inclusive).\n // Therefore, it must read log2sup(156) == 8 bits.\n //\n // Value decoded : small values use 1 less bit : example : Presuming values\n // from 0 to 156 (inclusive) are possible, 255-156 = 99 values are remaining\n // in an 8-bits field. They are used this way : first 99 values (hence from\n // 0 to 98) use only 7 bits, values from 99 to 156 use 8 bits. \"\n\n i32 remaining = 1 << accuracy_log;\n i16 frequencies[FSE_MAX_SYMBS];\n\n int symb = 0;\n while (remaining > 0 && symb < FSE_MAX_SYMBS) {\n // Log of the number of possible values we could read\n int bits = highest_set_bit(remaining + 1) + 1;\n\n u16 val = IO_read_bits(in, bits);\n\n // Try to mask out the lower bits to see if it qualifies for the \"small\n // value\" threshold\n const u16 lower_mask = ((u16)1 << (bits - 1)) - 1;\n const u16 threshold = ((u16)1 << bits) - 1 - (remaining + 1);\n\n if ((val & lower_mask) < threshold) {\n IO_rewind_bits(in, 1);\n val = val & lower_mask;\n } else if (val > lower_mask) {\n val = val - threshold;\n }\n\n // \"Probability is obtained from Value decoded by following formula :\n // Proba = value - 1\"\n const i16 proba = (i16)val - 1;\n\n // \"It means value 0 becomes negative probability -1. -1 is a special\n // probability, which means \"less than 1\". Its effect on distribution\n // table is described in next paragraph. For the purpose of calculating\n // cumulated distribution, it counts as one.\"\n remaining -= proba < 0 ? -proba : proba;\n\n frequencies[symb] = proba;\n symb++;\n\n // \"When a symbol has a probability of zero, it is followed by a 2-bits\n // repeat flag. This repeat flag tells how many probabilities of zeroes\n // follow the current one. It provides a number ranging from 0 to 3. If\n // it is a 3, another 2-bits repeat flag follows, and so on.\"\n if (proba == 0) {\n // Read the next two bits to see how many more 0s\n int repeat = IO_read_bits(in, 2);\n\n while (1) {\n for (int i = 0; i < repeat && symb < FSE_MAX_SYMBS; i++) {\n frequencies[symb++] = 0;\n }\n if (repeat == 3) {\n repeat = IO_read_bits(in, 2);\n } else {\n break;\n }\n }\n }\n }\n IO_align_stream(in);\n\n // \"When last symbol reaches cumulated total of 1 << Accuracy_Log, decoding\n // is complete. If the last symbol makes cumulated total go above 1 <<\n // Accuracy_Log, distribution is considered corrupted.\"\n if (remaining != 0 || symb >= FSE_MAX_SYMBS) {\n CORRUPTION();\n }\n\n // Initialize the decoding table using the determined weights\n FSE_init_dtable(dtable, frequencies, symb, accuracy_log);\n}\n\nstatic void FSE_init_dtable_rle(FSE_dtable *const dtable, const u8 symb) {\n dtable->symbols = malloc(sizeof(u8));\n dtable->num_bits = malloc(sizeof(u8));\n dtable->new_state_base = malloc(sizeof(u16));\n\n if (!dtable->symbols || !dtable->num_bits || !dtable->new_state_base) {\n BAD_ALLOC();\n }\n\n // This setup will always have a state of 0, always return symbol `symb`,\n // and never consume any bits\n dtable->symbols[0] = symb;\n dtable->num_bits[0] = 0;\n dtable->new_state_base[0] = 0;\n dtable->accuracy_log = 0;\n}\n\nstatic void FSE_free_dtable(FSE_dtable *const dtable) {\n free(dtable->symbols);\n free(dtable->num_bits);\n free(dtable->new_state_base);\n memset(dtable, 0, sizeof(FSE_dtable));\n}\n/******* END FSE PRIMITIVES ***************************************************/\n" }, { "path": "doc/educational_decoder/zstd_decompress.h", "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#include /* size_t */\n\n/******* EXPOSED TYPES ********************************************************/\n/*\n* Contains the parsed contents of a dictionary\n* This includes Huffman and FSE tables used for decoding and data on offsets\n*/\ntypedef struct dictionary_s dictionary_t;\n/******* END EXPOSED TYPES ****************************************************/\n\n/******* DECOMPRESSION FUNCTIONS **********************************************/\n/// Zstandard decompression functions.\n/// `dst` must point to a space at least as large as the reconstructed output.\nsize_t ZSTD_decompress(void *const dst, const size_t dst_len,\n const void *const src, const size_t src_len);\n\n/// If `dict != NULL` and `dict_len >= 8`, does the same thing as\n/// `ZSTD_decompress` but uses the provided dict\nsize_t ZSTD_decompress_with_dict(void *const dst, const size_t dst_len,\n const void *const src, const size_t src_len,\n dictionary_t* parsed_dict);\n\n/// Get the decompressed size of an input stream so memory can be allocated in\n/// advance\n/// Returns -1 if the size can't be determined\n/// Assumes decompression of a single frame\nsize_t ZSTD_get_decompressed_size(const void *const src, const size_t src_len);\n/******* END DECOMPRESSION FUNCTIONS ******************************************/\n\n/******* DICTIONARY MANAGEMENT ***********************************************/\n/*\n * Return a valid dictionary_t pointer for use with dictionary initialization\n * or decompression\n */\ndictionary_t* create_dictionary(void);\n\n/*\n * Parse a provided dictionary blob for use in decompression\n * `src` -- must point to memory space representing the dictionary\n * `src_len` -- must provide the dictionary size\n * `dict` -- will contain the parsed contents of the dictionary and\n * can be used for decompression\n */\nvoid parse_dictionary(dictionary_t *const dict, const void *src,\n size_t src_len);\n\n/*\n * Free internal Huffman tables, FSE tables, and dictionary content\n */\nvoid free_dictionary(dictionary_t *const dict);\n/******* END DICTIONARY MANAGEMENT *******************************************/\n" }, { "path": "doc/zstd_compression_format.md", "content": "Zstandard Compression Format\n============================\n\n### Notices\n\nCopyright (c) Meta Platforms, Inc. and affiliates.\n\nPermission is granted to copy and distribute this document\nfor any purpose and without charge,\nincluding translations into other languages\nand incorporation into compilations,\nprovided that the copyright notice and this notice are preserved,\nand that any substantive changes or deletions from the original\nare clearly marked.\nDistribution of this document is unlimited.\n\n### Version\n\n0.4.4 (2025-03-22)\n\n\nIntroduction\n------------\n\nThe purpose of this document is to define a lossless compressed data format,\nthat is independent of CPU type, operating system,\nfile system and character set, suitable for\nfile compression, pipe and streaming compression,\nusing the [Zstandard algorithm](https://facebook.github.io/zstd/).\nThe text of the specification assumes a basic background in programming\nat the level of bits and other primitive data representations.\n\nThe data can be produced or consumed,\neven for an arbitrarily long sequentially presented input data stream,\nusing only an a priori bounded amount of intermediate storage,\nand hence can be used in data communications.\nThe format uses the Zstandard compression method,\nand optional [xxHash-64 checksum method](https://cyan4973.github.io/xxHash/),\nfor detection of data corruption.\n\nThe data format defined by this specification\ndoes not attempt to allow random access to compressed data.\n\nUnless otherwise indicated below,\na compliant compressor must produce data sets\nthat conform to the specifications presented here.\nIt doesn’t need to support all options though.\n\nA compliant decompressor must be able to decompress\nat least one working set of parameters\nthat conforms to the specifications presented here.\nIt may also ignore informative fields, such as checksum.\nWhenever it does not support a parameter defined in the compressed stream,\nit must produce a non-ambiguous error code and associated error message\nexplaining which parameter is unsupported.\n\nThis specification is intended for use by implementers of software\nto compress data into Zstandard format and/or decompress data from Zstandard format.\nThe Zstandard format is supported by an open source reference implementation,\nwritten in portable C, and available at : https://github.com/facebook/zstd .\n\n\n### Overall conventions\nIn this document:\n- square brackets i.e. `[` and `]` are used to indicate optional fields or parameters.\n- the naming convention for identifiers is `Mixed_Case_With_Underscores`\n\n### Definitions\nContent compressed by Zstandard is transformed into a Zstandard __frame__.\nMultiple frames can be appended into a single file or stream.\nA frame is completely independent, has a defined beginning and end,\nand a set of parameters which tells the decoder how to decompress it.\n\nA frame encapsulates one or multiple __blocks__.\nEach block contains arbitrary content, which is described by its header,\nand has a guaranteed maximum content size, which depends on frame parameters.\nUnlike frames, each block depends on previous blocks for proper decoding.\nHowever, each block can be decompressed without waiting for its successor,\nallowing streaming operations.\n\nOverview\n---------\n- [Frames](#frames)\n - [Zstandard frames](#zstandard-frames)\n - [Blocks](#blocks)\n - [Literals Section](#literals-section)\n - [Sequences Section](#sequences-section)\n - [Sequence Execution](#sequence-execution)\n - [Skippable frames](#skippable-frames)\n- [Entropy Encoding](#entropy-encoding)\n - [FSE](#fse)\n - [Huffman Coding](#huffman-coding)\n- [Dictionary Format](#dictionary-format)\n\nFrames\n------\nZstandard compressed data is made of one or more __frames__.\nEach frame is independent and can be decompressed independently of other frames.\nThe decompressed content of multiple concatenated frames is the concatenation of\neach frame decompressed content.\n\nThere are two frame formats defined by Zstandard:\n Zstandard frames and Skippable frames.\nZstandard frames contain compressed data, while\nskippable frames contain custom user metadata.\n\n## Zstandard frames\nThe structure of a single Zstandard frame is following:\n\n| `Magic_Number` | `Frame_Header` |`Data_Block`| [More data blocks] | [`Content_Checksum`] |\n|:--------------:|:--------------:|:----------:| ------------------ |:--------------------:|\n| 4 bytes | 2-14 bytes | n bytes | | 0-4 bytes |\n\n__`Magic_Number`__\n\n4 Bytes, __little-endian__ format.\nValue : 0xFD2FB528\nNote: This value was selected to be less probable to find at the beginning of some random file.\nIt avoids trivial patterns (0x00, 0xFF, repeated bytes, increasing bytes, etc.),\ncontains byte values outside of ASCII range,\nand doesn't map into UTF8 space.\nIt reduces the chances that a text file represent this value by accident.\n\n__`Frame_Header`__\n\n2 to 14 Bytes, detailed in [`Frame_Header`](#frame_header).\n\n__`Data_Block`__\n\nDetailed in [`Blocks`](#blocks).\nThat’s where compressed data is stored.\n\n__`Content_Checksum`__\n\nAn optional 32-bit checksum, only present if `Content_Checksum_flag` is set.\nThe content checksum is the result\nof [xxh64() hash function](https://cyan4973.github.io/xxHash/)\ndigesting the original (decoded) data as input, and a seed of zero.\nThe low 4 bytes of the checksum are stored in __little-endian__ format.\n\n### `Frame_Header`\n\nThe `Frame_Header` has a variable size, with a minimum of 2 bytes,\nand up to 14 bytes depending on optional parameters.\nThe structure of `Frame_Header` is following:\n\n| `Frame_Header_Descriptor` | [`Window_Descriptor`] | [`Dictionary_ID`] | [`Frame_Content_Size`] |\n| ------------------------- | --------------------- | ----------------- | ---------------------- |\n| 1 byte | 0-1 byte | 0-4 bytes | 0-8 bytes |\n\n#### `Frame_Header_Descriptor`\n\nThe first header's byte is called the `Frame_Header_Descriptor`.\nIt describes which other fields are present.\nDecoding this byte is enough to tell the size of `Frame_Header`.\n\n| Bit number | Field name |\n| ---------- | ---------- |\n| 7-6 | `Frame_Content_Size_flag` |\n| 5 | `Single_Segment_flag` |\n| 4 | `Unused_bit` |\n| 3 | `Reserved_bit` |\n| 2 | `Content_Checksum_flag` |\n| 1-0 | `Dictionary_ID_flag` |\n\nIn this table, bit 7 is the highest bit, while bit 0 is the lowest one.\n\n__`Frame_Content_Size_flag`__\n\nThis is a 2-bits flag (`= Frame_Header_Descriptor >> 6`),\nspecifying if `Frame_Content_Size` (the decompressed data size)\nis provided within the header.\n`Flag_Value` provides `FCS_Field_Size`,\nwhich is the number of bytes used by `Frame_Content_Size`\naccording to the following table:\n\n| `Flag_Value` | 0 | 1 | 2 | 3 |\n| -------------- | ------ | --- | --- | --- |\n|`FCS_Field_Size`| 0 or 1 | 2 | 4 | 8 |\n\nWhen `Flag_Value` is `0`, `FCS_Field_Size` depends on `Single_Segment_flag` :\nif `Single_Segment_flag` is set, `FCS_Field_Size` is 1.\nOtherwise, `FCS_Field_Size` is 0 : `Frame_Content_Size` is not provided.\n\n__`Single_Segment_flag`__\n\nIf this flag is set,\ndata must be regenerated within a single continuous memory segment.\n\nIn this case, `Window_Descriptor` byte is skipped,\nbut `Frame_Content_Size` is necessarily present.\nAs a consequence, the decoder must allocate a memory segment\nof size equal or larger than `Frame_Content_Size`.\n\nIn order to preserve the decoder from unreasonable memory requirements,\na decoder is allowed to reject a compressed frame\nwhich requests a memory size beyond decoder's authorized range.\n\nFor broader compatibility, decoders are recommended to support\nmemory sizes of at least 8 MB.\nThis is only a recommendation,\neach decoder is free to support higher or lower limits,\ndepending on local limitations.\n\n__`Unused_bit`__\n\nA decoder compliant with this specification version shall not interpret this bit.\nIt might be used in any future version,\nto signal a property which is transparent to properly decode the frame.\nAn encoder compliant with this specification version must set this bit to zero.\n\n__`Reserved_bit`__\n\nThis bit is reserved for some future feature.\nIts value _must be zero_.\nA decoder compliant with this specification version must ensure it is not set.\nThis bit may be used in a future revision,\nto signal a feature that must be interpreted to decode the frame correctly.\n\n__`Content_Checksum_flag`__\n\nIf this flag is set, a 32-bits `Content_Checksum` will be present at frame's end.\nSee `Content_Checksum` paragraph.\n\n__`Dictionary_ID_flag`__\n\nThis is a 2-bits flag (`= FHD & 3`),\ntelling if a dictionary ID is provided within the header.\nIt also specifies the size of this field as `DID_Field_Size`.\n\n|`Flag_Value` | 0 | 1 | 2 | 3 |\n| -------------- | --- | --- | --- | --- |\n|`DID_Field_Size`| 0 | 1 | 2 | 4 |\n\n#### `Window_Descriptor`\n\nProvides guarantees on minimum memory buffer required to decompress a frame.\nThis information is important for decoders to allocate enough memory.\n\nThe `Window_Descriptor` byte is optional.\nWhen `Single_Segment_flag` is set, `Window_Descriptor` is not present.\nIn this case, `Window_Size` is `Frame_Content_Size`,\nwhich can be any value from 0 to 2^64-1 bytes (16 ExaBytes).\n\n| Bit numbers | 7-3 | 2-0 |\n| ----------- | ---------- | ---------- |\n| Field name | `Exponent` | `Mantissa` |\n\nThe minimum memory buffer size is called `Window_Size`.\nIt is described by the following formulas :\n```\nwindowLog = 10 + Exponent;\nwindowBase = 1 << windowLog;\nwindowAdd = (windowBase / 8) * Mantissa;\nWindow_Size = windowBase + windowAdd;\n```\nThe minimum `Window_Size` is 1 KB.\nThe maximum `Window_Size` is `(1<<41) + 7*(1<<38)` bytes, which is 3.75 TB.\n\nIn general, larger `Window_Size` tend to improve compression ratio,\nbut at the cost of memory usage.\n\nTo properly decode compressed data,\na decoder will need to allocate a buffer of at least `Window_Size` bytes.\n\nIn order to preserve decoder from unreasonable memory requirements,\na decoder is allowed to reject a compressed frame\nwhich requests a memory size beyond decoder's authorized range.\n\nFor improved interoperability,\nit's recommended for decoders to support `Window_Size` of up to 8 MB,\nand it's recommended for encoders to not generate frame requiring `Window_Size` larger than 8 MB.\nIt's merely a recommendation though,\ndecoders are free to support larger or lower limits,\ndepending on local limitations.\n\n#### `Dictionary_ID`\n\nThis is a variable size field, which contains\nthe ID of the dictionary required to properly decode the frame.\n`Dictionary_ID` field is optional. When it's not present,\nit's up to the decoder to know which dictionary to use.\n\n`Dictionary_ID` field size is provided by `DID_Field_Size`.\n`DID_Field_Size` is directly derived from value of `Dictionary_ID_flag`.\n1 byte can represent an ID 0-255.\n2 bytes can represent an ID 0-65535.\n4 bytes can represent an ID 0-4294967295.\nFormat is __little-endian__.\n\nIt's allowed to represent a small ID (for example `13`)\nwith a large 4-bytes dictionary ID, even if it is less efficient.\n\nA value of `0` has same meaning as no `Dictionary_ID`,\nin which case the frame may or may not need a dictionary to be decoded,\nand the ID of such a dictionary is not specified.\nThe decoder must know this information by other means.\n\n#### `Frame_Content_Size`\n\nThis is the original (uncompressed) size. This information is optional.\n`Frame_Content_Size` uses a variable number of bytes, provided by `FCS_Field_Size`.\n`FCS_Field_Size` is provided by the value of `Frame_Content_Size_flag`.\n`FCS_Field_Size` can be equal to 0 (not present), 1, 2, 4 or 8 bytes.\n\n| `FCS_Field_Size` | Range |\n| ---------------- | ---------- |\n| 0 | unknown |\n| 1 | 0 - 255 |\n| 2 | 256 - 65791|\n| 4 | 0 - 2^32-1 |\n| 8 | 0 - 2^64-1 |\n\n`Frame_Content_Size` format is __little-endian__.\nWhen `FCS_Field_Size` is 1, 4 or 8 bytes, the value is read directly.\nWhen `FCS_Field_Size` is 2, _the offset of 256 is added_.\nIt's allowed to represent a small size (for example `18`) using any compatible variant.\n\n\nBlocks\n-------\n\nAfter `Magic_Number` and `Frame_Header`, there are some number of blocks.\nEach frame must have at least one block,\nbut there is no upper limit on the number of blocks per frame.\n\nThe structure of a block is as follows:\n\n| `Block_Header` | `Block_Content` |\n|:--------------:|:---------------:|\n| 3 bytes | n bytes |\n\n__`Block_Header`__\n\n`Block_Header` uses 3 bytes, written using __little-endian__ convention.\nIt contains 3 fields :\n\n| `Last_Block` | `Block_Type` | `Block_Size` |\n|:------------:|:------------:|:------------:|\n| bit 0 | bits 1-2 | bits 3-23 |\n\n__`Last_Block`__\n\nThe lowest bit signals if this block is the last one.\nThe frame will end after this last block.\nIt may be followed by an optional `Content_Checksum`\n(see [Zstandard Frames](#zstandard-frames)).\n\n__`Block_Type`__\n\nThe next 2 bits represent the `Block_Type`.\n`Block_Type` influences the meaning of `Block_Size`.\nThere are 4 block types :\n\n| Value | 0 | 1 | 2 | 3 |\n| ------------ | ----------- | ----------- | ------------------ | --------- |\n| `Block_Type` | `Raw_Block` | `RLE_Block` | `Compressed_Block` | `Reserved`|\n\n- `Raw_Block` - this is an uncompressed block.\n `Block_Content` contains `Block_Size` bytes.\n\n- `RLE_Block` - this is a single byte, repeated `Block_Size` times.\n `Block_Content` consists of a single byte.\n On the decompression side, this byte must be repeated `Block_Size` times.\n\n- `Compressed_Block` - this is a [Zstandard compressed block](#compressed-blocks),\n explained later on.\n `Block_Size` is the length of `Block_Content`, the compressed data.\n The decompressed size is not known,\n but its maximum possible value is guaranteed (see below)\n\n- `Reserved` - this is not a block.\n This value cannot be used with current version of this specification.\n If such a value is present, it is considered corrupted data.\n\n__`Block_Size`__\n\nThe upper 21 bits of `Block_Header` represent the `Block_Size`.\n\nWhen `Block_Type` is `Compressed_Block` or `Raw_Block`,\n`Block_Size` is the size of `Block_Content` (hence excluding `Block_Header`).\n\nWhen `Block_Type` is `RLE_Block`, since `Block_Content`’s size is always 1,\n`Block_Size` represents the number of times this byte must be repeated.\n\n`Block_Size` is limited by `Block_Maximum_Size` (see below).\n\n__`Block_Content`__ and __`Block_Maximum_Size`__\n\nThe size of `Block_Content` is limited by `Block_Maximum_Size`,\nwhich is the smallest of:\n- `Window_Size`\n- 128 KiB (131.072 bytes)\n\n`Block_Maximum_Size` is constant for a given frame.\nThis maximum is applicable to both the decompressed size\nand the compressed size of any block in the frame.\n\nThe reasoning for this limit is that a decoder can read this information\nat the beginning of a frame and use it to allocate buffers.\nThe guarantees on the size of blocks ensure that\nthe buffers will be large enough for any following block of the valid frame.\n\n\nCompressed Blocks\n-----------------\nTo decompress a compressed block, the compressed size must be provided\nfrom `Block_Size` field within `Block_Header`.\n\nA compressed block consists of 2 sections :\n- [Literals Section](#literals-section)\n- [Sequences Section](#sequences-section)\n\nThe results of the two sections are then combined to produce the decompressed\ndata in [Sequence Execution](#sequence-execution)\n\n#### Prerequisites\nTo decode a compressed block, the following elements are necessary :\n- Previous decoded data, up to a distance of `Window_Size`,\n or beginning of the Frame, whichever is smaller.\n- List of \"recent offsets\" from previous `Compressed_Block`.\n- The previous Huffman tree, required by `Treeless_Literals_Block` type\n- Previous FSE decoding tables, required by `Repeat_Mode`\n for each symbol type (literals lengths, match lengths, offsets)\n\nNote that decoding tables aren't always from the previous `Compressed_Block`.\n\n- Every decoding table can come from a dictionary.\n- The Huffman tree comes from the previous `Compressed_Literals_Block`.\n\nLiterals Section\n----------------\nAll literals are regrouped in the first part of the block.\nThey can be decoded first, and then copied during [Sequence Execution],\nor they can be decoded on the flow during [Sequence Execution].\n\nLiterals can be stored uncompressed or compressed using Huffman prefix codes.\nWhen compressed, a tree description may optionally be present,\nfollowed by 1 or 4 streams.\n\n| `Literals_Section_Header` | [`Huffman_Tree_Description`] | [jumpTable] | Stream1 | [Stream2] | [Stream3] | [Stream4] |\n| ------------------------- | ---------------------------- | ----------- | ------- | --------- | --------- | --------- |\n\n\n### `Literals_Section_Header`\n\nHeader is in charge of describing how literals are packed.\nIt's a byte-aligned variable-size bitfield, ranging from 1 to 5 bytes,\nusing __little-endian__ convention.\n\n| `Literals_Block_Type` | `Size_Format` | `Regenerated_Size` | [`Compressed_Size`] |\n| --------------------- | ------------- | ------------------ | ------------------- |\n| 2 bits | 1 - 2 bits | 5 - 20 bits | 0 - 18 bits |\n\nIn this representation, bits on the left are the lowest bits.\n\n__`Literals_Block_Type`__\n\nThis field uses 2 lowest bits of first byte, describing 4 different block types :\n\n| `Literals_Block_Type` | Value |\n| --------------------------- | ----- |\n| `Raw_Literals_Block` | 0 |\n| `RLE_Literals_Block` | 1 |\n| `Compressed_Literals_Block` | 2 |\n| `Treeless_Literals_Block` | 3 |\n\n- `Raw_Literals_Block` - Literals are stored uncompressed.\n- `RLE_Literals_Block` - Literals consist of a single byte value\n repeated `Regenerated_Size` times.\n- `Compressed_Literals_Block` - This is a standard Huffman-compressed block,\n starting with a Huffman tree description.\n In this mode, there are at least 2 different literals represented in the Huffman tree description.\n See details below.\n- `Treeless_Literals_Block` - This is a Huffman-compressed block,\n using Huffman tree _from previous Huffman-compressed literals block_.\n `Huffman_Tree_Description` will be skipped.\n Note: If this mode is triggered without any previous Huffman-table in the frame\n (or [dictionary](#dictionary-format)), this should be treated as data corruption.\n\n__`Size_Format`__\n\n`Size_Format` is divided into 2 families :\n\n- For `Raw_Literals_Block` and `RLE_Literals_Block`,\n it's only necessary to decode `Regenerated_Size`.\n There is no `Compressed_Size` field.\n- For `Compressed_Block` and `Treeless_Literals_Block`,\n it's required to decode both `Compressed_Size`\n and `Regenerated_Size` (the decompressed size).\n It's also necessary to decode the number of streams (1 or 4).\n\nFor values spanning several bytes, convention is __little-endian__.\n\n__`Size_Format` for `Raw_Literals_Block` and `RLE_Literals_Block`__ :\n\n`Size_Format` uses 1 _or_ 2 bits.\nIts value is : `Size_Format = (Literals_Section_Header[0]>>2) & 3`\n\n- `Size_Format` == 00 or 10 : `Size_Format` uses 1 bit.\n `Regenerated_Size` uses 5 bits (0-31).\n `Literals_Section_Header` uses 1 byte.\n `Regenerated_Size = Literals_Section_Header[0]>>3`\n- `Size_Format` == 01 : `Size_Format` uses 2 bits.\n `Regenerated_Size` uses 12 bits (0-4095).\n `Literals_Section_Header` uses 2 bytes.\n `Regenerated_Size = (Literals_Section_Header[0]>>4) + (Literals_Section_Header[1]<<4)`\n- `Size_Format` == 11 : `Size_Format` uses 2 bits.\n `Regenerated_Size` uses 20 bits (0-1048575).\n `Literals_Section_Header` uses 3 bytes.\n `Regenerated_Size = (Literals_Section_Header[0]>>4) + (Literals_Section_Header[1]<<4) + (Literals_Section_Header[2]<<12)`\n\nOnly Stream1 is present for these cases.\nNote : it's allowed to represent a short value (for example `27`)\nusing a long format, even if it's less efficient.\n\n__`Size_Format` for `Compressed_Literals_Block` and `Treeless_Literals_Block`__ :\n\n`Size_Format` always uses 2 bits.\n\n- `Size_Format` == 00 : _A single stream_.\n Both `Regenerated_Size` and `Compressed_Size` use 10 bits (0-1023).\n `Literals_Section_Header` uses 3 bytes.\n- `Size_Format` == 01 : 4 streams.\n Both `Regenerated_Size` and `Compressed_Size` use 10 bits (6-1023).\n `Literals_Section_Header` uses 3 bytes.\n- `Size_Format` == 10 : 4 streams.\n Both `Regenerated_Size` and `Compressed_Size` use 14 bits (6-16383).\n `Literals_Section_Header` uses 4 bytes.\n- `Size_Format` == 11 : 4 streams.\n Both `Regenerated_Size` and `Compressed_Size` use 18 bits (6-262143).\n `Literals_Section_Header` uses 5 bytes.\n\nBoth `Compressed_Size` and `Regenerated_Size` fields follow __little-endian__ convention.\nNote: `Compressed_Size` __includes__ the size of the Huffman Tree description\n_when_ it is present.\nNote 2: `Compressed_Size` can never be `==0`.\nEven in single-stream scenario, assuming an empty content, it must be `>=1`,\nsince it contains at least the final end bit flag.\nIn 4-streams scenario, a valid `Compressed_Size` is necessarily `>= 10`\n(6 bytes for the jump table, + 4x1 bytes for the 4 streams).\n\n4 streams is faster than 1 stream in decompression speed,\nby exploiting instruction level parallelism.\nBut it's also more expensive,\ncosting on average ~7.3 bytes more than the 1 stream mode, mostly from the jump table.\n\nIn general, use the 4 streams mode when there are more literals to decode,\nto favor higher decompression speeds.\nNote that beyond >1KB of literals, the 4 streams mode is compulsory.\n\nNote that a minimum of 6 bytes is required for the 4 streams mode.\nThat's a technical minimum, but it's not recommended to employ the 4 streams mode\nfor such a small quantity, that would be wasteful.\nA more practical lower bound would be around ~256 bytes.\n\n#### Raw Literals Block\nThe data in Stream1 is `Regenerated_Size` bytes long,\nit contains the raw literals data to be used during [Sequence Execution].\n\n#### RLE Literals Block\nStream1 consists of a single byte which should be repeated `Regenerated_Size` times\nto generate the decoded literals.\n\n#### Compressed Literals Block and Treeless Literals Block\nBoth of these modes contain Huffman encoded data.\n\nFor `Treeless_Literals_Block`,\nthe Huffman table comes from previously compressed literals block,\nor from a dictionary.\n\n\n### `Huffman_Tree_Description`\nThis section is only present when `Literals_Block_Type` type is `Compressed_Literals_Block` (`2`).\nThe tree describes the weights of all literals symbols that can be present in the literals block, at least 2 and up to 256.\nThe format of the Huffman tree description can be found at [Huffman Tree description](#huffman-tree-description).\nThe size of `Huffman_Tree_Description` is determined during decoding process,\nit must be used to determine where streams begin.\n`Total_Streams_Size = Compressed_Size - Huffman_Tree_Description_Size`.\n\n\n### Jump Table\nThe Jump Table is only present when there are 4 Huffman-coded streams.\n\nReminder : Huffman compressed data consists of either 1 or 4 streams.\n\nIf only one stream is present, it is a single bitstream occupying the entire\nremaining portion of the literals block, encoded as described in\n[Huffman-Coded Streams](#huffman-coded-streams).\n\nIf there are four streams, `Literals_Section_Header` only provided\nenough information to know the decompressed and compressed sizes\nof all four streams _combined_.\nThe decompressed size of _each_ stream is equal to `(Regenerated_Size+3)/4`,\nexcept for the last stream which may be up to 3 bytes smaller,\nto reach a total decompressed size as specified in `Regenerated_Size`.\n\nThe compressed size of each stream is provided explicitly in the Jump Table.\nJump Table is 6 bytes long, and consists of three 2-byte __little-endian__ fields,\ndescribing the compressed sizes of the first three streams.\n`Stream4_Size` is computed from `Total_Streams_Size` minus sizes of other streams:\n\n`Stream4_Size = Total_Streams_Size - 6 - Stream1_Size - Stream2_Size - Stream3_Size`.\n\n`Stream4_Size` is necessarily `>= 1`. Therefore,\nif `Total_Streams_Size < Stream1_Size + Stream2_Size + Stream3_Size + 6 + 1`,\ndata is considered corrupted.\n\nEach of these 4 bitstreams is then decoded independently as a Huffman-Coded stream,\nas described in [Huffman-Coded Streams](#huffman-coded-streams)\n\n\nSequences Section\n-----------------\nA compressed block is a succession of _sequences_ .\nA sequence is a literal copy command, followed by a match copy command.\nA literal copy command specifies a length.\nIt is the number of bytes to be copied (or extracted) from the Literals Section.\nA match copy command specifies an offset and a length.\n\nWhen all _sequences_ are decoded,\nif there are literals left in the _literals section_,\nthese bytes are added at the end of the block.\n\nThis is described in more detail in [Sequence Execution](#sequence-execution).\n\nThe `Sequences_Section` regroup all symbols required to decode commands.\nThere are 3 symbol types : literals lengths, offsets and match lengths.\nThey are encoded together, interleaved, in a single _bitstream_.\n\nThe `Sequences_Section` starts by a header,\nfollowed by optional probability tables for each symbol type,\nfollowed by the bitstream.\n\n| `Sequences_Section_Header` | [`Literals_Length_Table`] | [`Offset_Table`] | [`Match_Length_Table`] | bitStream |\n| -------------------------- | ------------------------- | ---------------- | ---------------------- | --------- |\n\nTo decode the `Sequences_Section`, it's required to know its size.\nIts size is deduced from the size of `Literals_Section`:\n`Sequences_Section_Size = Block_Size - Literals_Section_Size`.\n\n\n#### `Sequences_Section_Header`\n\nConsists of 2 items:\n- `Number_of_Sequences`\n- Symbol compression modes\n\n__`Number_of_Sequences`__\n\nThis is a variable size field using between 1 and 3 bytes.\nLet's call its first byte `byte0`.\n- `if (byte0 < 128)` : `Number_of_Sequences = byte0` . Uses 1 byte.\n- `if (byte0 < 255)` : `Number_of_Sequences = ((byte0 - 0x80) << 8) + byte1`. Uses 2 bytes.\n Note that the 2 bytes format fully overlaps the 1 byte format.\n- `if (byte0 == 255)`: `Number_of_Sequences = byte1 + (byte2<<8) + 0x7F00`. Uses 3 bytes.\n\n`if (Number_of_Sequences == 0)` : there are no sequences.\n The sequence section stops immediately,\n FSE tables used in `Repeat_Mode` aren't updated.\n Block's decompressed content is defined solely by the Literals Section content.\n\n__Symbol compression modes__\n\nThis is a single byte, defining the compression mode of each symbol type.\n\n|Bit number| 7-6 | 5-4 | 3-2 | 1-0 |\n| -------- | ----------------------- | -------------- | -------------------- | ---------- |\n|Field name| `Literals_Lengths_Mode` | `Offsets_Mode` | `Match_Lengths_Mode` | `Reserved` |\n\nThe last field, `Reserved`, must be all-zeroes.\n\n`Literals_Lengths_Mode`, `Offsets_Mode` and `Match_Lengths_Mode` define the `Compression_Mode` of\nliterals lengths, offsets, and match lengths symbols respectively.\n\nThey follow the same enumeration :\n\n| Value | 0 | 1 | 2 | 3 |\n| ------------------ | ----------------- | ---------- | --------------------- | ------------- |\n| `Compression_Mode` | `Predefined_Mode` | `RLE_Mode` | `FSE_Compressed_Mode` | `Repeat_Mode` |\n\n- `Predefined_Mode` : A predefined FSE distribution table is used, defined in\n [default distributions](#default-distributions).\n No distribution table will be present.\n- `RLE_Mode` : The table description consists of a single byte, which contains the symbol's value.\n This symbol will be used for all sequences.\n- `FSE_Compressed_Mode` : standard FSE compression.\n A distribution table will be present.\n The format of this distribution table is described in [FSE Table Description](#fse-table-description).\n Note that the maximum allowed accuracy log for literals length and match length tables is 9,\n and the maximum accuracy log for the offsets table is 8.\n `FSE_Compressed_Mode` must not be used when only one symbol is present,\n `RLE_Mode` should be used instead (although any other mode will work).\n- `Repeat_Mode` : The table used in the previous `Compressed_Block` with `Number_of_Sequences > 0` will be used again,\n or if this is the first block, table in the dictionary will be used.\n Note that this includes `RLE_mode`, so if `Repeat_Mode` follows `RLE_Mode`, the same symbol will be repeated.\n It also includes `Predefined_Mode`, in which case `Repeat_Mode` will have same outcome as `Predefined_Mode`.\n No distribution table will be present.\n If this mode is used without any previous sequence table in the frame\n (nor [dictionary](#dictionary-format)) to repeat, this should be treated as corruption.\n\n#### The codes for literals lengths, match lengths, and offsets.\n\nEach symbol is a _code_ in its own context,\nwhich specifies `Baseline` and `Number_of_Bits` to add.\n_Codes_ are FSE compressed,\nand interleaved with raw additional bits in the same bitstream.\n\n##### Literals length codes\n\nLiterals length codes are values ranging from `0` to `35` included.\nThey define lengths from 0 to 131071 bytes.\nThe literals length is equal to the decoded `Baseline` plus\nthe result of reading `Number_of_Bits` bits from the bitstream,\nas a __little-endian__ value.\n\n| `Literals_Length_Code` | 0-15 |\n| ---------------------- | ---------------------- |\n| length | `Literals_Length_Code` |\n| `Number_of_Bits` | 0 |\n\n| `Literals_Length_Code` | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 |\n| ---------------------- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |\n| `Baseline` | 16 | 18 | 20 | 22 | 24 | 28 | 32 | 40 |\n| `Number_of_Bits` | 1 | 1 | 1 | 1 | 2 | 2 | 3 | 3 |\n\n| `Literals_Length_Code` | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 |\n| ---------------------- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |\n| `Baseline` | 48 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096 |\n| `Number_of_Bits` | 4 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |\n\n| `Literals_Length_Code` | 32 | 33 | 34 | 35 |\n| ---------------------- | ---- | ---- | ---- | ---- |\n| `Baseline` | 8192 |16384 |32768 |65536 |\n| `Number_of_Bits` | 13 | 14 | 15 | 16 |\n\n\n##### Match length codes\n\nMatch length codes are values ranging from `0` to `52` included.\nThey define lengths from 3 to 131074 bytes.\nThe match length is equal to the decoded `Baseline` plus\nthe result of reading `Number_of_Bits` bits from the bitstream,\nas a __little-endian__ value.\n\n| `Match_Length_Code` | 0-31 |\n| ------------------- | ----------------------- |\n| value | `Match_Length_Code` + 3 |\n| `Number_of_Bits` | 0 |\n\n| `Match_Length_Code` | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 |\n| ------------------- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |\n| `Baseline` | 35 | 37 | 39 | 41 | 43 | 47 | 51 | 59 |\n| `Number_of_Bits` | 1 | 1 | 1 | 1 | 2 | 2 | 3 | 3 |\n\n| `Match_Length_Code` | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 |\n| ------------------- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |\n| `Baseline` | 67 | 83 | 99 | 131 | 259 | 515 | 1027 | 2051 |\n| `Number_of_Bits` | 4 | 4 | 5 | 7 | 8 | 9 | 10 | 11 |\n\n| `Match_Length_Code` | 48 | 49 | 50 | 51 | 52 |\n| ------------------- | ---- | ---- | ---- | ---- | ---- |\n| `Baseline` | 4099 | 8195 |16387 |32771 |65539 |\n| `Number_of_Bits` | 12 | 13 | 14 | 15 | 16 |\n\n##### Offset codes\n\nOffset codes are values ranging from `0` to `N`.\n\nA decoder is free to limit its maximum `N` supported.\nRecommendation is to support at least up to `22`.\nFor information, at the time of this writing.\nthe reference decoder supports a maximum `N` value of `31`.\n\nAn offset code is also the number of additional bits to read in __little-endian__ fashion,\nand can be translated into an `Offset_Value` using the following formulas :\n\n```\nOffset_Value = (1 << offsetCode) + readNBits(offsetCode);\nif (Offset_Value > 3) offset = Offset_Value - 3;\n```\nIt means that maximum `Offset_Value` is `(2^(N+1))-1`\nsupporting back-reference distances up to `(2^(N+1))-4`,\nbut is limited by [maximum back-reference distance](#window_descriptor).\n\n`Offset_Value` from 1 to 3 are special : they define \"repeat codes\".\nThis is described in more detail in [Repeat Offsets](#repeat-offsets).\n\n#### Decoding Sequences\nFSE bitstreams are read in reverse direction than written. In zstd,\nthe compressor writes bits forward into a block and the decompressor\nmust read the bitstream _backwards_.\n\nTo find the start of the bitstream it is therefore necessary to\nknow the offset of the last byte of the block which can be found\nby counting `Block_Size` bytes after the block header.\n\nAfter writing the last bit containing information, the compressor\nwrites a single `1`-bit and then fills the byte with 0-7 `0` bits of\npadding. The last byte of the compressed bitstream cannot be `0` for\nthat reason.\n\nWhen decompressing, the last byte containing the padding is the first\nbyte to read. The decompressor needs to skip 0-7 initial `0`-bits and\nthe first `1`-bit it occurs. Afterwards, the useful part of the bitstream\nbegins.\n\nFSE decoding requires a 'state' to be carried from symbol to symbol.\nFor more explanation on FSE decoding, see the [FSE section](#fse).\n\nFor sequence decoding, a separate state keeps track of each\nliteral lengths, offsets, and match lengths symbols.\nSome FSE primitives are also used.\nFor more details on the operation of these primitives, see the [FSE section](#fse).\n\n##### Starting states\nThe bitstream starts with initial FSE state values,\neach using the required number of bits in their respective _accuracy_,\ndecoded previously from their normalized distribution.\n\nIt starts by `Literals_Length_State`,\nfollowed by `Offset_State`,\nand finally `Match_Length_State`.\n\nReminder : always keep in mind that all values are read _backward_,\nso the 'start' of the bitstream is at the highest position in memory,\nimmediately before the last `1`-bit for padding.\n\nAfter decoding the starting states, a single sequence is decoded\n`Number_Of_Sequences` times.\nThese sequences are decoded in order from first to last.\nSince the compressor writes the bitstream in the forward direction,\nthis means the compressor must encode the sequences starting with the last\none and ending with the first.\n\n##### Decoding a sequence\nFor each of the symbol types, the FSE state can be used to determine the appropriate code.\nThe code then defines the `Baseline` and `Number_of_Bits` to read for each type.\nSee the [description of the codes] for how to determine these values.\n\n[description of the codes]: #the-codes-for-literals-lengths-match-lengths-and-offsets\n\nDecoding starts by reading the `Number_of_Bits` required to decode `Offset`.\nIt then does the same for `Match_Length`, and then for `Literals_Length`.\nThis sequence is then used for [sequence execution](#sequence-execution).\n\nIf it is not the last sequence in the block,\nthe next operation is to update states.\nUsing the rules pre-calculated in the decoding tables,\n`Literals_Length_State` is updated,\nfollowed by `Match_Length_State`,\nand then `Offset_State`.\nSee the [FSE section](#fse) for details on how to update states from the bitstream.\n\nThis operation will be repeated `Number_of_Sequences` times.\nAt the end, the bitstream shall be entirely consumed,\notherwise the bitstream is considered corrupted.\n\n#### Default Distributions\nIf `Predefined_Mode` is selected for a symbol type,\nits FSE decoding table is generated from a predefined distribution table defined here.\nFor details on how to convert this distribution into a decoding table, see the [FSE section].\n\n[FSE section]: #from-normalized-distribution-to-decoding-tables\n\n##### Literals Length\nThe decoding table uses an accuracy log of 6 bits (64 states).\n```\nshort literalsLength_defaultDistribution[36] =\n { 4, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1,\n 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 1, 1, 1, 1, 1,\n -1,-1,-1,-1 };\n```\n\n##### Match Length\nThe decoding table uses an accuracy log of 6 bits (64 states).\n```\nshort matchLengths_defaultDistribution[53] =\n { 1, 4, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,-1,-1,\n -1,-1,-1,-1,-1 };\n```\n\n##### Offset Codes\nThe decoding table uses an accuracy log of 5 bits (32 states),\nand supports a maximum `N` value of 28, allowing offset values up to 536,870,908 .\n\nIf any sequence in the compressed block requires a larger offset than this,\nit's not possible to use the default distribution to represent it.\n```\nshort offsetCodes_defaultDistribution[29] =\n { 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,\n 1, 1, 1, 1, 1, 1, 1, 1,-1,-1,-1,-1,-1 };\n```\n\n\nSequence Execution\n------------------\nOnce literals and sequences have been decoded,\nthey are combined to produce the decoded content of a block.\n\nEach sequence consists of a tuple of (`literals_length`, `offset_value`, `match_length`),\ndecoded as described in the [Sequences Section](#sequences-section).\nTo execute a sequence, first copy `literals_length` bytes\nfrom the decoded literals to the output.\n\nThen `match_length` bytes are copied from previous decoded data.\nThe offset to copy from is determined by `offset_value`:\nif `offset_value > 3`, then the offset is `offset_value - 3`.\nIf `offset_value` is from 1-3, the offset is a special repeat offset value.\nSee the [repeat offset](#repeat-offsets) section for how the offset is determined\nin this case.\n\nThe offset is defined as from the current position, so an offset of 6\nand a match length of 3 means that 3 bytes should be copied from 6 bytes back.\nNote that all offsets leading to previously decoded data\nmust be smaller than `Window_Size` defined in `Frame_Header_Descriptor`.\n\n#### Repeat offsets\nAs seen in [Sequence Execution](#sequence-execution),\nthe first 3 values define a repeated offset and we will call them\n`Repeated_Offset1`, `Repeated_Offset2`, and `Repeated_Offset3`.\nThey are sorted in recency order, with `Repeated_Offset1` meaning \"most recent one\".\n\nIf `offset_value == 1`, then the offset used is `Repeated_Offset1`, etc.\n\nThere is an exception though, when current sequence's `literals_length = 0`.\nIn this case, repeated offsets are shifted by one,\nso an `offset_value` of 1 means `Repeated_Offset2`,\nan `offset_value` of 2 means `Repeated_Offset3`,\nand an `offset_value` of 3 means `Repeated_Offset1 - 1`.\n\nIn the final case, if `Repeated_Offset1 - 1` evaluates to 0, then the\ndata is considered corrupted.\n\nFor the first block, the starting offset history is populated with following values :\n`Repeated_Offset1`=1, `Repeated_Offset2`=4, `Repeated_Offset3`=8,\nunless a dictionary is used, in which case they come from the dictionary.\n\nThen each block gets its starting offset history from the ending values of the most recent `Compressed_Block`.\nNote that blocks which are not `Compressed_Block` are skipped, they do not contribute to offset history.\n\n[Offset Codes]: #offset-codes\n\n###### Offset updates rules\n\nDuring the execution of the sequences of a `Compressed_Block`, the\n`Repeated_Offsets`' values are kept up to date, so that they always represent\nthe three most-recently used offsets. In order to achieve that, they are\nupdated after executing each sequence in the following way:\n\nWhen the sequence's `offset_value` does not refer to one of the\n`Repeated_Offsets`--when it has value greater than 3, or when it has value 3\nand the sequence's `literals_length` is zero--the `Repeated_Offsets`' values\nare shifted back one, and `Repeated_Offset1` takes on the value of the\njust-used offset.\n\nOtherwise, when the sequence's `offset_value` refers to one of the\n`Repeated_Offsets`--when it has value 1 or 2, or when it has value 3 and the\nsequence's `literals_length` is non-zero--the `Repeated_Offsets` are re-ordered\nso that `Repeated_Offset1` takes on the value of the used Repeated_Offset, and\nthe existing values are pushed back from the first `Repeated_Offset` through to\nthe `Repeated_Offset` selected by the `offset_value`. This effectively performs\na single-stepped wrapping rotation of the values of these offsets, so that\ntheir order again reflects the recency of their use.\n\nThe following table shows the values of the `Repeated_Offsets` as a series of\nsequences are applied to them:\n\n| `offset_value` | `literals_length` | `Repeated_Offset1` | `Repeated_Offset2` | `Repeated_Offset3` | Comment |\n|:--------------:|:-----------------:|:------------------:|:------------------:|:------------------:|:-----------------------:|\n| | | 1 | 4 | 8 | starting values |\n| 1114 | 11 | 1111 | 1 | 4 | non-repeat |\n| 1 | 22 | 1111 | 1 | 4 | repeat 1: no change |\n| 2225 | 22 | 2222 | 1111 | 1 | non-repeat |\n| 1114 | 111 | 1111 | 2222 | 1111 | non-repeat |\n| 3336 | 33 | 3333 | 1111 | 2222 | non-repeat |\n| 2 | 22 | 1111 | 3333 | 2222 | repeat 2: swap 1 & 2 |\n| 3 | 33 | 2222 | 1111 | 3333 | repeat 3: rotate 3 to 1 |\n| 3 | 0 | 2221 | 2222 | 1111 | special case : insert `repeat1 - 1` |\n| 1 | 0 | 2222 | 2221 | 1111 | == repeat 2 |\n\n\nSkippable Frames\n----------------\n\n| `Magic_Number` | `Frame_Size` | `User_Data` |\n|:--------------:|:------------:|:-----------:|\n| 4 bytes | 4 bytes | n bytes |\n\nSkippable frames allow the insertion of user-defined metadata\ninto a flow of concatenated frames.\n\nSkippable frames defined in this specification are compatible with [LZ4] ones.\n\n[LZ4]:https://lz4.github.io/lz4/\n\nFrom a compliant decoder perspective, skippable frames need just be skipped,\nand their content ignored, resuming decoding after the skippable frame.\n\nIt can be noted that a skippable frame\ncan be used to watermark a stream of concatenated frames\nembedding any kind of tracking information (even just a UUID).\nUsers wary of such possibility should scan the stream of concatenated frames\nin an attempt to detect such frame for analysis or removal.\n\n__`Magic_Number`__\n\n4 Bytes, __little-endian__ format.\nValue : 0x184D2A5?, which means any value from 0x184D2A50 to 0x184D2A5F.\nAll 16 values are valid to identify a skippable frame.\nThis specification doesn't detail any specific tagging for skippable frames.\n\n__`Frame_Size`__\n\nThis is the size, in bytes, of the following `User_Data`\n(without including the magic number nor the size field itself).\nThis field is represented using 4 Bytes, __little-endian__ format, unsigned 32-bits.\nThis means `User_Data` can’t be bigger than (2^32-1) bytes.\n\n__`User_Data`__\n\nThe `User_Data` can be anything. Data will just be skipped by the decoder.\n\n\n\nEntropy Encoding\n----------------\nTwo types of entropy encoding are used by the Zstandard format:\nFSE, and Huffman coding.\nHuffman is used to compress literals,\nwhile FSE is used for all other symbols\n(`Literals_Length_Code`, `Match_Length_Code`, offset codes)\nand to compress Huffman headers.\n\n\nFSE\n---\nFSE, short for Finite State Entropy, is an entropy codec based on [ANS].\nFSE encoding/decoding involves a state that is carried over between symbols.\nDecoding must be done in the opposite direction as encoding.\nTherefore, all FSE bitstreams are read from end to beginning.\nNote that the order of the bits in the stream is not reversed,\nwe just read each multi-bits element in the reverse order they are encoded.\n\nFor additional details on FSE, see [Finite State Entropy].\n\n[Finite State Entropy]:https://github.com/Cyan4973/FiniteStateEntropy/\n\nFSE decoding is directed by a decoding table with a power of 2 size, each row containing three elements:\n`Symbol`, `Num_Bits`, and `Baseline`.\nThe `log2` of the table size is its `Accuracy_Log`.\nAn FSE state value represents an index in this table.\n\nTo obtain the initial state value, consume `Accuracy_Log` bits from the stream as a __little-endian__ value.\nThe first symbol in the stream is the `Symbol` indicated in the table for that state.\nTo obtain the next state value,\nthe decoder should consume `Num_Bits` bits from the stream as a __little-endian__ value and add it to `Baseline`.\n\n[ANS]: https://en.wikipedia.org/wiki/Asymmetric_Numeral_Systems\n\n### FSE Table Description\nTo decode an FSE bitstream, it is necessary to build its FSE decoding table.\nThe decoding table is derived from a distribution of Probabilities.\nThe Zstandard format encodes distributions of Probabilities as follows:\n\nThe distribution of probabilities is described in a bitstream which is read forward,\nin __little-endian__ fashion.\nThe amount of bytes consumed from the bitstream to describe the distribution\nis discovered at the end of the decoding process.\n\nThe bitstream starts by reporting on which scale the distribution operates.\nLet's `low4Bits` designate the lowest 4 bits of the first byte :\n`Accuracy_Log = low4bits + 5`.\n\nAn FSE distribution table describes the probabilities of all symbols\nfrom `0` to the last present one (included) in natural order.\nThe sum of probabilities is normalized to reach a power of 2 total of `1 << Accuracy_Log` .\nThere must be two or more symbols with non-zero probabilities.\n\nThe number of bits used to decode each probability is variable.\nIt depends on :\n\n- Remaining probabilities + 1 :\n __example__ :\n Presuming an `Accuracy_Log` of 8,\n and presuming 100 probability points have already been distributed,\n the decoder may read any value from `0` to `256 - 100 + 1 == 157` (inclusive).\n Therefore, it may read up to `log2sup(157) == 8` bits, where `log2sup(N)`\n is the smallest integer `T` that satisfies `(1 << T) > N`.\n\n- Value decoded : small values use 1 less bit :\n __example__ :\n Presuming values from 0 to 157 (inclusive) are possible,\n 255-157 = 98 values are remaining in an 8-bits field.\n They are used this way :\n first 98 values (hence from 0 to 97) use only 7 bits,\n values from 98 to 157 use 8 bits.\n This is achieved through this scheme :\n\n | 8-bit field read | Value decoded | Nb of bits consumed |\n | ---------------- | ------------- | ------------------- |\n | 0 - 97 | 0 - 97 | 7 |\n | 98 - 127 | 98 - 127 | 8 |\n | 128 - 225 | 0 - 97 | 7 |\n | 226 - 255 | 128 - 157 | 8 |\n\nProbability is derived from Value decoded using the following formula:\n`Probality = Value - 1`\n\nConsequently, a Probability of `0` is described by a Value `1`.\n\nA Value `0` is used to signal a special case, named \"Probability `-1`\".\nIt describes a probability which should have been \"less than 1\".\nIts effect on the decoding table building process is described in the [next section].\nFor the purpose of counting total allocated probability points, it counts as one.\n\n[next section]:#from-normalized-distribution-to-decoding-tables\n\nSymbols probabilities are read one by one, in order.\nAfter each probability is decoded, the total nb of probability points is updated.\nThis is used to determine how many bits must be read to decode the probability of next symbol.\n\nWhen a symbol has a __probability__ of `zero` (decoded from reading a Value `1`),\nit is followed by a 2-bits repeat flag.\nThis repeat flag tells how many probabilities of zeroes follow the current one.\nIt provides a number ranging from 0 to 3.\nIf it is a 3, another 2-bits repeat flag follows, and so on.\n\nWhen the Probability for a symbol makes cumulated total reach `1 << Accuracy_Log`,\nthen it's the last symbol, and decoding is complete.\n\nThen the decoder can tell how many bytes were used in this process,\nand how many symbols are present.\nThe bitstream consumes a round number of bytes.\nAny remaining bit within the last byte is just unused.\n\nIf this process results in a non-zero probability for a symbol outside of the\nvalid range of symbols that the FSE table is defined for, even if that symbol is\nnot used, then the data is considered corrupted.\nFor the specific case of offset codes,\na decoder implementation may reject a frame containing a non-zero probability\nfor an offset code larger than the largest offset code supported by the decoder\nimplementation.\n\n#### From normalized distribution to decoding tables\n\nThe normalized distribution of probabilities is enough\nto create a unique decoding table.\nIt is generated using the following build rule :\n\nThe table has a size of `Table_Size = 1 << Accuracy_Log`.\nEach row specifies the decoded symbol,\nand instructions to reach the next state (`Number_of_Bits` and `Baseline`).\n\nSymbols are first scanned in their natural order for \"less than 1\" probabilities\n(previously decoded from a Value of `0`).\nSymbols with this special probability are being attributed a single row,\nstarting from the end of the table and retreating.\nThese symbols define a full state reset, reading `Accuracy_Log` bits.\n\nThen, all remaining symbols, sorted in natural order, are allocated rows.\nStarting from smallest present symbol, and table position `0`,\neach symbol gets allocated as many rows as its probability.\n\nRow allocation is not linear, it follows this order, in modular arithmetic:\n```\nposition += (tableSize>>1) + (tableSize>>3) + 3;\nposition &= tableSize-1;\n```\n\nUsing above ordering rule, each symbol gets allocated as many rows as its probability.\nIf a position is already occupied by a \"less than 1\" probability symbol,\nit is simply skipped, and the next position is allocated instead.\nOnce enough rows have been allocated for the current symbol,\nthe allocation process continues, using the next symbol, in natural order.\nThis process guarantees that the table is entirely and exactly filled.\n\nEach row specifies a decoded symbol, and is accessed by current state value.\nIt also specifies `Number_of_Bits` and `Baseline`, which are required to determine next state value.\n\nTo correctly set these fields, it's necessary to sort all occurrences of each symbol in state value order,\nand then attribute N+1 bits to lower rows, and N bits to higher rows,\nfollowing the process described below (using an example):\n\n__Example__ :\nPresuming an `Accuracy_Log` of 7,\nlet's imagine a symbol with a Probability of 5:\nit receives 5 rows, corresponding to 5 state values between `0` and `127`.\n\nIn this example, the first state value happens to be `1` (after unspecified previous symbols).\nThe next 4 states are then determined using above modular arithmetic rule,\nwhich specifies to add `64+16+3 = 83` modulo `128` to jump to next position,\nproducing the following series: `1`, `84`, `39`, `122`, `77` (modular arithmetic).\n(note: the next symbol will then start at `32`).\n\nThese state values are then sorted in natural order,\nresulting in the following series: `1`, `39`, `77`, `84`, `122`.\n\nThe next power of 2 after 5 is 8.\nTherefore, the probability space will be divided into 8 equal parts.\nSince the probability space is `1<<7 = 128` large, each share is `128/8 = 16` large.\n\nIn order to reach 8 shares, the `8-5 = 3` lowest states will count \"double\",\ndoubling their shares (32 in width), hence requiring one more bit.\n\nBaseline is assigned starting from the lowest state using fewer bits,\ncontinuing in natural state order, looping back at the beginning.\nEach state takes its allocated range from Baseline, sized by its `Number_of_Bits`.\n\n| state order | 0 | 1 | 2 | 3 | 4 |\n| ---------------- | ----- | ----- | ------ | ---- | ------ |\n| state value | 1 | 39 | 77 | 84 | 122 |\n| width | 32 | 32 | 32 | 16 | 16 |\n| `Number_of_Bits` | 5 | 5 | 5 | 4 | 4 |\n| allocation order | 3 | 4 | 5 | 1 | 2 |\n| `Baseline` | 32 | 64 | 96 | 0 | 16 |\n| range | 32-63 | 64-95 | 96-127 | 0-15 | 16-31 |\n\nDuring decoding, the next state value is determined by using current state value as row number,\nthen reading the required `Number_of_Bits` from the bitstream, and adding the specified `Baseline`.\n\nNote:\nas a trivial example, it follows that, for a symbol with a Probability of `1`,\n`Baseline` is necessarily `0`, and `Number_of_Bits` is necessarily `Accuracy_Log`.\n\nSee [Appendix A] to see the outcome of this process applied to the default distributions.\n\n[Appendix A]: #appendix-a---decoding-tables-for-predefined-codes\n\n\nHuffman Coding\n--------------\nZstandard Huffman-coded streams are read backwards,\nsimilar to the FSE bitstreams.\nTherefore, to find the start of the bitstream, it is required to\nknow the offset of the last byte of the Huffman-coded stream.\n\nAfter writing the last bit containing information, the compressor\nwrites a single `1`-bit and then fills the byte with 0-7 `0` bits of\npadding. The last byte of the compressed bitstream cannot be `0` for\nthat reason.\n\nWhen decompressing, the last byte containing the padding is the first\nbyte to read. The decompressor needs to skip 0-7 initial `0`-bits and\nthe first `1`-bit it occurs. Afterwards, the useful part of the bitstream\nbegins.\n\nThe bitstream contains Huffman-coded symbols in __little-endian__ order,\nwith the codes defined by the method below.\n\n### Huffman Tree Description\n\nPrefix coding represents symbols from an a priori known alphabet\nby bit sequences (codewords), one codeword for each symbol,\nin a manner such that different symbols may be represented\nby bit sequences of different lengths,\nbut a parser can always parse an encoded string\nunambiguously symbol-by-symbol.\n\nGiven an alphabet with known symbol frequencies,\nthe Huffman algorithm allows the construction of an optimal prefix code\nusing the fewest bits of any possible prefix codes for that alphabet.\n\nPrefix code must not exceed a maximum code length.\nMore bits improve accuracy but cost more header size,\nand require more memory or more complex decoding operations.\nThis specification limits maximum code length to 11 bits.\n\n#### Representation\n\nAll literal symbols from zero (included) to last present one (excluded)\nare represented by `Weight` with values from `0` to `Max_Number_of_Bits`.\nTransformation from `Weight` to `Number_of_Bits` follows this formula :\n```\nNumber_of_Bits = Weight ? (Max_Number_of_Bits + 1 - Weight) : 0\n```\nWhen a literal symbol is not present, it receives a `Weight` of 0.\nThe least frequent symbol receives a `Weight` of 1.\nIf no literal has a `Weight` of 1, then the data is considered corrupted.\nIf there are not at least two literals with non-zero `Weight`, then the data\nis considered corrupted.\nThe most frequent symbol receives a `Weight` anywhere between 1 and 11 (max).\nThe last symbol's `Weight` is deduced from previously retrieved Weights,\nby completing to the nearest power of 2. It's necessarily non 0.\nIf it's not possible to reach a clean power of 2 with a single `Weight` value,\nthe Huffman Tree Description is considered invalid.\nThis final power of 2 gives `Max_Number_of_Bits`, the depth of the current tree.\n`Max_Number_of_Bits` must be <= 11,\notherwise the representation is considered corrupted.\n\n__Example__ :\nLet's presume the following Huffman tree must be described :\n\n| literal symbol | A | B | C | D | E | F |\n| ---------------- | --- | --- | --- | --- | --- | --- |\n| `Number_of_Bits` | 1 | 2 | 3 | 0 | 4 | 4 |\n\nThe tree depth is 4, since its longest elements uses 4 bits\n(longest elements are the ones with smallest frequency).\n\nAll symbols will now receive a `Weight` instead of `Number_of_Bits`.\nWeight formula is :\n```\nWeight = Number_of_Bits ? (Max_Number_of_Bits + 1 - Number_of_Bits) : 0\n```\nIt gives the following series of Weights :\n\n| literal symbol | A | B | C | D | E | F |\n| -------------- | --- | --- | --- | --- | --- | --- |\n| `Weight` | 4 | 3 | 2 | 0 | 1 | 1 |\n\nThis list will be sent to the decoder, with the following modifications:\n\n- `F` will not be listed, because it can be determined from previous symbols\n- nor will symbols above `F` as they are all 0\n- on the other hand, all symbols before `A`, starting with `\\0`, will be listed, with a Weight of 0.\n\nThe decoder will do the inverse operation :\nhaving collected weights of literal symbols from `A` to `E`,\nit knows the last literal, `F`, is present with a non-zero `Weight`.\nThe `Weight` of `F` can be determined by advancing to the next power of 2.\nThe sum of `2^(Weight-1)` (excluding 0's) is :\n`8 + 4 + 2 + 0 + 1 = 15`.\nNearest larger power of 2 value is 16.\nTherefore, `Max_Number_of_Bits = log2(16) = 4` and `Weight[F] = log_2(16 - 15) + 1 = 1`.\n\n#### Huffman Tree header\n\nThis is a single byte value (0-255),\nwhich describes how the series of weights is encoded.\n\n- if `headerByte` < 128 :\n the series of weights is compressed using FSE (see below).\n The length of the FSE-compressed series is equal to `headerByte` (0-127).\n\n- if `headerByte` >= 128 :\n + the series of weights uses a direct representation,\n where each `Weight` is encoded directly as a 4 bits field (0-15).\n + They are encoded forward, 2 weights to a byte,\n first weight taking the top four bits and second one taking the bottom four.\n * e.g. the following operations could be used to read the weights:\n `Weight[0] = (Byte[0] >> 4), Weight[1] = (Byte[0] & 0xf)`, etc.\n + The full representation occupies `Ceiling(Number_of_Weights/2)` bytes,\n meaning it uses only full bytes even if `Number_of_Weights` is odd.\n + `Number_of_Weights = headerByte - 127`.\n * Note that maximum `Number_of_Weights` is 255-127 = 128,\n therefore, only up to 128 `Weight` can be encoded using direct representation.\n * Since the last non-zero `Weight` is _not_ encoded,\n this scheme is compatible with alphabet sizes of up to 129 symbols,\n hence including literal symbol 128.\n * If any literal symbol > 128 has a non-zero `Weight`,\n direct representation is not possible.\n In such case, it's necessary to use FSE compression.\n\n\n#### Finite State Entropy (FSE) compression of Huffman weights\n\nIn this case, the series of Huffman weights is compressed using FSE compression.\nIt's a single bitstream with 2 interleaved states,\nsharing a single distribution table.\n\nTo decode an FSE bitstream, it is necessary to know its compressed size.\nCompressed size is provided by `headerByte`.\nIt's also necessary to know its _maximum possible_ decompressed size,\nwhich is `255`, since literal symbols span from `0` to `255`,\nand last symbol's `Weight` is not represented.\n\nAn FSE bitstream starts by a header, describing probabilities distribution.\nIt will create a Decoding Table.\nFor a list of Huffman weights, the maximum accuracy log is 6 bits.\nFor more description see the [FSE header description](#fse-table-description)\n\nThe Huffman header compression uses 2 states,\nwhich share the same FSE distribution table.\nThe first state (`State1`) encodes the even indexed symbols,\nand the second (`State2`) encodes the odd indexed symbols.\n`State1` is initialized first, and then `State2`, and they take turns\ndecoding a single symbol and updating their state.\nFor more details on these FSE operations, see the [FSE section](#fse).\n\nThe number of symbols to decode is determined\nby tracking bitStream overflow condition:\nIf updating state after decoding a symbol would require more bits than\nremain in the stream, it is assumed that extra bits are 0. Then,\nsymbols for each of the final states are decoded and the process is complete.\n\nIf this process would produce more weights than the maximum number of decoded\nweights (255), then the data is considered corrupted.\n\nIf either of the 2 initial states are absent or truncated, then the data is\nconsidered corrupted. Consequently, it is not possible to encode fewer than\n2 weights using this mode.\n\n#### Conversion from weights to Huffman prefix codes\n\nAll present symbols shall now have a `Weight` value.\nIt is possible to transform weights into `Number_of_Bits`, using this formula:\n```\nNumber_of_Bits = (Weight>0) ? Max_Number_of_Bits + 1 - Weight : 0\n```\nIn order to determine which prefix code is assigned to each Symbol,\nSymbols are first sorted by `Weight`, then by natural sequential order.\nSymbols with a `Weight` of zero are removed.\nThen, starting from lowest `Weight` (hence highest `Number_of_Bits`),\nprefix codes are assigned in ascending order.\n\n__Example__ :\nLet's assume the following list of weights has been decoded:\n\n| Literal | A | B | C | D | E | F |\n| -------- | --- | --- | --- | --- | --- | --- |\n| `Weight` | 4 | 3 | 2 | 0 | 1 | 1 |\n\nSorted by weight and then natural sequential order,\nit gives the following prefix codes distribution:\n\n| Literal | D | E | F | C | B | A |\n| ---------------- | --- | ---- | ---- | ---- | ---- | ---- |\n| `Weight` | 0 | 1 | 1 | 2 | 3 | 4 |\n| `Number_of_Bits` | 0 | 4 | 4 | 3 | 2 | 1 |\n| prefix code | N/A | 0000 | 0001 | 001 | 01 | 1 |\n| ascending order | N/A | 0000 | 0001 | 001x | 01xx | 1xxx |\n\n### Huffman-coded Streams\n\nGiven a Huffman decoding table,\nit's possible to decode a Huffman-coded stream.\n\nEach bitstream must be read _backward_,\nthat is starting from the end down to the beginning.\nTherefore it's necessary to know the size of each bitstream.\n\nIt's also necessary to know exactly which _bit_ is the last one.\nThis is detected by a final bit flag :\nthe highest bit of latest byte is a final-bit-flag.\nConsequently, a last byte of `0` is not possible.\nAnd the final-bit-flag itself is not part of the useful bitstream.\nHence, the last byte contains between 0 and 7 useful bits.\n\nStarting from the end,\nit's possible to read the bitstream in a __little-endian__ fashion,\nkeeping track of already used bits. Since the bitstream is encoded in reverse\norder, starting from the end read symbols in forward order.\n\nFor example, if the literal sequence `ABEF` was encoded using above prefix code,\nit would be encoded (in reverse order) as:\n\n|Symbol | F | E | B | A | Padding |\n|--------|------|------|----|---|---------|\n|Encoding|`0000`|`0001`|`01`|`1`| `00001` |\n\nResulting in following 2-bytes bitstream :\n```\n00010000 00001101\n```\n\nHere is an alternative representation with the symbol codes separated by underscore:\n```\n0001_0000 00001_1_01\n```\n\nReading highest `Max_Number_of_Bits` bits,\nit's possible to compare extracted value to decoding table,\ndetermining the symbol to decode and number of bits to discard.\n\nThe process continues up to reading the required number of symbols per stream.\nIf a bitstream is not entirely and exactly consumed,\nhence reaching exactly its beginning position with _all_ bits consumed,\nthe decoding process is considered faulty.\n\n\nDictionary Format\n-----------------\n\nZstandard is compatible with \"raw content\" dictionaries,\nfree of any format restriction, except that they must be at least 8 bytes.\nThese dictionaries function as if they were just the `Content` part\nof a formatted dictionary.\n\nBut dictionaries created by `zstd --train` follow a format, described here.\n\n__Pre-requisites__ : a dictionary has a size,\n defined either by a buffer limit, or a file size.\n\n| `Magic_Number` | `Dictionary_ID` | `Entropy_Tables` | `Content` |\n| -------------- | --------------- | ---------------- | --------- |\n\n__`Magic_Number`__ : 4 bytes ID, value 0xEC30A437, __little-endian__ format\n\n__`Dictionary_ID`__ : 4 bytes, stored in __little-endian__ format.\n `Dictionary_ID` can be any value, except 0 (which means no `Dictionary_ID`).\n It's used by decoders to check if they use the correct dictionary.\n\n_Reserved ranges :_\nIf the dictionary is going to be distributed in a public environment,\nthe following ranges of `Dictionary_ID` are reserved for some future registrar\nand shall not be used :\n\n - low range : <= 32767\n - high range : >= (2^31)\n\nOutside of these ranges, any value of `Dictionary_ID`\nwhich is both `>= 32768` and `< (1<<31)` can be used freely,\neven in public environment.\n\n\n__`Entropy_Tables`__ : follow the same format as tables in [compressed blocks].\n See the relevant [FSE](#fse-table-description)\n and [Huffman](#huffman-tree-description) sections for how to decode these tables.\n They are stored in following order :\n Huffman tables for literals, FSE table for offsets,\n FSE table for match lengths, and FSE table for literals lengths.\n These tables populate the Repeat Stats literals mode and\n Repeat distribution mode for sequence decoding.\n It's finally followed by 3 offset values, populating recent offsets (instead of using `{1,4,8}`),\n stored in order, 4-bytes __little-endian__ each, for a total of 12 bytes.\n Each recent offset must have a value <= dictionary content size, and cannot equal 0.\n\n__`Content`__ : The rest of the dictionary is its content.\n The content act as a \"past\" in front of data to compress or decompress,\n so it can be referenced in sequence commands.\n As long as the amount of data decoded from this frame is less than or\n equal to `Window_Size`, sequence commands may specify offsets longer\n than the total length of decoded output so far to reference back to the\n dictionary, even parts of the dictionary with offsets larger than `Window_Size`.\n After the total output has surpassed `Window_Size` however,\n this is no longer allowed and the dictionary is no longer accessible.\n\n[compressed blocks]: #the-format-of-compressed_block\n\nIf a dictionary is provided by an external source,\nit should be loaded with great care, its content considered untrusted.\n\n\n\nAppendix A - Decoding tables for predefined codes\n-------------------------------------------------\n\nThis appendix contains FSE decoding tables\nfor the predefined literal length, match length, and offset codes.\nThe tables have been constructed using the algorithm as given above in chapter\n\"from normalized distribution to decoding tables\".\nThe tables here can be used as examples\nto crosscheck that an implementation build its decoding tables correctly.\n\n#### Literal Length Code:\n\n| State | Symbol | Number_Of_Bits | Base |\n| ----- | ------ | -------------- | ---- |\n| 0 | 0 | 4 | 0 |\n| 1 | 0 | 4 | 16 |\n| 2 | 1 | 5 | 32 |\n| 3 | 3 | 5 | 0 |\n| 4 | 4 | 5 | 0 |\n| 5 | 6 | 5 | 0 |\n| 6 | 7 | 5 | 0 |\n| 7 | 9 | 5 | 0 |\n| 8 | 10 | 5 | 0 |\n| 9 | 12 | 5 | 0 |\n| 10 | 14 | 6 | 0 |\n| 11 | 16 | 5 | 0 |\n| 12 | 18 | 5 | 0 |\n| 13 | 19 | 5 | 0 |\n| 14 | 21 | 5 | 0 |\n| 15 | 22 | 5 | 0 |\n| 16 | 24 | 5 | 0 |\n| 17 | 25 | 5 | 32 |\n| 18 | 26 | 5 | 0 |\n| 19 | 27 | 6 | 0 |\n| 20 | 29 | 6 | 0 |\n| 21 | 31 | 6 | 0 |\n| 22 | 0 | 4 | 32 |\n| 23 | 1 | 4 | 0 |\n| 24 | 2 | 5 | 0 |\n| 25 | 4 | 5 | 32 |\n| 26 | 5 | 5 | 0 |\n| 27 | 7 | 5 | 32 |\n| 28 | 8 | 5 | 0 |\n| 29 | 10 | 5 | 32 |\n| 30 | 11 | 5 | 0 |\n| 31 | 13 | 6 | 0 |\n| 32 | 16 | 5 | 32 |\n| 33 | 17 | 5 | 0 |\n| 34 | 19 | 5 | 32 |\n| 35 | 20 | 5 | 0 |\n| 36 | 22 | 5 | 32 |\n| 37 | 23 | 5 | 0 |\n| 38 | 25 | 4 | 0 |\n| 39 | 25 | 4 | 16 |\n| 40 | 26 | 5 | 32 |\n| 41 | 28 | 6 | 0 |\n| 42 | 30 | 6 | 0 |\n| 43 | 0 | 4 | 48 |\n| 44 | 1 | 4 | 16 |\n| 45 | 2 | 5 | 32 |\n| 46 | 3 | 5 | 32 |\n| 47 | 5 | 5 | 32 |\n| 48 | 6 | 5 | 32 |\n| 49 | 8 | 5 | 32 |\n| 50 | 9 | 5 | 32 |\n| 51 | 11 | 5 | 32 |\n| 52 | 12 | 5 | 32 |\n| 53 | 15 | 6 | 0 |\n| 54 | 17 | 5 | 32 |\n| 55 | 18 | 5 | 32 |\n| 56 | 20 | 5 | 32 |\n| 57 | 21 | 5 | 32 |\n| 58 | 23 | 5 | 32 |\n| 59 | 24 | 5 | 32 |\n| 60 | 35 | 6 | 0 |\n| 61 | 34 | 6 | 0 |\n| 62 | 33 | 6 | 0 |\n| 63 | 32 | 6 | 0 |\n\n#### Match Length Code:\n\n| State | Symbol | Number_Of_Bits | Base |\n| ----- | ------ | -------------- | ---- |\n| 0 | 0 | 6 | 0 |\n| 1 | 1 | 4 | 0 |\n| 2 | 2 | 5 | 32 |\n| 3 | 3 | 5 | 0 |\n| 4 | 5 | 5 | 0 |\n| 5 | 6 | 5 | 0 |\n| 6 | 8 | 5 | 0 |\n| 7 | 10 | 6 | 0 |\n| 8 | 13 | 6 | 0 |\n| 9 | 16 | 6 | 0 |\n| 10 | 19 | 6 | 0 |\n| 11 | 22 | 6 | 0 |\n| 12 | 25 | 6 | 0 |\n| 13 | 28 | 6 | 0 |\n| 14 | 31 | 6 | 0 |\n| 15 | 33 | 6 | 0 |\n| 16 | 35 | 6 | 0 |\n| 17 | 37 | 6 | 0 |\n| 18 | 39 | 6 | 0 |\n| 19 | 41 | 6 | 0 |\n| 20 | 43 | 6 | 0 |\n| 21 | 45 | 6 | 0 |\n| 22 | 1 | 4 | 16 |\n| 23 | 2 | 4 | 0 |\n| 24 | 3 | 5 | 32 |\n| 25 | 4 | 5 | 0 |\n| 26 | 6 | 5 | 32 |\n| 27 | 7 | 5 | 0 |\n| 28 | 9 | 6 | 0 |\n| 29 | 12 | 6 | 0 |\n| 30 | 15 | 6 | 0 |\n| 31 | 18 | 6 | 0 |\n| 32 | 21 | 6 | 0 |\n| 33 | 24 | 6 | 0 |\n| 34 | 27 | 6 | 0 |\n| 35 | 30 | 6 | 0 |\n| 36 | 32 | 6 | 0 |\n| 37 | 34 | 6 | 0 |\n| 38 | 36 | 6 | 0 |\n| 39 | 38 | 6 | 0 |\n| 40 | 40 | 6 | 0 |\n| 41 | 42 | 6 | 0 |\n| 42 | 44 | 6 | 0 |\n| 43 | 1 | 4 | 32 |\n| 44 | 1 | 4 | 48 |\n| 45 | 2 | 4 | 16 |\n| 46 | 4 | 5 | 32 |\n| 47 | 5 | 5 | 32 |\n| 48 | 7 | 5 | 32 |\n| 49 | 8 | 5 | 32 |\n| 50 | 11 | 6 | 0 |\n| 51 | 14 | 6 | 0 |\n| 52 | 17 | 6 | 0 |\n| 53 | 20 | 6 | 0 |\n| 54 | 23 | 6 | 0 |\n| 55 | 26 | 6 | 0 |\n| 56 | 29 | 6 | 0 |\n| 57 | 52 | 6 | 0 |\n| 58 | 51 | 6 | 0 |\n| 59 | 50 | 6 | 0 |\n| 60 | 49 | 6 | 0 |\n| 61 | 48 | 6 | 0 |\n| 62 | 47 | 6 | 0 |\n| 63 | 46 | 6 | 0 |\n\n#### Offset Code:\n\n| State | Symbol | Number_Of_Bits | Base |\n| ----- | ------ | -------------- | ---- |\n| 0 | 0 | 5 | 0 |\n| 1 | 6 | 4 | 0 |\n| 2 | 9 | 5 | 0 |\n| 3 | 15 | 5 | 0 |\n| 4 | 21 | 5 | 0 |\n| 5 | 3 | 5 | 0 |\n| 6 | 7 | 4 | 0 |\n| 7 | 12 | 5 | 0 |\n| 8 | 18 | 5 | 0 |\n| 9 | 23 | 5 | 0 |\n| 10 | 5 | 5 | 0 |\n| 11 | 8 | 4 | 0 |\n| 12 | 14 | 5 | 0 |\n| 13 | 20 | 5 | 0 |\n| 14 | 2 | 5 | 0 |\n| 15 | 7 | 4 | 16 |\n| 16 | 11 | 5 | 0 |\n| 17 | 17 | 5 | 0 |\n| 18 | 22 | 5 | 0 |\n| 19 | 4 | 5 | 0 |\n| 20 | 8 | 4 | 16 |\n| 21 | 13 | 5 | 0 |\n| 22 | 19 | 5 | 0 |\n| 23 | 1 | 5 | 0 |\n| 24 | 6 | 4 | 16 |\n| 25 | 10 | 5 | 0 |\n| 26 | 16 | 5 | 0 |\n| 27 | 28 | 5 | 0 |\n| 28 | 27 | 5 | 0 |\n| 29 | 26 | 5 | 0 |\n| 30 | 25 | 5 | 0 |\n| 31 | 24 | 5 | 0 |\n\n\n\nAppendix B - Resources for implementers\n-------------------------------------------------\n\nAn open source reference implementation is available on :\nhttps://github.com/facebook/zstd\n\nThe project contains a frame generator, called [decodeCorpus],\nwhich can be used by any 3rd-party implementation\nto verify that a tested decoder is compliant with the specification.\n\n[decodeCorpus]: https://github.com/facebook/zstd/tree/v1.3.4/tests#decodecorpus---tool-to-generate-zstandard-frames-for-decoder-testing\n\n`decodeCorpus` generates random valid frames.\nA compliant decoder should be able to decode them all,\nor at least provide a meaningful error code explaining for which reason it cannot\n(memory limit restrictions for example).\n\n\nVersion changes\n---------------\n- 0.4.4 : minor clarification for block size\n- 0.4.3 : clarifications for Huffman prefix code assignment example\n- 0.4.2 : refactor FSE table construction process, inspired by Donald Pian\n- 0.4.1 : clarifications on a few error scenarios, by Eric Lasota\n- 0.4.0 : fixed imprecise behavior for nbSeq==0, detected by Igor Pavlov\n- 0.3.9 : clarifications for Huffman-compressed literal sizes.\n- 0.3.8 : clarifications for Huffman Blocks and Huffman Tree descriptions.\n- 0.3.7 : clarifications for Repeat_Offsets, matching RFC8878\n- 0.3.6 : clarifications for Dictionary_ID\n- 0.3.5 : clarifications for Block_Maximum_Size\n- 0.3.4 : clarifications for FSE decoding table\n- 0.3.3 : clarifications for field Block_Size\n- 0.3.2 : remove additional block size restriction on compressed blocks\n- 0.3.1 : minor clarification regarding offset history update rules\n- 0.3.0 : minor edits to match RFC8478\n- 0.2.9 : clarifications for huffman weights direct representation, by Ulrich Kunitz\n- 0.2.8 : clarifications for IETF RFC discuss\n- 0.2.7 : clarifications from IETF RFC review, by Vijay Gurbani and Nick Terrell\n- 0.2.6 : fixed an error in huffman example, by Ulrich Kunitz\n- 0.2.5 : minor typos and clarifications\n- 0.2.4 : section restructuring, by Sean Purcell\n- 0.2.3 : clarified several details, by Sean Purcell\n- 0.2.2 : added predefined codes, by Johannes Rudolph\n- 0.2.1 : clarify field names, by Przemyslaw Skibinski\n- 0.2.0 : numerous format adjustments for zstd v0.8+\n- 0.1.2 : limit Huffman tree depth to 11 bits\n- 0.1.1 : reserved dictID ranges\n- 0.1.0 : initial release\n" }, { "path": "doc/zstd_manual.html", "content": "\n\n\nzstd 1.5.7 Manual\n\n\n

zstd 1.5.7 Manual

\nNote: the content of this file has been automatically generated by parsing \"zstd.h\" \n
\n

Contents

\n
    \n
  1. Introduction
    2. \n
  2. Version
    3. \n
  3. Simple Core API
    4. \n
  4. Explicit context
    5. \n
  5. Advanced compression API (Requires v1.4.0+)
    6. \n
  6. Advanced decompression API (Requires v1.4.0+)
    7. \n
  7. Streaming
    8. \n
  8. Streaming compression - HowTo
    9. \n
  9. Streaming decompression - HowTo
    10. \n
  10. Simple dictionary API
    11. \n
  11. Bulk processing dictionary API
    12. \n
  12. Dictionary helper functions
    13. \n
  13. Advanced dictionary and prefix API (Requires v1.4.0+)
    14. \n
  14. experimental API (static linking only)
    15. \n
  15. Frame header and size functions
    16. \n
  16. Memory management
    17. \n
  17. Advanced compression functions
    18. \n
  18. Advanced decompression functions
    19. \n
  19. Advanced streaming functions
    20. \n
  20. Buffer-less and synchronous inner streaming functions (DEPRECATED)
    21. \n
  21. Buffer-less streaming compression (synchronous mode)
    22. \n
  22. Buffer-less streaming decompression (synchronous mode)
    23. \n
  23. Block level API (DEPRECATED)
    24. \n
\n
\n

Introduction

\n  zstd, short for Zstandard, is a fast lossless compression algorithm, targeting\n  real-time compression scenarios at zlib-level and better compression ratios.\n  The zstd compression library provides in-memory compression and decompression\n  functions.\n\n  The library supports regular compression levels from 1 up to ZSTD_maxCLevel(),\n  which is currently 22. Levels >= 20, labeled `--ultra`, should be used with\n  caution, as they require more memory. The library also offers negative\n  compression levels, which extend the range of speed vs. ratio preferences.\n  The lower the level, the faster the speed (at the cost of compression).\n\n  Compression can be done in:\n    - a single step (described as Simple API)\n    - a single step, reusing a context (described as Explicit context)\n    - unbounded multiple steps (described as Streaming compression)\n\n  The compression ratio achievable on small data can be highly improved using\n  a dictionary. Dictionary compression can be performed in:\n    - a single step (described as Simple dictionary API)\n    - a single step, reusing a dictionary (described as Bulk-processing\n      dictionary API)\n\n  Advanced experimental functions can be accessed using\n  `#define ZSTD_STATIC_LINKING_ONLY` before including zstd.h.\n\n  Advanced experimental APIs should never be used with a dynamically-linked\n  library. They are not \"stable\"; their definitions or signatures may change in\n  the future. Only static linking is allowed.\n
\n\n

Version

\n\n
unsigned ZSTD_versionNumber(void);\n
  Return runtime library version, the value is (MAJOR*100*100 + MINOR*100 + RELEASE). \n

\n\n
const char* ZSTD_versionString(void);\n
  Return runtime library version, like \"1.4.5\". Requires v1.3.0+. \n

\n\n
Simple Core API
\n\n
size_t ZSTD_compress( void* dst, size_t dstCapacity,\n                const void* src, size_t srcSize,\n                      int compressionLevel);\n
  Compresses `src` content as a single zstd compressed frame into already allocated `dst`.\n  NOTE: Providing `dstCapacity >= ZSTD_compressBound(srcSize)` guarantees that zstd will have\n        enough space to successfully compress the data.\n  @return : compressed size written into `dst` (<= `dstCapacity),\n            or an error code if it fails (which can be tested using ZSTD_isError()). \n

\n\n
size_t ZSTD_decompress( void* dst, size_t dstCapacity,\n                  const void* src, size_t compressedSize);\n
 `compressedSize` : must be the _exact_ size of some number of compressed and/or skippable frames.\n  Multiple compressed frames can be decompressed at once with this method.\n  The result will be the concatenation of all decompressed frames, back to back.\n `dstCapacity` is an upper bound of originalSize to regenerate.\n  First frame's decompressed size can be extracted using ZSTD_getFrameContentSize().\n  If maximum upper bound isn't known, prefer using streaming mode to decompress data.\n @return : the number of bytes decompressed into `dst` (<= `dstCapacity`),\n           or an errorCode if it fails (which can be tested using ZSTD_isError()). \n

\n\n
Decompression helper functions

\n
#define ZSTD_CONTENTSIZE_UNKNOWN (0ULL - 1)\n#define ZSTD_CONTENTSIZE_ERROR   (0ULL - 2)\nunsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize);\n
 `src` should point to the start of a ZSTD encoded frame.\n `srcSize` must be at least as large as the frame header.\n           hint : any size >= `ZSTD_frameHeaderSize_max` is large enough.\n @return : - decompressed size of `src` frame content, if known\n           - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined\n           - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small)\n  note 1 : a 0 return value means the frame is valid but \"empty\".\n           When invoking this method on a skippable frame, it will return 0.\n  note 2 : decompressed size is an optional field, it may not be present (typically in streaming mode).\n           When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size.\n           In which case, it's necessary to use streaming mode to decompress data.\n           Optionally, application can rely on some implicit limit,\n           as ZSTD_decompress() only needs an upper bound of decompressed size.\n           (For example, data could be necessarily cut into blocks <= 16 KB).\n  note 3 : decompressed size is always present when compression is completed using single-pass functions,\n           such as ZSTD_compress(), ZSTD_compressCCtx() ZSTD_compress_usingDict() or ZSTD_compress_usingCDict().\n  note 4 : decompressed size can be very large (64-bits value),\n           potentially larger than what local system can handle as a single memory segment.\n           In which case, it's necessary to use streaming mode to decompress data.\n  note 5 : If source is untrusted, decompressed size could be wrong or intentionally modified.\n           Always ensure return value fits within application's authorized limits.\n           Each application can set its own limits.\n  note 6 : This function replaces ZSTD_getDecompressedSize() \n

\n\n
ZSTD_DEPRECATED(\"Replaced by ZSTD_getFrameContentSize\")\nunsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize);\n
  This function is now obsolete, in favor of ZSTD_getFrameContentSize().\n  Both functions work the same way, but ZSTD_getDecompressedSize() blends\n  \"empty\", \"unknown\" and \"error\" results to the same return value (0),\n  while ZSTD_getFrameContentSize() gives them separate return values.\n @return : decompressed size of `src` frame content _if known and not empty_, 0 otherwise. \n

\n\n
size_t ZSTD_findFrameCompressedSize(const void* src, size_t srcSize);\n
 `src` should point to the start of a ZSTD frame or skippable frame.\n `srcSize` must be >= first frame size\n @return : the compressed size of the first frame starting at `src`,\n           suitable to pass as `srcSize` to `ZSTD_decompress` or similar,\n           or an error code if input is invalid\n  Note 1: this method is called _find*() because it's not enough to read the header,\n          it may have to scan through the frame's content, to reach its end.\n  Note 2: this method also works with Skippable Frames. In which case,\n          it returns the size of the complete skippable frame,\n          which is always equal to its content size + 8 bytes for headers. \n

\n\n
Compression helper functions

\n
#define ZSTD_MAX_INPUT_SIZE ((sizeof(size_t)==8) ? 0xFF00FF00FF00FF00ULL : 0xFF00FF00U)\n#define ZSTD_COMPRESSBOUND(srcSize)   (((size_t)(srcSize) >= ZSTD_MAX_INPUT_SIZE) ? 0 : (srcSize) + ((srcSize)>>8) + (((srcSize) < (128<<10)) ? (((128<<10) - (srcSize)) >> 11) /* margin, from 64 to 0 */ : 0))  /* this formula ensures that bound(A) + bound(B) <= bound(A+B) as long as A and B >= 128 KB */\nsize_t ZSTD_compressBound(size_t srcSize); /*!< maximum compressed size in worst case single-pass scenario */\n
 maximum compressed size in worst case single-pass scenario.\n When invoking `ZSTD_compress()`, or any other one-pass compression function,\n it's recommended to provide @dstCapacity >= ZSTD_compressBound(srcSize)\n as it eliminates one potential failure scenario,\n aka not enough room in dst buffer to write the compressed frame.\n Note : ZSTD_compressBound() itself can fail, if @srcSize >= ZSTD_MAX_INPUT_SIZE .\n        In which case, ZSTD_compressBound() will return an error code\n        which can be tested using ZSTD_isError().\n\n ZSTD_COMPRESSBOUND() :\n same as ZSTD_compressBound(), but as a macro.\n It can be used to produce constants, which can be useful for static allocation,\n for example to size a static array on stack.\n Will produce constant value 0 if srcSize is too large.\n \n

\n\n
Error helper functions
/* ZSTD_isError() :\n * Most ZSTD_* functions returning a size_t value can be tested for error,\n * using ZSTD_isError().\n * @return 1 if error, 0 otherwise\n */\nunsigned     ZSTD_isError(size_t result);      /*!< tells if a `size_t` function result is an error code */\nZSTD_ErrorCode ZSTD_getErrorCode(size_t functionResult); /* convert a result into an error code, which can be compared to error enum list */\nconst char*  ZSTD_getErrorName(size_t result); /*!< provides readable string from a function result */\nint          ZSTD_minCLevel(void);             /*!< minimum negative compression level allowed, requires v1.4.0+ */\nint          ZSTD_maxCLevel(void);             /*!< maximum compression level available */\nint          ZSTD_defaultCLevel(void);         /*!< default compression level, specified by ZSTD_CLEVEL_DEFAULT, requires v1.5.0+ */\n

\n
Explicit context
\n\n
Compression context
  When compressing many times,\n  it is recommended to allocate a compression context just once,\n  and reuse it for each successive compression operation.\n  This will make the workload easier for system's memory.\n  Note : re-using context is just a speed / resource optimization.\n         It doesn't change the compression ratio, which remains identical.\n  Note 2: For parallel execution in multi-threaded environments,\n         use one different context per thread .\n \n
typedef struct ZSTD_CCtx_s ZSTD_CCtx;\nZSTD_CCtx* ZSTD_createCCtx(void);\nsize_t     ZSTD_freeCCtx(ZSTD_CCtx* cctx);  /* compatible with NULL pointer */\n

\n
size_t ZSTD_compressCCtx(ZSTD_CCtx* cctx,\n                         void* dst, size_t dstCapacity,\n                   const void* src, size_t srcSize,\n                         int compressionLevel);\n
  Same as ZSTD_compress(), using an explicit ZSTD_CCtx.\n  Important : in order to mirror `ZSTD_compress()` behavior,\n  this function compresses at the requested compression level,\n  __ignoring any other advanced parameter__ .\n  If any advanced parameter was set using the advanced API,\n  they will all be reset. Only @compressionLevel remains.\n \n

\n\n
Decompression context
  When decompressing many times,\n  it is recommended to allocate a context only once,\n  and reuse it for each successive compression operation.\n  This will make workload friendlier for system's memory.\n  Use one context per thread for parallel execution. \n
typedef struct ZSTD_DCtx_s ZSTD_DCtx;\nZSTD_DCtx* ZSTD_createDCtx(void);\nsize_t     ZSTD_freeDCtx(ZSTD_DCtx* dctx);  /* accept NULL pointer */\n

\n
size_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx,\n                           void* dst, size_t dstCapacity,\n                     const void* src, size_t srcSize);\n
  Same as ZSTD_decompress(),\n  requires an allocated ZSTD_DCtx.\n  Compatible with sticky parameters (see below).\n \n

\n\n
Advanced compression API (Requires v1.4.0+)
\n\n
typedef enum { ZSTD_fast=1,\n               ZSTD_dfast=2,\n               ZSTD_greedy=3,\n               ZSTD_lazy=4,\n               ZSTD_lazy2=5,\n               ZSTD_btlazy2=6,\n               ZSTD_btopt=7,\n               ZSTD_btultra=8,\n               ZSTD_btultra2=9\n               /* note : new strategies _might_ be added in the future.\n                         Only the order (from fast to strong) is guaranteed */\n} ZSTD_strategy;\n

\n
typedef enum {\n\n    /* compression parameters\n     * Note: When compressing with a ZSTD_CDict these parameters are superseded\n     * by the parameters used to construct the ZSTD_CDict.\n     * See ZSTD_CCtx_refCDict() for more info (superseded-by-cdict). */\n    ZSTD_c_compressionLevel=100, /* Set compression parameters according to pre-defined cLevel table.\n                              * Note that exact compression parameters are dynamically determined,\n                              * depending on both compression level and srcSize (when known).\n                              * Default level is ZSTD_CLEVEL_DEFAULT==3.\n                              * Special: value 0 means default, which is controlled by ZSTD_CLEVEL_DEFAULT.\n                              * Note 1 : it's possible to pass a negative compression level.\n                              * Note 2 : setting a level does not automatically set all other compression parameters\n                              *   to default. Setting this will however eventually dynamically impact the compression\n                              *   parameters which have not been manually set. The manually set\n                              *   ones will 'stick'. */\n    /* Advanced compression parameters :\n     * It's possible to pin down compression parameters to some specific values.\n     * In which case, these values are no longer dynamically selected by the compressor */\n    ZSTD_c_windowLog=101,    /* Maximum allowed back-reference distance, expressed as power of 2.\n                              * This will set a memory budget for streaming decompression,\n                              * with larger values requiring more memory\n                              * and typically compressing more.\n                              * Must be clamped between ZSTD_WINDOWLOG_MIN and ZSTD_WINDOWLOG_MAX.\n                              * Special: value 0 means \"use default windowLog\".\n                              * Note: Using a windowLog greater than ZSTD_WINDOWLOG_LIMIT_DEFAULT\n                              *       requires explicitly allowing such size at streaming decompression stage. */\n    ZSTD_c_hashLog=102,      /* Size of the initial probe table, as a power of 2.\n                              * Resulting memory usage is (1 << (hashLog+2)).\n                              * Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX.\n                              * Larger tables improve compression ratio of strategies <= dFast,\n                              * and improve speed of strategies > dFast.\n                              * Special: value 0 means \"use default hashLog\". */\n    ZSTD_c_chainLog=103,     /* Size of the multi-probe search table, as a power of 2.\n                              * Resulting memory usage is (1 << (chainLog+2)).\n                              * Must be clamped between ZSTD_CHAINLOG_MIN and ZSTD_CHAINLOG_MAX.\n                              * Larger tables result in better and slower compression.\n                              * This parameter is useless for \"fast\" strategy.\n                              * It's still useful when using \"dfast\" strategy,\n                              * in which case it defines a secondary probe table.\n                              * Special: value 0 means \"use default chainLog\". */\n    ZSTD_c_searchLog=104,    /* Number of search attempts, as a power of 2.\n                              * More attempts result in better and slower compression.\n                              * This parameter is useless for \"fast\" and \"dFast\" strategies.\n                              * Special: value 0 means \"use default searchLog\". */\n    ZSTD_c_minMatch=105,     /* Minimum size of searched matches.\n                              * Note that Zstandard can still find matches of smaller size,\n                              * it just tweaks its search algorithm to look for this size and larger.\n                              * Larger values increase compression and decompression speed, but decrease ratio.\n                              * Must be clamped between ZSTD_MINMATCH_MIN and ZSTD_MINMATCH_MAX.\n                              * Note that currently, for all strategies < btopt, effective minimum is 4.\n                              *                    , for all strategies > fast, effective maximum is 6.\n                              * Special: value 0 means \"use default minMatchLength\". */\n    ZSTD_c_targetLength=106, /* Impact of this field depends on strategy.\n                              * For strategies btopt, btultra & btultra2:\n                              *     Length of Match considered \"good enough\" to stop search.\n                              *     Larger values make compression stronger, and slower.\n                              * For strategy fast:\n                              *     Distance between match sampling.\n                              *     Larger values make compression faster, and weaker.\n                              * Special: value 0 means \"use default targetLength\". */\n    ZSTD_c_strategy=107,     /* See ZSTD_strategy enum definition.\n                              * The higher the value of selected strategy, the more complex it is,\n                              * resulting in stronger and slower compression.\n                              * Special: value 0 means \"use default strategy\". */\n\n    ZSTD_c_targetCBlockSize=130, /* v1.5.6+\n                                  * Attempts to fit compressed block size into approximately targetCBlockSize.\n                                  * Bound by ZSTD_TARGETCBLOCKSIZE_MIN and ZSTD_TARGETCBLOCKSIZE_MAX.\n                                  * Note that it's not a guarantee, just a convergence target (default:0).\n                                  * No target when targetCBlockSize == 0.\n                                  * This is helpful in low bandwidth streaming environments to improve end-to-end latency,\n                                  * when a client can make use of partial documents (a prominent example being Chrome).\n                                  * Note: this parameter is stable since v1.5.6.\n                                  * It was present as an experimental parameter in earlier versions,\n                                  * but it's not recommended using it with earlier library versions\n                                  * due to massive performance regressions.\n                                  */\n    /* LDM mode parameters */\n    ZSTD_c_enableLongDistanceMatching=160, /* Enable long distance matching.\n                                     * This parameter is designed to improve compression ratio\n                                     * for large inputs, by finding large matches at long distance.\n                                     * It increases memory usage and window size.\n                                     * Note: enabling this parameter increases default ZSTD_c_windowLog to 128 MB\n                                     * except when expressly set to a different value.\n                                     * Note: will be enabled by default if ZSTD_c_windowLog >= 128 MB and\n                                     * compression strategy >= ZSTD_btopt (== compression level 16+) */\n    ZSTD_c_ldmHashLog=161,   /* Size of the table for long distance matching, as a power of 2.\n                              * Larger values increase memory usage and compression ratio,\n                              * but decrease compression speed.\n                              * Must be clamped between ZSTD_HASHLOG_MIN and ZSTD_HASHLOG_MAX\n                              * default: windowlog - 7.\n                              * Special: value 0 means \"automatically determine hashlog\". */\n    ZSTD_c_ldmMinMatch=162,  /* Minimum match size for long distance matcher.\n                              * Larger/too small values usually decrease compression ratio.\n                              * Must be clamped between ZSTD_LDM_MINMATCH_MIN and ZSTD_LDM_MINMATCH_MAX.\n                              * Special: value 0 means \"use default value\" (default: 64). */\n    ZSTD_c_ldmBucketSizeLog=163, /* Log size of each bucket in the LDM hash table for collision resolution.\n                              * Larger values improve collision resolution but decrease compression speed.\n                              * The maximum value is ZSTD_LDM_BUCKETSIZELOG_MAX.\n                              * Special: value 0 means \"use default value\" (default: 3). */\n    ZSTD_c_ldmHashRateLog=164, /* Frequency of inserting/looking up entries into the LDM hash table.\n                              * Must be clamped between 0 and (ZSTD_WINDOWLOG_MAX - ZSTD_HASHLOG_MIN).\n                              * Default is MAX(0, (windowLog - ldmHashLog)), optimizing hash table usage.\n                              * Larger values improve compression speed.\n                              * Deviating far from default value will likely result in a compression ratio decrease.\n                              * Special: value 0 means \"automatically determine hashRateLog\". */\n\n    /* frame parameters */\n    ZSTD_c_contentSizeFlag=200, /* Content size will be written into frame header _whenever known_ (default:1)\n                              * Content size must be known at the beginning of compression.\n                              * This is automatically the case when using ZSTD_compress2(),\n                              * For streaming scenarios, content size must be provided with ZSTD_CCtx_setPledgedSrcSize() */\n    ZSTD_c_checksumFlag=201, /* A 32-bits checksum of content is written at end of frame (default:0) */\n    ZSTD_c_dictIDFlag=202,   /* When applicable, dictionary's ID is written into frame header (default:1) */\n\n    /* multi-threading parameters */\n    /* These parameters are only active if multi-threading is enabled (compiled with build macro ZSTD_MULTITHREAD).\n     * Otherwise, trying to set any other value than default (0) will be a no-op and return an error.\n     * In a situation where it's unknown if the linked library supports multi-threading or not,\n     * setting ZSTD_c_nbWorkers to any value >= 1 and consulting the return value provides a quick way to check this property.\n     */\n    ZSTD_c_nbWorkers=400,    /* Select how many threads will be spawned to compress in parallel.\n                              * When nbWorkers >= 1, triggers asynchronous mode when invoking ZSTD_compressStream*() :\n                              * ZSTD_compressStream*() consumes input and flush output if possible, but immediately gives back control to caller,\n                              * while compression is performed in parallel, within worker thread(s).\n                              * (note : a strong exception to this rule is when first invocation of ZSTD_compressStream2() sets ZSTD_e_end :\n                              *  in which case, ZSTD_compressStream2() delegates to ZSTD_compress2(), which is always a blocking call).\n                              * More workers improve speed, but also increase memory usage.\n                              * Default value is `0`, aka \"single-threaded mode\" : no worker is spawned,\n                              * compression is performed inside Caller's thread, and all invocations are blocking */\n    ZSTD_c_jobSize=401,      /* Size of a compression job. This value is enforced only when nbWorkers >= 1.\n                              * Each compression job is completed in parallel, so this value can indirectly impact the nb of active threads.\n                              * 0 means default, which is dynamically determined based on compression parameters.\n                              * Job size must be a minimum of overlap size, or ZSTDMT_JOBSIZE_MIN (= 512 KB), whichever is largest.\n                              * The minimum size is automatically and transparently enforced. */\n    ZSTD_c_overlapLog=402,   /* Control the overlap size, as a fraction of window size.\n                              * The overlap size is an amount of data reloaded from previous job at the beginning of a new job.\n                              * It helps preserve compression ratio, while each job is compressed in parallel.\n                              * This value is enforced only when nbWorkers >= 1.\n                              * Larger values increase compression ratio, but decrease speed.\n                              * Possible values range from 0 to 9 :\n                              * - 0 means \"default\" : value will be determined by the library, depending on strategy\n                              * - 1 means \"no overlap\"\n                              * - 9 means \"full overlap\", using a full window size.\n                              * Each intermediate rank increases/decreases load size by a factor 2 :\n                              * 9: full window;  8: w/2;  7: w/4;  6: w/8;  5:w/16;  4: w/32;  3:w/64;  2:w/128;  1:no overlap;  0:default\n                              * default value varies between 6 and 9, depending on strategy */\n\n    /* note : additional experimental parameters are also available\n     * within the experimental section of the API.\n     * At the time of this writing, they include :\n     * ZSTD_c_rsyncable\n     * ZSTD_c_format\n     * ZSTD_c_forceMaxWindow\n     * ZSTD_c_forceAttachDict\n     * ZSTD_c_literalCompressionMode\n     * ZSTD_c_srcSizeHint\n     * ZSTD_c_enableDedicatedDictSearch\n     * ZSTD_c_stableInBuffer\n     * ZSTD_c_stableOutBuffer\n     * ZSTD_c_blockDelimiters\n     * ZSTD_c_validateSequences\n     * ZSTD_c_blockSplitterLevel\n     * ZSTD_c_splitAfterSequences\n     * ZSTD_c_useRowMatchFinder\n     * ZSTD_c_prefetchCDictTables\n     * ZSTD_c_enableSeqProducerFallback\n     * ZSTD_c_maxBlockSize\n     * Because they are not stable, it's necessary to define ZSTD_STATIC_LINKING_ONLY to access them.\n     * note : never ever use experimentalParam? names directly;\n     *        also, the enums values themselves are unstable and can still change.\n     */\n     ZSTD_c_experimentalParam1=500,\n     ZSTD_c_experimentalParam2=10,\n     ZSTD_c_experimentalParam3=1000,\n     ZSTD_c_experimentalParam4=1001,\n     ZSTD_c_experimentalParam5=1002,\n     /* was ZSTD_c_experimentalParam6=1003; is now ZSTD_c_targetCBlockSize */\n     ZSTD_c_experimentalParam7=1004,\n     ZSTD_c_experimentalParam8=1005,\n     ZSTD_c_experimentalParam9=1006,\n     ZSTD_c_experimentalParam10=1007,\n     ZSTD_c_experimentalParam11=1008,\n     ZSTD_c_experimentalParam12=1009,\n     ZSTD_c_experimentalParam13=1010,\n     ZSTD_c_experimentalParam14=1011,\n     ZSTD_c_experimentalParam15=1012,\n     ZSTD_c_experimentalParam16=1013,\n     ZSTD_c_experimentalParam17=1014,\n     ZSTD_c_experimentalParam18=1015,\n     ZSTD_c_experimentalParam19=1016,\n     ZSTD_c_experimentalParam20=1017\n} ZSTD_cParameter;\n

\n
typedef struct {\n    size_t error;\n    int lowerBound;\n    int upperBound;\n} ZSTD_bounds;\n

\n
ZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter cParam);\n
  All parameters must belong to an interval with lower and upper bounds,\n  otherwise they will either trigger an error or be automatically clamped.\n @return : a structure, ZSTD_bounds, which contains\n         - an error status field, which must be tested using ZSTD_isError()\n         - lower and upper bounds, both inclusive\n \n

\n\n
size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value);\n
  Set one compression parameter, selected by enum ZSTD_cParameter.\n  All parameters have valid bounds. Bounds can be queried using ZSTD_cParam_getBounds().\n  Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter).\n  Setting a parameter is generally only possible during frame initialization (before starting compression).\n  Exception : when using multi-threading mode (nbWorkers >= 1),\n              the following parameters can be updated _during_ compression (within same frame):\n              => compressionLevel, hashLog, chainLog, searchLog, minMatch, targetLength and strategy.\n              new parameters will be active for next job only (after a flush()).\n @return : an error code (which can be tested using ZSTD_isError()).\n \n

\n\n
size_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize);\n
  Total input data size to be compressed as a single frame.\n  Value will be written in frame header, unless if explicitly forbidden using ZSTD_c_contentSizeFlag.\n  This value will also be controlled at end of frame, and trigger an error if not respected.\n @result : 0, or an error code (which can be tested with ZSTD_isError()).\n  Note 1 : pledgedSrcSize==0 actually means zero, aka an empty frame.\n           In order to mean \"unknown content size\", pass constant ZSTD_CONTENTSIZE_UNKNOWN.\n           ZSTD_CONTENTSIZE_UNKNOWN is default value for any new frame.\n  Note 2 : pledgedSrcSize is only valid once, for the next frame.\n           It's discarded at the end of the frame, and replaced by ZSTD_CONTENTSIZE_UNKNOWN.\n  Note 3 : Whenever all input data is provided and consumed in a single round,\n           for example with ZSTD_compress2(),\n           or invoking immediately ZSTD_compressStream2(,,,ZSTD_e_end),\n           this value is automatically overridden by srcSize instead.\n \n

\n\n
typedef enum {\n    ZSTD_reset_session_only = 1,\n    ZSTD_reset_parameters = 2,\n    ZSTD_reset_session_and_parameters = 3\n} ZSTD_ResetDirective;\n

\n
size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset);\n
  There are 2 different things that can be reset, independently or jointly :\n  - The session : will stop compressing current frame, and make CCtx ready to start a new one.\n                  Useful after an error, or to interrupt any ongoing compression.\n                  Any internal data not yet flushed is cancelled.\n                  Compression parameters and dictionary remain unchanged.\n                  They will be used to compress next frame.\n                  Resetting session never fails.\n  - The parameters : changes all parameters back to \"default\".\n                  This also removes any reference to any dictionary or external sequence producer.\n                  Parameters can only be changed between 2 sessions (i.e. no compression is currently ongoing)\n                  otherwise the reset fails, and function returns an error value (which can be tested using ZSTD_isError())\n  - Both : similar to resetting the session, followed by resetting parameters.\n \n

\n\n
size_t ZSTD_compress2( ZSTD_CCtx* cctx,\n                       void* dst, size_t dstCapacity,\n                 const void* src, size_t srcSize);\n
  Behave the same as ZSTD_compressCCtx(), but compression parameters are set using the advanced API.\n  (note that this entry point doesn't even expose a compression level parameter).\n  ZSTD_compress2() always starts a new frame.\n  Should cctx hold data from a previously unfinished frame, everything about it is forgotten.\n  - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()\n  - The function is always blocking, returns when compression is completed.\n  NOTE: Providing `dstCapacity >= ZSTD_compressBound(srcSize)` guarantees that zstd will have\n        enough space to successfully compress the data, though it is possible it fails for other reasons.\n @return : compressed size written into `dst` (<= `dstCapacity),\n           or an error code if it fails (which can be tested using ZSTD_isError()).\n \n

\n\n
Advanced decompression API (Requires v1.4.0+)
\n\n
typedef enum {\n\n    ZSTD_d_windowLogMax=100, /* Select a size limit (in power of 2) beyond which\n                              * the streaming API will refuse to allocate memory buffer\n                              * in order to protect the host from unreasonable memory requirements.\n                              * This parameter is only useful in streaming mode, since no internal buffer is allocated in single-pass mode.\n                              * By default, a decompression context accepts window sizes <= (1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT).\n                              * Special: value 0 means \"use default maximum windowLog\". */\n\n    /* note : additional experimental parameters are also available\n     * within the experimental section of the API.\n     * At the time of this writing, they include :\n     * ZSTD_d_format\n     * ZSTD_d_stableOutBuffer\n     * ZSTD_d_forceIgnoreChecksum\n     * ZSTD_d_refMultipleDDicts\n     * ZSTD_d_disableHuffmanAssembly\n     * ZSTD_d_maxBlockSize\n     * Because they are not stable, it's necessary to define ZSTD_STATIC_LINKING_ONLY to access them.\n     * note : never ever use experimentalParam? names directly\n     */\n     ZSTD_d_experimentalParam1=1000,\n     ZSTD_d_experimentalParam2=1001,\n     ZSTD_d_experimentalParam3=1002,\n     ZSTD_d_experimentalParam4=1003,\n     ZSTD_d_experimentalParam5=1004,\n     ZSTD_d_experimentalParam6=1005\n\n} ZSTD_dParameter;\n

\n
ZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam);\n
  All parameters must belong to an interval with lower and upper bounds,\n  otherwise they will either trigger an error or be automatically clamped.\n @return : a structure, ZSTD_bounds, which contains\n         - an error status field, which must be tested using ZSTD_isError()\n         - both lower and upper bounds, inclusive\n \n

\n\n
size_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int value);\n
  Set one compression parameter, selected by enum ZSTD_dParameter.\n  All parameters have valid bounds. Bounds can be queried using ZSTD_dParam_getBounds().\n  Providing a value beyond bound will either clamp it, or trigger an error (depending on parameter).\n  Setting a parameter is only possible during frame initialization (before starting decompression).\n @return : 0, or an error code (which can be tested using ZSTD_isError()).\n \n

\n\n
size_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset);\n
  Return a DCtx to clean state.\n  Session and parameters can be reset jointly or separately.\n  Parameters can only be reset when no active frame is being decompressed.\n @return : 0, or an error code, which can be tested with ZSTD_isError()\n \n

\n\n
Streaming
\n\n
typedef struct ZSTD_inBuffer_s {\n  const void* src;    /**< start of input buffer */\n  size_t size;        /**< size of input buffer */\n  size_t pos;         /**< position where reading stopped. Will be updated. Necessarily 0 <= pos <= size */\n} ZSTD_inBuffer;\n

\n
typedef struct ZSTD_outBuffer_s {\n  void*  dst;         /**< start of output buffer */\n  size_t size;        /**< size of output buffer */\n  size_t pos;         /**< position where writing stopped. Will be updated. Necessarily 0 <= pos <= size */\n} ZSTD_outBuffer;\n

\n
Streaming compression - HowTo
\n  A ZSTD_CStream object is required to track streaming operation.\n  Use ZSTD_createCStream() and ZSTD_freeCStream() to create/release resources.\n  ZSTD_CStream objects can be reused multiple times on consecutive compression operations.\n  It is recommended to reuse ZSTD_CStream since it will play nicer with system's memory, by re-using already allocated memory.\n\n  For parallel execution, use one separate ZSTD_CStream per thread.\n\n  note : since v1.3.0, ZSTD_CStream and ZSTD_CCtx are the same thing.\n\n  Parameters are sticky : when starting a new compression on the same context,\n  it will reuse the same sticky parameters as previous compression session.\n  When in doubt, it's recommended to fully initialize the context before usage.\n  Use ZSTD_CCtx_reset() to reset the context and ZSTD_CCtx_setParameter(),\n  ZSTD_CCtx_setPledgedSrcSize(), or ZSTD_CCtx_loadDictionary() and friends to\n  set more specific parameters, the pledged source size, or load a dictionary.\n\n  Use ZSTD_compressStream2() with ZSTD_e_continue as many times as necessary to\n  consume input stream. The function will automatically update both `pos`\n  fields within `input` and `output`.\n  Note that the function may not consume the entire input, for example, because\n  the output buffer is already full, in which case `input.pos < input.size`.\n  The caller must check if input has been entirely consumed.\n  If not, the caller must make some room to receive more compressed data,\n  and then present again remaining input data.\n  note: ZSTD_e_continue is guaranteed to make some forward progress when called,\n        but doesn't guarantee maximal forward progress. This is especially relevant\n        when compressing with multiple threads. The call won't block if it can\n        consume some input, but if it can't it will wait for some, but not all,\n        output to be flushed.\n @return : provides a minimum amount of data remaining to be flushed from internal buffers\n           or an error code, which can be tested using ZSTD_isError().\n\n  At any moment, it's possible to flush whatever data might remain stuck within internal buffer,\n  using ZSTD_compressStream2() with ZSTD_e_flush. `output->pos` will be updated.\n  Note that, if `output->size` is too small, a single invocation with ZSTD_e_flush might not be enough (return code > 0).\n  In which case, make some room to receive more compressed data, and call again ZSTD_compressStream2() with ZSTD_e_flush.\n  You must continue calling ZSTD_compressStream2() with ZSTD_e_flush until it returns 0, at which point you can change the\n  operation.\n  note: ZSTD_e_flush will flush as much output as possible, meaning when compressing with multiple threads, it will\n        block until the flush is complete or the output buffer is full.\n  @return : 0 if internal buffers are entirely flushed,\n            >0 if some data still present within internal buffer (the value is minimal estimation of remaining size),\n            or an error code, which can be tested using ZSTD_isError().\n\n  Calling ZSTD_compressStream2() with ZSTD_e_end instructs to finish a frame.\n  It will perform a flush and write frame epilogue.\n  The epilogue is required for decoders to consider a frame completed.\n  flush operation is the same, and follows same rules as calling ZSTD_compressStream2() with ZSTD_e_flush.\n  You must continue calling ZSTD_compressStream2() with ZSTD_e_end until it returns 0, at which point you are free to\n  start a new frame.\n  note: ZSTD_e_end will flush as much output as possible, meaning when compressing with multiple threads, it will\n        block until the flush is complete or the output buffer is full.\n  @return : 0 if frame fully completed and fully flushed,\n            >0 if some data still present within internal buffer (the value is minimal estimation of remaining size),\n            or an error code, which can be tested using ZSTD_isError().\n\n \n
\n\n
typedef ZSTD_CCtx ZSTD_CStream;  /**< CCtx and CStream are now effectively same object (>= v1.3.0) */\n

\n
ZSTD_CStream management functions
ZSTD_CStream* ZSTD_createCStream(void);\nsize_t ZSTD_freeCStream(ZSTD_CStream* zcs);  /* accept NULL pointer */\n

\n
Streaming compression functions
typedef enum {\n    ZSTD_e_continue=0, /* collect more data, encoder decides when to output compressed result, for optimal compression ratio */\n    ZSTD_e_flush=1,    /* flush any data provided so far,\n                        * it creates (at least) one new block, that can be decoded immediately on reception;\n                        * frame will continue: any future data can still reference previously compressed data, improving compression.\n                        * note : multithreaded compression will block to flush as much output as possible. */\n    ZSTD_e_end=2       /* flush any remaining data _and_ close current frame.\n                        * note that frame is only closed after compressed data is fully flushed (return value == 0).\n                        * After that point, any additional data starts a new frame.\n                        * note : each frame is independent (does not reference any content from previous frame).\n                        : note : multithreaded compression will block to flush as much output as possible. */\n} ZSTD_EndDirective;\n

\n
size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,\n                             ZSTD_outBuffer* output,\n                             ZSTD_inBuffer* input,\n                             ZSTD_EndDirective endOp);\n
  Behaves about the same as ZSTD_compressStream, with additional control on end directive.\n  - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()\n  - Compression parameters cannot be changed once compression is started (save a list of exceptions in multi-threading mode)\n  - output->pos must be <= dstCapacity, input->pos must be <= srcSize\n  - output->pos and input->pos will be updated. They are guaranteed to remain below their respective limit.\n  - endOp must be a valid directive\n  - When nbWorkers==0 (default), function is blocking : it completes its job before returning to caller.\n  - When nbWorkers>=1, function is non-blocking : it copies a portion of input, distributes jobs to internal worker threads, flush to output whatever is available,\n                                                  and then immediately returns, just indicating that there is some data remaining to be flushed.\n                                                  The function nonetheless guarantees forward progress : it will return only after it reads or write at least 1+ byte.\n  - Exception : if the first call requests a ZSTD_e_end directive and provides enough dstCapacity, the function delegates to ZSTD_compress2() which is always blocking.\n  - @return provides a minimum amount of data remaining to be flushed from internal buffers\n            or an error code, which can be tested using ZSTD_isError().\n            if @return != 0, flush is not fully completed, there is still some data left within internal buffers.\n            This is useful for ZSTD_e_flush, since in this case more flushes are necessary to empty all buffers.\n            For ZSTD_e_end, @return == 0 when internal buffers are fully flushed and frame is completed.\n  - after a ZSTD_e_end directive, if internal buffer is not fully flushed (@return != 0),\n            only ZSTD_e_end or ZSTD_e_flush operations are allowed.\n            Before starting a new compression job, or changing compression parameters,\n            it is required to fully flush internal buffers.\n  - note: if an operation ends with an error, it may leave @cctx in an undefined state.\n          Therefore, it's UB to invoke ZSTD_compressStream2() of ZSTD_compressStream() on such a state.\n          In order to be re-employed after an error, a state must be reset,\n          which can be done explicitly (ZSTD_CCtx_reset()),\n          or is sometimes implied by methods starting a new compression job (ZSTD_initCStream(), ZSTD_compressCCtx())\n \n

\n\n
size_t ZSTD_CStreamInSize(void);    /**< recommended size for input buffer */\n

\n
size_t ZSTD_CStreamOutSize(void);   /**< recommended size for output buffer. Guarantee to successfully flush at least one complete compressed block. */\n

\n
size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel);\n/*!\n * Alternative for ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue).\n * NOTE: The return value is different. ZSTD_compressStream() returns a hint for\n * the next read size (if non-zero and not an error). ZSTD_compressStream2()\n * returns the minimum nb of bytes left to flush (if non-zero and not an error).\n */\nsize_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input);\n/*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_flush). */\nsize_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);\n/*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_end). */\nsize_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);\n
\n     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n     ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any)\n     ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);\n\n Note that ZSTD_initCStream() clears any previously set dictionary. Use the new API\n to compress with a dictionary.\n \n

\n\n
Streaming decompression - HowTo
\n  A ZSTD_DStream object is required to track streaming operations.\n  Use ZSTD_createDStream() and ZSTD_freeDStream() to create/release resources.\n  ZSTD_DStream objects can be re-employed multiple times.\n\n  Use ZSTD_initDStream() to start a new decompression operation.\n @return : recommended first input size\n  Alternatively, use advanced API to set specific properties.\n\n  Use ZSTD_decompressStream() repetitively to consume your input.\n  The function will update both `pos` fields.\n  If `input.pos < input.size`, some input has not been consumed.\n  It's up to the caller to present again remaining data.\n\n  The function tries to flush all data decoded immediately, respecting output buffer size.\n  If `output.pos < output.size`, decoder has flushed everything it could.\n\n  However, when `output.pos == output.size`, it's more difficult to know.\n  If @return > 0, the frame is not complete, meaning\n  either there is still some data left to flush within internal buffers,\n  or there is more input to read to complete the frame (or both).\n  In which case, call ZSTD_decompressStream() again to flush whatever remains in the buffer.\n  Note : with no additional input provided, amount of data flushed is necessarily <= ZSTD_BLOCKSIZE_MAX.\n @return : 0 when a frame is completely decoded and fully flushed,\n        or an error code, which can be tested using ZSTD_isError(),\n        or any other value > 0, which means there is still some decoding or flushing to do to complete current frame :\n                                the return value is a suggested next input size (just a hint for better latency)\n                                that will never request more than the remaining content of the compressed frame.\n \n
\n\n
typedef ZSTD_DCtx ZSTD_DStream;  /**< DCtx and DStream are now effectively same object (>= v1.3.0) */\n

\n
ZSTD_DStream management functions
ZSTD_DStream* ZSTD_createDStream(void);\nsize_t ZSTD_freeDStream(ZSTD_DStream* zds);  /* accept NULL pointer */\n

\n
Streaming decompression functions

\n
size_t ZSTD_initDStream(ZSTD_DStream* zds);\n
 Initialize/reset DStream state for new decompression operation.\n Call before new decompression operation using same DStream.\n\n Note : This function is redundant with the advanced API and equivalent to:\n     ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);\n     ZSTD_DCtx_refDDict(zds, NULL);\n \n

\n\n
size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input);\n
 Streaming decompression function.\n Call repetitively to consume full input updating it as necessary.\n Function will update both input and output `pos` fields exposing current state via these fields:\n - `input.pos < input.size`, some input remaining and caller should provide remaining input\n   on the next call.\n - `output.pos < output.size`, decoder flushed internal output buffer.\n - `output.pos == output.size`, unflushed data potentially present in the internal buffers,\n   check ZSTD_decompressStream() @return value,\n   if > 0, invoke it again to flush remaining data to output.\n Note : with no additional input, amount of data flushed <= ZSTD_BLOCKSIZE_MAX.\n\n @return : 0 when a frame is completely decoded and fully flushed,\n           or an error code, which can be tested using ZSTD_isError(),\n           or any other value > 0, which means there is some decoding or flushing to do to complete current frame.\n\n Note: when an operation returns with an error code, the @zds state may be left in undefined state.\n       It's UB to invoke `ZSTD_decompressStream()` on such a state.\n       In order to re-use such a state, it must be first reset,\n       which can be done explicitly (`ZSTD_DCtx_reset()`),\n       or is implied for operations starting some new decompression job (`ZSTD_initDStream`, `ZSTD_decompressDCtx()`, `ZSTD_decompress_usingDict()`)\n \n

\n\n
size_t ZSTD_DStreamInSize(void);    /*!< recommended size for input buffer */\n

\n
size_t ZSTD_DStreamOutSize(void);   /*!< recommended size for output buffer. Guarantee to successfully flush at least one complete block in all circumstances. */\n

\n
Simple dictionary API
\n\n
size_t ZSTD_compress_usingDict(ZSTD_CCtx* ctx,\n                               void* dst, size_t dstCapacity,\n                         const void* src, size_t srcSize,\n                         const void* dict,size_t dictSize,\n                               int compressionLevel);\n
  Compression at an explicit compression level using a Dictionary.\n  A dictionary can be any arbitrary data segment (also called a prefix),\n  or a buffer with specified information (see zdict.h).\n  Note : This function loads the dictionary, resulting in significant startup delay.\n         It's intended for a dictionary used only once.\n  Note 2 : When `dict == NULL || dictSize < 8` no dictionary is used. \n

\n\n
size_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,\n                                 void* dst, size_t dstCapacity,\n                           const void* src, size_t srcSize,\n                           const void* dict,size_t dictSize);\n
  Decompression using a known Dictionary.\n  Dictionary must be identical to the one used during compression.\n  Note : This function loads the dictionary, resulting in significant startup delay.\n         It's intended for a dictionary used only once.\n  Note : When `dict == NULL || dictSize < 8` no dictionary is used. \n

\n\n
Bulk processing dictionary API
\n\n
ZSTD_CDict* ZSTD_createCDict(const void* dictBuffer, size_t dictSize,\n                             int compressionLevel);\n
  When compressing multiple messages or blocks using the same dictionary,\n  it's recommended to digest the dictionary only once, since it's a costly operation.\n  ZSTD_createCDict() will create a state from digesting a dictionary.\n  The resulting state can be used for future compression operations with very limited startup cost.\n  ZSTD_CDict can be created once and shared by multiple threads concurrently, since its usage is read-only.\n @dictBuffer can be released after ZSTD_CDict creation, because its content is copied within CDict.\n  Note 1 : Consider experimental function `ZSTD_createCDict_byReference()` if you prefer to not duplicate @dictBuffer content.\n  Note 2 : A ZSTD_CDict can be created from an empty @dictBuffer,\n      in which case the only thing that it transports is the @compressionLevel.\n      This can be useful in a pipeline featuring ZSTD_compress_usingCDict() exclusively,\n      expecting a ZSTD_CDict parameter with any data, including those without a known dictionary. \n

\n\n
size_t      ZSTD_freeCDict(ZSTD_CDict* CDict);\n
  Function frees memory allocated by ZSTD_createCDict().\n  If a NULL pointer is passed, no operation is performed. \n

\n\n
size_t ZSTD_compress_usingCDict(ZSTD_CCtx* cctx,\n                                void* dst, size_t dstCapacity,\n                          const void* src, size_t srcSize,\n                          const ZSTD_CDict* cdict);\n
  Compression using a digested Dictionary.\n  Recommended when same dictionary is used multiple times.\n  Note : compression level is _decided at dictionary creation time_,\n     and frame parameters are hardcoded (dictID=yes, contentSize=yes, checksum=no) \n

\n\n
ZSTD_DDict* ZSTD_createDDict(const void* dictBuffer, size_t dictSize);\n
  Create a digested dictionary, ready to start decompression operation without startup delay.\n  dictBuffer can be released after DDict creation, as its content is copied inside DDict. \n

\n\n
size_t      ZSTD_freeDDict(ZSTD_DDict* ddict);\n
  Function frees memory allocated with ZSTD_createDDict()\n  If a NULL pointer is passed, no operation is performed. \n

\n\n
size_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx,\n                                  void* dst, size_t dstCapacity,\n                            const void* src, size_t srcSize,\n                            const ZSTD_DDict* ddict);\n
  Decompression using a digested Dictionary.\n  Recommended when same dictionary is used multiple times. \n

\n\n
Dictionary helper functions
\n\n
unsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize);\n
  Provides the dictID stored within dictionary.\n  if @return == 0, the dictionary is not conformant with Zstandard specification.\n  It can still be loaded, but as a content-only dictionary. \n

\n\n
unsigned ZSTD_getDictID_fromCDict(const ZSTD_CDict* cdict);\n
  Provides the dictID of the dictionary loaded into `cdict`.\n  If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.\n  Non-conformant dictionaries can still be loaded, but as content-only dictionaries. \n

\n\n
unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict);\n
  Provides the dictID of the dictionary loaded into `ddict`.\n  If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.\n  Non-conformant dictionaries can still be loaded, but as content-only dictionaries. \n

\n\n
unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize);\n
  Provides the dictID required to decompressed the frame stored within `src`.\n  If @return == 0, the dictID could not be decoded.\n  This could for one of the following reasons :\n  - The frame does not require a dictionary to be decoded (most common case).\n  - The frame was built with dictID intentionally removed. Whatever dictionary is necessary is a hidden piece of information.\n    Note : this use case also happens when using a non-conformant dictionary.\n  - `srcSize` is too small, and as a result, the frame header could not be decoded (only possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`).\n  - This is not a Zstandard frame.\n  When identifying the exact failure cause, it's possible to use ZSTD_getFrameHeader(), which will provide a more precise error code. \n

\n\n
Advanced dictionary and prefix API (Requires v1.4.0+)
\n This API allows dictionaries to be used with ZSTD_compress2(),\n ZSTD_compressStream2(), and ZSTD_decompressDCtx().\n Dictionaries are sticky, they remain valid when same context is reused,\n they only reset when the context is reset\n with ZSTD_reset_parameters or ZSTD_reset_session_and_parameters.\n In contrast, Prefixes are single-use.\n
\n\n
size_t ZSTD_CCtx_loadDictionary(ZSTD_CCtx* cctx, const void* dict, size_t dictSize);\n
  Create an internal CDict from `dict` buffer.\n  Decompression will have to use same dictionary.\n @result : 0, or an error code (which can be tested with ZSTD_isError()).\n  Special: Loading a NULL (or 0-size) dictionary invalidates previous dictionary,\n           meaning \"return to no-dictionary mode\".\n  Note 1 : Dictionary is sticky, it will be used for all future compressed frames,\n           until parameters are reset, a new dictionary is loaded, or the dictionary\n           is explicitly invalidated by loading a NULL dictionary.\n  Note 2 : Loading a dictionary involves building tables.\n           It's also a CPU consuming operation, with non-negligible impact on latency.\n           Tables are dependent on compression parameters, and for this reason,\n           compression parameters can no longer be changed after loading a dictionary.\n  Note 3 :`dict` content will be copied internally.\n           Use experimental ZSTD_CCtx_loadDictionary_byReference() to reference content instead.\n           In such a case, dictionary buffer must outlive its users.\n  Note 4 : Use ZSTD_CCtx_loadDictionary_advanced()\n           to precisely select how dictionary content must be interpreted.\n  Note 5 : This method does not benefit from LDM (long distance mode).\n           If you want to employ LDM on some large dictionary content,\n           prefer employing ZSTD_CCtx_refPrefix() described below.\n \n

\n\n
size_t ZSTD_CCtx_refCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict);\n
  Reference a prepared dictionary, to be used for all future compressed frames.\n  Note that compression parameters are enforced from within CDict,\n  and supersede any compression parameter previously set within CCtx.\n  The parameters ignored are labelled as \"superseded-by-cdict\" in the ZSTD_cParameter enum docs.\n  The ignored parameters will be used again if the CCtx is returned to no-dictionary mode.\n  The dictionary will remain valid for future compressed frames using same CCtx.\n @result : 0, or an error code (which can be tested with ZSTD_isError()).\n  Special : Referencing a NULL CDict means \"return to no-dictionary mode\".\n  Note 1 : Currently, only one dictionary can be managed.\n           Referencing a new dictionary effectively \"discards\" any previous one.\n  Note 2 : CDict is just referenced, its lifetime must outlive its usage within CCtx. \n

\n\n
size_t ZSTD_CCtx_refPrefix(ZSTD_CCtx* cctx,\n                     const void* prefix, size_t prefixSize);\n
  Reference a prefix (single-usage dictionary) for next compressed frame.\n  A prefix is **only used once**. Tables are discarded at end of frame (ZSTD_e_end).\n  Decompression will need same prefix to properly regenerate data.\n  Compressing with a prefix is similar in outcome as performing a diff and compressing it,\n  but performs much faster, especially during decompression (compression speed is tunable with compression level).\n  This method is compatible with LDM (long distance mode).\n @result : 0, or an error code (which can be tested with ZSTD_isError()).\n  Special: Adding any prefix (including NULL) invalidates any previous prefix or dictionary\n  Note 1 : Prefix buffer is referenced. It **must** outlive compression.\n           Its content must remain unmodified during compression.\n  Note 2 : If the intention is to diff some large src data blob with some prior version of itself,\n           ensure that the window size is large enough to contain the entire source.\n           See ZSTD_c_windowLog.\n  Note 3 : Referencing a prefix involves building tables, which are dependent on compression parameters.\n           It's a CPU consuming operation, with non-negligible impact on latency.\n           If there is a need to use the same prefix multiple times, consider loadDictionary instead.\n  Note 4 : By default, the prefix is interpreted as raw content (ZSTD_dct_rawContent).\n           Use experimental ZSTD_CCtx_refPrefix_advanced() to alter dictionary interpretation. \n

\n\n
size_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);\n
  Create an internal DDict from dict buffer, to be used to decompress all future frames.\n  The dictionary remains valid for all future frames, until explicitly invalidated, or\n  a new dictionary is loaded.\n @result : 0, or an error code (which can be tested with ZSTD_isError()).\n  Special : Adding a NULL (or 0-size) dictionary invalidates any previous dictionary,\n            meaning \"return to no-dictionary mode\".\n  Note 1 : Loading a dictionary involves building tables,\n           which has a non-negligible impact on CPU usage and latency.\n           It's recommended to \"load once, use many times\", to amortize the cost\n  Note 2 :`dict` content will be copied internally, so `dict` can be released after loading.\n           Use ZSTD_DCtx_loadDictionary_byReference() to reference dictionary content instead.\n  Note 3 : Use ZSTD_DCtx_loadDictionary_advanced() to take control of\n           how dictionary content is loaded and interpreted.\n \n

\n\n
size_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);\n
  Reference a prepared dictionary, to be used to decompress next frames.\n  The dictionary remains active for decompression of future frames using same DCtx.\n\n  If called with ZSTD_d_refMultipleDDicts enabled, repeated calls of this function\n  will store the DDict references in a table, and the DDict used for decompression\n  will be determined at decompression time, as per the dict ID in the frame.\n  The memory for the table is allocated on the first call to refDDict, and can be\n  freed with ZSTD_freeDCtx().\n\n  If called with ZSTD_d_refMultipleDDicts disabled (the default), only one dictionary\n  will be managed, and referencing a dictionary effectively \"discards\" any previous one.\n\n @result : 0, or an error code (which can be tested with ZSTD_isError()).\n  Special: referencing a NULL DDict means \"return to no-dictionary mode\".\n  Note 2 : DDict is just referenced, its lifetime must outlive its usage from DCtx.\n \n

\n\n
size_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx,\n                     const void* prefix, size_t prefixSize);\n
  Reference a prefix (single-usage dictionary) to decompress next frame.\n  This is the reverse operation of ZSTD_CCtx_refPrefix(),\n  and must use the same prefix as the one used during compression.\n  Prefix is **only used once**. Reference is discarded at end of frame.\n  End of frame is reached when ZSTD_decompressStream() returns 0.\n @result : 0, or an error code (which can be tested with ZSTD_isError()).\n  Note 1 : Adding any prefix (including NULL) invalidates any previously set prefix or dictionary\n  Note 2 : Prefix buffer is referenced. It **must** outlive decompression.\n           Prefix buffer must remain unmodified up to the end of frame,\n           reached when ZSTD_decompressStream() returns 0.\n  Note 3 : By default, the prefix is treated as raw content (ZSTD_dct_rawContent).\n           Use ZSTD_CCtx_refPrefix_advanced() to alter dictMode (Experimental section)\n  Note 4 : Referencing a raw content prefix has almost no cpu nor memory cost.\n           A full dictionary is more costly, as it requires building tables.\n \n

\n\n
size_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx);\nsize_t ZSTD_sizeof_DCtx(const ZSTD_DCtx* dctx);\nsize_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs);\nsize_t ZSTD_sizeof_DStream(const ZSTD_DStream* zds);\nsize_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict);\nsize_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict);\n
  These functions give the _current_ memory usage of selected object.\n  Note that object memory usage can evolve (increase or decrease) over time. \n

\n\n
experimental API (static linking only)
\n The following symbols and constants\n are not planned to join \"stable API\" status in the near future.\n They can still change in future versions.\n Some of them are planned to remain in the static_only section indefinitely.\n Some of them might be removed in the future (especially when redundant with existing stable functions)\n \n
\n\n
typedef struct {\n    unsigned int offset;      /* The offset of the match. (NOT the same as the offset code)\n                               * If offset == 0 and matchLength == 0, this sequence represents the last\n                               * literals in the block of litLength size.\n                               */\n\n    unsigned int litLength;   /* Literal length of the sequence. */\n    unsigned int matchLength; /* Match length of the sequence. */\n\n                              /* Note: Users of this API may provide a sequence with matchLength == litLength == offset == 0.\n                               * In this case, we will treat the sequence as a marker for a block boundary.\n                               */\n\n    unsigned int rep;         /* Represents which repeat offset is represented by the field 'offset'.\n                               * Ranges from [0, 3].\n                               *\n                               * Repeat offsets are essentially previous offsets from previous sequences sorted in\n                               * recency order. For more detail, see doc/zstd_compression_format.md\n                               *\n                               * If rep == 0, then 'offset' does not contain a repeat offset.\n                               * If rep > 0:\n                               *  If litLength != 0:\n                               *      rep == 1 --> offset == repeat_offset_1\n                               *      rep == 2 --> offset == repeat_offset_2\n                               *      rep == 3 --> offset == repeat_offset_3\n                               *  If litLength == 0:\n                               *      rep == 1 --> offset == repeat_offset_2\n                               *      rep == 2 --> offset == repeat_offset_3\n                               *      rep == 3 --> offset == repeat_offset_1 - 1\n                               *\n                               * Note: This field is optional. ZSTD_generateSequences() will calculate the value of\n                               * 'rep', but repeat offsets do not necessarily need to be calculated from an external\n                               * sequence provider perspective. For example, ZSTD_compressSequences() does not\n                               * use this 'rep' field at all (as of now).\n                               */\n} ZSTD_Sequence;\n

\n
typedef struct {\n    unsigned windowLog;       /**< largest match distance : larger == more compression, more memory needed during decompression */\n    unsigned chainLog;        /**< fully searched segment : larger == more compression, slower, more memory (useless for fast) */\n    unsigned hashLog;         /**< dispatch table : larger == faster, more memory */\n    unsigned searchLog;       /**< nb of searches : larger == more compression, slower */\n    unsigned minMatch;        /**< match length searched : larger == faster decompression, sometimes less compression */\n    unsigned targetLength;    /**< acceptable match size for optimal parser (only) : larger == more compression, slower */\n    ZSTD_strategy strategy;   /**< see ZSTD_strategy definition above */\n} ZSTD_compressionParameters;\n

\n
typedef struct {\n    int contentSizeFlag; /**< 1: content size will be in frame header (when known) */\n    int checksumFlag;    /**< 1: generate a 32-bits checksum using XXH64 algorithm at end of frame, for error detection */\n    int noDictIDFlag;    /**< 1: no dictID will be saved into frame header (dictID is only useful for dictionary compression) */\n} ZSTD_frameParameters;\n

\n
typedef struct {\n    ZSTD_compressionParameters cParams;\n    ZSTD_frameParameters fParams;\n} ZSTD_parameters;\n

\n
typedef enum {\n    ZSTD_dct_auto = 0,       /* dictionary is \"full\" when starting with ZSTD_MAGIC_DICTIONARY, otherwise it is \"rawContent\" */\n    ZSTD_dct_rawContent = 1, /* ensures dictionary is always loaded as rawContent, even if it starts with ZSTD_MAGIC_DICTIONARY */\n    ZSTD_dct_fullDict = 2    /* refuses to load a dictionary if it does not respect Zstandard's specification, starting with ZSTD_MAGIC_DICTIONARY */\n} ZSTD_dictContentType_e;\n

\n
typedef enum {\n    ZSTD_dlm_byCopy = 0,  /**< Copy dictionary content internally */\n    ZSTD_dlm_byRef = 1    /**< Reference dictionary content -- the dictionary buffer must outlive its users. */\n} ZSTD_dictLoadMethod_e;\n

\n
typedef enum {\n    ZSTD_f_zstd1 = 0,           /* zstd frame format, specified in zstd_compression_format.md (default) */\n    ZSTD_f_zstd1_magicless = 1  /* Variant of zstd frame format, without initial 4-bytes magic number.\n                                 * Useful to save 4 bytes per generated frame.\n                                 * Decoder cannot recognise automatically this format, requiring this instruction. */\n} ZSTD_format_e;\n

\n
typedef enum {\n    /* Note: this enum controls ZSTD_d_forceIgnoreChecksum */\n    ZSTD_d_validateChecksum = 0,\n    ZSTD_d_ignoreChecksum = 1\n} ZSTD_forceIgnoreChecksum_e;\n

\n
typedef enum {\n    /* Note: this enum controls ZSTD_d_refMultipleDDicts */\n    ZSTD_rmd_refSingleDDict = 0,\n    ZSTD_rmd_refMultipleDDicts = 1\n} ZSTD_refMultipleDDicts_e;\n

\n
typedef enum {\n    /* Note: this enum and the behavior it controls are effectively internal\n     * implementation details of the compressor. They are expected to continue\n     * to evolve and should be considered only in the context of extremely\n     * advanced performance tuning.\n     *\n     * Zstd currently supports the use of a CDict in three ways:\n     *\n     * - The contents of the CDict can be copied into the working context. This\n     *   means that the compression can search both the dictionary and input\n     *   while operating on a single set of internal tables. This makes\n     *   the compression faster per-byte of input. However, the initial copy of\n     *   the CDict's tables incurs a fixed cost at the beginning of the\n     *   compression. For small compressions (< 8 KB), that copy can dominate\n     *   the cost of the compression.\n     *\n     * - The CDict's tables can be used in-place. In this model, compression is\n     *   slower per input byte, because the compressor has to search two sets of\n     *   tables. However, this model incurs no start-up cost (as long as the\n     *   working context's tables can be reused). For small inputs, this can be\n     *   faster than copying the CDict's tables.\n     *\n     * - The CDict's tables are not used at all, and instead we use the working\n     *   context alone to reload the dictionary and use params based on the source\n     *   size. See ZSTD_compress_insertDictionary() and ZSTD_compress_usingDict().\n     *   This method is effective when the dictionary sizes are very small relative\n     *   to the input size, and the input size is fairly large to begin with.\n     *\n     * Zstd has a simple internal heuristic that selects which strategy to use\n     * at the beginning of a compression. However, if experimentation shows that\n     * Zstd is making poor choices, it is possible to override that choice with\n     * this enum.\n     */\n    ZSTD_dictDefaultAttach = 0, /* Use the default heuristic. */\n    ZSTD_dictForceAttach   = 1, /* Never copy the dictionary. */\n    ZSTD_dictForceCopy     = 2, /* Always copy the dictionary. */\n    ZSTD_dictForceLoad     = 3  /* Always reload the dictionary */\n} ZSTD_dictAttachPref_e;\n

\n
typedef enum {\n  ZSTD_lcm_auto = 0,          /**< Automatically determine the compression mode based on the compression level.\n                               *   Negative compression levels will be uncompressed, and positive compression\n                               *   levels will be compressed. */\n  ZSTD_lcm_huffman = 1,       /**< Always attempt Huffman compression. Uncompressed literals will still be\n                               *   emitted if Huffman compression is not profitable. */\n  ZSTD_lcm_uncompressed = 2   /**< Always emit uncompressed literals. */\n} ZSTD_literalCompressionMode_e;\n

\n
typedef enum {\n  /* Note: This enum controls features which are conditionally beneficial.\n   * Zstd can take a decision on whether or not to enable the feature (ZSTD_ps_auto),\n   * but setting the switch to ZSTD_ps_enable or ZSTD_ps_disable force enable/disable the feature.\n   */\n  ZSTD_ps_auto = 0,         /* Let the library automatically determine whether the feature shall be enabled */\n  ZSTD_ps_enable = 1,       /* Force-enable the feature */\n  ZSTD_ps_disable = 2       /* Do not use the feature */\n} ZSTD_ParamSwitch_e;\n

\n
Frame header and size functions
\n\n
ZSTDLIB_STATIC_API unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize);\n
  `src` should point to the start of a series of ZSTD encoded and/or skippable frames\n  `srcSize` must be the _exact_ size of this series\n       (i.e. there should be a frame boundary at `src + srcSize`)\n  @return : - decompressed size of all data in all successive frames\n            - if the decompressed size cannot be determined: ZSTD_CONTENTSIZE_UNKNOWN\n            - if an error occurred: ZSTD_CONTENTSIZE_ERROR\n\n   note 1 : decompressed size is an optional field, that may not be present, especially in streaming mode.\n            When `return==ZSTD_CONTENTSIZE_UNKNOWN`, data to decompress could be any size.\n            In which case, it's necessary to use streaming mode to decompress data.\n   note 2 : decompressed size is always present when compression is done with ZSTD_compress()\n   note 3 : decompressed size can be very large (64-bits value),\n            potentially larger than what local system can handle as a single memory segment.\n            In which case, it's necessary to use streaming mode to decompress data.\n   note 4 : If source is untrusted, decompressed size could be wrong or intentionally modified.\n            Always ensure result fits within application's authorized limits.\n            Each application can set its own limits.\n   note 5 : ZSTD_findDecompressedSize handles multiple frames, and so it must traverse the input to\n            read each contained frame header.  This is fast as most of the data is skipped,\n            however it does mean that all frame data must be present and valid. \n

\n\n
ZSTDLIB_STATIC_API unsigned long long ZSTD_decompressBound(const void* src, size_t srcSize);\n
  `src` should point to the start of a series of ZSTD encoded and/or skippable frames\n  `srcSize` must be the _exact_ size of this series\n       (i.e. there should be a frame boundary at `src + srcSize`)\n  @return : - upper-bound for the decompressed size of all data in all successive frames\n            - if an error occurred: ZSTD_CONTENTSIZE_ERROR\n\n  note 1  : an error can occur if `src` contains an invalid or incorrectly formatted frame.\n  note 2  : the upper-bound is exact when the decompressed size field is available in every ZSTD encoded frame of `src`.\n            in this case, `ZSTD_findDecompressedSize` and `ZSTD_decompressBound` return the same value.\n  note 3  : when the decompressed size field isn't available, the upper-bound for that frame is calculated by:\n              upper-bound = # blocks * min(128 KB, Window_Size)\n \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize);\n
  srcSize must be large enough, aka >= ZSTD_FRAMEHEADERSIZE_PREFIX.\n @return : size of the Frame Header,\n           or an error code (if srcSize is too small) \n

\n\n
typedef enum { ZSTD_frame, ZSTD_skippableFrame } ZSTD_FrameType_e;\n

\n
typedef struct {\n    unsigned long long frameContentSize; /* if == ZSTD_CONTENTSIZE_UNKNOWN, it means this field is not available. 0 means \"empty\" */\n    unsigned long long windowSize;       /* can be very large, up to <= frameContentSize */\n    unsigned blockSizeMax;\n    ZSTD_FrameType_e frameType;          /* if == ZSTD_skippableFrame, frameContentSize is the size of skippable content */\n    unsigned headerSize;\n    unsigned dictID;                     /* for ZSTD_skippableFrame, contains the skippable magic variant [0-15] */\n    unsigned checksumFlag;\n    unsigned _reserved1;\n    unsigned _reserved2;\n} ZSTD_FrameHeader;\n

\n
ZSTDLIB_STATIC_API size_t ZSTD_getFrameHeader(ZSTD_FrameHeader* zfhPtr, const void* src, size_t srcSize);\n/*! ZSTD_getFrameHeader_advanced() :\n *  same as ZSTD_getFrameHeader(),\n *  with added capability to select a format (like ZSTD_f_zstd1_magicless) */\nZSTDLIB_STATIC_API size_t ZSTD_getFrameHeader_advanced(ZSTD_FrameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format);\n
  decode Frame Header into `zfhPtr`, or requires larger `srcSize`.\n @return : 0 => header is complete, `zfhPtr` is correctly filled,\n          >0 => `srcSize` is too small, @return value is the wanted `srcSize` amount, `zfhPtr` is not filled,\n           or an error code, which can be tested using ZSTD_isError() \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_decompressionMargin(const void* src, size_t srcSize);\n
 Zstd supports in-place decompression, where the input and output buffers overlap.\n In this case, the output buffer must be at least (Margin + Output_Size) bytes large,\n and the input buffer must be at the end of the output buffer.\n\n  _______________________ Output Buffer ________________________\n |                                                              |\n |                                        ____ Input Buffer ____|\n |                                       |                      |\n v                                       v                      v\n |---------------------------------------|-----------|----------|\n ^                                                   ^          ^\n |___________________ Output_Size ___________________|_ Margin _|\n\n NOTE: See also ZSTD_DECOMPRESSION_MARGIN().\n NOTE: This applies only to single-pass decompression through ZSTD_decompress() or\n ZSTD_decompressDCtx().\n NOTE: This function supports multi-frame input.\n\n @param src The compressed frame(s)\n @param srcSize The size of the compressed frame(s)\n @returns The decompression margin or an error that can be checked with ZSTD_isError().\n \n

\n\n
#define ZSTD_DECOMPRESSION_MARGIN(originalSize, blockSize) ((size_t)(                                              \\\n        ZSTD_FRAMEHEADERSIZE_MAX                                                              /* Frame header */ + \\\n        4                                                                                         /* checksum */ + \\\n        ((originalSize) == 0 ? 0 : 3 * (((originalSize) + (blockSize) - 1) / blockSize)) /* 3 bytes per block */ + \\\n        (blockSize)                                                                    /* One block of margin */   \\\n    ))\n
 Similar to ZSTD_decompressionMargin(), but instead of computing the margin from\n the compressed frame, compute it from the original size and the blockSizeLog.\n See ZSTD_decompressionMargin() for details.\n\n WARNING: This macro does not support multi-frame input, the input must be a single\n zstd frame. If you need that support use the function, or implement it yourself.\n\n @param originalSize The original uncompressed size of the data.\n @param blockSize    The block size == MIN(windowSize, ZSTD_BLOCKSIZE_MAX).\n                     Unless you explicitly set the windowLog smaller than\n                     ZSTD_BLOCKSIZELOG_MAX you can just use ZSTD_BLOCKSIZE_MAX.\n \n

\n\n
typedef enum {\n  ZSTD_sf_noBlockDelimiters = 0,         /* ZSTD_Sequence[] has no block delimiters, just sequences */\n  ZSTD_sf_explicitBlockDelimiters = 1    /* ZSTD_Sequence[] contains explicit block delimiters */\n} ZSTD_SequenceFormat_e;\n

\n
ZSTDLIB_STATIC_API size_t ZSTD_sequenceBound(size_t srcSize);\n
 `srcSize` : size of the input buffer\n  @return : upper-bound for the number of sequences that can be generated\n            from a buffer of srcSize bytes\n\n  note : returns number of sequences - to get bytes, multiply by sizeof(ZSTD_Sequence).\n \n

\n\n
ZSTD_DEPRECATED(\"For debugging only, will be replaced by ZSTD_extractSequences()\")\nZSTDLIB_STATIC_API size_t\nZSTD_generateSequences(ZSTD_CCtx* zc,\n           ZSTD_Sequence* outSeqs, size_t outSeqsCapacity,\n           const void* src, size_t srcSize);\n
 WARNING: This function is meant for debugging and informational purposes ONLY!\n Its implementation is flawed, and it will be deleted in a future version.\n It is not guaranteed to succeed, as there are several cases where it will give\n up and fail. You should NOT use this function in production code.\n\n This function is deprecated, and will be removed in a future version.\n\n Generate sequences using ZSTD_compress2(), given a source buffer.\n\n @param zc The compression context to be used for ZSTD_compress2(). Set any\n           compression parameters you need on this context.\n @param outSeqs The output sequences buffer of size @p outSeqsSize\n @param outSeqsCapacity The size of the output sequences buffer.\n                    ZSTD_sequenceBound(srcSize) is an upper bound on the number\n                    of sequences that can be generated.\n @param src The source buffer to generate sequences from of size @p srcSize.\n @param srcSize The size of the source buffer.\n\n Each block will end with a dummy sequence\n with offset == 0, matchLength == 0, and litLength == length of last literals.\n litLength may be == 0, and if so, then the sequence of (of: 0 ml: 0 ll: 0)\n simply acts as a block delimiter.\n\n @returns The number of sequences generated, necessarily less than\n          ZSTD_sequenceBound(srcSize), or an error code that can be checked\n          with ZSTD_isError().\n \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_mergeBlockDelimiters(ZSTD_Sequence* sequences, size_t seqsSize);\n
 Given an array of ZSTD_Sequence, remove all sequences that represent block delimiters/last literals\n by merging them into the literals of the next sequence.\n\n As such, the final generated result has no explicit representation of block boundaries,\n and the final last literals segment is not represented in the sequences.\n\n The output of this function can be fed into ZSTD_compressSequences() with CCtx\n setting of ZSTD_c_blockDelimiters as ZSTD_sf_noBlockDelimiters\n @return : number of sequences left after merging\n \n

\n\n
ZSTDLIB_STATIC_API size_t\nZSTD_compressSequences(ZSTD_CCtx* cctx,\n           void* dst, size_t dstCapacity,\n     const ZSTD_Sequence* inSeqs, size_t inSeqsSize,\n     const void* src, size_t srcSize);\n
 Compress an array of ZSTD_Sequence, associated with @src buffer, into dst.\n @src contains the entire input (not just the literals).\n If @srcSize > sum(sequence.length), the remaining bytes are considered all literals\n If a dictionary is included, then the cctx should reference the dict (see: ZSTD_CCtx_refCDict(), ZSTD_CCtx_loadDictionary(), etc.).\n The entire source is compressed into a single frame.\n\n The compression behavior changes based on cctx params. In particular:\n    If ZSTD_c_blockDelimiters == ZSTD_sf_noBlockDelimiters, the array of ZSTD_Sequence is expected to contain\n    no block delimiters (defined in ZSTD_Sequence). Block boundaries are roughly determined based on\n    the block size derived from the cctx, and sequences may be split. This is the default setting.\n\n    If ZSTD_c_blockDelimiters == ZSTD_sf_explicitBlockDelimiters, the array of ZSTD_Sequence is expected to contain\n    valid block delimiters (defined in ZSTD_Sequence). Behavior is undefined if no block delimiters are provided.\n\n    When ZSTD_c_blockDelimiters == ZSTD_sf_explicitBlockDelimiters, it's possible to decide generating repcodes\n    using the advanced parameter ZSTD_c_repcodeResolution. Repcodes will improve compression ratio, though the benefit\n    can vary greatly depending on Sequences. On the other hand, repcode resolution is an expensive operation.\n    By default, it's disabled at low (<10) compression levels, and enabled above the threshold (>=10).\n    ZSTD_c_repcodeResolution makes it possible to directly manage this processing in either direction.\n\n    If ZSTD_c_validateSequences == 0, this function blindly accepts the Sequences provided. Invalid Sequences cause undefined\n    behavior. If ZSTD_c_validateSequences == 1, then the function will detect invalid Sequences (see doc/zstd_compression_format.md for\n    specifics regarding offset/matchlength requirements) and then bail out and return an error.\n\n    In addition to the two adjustable experimental params, there are other important cctx params.\n    - ZSTD_c_minMatch MUST be set as less than or equal to the smallest match generated by the match finder. It has a minimum value of ZSTD_MINMATCH_MIN.\n    - ZSTD_c_compressionLevel accordingly adjusts the strength of the entropy coder, as it would in typical compression.\n    - ZSTD_c_windowLog affects offset validation: this function will return an error at higher debug levels if a provided offset\n      is larger than what the spec allows for a given window log and dictionary (if present). See: doc/zstd_compression_format.md\n\n Note: Repcodes are, as of now, always re-calculated within this function, ZSTD_Sequence.rep is effectively unused.\n Dev Note: Once ability to ingest repcodes become available, the explicit block delims mode must respect those repcodes exactly,\n         and cannot emit an RLE block that disagrees with the repcode history.\n @return : final compressed size, or a ZSTD error code.\n \n

\n\n
ZSTDLIB_STATIC_API size_t\nZSTD_compressSequencesAndLiterals(ZSTD_CCtx* cctx,\n                      void* dst, size_t dstCapacity,\n                const ZSTD_Sequence* inSeqs, size_t nbSequences,\n                const void* literals, size_t litSize, size_t litBufCapacity,\n                size_t decompressedSize);\n
 This is a variant of ZSTD_compressSequences() which,\n instead of receiving (src,srcSize) as input parameter, receives (literals,litSize),\n aka all the literals, already extracted and laid out into a single continuous buffer.\n This can be useful if the process generating the sequences also happens to generate the buffer of literals,\n thus skipping an extraction + caching stage.\n It's a speed optimization, useful when the right conditions are met,\n but it also features the following limitations:\n - Only supports explicit delimiter mode\n - Currently does not support Sequences validation (so input Sequences are trusted)\n - Not compatible with frame checksum, which must be disabled\n - If any block is incompressible, will fail and return an error\n - @litSize must be == sum of all @.litLength fields in @inSeqs. Any discrepancy will generate an error.\n - @litBufCapacity is the size of the underlying buffer into which literals are written, starting at address @literals.\n   @litBufCapacity must be at least 8 bytes larger than @litSize.\n - @decompressedSize must be correct, and correspond to the sum of all Sequences. Any discrepancy will generate an error.\n @return : final compressed size, or a ZSTD error code.\n \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_writeSkippableFrame(void* dst, size_t dstCapacity,\n                                 const void* src, size_t srcSize,\n                                       unsigned magicVariant);\n
 Generates a zstd skippable frame containing data given by src, and writes it to dst buffer.\n\n Skippable frames begin with a 4-byte magic number. There are 16 possible choices of magic number,\n ranging from ZSTD_MAGIC_SKIPPABLE_START to ZSTD_MAGIC_SKIPPABLE_START+15.\n As such, the parameter magicVariant controls the exact skippable frame magic number variant used,\n so the magic number used will be ZSTD_MAGIC_SKIPPABLE_START + magicVariant.\n\n Returns an error if destination buffer is not large enough, if the source size is not representable\n with a 4-byte unsigned int, or if the parameter magicVariant is greater than 15 (and therefore invalid).\n\n @return : number of bytes written or a ZSTD error.\n \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_readSkippableFrame(void* dst, size_t dstCapacity,\n                                      unsigned* magicVariant,\n                                      const void* src, size_t srcSize);\n
 Retrieves the content of a zstd skippable frame starting at @src, and writes it to @dst buffer.\n\n The parameter @magicVariant will receive the magicVariant that was supplied when the frame was written,\n i.e. magicNumber - ZSTD_MAGIC_SKIPPABLE_START.\n This can be NULL if the caller is not interested in the magicVariant.\n\n Returns an error if destination buffer is not large enough, or if the frame is not skippable.\n\n @return : number of bytes written or a ZSTD error.\n \n

\n\n
ZSTDLIB_STATIC_API unsigned ZSTD_isSkippableFrame(const void* buffer, size_t size);\n
  Tells if the content of `buffer` starts with a valid Frame Identifier for a skippable frame.\n \n

\n\n
Memory management
\n\n
ZSTDLIB_STATIC_API size_t ZSTD_estimateCCtxSize(int maxCompressionLevel);\nZSTDLIB_STATIC_API size_t ZSTD_estimateCCtxSize_usingCParams(ZSTD_compressionParameters cParams);\nZSTDLIB_STATIC_API size_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params);\nZSTDLIB_STATIC_API size_t ZSTD_estimateDCtxSize(void);\n
  These functions make it possible to estimate memory usage\n  of a future {D,C}Ctx, before its creation.\n  This is useful in combination with ZSTD_initStatic(),\n  which makes it possible to employ a static buffer for ZSTD_CCtx* state.\n\n  ZSTD_estimateCCtxSize() will provide a memory budget large enough\n  to compress data of any size using one-shot compression ZSTD_compressCCtx() or ZSTD_compress2()\n  associated with any compression level up to max specified one.\n  The estimate will assume the input may be arbitrarily large,\n  which is the worst case.\n\n  Note that the size estimation is specific for one-shot compression,\n  it is not valid for streaming (see ZSTD_estimateCStreamSize*())\n  nor other potential ways of using a ZSTD_CCtx* state.\n\n  When srcSize can be bound by a known and rather \"small\" value,\n  this knowledge can be used to provide a tighter budget estimation\n  because the ZSTD_CCtx* state will need less memory for small inputs.\n  This tighter estimation can be provided by employing more advanced functions\n  ZSTD_estimateCCtxSize_usingCParams(), which can be used in tandem with ZSTD_getCParams(),\n  and ZSTD_estimateCCtxSize_usingCCtxParams(), which can be used in tandem with ZSTD_CCtxParams_setParameter().\n  Both can be used to estimate memory using custom compression parameters and arbitrary srcSize limits.\n\n  Note : only single-threaded compression is supported.\n  ZSTD_estimateCCtxSize_usingCCtxParams() will return an error code if ZSTD_c_nbWorkers is >= 1.\n \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_estimateCStreamSize(int maxCompressionLevel);\nZSTDLIB_STATIC_API size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams);\nZSTDLIB_STATIC_API size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params);\nZSTDLIB_STATIC_API size_t ZSTD_estimateDStreamSize(size_t maxWindowSize);\nZSTDLIB_STATIC_API size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize);\n
  ZSTD_estimateCStreamSize() will provide a memory budget large enough for streaming compression\n  using any compression level up to the max specified one.\n  It will also consider src size to be arbitrarily \"large\", which is a worst case scenario.\n  If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation.\n  ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionLevel.\n  ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParams_setParameter(). Only single-threaded compression is supported. This function will return an error code if ZSTD_c_nbWorkers is >= 1.\n  Note : CStream size estimation is only correct for single-threaded compression.\n  ZSTD_estimateCStreamSize_usingCCtxParams() will return an error code if ZSTD_c_nbWorkers is >= 1.\n  Note 2 : ZSTD_estimateCStreamSize* functions are not compatible with the Block-Level Sequence Producer API at this time.\n  Size estimates assume that no external sequence producer is registered.\n\n  ZSTD_DStream memory budget depends on frame's window Size.\n  This information can be passed manually, using ZSTD_estimateDStreamSize,\n  or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame();\n  Any frame requesting a window size larger than max specified one will be rejected.\n  Note : if streaming is init with function ZSTD_init?Stream_usingDict(),\n         an internal ?Dict will be created, which additional size is not estimated here.\n         In this case, get total size by adding ZSTD_estimate?DictSize\n \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel);\nZSTDLIB_STATIC_API size_t ZSTD_estimateCDictSize_advanced(size_t dictSize, ZSTD_compressionParameters cParams, ZSTD_dictLoadMethod_e dictLoadMethod);\nZSTDLIB_STATIC_API size_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod);\n
  ZSTD_estimateCDictSize() will bet that src size is relatively \"small\", and content is copied, like ZSTD_createCDict().\n  ZSTD_estimateCDictSize_advanced() makes it possible to control compression parameters precisely, like ZSTD_createCDict_advanced().\n  Note : dictionaries created by reference (`ZSTD_dlm_byRef`) are logically smaller.\n \n

\n\n
ZSTDLIB_STATIC_API ZSTD_CCtx*    ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize);\nZSTDLIB_STATIC_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticCCtx() */\n
  Initialize an object using a pre-allocated fixed-size buffer.\n  workspace: The memory area to emplace the object into.\n             Provided pointer *must be 8-bytes aligned*.\n             Buffer must outlive object.\n  workspaceSize: Use ZSTD_estimate*Size() to determine\n                 how large workspace must be to support target scenario.\n @return : pointer to object (same address as workspace, just different type),\n           or NULL if error (size too small, incorrect alignment, etc.)\n  Note : zstd will never resize nor malloc() when using a static buffer.\n         If the object requires more memory than available,\n         zstd will just error out (typically ZSTD_error_memory_allocation).\n  Note 2 : there is no corresponding \"free\" function.\n           Since workspace is allocated externally, it must be freed externally too.\n  Note 3 : cParams : use ZSTD_getCParams() to convert a compression level\n           into its associated cParams.\n  Limitation 1 : currently not compatible with internal dictionary creation, triggered by\n                 ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict().\n  Limitation 2 : static cctx currently not compatible with multi-threading.\n  Limitation 3 : static dctx is incompatible with legacy support.\n \n

\n\n
ZSTDLIB_STATIC_API ZSTD_DStream* ZSTD_initStaticDStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticDCtx() */\n

\n
typedef void* (*ZSTD_allocFunction) (void* opaque, size_t size);\ntypedef void  (*ZSTD_freeFunction) (void* opaque, void* address);\ntypedef struct { ZSTD_allocFunction customAlloc; ZSTD_freeFunction customFree; void* opaque; } ZSTD_customMem;\nstatic\n#ifdef __GNUC__\n__attribute__((__unused__))\n#endif\n
  These prototypes make it possible to pass your own allocation/free functions.\n  ZSTD_customMem is provided at creation time, using ZSTD_create*_advanced() variants listed below.\n  All allocation/free operations will be completed using these custom variants instead of regular  ones.\n \n

\n\n
ZSTD_customMem const ZSTD_defaultCMem = { NULL, NULL, NULL };  /**< this constant defers to stdlib's functions */\n

\n
typedef struct POOL_ctx_s ZSTD_threadPool;\nZSTDLIB_STATIC_API ZSTD_threadPool* ZSTD_createThreadPool(size_t numThreads);\nZSTDLIB_STATIC_API void ZSTD_freeThreadPool (ZSTD_threadPool* pool);  /* accept NULL pointer */\nZSTDLIB_STATIC_API size_t ZSTD_CCtx_refThreadPool(ZSTD_CCtx* cctx, ZSTD_threadPool* pool);\n
  These prototypes make it possible to share a thread pool among multiple compression contexts.\n  This can limit resources for applications with multiple threads where each one uses\n  a threaded compression mode (via ZSTD_c_nbWorkers parameter).\n  ZSTD_createThreadPool creates a new thread pool with a given number of threads.\n  Note that the lifetime of such pool must exist while being used.\n  ZSTD_CCtx_refThreadPool assigns a thread pool to a context (use NULL argument value\n  to use an internal thread pool).\n  ZSTD_freeThreadPool frees a thread pool, accepts NULL pointer.\n \n

\n\n
Advanced compression functions
\n\n
ZSTDLIB_STATIC_API ZSTD_CDict* ZSTD_createCDict_byReference(const void* dictBuffer, size_t dictSize, int compressionLevel);\n
  Create a digested dictionary for compression\n  Dictionary content is just referenced, not duplicated.\n  As a consequence, `dictBuffer` **must** outlive CDict,\n  and its content must remain unmodified throughout the lifetime of CDict.\n  note: equivalent to ZSTD_createCDict_advanced(), with dictLoadMethod==ZSTD_dlm_byRef \n

\n\n
ZSTDLIB_STATIC_API ZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize);\n
 @return ZSTD_compressionParameters structure for a selected compression level and estimated srcSize.\n `estimatedSrcSize` value is optional, select 0 if not known \n

\n\n
ZSTDLIB_STATIC_API ZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long estimatedSrcSize, size_t dictSize);\n
  same as ZSTD_getCParams(), but @return a full `ZSTD_parameters` object instead of sub-component `ZSTD_compressionParameters`.\n  All fields of `ZSTD_frameParameters` are set to default : contentSize=1, checksum=0, noDictID=0 \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_checkCParams(ZSTD_compressionParameters params);\n
  Ensure param values remain within authorized range.\n @return 0 on success, or an error code (can be checked with ZSTD_isError()) \n

\n\n
ZSTDLIB_STATIC_API ZSTD_compressionParameters ZSTD_adjustCParams(ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize);\n
  optimize params for a given `srcSize` and `dictSize`.\n `srcSize` can be unknown, in which case use ZSTD_CONTENTSIZE_UNKNOWN.\n `dictSize` must be `0` when there is no dictionary.\n  cPar can be invalid : all parameters will be clamped within valid range in the @return struct.\n  This function never fails (wide contract) \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_CCtx_setCParams(ZSTD_CCtx* cctx, ZSTD_compressionParameters cparams);\n
  Set all parameters provided within @p cparams into the working @p cctx.\n  Note : if modifying parameters during compression (MT mode only),\n         note that changes to the .windowLog parameter will be ignored.\n @return 0 on success, or an error code (can be checked with ZSTD_isError()).\n         On failure, no parameters are updated.\n \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_CCtx_setFParams(ZSTD_CCtx* cctx, ZSTD_frameParameters fparams);\n
  Set all parameters provided within @p fparams into the working @p cctx.\n @return 0 on success, or an error code (can be checked with ZSTD_isError()).\n \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_CCtx_setParams(ZSTD_CCtx* cctx, ZSTD_parameters params);\n
  Set all parameters provided within @p params into the working @p cctx.\n @return 0 on success, or an error code (can be checked with ZSTD_isError()).\n \n

\n\n
ZSTD_DEPRECATED(\"use ZSTD_compress2\")\nZSTDLIB_STATIC_API\nsize_t ZSTD_compress_advanced(ZSTD_CCtx* cctx,\n                  void* dst, size_t dstCapacity,\n            const void* src, size_t srcSize,\n            const void* dict,size_t dictSize,\n                  ZSTD_parameters params);\n
  Note : this function is now DEPRECATED.\n         It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_setParameter() and other parameter setters.\n  This prototype will generate compilation warnings. \n

\n\n
ZSTD_DEPRECATED(\"use ZSTD_compress2 with ZSTD_CCtx_loadDictionary\")\nZSTDLIB_STATIC_API\nsize_t ZSTD_compress_usingCDict_advanced(ZSTD_CCtx* cctx,\n                                  void* dst, size_t dstCapacity,\n                            const void* src, size_t srcSize,\n                            const ZSTD_CDict* cdict,\n                                  ZSTD_frameParameters fParams);\n
  Note : this function is now DEPRECATED.\n         It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_loadDictionary() and other parameter setters.\n  This prototype will generate compilation warnings. \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_CCtx_loadDictionary_byReference(ZSTD_CCtx* cctx, const void* dict, size_t dictSize);\n
  Same as ZSTD_CCtx_loadDictionary(), but dictionary content is referenced, instead of being copied into CCtx.\n  It saves some memory, but also requires that `dict` outlives its usage within `cctx` \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_CCtx_loadDictionary_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType);\n
  Same as ZSTD_CCtx_loadDictionary(), but gives finer control over\n  how to load the dictionary (by copy ? by reference ?)\n  and how to interpret it (automatic ? force raw mode ? full mode only ?) \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_CCtx_refPrefix_advanced(ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType);\n
  Same as ZSTD_CCtx_refPrefix(), but gives finer control over\n  how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?) \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_CCtx_getParameter(const ZSTD_CCtx* cctx, ZSTD_cParameter param, int* value);\n
  Get the requested compression parameter value, selected by enum ZSTD_cParameter,\n  and store it into int* value.\n @return : 0, or an error code (which can be tested with ZSTD_isError()).\n \n

\n\n
ZSTDLIB_STATIC_API ZSTD_CCtx_params* ZSTD_createCCtxParams(void);\nZSTDLIB_STATIC_API size_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params);  /* accept NULL pointer */\n
  Quick howto :\n  - ZSTD_createCCtxParams() : Create a ZSTD_CCtx_params structure\n  - ZSTD_CCtxParams_setParameter() : Push parameters one by one into\n                                     an existing ZSTD_CCtx_params structure.\n                                     This is similar to\n                                     ZSTD_CCtx_setParameter().\n  - ZSTD_CCtx_setParametersUsingCCtxParams() : Apply parameters to\n                                    an existing CCtx.\n                                    These parameters will be applied to\n                                    all subsequent frames.\n  - ZSTD_compressStream2() : Do compression using the CCtx.\n  - ZSTD_freeCCtxParams() : Free the memory, accept NULL pointer.\n\n  This can be used with ZSTD_estimateCCtxSize_advanced_usingCCtxParams()\n  for static allocation of CCtx for single-threaded compression.\n \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_CCtxParams_reset(ZSTD_CCtx_params* params);\n
  Reset params to default values.\n \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_CCtxParams_init(ZSTD_CCtx_params* cctxParams, int compressionLevel);\n
  Initializes the compression parameters of cctxParams according to\n  compression level. All other parameters are reset to their default values.\n \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_CCtxParams_init_advanced(ZSTD_CCtx_params* cctxParams, ZSTD_parameters params);\n
  Initializes the compression and frame parameters of cctxParams according to\n  params. All other parameters are reset to their default values.\n \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_CCtxParams_setParameter(ZSTD_CCtx_params* params, ZSTD_cParameter param, int value);\n
  Similar to ZSTD_CCtx_setParameter.\n  Set one compression parameter, selected by enum ZSTD_cParameter.\n  Parameters must be applied to a ZSTD_CCtx using\n  ZSTD_CCtx_setParametersUsingCCtxParams().\n @result : a code representing success or failure (which can be tested with\n           ZSTD_isError()).\n \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_CCtxParams_getParameter(const ZSTD_CCtx_params* params, ZSTD_cParameter param, int* value);\n
 Similar to ZSTD_CCtx_getParameter.\n Get the requested value of one compression parameter, selected by enum ZSTD_cParameter.\n @result : 0, or an error code (which can be tested with ZSTD_isError()).\n \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_CCtx_setParametersUsingCCtxParams(\n        ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params);\n
  Apply a set of ZSTD_CCtx_params to the compression context.\n  This can be done even after compression is started,\n    if nbWorkers==0, this will have no impact until a new compression is started.\n    if nbWorkers>=1, new parameters will be picked up at next job,\n       with a few restrictions (windowLog, pledgedSrcSize, nbWorkers, jobSize, and overlapLog are not updated).\n \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_compressStream2_simpleArgs (\n                ZSTD_CCtx* cctx,\n                void* dst, size_t dstCapacity, size_t* dstPos,\n          const void* src, size_t srcSize, size_t* srcPos,\n                ZSTD_EndDirective endOp);\n
  Same as ZSTD_compressStream2(),\n  but using only integral types as arguments.\n  This variant might be helpful for binders from dynamic languages\n  which have troubles handling structures containing memory pointers.\n \n

\n\n
Advanced decompression functions
\n\n
ZSTDLIB_STATIC_API unsigned ZSTD_isFrame(const void* buffer, size_t size);\n
  Tells if the content of `buffer` starts with a valid Frame Identifier.\n  Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.\n  Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled.\n  Note 3 : Skippable Frame Identifiers are considered valid. \n

\n\n
ZSTDLIB_STATIC_API ZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize);\n
  Create a digested dictionary, ready to start decompression operation without startup delay.\n  Dictionary content is referenced, and therefore stays in dictBuffer.\n  It is important that dictBuffer outlives DDict,\n  it must remain read accessible throughout the lifetime of DDict \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);\n
  Same as ZSTD_DCtx_loadDictionary(),\n  but references `dict` content instead of copying it into `dctx`.\n  This saves memory if `dict` remains around.,\n  However, it's imperative that `dict` remains accessible (and unmodified) while being used, so it must outlive decompression. \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx, const void* dict, size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod, ZSTD_dictContentType_e dictContentType);\n
  Same as ZSTD_DCtx_loadDictionary(),\n  but gives direct control over\n  how to load the dictionary (by copy ? by reference ?)\n  and how to interpret it (automatic ? force raw mode ? full mode only ?). \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType);\n
  Same as ZSTD_DCtx_refPrefix(), but gives finer control over\n  how to interpret prefix content (automatic ? force raw mode (default) ? full mode only ?) \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize);\n
  Refuses allocating internal buffers for frames requiring a window size larger than provided limit.\n  This protects a decoder context from reserving too much memory for itself (potential attack scenario).\n  This parameter is only useful in streaming mode, since no internal buffer is allocated in single-pass mode.\n  By default, a decompression context accepts all window sizes <= (1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT)\n @return : 0, or an error code (which can be tested using ZSTD_isError()).\n \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_DCtx_getParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int* value);\n
  Get the requested decompression parameter value, selected by enum ZSTD_dParameter,\n  and store it into int* value.\n @return : 0, or an error code (which can be tested with ZSTD_isError()).\n \n

\n\n
ZSTD_DEPRECATED(\"use ZSTD_DCtx_setParameter() instead\")\nZSTDLIB_STATIC_API\nsize_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format);\n
  This function is REDUNDANT. Prefer ZSTD_DCtx_setParameter().\n  Instruct the decoder context about what kind of data to decode next.\n  This instruction is mandatory to decode data without a fully-formed header,\n  such ZSTD_f_zstd1_magicless for example.\n @return : 0, or an error code (which can be tested using ZSTD_isError()). \n

\n\n
ZSTDLIB_STATIC_API size_t ZSTD_decompressStream_simpleArgs (\n                ZSTD_DCtx* dctx,\n                void* dst, size_t dstCapacity, size_t* dstPos,\n          const void* src, size_t srcSize, size_t* srcPos);\n
  Same as ZSTD_decompressStream(),\n  but using only integral types as arguments.\n  This can be helpful for binders from dynamic languages\n  which have troubles handling structures containing memory pointers.\n \n

\n\n
Advanced streaming functions
  Warning : most of these functions are now redundant with the Advanced API.\n  Once Advanced API reaches \"stable\" status,\n  redundant functions will be deprecated, and then at some point removed.\n
\n\n
Advanced Streaming compression functions

\n
ZSTD_DEPRECATED(\"use ZSTD_CCtx_reset, see zstd.h for detailed instructions\")\nZSTDLIB_STATIC_API\nsize_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs,\n             int compressionLevel,\n             unsigned long long pledgedSrcSize);\n
 This function is DEPRECATED, and equivalent to:\n     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n     ZSTD_CCtx_refCDict(zcs, NULL); // clear the dictionary (if any)\n     ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);\n     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);\n\n pledgedSrcSize must be correct. If it is not known at init time, use\n ZSTD_CONTENTSIZE_UNKNOWN. Note that, for compatibility with older programs,\n \"0\" also disables frame content size field. It may be enabled in the future.\n This prototype will generate compilation warnings.\n \n

\n\n
ZSTD_DEPRECATED(\"use ZSTD_CCtx_reset, see zstd.h for detailed instructions\")\nZSTDLIB_STATIC_API\nsize_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs,\n         const void* dict, size_t dictSize,\n               int compressionLevel);\n
 This function is DEPRECATED, and is equivalent to:\n     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n     ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel);\n     ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);\n\n Creates of an internal CDict (incompatible with static CCtx), except if\n dict == NULL or dictSize < 8, in which case no dict is used.\n Note: dict is loaded with ZSTD_dct_auto (treated as a full zstd dictionary if\n it begins with ZSTD_MAGIC_DICTIONARY, else as raw content) and ZSTD_dlm_byCopy.\n This prototype will generate compilation warnings.\n \n

\n\n
ZSTD_DEPRECATED(\"use ZSTD_CCtx_reset, see zstd.h for detailed instructions\")\nZSTDLIB_STATIC_API\nsize_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,\n        const void* dict, size_t dictSize,\n              ZSTD_parameters params,\n              unsigned long long pledgedSrcSize);\n
 This function is DEPRECATED, and is equivalent to:\n     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n     ZSTD_CCtx_setParams(zcs, params);\n     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);\n     ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);\n\n dict is loaded with ZSTD_dct_auto and ZSTD_dlm_byCopy.\n pledgedSrcSize must be correct.\n If srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN.\n This prototype will generate compilation warnings.\n \n

\n\n
ZSTD_DEPRECATED(\"use ZSTD_CCtx_reset and ZSTD_CCtx_refCDict, see zstd.h for detailed instructions\")\nZSTDLIB_STATIC_API\nsize_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);\n
 This function is DEPRECATED, and equivalent to:\n     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n     ZSTD_CCtx_refCDict(zcs, cdict);\n\n note : cdict will just be referenced, and must outlive compression session\n This prototype will generate compilation warnings.\n \n

\n\n
ZSTD_DEPRECATED(\"use ZSTD_CCtx_reset and ZSTD_CCtx_refCDict, see zstd.h for detailed instructions\")\nZSTDLIB_STATIC_API\nsize_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,\n                   const ZSTD_CDict* cdict,\n                         ZSTD_frameParameters fParams,\n                         unsigned long long pledgedSrcSize);\n
   This function is DEPRECATED, and is equivalent to:\n     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n     ZSTD_CCtx_setFParams(zcs, fParams);\n     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);\n     ZSTD_CCtx_refCDict(zcs, cdict);\n\n same as ZSTD_initCStream_usingCDict(), with control over frame parameters.\n pledgedSrcSize must be correct. If srcSize is not known at init time, use\n value ZSTD_CONTENTSIZE_UNKNOWN.\n This prototype will generate compilation warnings.\n \n

\n\n
ZSTD_DEPRECATED(\"use ZSTD_CCtx_reset, see zstd.h for detailed instructions\")\nZSTDLIB_STATIC_API\nsize_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize);\n
 This function is DEPRECATED, and is equivalent to:\n     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);\n Note: ZSTD_resetCStream() interprets pledgedSrcSize == 0 as ZSTD_CONTENTSIZE_UNKNOWN, but\n       ZSTD_CCtx_setPledgedSrcSize() does not do the same, so ZSTD_CONTENTSIZE_UNKNOWN must be\n       explicitly specified.\n\n  start a new frame, using same parameters from previous frame.\n  This is typically useful to skip dictionary loading stage, since it will reuse it in-place.\n  Note that zcs must be init at least once before using ZSTD_resetCStream().\n  If pledgedSrcSize is not known at reset time, use macro ZSTD_CONTENTSIZE_UNKNOWN.\n  If pledgedSrcSize > 0, its value must be correct, as it will be written in header, and controlled at the end.\n  For the time being, pledgedSrcSize==0 is interpreted as \"srcSize unknown\" for compatibility with older programs,\n  but it will change to mean \"empty\" in future version, so use macro ZSTD_CONTENTSIZE_UNKNOWN instead.\n @return : 0, or an error code (which can be tested using ZSTD_isError())\n  This prototype will generate compilation warnings.\n \n

\n\n
typedef struct {\n    unsigned long long ingested;   /* nb input bytes read and buffered */\n    unsigned long long consumed;   /* nb input bytes actually compressed */\n    unsigned long long produced;   /* nb of compressed bytes generated and buffered */\n    unsigned long long flushed;    /* nb of compressed bytes flushed : not provided; can be tracked from caller side */\n    unsigned currentJobID;         /* MT only : latest started job nb */\n    unsigned nbActiveWorkers;      /* MT only : nb of workers actively compressing at probe time */\n} ZSTD_frameProgression;\n

\n
ZSTDLIB_STATIC_API size_t ZSTD_toFlushNow(ZSTD_CCtx* cctx);\n
  Tell how many bytes are ready to be flushed immediately.\n  Useful for multithreading scenarios (nbWorkers >= 1).\n  Probe the oldest active job, defined as oldest job not yet entirely flushed,\n  and check its output buffer.\n @return : amount of data stored in oldest job and ready to be flushed immediately.\n  if @return == 0, it means either :\n  + there is no active job (could be checked with ZSTD_frameProgression()), or\n  + oldest job is still actively compressing data,\n    but everything it has produced has also been flushed so far,\n    therefore flush speed is limited by production speed of oldest job\n    irrespective of the speed of concurrent (and newer) jobs.\n \n

\n\n
Advanced Streaming decompression functions

\n
ZSTD_DEPRECATED(\"use ZSTD_DCtx_reset + ZSTD_DCtx_loadDictionary, see zstd.h for detailed instructions\")\nZSTDLIB_STATIC_API size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize);\n
\n     ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);\n     ZSTD_DCtx_loadDictionary(zds, dict, dictSize);\n\n note: no dictionary will be used if dict == NULL or dictSize < 8\n \n

\n\n
ZSTD_DEPRECATED(\"use ZSTD_DCtx_reset + ZSTD_DCtx_refDDict, see zstd.h for detailed instructions\")\nZSTDLIB_STATIC_API size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* zds, const ZSTD_DDict* ddict);\n
\n     ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);\n     ZSTD_DCtx_refDDict(zds, ddict);\n\n note : ddict is referenced, it must outlive decompression session\n \n

\n\n
ZSTD_DEPRECATED(\"use ZSTD_DCtx_reset, see zstd.h for detailed instructions\")\nZSTDLIB_STATIC_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);\n
\n     ZSTD_DCtx_reset(zds, ZSTD_reset_session_only);\n\n reuse decompression parameters from previous init; saves dictionary loading\n \n

\n\n
ZSTDLIB_STATIC_API void\nZSTD_registerSequenceProducer(\n  ZSTD_CCtx* cctx,\n  void* sequenceProducerState,\n  ZSTD_sequenceProducer_F sequenceProducer\n);\n
 Instruct zstd to use a block-level external sequence producer function.\n\n The sequenceProducerState must be initialized by the caller, and the caller is\n responsible for managing its lifetime. This parameter is sticky across\n compressions. It will remain set until the user explicitly resets compression\n parameters.\n\n Sequence producer registration is considered to be an \"advanced parameter\",\n part of the \"advanced API\". This means it will only have an effect on compression\n APIs which respect advanced parameters, such as compress2() and compressStream2().\n Older compression APIs such as compressCCtx(), which predate the introduction of\n \"advanced parameters\", will ignore any external sequence producer setting.\n\n The sequence producer can be \"cleared\" by registering a NULL function pointer. This\n removes all limitations described above in the \"LIMITATIONS\" section of the API docs.\n\n The user is strongly encouraged to read the full API documentation (above) before\n calling this function. \n

\n\n
ZSTDLIB_STATIC_API void\nZSTD_CCtxParams_registerSequenceProducer(\n  ZSTD_CCtx_params* params,\n  void* sequenceProducerState,\n  ZSTD_sequenceProducer_F sequenceProducer\n);\n
 Same as ZSTD_registerSequenceProducer(), but operates on ZSTD_CCtx_params.\n This is used for accurate size estimation with ZSTD_estimateCCtxSize_usingCCtxParams(),\n which is needed when creating a ZSTD_CCtx with ZSTD_initStaticCCtx().\n\n If you are using the external sequence producer API in a scenario where ZSTD_initStaticCCtx()\n is required, then this function is for you. Otherwise, you probably don't need it.\n\n See tests/zstreamtest.c for example usage. \n

\n\n
Buffer-less and synchronous inner streaming functions (DEPRECATED)
\n  This API is deprecated, and will be removed in a future version.\n  It allows streaming (de)compression with user allocated buffers.\n  However, it is hard to use, and not as well tested as the rest of\n  our API.\n\n  Please use the normal streaming API instead: ZSTD_compressStream2,\n  and ZSTD_decompressStream.\n  If there is functionality that you need, but it doesn't provide,\n  please open an issue on our GitHub.\n \n
\n\n
Buffer-less streaming compression (synchronous mode)
\n  A ZSTD_CCtx object is required to track streaming operations.\n  Use ZSTD_createCCtx() / ZSTD_freeCCtx() to manage resource.\n  ZSTD_CCtx object can be reused multiple times within successive compression operations.\n\n  Start by initializing a context.\n  Use ZSTD_compressBegin(), or ZSTD_compressBegin_usingDict() for dictionary compression.\n\n  Then, consume your input using ZSTD_compressContinue().\n  There are some important considerations to keep in mind when using this advanced function :\n  - ZSTD_compressContinue() has no internal buffer. It uses externally provided buffers only.\n  - Interface is synchronous : input is consumed entirely and produces 1+ compressed blocks.\n  - Caller must ensure there is enough space in `dst` to store compressed data under worst case scenario.\n    Worst case evaluation is provided by ZSTD_compressBound().\n    ZSTD_compressContinue() doesn't guarantee recover after a failed compression.\n  - ZSTD_compressContinue() presumes prior input ***is still accessible and unmodified*** (up to maximum distance size, see WindowLog).\n    It remembers all previous contiguous blocks, plus one separated memory segment (which can itself consists of multiple contiguous blocks)\n  - ZSTD_compressContinue() detects that prior input has been overwritten when `src` buffer overlaps.\n    In which case, it will \"discard\" the relevant memory section from its history.\n\n  Finish a frame with ZSTD_compressEnd(), which will write the last block(s) and optional checksum.\n  It's possible to use srcSize==0, in which case, it will write a final empty block to end the frame.\n  Without last block mark, frames are considered unfinished (hence corrupted) by compliant decoders.\n\n  `ZSTD_CCtx` object can be reused (ZSTD_compressBegin()) to compress again.\n
\n\n
Buffer-less streaming compression functions
ZSTD_DEPRECATED(\"The buffer-less API is deprecated in favor of the normal streaming API. See docs.\")\nZSTDLIB_STATIC_API size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel);\nZSTD_DEPRECATED(\"The buffer-less API is deprecated in favor of the normal streaming API. See docs.\")\nZSTDLIB_STATIC_API size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel);\nZSTD_DEPRECATED(\"The buffer-less API is deprecated in favor of the normal streaming API. See docs.\")\nZSTDLIB_STATIC_API size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict); /**< note: fails if cdict==NULL */\n

\n
size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx, unsigned long long pledgedSrcSize); /**<  note: if pledgedSrcSize is not known, use ZSTD_CONTENTSIZE_UNKNOWN */\n

\n
size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, ZSTD_parameters params, unsigned long long pledgedSrcSize); /**< pledgedSrcSize : If srcSize is not known at init time, use ZSTD_CONTENTSIZE_UNKNOWN */\n

\n
Buffer-less streaming decompression (synchronous mode)
\n  A ZSTD_DCtx object is required to track streaming operations.\n  Use ZSTD_createDCtx() / ZSTD_freeDCtx() to manage it.\n  A ZSTD_DCtx object can be reused multiple times.\n\n  First typical operation is to retrieve frame parameters, using ZSTD_getFrameHeader().\n  Frame header is extracted from the beginning of compressed frame, so providing only the frame's beginning is enough.\n  Data fragment must be large enough to ensure successful decoding.\n `ZSTD_frameHeaderSize_max` bytes is guaranteed to always be large enough.\n  result  : 0 : successful decoding, the `ZSTD_frameHeader` structure is correctly filled.\n           >0 : `srcSize` is too small, please provide at least result bytes on next attempt.\n           errorCode, which can be tested using ZSTD_isError().\n\n  It fills a ZSTD_FrameHeader structure with important information to correctly decode the frame,\n  such as the dictionary ID, content size, or maximum back-reference distance (`windowSize`).\n  Note that these values could be wrong, either because of data corruption, or because a 3rd party deliberately spoofs false information.\n  As a consequence, check that values remain within valid application range.\n  For example, do not allocate memory blindly, check that `windowSize` is within expectation.\n  Each application can set its own limits, depending on local restrictions.\n  For extended interoperability, it is recommended to support `windowSize` of at least 8 MB.\n\n  ZSTD_decompressContinue() needs previous data blocks during decompression, up to `windowSize` bytes.\n  ZSTD_decompressContinue() is very sensitive to contiguity,\n  if 2 blocks don't follow each other, make sure that either the compressor breaks contiguity at the same place,\n  or that previous contiguous segment is large enough to properly handle maximum back-reference distance.\n  There are multiple ways to guarantee this condition.\n\n  The most memory efficient way is to use a round buffer of sufficient size.\n  Sufficient size is determined by invoking ZSTD_decodingBufferSize_min(),\n  which can return an error code if required value is too large for current system (in 32-bits mode).\n  In a round buffer methodology, ZSTD_decompressContinue() decompresses each block next to previous one,\n  up to the moment there is not enough room left in the buffer to guarantee decoding another full block,\n  which maximum size is provided in `ZSTD_frameHeader` structure, field `blockSizeMax`.\n  At which point, decoding can resume from the beginning of the buffer.\n  Note that already decoded data stored in the buffer should be flushed before being overwritten.\n\n  There are alternatives possible, for example using two or more buffers of size `windowSize` each, though they consume more memory.\n\n  Finally, if you control the compression process, you can also ignore all buffer size rules,\n  as long as the encoder and decoder progress in \"lock-step\",\n  aka use exactly the same buffer sizes, break contiguity at the same place, etc.\n\n  Once buffers are setup, start decompression, with ZSTD_decompressBegin().\n  If decompression requires a dictionary, use ZSTD_decompressBegin_usingDict() or ZSTD_decompressBegin_usingDDict().\n\n  Then use ZSTD_nextSrcSizeToDecompress() and ZSTD_decompressContinue() alternatively.\n  ZSTD_nextSrcSizeToDecompress() tells how many bytes to provide as 'srcSize' to ZSTD_decompressContinue().\n  ZSTD_decompressContinue() requires this _exact_ amount of bytes, or it will fail.\n\n  result of ZSTD_decompressContinue() is the number of bytes regenerated within 'dst' (necessarily <= dstCapacity).\n  It can be zero : it just means ZSTD_decompressContinue() has decoded some metadata item.\n  It can also be an error code, which can be tested with ZSTD_isError().\n\n  A frame is fully decoded when ZSTD_nextSrcSizeToDecompress() returns zero.\n  Context can then be reset to start a new decompression.\n\n  Note : it's possible to know if next input to present is a header or a block, using ZSTD_nextInputType().\n  This information is not required to properly decode a frame.\n\n  == Special case : skippable frames \n\n  Skippable frames allow integration of user-defined data into a flow of concatenated frames.\n  Skippable frames will be ignored (skipped) by decompressor.\n  The format of skippable frames is as follows :\n  a) Skippable frame ID - 4 Bytes, Little endian format, any value from 0x184D2A50 to 0x184D2A5F\n  b) Frame Size - 4 Bytes, Little endian format, unsigned 32-bits\n  c) Frame Content - any content (User Data) of length equal to Frame Size\n  For skippable frames ZSTD_getFrameHeader() returns zfhPtr->frameType==ZSTD_skippableFrame.\n  For skippable frames ZSTD_decompressContinue() always returns 0 : it only skips the content.\n
\n\n
Buffer-less streaming decompression functions

\n
ZSTDLIB_STATIC_API size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize);  /**< when frame content size is not known, pass in frameContentSize == ZSTD_CONTENTSIZE_UNKNOWN */\n

\n
typedef enum { ZSTDnit_frameHeader, ZSTDnit_blockHeader, ZSTDnit_block, ZSTDnit_lastBlock, ZSTDnit_checksum, ZSTDnit_skippableFrame } ZSTD_nextInputType_e;\n

\n
Block level API (DEPRECATED)
\n\n
    You can get the frame header down to 2 bytes by setting:\n      - ZSTD_c_format = ZSTD_f_zstd1_magicless\n      - ZSTD_c_contentSizeFlag = 0\n      - ZSTD_c_checksumFlag = 0\n      - ZSTD_c_dictIDFlag = 0\n\n    This API is not as well tested as our normal API, so we recommend not using it.\n    We will be removing it in a future version. If the normal API doesn't provide\n    the functionality you need, please open a GitHub issue.\n\n    Block functions produce and decode raw zstd blocks, without frame metadata.\n    Frame metadata cost is typically ~12 bytes, which can be non-negligible for very small blocks (< 100 bytes).\n    But users will have to take in charge needed metadata to regenerate data, such as compressed and content sizes.\n\n    A few rules to respect :\n    - Compressing and decompressing require a context structure\n      + Use ZSTD_createCCtx() and ZSTD_createDCtx()\n    - It is necessary to init context before starting\n      + compression : any ZSTD_compressBegin*() variant, including with dictionary\n      + decompression : any ZSTD_decompressBegin*() variant, including with dictionary\n    - Block size is limited, it must be <= ZSTD_getBlockSize() <= ZSTD_BLOCKSIZE_MAX == 128 KB\n      + If input is larger than a block size, it's necessary to split input data into multiple blocks\n      + For inputs larger than a single block, consider using regular ZSTD_compress() instead.\n        Frame metadata is not that costly, and quickly becomes negligible as source size grows larger than a block.\n    - When a block is considered not compressible enough, ZSTD_compressBlock() result will be 0 (zero) !\n      ===> In which case, nothing is produced into `dst` !\n      + User __must__ test for such outcome and deal directly with uncompressed data\n      + A block cannot be declared incompressible if ZSTD_compressBlock() return value was != 0.\n        Doing so would mess up with statistics history, leading to potential data corruption.\n      + ZSTD_decompressBlock() _doesn't accept uncompressed data as input_ !!\n      + In case of multiple successive blocks, should some of them be uncompressed,\n        decoder must be informed of their existence in order to follow proper history.\n        Use ZSTD_insertBlock() for such a case.\n

\n\n
Raw zstd block functions
ZSTD_DEPRECATED(\"The block API is deprecated in favor of the normal compression API. See docs.\")\nZSTDLIB_STATIC_API size_t ZSTD_getBlockSize   (const ZSTD_CCtx* cctx);\nZSTD_DEPRECATED(\"The block API is deprecated in favor of the normal compression API. See docs.\")\nZSTDLIB_STATIC_API size_t ZSTD_compressBlock  (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);\nZSTD_DEPRECATED(\"The block API is deprecated in favor of the normal compression API. See docs.\")\nZSTDLIB_STATIC_API size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);\nZSTD_DEPRECATED(\"The block API is deprecated in favor of the normal compression API. See docs.\")\nZSTDLIB_STATIC_API size_t ZSTD_insertBlock    (ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize);  /**< insert uncompressed block into `dctx` history. Useful for multi-blocks decompression. */\n

\n\n\n"
  },
  {
    "path": "examples/.gitignore",
    "content": "#build\nsimple_compression\nsimple_decompression\nmultiple_simple_compression\ndictionary_compression\ndictionary_decompression\nstreaming_compression\nstreaming_decompression\nmultiple_streaming_compression\nstreaming_memory_usage\n\n#test artefact\ntmp*\ntest*\n*.zst\n"
  },
  {
    "path": "examples/Makefile",
    "content": "# ################################################################\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n# All rights reserved.\n#\n# This source code is licensed under both the BSD-style license (found in the\n# LICENSE file in the root directory of this source tree) and the GPLv2 (found\n# in the COPYING file in the root directory of this source tree).\n# You may select, at your option, one of the above-listed licenses.\n# ################################################################\n\nLIBDIR =../lib\nCPPFLAGS += -I$(LIBDIR)\nLIB = $(LIBDIR)/libzstd.a\n\n\n.PHONY: default\ndefault: all\n\n.PHONY: all\nall: simple_compression simple_decompression \\\n\tmultiple_simple_compression\\\n\tdictionary_compression dictionary_decompression \\\n\tstreaming_compression streaming_decompression \\\n\tmultiple_streaming_compression streaming_memory_usage\n\n$(LIB) :\n\t$(MAKE) -C $(LIBDIR) libzstd.a\n\nsimple_compression.o: common.h\nsimple_compression : $(LIB)\n\nsimple_decompression.o: common.h\nsimple_decompression : $(LIB)\n\nmultiple_simple_compression.o: common.h\nmultiple_simple_compression : $(LIB)\n\ndictionary_compression.o: common.h\ndictionary_compression : $(LIB)\n\ndictionary_decompression.o: common.h\ndictionary_decompression : $(LIB)\n\nstreaming_compression.o: common.h\nstreaming_compression : $(LIB)\n\nmultiple_streaming_compression.o: common.h\nmultiple_streaming_compression : $(LIB)\n\nstreaming_decompression.o: common.h\nstreaming_decompression : $(LIB)\n\nstreaming_memory_usage.o: common.h\nstreaming_memory_usage : $(LIB)\n\n\n.PHONY:clean\nclean:\n\t@$(RM) core *.o tmp* result* *.zst \\\n        simple_compression simple_decompression \\\n        multiple_simple_compression \\\n        dictionary_compression dictionary_decompression \\\n        streaming_compression streaming_decompression \\\n        multiple_streaming_compression streaming_memory_usage\n\t@echo Cleaning completed\n\n.PHONY:test\ntest: all\n\tcp README.md tmp\n\tcp Makefile tmp2\n\t@echo -- Simple compression tests\n\t./simple_compression tmp\n\t./simple_decompression tmp.zst\n\t./multiple_simple_compression *.c\n\t./streaming_decompression tmp.zst > /dev/null\n\t@echo -- Streaming memory usage\n\t./streaming_memory_usage\n\t@echo -- Streaming compression tests\n\t./streaming_compression tmp\n\t./streaming_decompression tmp.zst > /dev/null\n\t@echo -- Edge cases detection\n\t! ./streaming_decompression tmp    # invalid input, must fail\n\t! ./simple_decompression tmp       # invalid input, must fail\n\ttouch tmpNull                      # create 0-size file\n\t./simple_compression tmpNull\n\t./simple_decompression tmpNull.zst # 0-size frame : must work\n\t@echo -- Multiple streaming tests\n\t./multiple_streaming_compression *.c\n\t@echo -- Dictionary compression tests\n\t./dictionary_compression tmp2 tmp README.md\n\t./dictionary_decompression tmp2.zst tmp.zst README.md\n\t$(RM) tmp* *.zst\n\t@echo tests completed\n"
  },
  {
    "path": "examples/README.md",
    "content": "Zstandard library : usage examples\n==================================\n\n- [Simple compression](simple_compression.c) :\n  Compress a single file.\n  Introduces usage of : `ZSTD_compress()`\n\n- [Simple decompression](simple_decompression.c) :\n  Decompress a single file.\n  Only compatible with simple compression.\n  Result remains in memory.\n  Introduces usage of : `ZSTD_decompress()`\n\n- [Multiple simple compression](multiple_simple_compression.c) :\n  Compress multiple files (in simple mode) in a single command line.\n  Demonstrates memory preservation technique that\n  minimizes malloc()/free() calls by re-using existing resources.\n  Introduces usage of : `ZSTD_compressCCtx()`\n\n- [Streaming memory usage](streaming_memory_usage.c) :\n  Provides amount of memory used by streaming context.\n  Introduces usage of : `ZSTD_sizeof_CStream()`\n\n- [Streaming compression](streaming_compression.c) :\n  Compress a single file.\n  Introduces usage of : `ZSTD_compressStream()`\n\n- [Multiple Streaming compression](multiple_streaming_compression.c) :\n  Compress multiple files (in streaming mode) in a single command line.\n  Introduces memory usage preservation technique,\n  reducing impact of malloc()/free() and memset() by re-using existing resources.\n\n- [Streaming decompression](streaming_decompression.c) :\n  Decompress a single file compressed by zstd.\n  Compatible with both simple and streaming compression.\n  Result is sent to stdout.\n  Introduces usage of : `ZSTD_decompressStream()`\n\n- [Dictionary compression](dictionary_compression.c) :\n  Compress multiple files using the same dictionary.\n  Introduces usage of : `ZSTD_createCDict()` and `ZSTD_compress_usingCDict()`\n\n- [Dictionary decompression](dictionary_decompression.c) :\n  Decompress multiple files using the same dictionary.\n  Result remains in memory.\n  Introduces usage of : `ZSTD_createDDict()` and `ZSTD_decompress_usingDDict()`\n"
  },
  {
    "path": "examples/common.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/*\n * This header file has common utility functions used in examples.\n */\n#ifndef COMMON_H\n#define COMMON_H\n\n#include     // malloc, free, exit\n#include      // fprintf, perror, fopen, etc.\n#include     // strerror\n#include      // errno\n#include   // stat\n#include \n\n\n/* UNUSED_ATTR tells the compiler it is okay if the function is unused. */\n#if defined(__GNUC__)\n#  define UNUSED_ATTR __attribute__((unused))\n#else\n#  define UNUSED_ATTR\n#endif\n\n#define HEADER_FUNCTION static UNUSED_ATTR\n\n\n/*\n * Define the returned error code from utility functions.\n */\ntypedef enum {\n    ERROR_fsize = 1,\n    ERROR_fopen = 2,\n    ERROR_fclose = 3,\n    ERROR_fread = 4,\n    ERROR_fwrite = 5,\n    ERROR_loadFile = 6,\n    ERROR_saveFile = 7,\n    ERROR_malloc = 8,\n    ERROR_largeFile = 9,\n} COMMON_ErrorCode;\n\n/*! CHECK\n * Check that the condition holds. If it doesn't print a message and die.\n */\n#define CHECK(cond, ...)                        \\\n    do {                                        \\\n        if (!(cond)) {                          \\\n            fprintf(stderr,                     \\\n                    \"%s:%d CHECK(%s) failed: \", \\\n                    __FILE__,                   \\\n                    __LINE__,                   \\\n                    #cond);                     \\\n            fprintf(stderr, \"\" __VA_ARGS__);    \\\n            fprintf(stderr, \"\\n\");              \\\n            exit(1);                            \\\n        }                                       \\\n    } while (0)\n\n/*! CHECK_ZSTD\n * Check the zstd error code and die if an error occurred after printing a\n * message.\n */\n#define CHECK_ZSTD(fn)                                           \\\n    do {                                                         \\\n        size_t const err = (fn);                                 \\\n        CHECK(!ZSTD_isError(err), \"%s\", ZSTD_getErrorName(err)); \\\n    } while (0)\n\n/*! fsize_orDie() :\n * Get the size of a given file path.\n *\n * @return The size of a given file path.\n */\nHEADER_FUNCTION size_t fsize_orDie(const char *filename)\n{\n    struct stat st;\n    if (stat(filename, &st) != 0) {\n        /* error */\n        perror(filename);\n        exit(ERROR_fsize);\n    }\n\n    off_t const fileSize = st.st_size;\n    size_t const size = (size_t)fileSize;\n    /* 1. fileSize should be non-negative,\n     * 2. if off_t -> size_t type conversion results in discrepancy,\n     *    the file size is too large for type size_t.\n     */\n    if ((fileSize < 0) || (fileSize != (off_t)size)) {\n        fprintf(stderr, \"%s : filesize too large \\n\", filename);\n        exit(ERROR_largeFile);\n    }\n    return size;\n}\n\n/*! fopen_orDie() :\n * Open a file using given file path and open option.\n *\n * @return If successful this function will return a FILE pointer to an\n * opened file otherwise it sends an error to stderr and exits.\n */\nHEADER_FUNCTION FILE* fopen_orDie(const char *filename, const char *instruction)\n{\n    FILE* const inFile = fopen(filename, instruction);\n    if (inFile) return inFile;\n    /* error */\n    perror(filename);\n    exit(ERROR_fopen);\n}\n\n/*! fclose_orDie() :\n * Close an opened file using given FILE pointer.\n */\nHEADER_FUNCTION void fclose_orDie(FILE* file)\n{\n    if (!fclose(file)) { return; };\n    /* error */\n    perror(\"fclose\");\n    exit(ERROR_fclose);\n}\n\n/*! fread_orDie() :\n *\n * Read sizeToRead bytes from a given file, storing them at the\n * location given by buffer.\n *\n * @return The number of bytes read.\n */\nHEADER_FUNCTION size_t fread_orDie(void* buffer, size_t sizeToRead, FILE* file)\n{\n    size_t const readSize = fread(buffer, 1, sizeToRead, file);\n    if (readSize == sizeToRead) return readSize;   /* good */\n    if (feof(file)) return readSize;   /* good, reached end of file */\n    /* error */\n    perror(\"fread\");\n    exit(ERROR_fread);\n}\n\n/*! fwrite_orDie() :\n *\n * Write sizeToWrite bytes to a file pointed to by file, obtaining\n * them from a location given by buffer.\n *\n * Note: This function will send an error to stderr and exit if it\n * cannot write data to the given file pointer.\n *\n * @return The number of bytes written.\n */\nHEADER_FUNCTION size_t fwrite_orDie(const void* buffer, size_t sizeToWrite, FILE* file)\n{\n    size_t const writtenSize = fwrite(buffer, 1, sizeToWrite, file);\n    if (writtenSize == sizeToWrite) return sizeToWrite;   /* good */\n    /* error */\n    perror(\"fwrite\");\n    exit(ERROR_fwrite);\n}\n\n/*! malloc_orDie() :\n * Allocate memory.\n *\n * @return If successful this function returns a pointer to allo-\n * cated memory.  If there is an error, this function will send that\n * error to stderr and exit.\n */\nHEADER_FUNCTION void* malloc_orDie(size_t size)\n{\n    void* const buff = malloc(size);\n    if (buff) return buff;\n    /* error */\n    perror(\"malloc\");\n    exit(ERROR_malloc);\n}\n\n/*! loadFile_orDie() :\n * load file into buffer (memory).\n *\n * Note: This function will send an error to stderr and exit if it\n * cannot read data from the given file path.\n *\n * @return If successful this function will load file into buffer and\n * return file size, otherwise it will printout an error to stderr and exit.\n */\nHEADER_FUNCTION size_t loadFile_orDie(const char* fileName, void* buffer, size_t bufferSize)\n{\n    size_t const fileSize = fsize_orDie(fileName);\n    CHECK(fileSize <= bufferSize, \"File too large!\");\n\n    FILE* const inFile = fopen_orDie(fileName, \"rb\");\n    size_t const readSize = fread(buffer, 1, fileSize, inFile);\n    if (readSize != (size_t)fileSize) {\n        fprintf(stderr, \"fread: %s : %s \\n\", fileName, strerror(errno));\n        exit(ERROR_fread);\n    }\n    fclose(inFile);  /* can't fail, read only */\n    return fileSize;\n}\n\n/*! mallocAndLoadFile_orDie() :\n * allocate memory buffer and then load file into it.\n *\n * Note: This function will send an error to stderr and exit if memory allocation\n * fails or it cannot read data from the given file path.\n *\n * @return If successful this function will return buffer and bufferSize(=fileSize),\n * otherwise it will printout an error to stderr and exit.\n */\nHEADER_FUNCTION void* mallocAndLoadFile_orDie(const char* fileName, size_t* bufferSize)\n{\n    size_t const fileSize = fsize_orDie(fileName);\n    *bufferSize = fileSize;\n    void* const buffer = malloc_orDie(*bufferSize);\n    loadFile_orDie(fileName, buffer, *bufferSize);\n    return buffer;\n}\n\n/*! saveFile_orDie() :\n *\n * Save buffSize bytes to a given file path, obtaining them from a location pointed\n * to by buff.\n *\n * Note: This function will send an error to stderr and exit if it\n * cannot write to a given file.\n */\nHEADER_FUNCTION void saveFile_orDie(const char* fileName, const void* buff, size_t buffSize)\n{\n    FILE* const oFile = fopen_orDie(fileName, \"wb\");\n    size_t const wSize = fwrite(buff, 1, buffSize, oFile);\n    if (wSize != (size_t)buffSize) {\n        fprintf(stderr, \"fwrite: %s : %s \\n\", fileName, strerror(errno));\n        exit(ERROR_fwrite);\n    }\n    if (fclose(oFile)) {\n        perror(fileName);\n        exit(ERROR_fclose);\n    }\n}\n\n#endif\n"
  },
  {
    "path": "examples/dictionary_compression.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n**/\n\n/* This example deals with Dictionary compression,\n * its counterpart is `examples/dictionary_decompression.c` .\n * These examples presume that a dictionary already exists.\n * The main method to create a dictionary is `zstd --train`,\n * look at the CLI documentation for details.\n * Another possible method is to employ dictionary training API,\n * published in `lib/zdict.h` .\n**/\n\n#include      // printf\n#include     // free\n#include     // memset, strcat\n#include       // presumes zstd library is installed\n#include \"common.h\"    // Helper functions, CHECK(), and CHECK_ZSTD()\n\n/* createDict() :\n** `dictFileName` is supposed already created using `zstd --train` */\nstatic ZSTD_CDict* createCDict_orDie(const char* dictFileName, int cLevel)\n{\n    size_t dictSize;\n    printf(\"loading dictionary %s \\n\", dictFileName);\n    void* const dictBuffer = mallocAndLoadFile_orDie(dictFileName, &dictSize);\n    ZSTD_CDict* const cdict = ZSTD_createCDict(dictBuffer, dictSize, cLevel);\n    CHECK(cdict != NULL, \"ZSTD_createCDict() failed!\");\n    free(dictBuffer);\n    return cdict;\n}\n\n\nstatic void compress(const char* fname, const char* oname, const ZSTD_CDict* cdict)\n{\n    size_t fSize;\n    void* const fBuff = mallocAndLoadFile_orDie(fname, &fSize);\n    size_t const cBuffSize = ZSTD_compressBound(fSize);\n    void* const cBuff = malloc_orDie(cBuffSize);\n\n    /* Compress using the dictionary.\n     * This function writes the dictionary id, and content size into the header.\n     * But, it doesn't use a checksum. You can control these options using the\n     * advanced API: ZSTD_CCtx_setParameter(), ZSTD_CCtx_refCDict(),\n     * and ZSTD_compress2().\n     */\n    ZSTD_CCtx* const cctx = ZSTD_createCCtx();\n    CHECK(cctx != NULL, \"ZSTD_createCCtx() failed!\");\n    size_t const cSize = ZSTD_compress_usingCDict(cctx, cBuff, cBuffSize, fBuff, fSize, cdict);\n    CHECK_ZSTD(cSize);\n\n    saveFile_orDie(oname, cBuff, cSize);\n\n    /* success */\n    printf(\"%25s : %6u -> %7u - %s \\n\", fname, (unsigned)fSize, (unsigned)cSize, oname);\n\n    ZSTD_freeCCtx(cctx);   /* never fails */\n    free(fBuff);\n    free(cBuff);\n}\n\n\nstatic char* createOutFilename_orDie(const char* filename)\n{\n    size_t const inL = strlen(filename);\n    size_t const outL = inL + 5;\n    void* outSpace = malloc_orDie(outL);\n    memset(outSpace, 0, outL);\n    strcat(outSpace, filename);\n    strcat(outSpace, \".zst\");\n    return (char*)outSpace;\n}\n\nint main(int argc, const char** argv)\n{\n    const char* const exeName = argv[0];\n    int const cLevel = 3;\n\n    if (argc<3) {\n        fprintf(stderr, \"wrong arguments\\n\");\n        fprintf(stderr, \"usage:\\n\");\n        fprintf(stderr, \"%s [FILES] dictionary\\n\", exeName);\n        return 1;\n    }\n\n    /* load dictionary only once */\n    const char* const dictName = argv[argc-1];\n    ZSTD_CDict* const dictPtr = createCDict_orDie(dictName, cLevel);\n\n    int u;\n    for (u=1; u     // printf\n#include     // free\n#include       // presumes zstd library is installed\n#include \"common.h\"    // Helper functions, CHECK(), and CHECK_ZSTD()\n\n/* createDict() :\n   `dictFileName` is supposed to have been created using `zstd --train` */\nstatic ZSTD_DDict* createDict_orDie(const char* dictFileName)\n{\n    size_t dictSize;\n    printf(\"loading dictionary %s \\n\", dictFileName);\n    void* const dictBuffer = mallocAndLoadFile_orDie(dictFileName, &dictSize);\n    ZSTD_DDict* const ddict = ZSTD_createDDict(dictBuffer, dictSize);\n    CHECK(ddict != NULL, \"ZSTD_createDDict() failed!\");\n    free(dictBuffer);\n    return ddict;\n}\n\nstatic void decompress(const char* fname, const ZSTD_DDict* ddict)\n{\n    size_t cSize;\n    void* const cBuff = mallocAndLoadFile_orDie(fname, &cSize);\n    /* Read the content size from the frame header. For simplicity we require\n     * that it is always present. By default, zstd will write the content size\n     * in the header when it is known. If you can't guarantee that the frame\n     * content size is always written into the header, either use streaming\n     * decompression, or ZSTD_decompressBound().\n     */\n    unsigned long long const rSize = ZSTD_getFrameContentSize(cBuff, cSize);\n    CHECK(rSize != ZSTD_CONTENTSIZE_ERROR, \"%s: not compressed by zstd!\", fname);\n    CHECK(rSize != ZSTD_CONTENTSIZE_UNKNOWN, \"%s: original size unknown!\", fname);\n    void* const rBuff = malloc_orDie((size_t)rSize);\n\n    /* Check that the dictionary ID matches.\n     * If a non-zstd dictionary is used, then both will be zero.\n     * By default zstd always writes the dictionary ID into the frame.\n     * Zstd will check if there is a dictionary ID mismatch as well.\n     */\n    unsigned const expectedDictID = ZSTD_getDictID_fromDDict(ddict);\n    unsigned const actualDictID = ZSTD_getDictID_fromFrame(cBuff, cSize);\n    CHECK(actualDictID == expectedDictID,\n          \"DictID mismatch: expected %u got %u\",\n          expectedDictID,\n          actualDictID);\n\n    /* Decompress using the dictionary.\n     * If you need to control the decompression parameters, then use the\n     * advanced API: ZSTD_DCtx_setParameter(), ZSTD_DCtx_refDDict(), and\n     * ZSTD_decompressDCtx().\n     */\n    ZSTD_DCtx* const dctx = ZSTD_createDCtx();\n    CHECK(dctx != NULL, \"ZSTD_createDCtx() failed!\");\n    size_t const dSize = ZSTD_decompress_usingDDict(dctx, rBuff, rSize, cBuff, cSize, ddict);\n    CHECK_ZSTD(dSize);\n    /* When zstd knows the content size, it will error if it doesn't match. */\n    CHECK(dSize == rSize, \"Impossible because zstd will check this condition!\");\n\n    /* success */\n    printf(\"%25s : %6u -> %7u \\n\", fname, (unsigned)cSize, (unsigned)rSize);\n\n    ZSTD_freeDCtx(dctx);\n    free(rBuff);\n    free(cBuff);\n}\n\n\nint main(int argc, const char** argv)\n{\n    const char* const exeName = argv[0];\n\n    if (argc<3) {\n        printf(\"wrong arguments\\n\");\n        printf(\"usage:\\n\");\n        printf(\"%s [FILES] dictionary\\n\", exeName);\n        return 1;\n    }\n\n    /* load dictionary only once */\n    const char* const dictName = argv[argc-1];\n    ZSTD_DDict* const dictPtr = createDict_orDie(dictName);\n\n    int u;\n    for (u=1; u     // printf\n#include     // free\n#include     // memcpy, strlen\n#include       // presumes zstd library is installed\n#include \"common.h\"    // Helper functions, CHECK(), and CHECK_ZSTD()\n\ntypedef struct {\n    void* fBuffer;\n    void* cBuffer;\n    size_t fBufferSize;\n    size_t cBufferSize;\n    ZSTD_CCtx* cctx;\n} resources;\n\n/*\n * allocate memory for buffers big enough to compress all files\n * as well as memory for output file name (ofn)\n */\nstatic resources createResources_orDie(int argc, const char** argv, char **ofn, size_t* ofnBufferLen)\n{\n    size_t maxFilenameLength=0;\n    size_t maxFileSize = 0;\n\n    int argNb;\n    for (argNb = 1; argNb < argc; argNb++) {\n      const char* const filename = argv[argNb];\n      size_t const filenameLength = strlen(filename);\n      size_t const fileSize = fsize_orDie(filename);\n\n      if (filenameLength > maxFilenameLength) maxFilenameLength = filenameLength;\n      if (fileSize > maxFileSize) maxFileSize = fileSize;\n    }\n\n    resources ress;\n    ress.fBufferSize = maxFileSize;\n    ress.cBufferSize = ZSTD_compressBound(maxFileSize);\n\n    *ofnBufferLen = maxFilenameLength + 5;\n    *ofn = (char*)malloc_orDie(*ofnBufferLen);\n    ress.fBuffer = malloc_orDie(ress.fBufferSize);\n    ress.cBuffer = malloc_orDie(ress.cBufferSize);\n    ress.cctx = ZSTD_createCCtx();\n    CHECK(ress.cctx != NULL, \"ZSTD_createCCtx() failed!\");\n    return ress;\n}\n\nstatic void freeResources(resources ress, char *outFilename)\n{\n    free(ress.fBuffer);\n    free(ress.cBuffer);\n    ZSTD_freeCCtx(ress.cctx);   /* never fails */\n    free(outFilename);\n}\n\n/* compress with pre-allocated context (ZSTD_CCtx) and input/output buffers*/\nstatic void compressFile_orDie(resources ress, const char* fname, const char* oname)\n{\n    size_t fSize = loadFile_orDie(fname, ress.fBuffer, ress.fBufferSize);\n\n    /* Compress using the context.\n     * If you need more control over parameters, use the advanced API:\n     * ZSTD_CCtx_setParameter(), and ZSTD_compress2().\n     */\n    size_t const cSize = ZSTD_compressCCtx(ress.cctx, ress.cBuffer, ress.cBufferSize, ress.fBuffer, fSize, 1);\n    CHECK_ZSTD(cSize);\n\n    saveFile_orDie(oname, ress.cBuffer, cSize);\n\n    /* success */\n    printf(\"%25s : %6u -> %7u - %s \\n\", fname, (unsigned)fSize, (unsigned)cSize, oname);\n}\n\nint main(int argc, const char** argv)\n{\n    const char* const exeName = argv[0];\n\n    if (argc<2) {\n        printf(\"wrong arguments\\n\");\n        printf(\"usage:\\n\");\n        printf(\"%s FILE(s)\\n\", exeName);\n        return 1;\n    }\n\n    /* memory allocation for outFilename and resources */\n    char* outFilename;\n    size_t outFilenameBufferLen;\n    resources const ress = createResources_orDie(argc, argv, &outFilename, &outFilenameBufferLen);\n\n    /* compress files with shared context, input and output buffers */\n    int argNb;\n    for (argNb = 1; argNb < argc; argNb++) {\n        const char* const inFilename = argv[argNb];\n        size_t const inFilenameLen = strlen(inFilename);\n        CHECK(inFilenameLen + 5 <= outFilenameBufferLen, \"File name too long!\");\n        memcpy(outFilename, inFilename, inFilenameLen);\n        memcpy(outFilename+inFilenameLen, \".zst\", 5);\n        compressFile_orDie(ress, inFilename, outFilename);\n    }\n\n    /* free memory */\n    freeResources(ress,outFilename);\n\n    printf(\"compressed %i files \\n\", argc-1);\n\n    return 0;\n}\n"
  },
  {
    "path": "examples/multiple_streaming_compression.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n\n/* The objective of this example is to show of to compress multiple successive files\n*  while preserving memory management.\n*  All structures and buffers will be created only once,\n*  and shared across all compression operations */\n\n#include      // printf\n#include     // free\n#include     // memset, strcat\n#include       // presumes zstd library is installed\n#include \"common.h\"    // Helper functions, CHECK(), and CHECK_ZSTD()\n\ntypedef struct {\n    void* buffIn;\n    void* buffOut;\n    size_t buffInSize;\n    size_t buffOutSize;\n    ZSTD_CCtx* cctx;\n} resources;\n\nstatic resources createResources_orDie(int cLevel)\n{\n    resources ress;\n    ress.buffInSize = ZSTD_CStreamInSize();   /* can always read one full block */\n    ress.buffOutSize= ZSTD_CStreamOutSize();  /* can always flush a full block */\n    ress.buffIn = malloc_orDie(ress.buffInSize);\n    ress.buffOut= malloc_orDie(ress.buffOutSize);\n    ress.cctx = ZSTD_createCCtx();\n    CHECK(ress.cctx != NULL, \"ZSTD_createCCtx() failed!\");\n\n    /* Set any compression parameters you want here.\n     * They will persist for every compression operation.\n     * Here we set the compression level, and enable the checksum.\n     */\n    CHECK_ZSTD( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_c_compressionLevel, cLevel) );\n    CHECK_ZSTD( ZSTD_CCtx_setParameter(ress.cctx, ZSTD_c_checksumFlag, 1) );\n    return ress;\n}\n\nstatic void freeResources(resources ress)\n{\n    ZSTD_freeCCtx(ress.cctx);\n    free(ress.buffIn);\n    free(ress.buffOut);\n}\n\nstatic void compressFile_orDie(resources ress, const char* fname, const char* outName)\n{\n    // Open the input and output files.\n    FILE* const fin  = fopen_orDie(fname, \"rb\");\n    FILE* const fout = fopen_orDie(outName, \"wb\");\n\n    /* Reset the context to a clean state to start a new compression operation.\n     * The parameters are sticky, so we keep the compression level and extra\n     * parameters that we set in createResources_orDie().\n     */\n    CHECK_ZSTD( ZSTD_CCtx_reset(ress.cctx, ZSTD_reset_session_only) );\n\n    size_t const toRead = ress.buffInSize;\n    size_t read;\n    while ( (read = fread_orDie(ress.buffIn, toRead, fin)) ) {\n        /* This loop is the same as streaming_compression.c.\n         * See that file for detailed comments.\n         */\n        int const lastChunk = (read < toRead);\n        ZSTD_EndDirective const mode = lastChunk ? ZSTD_e_end : ZSTD_e_continue;\n\n        ZSTD_inBuffer input = { ress.buffIn, read, 0 };\n        int finished;\n        do {\n            ZSTD_outBuffer output = { ress.buffOut, ress.buffOutSize, 0 };\n            size_t const remaining = ZSTD_compressStream2(ress.cctx, &output, &input, mode);\n            CHECK_ZSTD(remaining);\n            fwrite_orDie(ress.buffOut, output.pos, fout);\n            finished = lastChunk ? (remaining == 0) : (input.pos == input.size);\n        } while (!finished);\n        CHECK(input.pos == input.size,\n              \"Impossible: zstd only returns 0 when the input is completely consumed!\");\n    }\n\n    fclose_orDie(fout);\n    fclose_orDie(fin);\n}\n\nint main(int argc, const char** argv)\n{\n    const char* const exeName = argv[0];\n\n    if (argc<2) {\n        printf(\"wrong arguments\\n\");\n        printf(\"usage:\\n\");\n        printf(\"%s FILE(s)\\n\", exeName);\n        return 1;\n    }\n\n    int const cLevel = 7;\n    resources const ress = createResources_orDie(cLevel);\n    void* ofnBuffer = NULL;\n    size_t ofnbSize = 0;\n\n    int argNb;\n    for (argNb = 1; argNb < argc; argNb++) {\n        const char* const ifn = argv[argNb];\n        size_t const ifnSize = strlen(ifn);\n        size_t const ofnSize = ifnSize + 5;\n        if (ofnbSize <= ofnSize) {\n            ofnbSize = ofnSize + 16;\n            free(ofnBuffer);\n            ofnBuffer = malloc_orDie(ofnbSize);\n        }\n        memset(ofnBuffer, 0, ofnSize);\n        strcat(ofnBuffer, ifn);\n        strcat(ofnBuffer, \".zst\");\n        compressFile_orDie(ress, ifn, ofnBuffer);\n    }\n\n    freeResources(ress);\n    free(ofnBuffer);\n\n    printf(\"compressed %i files \\n\", argc-1);\n\n    return 0;\n}\n"
  },
  {
    "path": "examples/simple_compression.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#include      // printf\n#include     // free\n#include     // strlen, strcat, memset\n#include       // presumes zstd library is installed\n#include \"common.h\"    // Helper functions, CHECK(), and CHECK_ZSTD()\n\nstatic void compress_orDie(const char* fname, const char* oname)\n{\n    size_t fSize;\n    void* const fBuff = mallocAndLoadFile_orDie(fname, &fSize);\n    size_t const cBuffSize = ZSTD_compressBound(fSize);\n    void* const cBuff = malloc_orDie(cBuffSize);\n\n    /* Compress.\n     * If you are doing many compressions, you may want to reuse the context.\n     * See the multiple_simple_compression.c example.\n     */\n    size_t const cSize = ZSTD_compress(cBuff, cBuffSize, fBuff, fSize, 1);\n    CHECK_ZSTD(cSize);\n\n    saveFile_orDie(oname, cBuff, cSize);\n\n    /* success */\n    printf(\"%25s : %6u -> %7u - %s \\n\", fname, (unsigned)fSize, (unsigned)cSize, oname);\n\n    free(fBuff);\n    free(cBuff);\n}\n\nstatic char* createOutFilename_orDie(const char* filename)\n{\n    size_t const inL = strlen(filename);\n    size_t const outL = inL + 5;\n    void* const outSpace = malloc_orDie(outL);\n    memset(outSpace, 0, outL);\n    strcat(outSpace, filename);\n    strcat(outSpace, \".zst\");\n    return (char*)outSpace;\n}\n\nint main(int argc, const char** argv)\n{\n    const char* const exeName = argv[0];\n\n    if (argc!=2) {\n        printf(\"wrong arguments\\n\");\n        printf(\"usage:\\n\");\n        printf(\"%s FILE\\n\", exeName);\n        return 1;\n    }\n\n    const char* const inFilename = argv[1];\n\n    char* const outFilename = createOutFilename_orDie(inFilename);\n    compress_orDie(inFilename, outFilename);\n    free(outFilename);\n    return 0;\n}\n"
  },
  {
    "path": "examples/simple_decompression.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#include      // printf\n#include     // free\n#include       // presumes zstd library is installed\n#include \"common.h\"    // Helper functions, CHECK(), and CHECK_ZSTD()\n\nstatic void decompress(const char* fname)\n{\n    size_t cSize;\n    void* const cBuff = mallocAndLoadFile_orDie(fname, &cSize);\n    /* Read the content size from the frame header. For simplicity we require\n     * that it is always present. By default, zstd will write the content size\n     * in the header when it is known. If you can't guarantee that the frame\n     * content size is always written into the header, either use streaming\n     * decompression, or ZSTD_decompressBound().\n     */\n    unsigned long long const rSize = ZSTD_getFrameContentSize(cBuff, cSize);\n    CHECK(rSize != ZSTD_CONTENTSIZE_ERROR, \"%s: not compressed by zstd!\", fname);\n    CHECK(rSize != ZSTD_CONTENTSIZE_UNKNOWN, \"%s: original size unknown!\", fname);\n\n    void* const rBuff = malloc_orDie((size_t)rSize);\n\n    /* Decompress.\n     * If you are doing many decompressions, you may want to reuse the context\n     * and use ZSTD_decompressDCtx(). If you want to set advanced parameters,\n     * use ZSTD_DCtx_setParameter().\n     */\n    size_t const dSize = ZSTD_decompress(rBuff, rSize, cBuff, cSize);\n    CHECK_ZSTD(dSize);\n    /* When zstd knows the content size, it will error if it doesn't match. */\n    CHECK(dSize == rSize, \"Impossible because zstd will check this condition!\");\n\n    /* success */\n    printf(\"%25s : %6u -> %7u \\n\", fname, (unsigned)cSize, (unsigned)rSize);\n\n    free(rBuff);\n    free(cBuff);\n}\n\nint main(int argc, const char** argv)\n{\n    const char* const exeName = argv[0];\n\n    if (argc!=2) {\n        printf(\"wrong arguments\\n\");\n        printf(\"usage:\\n\");\n        printf(\"%s FILE\\n\", exeName);\n        return 1;\n    }\n\n    decompress(argv[1]);\n\n    printf(\"%s correctly decoded (in memory). \\n\", argv[1]);\n\n    return 0;\n}\n"
  },
  {
    "path": "examples/streaming_compression.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n\n#include      // printf\n#include     // free\n#include     // memset, strcat, strlen\n#include       // presumes zstd library is installed\n#include \"common.h\"    // Helper functions, CHECK(), and CHECK_ZSTD()\n\nstatic void compressFile_orDie(const char* fname, const char* outName, int cLevel,\n                               int nbThreads)\n{\n    fprintf (stderr, \"Starting compression of %s with level %d, using %d threads\\n\",\n             fname, cLevel, nbThreads);\n\n    /* Open the input and output files. */\n    FILE* const fin  = fopen_orDie(fname, \"rb\");\n    FILE* const fout = fopen_orDie(outName, \"wb\");\n    /* Create the input and output buffers.\n     * They may be any size, but we recommend using these functions to size them.\n     * Performance will only suffer significantly for very tiny buffers.\n     */\n    size_t const buffInSize = ZSTD_CStreamInSize();\n    void*  const buffIn  = malloc_orDie(buffInSize);\n    size_t const buffOutSize = ZSTD_CStreamOutSize();\n    void*  const buffOut = malloc_orDie(buffOutSize);\n\n    /* Create the context. */\n    ZSTD_CCtx* const cctx = ZSTD_createCCtx();\n    CHECK(cctx != NULL, \"ZSTD_createCCtx() failed!\");\n\n    /* Set any parameters you want.\n     * Here we set the compression level, and enable the checksum.\n     */\n    CHECK_ZSTD( ZSTD_CCtx_setParameter(cctx, ZSTD_c_compressionLevel, cLevel) );\n    CHECK_ZSTD( ZSTD_CCtx_setParameter(cctx, ZSTD_c_checksumFlag, 1) );\n    if (nbThreads > 1) {\n        size_t const r = ZSTD_CCtx_setParameter(cctx, ZSTD_c_nbWorkers, nbThreads);\n        if (ZSTD_isError(r)) {\n            fprintf (stderr, \"Note: the linked libzstd library doesn't support multithreading. \"\n                             \"Reverting to single-thread mode. \\n\");\n        }\n    }\n\n    /* This loop read from the input file, compresses that entire chunk,\n     * and writes all output produced to the output file.\n     */\n    size_t const toRead = buffInSize;\n    for (;;) {\n        size_t read = fread_orDie(buffIn, toRead, fin);\n        /* Select the flush mode.\n         * If the read may not be finished (read == toRead) we use\n         * ZSTD_e_continue. If this is the last chunk, we use ZSTD_e_end.\n         * Zstd optimizes the case where the first flush mode is ZSTD_e_end,\n         * since it knows it is compressing the entire source in one pass.\n         */\n        int const lastChunk = (read < toRead);\n        ZSTD_EndDirective const mode = lastChunk ? ZSTD_e_end : ZSTD_e_continue;\n        /* Set the input buffer to what we just read.\n         * We compress until the input buffer is empty, each time flushing the\n         * output.\n         */\n        ZSTD_inBuffer input = { buffIn, read, 0 };\n        int finished;\n        do {\n            /* Compress into the output buffer and write all of the output to\n             * the file so we can reuse the buffer next iteration.\n             */\n            ZSTD_outBuffer output = { buffOut, buffOutSize, 0 };\n            size_t const remaining = ZSTD_compressStream2(cctx, &output , &input, mode);\n            CHECK_ZSTD(remaining);\n            fwrite_orDie(buffOut, output.pos, fout);\n            /* If we're on the last chunk we're finished when zstd returns 0,\n             * which means its consumed all the input AND finished the frame.\n             * Otherwise, we're finished when we've consumed all the input.\n             */\n            finished = lastChunk ? (remaining == 0) : (input.pos == input.size);\n        } while (!finished);\n        CHECK(input.pos == input.size,\n              \"Impossible: zstd only returns 0 when the input is completely consumed!\");\n\n        if (lastChunk) {\n            break;\n        }\n    }\n\n    ZSTD_freeCCtx(cctx);\n    fclose_orDie(fout);\n    fclose_orDie(fin);\n    free(buffIn);\n    free(buffOut);\n}\n\n\nstatic char* createOutFilename_orDie(const char* filename)\n{\n    size_t const inL = strlen(filename);\n    size_t const outL = inL + 5;\n    void* const outSpace = malloc_orDie(outL);\n    memset(outSpace, 0, outL);\n    strcat(outSpace, filename);\n    strcat(outSpace, \".zst\");\n    return (char*)outSpace;\n}\n\nint main(int argc, const char** argv)\n{\n    const char* const exeName = argv[0];\n\n    if (argc < 2) {\n        printf(\"wrong arguments\\n\");\n        printf(\"usage:\\n\");\n        printf(\"%s FILE [LEVEL] [THREADS]\\n\", exeName);\n        return 1;\n    }\n\n    int cLevel = 1;\n    int nbThreads = 1;\n\n    if (argc >= 3) {\n      cLevel = atoi (argv[2]);\n      CHECK(cLevel != 0, \"can't parse LEVEL!\");\n    }\n\n    if (argc >= 4) {\n      nbThreads = atoi (argv[3]);\n      CHECK(nbThreads != 0, \"can't parse THREADS!\");\n    }\n\n    const char* const inFilename = argv[1];\n\n    char* const outFilename = createOutFilename_orDie(inFilename);\n    compressFile_orDie(inFilename, outFilename, cLevel, nbThreads);\n\n    free(outFilename);   /* not strictly required, since program execution stops there,\n                          * but some static analyzer may complain otherwise */\n    return 0;\n}\n"
  },
  {
    "path": "examples/streaming_compression_thread_pool.c",
    "content": "/*\n * Copyright (c) Martin Liska, SUSE, Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n\n#include      // printf\n#include     // free\n#include     // memset, strcat, strlen\n#include       // presumes zstd library is installed\n#include \"common.h\"    // Helper functions, CHECK(), and CHECK_ZSTD()\n#include \n\ntypedef struct compress_args\n{\n  const char *fname;\n  char *outName;\n  int cLevel;\n#if defined(ZSTD_STATIC_LINKING_ONLY)\n  ZSTD_threadPool *pool;\n#endif\n} compress_args_t;\n\nstatic void *compressFile_orDie(void *data)\n{\n    const int nbThreads = 16;\n\n    compress_args_t *args = (compress_args_t *)data;\n    fprintf (stderr, \"Starting compression of %s with level %d, using %d threads\\n\", args->fname, args->cLevel, nbThreads);\n    /* Open the input and output files. */\n    FILE* const fin  = fopen_orDie(args->fname, \"rb\");\n    FILE* const fout = fopen_orDie(args->outName, \"wb\");\n    /* Create the input and output buffers.\n     * They may be any size, but we recommend using these functions to size them.\n     * Performance will only suffer significantly for very tiny buffers.\n     */\n    size_t const buffInSize = ZSTD_CStreamInSize();\n    void*  const buffIn  = malloc_orDie(buffInSize);\n    size_t const buffOutSize = ZSTD_CStreamOutSize();\n    void*  const buffOut = malloc_orDie(buffOutSize);\n\n    /* Create the context. */\n    ZSTD_CCtx* const cctx = ZSTD_createCCtx();\n    CHECK(cctx != NULL, \"ZSTD_createCCtx() failed!\");\n\n#if defined(ZSTD_STATIC_LINKING_ONLY)\n    size_t r = ZSTD_CCtx_refThreadPool(cctx, args->pool);\n    CHECK(r == 0, \"ZSTD_CCtx_refThreadPool failed!\");\n#endif\n\n    /* Set any parameters you want.\n     * Here we set the compression level, and enable the checksum.\n     */\n    CHECK_ZSTD( ZSTD_CCtx_setParameter(cctx, ZSTD_c_compressionLevel, args->cLevel) );\n    CHECK_ZSTD( ZSTD_CCtx_setParameter(cctx, ZSTD_c_checksumFlag, 1) );\n    ZSTD_CCtx_setParameter(cctx, ZSTD_c_nbWorkers, nbThreads);\n\n    /* This loop reads from the input file, compresses that entire chunk,\n     * and writes all output produced to the output file.\n     */\n    size_t const toRead = buffInSize;\n    for (;;) {\n        size_t read = fread_orDie(buffIn, toRead, fin);\n        /* Select the flush mode.\n         * If the read may not be finished (read == toRead) we use\n         * ZSTD_e_continue. If this is the last chunk, we use ZSTD_e_end.\n         * Zstd optimizes the case where the first flush mode is ZSTD_e_end,\n         * since it knows it is compressing the entire source in one pass.\n         */\n        int const lastChunk = (read < toRead);\n        ZSTD_EndDirective const mode = lastChunk ? ZSTD_e_end : ZSTD_e_continue;\n        /* Set the input buffer to what we just read.\n         * We compress until the input buffer is empty, each time flushing the\n         * output.\n         */\n        ZSTD_inBuffer input = { buffIn, read, 0 };\n        int finished;\n        do {\n            /* Compress into the output buffer and write all of the output to\n             * the file so we can reuse the buffer next iteration.\n             */\n            ZSTD_outBuffer output = { buffOut, buffOutSize, 0 };\n            size_t const remaining = ZSTD_compressStream2(cctx, &output , &input, mode);\n            CHECK_ZSTD(remaining);\n            fwrite_orDie(buffOut, output.pos, fout);\n            /* If we're on the last chunk we're finished when zstd returns 0,\n             * which means its consumed all the input AND finished the frame.\n             * Otherwise, we're finished when we've consumed all the input.\n             */\n            finished = lastChunk ? (remaining == 0) : (input.pos == input.size);\n        } while (!finished);\n        CHECK(input.pos == input.size,\n              \"Impossible: zstd only returns 0 when the input is completely consumed!\");\n\n        if (lastChunk) {\n            break;\n        }\n    }\n\n    fprintf (stderr, \"Finishing compression of %s\\n\", args->outName);\n\n    ZSTD_freeCCtx(cctx);\n    fclose_orDie(fout);\n    fclose_orDie(fin);\n    free(buffIn);\n    free(buffOut);\n    free(args->outName);\n\n    return NULL;\n}\n\n\nstatic char* createOutFilename_orDie(const char* filename)\n{\n    size_t const inL = strlen(filename);\n    size_t const outL = inL + 5;\n    void* const outSpace = malloc_orDie(outL);\n    memset(outSpace, 0, outL);\n    strcat(outSpace, filename);\n    strcat(outSpace, \".zst\");\n    return (char*)outSpace;\n}\n\nint main(int argc, const char** argv)\n{\n    const char* const exeName = argv[0];\n\n    if (argc<=3) {\n        printf(\"wrong arguments\\n\");\n        printf(\"usage:\\n\");\n        printf(\"%s POOL_SIZE LEVEL FILES\\n\", exeName);\n        return 1;\n    }\n\n    int pool_size = atoi (argv[1]);\n    CHECK(pool_size != 0, \"can't parse POOL_SIZE!\");\n\n    int level = atoi (argv[2]);\n    CHECK(level != 0, \"can't parse LEVEL!\");\n\n    argc -= 3;\n    argv += 3;\n\n#if defined(ZSTD_STATIC_LINKING_ONLY)\n    ZSTD_threadPool *pool = ZSTD_createThreadPool (pool_size);\n    CHECK(pool != NULL, \"ZSTD_createThreadPool() failed!\");\n    fprintf (stderr, \"Using shared thread pool of size %d\\n\", pool_size);\n#else\n    fprintf (stderr, \"All threads use its own thread pool\\n\");\n#endif\n\n    pthread_t *threads = malloc_orDie(argc * sizeof(pthread_t));\n    compress_args_t *args = malloc_orDie(argc * sizeof(compress_args_t));\n\n    for (unsigned i = 0; i < argc; i++)\n    {\n      args[i].fname = argv[i];\n      args[i].outName = createOutFilename_orDie(args[i].fname);\n      args[i].cLevel = level;\n#if defined(ZSTD_STATIC_LINKING_ONLY)\n      args[i].pool = pool;\n#endif\n\n      pthread_create (&threads[i], NULL, compressFile_orDie, &args[i]);\n    }\n\n    for (unsigned i = 0; i < argc; i++)\n      pthread_join (threads[i], NULL);\n\n#if defined(ZSTD_STATIC_LINKING_ONLY)\n    ZSTD_freeThreadPool (pool);\n#endif\n\n    return 0;\n}\n"
  },
  {
    "path": "examples/streaming_decompression.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n\n#include      // fprintf\n#include     // free\n#include       // presumes zstd library is installed\n#include \"common.h\"    // Helper functions, CHECK(), and CHECK_ZSTD()\n\nstatic void decompressFile_orDie(const char* fname)\n{\n    FILE* const fin  = fopen_orDie(fname, \"rb\");\n    size_t const buffInSize = ZSTD_DStreamInSize();\n    void*  const buffIn  = malloc_orDie(buffInSize);\n    FILE* const fout = stdout;\n    size_t const buffOutSize = ZSTD_DStreamOutSize();  /* Guarantee to successfully flush at least one complete compressed block in all circumstances. */\n    void*  const buffOut = malloc_orDie(buffOutSize);\n\n    ZSTD_DCtx* const dctx = ZSTD_createDCtx();\n    CHECK(dctx != NULL, \"ZSTD_createDCtx() failed!\");\n\n    /* This loop assumes that the input file is one or more concatenated zstd\n     * streams. This example won't work if there is trailing non-zstd data at\n     * the end, but streaming decompression in general handles this case.\n     * ZSTD_decompressStream() returns 0 exactly when the frame is completed,\n     * and doesn't consume input after the frame.\n     */\n    size_t const toRead = buffInSize;\n    size_t read;\n    size_t lastRet = 0;\n    int isEmpty = 1;\n    while ( (read = fread_orDie(buffIn, toRead, fin)) ) {\n        isEmpty = 0;\n        ZSTD_inBuffer input = { buffIn, read, 0 };\n        /* Given a valid frame, zstd won't consume the last byte of the frame\n         * until it has flushed all of the decompressed data of the frame.\n         * Therefore, instead of checking if the return code is 0, we can\n         * decompress just check if input.pos < input.size.\n         */\n        while (input.pos < input.size) {\n            ZSTD_outBuffer output = { buffOut, buffOutSize, 0 };\n            /* The return code is zero if the frame is complete, but there may\n             * be multiple frames concatenated together. Zstd will automatically\n             * reset the context when a frame is complete. Still, calling\n             * ZSTD_DCtx_reset() can be useful to reset the context to a clean\n             * state, for instance if the last decompression call returned an\n             * error.\n             */\n            size_t const ret = ZSTD_decompressStream(dctx, &output , &input);\n            CHECK_ZSTD(ret);\n            fwrite_orDie(buffOut, output.pos, fout);\n            lastRet = ret;\n        }\n    }\n\n    if (isEmpty) {\n        fprintf(stderr, \"input is empty\\n\");\n        exit(1);\n    }\n\n    if (lastRet != 0) {\n        /* The last return value from ZSTD_decompressStream did not end on a\n         * frame, but we reached the end of the file! We assume this is an\n         * error, and the input was truncated.\n         */\n        fprintf(stderr, \"EOF before end of stream: %zu\\n\", lastRet);\n        exit(1);\n    }\n\n    ZSTD_freeDCtx(dctx);\n    fclose_orDie(fin);\n    fclose_orDie(fout);\n    free(buffIn);\n    free(buffOut);\n}\n\n\nint main(int argc, const char** argv)\n{\n    const char* const exeName = argv[0];\n\n    if (argc!=2) {\n        fprintf(stderr, \"wrong arguments\\n\");\n        fprintf(stderr, \"usage:\\n\");\n        fprintf(stderr, \"%s FILE\\n\", exeName);\n        return 1;\n    }\n\n    const char* const inFilename = argv[1];\n\n    decompressFile_orDie(inFilename);\n    return 0;\n}\n"
  },
  {
    "path": "examples/streaming_memory_usage.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n\n/*===   Tuning parameter   ===*/\n#ifndef MAX_TESTED_LEVEL\n#define MAX_TESTED_LEVEL 12\n#endif\n\n\n/*===   Dependencies   ===*/\n#include      // printf\n#define ZSTD_STATIC_LINKING_ONLY\n#include       // presumes zstd library is installed\n#include \"common.h\"    // Helper functions, CHECK(), and CHECK_ZSTD()\n\n\n/*===   functions   ===*/\n\n/*! readU32FromChar() :\n    @return : unsigned integer value read from input in `char` format\n    allows and interprets K, KB, KiB, M, MB and MiB suffix.\n    Will also modify `*stringPtr`, advancing it to position where it stopped reading.\n    Note : function result can overflow if digit string > MAX_UINT */\nstatic unsigned readU32FromChar(const char** stringPtr)\n{\n    unsigned result = 0;\n    while ((**stringPtr >='0') && (**stringPtr <='9'))\n        result *= 10, result += **stringPtr - '0', (*stringPtr)++ ;\n    if ((**stringPtr=='K') || (**stringPtr=='M')) {\n        result <<= 10;\n        if (**stringPtr=='M') result <<= 10;\n        (*stringPtr)++ ;\n        if (**stringPtr=='i') (*stringPtr)++;\n        if (**stringPtr=='B') (*stringPtr)++;\n    }\n    return result;\n}\n\n\nint main(int argc, char const *argv[]) {\n\n    printf(\"\\n Zstandard (v%s) memory usage for streaming : \\n\\n\", ZSTD_versionString());\n\n    unsigned wLog = 0;\n    if (argc > 1) {\n        const char* valStr = argv[1];\n        wLog = readU32FromChar(&valStr);\n    }\n\n    int compressionLevel;\n    for (compressionLevel = 1; compressionLevel <= MAX_TESTED_LEVEL; compressionLevel++) {\n#define INPUT_SIZE 5\n#define COMPRESSED_SIZE 128\n        char const dataToCompress[INPUT_SIZE] = \"abcde\";\n        char compressedData[COMPRESSED_SIZE];\n        char decompressedData[INPUT_SIZE];\n        /* the ZSTD_CCtx_params structure is a way to save parameters and use\n         * them across multiple contexts. We use them here so we can call the\n         * function ZSTD_estimateCStreamSize_usingCCtxParams().\n         */\n        ZSTD_CCtx_params* const cctxParams = ZSTD_createCCtxParams();\n        CHECK(cctxParams != NULL, \"ZSTD_createCCtxParams() failed!\");\n\n        /* Set the compression level. */\n        CHECK_ZSTD( ZSTD_CCtxParams_setParameter(cctxParams, ZSTD_c_compressionLevel, compressionLevel) );\n        /* Set the window log.\n         * The value 0 means use the default window log, which is equivalent to\n         * not setting it.\n         */\n        CHECK_ZSTD( ZSTD_CCtxParams_setParameter(cctxParams, ZSTD_c_windowLog, wLog) );\n\n        /* Force the compressor to allocate the maximum memory size for a given\n         * level by not providing the pledged source size, or calling\n         * ZSTD_compressStream2() with ZSTD_e_end.\n         */\n        ZSTD_CCtx* const cctx = ZSTD_createCCtx();\n        CHECK(cctx != NULL, \"ZSTD_createCCtx() failed!\");\n        CHECK_ZSTD( ZSTD_CCtx_setParametersUsingCCtxParams(cctx, cctxParams) );\n        size_t compressedSize;\n        {\n            ZSTD_inBuffer inBuff = { dataToCompress, sizeof(dataToCompress), 0 };\n            ZSTD_outBuffer outBuff = { compressedData, sizeof(compressedData), 0 };\n            CHECK_ZSTD( ZSTD_compressStream(cctx, &outBuff, &inBuff) );\n            size_t const remaining = ZSTD_endStream(cctx, &outBuff);\n            CHECK_ZSTD(remaining);\n            CHECK(remaining == 0, \"Frame not flushed!\");\n            compressedSize = outBuff.pos;\n        }\n\n        ZSTD_DCtx* const dctx = ZSTD_createDCtx();\n        CHECK(dctx != NULL, \"ZSTD_createDCtx() failed!\");\n        /* Set the maximum allowed window log.\n         * The value 0 means use the default window log, which is equivalent to\n         * not setting it.\n         */\n        CHECK_ZSTD( ZSTD_DCtx_setParameter(dctx, ZSTD_d_windowLogMax, wLog) );\n        /* forces decompressor to use maximum memory size, since the\n         * decompressed size is not stored in the frame header.\n         */\n        {   ZSTD_inBuffer inBuff = { compressedData, compressedSize, 0 };\n            ZSTD_outBuffer outBuff = { decompressedData, sizeof(decompressedData), 0 };\n            size_t const remaining = ZSTD_decompressStream(dctx, &outBuff, &inBuff);\n            CHECK_ZSTD(remaining);\n            CHECK(remaining == 0, \"Frame not complete!\");\n            CHECK(outBuff.pos == sizeof(dataToCompress), \"Bad decompression!\");\n        }\n\n        size_t const cstreamSize = ZSTD_sizeof_CStream(cctx);\n        size_t const cstreamEstimatedSize = ZSTD_estimateCStreamSize_usingCCtxParams(cctxParams);\n        size_t const dstreamSize = ZSTD_sizeof_DStream(dctx);\n        size_t const dstreamEstimatedSize = ZSTD_estimateDStreamSize_fromFrame(compressedData, compressedSize);\n\n        CHECK(cstreamSize <= cstreamEstimatedSize, \"Compression mem (%u) > estimated (%u)\",\n                (unsigned)cstreamSize, (unsigned)cstreamEstimatedSize);\n        CHECK(dstreamSize <= dstreamEstimatedSize, \"Decompression mem (%u) > estimated (%u)\",\n                (unsigned)dstreamSize, (unsigned)dstreamEstimatedSize);\n\n        printf(\"Level %2i : Compression Mem = %5u KB (estimated : %5u KB) ; Decompression Mem = %4u KB (estimated : %5u KB)\\n\",\n                compressionLevel,\n                (unsigned)(cstreamSize>>10), (unsigned)(cstreamEstimatedSize>>10),\n                (unsigned)(dstreamSize>>10), (unsigned)(dstreamEstimatedSize>>10));\n\n        ZSTD_freeDCtx(dctx);\n        ZSTD_freeCCtx(cctx);\n        ZSTD_freeCCtxParams(cctxParams);\n        if (wLog) break;  /* single test */\n    }\n    return 0;\n}\n"
  },
  {
    "path": "lib/.gitignore",
    "content": "# make install artefact\nlibzstd.pc\nlibzstd-nomt\n"
  },
  {
    "path": "lib/BUCK",
    "content": "cxx_library(\n    name='zstd',\n    header_namespace='',\n    exported_headers=['zstd.h'],\n    visibility=['PUBLIC'],\n    deps=[\n        ':common',\n        ':compress',\n        ':decompress',\n        ':deprecated',\n    ],\n)\n\ncxx_library(\n    name='compress',\n    header_namespace='',\n    visibility=['PUBLIC'],\n    exported_headers=subdir_glob([\n        ('compress', 'zstd*.h'),\n    ]),\n    srcs=glob(['compress/zstd*.c', 'compress/hist.c']),\n    deps=[':common'],\n)\n\ncxx_library(\n    name='decompress',\n    header_namespace='',\n    visibility=['PUBLIC'],\n    headers=subdir_glob([\n        ('decompress', '*_impl.h'),\n    ]),\n    srcs=glob(['decompress/zstd*.c']),\n    deps=[\n        ':common',\n        ':legacy',\n    ],\n)\n\ncxx_library(\n    name='deprecated',\n    header_namespace='',\n    visibility=['PUBLIC'],\n    exported_headers=subdir_glob([\n        ('deprecated', '*.h'),\n    ]),\n    srcs=glob(['deprecated/*.c']),\n    deps=[':common'],\n)\n\ncxx_library(\n    name='legacy',\n    header_namespace='',\n    visibility=['PUBLIC'],\n    exported_headers=subdir_glob([\n        ('legacy', '*.h'),\n    ]),\n    srcs=glob(['legacy/*.c']),\n    deps=[':common'],\n    exported_preprocessor_flags=[\n        '-DZSTD_LEGACY_SUPPORT=0',\n    ],\n)\n\ncxx_library(\n    name='zdict',\n    header_namespace='',\n    visibility=['PUBLIC'],\n    exported_headers=['zdict.h'],\n    headers=subdir_glob([\n        ('dictBuilder', 'divsufsort.h'),\n        ('dictBuilder', 'cover.h'),\n    ]),\n    srcs=glob(['dictBuilder/*.c']),\n    deps=[':common'],\n)\n\ncxx_library(\n    name='compiler',\n    header_namespace='',\n    visibility=['PUBLIC'],\n    exported_headers=subdir_glob([\n        ('common', 'compiler.h'),\n    ]),\n)\n\ncxx_library(\n    name='cpu',\n    header_namespace='',\n    visibility=['PUBLIC'],\n    exported_headers=subdir_glob([\n        ('common', 'cpu.h'),\n    ]),\n)\n\ncxx_library(\n    name='bitstream',\n    header_namespace='',\n    visibility=['PUBLIC'],\n    exported_headers=subdir_glob([\n        ('common', 'bitstream.h'),\n    ]),\n)\n\ncxx_library(\n    name='entropy',\n    header_namespace='',\n    visibility=['PUBLIC'],\n    exported_headers=subdir_glob([\n        ('common', 'fse.h'),\n        ('common', 'huf.h'),\n    ]),\n    srcs=[\n        'common/entropy_common.c',\n        'common/fse_decompress.c',\n        'compress/fse_compress.c',\n        'compress/huf_compress.c',\n        'decompress/huf_decompress.c',\n    ],\n    deps=[\n        ':debug',\n        ':bitstream',\n        ':compiler',\n        ':errors',\n        ':mem',\n    ],\n)\n\ncxx_library(\n    name='errors',\n    header_namespace='',\n    visibility=['PUBLIC'],\n    exported_headers=[\n        'zstd_errors.h',\n        'common/error_private.h',\n    ]\n    srcs=['common/error_private.c'],\n)\n\ncxx_library(\n    name='mem',\n    header_namespace='',\n    visibility=['PUBLIC'],\n    exported_headers=subdir_glob([\n        ('common', 'mem.h'),\n    ]),\n)\n\ncxx_library(\n    name='pool',\n    header_namespace='',\n    visibility=['PUBLIC'],\n    exported_headers=subdir_glob([\n        ('common', 'pool.h'),\n    ]),\n    srcs=['common/pool.c'],\n    deps=[\n        ':threading',\n        ':zstd_common',\n    ],\n)\n\ncxx_library(\n    name='threading',\n    header_namespace='',\n    visibility=['PUBLIC'],\n    exported_headers=subdir_glob([\n        ('common', 'threading.h'),\n    ]),\n    srcs=['common/threading.c'],\n    exported_preprocessor_flags=[\n        '-DZSTD_MULTITHREAD',\n    ],\n    exported_linker_flags=[\n        '-pthread',\n    ],\n)\n\ncxx_library(\n    name='xxhash',\n    header_namespace='',\n    visibility=['PUBLIC'],\n    exported_headers=subdir_glob([\n        ('common', 'xxhash.h'),\n    ]),\n    srcs=['common/xxhash.c'],\n    exported_preprocessor_flags=[\n        '-DXXH_NAMESPACE=ZSTD_',\n    ],\n)\n\ncxx_library(\n    name='zstd_common',\n    header_namespace='',\n    visibility=['PUBLIC'],\n    exported_headers=subdir_glob([\n        ('', 'zstd.h'),\n        ('common', 'zstd_internal.h'),\n    ]),\n    srcs=['common/zstd_common.c'],\n    deps=[\n        ':compiler',\n        ':errors',\n        ':mem',\n    ],\n)\n\ncxx_library(\n    name='debug',\n    header_namespace='',\n    visibility=['PUBLIC'],\n    exported_headers=subdir_glob([\n        ('common', 'debug.h'),\n    ]),\n    srcs=['common/debug.c'],\n)\n\ncxx_library(\n    name='common',\n    deps=[\n        ':debug',\n        ':bitstream',\n        ':compiler',\n        ':cpu',\n        ':entropy',\n        ':errors',\n        ':mem',\n        ':pool',\n        ':threading',\n        ':xxhash',\n        ':zstd_common',\n    ]\n)\n"
  },
  {
    "path": "lib/Makefile",
    "content": "# ################################################################\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n# All rights reserved.\n#\n# This source code is licensed under both the BSD-style license (found in the\n# LICENSE file in the root directory of this source tree) and the GPLv2 (found\n# in the COPYING file in the root directory of this source tree).\n# You may select, at your option, one of the above-listed licenses.\n# ################################################################\n\n# default target (when running `make` with no argument)\nlib-release:\n\n# Modules\nZSTD_LIB_COMPRESSION ?= 1\nZSTD_LIB_DECOMPRESSION ?= 1\nZSTD_LIB_DICTBUILDER ?= 1\nZSTD_LIB_DEPRECATED ?= 0\n\n# Input variables for libzstd.mk\nifeq ($(ZSTD_LIB_COMPRESSION), 0)\n  ZSTD_LIB_DICTBUILDER = 0\n  ZSTD_LIB_DEPRECATED = 0\nendif\n\nifeq ($(ZSTD_LIB_DECOMPRESSION), 0)\n  ZSTD_LEGACY_SUPPORT = 0\n  ZSTD_LIB_DEPRECATED = 0\nendif\n\ninclude libzstd.mk\n\nZSTD_FILES := $(ZSTD_COMMON_FILES) $(ZSTD_LEGACY_FILES)\n\nifneq ($(ZSTD_LIB_COMPRESSION), 0)\n  ZSTD_FILES += $(ZSTD_COMPRESS_FILES)\nendif\n\nifneq ($(ZSTD_LIB_DECOMPRESSION), 0)\n  ZSTD_FILES += $(ZSTD_DECOMPRESS_FILES)\nendif\n\nifneq ($(ZSTD_LIB_DEPRECATED), 0)\n  ZSTD_FILES += $(ZSTD_DEPRECATED_FILES)\nendif\n\nifneq ($(ZSTD_LIB_DICTBUILDER), 0)\n  ZSTD_FILES += $(ZSTD_DICTBUILDER_FILES)\nendif\n\nZSTD_LOCAL_SRC := $(notdir $(ZSTD_FILES))\nZSTD_LOCAL_OBJ0 := $(ZSTD_LOCAL_SRC:.c=.o)\nZSTD_LOCAL_OBJ := $(ZSTD_LOCAL_OBJ0:.S=.o)\n\nVERSION := $(ZSTD_VERSION)\n\n# Note: by default, the static library is built single-threaded and dynamic library is built\n# multi-threaded. It is possible to force multi or single threaded builds by appending\n# -mt or -nomt to the build target (like lib-mt for multi-threaded, lib-nomt for single-threaded).\n\n\nCPPFLAGS_DYNLIB  += -DZSTD_MULTITHREAD # dynamic library build defaults to multi-threaded\nLDFLAGS_DYNLIB   += -pthread\nCPPFLAGS_STATICLIB +=                  # static library build defaults to single-threaded\n\n# pkg-config Libs.private points to LDFLAGS_DYNLIB\nPCLIB := $(LDFLAGS_DYNLIB)\n\nifeq ($(findstring GCC,$(CCVER)),GCC)\ndecompress/zstd_decompress_block.o : CFLAGS+=-fno-tree-vectorize\nendif\n\n\n# macOS linker doesn't support -soname, and use different extension\n# see : https://developer.apple.com/library/mac/documentation/DeveloperTools/Conceptual/DynamicLibraries/100-Articles/DynamicLibraryDesignGuidelines.html\nUNAME_TARGET_SYSTEM ?= $(UNAME)\n\nifeq ($(UNAME_TARGET_SYSTEM), Darwin)\n  SHARED_EXT = dylib\n  SHARED_EXT_MAJOR = $(LIBVER_MAJOR).$(SHARED_EXT)\n  SHARED_EXT_VER = $(LIBVER).$(SHARED_EXT)\n  SONAME_FLAGS = -install_name $(LIBDIR)/libzstd.$(SHARED_EXT_MAJOR) -compatibility_version $(LIBVER_MAJOR) -current_version $(LIBVER)\nelse\n  ifeq ($(UNAME_TARGET_SYSTEM), AIX)\n    SONAME_FLAGS =\n  else\n    SONAME_FLAGS = -Wl,-soname=libzstd.$(SHARED_EXT).$(LIBVER_MAJOR)\n  endif\n  SHARED_EXT = so\n  SHARED_EXT_MAJOR = $(SHARED_EXT).$(LIBVER_MAJOR)\n  SHARED_EXT_VER = $(SHARED_EXT).$(LIBVER)\nendif\n\n\n.PHONY: all\nall: lib\n\n\n.PHONY: libzstd.a  # must be run every time\nlibzstd.a: CPPFLAGS += $(CPPFLAGS_STATICLIB)\n\nSET_CACHE_DIRECTORY = \\\n   +$(MAKE) --no-print-directory $@ \\\n    BUILD_DIR=obj/$(HASH_DIR) \\\n    CPPFLAGS=\"$(CPPFLAGS)\" \\\n    CFLAGS=\"$(CFLAGS)\" \\\n    LDFLAGS=\"$(LDFLAGS)\"\n\nifndef BUILD_DIR\n# determine BUILD_DIR from compilation flags\n\nlibzstd.a:\n\t$(SET_CACHE_DIRECTORY)\n\nelse\n# BUILD_DIR is defined\n\nZSTD_STATICLIB_DIR := $(BUILD_DIR)/static\nZSTD_STATICLIB := $(ZSTD_STATICLIB_DIR)/libzstd.a\nZSTD_STATICLIB_OBJ := $(addprefix $(ZSTD_STATICLIB_DIR)/,$(ZSTD_LOCAL_OBJ))\n$(ZSTD_STATICLIB): ARFLAGS = rcs\n$(ZSTD_STATICLIB): | $(ZSTD_STATICLIB_DIR)\n$(ZSTD_STATICLIB): $(ZSTD_STATICLIB_OBJ)\n  # Check for multithread flag at target execution time\n\t$(if $(filter -DZSTD_MULTITHREAD,$(CPPFLAGS)),\\\n    @echo compiling multi-threaded static library $(LIBVER),\\\n    @echo compiling single-threaded static library $(LIBVER))\n\t$(AR) $(ARFLAGS) $@ $^\n\nlibzstd.a: $(ZSTD_STATICLIB)\n\t$(CP) $< $@\n\nendif\n\nifneq (,$(filter Windows%,$(TARGET_SYSTEM)))\n\nLIBZSTD = dll/libzstd.dll\n$(LIBZSTD): $(ZSTD_FILES)\n\t@echo compiling dynamic library $(LIBVER)\n\t$(CC) $(FLAGS) -DZSTD_DLL_EXPORT=1 -Wl,--out-implib,dll/libzstd.dll.a -shared $^ -o $@\n\nelse  # not Windows\n\nLIBZSTD = libzstd.$(SHARED_EXT_VER)\n.PHONY: $(LIBZSTD)  # must be run every time\n$(LIBZSTD): CPPFLAGS += $(CPPFLAGS_DYNLIB)\n$(LIBZSTD): CFLAGS   += -fPIC -fvisibility=hidden\n$(LIBZSTD): LDFLAGS  += -shared $(LDFLAGS_DYNLIB)\n\nifndef BUILD_DIR\n# determine BUILD_DIR from compilation flags\n\n$(LIBZSTD):\n\t$(SET_CACHE_DIRECTORY)\n\nelse\n# BUILD_DIR is defined\n\nZSTD_DYNLIB_DIR := $(BUILD_DIR)/dynamic\nZSTD_DYNLIB := $(ZSTD_DYNLIB_DIR)/$(LIBZSTD)\nZSTD_DYNLIB_OBJ := $(addprefix $(ZSTD_DYNLIB_DIR)/,$(ZSTD_LOCAL_OBJ))\n\n$(ZSTD_DYNLIB): | $(ZSTD_DYNLIB_DIR)\n$(ZSTD_DYNLIB): $(ZSTD_DYNLIB_OBJ)\n# Check for multithread flag at target execution time\n\t$(if $(filter -DZSTD_MULTITHREAD,$(CPPFLAGS)),\\\n    @echo compiling multi-threaded dynamic library $(LIBVER),\\\n    @echo compiling single-threaded dynamic library $(LIBVER))\n\t$(CC) $(FLAGS) $^ $(SONAME_FLAGS) -o $@\n\t@echo creating versioned links\n\t$(LN) -sf $@ libzstd.$(SHARED_EXT_MAJOR)\n\t$(LN) -sf $@ libzstd.$(SHARED_EXT)\n\n$(LIBZSTD): $(ZSTD_DYNLIB)\n\t$(CP) $< $@\n\nendif  # ifndef BUILD_DIR\nendif  # if windows\n\n.PHONY: libzstd\nlibzstd : $(LIBZSTD)\n\n.PHONY: lib\nlib : libzstd.a libzstd\n\n\n# note : do not define lib-mt or lib-release as .PHONY\n# make does not consider implicit pattern rule for .PHONY target\n\n%-mt : CPPFLAGS_DYNLIB  := -DZSTD_MULTITHREAD\n%-mt : CPPFLAGS_STATICLIB := -DZSTD_MULTITHREAD\n%-mt : LDFLAGS_DYNLIB   := -pthread\n%-mt : PCLIB :=\n%-mt : PCMTLIB := $(LDFLAGS_DYNLIB)\n%-mt : %\n\t@echo multi-threaded build completed\n\n%-nomt : CPPFLAGS_DYNLIB  :=\n%-nomt : LDFLAGS_DYNLIB   :=\n%-nomt : CPPFLAGS_STATICLIB :=\n%-nomt : PCLIB :=\n%-nomt : %\n\t@echo single-threaded build completed\n\n%-release : DEBUGFLAGS :=\n%-release : %\n\t@echo release build completed\n\n\n# Generate .h dependencies automatically\n\n# -MMD: compiler generates dependency information as a side-effect of compilation, without system headers\n# -MP: adds phony target for each dependency other than main file.\nDEPFLAGS = -MMD -MP\n\n# ensure that ZSTD_DYNLIB_DIR exists prior to generating %.o\n$(ZSTD_DYNLIB_DIR)/%.o : %.c | $(ZSTD_DYNLIB_DIR)\n\t@echo CC $@\n\t$(COMPILE.c) $(DEPFLAGS) $(OUTPUT_OPTION) $<\n\n$(ZSTD_STATICLIB_DIR)/%.o : %.c | $(ZSTD_STATICLIB_DIR)\n\t@echo CC $@\n\t$(COMPILE.c) $(DEPFLAGS) $(OUTPUT_OPTION) $<\n\n$(ZSTD_DYNLIB_DIR)/%.o : %.S | $(ZSTD_DYNLIB_DIR)\n\t@echo AS $@\n\t$(COMPILE.S) $(OUTPUT_OPTION) $<\n\n$(ZSTD_STATICLIB_DIR)/%.o : %.S | $(ZSTD_STATICLIB_DIR)\n\t@echo AS $@\n\t$(COMPILE.S) $(OUTPUT_OPTION) $<\n\nMKDIR ?= mkdir -p\n$(BUILD_DIR) $(ZSTD_DYNLIB_DIR) $(ZSTD_STATICLIB_DIR):\n\t$(MKDIR) $@\n\nDEPFILES := $(ZSTD_DYNLIB_OBJ:.o=.d) $(ZSTD_STATICLIB_OBJ:.o=.d)\n$(DEPFILES):\n\n# The leading '-' means: do not fail is include fails (ex: directory does not exist yet)\n-include $(wildcard $(DEPFILES))\n\n\n# Special case : build library in single-thread mode _and_ without zstdmt_compress.c\n# Note : we still need threading.c and pool.c for the dictionary builder,\n# but they will correctly behave single-threaded.\nZSTDMT_FILES = zstdmt_compress.c\nZSTD_NOMT_FILES = $(filter-out $(ZSTDMT_FILES),$(notdir $(ZSTD_FILES)))\nlibzstd-nomt: CFLAGS += -fPIC -fvisibility=hidden\nlibzstd-nomt: LDFLAGS += -shared\nlibzstd-nomt: $(ZSTD_NOMT_FILES)\n\t@echo compiling single-thread dynamic library $(LIBVER)\n\t@echo files : $(ZSTD_NOMT_FILES)\n\t@if echo \"$(ZSTD_NOMT_FILES)\" | tr ' ' '\\n' | $(GREP) -q zstdmt; then \\\n        echo \"Error: Found zstdmt in list.\"; \\\n        exit 1; \\\n    fi\n\t$(CC) $(FLAGS) $^ $(SONAME_FLAGS) -o $@\n\n.PHONY: clean\nclean:\n\t$(RM) -r *.dSYM   # macOS-specific\n\t$(RM) core *.o *.a *.gcda *.$(SHARED_EXT) *.$(SHARED_EXT).* libzstd.pc\n\t$(RM) dll/libzstd.dll dll/libzstd.lib libzstd-nomt*\n\t$(RM) -r obj/*\n\t@echo Cleaning library completed\n\n#-----------------------------------------------------------------------------\n# make install is validated only for below listed environments\n#-----------------------------------------------------------------------------\nifneq (,$(filter $(INSTALL_OS_LIST),$(UNAME)))\n\nlib: libzstd.pc\n\nHAS_EXPLICIT_EXEC_PREFIX := $(if $(or $(EXEC_PREFIX),$(exec_prefix)),1,)\n\nDESTDIR     ?=\n# directory variables : GNU conventions prefer lowercase\n# see https://www.gnu.org/prep/standards/html_node/Makefile-Conventions.html\n# support both lower and uppercase (BSD), use uppercase in script\nprefix      ?= /usr/local\nPREFIX      ?= $(prefix)\nexec_prefix ?= $(PREFIX)\nEXEC_PREFIX ?= $(exec_prefix)\nlibdir      ?= $(EXEC_PREFIX)/lib\nLIBDIR      ?= $(libdir)\nincludedir  ?= $(PREFIX)/include\nINCLUDEDIR  ?= $(includedir)\n\nPCINCDIR := $(patsubst $(PREFIX)%,%,$(INCLUDEDIR))\nPCLIBDIR := $(patsubst $(EXEC_PREFIX)%,%,$(LIBDIR))\n\n# If we successfully stripped off a prefix, we'll add a reference to the\n# relevant pc variable.\nPCINCPREFIX := $(if $(findstring $(INCLUDEDIR),$(PCINCDIR)),,$${prefix})\nPCLIBPREFIX := $(if $(findstring $(LIBDIR),$(PCLIBDIR)),,$${exec_prefix})\n\n# If no explicit EXEC_PREFIX was set by the caller, write it out as a reference\n# to PREFIX, rather than as a resolved value.\nPCEXEC_PREFIX := $(if $(HAS_EXPLICIT_EXEC_PREFIX),$(EXEC_PREFIX),$${prefix})\n\n\nifneq ($(MT),)\n  PCLIB :=\n  PCMTLIB := $(LDFLAGS_DYNLIB)\nelse\n  PCLIB := $(LDFLAGS_DYNLIB)\nendif\n\nifneq (,$(filter FreeBSD NetBSD DragonFly,$(UNAME)))\n  PKGCONFIGDIR ?= $(PREFIX)/libdata/pkgconfig\nelse\n  PKGCONFIGDIR ?= $(LIBDIR)/pkgconfig\nendif\n\nifneq (,$(filter SunOS,$(UNAME)))\n  INSTALL ?= ginstall\nelse\n  INSTALL ?= install\nendif\n\nINSTALL_PROGRAM ?= $(INSTALL)\nINSTALL_DATA    ?= $(INSTALL) -m 644\n\n\n# pkg-config library define.\n# For static single-threaded library declare -pthread in Libs.private\n# For static multi-threaded library declare -pthread in Libs and Cflags\n.PHONY: libzstd.pc\nlibzstd.pc: libzstd.pc.in\n\t@echo creating pkgconfig\n\t@sed \\\n\t        -e 's|@PREFIX@|$(PREFIX)|' \\\n\t        -e 's|@EXEC_PREFIX@|$(PCEXEC_PREFIX)|' \\\n\t        -e 's|@INCLUDEDIR@|$(PCINCPREFIX)$(PCINCDIR)|' \\\n\t        -e 's|@LIBDIR@|$(PCLIBPREFIX)$(PCLIBDIR)|' \\\n\t        -e 's|@VERSION@|$(VERSION)|' \\\n\t        -e 's|@LIBS_MT@|$(PCMTLIB)|' \\\n\t        -e 's|@LIBS_PRIVATE@|$(PCLIB)|' \\\n\t        $< >$@\n\n.PHONY: install\ninstall: install-pc install-static install-shared install-includes\n\t@echo zstd static and shared library installed\n\n.PHONY: install-pc\ninstall-pc: libzstd.pc\n\t[ -e $(DESTDIR)$(PKGCONFIGDIR) ] || $(INSTALL) -d -m 755 $(DESTDIR)$(PKGCONFIGDIR)/\n\t$(INSTALL_DATA) libzstd.pc $(DESTDIR)$(PKGCONFIGDIR)/\n\n.PHONY: install-static\ninstall-static:\n\t# only generate libzstd.a if it's not already present\n\t[ -e libzstd.a ] || $(MAKE) libzstd.a-release\n\t[ -e $(DESTDIR)$(LIBDIR) ] || $(INSTALL) -d -m 755 $(DESTDIR)$(LIBDIR)/\n\t@echo Installing static library\n\t$(INSTALL_DATA) libzstd.a $(DESTDIR)$(LIBDIR)\n\n.PHONY: install-shared\ninstall-shared:\n\t# only generate libzstd.so if it's not already present\n\t[ -e $(LIBZSTD) ] || $(MAKE) libzstd-release\n\t[ -e $(DESTDIR)$(LIBDIR) ] || $(INSTALL) -d -m 755 $(DESTDIR)$(LIBDIR)/\n\t@echo Installing shared library\n\t$(INSTALL_PROGRAM) $(LIBZSTD) $(DESTDIR)$(LIBDIR)\n\t$(LN) -sf $(LIBZSTD) $(DESTDIR)$(LIBDIR)/libzstd.$(SHARED_EXT_MAJOR)\n\t$(LN) -sf $(LIBZSTD) $(DESTDIR)$(LIBDIR)/libzstd.$(SHARED_EXT)\n\n.PHONY: install-includes\ninstall-includes:\n\t[ -e $(DESTDIR)$(INCLUDEDIR) ] || $(INSTALL) -d -m 755 $(DESTDIR)$(INCLUDEDIR)/\n\t@echo Installing includes\n\t$(INSTALL_DATA) zstd.h $(DESTDIR)$(INCLUDEDIR)\n\t$(INSTALL_DATA) zstd_errors.h $(DESTDIR)$(INCLUDEDIR)\n\t$(INSTALL_DATA) zdict.h $(DESTDIR)$(INCLUDEDIR)\n\n.PHONY: uninstall\nuninstall:\n\t$(RM) $(DESTDIR)$(LIBDIR)/libzstd.a\n\t$(RM) $(DESTDIR)$(LIBDIR)/libzstd.$(SHARED_EXT)\n\t$(RM) $(DESTDIR)$(LIBDIR)/libzstd.$(SHARED_EXT_MAJOR)\n\t$(RM) $(DESTDIR)$(LIBDIR)/$(LIBZSTD)\n\t$(RM) $(DESTDIR)$(PKGCONFIGDIR)/libzstd.pc\n\t$(RM) $(DESTDIR)$(INCLUDEDIR)/zstd.h\n\t$(RM) $(DESTDIR)$(INCLUDEDIR)/zstd_errors.h\n\t$(RM) $(DESTDIR)$(INCLUDEDIR)/zdict.h\n\t@echo zstd libraries successfully uninstalled\n\nendif\n"
  },
  {
    "path": "lib/README.md",
    "content": "Zstandard library files\n================================\n\nThe __lib__ directory is split into several sub-directories,\nin order to make it easier to select or exclude features.\n\n\n#### Building\n\nA `Makefile` script is provided, supporting [Makefile conventions](https://www.gnu.org/prep/standards/html_node/Makefile-Conventions.html#Makefile-Conventions),\nincluding commands variables, staged install, directory variables and standard targets.\n- `make` : generates both static and dynamic libraries\n- `make install` : install libraries, headers and pkg-config in local system directories\n\n`libzstd` default scope includes compression, decompression, and dictionary builder.\nNote: starting v1.6.0, support for decoding legacy formats is disabled by default.\nSee _modular build_ below to learn how to enable it.\nThe scope can be reduced on demand (see paragraph _modular build_).\n\n#### Multiarch Support\n\nFor multiarch systems (like Debian/Ubuntu), libraries should be installed to architecture-specific directories.\nWhen creating packages for such systems, use the `LIBDIR` variable to specify the correct multiarch path:\n\n```bash\n# For x86_64 systems on Ubuntu/Debian:\nmake install PREFIX=/usr LIBDIR=/usr/lib/x86_64-linux-gnu\n\n# For ARM64 systems on Ubuntu/Debian:\nmake install PREFIX=/usr LIBDIR=/usr/lib/aarch64-linux-gnu\n```\n\nThis will not only install the files in the correct directories, but also generate the correct paths for `pkg-config`.\n\n#### Multithreading support\n\nWhen building with `make`, by default the dynamic library is multithreaded and static library is single-threaded (for compatibility reasons).\n\nEnabling multithreading requires 2 conditions :\n- set build macro `ZSTD_MULTITHREAD` (`-DZSTD_MULTITHREAD` for `gcc`)\n- for POSIX systems : compile with pthread (`-pthread` compilation flag for `gcc`)\n\nFor convenience, we provide a build target to generate multi and single threaded libraries:\n- Force enable multithreading on both dynamic and static libraries by appending `-mt` to the target, e.g. `make lib-mt`.\n  Note that the `.pc` generated on calling `make lib-mt` will already include the require Libs and Cflags.\n- Force disable multithreading on both dynamic and static libraries by appending `-nomt` to the target, e.g. `make lib-nomt`.\n- By default, as mentioned before, dynamic library is multithreaded, and static library is single-threaded, e.g. `make lib`.\n\nWhen linking a POSIX program with a multithreaded version of `libzstd`,\nnote that it's necessary to invoke the `-pthread` flag during link stage.\n\nThe `.pc` generated from `make install` or `make install-pc` always assume a single-threaded static library\nis compiled. To correctly generate a `.pc` for the multi-threaded static library, set `MT=1` as ENV variable.\n\nMultithreading capabilities are exposed\nvia the [advanced API defined in `lib/zstd.h`](https://github.com/facebook/zstd/blob/v1.4.3/lib/zstd.h#L351).\n\n\n#### API\n\nZstandard's stable API is exposed within [lib/zstd.h](zstd.h).\n\n\n#### Advanced API\n\nOptional advanced features are exposed via :\n\n- `lib/zstd_errors.h` : translates `size_t` function results\n                        into a `ZSTD_ErrorCode`, for accurate error handling.\n\n- `ZSTD_STATIC_LINKING_ONLY` : if this macro is defined _before_ including `zstd.h`,\n                          it unlocks access to the experimental API,\n                          exposed in the second part of `zstd.h`.\n                          All definitions in the experimental APIs are unstable,\n                          they may still change in the future, or even be removed.\n                          As a consequence, experimental definitions shall ___never be used with dynamic library___ !\n                          Only static linking is allowed.\n\n\n#### Modular build\n\nIt's possible to compile only a limited set of features within `libzstd`.\nThe file structure is designed to make this selection manually achievable for any build system :\n\n- Directory `lib/common` is always required, for all variants.\n\n- Compression source code lies in `lib/compress`\n\n- Decompression source code lies in `lib/decompress`\n\n- It's possible to include only `compress` or only `decompress`, they don't depend on each other.\n\n- `lib/dictBuilder` : makes it possible to generate dictionaries from a set of samples.\n        The API is exposed in `lib/dictBuilder/zdict.h`.\n        This module depends on both `lib/common` and `lib/compress` .\n\n- `lib/legacy` : makes it possible to decompress legacy zstd formats, starting from `v0.1.0`.\n        This module depends on `lib/common` and `lib/decompress`.\n        To enable this feature, define `ZSTD_LEGACY_SUPPORT` during compilation.\n        Specifying a number limits versions supported to that version onward.\n        For example, `ZSTD_LEGACY_SUPPORT=2` means : \"support legacy formats >= v0.2.0\".\n        Conversely, `ZSTD_LEGACY_SUPPORT=0` means \"do __not__ support legacy formats\".\n        By default, this build macro is set as `ZSTD_LEGACY_SUPPORT=0` (disabled).\n        Decoding supported legacy format is a transparent capability triggered within decompression functions.\n        It's also allowed to invoke legacy API directly, exposed in `lib/legacy/zstd_legacy.h`.\n        Each version does also provide its own set of advanced API.\n        For example, advanced API for version `v0.4` is exposed in `lib/legacy/zstd_v04.h` .\n\n- While invoking `make libzstd`, it's possible to define build macros\n        `ZSTD_LIB_COMPRESSION`, `ZSTD_LIB_DECOMPRESSION`, `ZSTD_LIB_DICTBUILDER`,\n        and `ZSTD_LIB_DEPRECATED` as `0` to forgo compilation of the\n        corresponding features. This will also disable compilation of all\n        dependencies (e.g. `ZSTD_LIB_COMPRESSION=0` will also disable\n        dictBuilder).\n\n- There are a number of options that can help minimize the binary size of\n  `libzstd`.\n\n  The first step is to select the components needed (using the above-described\n  `ZSTD_LIB_COMPRESSION` etc.).\n\n  The next step is to set `ZSTD_LIB_MINIFY` to `1` when invoking `make`. This\n  disables various optional components and changes the compilation flags to\n  prioritize space-saving.\n\n  Detailed options: Zstandard's code and build environment is set up by default\n  to optimize above all else for performance. In pursuit of this goal, Zstandard\n  makes significant trade-offs in code size. For example, Zstandard often has\n  more than one implementation of a particular component, with each\n  implementation optimized for different scenarios. For example, the Huffman\n  decoder has complementary implementations that decode the stream one symbol at\n  a time or two symbols at a time. Zstd normally includes both (and dispatches\n  between them at runtime), but by defining `HUF_FORCE_DECOMPRESS_X1` or\n  `HUF_FORCE_DECOMPRESS_X2`, you can force the use of one or the other, avoiding\n  compilation of the other. Similarly, `ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT`\n  and `ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG` force the compilation and use of\n  only one or the other of two decompression implementations. The smallest\n  binary is achieved by using `HUF_FORCE_DECOMPRESS_X1` and\n  `ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT` (implied by `ZSTD_LIB_MINIFY`).\n\n  On the compressor side, Zstd's compression levels map to several internal\n  strategies. In environments where the higher compression levels aren't used,\n  it is possible to exclude all but the fastest strategy with\n  `ZSTD_LIB_EXCLUDE_COMPRESSORS_DFAST_AND_UP=1`. (Note that this will change\n  the behavior of the default compression level.) Or if you want to retain the\n  default compressor as well, you can set\n  `ZSTD_LIB_EXCLUDE_COMPRESSORS_GREEDY_AND_UP=1`, at the cost of an additional\n  ~20KB or so.\n\n  For squeezing the last ounce of size out, you can also define\n  `ZSTD_NO_INLINE`, which disables inlining, and `ZSTD_STRIP_ERROR_STRINGS`,\n  which removes the error messages that are otherwise returned by\n  `ZSTD_getErrorName` (implied by `ZSTD_LIB_MINIFY`).\n\n  Finally, when integrating into your application, make sure you're doing link-\n  time optimization and unused symbol garbage collection (via some combination of,\n  e.g., `-flto`, `-ffat-lto-objects`, `-fuse-linker-plugin`,\n  `-ffunction-sections`, `-fdata-sections`, `-fmerge-all-constants`,\n  `-Wl,--gc-sections`, `-Wl,-z,norelro`, and an archiver that understands\n  the compiler's intermediate representation, e.g., `AR=gcc-ar`). Consult your\n  compiler's documentation.\n\n- While invoking `make libzstd`, the build macro `ZSTD_LEGACY_MULTITHREADED_API=1`\n  will expose the deprecated `ZSTDMT` API exposed by `zstdmt_compress.h` in\n  the shared library, which is now hidden by default.\n\n- The build macro `STATIC_BMI2` can be set to 1 to force usage of `bmi2` instructions.\n  It is generally not necessary to set this build macro,\n  because `STATIC_BMI2` will be automatically set to 1\n  on detecting the presence of the corresponding instruction set in the compilation target.\n  It's nonetheless available as an optional manual toggle for better control,\n  and can also be used to forcefully disable `bmi2` instructions by setting it to 0.\n\n- The build macro `DYNAMIC_BMI2` can be set to 1 or 0 in order to generate binaries\n  which can detect at runtime the presence of BMI2 instructions, and use them only if present.\n  These instructions contribute to better performance, notably on the decoder side.\n  By default, this feature is automatically enabled on detecting\n  the right instruction set (x64) and compiler (clang or gcc >= 5).\n  It's obviously disabled for different cpus,\n  or when BMI2 instruction set is _required_ by the compiler command line\n  (in this case, only the BMI2 code path is generated).\n  Setting this macro will either force to generate the BMI2 dispatcher (1)\n  or prevent it (0). It overrides automatic detection.\n\n- The build macro `ZSTD_NO_UNUSED_FUNCTIONS` can be defined to hide the definitions of functions\n  that zstd does not use. Not all unused functions are hidden, but they can be if needed.\n  Currently, this macro will hide function definitions in FSE and HUF that use an excessive\n  amount of stack space.\n\n- The build macro `ZSTD_NO_INTRINSICS` can be defined to disable all explicit intrinsics.\n  Compiler builtins are still used.\n\n- The build macro `ZSTD_DECODER_INTERNAL_BUFFER` can be set to control\n  the amount of extra memory used during decompression to store literals.\n  This defaults to 64kB.  Reducing this value reduces the memory footprint of\n  `ZSTD_DCtx` decompression contexts,\n  but might also result in a small decompression speed cost.\n\n- The C compiler macros `ZSTDLIB_VISIBLE`, `ZSTDERRORLIB_VISIBLE` and `ZDICTLIB_VISIBLE`\n  can be overridden to control the visibility of zstd's API. Additionally,\n  `ZSTDLIB_STATIC_API` and `ZDICTLIB_STATIC_API` can be overridden to control the visibility\n  of zstd's static API. Specifically, it can be set to `ZSTDLIB_HIDDEN` to hide the symbols\n  from the shared library. These macros default to `ZSTDLIB_VISIBILITY`,\n  `ZSTDERRORLIB_VSIBILITY`, and `ZDICTLIB_VISIBILITY` if unset, for backwards compatibility\n  with the old macro names.\n\n- The C compiler macro `HUF_DISABLE_FAST_DECODE` disables the newer Huffman fast C\n  and assembly decoding loops. You may want to use this macro if these loops are\n  slower on your platform.\n\n- The macro `ZDICT_QSORT` can enforce selection of a specific sorting variant,\n  which is useful when autodetection fails, for example with older versions of `musl`.\n  For this scenario, it can be set as `ZDICT_QSORT=ZDICT_QSORT_C90`.\n  Other selectable suffixes are `_GNU`, `_APPLE`, `_MSVC` and `_C11`.\n\n#### Windows : using MinGW+MSYS to create DLL\n\nDLL can be created using MinGW+MSYS with the `make libzstd` command.\nThis command creates `dll\\libzstd.dll` and the import library `dll\\libzstd.lib`.\nThe import library is only required with Visual C++.\nThe header file `zstd.h` and the dynamic library `dll\\libzstd.dll` are required to\ncompile a project using gcc/MinGW.\nThe dynamic library has to be added to linking options.\nIt means that if a project that uses ZSTD consists of a single `test-dll.c`\nfile it should be linked with `dll\\libzstd.dll`. For example:\n```\n    gcc $(CFLAGS) -Iinclude/ test-dll.c -o test-dll dll\\libzstd.dll\n```\nThe compiled executable will require ZSTD DLL which is available at `dll\\libzstd.dll`.\n\n\n#### Advanced Build options\n\nThe build system requires a hash function in order to\nseparate object files created with different compilation flags.\nBy default, it tries to use `md5sum` or equivalent.\nThe hash function can be manually switched by setting the `HASH` variable.\nFor example : `make HASH=xxhsum`\nThe hash function needs to generate at least 64-bit using hexadecimal format.\nWhen no hash function is found,\nthe Makefile just generates all object files into the same default directory,\nirrespective of compilation flags.\nThis functionality only matters if `libzstd` is compiled multiple times\nwith different build flags.\n\nThe build directory, where object files are stored\ncan also be manually controlled using variable `BUILD_DIR`,\nfor example `make BUILD_DIR=objectDir/v1`.\nIn which case, the hash function doesn't matter.\n\n\n#### Deprecated API\n\nObsolete API on their way out are stored in directory `lib/deprecated`.\nAt this stage, it contains older streaming prototypes, in `lib/deprecated/zbuff.h`.\nThese prototypes will be removed in some future version.\nConsider migrating code towards supported streaming API exposed in `zstd.h`.\n\n\n#### Miscellaneous\n\nThe other files are not source code. There are :\n\n - `BUCK` : support for `buck` build system (https://buckbuild.com/)\n - `Makefile` : `make` script to build and install zstd library (static and dynamic)\n - `README.md` : this file\n - `dll/` : resources directory for Windows compilation\n - `libzstd.pc.in` : script for `pkg-config` (used in `make install`)\n"
  },
  {
    "path": "lib/common/allocations.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/* This file provides custom allocation primitives\n */\n\n#define ZSTD_DEPS_NEED_MALLOC\n#include \"zstd_deps.h\"   /* ZSTD_malloc, ZSTD_calloc, ZSTD_free, ZSTD_memset */\n\n#include \"compiler.h\" /* MEM_STATIC */\n#define ZSTD_STATIC_LINKING_ONLY\n#include \"../zstd.h\" /* ZSTD_customMem */\n\n#ifndef ZSTD_ALLOCATIONS_H\n#define ZSTD_ALLOCATIONS_H\n\n/* custom memory allocation functions */\n\nMEM_STATIC void* ZSTD_customMalloc(size_t size, ZSTD_customMem customMem)\n{\n    if (customMem.customAlloc)\n        return customMem.customAlloc(customMem.opaque, size);\n    return ZSTD_malloc(size);\n}\n\nMEM_STATIC void* ZSTD_customCalloc(size_t size, ZSTD_customMem customMem)\n{\n    if (customMem.customAlloc) {\n        /* calloc implemented as malloc+memset */\n        void* const ptr = customMem.customAlloc(customMem.opaque, size);\n\n        if (ptr == NULL) {\n            return NULL;\n        }\n\n        ZSTD_memset(ptr, 0, size);\n        return ptr;\n    }\n    return ZSTD_calloc(1, size);\n}\n\nMEM_STATIC void ZSTD_customFree(void* ptr, ZSTD_customMem customMem)\n{\n    if (ptr!=NULL) {\n        if (customMem.customFree)\n            customMem.customFree(customMem.opaque, ptr);\n        else\n            ZSTD_free(ptr);\n    }\n}\n\n#endif /* ZSTD_ALLOCATIONS_H */\n"
  },
  {
    "path": "lib/common/bits.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_BITS_H\n#define ZSTD_BITS_H\n\n#include \"mem.h\"\n\nMEM_STATIC unsigned ZSTD_countTrailingZeros32_fallback(U32 val)\n{\n    assert(val != 0);\n    {\n        static const U32 DeBruijnBytePos[32] = {0, 1, 28, 2, 29, 14, 24, 3,\n                                                30, 22, 20, 15, 25, 17, 4, 8,\n                                                31, 27, 13, 23, 21, 19, 16, 7,\n                                                26, 12, 18, 6, 11, 5, 10, 9};\n        return DeBruijnBytePos[((U32) ((val & (0-val)) * 0x077CB531U)) >> 27];\n    }\n}\n\nMEM_STATIC unsigned ZSTD_countTrailingZeros32(U32 val)\n{\n    assert(val != 0);\n#if defined(_MSC_VER)\n#  if STATIC_BMI2\n    return (unsigned)_tzcnt_u32(val);\n#  else\n    if (val != 0) {\n        unsigned long r;\n        _BitScanForward(&r, val);\n        return (unsigned)r;\n    } else {\n        __assume(0); /* Should not reach this code path */\n    }\n#  endif\n#elif defined(__GNUC__) && (__GNUC__ >= 4)\n    return (unsigned)__builtin_ctz(val);\n#elif defined(__ICCARM__)\n    return (unsigned)__builtin_ctz(val);\n#else\n    return ZSTD_countTrailingZeros32_fallback(val);\n#endif\n}\n\nMEM_STATIC unsigned ZSTD_countLeadingZeros32_fallback(U32 val)\n{\n    assert(val != 0);\n    {\n        static const U32 DeBruijnClz[32] = {0, 9, 1, 10, 13, 21, 2, 29,\n                                            11, 14, 16, 18, 22, 25, 3, 30,\n                                            8, 12, 20, 28, 15, 17, 24, 7,\n                                            19, 27, 23, 6, 26, 5, 4, 31};\n        val |= val >> 1;\n        val |= val >> 2;\n        val |= val >> 4;\n        val |= val >> 8;\n        val |= val >> 16;\n        return 31 - DeBruijnClz[(val * 0x07C4ACDDU) >> 27];\n    }\n}\n\nMEM_STATIC unsigned ZSTD_countLeadingZeros32(U32 val)\n{\n    assert(val != 0);\n#if defined(_MSC_VER)\n#  if STATIC_BMI2\n    return (unsigned)_lzcnt_u32(val);\n#  else\n    if (val != 0) {\n        unsigned long r;\n        _BitScanReverse(&r, val);\n        return (unsigned)(31 - r);\n    } else {\n        __assume(0); /* Should not reach this code path */\n    }\n#  endif\n#elif defined(__GNUC__) && (__GNUC__ >= 4)\n    return (unsigned)__builtin_clz(val);\n#elif defined(__ICCARM__)\n    return (unsigned)__builtin_clz(val);\n#else\n    return ZSTD_countLeadingZeros32_fallback(val);\n#endif\n}\n\nMEM_STATIC unsigned ZSTD_countTrailingZeros64(U64 val)\n{\n    assert(val != 0);\n#if defined(_MSC_VER) && defined(_WIN64)\n#  if STATIC_BMI2\n    return (unsigned)_tzcnt_u64(val);\n#  else\n    if (val != 0) {\n        unsigned long r;\n        _BitScanForward64(&r, val);\n        return (unsigned)r;\n    } else {\n        __assume(0); /* Should not reach this code path */\n    }\n#  endif\n#elif defined(__GNUC__) && (__GNUC__ >= 4) && defined(__LP64__)\n    return (unsigned)__builtin_ctzll(val);\n#elif defined(__ICCARM__)\n    return (unsigned)__builtin_ctzll(val);\n#else\n    {\n        U32 mostSignificantWord = (U32)(val >> 32);\n        U32 leastSignificantWord = (U32)val;\n        if (leastSignificantWord == 0) {\n            return 32 + ZSTD_countTrailingZeros32(mostSignificantWord);\n        } else {\n            return ZSTD_countTrailingZeros32(leastSignificantWord);\n        }\n    }\n#endif\n}\n\nMEM_STATIC unsigned ZSTD_countLeadingZeros64(U64 val)\n{\n    assert(val != 0);\n#if defined(_MSC_VER) && defined(_WIN64)\n#  if STATIC_BMI2\n    return (unsigned)_lzcnt_u64(val);\n#  else\n    if (val != 0) {\n        unsigned long r;\n        _BitScanReverse64(&r, val);\n        return (unsigned)(63 - r);\n    } else {\n        __assume(0); /* Should not reach this code path */\n    }\n#  endif\n#elif defined(__GNUC__) && (__GNUC__ >= 4)\n    return (unsigned)(__builtin_clzll(val));\n#elif defined(__ICCARM__)\n    return (unsigned)(__builtin_clzll(val));\n#else\n    {\n        U32 mostSignificantWord = (U32)(val >> 32);\n        U32 leastSignificantWord = (U32)val;\n        if (mostSignificantWord == 0) {\n            return 32 + ZSTD_countLeadingZeros32(leastSignificantWord);\n        } else {\n            return ZSTD_countLeadingZeros32(mostSignificantWord);\n        }\n    }\n#endif\n}\n\nMEM_STATIC unsigned ZSTD_NbCommonBytes(size_t val)\n{\n    if (MEM_isLittleEndian()) {\n        if (MEM_64bits()) {\n            return ZSTD_countTrailingZeros64((U64)val) >> 3;\n        } else {\n            return ZSTD_countTrailingZeros32((U32)val) >> 3;\n        }\n    } else {  /* Big Endian CPU */\n        if (MEM_64bits()) {\n            return ZSTD_countLeadingZeros64((U64)val) >> 3;\n        } else {\n            return ZSTD_countLeadingZeros32((U32)val) >> 3;\n        }\n    }\n}\n\nMEM_STATIC unsigned ZSTD_highbit32(U32 val)   /* compress, dictBuilder, decodeCorpus */\n{\n    assert(val != 0);\n    return 31 - ZSTD_countLeadingZeros32(val);\n}\n\n/* ZSTD_rotateRight_*():\n * Rotates a bitfield to the right by \"count\" bits.\n * https://en.wikipedia.org/w/index.php?title=Circular_shift&oldid=991635599#Implementing_circular_shifts\n */\nMEM_STATIC\nU64 ZSTD_rotateRight_U64(U64 const value, U32 count) {\n    assert(count < 64);\n    count &= 0x3F; /* for fickle pattern recognition */\n    return (value >> count) | (U64)(value << ((0U - count) & 0x3F));\n}\n\nMEM_STATIC\nU32 ZSTD_rotateRight_U32(U32 const value, U32 count) {\n    assert(count < 32);\n    count &= 0x1F; /* for fickle pattern recognition */\n    return (value >> count) | (U32)(value << ((0U - count) & 0x1F));\n}\n\nMEM_STATIC\nU16 ZSTD_rotateRight_U16(U16 const value, U32 count) {\n    assert(count < 16);\n    count &= 0x0F; /* for fickle pattern recognition */\n    return (value >> count) | (U16)(value << ((0U - count) & 0x0F));\n}\n\n#endif /* ZSTD_BITS_H */\n"
  },
  {
    "path": "lib/common/bitstream.h",
    "content": "/* ******************************************************************\n * bitstream\n * Part of FSE library\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * You can contact the author at :\n * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n****************************************************************** */\n#ifndef BITSTREAM_H_MODULE\n#define BITSTREAM_H_MODULE\n\n/*\n*  This API consists of small unitary functions, which must be inlined for best performance.\n*  Since link-time-optimization is not available for all compilers,\n*  these functions are defined into a .h to be included.\n*/\n\n/*-****************************************\n*  Dependencies\n******************************************/\n#include \"mem.h\"            /* unaligned access routines */\n#include \"compiler.h\"       /* UNLIKELY() */\n#include \"debug.h\"          /* assert(), DEBUGLOG(), RAWLOG() */\n#include \"error_private.h\"  /* error codes and messages */\n#include \"bits.h\"           /* ZSTD_highbit32 */\n\n/*=========================================\n*  Target specific\n=========================================*/\n#ifndef ZSTD_NO_INTRINSICS\n#  if (defined(__BMI__) || defined(__BMI2__)) && defined(__GNUC__)\n#    include    /* support for bextr (experimental)/bzhi */\n#  elif defined(__ICCARM__)\n#    include \n#  endif\n#endif\n\n#define STREAM_ACCUMULATOR_MIN_32  25\n#define STREAM_ACCUMULATOR_MIN_64  57\n#define STREAM_ACCUMULATOR_MIN    ((U32)(MEM_32bits() ? STREAM_ACCUMULATOR_MIN_32 : STREAM_ACCUMULATOR_MIN_64))\n\n\n/*-******************************************\n*  bitStream encoding API (write forward)\n********************************************/\ntypedef size_t BitContainerType;\n/* bitStream can mix input from multiple sources.\n * A critical property of these streams is that they encode and decode in **reverse** direction.\n * So the first bit sequence you add will be the last to be read, like a LIFO stack.\n */\ntypedef struct {\n    BitContainerType bitContainer;\n    unsigned bitPos;\n    char*  startPtr;\n    char*  ptr;\n    char*  endPtr;\n} BIT_CStream_t;\n\nMEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC, void* dstBuffer, size_t dstCapacity);\nMEM_STATIC void   BIT_addBits(BIT_CStream_t* bitC, BitContainerType value, unsigned nbBits);\nMEM_STATIC void   BIT_flushBits(BIT_CStream_t* bitC);\nMEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC);\n\n/* Start with initCStream, providing the size of buffer to write into.\n*  bitStream will never write outside of this buffer.\n*  `dstCapacity` must be >= sizeof(bitD->bitContainer), otherwise @return will be an error code.\n*\n*  bits are first added to a local register.\n*  Local register is BitContainerType, 64-bits on 64-bits systems, or 32-bits on 32-bits systems.\n*  Writing data into memory is an explicit operation, performed by the flushBits function.\n*  Hence keep track how many bits are potentially stored into local register to avoid register overflow.\n*  After a flushBits, a maximum of 7 bits might still be stored into local register.\n*\n*  Avoid storing elements of more than 24 bits if you want compatibility with 32-bits bitstream readers.\n*\n*  Last operation is to close the bitStream.\n*  The function returns the final size of CStream in bytes.\n*  If data couldn't fit into `dstBuffer`, it will return a 0 ( == not storable)\n*/\n\n\n/*-********************************************\n*  bitStream decoding API (read backward)\n**********************************************/\ntypedef struct {\n    BitContainerType bitContainer;\n    unsigned bitsConsumed;\n    const char* ptr;\n    const char* start;\n    const char* limitPtr;\n} BIT_DStream_t;\n\ntypedef enum { BIT_DStream_unfinished = 0,  /* fully refilled */\n               BIT_DStream_endOfBuffer = 1, /* still some bits left in bitstream */\n               BIT_DStream_completed = 2,   /* bitstream entirely consumed, bit-exact */\n               BIT_DStream_overflow = 3     /* user requested more bits than present in bitstream */\n    } BIT_DStream_status;  /* result of BIT_reloadDStream() */\n\nMEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);\nFORCE_INLINE_TEMPLATE BitContainerType BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);\nFORCE_INLINE_TEMPLATE BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);\nMEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);\n\n\n/* Start by invoking BIT_initDStream().\n*  A chunk of the bitStream is then stored into a local register.\n*  Local register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (BitContainerType).\n*  You can then retrieve bitFields stored into the local register, **in reverse order**.\n*  Local register is explicitly reloaded from memory by the BIT_reloadDStream() method.\n*  A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BIT_DStream_unfinished.\n*  Otherwise, it can be less than that, so proceed accordingly.\n*  Checking if DStream has reached its end can be performed with BIT_endOfDStream().\n*/\n\n\n/*-****************************************\n*  unsafe API\n******************************************/\nMEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, BitContainerType value, unsigned nbBits);\n/* faster, but works only if value is \"clean\", meaning all high bits above nbBits are 0 */\n\nMEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC);\n/* unsafe version; does not check buffer overflow */\n\nMEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);\n/* faster, but works only if nbBits >= 1 */\n\n/*=====    Local Constants   =====*/\nstatic const unsigned BIT_mask[] = {\n    0,          1,         3,         7,         0xF,       0x1F,\n    0x3F,       0x7F,      0xFF,      0x1FF,     0x3FF,     0x7FF,\n    0xFFF,      0x1FFF,    0x3FFF,    0x7FFF,    0xFFFF,    0x1FFFF,\n    0x3FFFF,    0x7FFFF,   0xFFFFF,   0x1FFFFF,  0x3FFFFF,  0x7FFFFF,\n    0xFFFFFF,   0x1FFFFFF, 0x3FFFFFF, 0x7FFFFFF, 0xFFFFFFF, 0x1FFFFFFF,\n    0x3FFFFFFF, 0x7FFFFFFF}; /* up to 31 bits */\n#define BIT_MASK_SIZE (sizeof(BIT_mask) / sizeof(BIT_mask[0]))\n\n/*-**************************************************************\n*  bitStream encoding\n****************************************************************/\n/*! BIT_initCStream() :\n *  `dstCapacity` must be > sizeof(size_t)\n *  @return : 0 if success,\n *            otherwise an error code (can be tested using ERR_isError()) */\nMEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC,\n                                  void* startPtr, size_t dstCapacity)\n{\n    bitC->bitContainer = 0;\n    bitC->bitPos = 0;\n    bitC->startPtr = (char*)startPtr;\n    bitC->ptr = bitC->startPtr;\n    bitC->endPtr = bitC->startPtr + dstCapacity - sizeof(bitC->bitContainer);\n    if (dstCapacity <= sizeof(bitC->bitContainer)) return ERROR(dstSize_tooSmall);\n    return 0;\n}\n\nFORCE_INLINE_TEMPLATE BitContainerType BIT_getLowerBits(BitContainerType bitContainer, U32 const nbBits)\n{\n#if STATIC_BMI2 && !defined(ZSTD_NO_INTRINSICS)\n#  if (defined(__x86_64__) || defined(_M_X64)) && !defined(__ILP32__)\n    return _bzhi_u64(bitContainer, nbBits);\n#  else\n    DEBUG_STATIC_ASSERT(sizeof(bitContainer) == sizeof(U32));\n    return _bzhi_u32(bitContainer, nbBits);\n#  endif\n#else\n    assert(nbBits < BIT_MASK_SIZE);\n    return bitContainer & BIT_mask[nbBits];\n#endif\n}\n\n/*! BIT_addBits() :\n *  can add up to 31 bits into `bitC`.\n *  Note : does not check for register overflow ! */\nMEM_STATIC void BIT_addBits(BIT_CStream_t* bitC,\n                            BitContainerType value, unsigned nbBits)\n{\n    DEBUG_STATIC_ASSERT(BIT_MASK_SIZE == 32);\n    assert(nbBits < BIT_MASK_SIZE);\n    assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8);\n    bitC->bitContainer |= BIT_getLowerBits(value, nbBits) << bitC->bitPos;\n    bitC->bitPos += nbBits;\n}\n\n/*! BIT_addBitsFast() :\n *  works only if `value` is _clean_,\n *  meaning all high bits above nbBits are 0 */\nMEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC,\n                                BitContainerType value, unsigned nbBits)\n{\n    assert((value>>nbBits) == 0);\n    assert(nbBits + bitC->bitPos < sizeof(bitC->bitContainer) * 8);\n    bitC->bitContainer |= value << bitC->bitPos;\n    bitC->bitPos += nbBits;\n}\n\n/*! BIT_flushBitsFast() :\n *  assumption : bitContainer has not overflowed\n *  unsafe version; does not check buffer overflow */\nMEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC)\n{\n    size_t const nbBytes = bitC->bitPos >> 3;\n    assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);\n    assert(bitC->ptr <= bitC->endPtr);\n    MEM_writeLEST(bitC->ptr, bitC->bitContainer);\n    bitC->ptr += nbBytes;\n    bitC->bitPos &= 7;\n    bitC->bitContainer >>= nbBytes*8;\n}\n\n/*! BIT_flushBits() :\n *  assumption : bitContainer has not overflowed\n *  safe version; check for buffer overflow, and prevents it.\n *  note : does not signal buffer overflow.\n *  overflow will be revealed later on using BIT_closeCStream() */\nMEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC)\n{\n    size_t const nbBytes = bitC->bitPos >> 3;\n    assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);\n    assert(bitC->ptr <= bitC->endPtr);\n    MEM_writeLEST(bitC->ptr, bitC->bitContainer);\n    bitC->ptr += nbBytes;\n    if (bitC->ptr > bitC->endPtr) bitC->ptr = bitC->endPtr;\n    bitC->bitPos &= 7;\n    bitC->bitContainer >>= nbBytes*8;\n}\n\n/*! BIT_closeCStream() :\n *  @return : size of CStream, in bytes,\n *            or 0 if it could not fit into dstBuffer */\nMEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC)\n{\n    BIT_addBitsFast(bitC, 1, 1);   /* endMark */\n    BIT_flushBits(bitC);\n    if (bitC->ptr >= bitC->endPtr) return 0; /* overflow detected */\n    return (size_t)(bitC->ptr - bitC->startPtr) + (bitC->bitPos > 0);\n}\n\n\n/*-********************************************************\n*  bitStream decoding\n**********************************************************/\n/*! BIT_initDStream() :\n *  Initialize a BIT_DStream_t.\n * `bitD` : a pointer to an already allocated BIT_DStream_t structure.\n * `srcSize` must be the *exact* size of the bitStream, in bytes.\n * @return : size of stream (== srcSize), or an errorCode if a problem is detected\n */\nMEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)\n{\n    if (srcSize < 1) { ZSTD_memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }\n\n    bitD->start = (const char*)srcBuffer;\n    bitD->limitPtr = bitD->start + sizeof(bitD->bitContainer);\n\n    if (srcSize >=  sizeof(bitD->bitContainer)) {  /* normal case */\n        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(bitD->bitContainer);\n        bitD->bitContainer = MEM_readLEST(bitD->ptr);\n        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];\n          bitD->bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0;  /* ensures bitsConsumed is always set */\n          if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }\n    } else {\n        bitD->ptr   = bitD->start;\n        bitD->bitContainer = *(const BYTE*)(bitD->start);\n        switch(srcSize)\n        {\n        case 7: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);\n                ZSTD_FALLTHROUGH;\n\n        case 6: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);\n                ZSTD_FALLTHROUGH;\n\n        case 5: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);\n                ZSTD_FALLTHROUGH;\n\n        case 4: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[3]) << 24;\n                ZSTD_FALLTHROUGH;\n\n        case 3: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[2]) << 16;\n                ZSTD_FALLTHROUGH;\n\n        case 2: bitD->bitContainer += (BitContainerType)(((const BYTE*)(srcBuffer))[1]) <<  8;\n                ZSTD_FALLTHROUGH;\n\n        default: break;\n        }\n        {   BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];\n            bitD->bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0;\n            if (lastByte == 0) return ERROR(corruption_detected);  /* endMark not present */\n        }\n        bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;\n    }\n\n    return srcSize;\n}\n\nFORCE_INLINE_TEMPLATE BitContainerType BIT_getUpperBits(BitContainerType bitContainer, U32 const start)\n{\n    return bitContainer >> start;\n}\n\nFORCE_INLINE_TEMPLATE BitContainerType BIT_getMiddleBits(BitContainerType bitContainer, U32 const start, U32 const nbBits)\n{\n    U32 const regMask = sizeof(bitContainer)*8 - 1;\n    /* if start > regMask, bitstream is corrupted, and result is undefined */\n    assert(nbBits < BIT_MASK_SIZE);\n    /* x86 transform & ((1 << nbBits) - 1) to bzhi instruction, it is better\n     * than accessing memory. When bmi2 instruction is not present, we consider\n     * such cpus old (pre-Haswell, 2013) and their performance is not of that\n     * importance.\n     */\n#if defined(__x86_64__) || defined(_M_X64)\n    return (bitContainer >> (start & regMask)) & ((((U64)1) << nbBits) - 1);\n#else\n    return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];\n#endif\n}\n\n/*! BIT_lookBits() :\n *  Provides next n bits from local register.\n *  local register is not modified.\n *  On 32-bits, maxNbBits==24.\n *  On 64-bits, maxNbBits==56.\n * @return : value extracted */\nFORCE_INLINE_TEMPLATE BitContainerType BIT_lookBits(const BIT_DStream_t*  bitD, U32 nbBits)\n{\n    /* arbitrate between double-shift and shift+mask */\n#if 1\n    /* if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8,\n     * bitstream is likely corrupted, and result is undefined */\n    return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);\n#else\n    /* this code path is slower on my os-x laptop */\n    U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;\n    return ((bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> 1) >> ((regMask-nbBits) & regMask);\n#endif\n}\n\n/*! BIT_lookBitsFast() :\n *  unsafe version; only works if nbBits >= 1 */\nMEM_STATIC BitContainerType BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits)\n{\n    U32 const regMask = sizeof(bitD->bitContainer)*8 - 1;\n    assert(nbBits >= 1);\n    return (bitD->bitContainer << (bitD->bitsConsumed & regMask)) >> (((regMask+1)-nbBits) & regMask);\n}\n\nFORCE_INLINE_TEMPLATE void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)\n{\n    bitD->bitsConsumed += nbBits;\n}\n\n/*! BIT_readBits() :\n *  Read (consume) next n bits from local register and update.\n *  Pay attention to not read more than nbBits contained into local register.\n * @return : extracted value. */\nFORCE_INLINE_TEMPLATE BitContainerType BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits)\n{\n    BitContainerType const value = BIT_lookBits(bitD, nbBits);\n    BIT_skipBits(bitD, nbBits);\n    return value;\n}\n\n/*! BIT_readBitsFast() :\n *  unsafe version; only works if nbBits >= 1 */\nMEM_STATIC BitContainerType BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits)\n{\n    BitContainerType const value = BIT_lookBitsFast(bitD, nbBits);\n    assert(nbBits >= 1);\n    BIT_skipBits(bitD, nbBits);\n    return value;\n}\n\n/*! BIT_reloadDStream_internal() :\n *  Simple variant of BIT_reloadDStream(), with two conditions:\n *  1. bitstream is valid : bitsConsumed <= sizeof(bitD->bitContainer)*8\n *  2. look window is valid after shifted down : bitD->ptr >= bitD->start\n */\nMEM_STATIC BIT_DStream_status BIT_reloadDStream_internal(BIT_DStream_t* bitD)\n{\n    assert(bitD->bitsConsumed <= sizeof(bitD->bitContainer)*8);\n    bitD->ptr -= bitD->bitsConsumed >> 3;\n    assert(bitD->ptr >= bitD->start);\n    bitD->bitsConsumed &= 7;\n    bitD->bitContainer = MEM_readLEST(bitD->ptr);\n    return BIT_DStream_unfinished;\n}\n\n/*! BIT_reloadDStreamFast() :\n *  Similar to BIT_reloadDStream(), but with two differences:\n *  1. bitsConsumed <= sizeof(bitD->bitContainer)*8 must hold!\n *  2. Returns BIT_DStream_overflow when bitD->ptr < bitD->limitPtr, at this\n *     point you must use BIT_reloadDStream() to reload.\n */\nMEM_STATIC BIT_DStream_status BIT_reloadDStreamFast(BIT_DStream_t* bitD)\n{\n    if (UNLIKELY(bitD->ptr < bitD->limitPtr))\n        return BIT_DStream_overflow;\n    return BIT_reloadDStream_internal(bitD);\n}\n\n/*! BIT_reloadDStream() :\n *  Refill `bitD` from buffer previously set in BIT_initDStream() .\n *  This function is safe, it guarantees it will not never beyond src buffer.\n * @return : status of `BIT_DStream_t` internal register.\n *           when status == BIT_DStream_unfinished, internal register is filled with at least 25 or 57 bits */\nFORCE_INLINE_TEMPLATE BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)\n{\n    /* note : once in overflow mode, a bitstream remains in this mode until it's reset */\n    if (UNLIKELY(bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))) {\n        static const BitContainerType zeroFilled = 0;\n        bitD->ptr = (const char*)&zeroFilled; /* aliasing is allowed for char */\n        /* overflow detected, erroneous scenario or end of stream: no update */\n        return BIT_DStream_overflow;\n    }\n\n    assert(bitD->ptr >= bitD->start);\n\n    if (bitD->ptr >= bitD->limitPtr) {\n        return BIT_reloadDStream_internal(bitD);\n    }\n    if (bitD->ptr == bitD->start) {\n        /* reached end of bitStream => no update */\n        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;\n        return BIT_DStream_completed;\n    }\n    /* start < ptr < limitPtr => cautious update */\n    {   U32 nbBytes = bitD->bitsConsumed >> 3;\n        BIT_DStream_status result = BIT_DStream_unfinished;\n        if (bitD->ptr - nbBytes < bitD->start) {\n            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */\n            result = BIT_DStream_endOfBuffer;\n        }\n        bitD->ptr -= nbBytes;\n        bitD->bitsConsumed -= nbBytes*8;\n        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */\n        return result;\n    }\n}\n\n/*! BIT_endOfDStream() :\n * @return : 1 if DStream has _exactly_ reached its end (all bits consumed).\n */\nMEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)\n{\n    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));\n}\n\n#endif /* BITSTREAM_H_MODULE */\n"
  },
  {
    "path": "lib/common/compiler.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_COMPILER_H\n#define ZSTD_COMPILER_H\n\n#include \n\n#include \"portability_macros.h\"\n\n/*-*******************************************************\n*  Compiler specifics\n*********************************************************/\n/* force inlining */\n\n#if !defined(ZSTD_NO_INLINE)\n#if (defined(__GNUC__) && !defined(__STRICT_ANSI__)) || defined(__cplusplus) || defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */\n#  define INLINE_KEYWORD inline\n#else\n#  define INLINE_KEYWORD\n#endif\n\n#if defined(__GNUC__) || defined(__IAR_SYSTEMS_ICC__)\n#  define FORCE_INLINE_ATTR __attribute__((always_inline))\n#elif defined(_MSC_VER)\n#  define FORCE_INLINE_ATTR __forceinline\n#else\n#  define FORCE_INLINE_ATTR\n#endif\n\n#else\n\n#define INLINE_KEYWORD\n#define FORCE_INLINE_ATTR\n\n#endif\n\n/**\n  On MSVC qsort requires that functions passed into it use the __cdecl calling conversion(CC).\n  This explicitly marks such functions as __cdecl so that the code will still compile\n  if a CC other than __cdecl has been made the default.\n*/\n#if  defined(_MSC_VER)\n#  define WIN_CDECL __cdecl\n#else\n#  define WIN_CDECL\n#endif\n\n/* UNUSED_ATTR tells the compiler it is okay if the function is unused. */\n#if defined(__GNUC__) || defined(__IAR_SYSTEMS_ICC__)\n#  define UNUSED_ATTR __attribute__((unused))\n#else\n#  define UNUSED_ATTR\n#endif\n\n/**\n * FORCE_INLINE_TEMPLATE is used to define C \"templates\", which take constant\n * parameters. They must be inlined for the compiler to eliminate the constant\n * branches.\n */\n#define FORCE_INLINE_TEMPLATE static INLINE_KEYWORD FORCE_INLINE_ATTR UNUSED_ATTR\n/**\n * HINT_INLINE is used to help the compiler generate better code. It is *not*\n * used for \"templates\", so it can be tweaked based on the compilers\n * performance.\n *\n * gcc-4.8 and gcc-4.9 have been shown to benefit from leaving off the\n * always_inline attribute.\n *\n * clang up to 5.0.0 (trunk) benefit tremendously from the always_inline\n * attribute.\n */\n#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 8 && __GNUC__ < 5\n#  define HINT_INLINE static INLINE_KEYWORD\n#else\n#  define HINT_INLINE FORCE_INLINE_TEMPLATE\n#endif\n\n/* \"soft\" inline :\n * The compiler is free to select if it's a good idea to inline or not.\n * The main objective is to silence compiler warnings\n * when a defined function in included but not used.\n *\n * Note : this macro is prefixed `MEM_` because it used to be provided by `mem.h` unit.\n * Updating the prefix is probably preferable, but requires a fairly large codemod,\n * since this name is used everywhere.\n */\n#ifndef MEM_STATIC  /* already defined in Linux Kernel mem.h */\n#if defined(__GNUC__)\n#  define MEM_STATIC static __inline UNUSED_ATTR\n#elif defined(__IAR_SYSTEMS_ICC__)\n#  define MEM_STATIC static inline UNUSED_ATTR\n#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)\n#  define MEM_STATIC static inline\n#elif defined(_MSC_VER)\n#  define MEM_STATIC static __inline\n#else\n#  define MEM_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */\n#endif\n#endif\n\n/* force no inlining */\n#ifdef _MSC_VER\n#  define FORCE_NOINLINE static __declspec(noinline)\n#else\n#  if defined(__GNUC__) || defined(__IAR_SYSTEMS_ICC__)\n#    define FORCE_NOINLINE static __attribute__((__noinline__))\n#  else\n#    define FORCE_NOINLINE static\n#  endif\n#endif\n\n\n/* target attribute */\n#if defined(__GNUC__) || defined(__IAR_SYSTEMS_ICC__)\n#  define TARGET_ATTRIBUTE(target) __attribute__((__target__(target)))\n#else\n#  define TARGET_ATTRIBUTE(target)\n#endif\n\n/* Target attribute for BMI2 dynamic dispatch.\n * Enable lzcnt, bmi, and bmi2.\n * We test for bmi1 & bmi2. lzcnt is included in bmi1.\n */\n#define BMI2_TARGET_ATTRIBUTE TARGET_ATTRIBUTE(\"lzcnt,bmi,bmi2\")\n\n/* prefetch\n * can be disabled, by declaring NO_PREFETCH build macro */\n#if defined(NO_PREFETCH)\n#  define PREFETCH_L1(ptr)  do { (void)(ptr); } while (0)  /* disabled */\n#  define PREFETCH_L2(ptr)  do { (void)(ptr); } while (0)  /* disabled */\n#else\n#  if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_I86)) && !defined(_M_ARM64EC)  /* _mm_prefetch() is not defined outside of x86/x64 */\n#    include    /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */\n#    define PREFETCH_L1(ptr)  _mm_prefetch((const char*)(ptr), _MM_HINT_T0)\n#    define PREFETCH_L2(ptr)  _mm_prefetch((const char*)(ptr), _MM_HINT_T1)\n#  elif defined(__GNUC__) && ( (__GNUC__ >= 4) || ( (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1) ) )\n#    define PREFETCH_L1(ptr)  __builtin_prefetch((ptr), 0 /* rw==read */, 3 /* locality */)\n#    define PREFETCH_L2(ptr)  __builtin_prefetch((ptr), 0 /* rw==read */, 2 /* locality */)\n#  elif defined(__aarch64__)\n#    define PREFETCH_L1(ptr)  do { __asm__ __volatile__(\"prfm pldl1keep, %0\" ::\"Q\"(*(ptr))); } while (0)\n#    define PREFETCH_L2(ptr)  do { __asm__ __volatile__(\"prfm pldl2keep, %0\" ::\"Q\"(*(ptr))); } while (0)\n#  else\n#    define PREFETCH_L1(ptr) do { (void)(ptr); } while (0)  /* disabled */\n#    define PREFETCH_L2(ptr) do { (void)(ptr); } while (0)  /* disabled */\n#  endif\n#endif  /* NO_PREFETCH */\n\n#define CACHELINE_SIZE 64\n\n#define PREFETCH_AREA(p, s)                              \\\n    do {                                                 \\\n        const char* const _ptr = (const char*)(p);       \\\n        size_t const _size = (size_t)(s);                \\\n        size_t _pos;                                     \\\n        for (_pos=0; _pos<_size; _pos+=CACHELINE_SIZE) { \\\n            PREFETCH_L2(_ptr + _pos);                    \\\n        }                                                \\\n    } while (0)\n\n/* vectorization\n * older GCC (pre gcc-4.3 picked as the cutoff) uses a different syntax,\n * and some compilers, like Intel ICC and MCST LCC, do not support it at all. */\n#if !defined(__INTEL_COMPILER) && !defined(__clang__) && defined(__GNUC__) && !defined(__LCC__)\n#  if (__GNUC__ == 4 && __GNUC_MINOR__ > 3) || (__GNUC__ >= 5)\n#    define DONT_VECTORIZE __attribute__((optimize(\"no-tree-vectorize\")))\n#  else\n#    define DONT_VECTORIZE _Pragma(\"GCC optimize(\\\"no-tree-vectorize\\\")\")\n#  endif\n#else\n#  define DONT_VECTORIZE\n#endif\n\n/* Tell the compiler that a branch is likely or unlikely.\n * Only use these macros if it causes the compiler to generate better code.\n * If you can remove a LIKELY/UNLIKELY annotation without speed changes in gcc\n * and clang, please do.\n */\n#if defined(__GNUC__)\n#define LIKELY(x) (__builtin_expect((x), 1))\n#define UNLIKELY(x) (__builtin_expect((x), 0))\n#else\n#define LIKELY(x) (x)\n#define UNLIKELY(x) (x)\n#endif\n\n#if __has_builtin(__builtin_unreachable) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)))\n#  define ZSTD_UNREACHABLE do { assert(0), __builtin_unreachable(); } while (0)\n#else\n#  define ZSTD_UNREACHABLE do { assert(0); } while (0)\n#endif\n\n/* disable warnings */\n#ifdef _MSC_VER    /* Visual Studio */\n#  include                     /* For Visual 2005 */\n#  pragma warning(disable : 4100)        /* disable: C4100: unreferenced formal parameter */\n#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */\n#  pragma warning(disable : 4204)        /* disable: C4204: non-constant aggregate initializer */\n#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */\n#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */\n#endif\n\n/* compile time determination of SIMD support */\n#if !defined(ZSTD_NO_INTRINSICS)\n#  if defined(__AVX2__)\n#    define ZSTD_ARCH_X86_AVX2\n#  endif\n#  if defined(__SSE2__) || defined(_M_X64) || (defined (_M_IX86) && defined(_M_IX86_FP) && (_M_IX86_FP >= 2))\n#    define ZSTD_ARCH_X86_SSE2\n#  endif\n#  if defined(__ARM_NEON) || defined(_M_ARM64)\n#    define ZSTD_ARCH_ARM_NEON\n#  endif\n#  if defined(__ARM_FEATURE_SVE)\n#    define ZSTD_ARCH_ARM_SVE\n#  endif\n#  if defined(__ARM_FEATURE_SVE2)\n#    define ZSTD_ARCH_ARM_SVE2\n#  endif\n#  if defined(__riscv) && defined(__riscv_vector)\n#    if ((defined(__GNUC__) && !defined(__clang__) && __GNUC__ >= 14) || \\\n        (defined(__clang__) && __clang_major__ >= 19))\n        #define ZSTD_ARCH_RISCV_RVV\n#  endif\n#endif\n#\n#  if defined(ZSTD_ARCH_X86_AVX2)\n#    include \n#  endif\n#  if defined(ZSTD_ARCH_X86_SSE2)\n#    include \n#  elif defined(ZSTD_ARCH_ARM_NEON)\n#    include \n#  endif\n#  if defined(ZSTD_ARCH_ARM_SVE) || defined(ZSTD_ARCH_ARM_SVE2)\n#    include \n#  endif\n#  if defined(ZSTD_ARCH_RISCV_RVV)\n#    include \n#  endif\n#endif\n\n/* C-language Attributes are added in C23. */\n#if defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201710L) && defined(__has_c_attribute)\n# define ZSTD_HAS_C_ATTRIBUTE(x) __has_c_attribute(x)\n#else\n# define ZSTD_HAS_C_ATTRIBUTE(x) 0\n#endif\n\n/* Only use C++ attributes in C++. Some compilers report support for C++\n * attributes when compiling with C.\n */\n#if defined(__cplusplus) && defined(__has_cpp_attribute)\n# define ZSTD_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)\n#else\n# define ZSTD_HAS_CPP_ATTRIBUTE(x) 0\n#endif\n\n/* Define ZSTD_FALLTHROUGH macro for annotating switch case with the 'fallthrough' attribute.\n * - C23: https://en.cppreference.com/w/c/language/attributes/fallthrough\n * - CPP17: https://en.cppreference.com/w/cpp/language/attributes/fallthrough\n * - Else: __attribute__((__fallthrough__))\n */\n#ifndef ZSTD_FALLTHROUGH\n# if ZSTD_HAS_C_ATTRIBUTE(fallthrough)\n#  define ZSTD_FALLTHROUGH [[fallthrough]]\n# elif ZSTD_HAS_CPP_ATTRIBUTE(fallthrough)\n#  define ZSTD_FALLTHROUGH [[fallthrough]]\n# elif __has_attribute(__fallthrough__)\n/* Leading semicolon is to satisfy gcc-11 with -pedantic. Without the semicolon\n * gcc complains about: a label can only be part of a statement and a declaration is not a statement.\n */\n#  define ZSTD_FALLTHROUGH ; __attribute__((__fallthrough__))\n# else\n#  define ZSTD_FALLTHROUGH\n# endif\n#endif\n\n/*-**************************************************************\n*  Alignment\n*****************************************************************/\n\n/* @return 1 if @u is a 2^n value, 0 otherwise\n * useful to check a value is valid for alignment restrictions */\nMEM_STATIC int ZSTD_isPower2(size_t u) {\n    return (u & (u-1)) == 0;\n}\n\n/* this test was initially positioned in mem.h,\n * but this file is removed (or replaced) for linux kernel\n * so it's now hosted in compiler.h,\n * which remains valid for both user & kernel spaces.\n */\n\n#ifndef ZSTD_ALIGNOF\n# if defined(__GNUC__) || defined(_MSC_VER)\n/* covers gcc, clang & MSVC */\n/* note : this section must come first, before C11,\n * due to a limitation in the kernel source generator */\n#  define ZSTD_ALIGNOF(T) __alignof(T)\n\n# elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)\n/* C11 support */\n#  include \n#  define ZSTD_ALIGNOF(T) alignof(T)\n\n# else\n/* No known support for alignof() - imperfect backup */\n#  define ZSTD_ALIGNOF(T) (sizeof(void*) < sizeof(T) ? sizeof(void*) : sizeof(T))\n\n# endif\n#endif /* ZSTD_ALIGNOF */\n\n#ifndef ZSTD_ALIGNED\n/* C90-compatible alignment macro (GCC/Clang). Adjust for other compilers if needed. */\n# if defined(__GNUC__) || defined(__clang__)\n#  define ZSTD_ALIGNED(a) __attribute__((aligned(a)))\n# elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) /* C11 */\n#  define ZSTD_ALIGNED(a) _Alignas(a)\n#elif defined(_MSC_VER)\n#  define ZSTD_ALIGNED(n) __declspec(align(n))\n# else\n   /* this compiler will require its own alignment instruction */\n#  define ZSTD_ALIGNED(...)\n# endif\n#endif /* ZSTD_ALIGNED */\n\n\n/*-**************************************************************\n*  Sanitizer\n*****************************************************************/\n\n/**\n * Zstd relies on pointer overflow in its decompressor.\n * We add this attribute to functions that rely on pointer overflow.\n */\n#ifndef ZSTD_ALLOW_POINTER_OVERFLOW_ATTR\n#  if __has_attribute(no_sanitize)\n#    if !defined(__clang__) && defined(__GNUC__) && __GNUC__ < 8\n       /* gcc < 8 only has signed-integer-overlow which triggers on pointer overflow */\n#      define ZSTD_ALLOW_POINTER_OVERFLOW_ATTR __attribute__((no_sanitize(\"signed-integer-overflow\")))\n#    else\n       /* older versions of clang [3.7, 5.0) will warn that pointer-overflow is ignored. */\n#      define ZSTD_ALLOW_POINTER_OVERFLOW_ATTR __attribute__((no_sanitize(\"pointer-overflow\")))\n#    endif\n#  else\n#    define ZSTD_ALLOW_POINTER_OVERFLOW_ATTR\n#  endif\n#endif\n\n/**\n * Helper function to perform a wrapped pointer difference without triggering\n * UBSAN.\n *\n * @returns lhs - rhs with wrapping\n */\nMEM_STATIC\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nptrdiff_t ZSTD_wrappedPtrDiff(unsigned char const* lhs, unsigned char const* rhs)\n{\n    return lhs - rhs;\n}\n\n/**\n * Helper function to perform a wrapped pointer add without triggering UBSAN.\n *\n * @return ptr + add with wrapping\n */\nMEM_STATIC\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nconst void* ZSTD_wrappedPtrAdd(const void* ptr, ptrdiff_t add)\n{\n    return (const char*)ptr + add;\n}\n\n/**\n * Helper function to perform a wrapped pointer subtraction without triggering\n * UBSAN.\n *\n * @return ptr - sub with wrapping\n */\nMEM_STATIC\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nconst void* ZSTD_wrappedPtrSub(const void* ptr, ptrdiff_t sub)\n{\n    return (const char*)ptr - sub;\n}\n\n/**\n * Helper function to add to a pointer that works around C's undefined behavior\n * of adding 0 to NULL.\n *\n * @returns `ptr + add` except it defines `NULL + 0 == NULL`.\n */\nMEM_STATIC\nvoid* ZSTD_maybeNullPtrAdd(void* ptr, ptrdiff_t add)\n{\n    return add > 0 ? (char*)ptr + add : ptr;\n}\n\n/* Issue #3240 reports an ASAN failure on an llvm-mingw build. Out of an\n * abundance of caution, disable our custom poisoning on mingw. */\n#ifdef __MINGW32__\n#ifndef ZSTD_ASAN_DONT_POISON_WORKSPACE\n#define ZSTD_ASAN_DONT_POISON_WORKSPACE 1\n#endif\n#ifndef ZSTD_MSAN_DONT_POISON_WORKSPACE\n#define ZSTD_MSAN_DONT_POISON_WORKSPACE 1\n#endif\n#endif\n\n#if ZSTD_MEMORY_SANITIZER && !defined(ZSTD_MSAN_DONT_POISON_WORKSPACE)\n/* Not all platforms that support msan provide sanitizers/msan_interface.h.\n * We therefore declare the functions we need ourselves, rather than trying to\n * include the header file... */\n#include   /* size_t */\n#define ZSTD_DEPS_NEED_STDINT\n#include \"zstd_deps.h\"  /* intptr_t */\n\n/* Make memory region fully initialized (without changing its contents). */\nvoid __msan_unpoison(const volatile void *a, size_t size);\n\n/* Make memory region fully uninitialized (without changing its contents).\n   This is a legacy interface that does not update origin information. Use\n   __msan_allocated_memory() instead. */\nvoid __msan_poison(const volatile void *a, size_t size);\n\n/* Returns the offset of the first (at least partially) poisoned byte in the\n   memory range, or -1 if the whole range is good. */\nintptr_t __msan_test_shadow(const volatile void *x, size_t size);\n\n/* Print shadow and origin for the memory range to stderr in a human-readable\n   format. */\nvoid __msan_print_shadow(const volatile void *x, size_t size);\n#endif\n\n#if ZSTD_ADDRESS_SANITIZER && !defined(ZSTD_ASAN_DONT_POISON_WORKSPACE)\n/* Not all platforms that support asan provide sanitizers/asan_interface.h.\n * We therefore declare the functions we need ourselves, rather than trying to\n * include the header file... */\n#include   /* size_t */\n\n/**\n * Marks a memory region ([addr, addr+size)) as unaddressable.\n *\n * This memory must be previously allocated by your program. Instrumented\n * code is forbidden from accessing addresses in this region until it is\n * unpoisoned. This function is not guaranteed to poison the entire region -\n * it could poison only a subregion of [addr, addr+size) due to ASan\n * alignment restrictions.\n *\n * \\note This function is not thread-safe because no two threads can poison or\n * unpoison memory in the same memory region simultaneously.\n *\n * \\param addr Start of memory region.\n * \\param size Size of memory region. */\nvoid __asan_poison_memory_region(void const volatile *addr, size_t size);\n\n/**\n * Marks a memory region ([addr, addr+size)) as addressable.\n *\n * This memory must be previously allocated by your program. Accessing\n * addresses in this region is allowed until this region is poisoned again.\n * This function could unpoison a super-region of [addr, addr+size) due\n * to ASan alignment restrictions.\n *\n * \\note This function is not thread-safe because no two threads can\n * poison or unpoison memory in the same memory region simultaneously.\n *\n * \\param addr Start of memory region.\n * \\param size Size of memory region. */\nvoid __asan_unpoison_memory_region(void const volatile *addr, size_t size);\n#endif\n\n#endif /* ZSTD_COMPILER_H */\n"
  },
  {
    "path": "lib/common/cpu.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_COMMON_CPU_H\n#define ZSTD_COMMON_CPU_H\n\n/**\n * Implementation taken from folly/CpuId.h\n * https://github.com/facebook/folly/blob/master/folly/CpuId.h\n */\n\n#include \"mem.h\"\n\n#ifdef _MSC_VER\n#include \n#endif\n\ntypedef struct {\n    U32 f1c;\n    U32 f1d;\n    U32 f7b;\n    U32 f7c;\n} ZSTD_cpuid_t;\n\nMEM_STATIC ZSTD_cpuid_t ZSTD_cpuid(void) {\n    U32 f1c = 0;\n    U32 f1d = 0;\n    U32 f7b = 0;\n    U32 f7c = 0;\n#if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86))\n#if !defined(_M_X64) || !defined(__clang__) || __clang_major__ >= 16\n    int reg[4];\n    __cpuid((int*)reg, 0);\n    {\n        int const n = reg[0];\n        if (n >= 1) {\n            __cpuid((int*)reg, 1);\n            f1c = (U32)reg[2];\n            f1d = (U32)reg[3];\n        }\n        if (n >= 7) {\n            __cpuidex((int*)reg, 7, 0);\n            f7b = (U32)reg[1];\n            f7c = (U32)reg[2];\n        }\n    }\n#else\n    /* Clang compiler has a bug (fixed in https://reviews.llvm.org/D101338) in\n     * which the `__cpuid` intrinsic does not save and restore `rbx` as it needs\n     * to due to being a reserved register. So in that case, do the `cpuid`\n     * ourselves. Clang supports inline assembly anyway.\n     */\n    U32 n;\n    __asm__(\n        \"pushq %%rbx\\n\\t\"\n        \"cpuid\\n\\t\"\n        \"popq %%rbx\\n\\t\"\n        : \"=a\"(n)\n        : \"a\"(0)\n        : \"rcx\", \"rdx\");\n    if (n >= 1) {\n      U32 f1a;\n      __asm__(\n          \"pushq %%rbx\\n\\t\"\n          \"cpuid\\n\\t\"\n          \"popq %%rbx\\n\\t\"\n          : \"=a\"(f1a), \"=c\"(f1c), \"=d\"(f1d)\n          : \"a\"(1)\n          :);\n    }\n    if (n >= 7) {\n      __asm__(\n          \"pushq %%rbx\\n\\t\"\n          \"cpuid\\n\\t\"\n          \"movq %%rbx, %%rax\\n\\t\"\n          \"popq %%rbx\"\n          : \"=a\"(f7b), \"=c\"(f7c)\n          : \"a\"(7), \"c\"(0)\n          : \"rdx\");\n    }\n#endif\n#elif defined(__i386__) && defined(__PIC__) && !defined(__clang__) && defined(__GNUC__)\n    /* The following block like the normal cpuid branch below, but gcc\n     * reserves ebx for use of its pic register so we must specially\n     * handle the save and restore to avoid clobbering the register\n     */\n    U32 n;\n    __asm__(\n        \"pushl %%ebx\\n\\t\"\n        \"cpuid\\n\\t\"\n        \"popl %%ebx\\n\\t\"\n        : \"=a\"(n)\n        : \"a\"(0)\n        : \"ecx\", \"edx\");\n    if (n >= 1) {\n      U32 f1a;\n      __asm__(\n          \"pushl %%ebx\\n\\t\"\n          \"cpuid\\n\\t\"\n          \"popl %%ebx\\n\\t\"\n          : \"=a\"(f1a), \"=c\"(f1c), \"=d\"(f1d)\n          : \"a\"(1));\n    }\n    if (n >= 7) {\n      __asm__(\n          \"pushl %%ebx\\n\\t\"\n          \"cpuid\\n\\t\"\n          \"movl %%ebx, %%eax\\n\\t\"\n          \"popl %%ebx\"\n          : \"=a\"(f7b), \"=c\"(f7c)\n          : \"a\"(7), \"c\"(0)\n          : \"edx\");\n    }\n#elif defined(__x86_64__) || defined(_M_X64) || defined(__i386__)\n    U32 n;\n    __asm__(\"cpuid\" : \"=a\"(n) : \"a\"(0) : \"ebx\", \"ecx\", \"edx\");\n    if (n >= 1) {\n      U32 f1a;\n      __asm__(\"cpuid\" : \"=a\"(f1a), \"=c\"(f1c), \"=d\"(f1d) : \"a\"(1) : \"ebx\");\n    }\n    if (n >= 7) {\n      U32 f7a;\n      __asm__(\"cpuid\"\n              : \"=a\"(f7a), \"=b\"(f7b), \"=c\"(f7c)\n              : \"a\"(7), \"c\"(0)\n              : \"edx\");\n    }\n#endif\n    {\n        ZSTD_cpuid_t cpuid;\n        cpuid.f1c = f1c;\n        cpuid.f1d = f1d;\n        cpuid.f7b = f7b;\n        cpuid.f7c = f7c;\n        return cpuid;\n    }\n}\n\n#define X(name, r, bit)                                                        \\\n  MEM_STATIC int ZSTD_cpuid_##name(ZSTD_cpuid_t const cpuid) {                 \\\n    return ((cpuid.r) & (1U << bit)) != 0;                                     \\\n  }\n\n/* cpuid(1): Processor Info and Feature Bits. */\n#define C(name, bit) X(name, f1c, bit)\n  C(sse3, 0)\n  C(pclmuldq, 1)\n  C(dtes64, 2)\n  C(monitor, 3)\n  C(dscpl, 4)\n  C(vmx, 5)\n  C(smx, 6)\n  C(eist, 7)\n  C(tm2, 8)\n  C(ssse3, 9)\n  C(cnxtid, 10)\n  C(fma, 12)\n  C(cx16, 13)\n  C(xtpr, 14)\n  C(pdcm, 15)\n  C(pcid, 17)\n  C(dca, 18)\n  C(sse41, 19)\n  C(sse42, 20)\n  C(x2apic, 21)\n  C(movbe, 22)\n  C(popcnt, 23)\n  C(tscdeadline, 24)\n  C(aes, 25)\n  C(xsave, 26)\n  C(osxsave, 27)\n  C(avx, 28)\n  C(f16c, 29)\n  C(rdrand, 30)\n#undef C\n#define D(name, bit) X(name, f1d, bit)\n  D(fpu, 0)\n  D(vme, 1)\n  D(de, 2)\n  D(pse, 3)\n  D(tsc, 4)\n  D(msr, 5)\n  D(pae, 6)\n  D(mce, 7)\n  D(cx8, 8)\n  D(apic, 9)\n  D(sep, 11)\n  D(mtrr, 12)\n  D(pge, 13)\n  D(mca, 14)\n  D(cmov, 15)\n  D(pat, 16)\n  D(pse36, 17)\n  D(psn, 18)\n  D(clfsh, 19)\n  D(ds, 21)\n  D(acpi, 22)\n  D(mmx, 23)\n  D(fxsr, 24)\n  D(sse, 25)\n  D(sse2, 26)\n  D(ss, 27)\n  D(htt, 28)\n  D(tm, 29)\n  D(pbe, 31)\n#undef D\n\n/* cpuid(7): Extended Features. */\n#define B(name, bit) X(name, f7b, bit)\n  B(bmi1, 3)\n  B(hle, 4)\n  B(avx2, 5)\n  B(smep, 7)\n  B(bmi2, 8)\n  B(erms, 9)\n  B(invpcid, 10)\n  B(rtm, 11)\n  B(mpx, 14)\n  B(avx512f, 16)\n  B(avx512dq, 17)\n  B(rdseed, 18)\n  B(adx, 19)\n  B(smap, 20)\n  B(avx512ifma, 21)\n  B(pcommit, 22)\n  B(clflushopt, 23)\n  B(clwb, 24)\n  B(avx512pf, 26)\n  B(avx512er, 27)\n  B(avx512cd, 28)\n  B(sha, 29)\n  B(avx512bw, 30)\n  B(avx512vl, 31)\n#undef B\n#define C(name, bit) X(name, f7c, bit)\n  C(prefetchwt1, 0)\n  C(avx512vbmi, 1)\n#undef C\n\n#undef X\n\n#endif /* ZSTD_COMMON_CPU_H */\n"
  },
  {
    "path": "lib/common/debug.c",
    "content": "/* ******************************************************************\n * debug\n * Part of FSE library\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * You can contact the author at :\n * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n****************************************************************** */\n\n\n/*\n * This module only hosts one global variable\n * which can be used to dynamically influence the verbosity of traces,\n * such as DEBUGLOG and RAWLOG\n */\n\n#include \"debug.h\"\n\n#if !defined(ZSTD_LINUX_KERNEL) || (DEBUGLEVEL>=2)\n/* We only use this when DEBUGLEVEL>=2, but we get -Werror=pedantic errors if a\n * translation unit is empty. So remove this from Linux kernel builds, but\n * otherwise just leave it in.\n */\nint g_debuglevel = DEBUGLEVEL;\n#endif\n"
  },
  {
    "path": "lib/common/debug.h",
    "content": "/* ******************************************************************\n * debug\n * Part of FSE library\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * You can contact the author at :\n * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n****************************************************************** */\n\n\n/*\n * The purpose of this header is to enable debug functions.\n * They regroup assert(), DEBUGLOG() and RAWLOG() for run-time,\n * and DEBUG_STATIC_ASSERT() for compile-time.\n *\n * By default, DEBUGLEVEL==0, which means run-time debug is disabled.\n *\n * Level 1 enables assert() only.\n * Starting level 2, traces can be generated and pushed to stderr.\n * The higher the level, the more verbose the traces.\n *\n * It's possible to dynamically adjust level using variable g_debug_level,\n * which is only declared if DEBUGLEVEL>=2,\n * and is a global variable, not multi-thread protected (use with care)\n */\n\n#ifndef DEBUG_H_12987983217\n#define DEBUG_H_12987983217\n\n\n/* static assert is triggered at compile time, leaving no runtime artefact.\n * static assert only works with compile-time constants.\n * Also, this variant can only be used inside a function. */\n#define DEBUG_STATIC_ASSERT(c) (void)sizeof(char[(c) ? 1 : -1])\n\n\n/* DEBUGLEVEL is expected to be defined externally,\n * typically through compiler command line.\n * Value must be a number. */\n#ifndef DEBUGLEVEL\n#  define DEBUGLEVEL 0\n#endif\n\n\n/* recommended values for DEBUGLEVEL :\n * 0 : release mode, no debug, all run-time checks disabled\n * 1 : enables assert() only, no display\n * 2 : reserved, for currently active debug path\n * 3 : events once per object lifetime (CCtx, CDict, etc.)\n * 4 : events once per frame\n * 5 : events once per block\n * 6 : events once per sequence (verbose)\n * 7+: events at every position (*very* verbose)\n *\n * It's generally inconvenient to output traces > 5.\n * In which case, it's possible to selectively trigger high verbosity levels\n * by modifying g_debug_level.\n */\n\n#if (DEBUGLEVEL>=1)\n#  define ZSTD_DEPS_NEED_ASSERT\n#  include \"zstd_deps.h\"\n#else\n#  ifndef assert   /* assert may be already defined, due to prior #include  */\n#    define assert(condition) ((void)0)   /* disable assert (default) */\n#  endif\n#endif\n\n#if (DEBUGLEVEL>=2)\n#  define ZSTD_DEPS_NEED_IO\n#  include \"zstd_deps.h\"\nextern int g_debuglevel; /* the variable is only declared,\n                            it actually lives in debug.c,\n                            and is shared by the whole process.\n                            It's not thread-safe.\n                            It's useful when enabling very verbose levels\n                            on selective conditions (such as position in src) */\n\n#  define RAWLOG(l, ...)                   \\\n    do {                                   \\\n        if (l<=g_debuglevel) {             \\\n            ZSTD_DEBUG_PRINT(__VA_ARGS__); \\\n        }                                  \\\n    } while (0)\n\n#define STRINGIFY(x) #x\n#define TOSTRING(x) STRINGIFY(x)\n#define LINE_AS_STRING TOSTRING(__LINE__)\n\n#  define DEBUGLOG(l, ...)                               \\\n    do {                                                 \\\n        if (l<=g_debuglevel) {                           \\\n            ZSTD_DEBUG_PRINT(__FILE__ \":\" LINE_AS_STRING \": \" __VA_ARGS__); \\\n            ZSTD_DEBUG_PRINT(\" \\n\");                     \\\n        }                                                \\\n    } while (0)\n#else\n#  define RAWLOG(l, ...)   do { } while (0)    /* disabled */\n#  define DEBUGLOG(l, ...) do { } while (0)    /* disabled */\n#endif\n\n#endif /* DEBUG_H_12987983217 */\n"
  },
  {
    "path": "lib/common/entropy_common.c",
    "content": "/* ******************************************************************\n * Common functions of New Generation Entropy library\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n *  You can contact the author at :\n *  - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy\n *  - Public forum : https://groups.google.com/forum/#!forum/lz4c\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n****************************************************************** */\n\n/* *************************************\n*  Dependencies\n***************************************/\n#include \"mem.h\"\n#include \"error_private.h\"       /* ERR_*, ERROR */\n#define FSE_STATIC_LINKING_ONLY  /* FSE_MIN_TABLELOG */\n#include \"fse.h\"\n#include \"huf.h\"\n#include \"bits.h\"                /* ZSDT_highbit32, ZSTD_countTrailingZeros32 */\n\n\n/*===   Version   ===*/\nunsigned FSE_versionNumber(void) { return FSE_VERSION_NUMBER; }\n\n\n/*===   Error Management   ===*/\nunsigned FSE_isError(size_t code) { return ERR_isError(code); }\nconst char* FSE_getErrorName(size_t code) { return ERR_getErrorName(code); }\n\nunsigned HUF_isError(size_t code) { return ERR_isError(code); }\nconst char* HUF_getErrorName(size_t code) { return ERR_getErrorName(code); }\n\n\n/*-**************************************************************\n*  FSE NCount encoding-decoding\n****************************************************************/\nFORCE_INLINE_TEMPLATE\nsize_t FSE_readNCount_body(short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,\n                           const void* headerBuffer, size_t hbSize)\n{\n    const BYTE* const istart = (const BYTE*) headerBuffer;\n    const BYTE* const iend = istart + hbSize;\n    const BYTE* ip = istart;\n    int nbBits;\n    int remaining;\n    int threshold;\n    U32 bitStream;\n    int bitCount;\n    unsigned charnum = 0;\n    unsigned const maxSV1 = *maxSVPtr + 1;\n    int previous0 = 0;\n\n    if (hbSize < 8) {\n        /* This function only works when hbSize >= 8 */\n        char buffer[8] = {0};\n        ZSTD_memcpy(buffer, headerBuffer, hbSize);\n        {   size_t const countSize = FSE_readNCount(normalizedCounter, maxSVPtr, tableLogPtr,\n                                                    buffer, sizeof(buffer));\n            if (FSE_isError(countSize)) return countSize;\n            if (countSize > hbSize) return ERROR(corruption_detected);\n            return countSize;\n    }   }\n    assert(hbSize >= 8);\n\n    /* init */\n    ZSTD_memset(normalizedCounter, 0, (*maxSVPtr+1) * sizeof(normalizedCounter[0]));   /* all symbols not present in NCount have a frequency of 0 */\n    bitStream = MEM_readLE32(ip);\n    nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG;   /* extract tableLog */\n    if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);\n    bitStream >>= 4;\n    bitCount = 4;\n    *tableLogPtr = nbBits;\n    remaining = (1<> 1;\n            while (repeats >= 12) {\n                charnum += 3 * 12;\n                if (LIKELY(ip <= iend-7)) {\n                    ip += 3;\n                } else {\n                    bitCount -= (int)(8 * (iend - 7 - ip));\n                    bitCount &= 31;\n                    ip = iend - 4;\n                }\n                bitStream = MEM_readLE32(ip) >> bitCount;\n                repeats = ZSTD_countTrailingZeros32(~bitStream | 0x80000000) >> 1;\n            }\n            charnum += 3 * repeats;\n            bitStream >>= 2 * repeats;\n            bitCount += 2 * repeats;\n\n            /* Add the final repeat which isn't 0b11. */\n            assert((bitStream & 3) < 3);\n            charnum += bitStream & 3;\n            bitCount += 2;\n\n            /* This is an error, but break and return an error\n             * at the end, because returning out of a loop makes\n             * it harder for the compiler to optimize.\n             */\n            if (charnum >= maxSV1) break;\n\n            /* We don't need to set the normalized count to 0\n             * because we already memset the whole buffer to 0.\n             */\n\n            if (LIKELY(ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {\n                assert((bitCount >> 3) <= 3); /* For first condition to work */\n                ip += bitCount>>3;\n                bitCount &= 7;\n            } else {\n                bitCount -= (int)(8 * (iend - 4 - ip));\n                bitCount &= 31;\n                ip = iend - 4;\n            }\n            bitStream = MEM_readLE32(ip) >> bitCount;\n        }\n        {\n            int const max = (2*threshold-1) - remaining;\n            int count;\n\n            if ((bitStream & (threshold-1)) < (U32)max) {\n                count = bitStream & (threshold-1);\n                bitCount += nbBits-1;\n            } else {\n                count = bitStream & (2*threshold-1);\n                if (count >= threshold) count -= max;\n                bitCount += nbBits;\n            }\n\n            count--;   /* extra accuracy */\n            /* When it matters (small blocks), this is a\n             * predictable branch, because we don't use -1.\n             */\n            if (count >= 0) {\n                remaining -= count;\n            } else {\n                assert(count == -1);\n                remaining += count;\n            }\n            normalizedCounter[charnum++] = (short)count;\n            previous0 = !count;\n\n            assert(threshold > 1);\n            if (remaining < threshold) {\n                /* This branch can be folded into the\n                 * threshold update condition because we\n                 * know that threshold > 1.\n                 */\n                if (remaining <= 1) break;\n                nbBits = ZSTD_highbit32(remaining) + 1;\n                threshold = 1 << (nbBits - 1);\n            }\n            if (charnum >= maxSV1) break;\n\n            if (LIKELY(ip <= iend-7) || (ip + (bitCount>>3) <= iend-4)) {\n                ip += bitCount>>3;\n                bitCount &= 7;\n            } else {\n                bitCount -= (int)(8 * (iend - 4 - ip));\n                bitCount &= 31;\n                ip = iend - 4;\n            }\n            bitStream = MEM_readLE32(ip) >> bitCount;\n    }   }\n    if (remaining != 1) return ERROR(corruption_detected);\n    /* Only possible when there are too many zeros. */\n    if (charnum > maxSV1) return ERROR(maxSymbolValue_tooSmall);\n    if (bitCount > 32) return ERROR(corruption_detected);\n    *maxSVPtr = charnum-1;\n\n    ip += (bitCount+7)>>3;\n    return ip-istart;\n}\n\n/* Avoids the FORCE_INLINE of the _body() function. */\nstatic size_t FSE_readNCount_body_default(\n        short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,\n        const void* headerBuffer, size_t hbSize)\n{\n    return FSE_readNCount_body(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize);\n}\n\n#if DYNAMIC_BMI2\nBMI2_TARGET_ATTRIBUTE static size_t FSE_readNCount_body_bmi2(\n        short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,\n        const void* headerBuffer, size_t hbSize)\n{\n    return FSE_readNCount_body(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize);\n}\n#endif\n\nsize_t FSE_readNCount_bmi2(\n        short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,\n        const void* headerBuffer, size_t hbSize, int bmi2)\n{\n#if DYNAMIC_BMI2\n    if (bmi2) {\n        return FSE_readNCount_body_bmi2(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize);\n    }\n#endif\n    (void)bmi2;\n    return FSE_readNCount_body_default(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize);\n}\n\nsize_t FSE_readNCount(\n        short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,\n        const void* headerBuffer, size_t hbSize)\n{\n    return FSE_readNCount_bmi2(normalizedCounter, maxSVPtr, tableLogPtr, headerBuffer, hbSize, /* bmi2 */ 0);\n}\n\n\n/*! HUF_readStats() :\n    Read compact Huffman tree, saved by HUF_writeCTable().\n    `huffWeight` is destination buffer.\n    `rankStats` is assumed to be a table of at least HUF_TABLELOG_MAX U32.\n    @return : size read from `src` , or an error Code .\n    Note : Needed by HUF_readCTable() and HUF_readDTableX?() .\n*/\nsize_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,\n                     U32* nbSymbolsPtr, U32* tableLogPtr,\n                     const void* src, size_t srcSize)\n{\n    U32 wksp[HUF_READ_STATS_WORKSPACE_SIZE_U32];\n    return HUF_readStats_wksp(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, wksp, sizeof(wksp), /* flags */ 0);\n}\n\nFORCE_INLINE_TEMPLATE size_t\nHUF_readStats_body(BYTE* huffWeight, size_t hwSize, U32* rankStats,\n                   U32* nbSymbolsPtr, U32* tableLogPtr,\n                   const void* src, size_t srcSize,\n                   void* workSpace, size_t wkspSize,\n                   int bmi2)\n{\n    U32 weightTotal;\n    const BYTE* ip = (const BYTE*) src;\n    size_t iSize;\n    size_t oSize;\n\n    if (!srcSize) return ERROR(srcSize_wrong);\n    iSize = ip[0];\n    /* ZSTD_memset(huffWeight, 0, hwSize);   *//* is not necessary, even though some analyzer complain ... */\n\n    if (iSize >= 128) {  /* special header */\n        oSize = iSize - 127;\n        iSize = ((oSize+1)/2);\n        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);\n        if (oSize >= hwSize) return ERROR(corruption_detected);\n        ip += 1;\n        {   U32 n;\n            for (n=0; n> 4;\n                huffWeight[n+1] = ip[n/2] & 15;\n    }   }   }\n    else  {   /* header compressed with FSE (normal case) */\n        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);\n        /* max (hwSize-1) values decoded, as last one is implied */\n        oSize = FSE_decompress_wksp_bmi2(huffWeight, hwSize-1, ip+1, iSize, 6, workSpace, wkspSize, bmi2);\n        if (FSE_isError(oSize)) return oSize;\n    }\n\n    /* collect weight stats */\n    ZSTD_memset(rankStats, 0, (HUF_TABLELOG_MAX + 1) * sizeof(U32));\n    weightTotal = 0;\n    {   U32 n; for (n=0; n HUF_TABLELOG_MAX) return ERROR(corruption_detected);\n            rankStats[huffWeight[n]]++;\n            weightTotal += (1 << huffWeight[n]) >> 1;\n    }   }\n    if (weightTotal == 0) return ERROR(corruption_detected);\n\n    /* get last non-null symbol weight (implied, total must be 2^n) */\n    {   U32 const tableLog = ZSTD_highbit32(weightTotal) + 1;\n        if (tableLog > HUF_TABLELOG_MAX) return ERROR(corruption_detected);\n        *tableLogPtr = tableLog;\n        /* determine last weight */\n        {   U32 const total = 1 << tableLog;\n            U32 const rest = total - weightTotal;\n            U32 const verif = 1 << ZSTD_highbit32(rest);\n            U32 const lastWeight = ZSTD_highbit32(rest) + 1;\n            if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */\n            huffWeight[oSize] = (BYTE)lastWeight;\n            rankStats[lastWeight]++;\n    }   }\n\n    /* check tree construction validity */\n    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */\n\n    /* results */\n    *nbSymbolsPtr = (U32)(oSize+1);\n    return iSize+1;\n}\n\n/* Avoids the FORCE_INLINE of the _body() function. */\nstatic size_t HUF_readStats_body_default(BYTE* huffWeight, size_t hwSize, U32* rankStats,\n                     U32* nbSymbolsPtr, U32* tableLogPtr,\n                     const void* src, size_t srcSize,\n                     void* workSpace, size_t wkspSize)\n{\n    return HUF_readStats_body(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, workSpace, wkspSize, 0);\n}\n\n#if DYNAMIC_BMI2\nstatic BMI2_TARGET_ATTRIBUTE size_t HUF_readStats_body_bmi2(BYTE* huffWeight, size_t hwSize, U32* rankStats,\n                     U32* nbSymbolsPtr, U32* tableLogPtr,\n                     const void* src, size_t srcSize,\n                     void* workSpace, size_t wkspSize)\n{\n    return HUF_readStats_body(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, workSpace, wkspSize, 1);\n}\n#endif\n\nsize_t HUF_readStats_wksp(BYTE* huffWeight, size_t hwSize, U32* rankStats,\n                     U32* nbSymbolsPtr, U32* tableLogPtr,\n                     const void* src, size_t srcSize,\n                     void* workSpace, size_t wkspSize,\n                     int flags)\n{\n#if DYNAMIC_BMI2\n    if (flags & HUF_flags_bmi2) {\n        return HUF_readStats_body_bmi2(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, workSpace, wkspSize);\n    }\n#endif\n    (void)flags;\n    return HUF_readStats_body_default(huffWeight, hwSize, rankStats, nbSymbolsPtr, tableLogPtr, src, srcSize, workSpace, wkspSize);\n}\n"
  },
  {
    "path": "lib/common/error_private.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/* The purpose of this file is to have a single list of error strings embedded in binary */\n\n#include \"error_private.h\"\n\nconst char* ERR_getErrorString(ERR_enum code)\n{\n#ifdef ZSTD_STRIP_ERROR_STRINGS\n    (void)code;\n    return \"Error strings stripped\";\n#else\n    static const char* const notErrorCode = \"Unspecified error code\";\n    switch( code )\n    {\n    case PREFIX(no_error): return \"No error detected\";\n    case PREFIX(GENERIC):  return \"Error (generic)\";\n    case PREFIX(prefix_unknown): return \"Unknown frame descriptor\";\n    case PREFIX(version_unsupported): return \"Version not supported\";\n    case PREFIX(frameParameter_unsupported): return \"Unsupported frame parameter\";\n    case PREFIX(frameParameter_windowTooLarge): return \"Frame requires too much memory for decoding\";\n    case PREFIX(corruption_detected): return \"Data corruption detected\";\n    case PREFIX(checksum_wrong): return \"Restored data doesn't match checksum\";\n    case PREFIX(literals_headerWrong): return \"Header of Literals' block doesn't respect format specification\";\n    case PREFIX(parameter_unsupported): return \"Unsupported parameter\";\n    case PREFIX(parameter_combination_unsupported): return \"Unsupported combination of parameters\";\n    case PREFIX(parameter_outOfBound): return \"Parameter is out of bound\";\n    case PREFIX(init_missing): return \"Context should be init first\";\n    case PREFIX(memory_allocation): return \"Allocation error : not enough memory\";\n    case PREFIX(workSpace_tooSmall): return \"workSpace buffer is not large enough\";\n    case PREFIX(stage_wrong): return \"Operation not authorized at current processing stage\";\n    case PREFIX(tableLog_tooLarge): return \"tableLog requires too much memory : unsupported\";\n    case PREFIX(maxSymbolValue_tooLarge): return \"Unsupported max Symbol Value : too large\";\n    case PREFIX(maxSymbolValue_tooSmall): return \"Specified maxSymbolValue is too small\";\n    case PREFIX(cannotProduce_uncompressedBlock): return \"This mode cannot generate an uncompressed block\";\n    case PREFIX(stabilityCondition_notRespected): return \"pledged buffer stability condition is not respected\";\n    case PREFIX(dictionary_corrupted): return \"Dictionary is corrupted\";\n    case PREFIX(dictionary_wrong): return \"Dictionary mismatch\";\n    case PREFIX(dictionaryCreation_failed): return \"Cannot create Dictionary from provided samples\";\n    case PREFIX(dstSize_tooSmall): return \"Destination buffer is too small\";\n    case PREFIX(srcSize_wrong): return \"Src size is incorrect\";\n    case PREFIX(dstBuffer_null): return \"Operation on NULL destination buffer\";\n    case PREFIX(noForwardProgress_destFull): return \"Operation made no progress over multiple calls, due to output buffer being full\";\n    case PREFIX(noForwardProgress_inputEmpty): return \"Operation made no progress over multiple calls, due to input being empty\";\n        /* following error codes are not stable and may be removed or changed in a future version */\n    case PREFIX(frameIndex_tooLarge): return \"Frame index is too large\";\n    case PREFIX(seekableIO): return \"An I/O error occurred when reading/seeking\";\n    case PREFIX(dstBuffer_wrong): return \"Destination buffer is wrong\";\n    case PREFIX(srcBuffer_wrong): return \"Source buffer is wrong\";\n    case PREFIX(sequenceProducer_failed): return \"Block-level external sequence producer returned an error code\";\n    case PREFIX(externalSequences_invalid): return \"External sequences are not valid\";\n    case PREFIX(maxCode):\n    default: return notErrorCode;\n    }\n#endif\n}\n"
  },
  {
    "path": "lib/common/error_private.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/* Note : this module is expected to remain private, do not expose it */\n\n#ifndef ERROR_H_MODULE\n#define ERROR_H_MODULE\n\n/* ****************************************\n*  Dependencies\n******************************************/\n#include \"../zstd_errors.h\"  /* enum list */\n#include \"compiler.h\"\n#include \"debug.h\"\n#include \"zstd_deps.h\"       /* size_t */\n\n/* ****************************************\n*  Compiler-specific\n******************************************/\n#if defined(__GNUC__)\n#  define ERR_STATIC static __attribute__((unused))\n#elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)\n#  define ERR_STATIC static inline\n#elif defined(_MSC_VER)\n#  define ERR_STATIC static __inline\n#else\n#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */\n#endif\n\n\n/*-****************************************\n*  Customization (error_public.h)\n******************************************/\ntypedef ZSTD_ErrorCode ERR_enum;\n#define PREFIX(name) ZSTD_error_##name\n\n\n/*-****************************************\n*  Error codes handling\n******************************************/\n#undef ERROR   /* already defined on Visual Studio */\n#define ERROR(name) ZSTD_ERROR(name)\n#define ZSTD_ERROR(name) ((size_t)-PREFIX(name))\n\nERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }\n\nERR_STATIC ERR_enum ERR_getErrorCode(size_t code) { if (!ERR_isError(code)) return (ERR_enum)0; return (ERR_enum) (0-code); }\n\n/* check and forward error code */\n#define CHECK_V_F(e, f)     \\\n    size_t const e = f;     \\\n    do {                    \\\n        if (ERR_isError(e)) \\\n            return e;       \\\n    } while (0)\n#define CHECK_F(f)   do { CHECK_V_F(_var_err__, f); } while (0)\n\n\n/*-****************************************\n*  Error Strings\n******************************************/\n\nconst char* ERR_getErrorString(ERR_enum code);   /* error_private.c */\n\nERR_STATIC const char* ERR_getErrorName(size_t code)\n{\n    return ERR_getErrorString(ERR_getErrorCode(code));\n}\n\n/**\n * Ignore: this is an internal helper.\n *\n * This is a helper function to help force C99-correctness during compilation.\n * Under strict compilation modes, variadic macro arguments can't be empty.\n * However, variadic function arguments can be. Using a function therefore lets\n * us statically check that at least one (string) argument was passed,\n * independent of the compilation flags.\n */\nstatic INLINE_KEYWORD UNUSED_ATTR\nvoid _force_has_format_string(const char *format, ...) {\n  (void)format;\n}\n\n/**\n * Ignore: this is an internal helper.\n *\n * We want to force this function invocation to be syntactically correct, but\n * we don't want to force runtime evaluation of its arguments.\n */\n#define _FORCE_HAS_FORMAT_STRING(...)              \\\n    do {                                           \\\n        if (0) {                                   \\\n            _force_has_format_string(__VA_ARGS__); \\\n        }                                          \\\n    } while (0)\n\n#define ERR_QUOTE(str) #str\n\n/**\n * Return the specified error if the condition evaluates to true.\n *\n * In debug modes, prints additional information.\n * In order to do that (particularly, printing the conditional that failed),\n * this can't just wrap RETURN_ERROR().\n */\n#define RETURN_ERROR_IF(cond, err, ...)                                        \\\n    do {                                                                       \\\n        if (cond) {                                                            \\\n            RAWLOG(3, \"%s:%d: ERROR!: check %s failed, returning %s\",          \\\n                  __FILE__, __LINE__, ERR_QUOTE(cond), ERR_QUOTE(ERROR(err))); \\\n            _FORCE_HAS_FORMAT_STRING(__VA_ARGS__);                             \\\n            RAWLOG(3, \": \" __VA_ARGS__);                                       \\\n            RAWLOG(3, \"\\n\");                                                   \\\n            return ERROR(err);                                                 \\\n        }                                                                      \\\n    } while (0)\n\n/**\n * Unconditionally return the specified error.\n *\n * In debug modes, prints additional information.\n */\n#define RETURN_ERROR(err, ...)                                               \\\n    do {                                                                     \\\n        RAWLOG(3, \"%s:%d: ERROR!: unconditional check failed, returning %s\", \\\n              __FILE__, __LINE__, ERR_QUOTE(ERROR(err)));                    \\\n        _FORCE_HAS_FORMAT_STRING(__VA_ARGS__);                               \\\n        RAWLOG(3, \": \" __VA_ARGS__);                                         \\\n        RAWLOG(3, \"\\n\");                                                     \\\n        return ERROR(err);                                                   \\\n    } while(0)\n\n/**\n * If the provided expression evaluates to an error code, returns that error code.\n *\n * In debug modes, prints additional information.\n */\n#define FORWARD_IF_ERROR(err, ...)                                                 \\\n    do {                                                                           \\\n        size_t const err_code = (err);                                             \\\n        if (ERR_isError(err_code)) {                                               \\\n            RAWLOG(3, \"%s:%d: ERROR!: forwarding error in %s: %s\",                 \\\n                  __FILE__, __LINE__, ERR_QUOTE(err), ERR_getErrorName(err_code)); \\\n            _FORCE_HAS_FORMAT_STRING(__VA_ARGS__);                                 \\\n            RAWLOG(3, \": \" __VA_ARGS__);                                           \\\n            RAWLOG(3, \"\\n\");                                                       \\\n            return err_code;                                                       \\\n        }                                                                          \\\n    } while(0)\n\n#endif /* ERROR_H_MODULE */\n"
  },
  {
    "path": "lib/common/fse.h",
    "content": "/* ******************************************************************\n * FSE : Finite State Entropy codec\n * Public Prototypes declaration\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * You can contact the author at :\n * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n****************************************************************** */\n#ifndef FSE_H\n#define FSE_H\n\n\n/*-*****************************************\n*  Dependencies\n******************************************/\n#include \"zstd_deps.h\"    /* size_t, ptrdiff_t */\n\n/*-*****************************************\n*  FSE_PUBLIC_API : control library symbols visibility\n******************************************/\n#if defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1) && defined(__GNUC__) && (__GNUC__ >= 4)\n#  define FSE_PUBLIC_API __attribute__ ((visibility (\"default\")))\n#elif defined(FSE_DLL_EXPORT) && (FSE_DLL_EXPORT==1)   /* Visual expected */\n#  define FSE_PUBLIC_API __declspec(dllexport)\n#elif defined(FSE_DLL_IMPORT) && (FSE_DLL_IMPORT==1)\n#  define FSE_PUBLIC_API __declspec(dllimport) /* It isn't required but allows to generate better code, saving a function pointer load from the IAT and an indirect jump.*/\n#else\n#  define FSE_PUBLIC_API\n#endif\n\n/*------   Version   ------*/\n#define FSE_VERSION_MAJOR    0\n#define FSE_VERSION_MINOR    9\n#define FSE_VERSION_RELEASE  0\n\n#define FSE_LIB_VERSION FSE_VERSION_MAJOR.FSE_VERSION_MINOR.FSE_VERSION_RELEASE\n#define FSE_QUOTE(str) #str\n#define FSE_EXPAND_AND_QUOTE(str) FSE_QUOTE(str)\n#define FSE_VERSION_STRING FSE_EXPAND_AND_QUOTE(FSE_LIB_VERSION)\n\n#define FSE_VERSION_NUMBER  (FSE_VERSION_MAJOR *100*100 + FSE_VERSION_MINOR *100 + FSE_VERSION_RELEASE)\nFSE_PUBLIC_API unsigned FSE_versionNumber(void);   /**< library version number; to be used when checking dll version */\n\n\n/*-*****************************************\n*  Tool functions\n******************************************/\nFSE_PUBLIC_API size_t FSE_compressBound(size_t size);       /* maximum compressed size */\n\n/* Error Management */\nFSE_PUBLIC_API unsigned    FSE_isError(size_t code);        /* tells if a return value is an error code */\nFSE_PUBLIC_API const char* FSE_getErrorName(size_t code);   /* provides error code string (useful for debugging) */\n\n\n/*-*****************************************\n*  FSE detailed API\n******************************************/\n/*!\nFSE_compress() does the following:\n1. count symbol occurrence from source[] into table count[] (see hist.h)\n2. normalize counters so that sum(count[]) == Power_of_2 (2^tableLog)\n3. save normalized counters to memory buffer using writeNCount()\n4. build encoding table 'CTable' from normalized counters\n5. encode the data stream using encoding table 'CTable'\n\nFSE_decompress() does the following:\n1. read normalized counters with readNCount()\n2. build decoding table 'DTable' from normalized counters\n3. decode the data stream using decoding table 'DTable'\n\nThe following API allows targeting specific sub-functions for advanced tasks.\nFor example, it's possible to compress several blocks using the same 'CTable',\nor to save and provide normalized distribution using external method.\n*/\n\n/* *** COMPRESSION *** */\n\n/*! FSE_optimalTableLog():\n    dynamically downsize 'tableLog' when conditions are met.\n    It saves CPU time, by using smaller tables, while preserving or even improving compression ratio.\n    @return : recommended tableLog (necessarily <= 'maxTableLog') */\nFSE_PUBLIC_API unsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue);\n\n/*! FSE_normalizeCount():\n    normalize counts so that sum(count[]) == Power_of_2 (2^tableLog)\n    'normalizedCounter' is a table of short, of minimum size (maxSymbolValue+1).\n    useLowProbCount is a boolean parameter which trades off compressed size for\n    faster header decoding. When it is set to 1, the compressed data will be slightly\n    smaller. And when it is set to 0, FSE_readNCount() and FSE_buildDTable() will be\n    faster. If you are compressing a small amount of data (< 2 KB) then useLowProbCount=0\n    is a good default, since header deserialization makes a big speed difference.\n    Otherwise, useLowProbCount=1 is a good default, since the speed difference is small.\n    @return : tableLog,\n              or an errorCode, which can be tested using FSE_isError() */\nFSE_PUBLIC_API size_t FSE_normalizeCount(short* normalizedCounter, unsigned tableLog,\n                    const unsigned* count, size_t srcSize, unsigned maxSymbolValue, unsigned useLowProbCount);\n\n/*! FSE_NCountWriteBound():\n    Provides the maximum possible size of an FSE normalized table, given 'maxSymbolValue' and 'tableLog'.\n    Typically useful for allocation purpose. */\nFSE_PUBLIC_API size_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog);\n\n/*! FSE_writeNCount():\n    Compactly save 'normalizedCounter' into 'buffer'.\n    @return : size of the compressed table,\n              or an errorCode, which can be tested using FSE_isError(). */\nFSE_PUBLIC_API size_t FSE_writeNCount (void* buffer, size_t bufferSize,\n                                 const short* normalizedCounter,\n                                 unsigned maxSymbolValue, unsigned tableLog);\n\n/*! Constructor and Destructor of FSE_CTable.\n    Note that FSE_CTable size depends on 'tableLog' and 'maxSymbolValue' */\ntypedef unsigned FSE_CTable;   /* don't allocate that. It's only meant to be more restrictive than void* */\n\n/*! FSE_buildCTable():\n    Builds `ct`, which must be already allocated, using FSE_createCTable().\n    @return : 0, or an errorCode, which can be tested using FSE_isError() */\nFSE_PUBLIC_API size_t FSE_buildCTable(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog);\n\n/*! FSE_compress_usingCTable():\n    Compress `src` using `ct` into `dst` which must be already allocated.\n    @return : size of compressed data (<= `dstCapacity`),\n              or 0 if compressed data could not fit into `dst`,\n              or an errorCode, which can be tested using FSE_isError() */\nFSE_PUBLIC_API size_t FSE_compress_usingCTable (void* dst, size_t dstCapacity, const void* src, size_t srcSize, const FSE_CTable* ct);\n\n/*!\nTutorial :\n----------\nThe first step is to count all symbols. FSE_count() does this job very fast.\nResult will be saved into 'count', a table of unsigned int, which must be already allocated, and have 'maxSymbolValuePtr[0]+1' cells.\n'src' is a table of bytes of size 'srcSize'. All values within 'src' MUST be <= maxSymbolValuePtr[0]\nmaxSymbolValuePtr[0] will be updated, with its real value (necessarily <= original value)\nFSE_count() will return the number of occurrence of the most frequent symbol.\nThis can be used to know if there is a single symbol within 'src', and to quickly evaluate its compressibility.\nIf there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()).\n\nThe next step is to normalize the frequencies.\nFSE_normalizeCount() will ensure that sum of frequencies is == 2 ^'tableLog'.\nIt also guarantees a minimum of 1 to any Symbol with frequency >= 1.\nYou can use 'tableLog'==0 to mean \"use default tableLog value\".\nIf you are unsure of which tableLog value to use, you can ask FSE_optimalTableLog(),\nwhich will provide the optimal valid tableLog given sourceSize, maxSymbolValue, and a user-defined maximum (0 means \"default\").\n\nThe result of FSE_normalizeCount() will be saved into a table,\ncalled 'normalizedCounter', which is a table of signed short.\n'normalizedCounter' must be already allocated, and have at least 'maxSymbolValue+1' cells.\nThe return value is tableLog if everything proceeded as expected.\nIt is 0 if there is a single symbol within distribution.\nIf there is an error (ex: invalid tableLog value), the function will return an ErrorCode (which can be tested using FSE_isError()).\n\n'normalizedCounter' can be saved in a compact manner to a memory area using FSE_writeNCount().\n'buffer' must be already allocated.\nFor guaranteed success, buffer size must be at least FSE_headerBound().\nThe result of the function is the number of bytes written into 'buffer'.\nIf there is an error, the function will return an ErrorCode (which can be tested using FSE_isError(); ex : buffer size too small).\n\n'normalizedCounter' can then be used to create the compression table 'CTable'.\nThe space required by 'CTable' must be already allocated, using FSE_createCTable().\nYou can then use FSE_buildCTable() to fill 'CTable'.\nIf there is an error, both functions will return an ErrorCode (which can be tested using FSE_isError()).\n\n'CTable' can then be used to compress 'src', with FSE_compress_usingCTable().\nSimilar to FSE_count(), the convention is that 'src' is assumed to be a table of char of size 'srcSize'\nThe function returns the size of compressed data (without header), necessarily <= `dstCapacity`.\nIf it returns '0', compressed data could not fit into 'dst'.\nIf there is an error, the function will return an ErrorCode (which can be tested using FSE_isError()).\n*/\n\n\n/* *** DECOMPRESSION *** */\n\n/*! FSE_readNCount():\n    Read compactly saved 'normalizedCounter' from 'rBuffer'.\n    @return : size read from 'rBuffer',\n              or an errorCode, which can be tested using FSE_isError().\n              maxSymbolValuePtr[0] and tableLogPtr[0] will also be updated with their respective values */\nFSE_PUBLIC_API size_t FSE_readNCount (short* normalizedCounter,\n                           unsigned* maxSymbolValuePtr, unsigned* tableLogPtr,\n                           const void* rBuffer, size_t rBuffSize);\n\n/*! FSE_readNCount_bmi2():\n * Same as FSE_readNCount() but pass bmi2=1 when your CPU supports BMI2 and 0 otherwise.\n */\nFSE_PUBLIC_API size_t FSE_readNCount_bmi2(short* normalizedCounter,\n                           unsigned* maxSymbolValuePtr, unsigned* tableLogPtr,\n                           const void* rBuffer, size_t rBuffSize, int bmi2);\n\ntypedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */\n\n/*!\nTutorial :\n----------\n(Note : these functions only decompress FSE-compressed blocks.\n If block is uncompressed, use memcpy() instead\n If block is a single repeated byte, use memset() instead )\n\nThe first step is to obtain the normalized frequencies of symbols.\nThis can be performed by FSE_readNCount() if it was saved using FSE_writeNCount().\n'normalizedCounter' must be already allocated, and have at least 'maxSymbolValuePtr[0]+1' cells of signed short.\nIn practice, that means it's necessary to know 'maxSymbolValue' beforehand,\nor size the table to handle worst case situations (typically 256).\nFSE_readNCount() will provide 'tableLog' and 'maxSymbolValue'.\nThe result of FSE_readNCount() is the number of bytes read from 'rBuffer'.\nNote that 'rBufferSize' must be at least 4 bytes, even if useful information is less than that.\nIf there is an error, the function will return an error code, which can be tested using FSE_isError().\n\nThe next step is to build the decompression tables 'FSE_DTable' from 'normalizedCounter'.\nThis is performed by the function FSE_buildDTable().\nThe space required by 'FSE_DTable' must be already allocated using FSE_createDTable().\nIf there is an error, the function will return an error code, which can be tested using FSE_isError().\n\n`FSE_DTable` can then be used to decompress `cSrc`, with FSE_decompress_usingDTable().\n`cSrcSize` must be strictly correct, otherwise decompression will fail.\nFSE_decompress_usingDTable() result will tell how many bytes were regenerated (<=`dstCapacity`).\nIf there is an error, the function will return an error code, which can be tested using FSE_isError(). (ex: dst buffer too small)\n*/\n\n#endif  /* FSE_H */\n\n\n#if defined(FSE_STATIC_LINKING_ONLY) && !defined(FSE_H_FSE_STATIC_LINKING_ONLY)\n#define FSE_H_FSE_STATIC_LINKING_ONLY\n#include \"bitstream.h\"\n\n/* *****************************************\n*  Static allocation\n*******************************************/\n/* FSE buffer bounds */\n#define FSE_NCOUNTBOUND 512\n#define FSE_BLOCKBOUND(size) ((size) + ((size)>>7) + 4 /* fse states */ + sizeof(size_t) /* bitContainer */)\n#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size))   /* Macro version, useful for static allocation */\n\n/* It is possible to statically allocate FSE CTable/DTable as a table of FSE_CTable/FSE_DTable using below macros */\n#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue)   (1 + (1<<((maxTableLog)-1)) + (((maxSymbolValue)+1)*2))\n#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<<(maxTableLog)))\n\n/* or use the size to malloc() space directly. Pay attention to alignment restrictions though */\n#define FSE_CTABLE_SIZE(maxTableLog, maxSymbolValue)   (FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue) * sizeof(FSE_CTable))\n#define FSE_DTABLE_SIZE(maxTableLog)                   (FSE_DTABLE_SIZE_U32(maxTableLog) * sizeof(FSE_DTable))\n\n\n/* *****************************************\n *  FSE advanced API\n ***************************************** */\n\nunsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus);\n/**< same as FSE_optimalTableLog(), which used `minus==2` */\n\nsize_t FSE_buildCTable_rle (FSE_CTable* ct, unsigned char symbolValue);\n/**< build a fake FSE_CTable, designed to compress always the same symbolValue */\n\n/* FSE_buildCTable_wksp() :\n * Same as FSE_buildCTable(), but using an externally allocated scratch buffer (`workSpace`).\n * `wkspSize` must be >= `FSE_BUILD_CTABLE_WORKSPACE_SIZE_U32(maxSymbolValue, tableLog)` of `unsigned`.\n * See FSE_buildCTable_wksp() for breakdown of workspace usage.\n */\n#define FSE_BUILD_CTABLE_WORKSPACE_SIZE_U32(maxSymbolValue, tableLog) (((maxSymbolValue + 2) + (1ull << (tableLog)))/2 + sizeof(U64)/sizeof(U32) /* additional 8 bytes for potential table overwrite */)\n#define FSE_BUILD_CTABLE_WORKSPACE_SIZE(maxSymbolValue, tableLog) (sizeof(unsigned) * FSE_BUILD_CTABLE_WORKSPACE_SIZE_U32(maxSymbolValue, tableLog))\nsize_t FSE_buildCTable_wksp(FSE_CTable* ct, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);\n\n#define FSE_BUILD_DTABLE_WKSP_SIZE(maxTableLog, maxSymbolValue) (sizeof(short) * (maxSymbolValue + 1) + (1ULL << maxTableLog) + 8)\n#define FSE_BUILD_DTABLE_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) ((FSE_BUILD_DTABLE_WKSP_SIZE(maxTableLog, maxSymbolValue) + sizeof(unsigned) - 1) / sizeof(unsigned))\nFSE_PUBLIC_API size_t FSE_buildDTable_wksp(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize);\n/**< Same as FSE_buildDTable(), using an externally allocated `workspace` produced with `FSE_BUILD_DTABLE_WKSP_SIZE_U32(maxSymbolValue)` */\n\n#define FSE_DECOMPRESS_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) (FSE_DTABLE_SIZE_U32(maxTableLog) + 1 + FSE_BUILD_DTABLE_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) + (FSE_MAX_SYMBOL_VALUE + 1) / 2 + 1)\n#define FSE_DECOMPRESS_WKSP_SIZE(maxTableLog, maxSymbolValue) (FSE_DECOMPRESS_WKSP_SIZE_U32(maxTableLog, maxSymbolValue) * sizeof(unsigned))\nsize_t FSE_decompress_wksp_bmi2(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize, int bmi2);\n/**< same as FSE_decompress(), using an externally allocated `workSpace` produced with `FSE_DECOMPRESS_WKSP_SIZE_U32(maxLog, maxSymbolValue)`.\n * Set bmi2 to 1 if your CPU supports BMI2 or 0 if it doesn't */\n\ntypedef enum {\n   FSE_repeat_none,  /**< Cannot use the previous table */\n   FSE_repeat_check, /**< Can use the previous table but it must be checked */\n   FSE_repeat_valid  /**< Can use the previous table and it is assumed to be valid */\n } FSE_repeat;\n\n/* *****************************************\n*  FSE symbol compression API\n*******************************************/\n/*!\n   This API consists of small unitary functions, which highly benefit from being inlined.\n   Hence their body are included in next section.\n*/\ntypedef struct {\n    ptrdiff_t   value;\n    const void* stateTable;\n    const void* symbolTT;\n    unsigned    stateLog;\n} FSE_CState_t;\n\nstatic void FSE_initCState(FSE_CState_t* CStatePtr, const FSE_CTable* ct);\n\nstatic void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* CStatePtr, unsigned symbol);\n\nstatic void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* CStatePtr);\n\n/**<\nThese functions are inner components of FSE_compress_usingCTable().\nThey allow the creation of custom streams, mixing multiple tables and bit sources.\n\nA key property to keep in mind is that encoding and decoding are done **in reverse direction**.\nSo the first symbol you will encode is the last you will decode, like a LIFO stack.\n\nYou will need a few variables to track your CStream. They are :\n\nFSE_CTable    ct;         // Provided by FSE_buildCTable()\nBIT_CStream_t bitStream;  // bitStream tracking structure\nFSE_CState_t  state;      // State tracking structure (can have several)\n\n\nThe first thing to do is to init bitStream and state.\n    size_t errorCode = BIT_initCStream(&bitStream, dstBuffer, maxDstSize);\n    FSE_initCState(&state, ct);\n\nNote that BIT_initCStream() can produce an error code, so its result should be tested, using FSE_isError();\nYou can then encode your input data, byte after byte.\nFSE_encodeSymbol() outputs a maximum of 'tableLog' bits at a time.\nRemember decoding will be done in reverse direction.\n    FSE_encodeByte(&bitStream, &state, symbol);\n\nAt any time, you can also add any bit sequence.\nNote : maximum allowed nbBits is 25, for compatibility with 32-bits decoders\n    BIT_addBits(&bitStream, bitField, nbBits);\n\nThe above methods don't commit data to memory, they just store it into local register, for speed.\nLocal register size is 64-bits on 64-bits systems, 32-bits on 32-bits systems (size_t).\nWriting data to memory is a manual operation, performed by the flushBits function.\n    BIT_flushBits(&bitStream);\n\nYour last FSE encoding operation shall be to flush your last state value(s).\n    FSE_flushState(&bitStream, &state);\n\nFinally, you must close the bitStream.\nThe function returns the size of CStream in bytes.\nIf data couldn't fit into dstBuffer, it will return a 0 ( == not compressible)\nIf there is an error, it returns an errorCode (which can be tested using FSE_isError()).\n    size_t size = BIT_closeCStream(&bitStream);\n*/\n\n\n/* *****************************************\n*  FSE symbol decompression API\n*******************************************/\ntypedef struct {\n    size_t      state;\n    const void* table;   /* precise table may vary, depending on U16 */\n} FSE_DState_t;\n\n\nstatic void     FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt);\n\nstatic unsigned char FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);\n\nstatic unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr);\n\n/**<\nLet's now decompose FSE_decompress_usingDTable() into its unitary components.\nYou will decode FSE-encoded symbols from the bitStream,\nand also any other bitFields you put in, **in reverse order**.\n\nYou will need a few variables to track your bitStream. They are :\n\nBIT_DStream_t DStream;    // Stream context\nFSE_DState_t  DState;     // State context. Multiple ones are possible\nFSE_DTable*   DTablePtr;  // Decoding table, provided by FSE_buildDTable()\n\nThe first thing to do is to init the bitStream.\n    errorCode = BIT_initDStream(&DStream, srcBuffer, srcSize);\n\nYou should then retrieve your initial state(s)\n(in reverse flushing order if you have several ones) :\n    errorCode = FSE_initDState(&DState, &DStream, DTablePtr);\n\nYou can then decode your data, symbol after symbol.\nFor information the maximum number of bits read by FSE_decodeSymbol() is 'tableLog'.\nKeep in mind that symbols are decoded in reverse order, like a LIFO stack (last in, first out).\n    unsigned char symbol = FSE_decodeSymbol(&DState, &DStream);\n\nYou can retrieve any bitfield you eventually stored into the bitStream (in reverse order)\nNote : maximum allowed nbBits is 25, for 32-bits compatibility\n    size_t bitField = BIT_readBits(&DStream, nbBits);\n\nAll above operations only read from local register (which size depends on size_t).\nRefueling the register from memory is manually performed by the reload method.\n    endSignal = FSE_reloadDStream(&DStream);\n\nBIT_reloadDStream() result tells if there is still some more data to read from DStream.\nBIT_DStream_unfinished : there is still some data left into the DStream.\nBIT_DStream_endOfBuffer : Dstream reached end of buffer. Its container may no longer be completely filled.\nBIT_DStream_completed : Dstream reached its exact end, corresponding in general to decompression completed.\nBIT_DStream_tooFar : Dstream went too far. Decompression result is corrupted.\n\nWhen reaching end of buffer (BIT_DStream_endOfBuffer), progress slowly, notably if you decode multiple symbols per loop,\nto properly detect the exact end of stream.\nAfter each decoded symbol, check if DStream is fully consumed using this simple test :\n    BIT_reloadDStream(&DStream) >= BIT_DStream_completed\n\nWhen it's done, verify decompression is fully completed, by checking both DStream and the relevant states.\nChecking if DStream has reached its end is performed by :\n    BIT_endOfDStream(&DStream);\nCheck also the states. There might be some symbols left there, if some high probability ones (>50%) are possible.\n    FSE_endOfDState(&DState);\n*/\n\n\n/* *****************************************\n*  FSE unsafe API\n*******************************************/\nstatic unsigned char FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD);\n/* faster, but works only if nbBits is always >= 1 (otherwise, result will be corrupted) */\n\n\n/* *****************************************\n*  Implementation of inlined functions\n*******************************************/\ntypedef struct {\n    int deltaFindState;\n    U32 deltaNbBits;\n} FSE_symbolCompressionTransform; /* total 8 bytes */\n\nMEM_STATIC void FSE_initCState(FSE_CState_t* statePtr, const FSE_CTable* ct)\n{\n    const void* ptr = ct;\n    const U16* u16ptr = (const U16*) ptr;\n    const U32 tableLog = MEM_read16(ptr);\n    statePtr->value = (ptrdiff_t)1<stateTable = u16ptr+2;\n    statePtr->symbolTT = ct + 1 + (tableLog ? (1<<(tableLog-1)) : 1);\n    statePtr->stateLog = tableLog;\n}\n\n\n/*! FSE_initCState2() :\n*   Same as FSE_initCState(), but the first symbol to include (which will be the last to be read)\n*   uses the smallest state value possible, saving the cost of this symbol */\nMEM_STATIC void FSE_initCState2(FSE_CState_t* statePtr, const FSE_CTable* ct, U32 symbol)\n{\n    FSE_initCState(statePtr, ct);\n    {   const FSE_symbolCompressionTransform symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];\n        const U16* stateTable = (const U16*)(statePtr->stateTable);\n        U32 nbBitsOut  = (U32)((symbolTT.deltaNbBits + (1<<15)) >> 16);\n        statePtr->value = (nbBitsOut << 16) - symbolTT.deltaNbBits;\n        statePtr->value = stateTable[(statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];\n    }\n}\n\nMEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, unsigned symbol)\n{\n    FSE_symbolCompressionTransform const symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];\n    const U16* const stateTable = (const U16*)(statePtr->stateTable);\n    U32 const nbBitsOut  = (U32)((statePtr->value + symbolTT.deltaNbBits) >> 16);\n    BIT_addBits(bitC, (BitContainerType)statePtr->value, nbBitsOut);\n    statePtr->value = stateTable[ (statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];\n}\n\nMEM_STATIC void FSE_flushCState(BIT_CStream_t* bitC, const FSE_CState_t* statePtr)\n{\n    BIT_addBits(bitC, (BitContainerType)statePtr->value, statePtr->stateLog);\n    BIT_flushBits(bitC);\n}\n\n\n/* FSE_getMaxNbBits() :\n * Approximate maximum cost of a symbol, in bits.\n * Fractional get rounded up (i.e. a symbol with a normalized frequency of 3 gives the same result as a frequency of 2)\n * note 1 : assume symbolValue is valid (<= maxSymbolValue)\n * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */\nMEM_STATIC U32 FSE_getMaxNbBits(const void* symbolTTPtr, U32 symbolValue)\n{\n    const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr;\n    return (symbolTT[symbolValue].deltaNbBits + ((1<<16)-1)) >> 16;\n}\n\n/* FSE_bitCost() :\n * Approximate symbol cost, as fractional value, using fixed-point format (accuracyLog fractional bits)\n * note 1 : assume symbolValue is valid (<= maxSymbolValue)\n * note 2 : if freq[symbolValue]==0, @return a fake cost of tableLog+1 bits */\nMEM_STATIC U32 FSE_bitCost(const void* symbolTTPtr, U32 tableLog, U32 symbolValue, U32 accuracyLog)\n{\n    const FSE_symbolCompressionTransform* symbolTT = (const FSE_symbolCompressionTransform*) symbolTTPtr;\n    U32 const minNbBits = symbolTT[symbolValue].deltaNbBits >> 16;\n    U32 const threshold = (minNbBits+1) << 16;\n    assert(tableLog < 16);\n    assert(accuracyLog < 31-tableLog);  /* ensure enough room for renormalization double shift */\n    {   U32 const tableSize = 1 << tableLog;\n        U32 const deltaFromThreshold = threshold - (symbolTT[symbolValue].deltaNbBits + tableSize);\n        U32 const normalizedDeltaFromThreshold = (deltaFromThreshold << accuracyLog) >> tableLog;   /* linear interpolation (very approximate) */\n        U32 const bitMultiplier = 1 << accuracyLog;\n        assert(symbolTT[symbolValue].deltaNbBits + tableSize <= threshold);\n        assert(normalizedDeltaFromThreshold <= bitMultiplier);\n        return (minNbBits+1)*bitMultiplier - normalizedDeltaFromThreshold;\n    }\n}\n\n\n/* ======    Decompression    ====== */\n\ntypedef struct {\n    U16 tableLog;\n    U16 fastMode;\n} FSE_DTableHeader;   /* sizeof U32 */\n\ntypedef struct\n{\n    unsigned short newState;\n    unsigned char  symbol;\n    unsigned char  nbBits;\n} FSE_decode_t;   /* size == U32 */\n\nMEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)\n{\n    const void* ptr = dt;\n    const FSE_DTableHeader* const DTableH = (const FSE_DTableHeader*)ptr;\n    DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);\n    BIT_reloadDStream(bitD);\n    DStatePtr->table = dt + 1;\n}\n\nMEM_STATIC BYTE FSE_peekSymbol(const FSE_DState_t* DStatePtr)\n{\n    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];\n    return DInfo.symbol;\n}\n\nMEM_STATIC void FSE_updateState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)\n{\n    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];\n    U32 const nbBits = DInfo.nbBits;\n    size_t const lowBits = BIT_readBits(bitD, nbBits);\n    DStatePtr->state = DInfo.newState + lowBits;\n}\n\nMEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)\n{\n    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];\n    U32 const nbBits = DInfo.nbBits;\n    BYTE const symbol = DInfo.symbol;\n    size_t const lowBits = BIT_readBits(bitD, nbBits);\n\n    DStatePtr->state = DInfo.newState + lowBits;\n    return symbol;\n}\n\n/*! FSE_decodeSymbolFast() :\n    unsafe, only works if no symbol has a probability > 50% */\nMEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)\n{\n    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];\n    U32 const nbBits = DInfo.nbBits;\n    BYTE const symbol = DInfo.symbol;\n    size_t const lowBits = BIT_readBitsFast(bitD, nbBits);\n\n    DStatePtr->state = DInfo.newState + lowBits;\n    return symbol;\n}\n\nMEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)\n{\n    return DStatePtr->state == 0;\n}\n\n\n\n#ifndef FSE_COMMONDEFS_ONLY\n\n/* **************************************************************\n*  Tuning parameters\n****************************************************************/\n/*!MEMORY_USAGE :\n*  Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)\n*  Increasing memory usage improves compression ratio\n*  Reduced memory usage can improve speed, due to cache effect\n*  Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */\n#ifndef FSE_MAX_MEMORY_USAGE\n#  define FSE_MAX_MEMORY_USAGE 14\n#endif\n#ifndef FSE_DEFAULT_MEMORY_USAGE\n#  define FSE_DEFAULT_MEMORY_USAGE 13\n#endif\n#if (FSE_DEFAULT_MEMORY_USAGE > FSE_MAX_MEMORY_USAGE)\n#  error \"FSE_DEFAULT_MEMORY_USAGE must be <= FSE_MAX_MEMORY_USAGE\"\n#endif\n\n/*!FSE_MAX_SYMBOL_VALUE :\n*  Maximum symbol value authorized.\n*  Required for proper stack allocation */\n#ifndef FSE_MAX_SYMBOL_VALUE\n#  define FSE_MAX_SYMBOL_VALUE 255\n#endif\n\n/* **************************************************************\n*  template functions type & suffix\n****************************************************************/\n#define FSE_FUNCTION_TYPE BYTE\n#define FSE_FUNCTION_EXTENSION\n#define FSE_DECODE_TYPE FSE_decode_t\n\n\n#endif   /* !FSE_COMMONDEFS_ONLY */\n\n\n/* ***************************************************************\n*  Constants\n*****************************************************************/\n#define FSE_MAX_TABLELOG  (FSE_MAX_MEMORY_USAGE-2)\n#define FSE_MAX_TABLESIZE (1U< FSE_TABLELOG_ABSOLUTE_MAX\n#  error \"FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported\"\n#endif\n\n#define FSE_TABLESTEP(tableSize) (((tableSize)>>1) + ((tableSize)>>3) + 3)\n\n#endif /* FSE_STATIC_LINKING_ONLY */\n"
  },
  {
    "path": "lib/common/fse_decompress.c",
    "content": "/* ******************************************************************\n * FSE : Finite State Entropy decoder\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n *  You can contact the author at :\n *  - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy\n *  - Public forum : https://groups.google.com/forum/#!forum/lz4c\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n****************************************************************** */\n\n\n/* **************************************************************\n*  Includes\n****************************************************************/\n#include \"debug.h\"      /* assert */\n#include \"bitstream.h\"\n#include \"compiler.h\"\n#define FSE_STATIC_LINKING_ONLY\n#include \"fse.h\"\n#include \"error_private.h\"\n#include \"zstd_deps.h\"  /* ZSTD_memcpy */\n#include \"bits.h\"       /* ZSTD_highbit32 */\n\n\n/* **************************************************************\n*  Error Management\n****************************************************************/\n#define FSE_isError ERR_isError\n#define FSE_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)   /* use only *after* variable declarations */\n\n\n/* **************************************************************\n*  Templates\n****************************************************************/\n/*\n  designed to be included\n  for type-specific functions (template emulation in C)\n  Objective is to write these functions only once, for improved maintenance\n*/\n\n/* safety checks */\n#ifndef FSE_FUNCTION_EXTENSION\n#  error \"FSE_FUNCTION_EXTENSION must be defined\"\n#endif\n#ifndef FSE_FUNCTION_TYPE\n#  error \"FSE_FUNCTION_TYPE must be defined\"\n#endif\n\n/* Function names */\n#define FSE_CAT(X,Y) X##Y\n#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)\n#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)\n\nstatic size_t FSE_buildDTable_internal(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog, void* workSpace, size_t wkspSize)\n{\n    void* const tdPtr = dt+1;   /* because *dt is unsigned, 32-bits aligned on 32-bits */\n    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*) (tdPtr);\n    U16* symbolNext = (U16*)workSpace;\n    BYTE* spread = (BYTE*)(symbolNext + maxSymbolValue + 1);\n\n    U32 const maxSV1 = maxSymbolValue + 1;\n    U32 const tableSize = 1 << tableLog;\n    U32 highThreshold = tableSize-1;\n\n    /* Sanity Checks */\n    if (FSE_BUILD_DTABLE_WKSP_SIZE(tableLog, maxSymbolValue) > wkspSize) return ERROR(maxSymbolValue_tooLarge);\n    if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);\n    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);\n\n    /* Init, lay down lowprob symbols */\n    {   FSE_DTableHeader DTableH;\n        DTableH.tableLog = (U16)tableLog;\n        DTableH.fastMode = 1;\n        {   S16 const largeLimit= (S16)(1 << (tableLog-1));\n            U32 s;\n            for (s=0; s= largeLimit) DTableH.fastMode=0;\n                    symbolNext[s] = (U16)normalizedCounter[s];\n        }   }   }\n        ZSTD_memcpy(dt, &DTableH, sizeof(DTableH));\n    }\n\n    /* Spread symbols */\n    if (highThreshold == tableSize - 1) {\n        size_t const tableMask = tableSize-1;\n        size_t const step = FSE_TABLESTEP(tableSize);\n        /* First lay down the symbols in order.\n         * We use a uint64_t to lay down 8 bytes at a time. This reduces branch\n         * misses since small blocks generally have small table logs, so nearly\n         * all symbols have counts <= 8. We ensure we have 8 bytes at the end of\n         * our buffer to handle the over-write.\n         */\n        {   U64 const add = 0x0101010101010101ull;\n            size_t pos = 0;\n            U64 sv = 0;\n            U32 s;\n            for (s=0; s highThreshold) position = (position + step) & tableMask;   /* lowprob area */\n        }   }\n        if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */\n    }\n\n    /* Build Decoding table */\n    {   U32 u;\n        for (u=0; u sizeof(bitD.bitContainer)*8)    /* This test must be static */\n            BIT_reloadDStream(&bitD);\n\n        op[1] = FSE_GETSYMBOL(&state2);\n\n        if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */\n            { if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } }\n\n        op[2] = FSE_GETSYMBOL(&state1);\n\n        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */\n            BIT_reloadDStream(&bitD);\n\n        op[3] = FSE_GETSYMBOL(&state2);\n    }\n\n    /* tail */\n    /* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */\n    while (1) {\n        if (op>(omax-2)) return ERROR(dstSize_tooSmall);\n        *op++ = FSE_GETSYMBOL(&state1);\n        if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) {\n            *op++ = FSE_GETSYMBOL(&state2);\n            break;\n        }\n\n        if (op>(omax-2)) return ERROR(dstSize_tooSmall);\n        *op++ = FSE_GETSYMBOL(&state2);\n        if (BIT_reloadDStream(&bitD)==BIT_DStream_overflow) {\n            *op++ = FSE_GETSYMBOL(&state1);\n            break;\n    }   }\n\n    assert(op >= ostart);\n    return (size_t)(op-ostart);\n}\n\ntypedef struct {\n    short ncount[FSE_MAX_SYMBOL_VALUE + 1];\n} FSE_DecompressWksp;\n\n\nFORCE_INLINE_TEMPLATE size_t FSE_decompress_wksp_body(\n        void* dst, size_t dstCapacity,\n        const void* cSrc, size_t cSrcSize,\n        unsigned maxLog, void* workSpace, size_t wkspSize,\n        int bmi2)\n{\n    const BYTE* const istart = (const BYTE*)cSrc;\n    const BYTE* ip = istart;\n    unsigned tableLog;\n    unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;\n    FSE_DecompressWksp* const wksp = (FSE_DecompressWksp*)workSpace;\n    size_t const dtablePos = sizeof(FSE_DecompressWksp) / sizeof(FSE_DTable);\n    FSE_DTable* const dtable = (FSE_DTable*)workSpace + dtablePos;\n\n    FSE_STATIC_ASSERT((FSE_MAX_SYMBOL_VALUE + 1) % 2 == 0);\n    if (wkspSize < sizeof(*wksp)) return ERROR(GENERIC);\n\n    /* correct offset to dtable depends on this property */\n    FSE_STATIC_ASSERT(sizeof(FSE_DecompressWksp) % sizeof(FSE_DTable) == 0);\n\n    /* normal FSE decoding mode */\n    {   size_t const NCountLength =\n            FSE_readNCount_bmi2(wksp->ncount, &maxSymbolValue, &tableLog, istart, cSrcSize, bmi2);\n        if (FSE_isError(NCountLength)) return NCountLength;\n        if (tableLog > maxLog) return ERROR(tableLog_tooLarge);\n        assert(NCountLength <= cSrcSize);\n        ip += NCountLength;\n        cSrcSize -= NCountLength;\n    }\n\n    if (FSE_DECOMPRESS_WKSP_SIZE(tableLog, maxSymbolValue) > wkspSize) return ERROR(tableLog_tooLarge);\n    assert(sizeof(*wksp) + FSE_DTABLE_SIZE(tableLog) <= wkspSize);\n    workSpace = (BYTE*)workSpace + sizeof(*wksp) + FSE_DTABLE_SIZE(tableLog);\n    wkspSize -= sizeof(*wksp) + FSE_DTABLE_SIZE(tableLog);\n\n    CHECK_F( FSE_buildDTable_internal(dtable, wksp->ncount, maxSymbolValue, tableLog, workSpace, wkspSize) );\n\n    {\n        const void* ptr = dtable;\n        const FSE_DTableHeader* DTableH = (const FSE_DTableHeader*)ptr;\n        const U32 fastMode = DTableH->fastMode;\n\n        /* select fast mode (static) */\n        if (fastMode) return FSE_decompress_usingDTable_generic(dst, dstCapacity, ip, cSrcSize, dtable, 1);\n        return FSE_decompress_usingDTable_generic(dst, dstCapacity, ip, cSrcSize, dtable, 0);\n    }\n}\n\n/* Avoids the FORCE_INLINE of the _body() function. */\nstatic size_t FSE_decompress_wksp_body_default(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize)\n{\n    return FSE_decompress_wksp_body(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize, 0);\n}\n\n#if DYNAMIC_BMI2\nBMI2_TARGET_ATTRIBUTE static size_t FSE_decompress_wksp_body_bmi2(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize)\n{\n    return FSE_decompress_wksp_body(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize, 1);\n}\n#endif\n\nsize_t FSE_decompress_wksp_bmi2(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, unsigned maxLog, void* workSpace, size_t wkspSize, int bmi2)\n{\n#if DYNAMIC_BMI2\n    if (bmi2) {\n        return FSE_decompress_wksp_body_bmi2(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize);\n    }\n#endif\n    (void)bmi2;\n    return FSE_decompress_wksp_body_default(dst, dstCapacity, cSrc, cSrcSize, maxLog, workSpace, wkspSize);\n}\n\n#endif   /* FSE_COMMONDEFS_ONLY */\n"
  },
  {
    "path": "lib/common/huf.h",
    "content": "/* ******************************************************************\n * huff0 huffman codec,\n * part of Finite State Entropy library\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * You can contact the author at :\n * - Source repository : https://github.com/Cyan4973/FiniteStateEntropy\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n****************************************************************** */\n\n#ifndef HUF_H_298734234\n#define HUF_H_298734234\n\n/* *** Dependencies *** */\n#include \"zstd_deps.h\"    /* size_t */\n#include \"mem.h\"          /* U32 */\n#define FSE_STATIC_LINKING_ONLY\n#include \"fse.h\"\n\n/* ***   Tool functions *** */\n#define HUF_BLOCKSIZE_MAX (128 * 1024)   /**< maximum input size for a single block compressed with HUF_compress */\nsize_t HUF_compressBound(size_t size);   /**< maximum compressed size (worst case) */\n\n/* Error Management */\nunsigned    HUF_isError(size_t code);       /**< tells if a return value is an error code */\nconst char* HUF_getErrorName(size_t code);  /**< provides error code string (useful for debugging) */\n\n\n#define HUF_WORKSPACE_SIZE ((8 << 10) + 512 /* sorting scratch space */)\n#define HUF_WORKSPACE_SIZE_U64 (HUF_WORKSPACE_SIZE / sizeof(U64))\n\n/* *** Constants *** */\n#define HUF_TABLELOG_MAX      12      /* max runtime value of tableLog (due to static allocation); can be modified up to HUF_TABLELOG_ABSOLUTEMAX */\n#define HUF_TABLELOG_DEFAULT  11      /* default tableLog value when none specified */\n#define HUF_SYMBOLVALUE_MAX  255\n\n#define HUF_TABLELOG_ABSOLUTEMAX  12  /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */\n#if (HUF_TABLELOG_MAX > HUF_TABLELOG_ABSOLUTEMAX)\n#  error \"HUF_TABLELOG_MAX is too large !\"\n#endif\n\n\n/* ****************************************\n*  Static allocation\n******************************************/\n/* HUF buffer bounds */\n#define HUF_CTABLEBOUND 129\n#define HUF_BLOCKBOUND(size) (size + (size>>8) + 8)   /* only true when incompressible is pre-filtered with fast heuristic */\n#define HUF_COMPRESSBOUND(size) (HUF_CTABLEBOUND + HUF_BLOCKBOUND(size))   /* Macro version, useful for static allocation */\n\n/* static allocation of HUF's Compression Table */\n/* this is a private definition, just exposed for allocation and strict aliasing purpose. never EVER access its members directly */\ntypedef size_t HUF_CElt;   /* consider it an incomplete type */\n#define HUF_CTABLE_SIZE_ST(maxSymbolValue)   ((maxSymbolValue)+2)   /* Use tables of size_t, for proper alignment */\n#define HUF_CTABLE_SIZE(maxSymbolValue)       (HUF_CTABLE_SIZE_ST(maxSymbolValue) * sizeof(size_t))\n#define HUF_CREATE_STATIC_CTABLE(name, maxSymbolValue) \\\n    HUF_CElt name[HUF_CTABLE_SIZE_ST(maxSymbolValue)] /* no final ; */\n\n/* static allocation of HUF's DTable */\ntypedef U32 HUF_DTable;\n#define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<<(maxTableLog)))\n#define HUF_CREATE_STATIC_DTABLEX1(DTable, maxTableLog) \\\n        HUF_DTable DTable[HUF_DTABLE_SIZE((maxTableLog)-1)] = { ((U32)((maxTableLog)-1) * 0x01000001) }\n#define HUF_CREATE_STATIC_DTABLEX2(DTable, maxTableLog) \\\n        HUF_DTable DTable[HUF_DTABLE_SIZE(maxTableLog)] = { ((U32)(maxTableLog) * 0x01000001) }\n\n\n/* ****************************************\n*  Advanced decompression functions\n******************************************/\n\n/**\n * Huffman flags bitset.\n * For all flags, 0 is the default value.\n */\ntypedef enum {\n    /**\n     * If compiled with DYNAMIC_BMI2: Set flag only if the CPU supports BMI2 at runtime.\n     * Otherwise: Ignored.\n     */\n    HUF_flags_bmi2 = (1 << 0),\n    /**\n     * If set: Test possible table depths to find the one that produces the smallest header + encoded size.\n     * If unset: Use heuristic to find the table depth.\n     */\n    HUF_flags_optimalDepth = (1 << 1),\n    /**\n     * If set: If the previous table can encode the input, always reuse the previous table.\n     * If unset: If the previous table can encode the input, reuse the previous table if it results in a smaller output.\n     */\n    HUF_flags_preferRepeat = (1 << 2),\n    /**\n     * If set: Sample the input and check if the sample is uncompressible, if it is then don't attempt to compress.\n     * If unset: Always histogram the entire input.\n     */\n    HUF_flags_suspectUncompressible = (1 << 3),\n    /**\n     * If set: Don't use assembly implementations\n     * If unset: Allow using assembly implementations\n     */\n    HUF_flags_disableAsm = (1 << 4),\n    /**\n     * If set: Don't use the fast decoding loop, always use the fallback decoding loop.\n     * If unset: Use the fast decoding loop when possible.\n     */\n    HUF_flags_disableFast = (1 << 5)\n} HUF_flags_e;\n\n\n/* ****************************************\n *  HUF detailed API\n * ****************************************/\n#define HUF_OPTIMAL_DEPTH_THRESHOLD ZSTD_btultra\n\n/*! HUF_compress() does the following:\n *  1. count symbol occurrence from source[] into table count[] using FSE_count() (exposed within \"fse.h\")\n *  2. (optional) refine tableLog using HUF_optimalTableLog()\n *  3. build Huffman table from count using HUF_buildCTable()\n *  4. save Huffman table to memory buffer using HUF_writeCTable()\n *  5. encode the data stream using HUF_compress4X_usingCTable()\n *\n *  The following API allows targeting specific sub-functions for advanced tasks.\n *  For example, it's possible to compress several blocks using the same 'CTable',\n *  or to save and regenerate 'CTable' using external methods.\n */\nunsigned HUF_minTableLog(unsigned symbolCardinality);\nunsigned HUF_cardinality(const unsigned* count, unsigned maxSymbolValue);\nunsigned HUF_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, void* workSpace,\n size_t wkspSize, HUF_CElt* table, const unsigned* count, int flags); /* table is used as scratch space for building and testing tables, not a return value */\nsize_t HUF_writeCTable_wksp(void* dst, size_t maxDstSize, const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog, void* workspace, size_t workspaceSize);\nsize_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, int flags);\nsize_t HUF_estimateCompressedSize(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue);\nint HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue);\n\ntypedef enum {\n   HUF_repeat_none,  /**< Cannot use the previous table */\n   HUF_repeat_check, /**< Can use the previous table but it must be checked. Note : The previous table must have been constructed by HUF_compress{1, 4}X_repeat */\n   HUF_repeat_valid  /**< Can use the previous table and it is assumed to be valid */\n } HUF_repeat;\n\n/** HUF_compress4X_repeat() :\n *  Same as HUF_compress4X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none.\n *  If it uses hufTable it does not modify hufTable or repeat.\n *  If it doesn't, it sets *repeat = HUF_repeat_none, and it sets hufTable to the table used.\n *  If preferRepeat then the old table will always be used if valid.\n *  If suspectUncompressible then some sampling checks will be run to potentially skip huffman coding */\nsize_t HUF_compress4X_repeat(void* dst, size_t dstSize,\n                       const void* src, size_t srcSize,\n                       unsigned maxSymbolValue, unsigned tableLog,\n                       void* workSpace, size_t wkspSize,    /**< `workSpace` must be aligned on 4-bytes boundaries, `wkspSize` must be >= HUF_WORKSPACE_SIZE */\n                       HUF_CElt* hufTable, HUF_repeat* repeat, int flags);\n\n/** HUF_buildCTable_wksp() :\n *  Same as HUF_buildCTable(), but using externally allocated scratch buffer.\n * `workSpace` must be aligned on 4-bytes boundaries, and its size must be >= HUF_CTABLE_WORKSPACE_SIZE.\n */\n#define HUF_CTABLE_WORKSPACE_SIZE_U32 ((4 * (HUF_SYMBOLVALUE_MAX + 1)) + 192)\n#define HUF_CTABLE_WORKSPACE_SIZE (HUF_CTABLE_WORKSPACE_SIZE_U32 * sizeof(unsigned))\nsize_t HUF_buildCTable_wksp (HUF_CElt* tree,\n                       const unsigned* count, U32 maxSymbolValue, U32 maxNbBits,\n                             void* workSpace, size_t wkspSize);\n\n/*! HUF_readStats() :\n *  Read compact Huffman tree, saved by HUF_writeCTable().\n * `huffWeight` is destination buffer.\n * @return : size read from `src` , or an error Code .\n *  Note : Needed by HUF_readCTable() and HUF_readDTableXn() . */\nsize_t HUF_readStats(BYTE* huffWeight, size_t hwSize,\n                     U32* rankStats, U32* nbSymbolsPtr, U32* tableLogPtr,\n                     const void* src, size_t srcSize);\n\n/*! HUF_readStats_wksp() :\n * Same as HUF_readStats() but takes an external workspace which must be\n * 4-byte aligned and its size must be >= HUF_READ_STATS_WORKSPACE_SIZE.\n * If the CPU has BMI2 support, pass bmi2=1, otherwise pass bmi2=0.\n */\n#define HUF_READ_STATS_WORKSPACE_SIZE_U32 FSE_DECOMPRESS_WKSP_SIZE_U32(6, HUF_TABLELOG_MAX-1)\n#define HUF_READ_STATS_WORKSPACE_SIZE (HUF_READ_STATS_WORKSPACE_SIZE_U32 * sizeof(unsigned))\nsize_t HUF_readStats_wksp(BYTE* huffWeight, size_t hwSize,\n                          U32* rankStats, U32* nbSymbolsPtr, U32* tableLogPtr,\n                          const void* src, size_t srcSize,\n                          void* workspace, size_t wkspSize,\n                          int flags);\n\n/** HUF_readCTable() :\n *  Loading a CTable saved with HUF_writeCTable() */\nsize_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize, unsigned *hasZeroWeights);\n\n/** HUF_getNbBitsFromCTable() :\n *  Read nbBits from CTable symbolTable, for symbol `symbolValue` presumed <= HUF_SYMBOLVALUE_MAX\n *  Note 1 : If symbolValue > HUF_readCTableHeader(symbolTable).maxSymbolValue, returns 0\n *  Note 2 : is not inlined, as HUF_CElt definition is private\n */\nU32 HUF_getNbBitsFromCTable(const HUF_CElt* symbolTable, U32 symbolValue);\n\ntypedef struct {\n    BYTE tableLog;\n    BYTE maxSymbolValue;\n    BYTE unused[sizeof(size_t) - 2];\n} HUF_CTableHeader;\n\n/** HUF_readCTableHeader() :\n *  @returns The header from the CTable specifying the tableLog and the maxSymbolValue.\n */\nHUF_CTableHeader HUF_readCTableHeader(HUF_CElt const* ctable);\n\n/*\n * HUF_decompress() does the following:\n * 1. select the decompression algorithm (X1, X2) based on pre-computed heuristics\n * 2. build Huffman table from save, using HUF_readDTableX?()\n * 3. decode 1 or 4 segments in parallel using HUF_decompress?X?_usingDTable()\n */\n\n/** HUF_selectDecoder() :\n *  Tells which decoder is likely to decode faster,\n *  based on a set of pre-computed metrics.\n * @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 .\n *  Assumption : 0 < dstSize <= 128 KB */\nU32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize);\n\n/**\n *  The minimum workspace size for the `workSpace` used in\n *  HUF_readDTableX1_wksp() and HUF_readDTableX2_wksp().\n *\n *  The space used depends on HUF_TABLELOG_MAX, ranging from ~1500 bytes when\n *  HUF_TABLE_LOG_MAX=12 to ~1850 bytes when HUF_TABLE_LOG_MAX=15.\n *  Buffer overflow errors may potentially occur if code modifications result in\n *  a required workspace size greater than that specified in the following\n *  macro.\n */\n#define HUF_DECOMPRESS_WORKSPACE_SIZE ((2 << 10) + (1 << 9))\n#define HUF_DECOMPRESS_WORKSPACE_SIZE_U32 (HUF_DECOMPRESS_WORKSPACE_SIZE / sizeof(U32))\n\n\n/* ====================== */\n/* single stream variants */\n/* ====================== */\n\nsize_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, int flags);\n/** HUF_compress1X_repeat() :\n *  Same as HUF_compress1X_wksp(), but considers using hufTable if *repeat != HUF_repeat_none.\n *  If it uses hufTable it does not modify hufTable or repeat.\n *  If it doesn't, it sets *repeat = HUF_repeat_none, and it sets hufTable to the table used.\n *  If preferRepeat then the old table will always be used if valid.\n *  If suspectUncompressible then some sampling checks will be run to potentially skip huffman coding */\nsize_t HUF_compress1X_repeat(void* dst, size_t dstSize,\n                       const void* src, size_t srcSize,\n                       unsigned maxSymbolValue, unsigned tableLog,\n                       void* workSpace, size_t wkspSize,   /**< `workSpace` must be aligned on 4-bytes boundaries, `wkspSize` must be >= HUF_WORKSPACE_SIZE */\n                       HUF_CElt* hufTable, HUF_repeat* repeat, int flags);\n\nsize_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags);\n#ifndef HUF_FORCE_DECOMPRESS_X1\nsize_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags);   /**< double-symbols decoder */\n#endif\n\n/* BMI2 variants.\n * If the CPU has BMI2 support, pass bmi2=1, otherwise pass bmi2=0.\n */\nsize_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int flags);\n#ifndef HUF_FORCE_DECOMPRESS_X2\nsize_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags);\n#endif\nsize_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int flags);\nsize_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags);\n#ifndef HUF_FORCE_DECOMPRESS_X2\nsize_t HUF_readDTableX1_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize, int flags);\n#endif\n#ifndef HUF_FORCE_DECOMPRESS_X1\nsize_t HUF_readDTableX2_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize, int flags);\n#endif\n\n#endif   /* HUF_H_298734234 */\n"
  },
  {
    "path": "lib/common/mem.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef MEM_H_MODULE\n#define MEM_H_MODULE\n\n/*-****************************************\n*  Dependencies\n******************************************/\n#include   /* size_t, ptrdiff_t */\n#include \"compiler.h\"  /* __has_builtin */\n#include \"debug.h\"  /* DEBUG_STATIC_ASSERT */\n#include \"zstd_deps.h\"  /* ZSTD_memcpy */\n\n\n/*-****************************************\n*  Compiler specifics\n******************************************/\n#if defined(_MSC_VER)   /* Visual Studio */\n#   include   /* _byteswap_ulong */\n#   include   /* _byteswap_* */\n#elif defined(__ICCARM__)\n#   include \n#endif\n\n/*-**************************************************************\n*  Basic Types\n*****************************************************************/\n#if  !defined (__VMS) && (defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )\n#  if defined(_AIX)\n#    include \n#  else\n#    include  /* intptr_t */\n#  endif\n  typedef   uint8_t BYTE;\n  typedef   uint8_t U8;\n  typedef    int8_t S8;\n  typedef  uint16_t U16;\n  typedef   int16_t S16;\n  typedef  uint32_t U32;\n  typedef   int32_t S32;\n  typedef  uint64_t U64;\n  typedef   int64_t S64;\n#else\n# include \n#if CHAR_BIT != 8\n#  error \"this implementation requires char to be exactly 8-bit type\"\n#endif\n  typedef unsigned char      BYTE;\n  typedef unsigned char      U8;\n  typedef   signed char      S8;\n#if USHRT_MAX != 65535\n#  error \"this implementation requires short to be exactly 16-bit type\"\n#endif\n  typedef unsigned short      U16;\n  typedef   signed short      S16;\n#if UINT_MAX != 4294967295\n#  error \"this implementation requires int to be exactly 32-bit type\"\n#endif\n  typedef unsigned int        U32;\n  typedef   signed int        S32;\n/* note : there are no limits defined for long long type in C90.\n * limits exist in C99, however, in such case,  is preferred */\n  typedef unsigned long long  U64;\n  typedef   signed long long  S64;\n#endif\n\n/*-**************************************************************\n*  Memory I/O API\n*****************************************************************/\n/*=== Static platform detection ===*/\nMEM_STATIC unsigned MEM_32bits(void);\nMEM_STATIC unsigned MEM_64bits(void);\nMEM_STATIC unsigned MEM_isLittleEndian(void);\n\n/*=== Native unaligned read/write ===*/\nMEM_STATIC U16 MEM_read16(const void* memPtr);\nMEM_STATIC U32 MEM_read32(const void* memPtr);\nMEM_STATIC U64 MEM_read64(const void* memPtr);\nMEM_STATIC size_t MEM_readST(const void* memPtr);\n\nMEM_STATIC void MEM_write16(void* memPtr, U16 value);\nMEM_STATIC void MEM_write32(void* memPtr, U32 value);\nMEM_STATIC void MEM_write64(void* memPtr, U64 value);\n\n/*=== Little endian unaligned read/write ===*/\nMEM_STATIC U16 MEM_readLE16(const void* memPtr);\nMEM_STATIC U32 MEM_readLE24(const void* memPtr);\nMEM_STATIC U32 MEM_readLE32(const void* memPtr);\nMEM_STATIC U64 MEM_readLE64(const void* memPtr);\nMEM_STATIC size_t MEM_readLEST(const void* memPtr);\n\nMEM_STATIC void MEM_writeLE16(void* memPtr, U16 val);\nMEM_STATIC void MEM_writeLE24(void* memPtr, U32 val);\nMEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32);\nMEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64);\nMEM_STATIC void MEM_writeLEST(void* memPtr, size_t val);\n\n/*=== Big endian unaligned read/write ===*/\nMEM_STATIC U32 MEM_readBE32(const void* memPtr);\nMEM_STATIC U64 MEM_readBE64(const void* memPtr);\nMEM_STATIC size_t MEM_readBEST(const void* memPtr);\n\nMEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32);\nMEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64);\nMEM_STATIC void MEM_writeBEST(void* memPtr, size_t val);\n\n/*=== Byteswap ===*/\nMEM_STATIC U32 MEM_swap32(U32 in);\nMEM_STATIC U64 MEM_swap64(U64 in);\nMEM_STATIC size_t MEM_swapST(size_t in);\n\n\n/*-**************************************************************\n*  Memory I/O Implementation\n*****************************************************************/\n/* MEM_FORCE_MEMORY_ACCESS : For accessing unaligned memory:\n * Method 0 : always use `memcpy()`. Safe and portable.\n * Method 1 : Use compiler extension to set unaligned access.\n * Method 2 : direct access. This method is portable but violate C standard.\n *            It can generate buggy code on targets depending on alignment.\n * Default  : method 1 if supported, else method 0\n */\n#ifndef MEM_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */\n#  ifdef __GNUC__\n#    define MEM_FORCE_MEMORY_ACCESS 1\n#  endif\n#endif\n\nMEM_STATIC unsigned MEM_32bits(void) { return sizeof(size_t)==4; }\nMEM_STATIC unsigned MEM_64bits(void) { return sizeof(size_t)==8; }\n\nMEM_STATIC unsigned MEM_isLittleEndian(void)\n{\n#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)\n    return 1;\n#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)\n    return 0;\n#elif defined(__clang__) && __LITTLE_ENDIAN__\n    return 1;\n#elif defined(__clang__) && __BIG_ENDIAN__\n    return 0;\n#elif defined(_MSC_VER) && (_M_X64 || _M_IX86)\n    return 1;\n#elif defined(__DMC__) && defined(_M_IX86)\n    return 1;\n#elif defined(__IAR_SYSTEMS_ICC__) && __LITTLE_ENDIAN__\n    return 1;\n#else\n    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */\n    return one.c[0];\n#endif\n}\n\n#if defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==2)\n\n/* violates C standard, by lying on structure alignment.\nOnly use if no other choice to achieve best performance on target platform */\nMEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }\nMEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }\nMEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }\nMEM_STATIC size_t MEM_readST(const void* memPtr) { return *(const size_t*) memPtr; }\n\nMEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }\nMEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }\nMEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; }\n\n#elif defined(MEM_FORCE_MEMORY_ACCESS) && (MEM_FORCE_MEMORY_ACCESS==1)\n\ntypedef __attribute__((aligned(1))) U16 unalign16;\ntypedef __attribute__((aligned(1))) U32 unalign32;\ntypedef __attribute__((aligned(1))) U64 unalign64;\ntypedef __attribute__((aligned(1))) size_t unalignArch;\n\nMEM_STATIC U16 MEM_read16(const void* ptr) { return *(const unalign16*)ptr; }\nMEM_STATIC U32 MEM_read32(const void* ptr) { return *(const unalign32*)ptr; }\nMEM_STATIC U64 MEM_read64(const void* ptr) { return *(const unalign64*)ptr; }\nMEM_STATIC size_t MEM_readST(const void* ptr) { return *(const unalignArch*)ptr; }\n\nMEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(unalign16*)memPtr = value; }\nMEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(unalign32*)memPtr = value; }\nMEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(unalign64*)memPtr = value; }\n\n#else\n\n/* default method, safe and standard.\n   can sometimes prove slower */\n\nMEM_STATIC U16 MEM_read16(const void* memPtr)\n{\n    U16 val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;\n}\n\nMEM_STATIC U32 MEM_read32(const void* memPtr)\n{\n    U32 val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;\n}\n\nMEM_STATIC U64 MEM_read64(const void* memPtr)\n{\n    U64 val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;\n}\n\nMEM_STATIC size_t MEM_readST(const void* memPtr)\n{\n    size_t val; ZSTD_memcpy(&val, memPtr, sizeof(val)); return val;\n}\n\nMEM_STATIC void MEM_write16(void* memPtr, U16 value)\n{\n    ZSTD_memcpy(memPtr, &value, sizeof(value));\n}\n\nMEM_STATIC void MEM_write32(void* memPtr, U32 value)\n{\n    ZSTD_memcpy(memPtr, &value, sizeof(value));\n}\n\nMEM_STATIC void MEM_write64(void* memPtr, U64 value)\n{\n    ZSTD_memcpy(memPtr, &value, sizeof(value));\n}\n\n#endif /* MEM_FORCE_MEMORY_ACCESS */\n\nMEM_STATIC U32 MEM_swap32_fallback(U32 in)\n{\n    return  ((in << 24) & 0xff000000 ) |\n            ((in <<  8) & 0x00ff0000 ) |\n            ((in >>  8) & 0x0000ff00 ) |\n            ((in >> 24) & 0x000000ff );\n}\n\nMEM_STATIC U32 MEM_swap32(U32 in)\n{\n#if defined(_MSC_VER)     /* Visual Studio */\n    return _byteswap_ulong(in);\n#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \\\n  || (defined(__clang__) && __has_builtin(__builtin_bswap32))\n    return __builtin_bswap32(in);\n#elif defined(__ICCARM__)\n    return __REV(in);\n#else\n    return MEM_swap32_fallback(in);\n#endif\n}\n\nMEM_STATIC U64 MEM_swap64_fallback(U64 in)\n{\n     return  ((in << 56) & 0xff00000000000000ULL) |\n            ((in << 40) & 0x00ff000000000000ULL) |\n            ((in << 24) & 0x0000ff0000000000ULL) |\n            ((in << 8)  & 0x000000ff00000000ULL) |\n            ((in >> 8)  & 0x00000000ff000000ULL) |\n            ((in >> 24) & 0x0000000000ff0000ULL) |\n            ((in >> 40) & 0x000000000000ff00ULL) |\n            ((in >> 56) & 0x00000000000000ffULL);\n}\n\nMEM_STATIC U64 MEM_swap64(U64 in)\n{\n#if defined(_MSC_VER)     /* Visual Studio */\n    return _byteswap_uint64(in);\n#elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \\\n  || (defined(__clang__) && __has_builtin(__builtin_bswap64))\n    return __builtin_bswap64(in);\n#else\n    return MEM_swap64_fallback(in);\n#endif\n}\n\nMEM_STATIC size_t MEM_swapST(size_t in)\n{\n    if (MEM_32bits())\n        return (size_t)MEM_swap32((U32)in);\n    else\n        return (size_t)MEM_swap64((U64)in);\n}\n\n/*=== Little endian r/w ===*/\n\nMEM_STATIC U16 MEM_readLE16(const void* memPtr)\n{\n    if (MEM_isLittleEndian())\n        return MEM_read16(memPtr);\n    else {\n        const BYTE* p = (const BYTE*)memPtr;\n        return (U16)(p[0] + (p[1]<<8));\n    }\n}\n\nMEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)\n{\n    if (MEM_isLittleEndian()) {\n        MEM_write16(memPtr, val);\n    } else {\n        BYTE* p = (BYTE*)memPtr;\n        p[0] = (BYTE)val;\n        p[1] = (BYTE)(val>>8);\n    }\n}\n\nMEM_STATIC U32 MEM_readLE24(const void* memPtr)\n{\n    return (U32)MEM_readLE16(memPtr) + ((U32)(((const BYTE*)memPtr)[2]) << 16);\n}\n\nMEM_STATIC void MEM_writeLE24(void* memPtr, U32 val)\n{\n    MEM_writeLE16(memPtr, (U16)val);\n    ((BYTE*)memPtr)[2] = (BYTE)(val>>16);\n}\n\nMEM_STATIC U32 MEM_readLE32(const void* memPtr)\n{\n    if (MEM_isLittleEndian())\n        return MEM_read32(memPtr);\n    else\n        return MEM_swap32(MEM_read32(memPtr));\n}\n\nMEM_STATIC void MEM_writeLE32(void* memPtr, U32 val32)\n{\n    if (MEM_isLittleEndian())\n        MEM_write32(memPtr, val32);\n    else\n        MEM_write32(memPtr, MEM_swap32(val32));\n}\n\nMEM_STATIC U64 MEM_readLE64(const void* memPtr)\n{\n    if (MEM_isLittleEndian())\n        return MEM_read64(memPtr);\n    else\n        return MEM_swap64(MEM_read64(memPtr));\n}\n\nMEM_STATIC void MEM_writeLE64(void* memPtr, U64 val64)\n{\n    if (MEM_isLittleEndian())\n        MEM_write64(memPtr, val64);\n    else\n        MEM_write64(memPtr, MEM_swap64(val64));\n}\n\nMEM_STATIC size_t MEM_readLEST(const void* memPtr)\n{\n    if (MEM_32bits())\n        return (size_t)MEM_readLE32(memPtr);\n    else\n        return (size_t)MEM_readLE64(memPtr);\n}\n\nMEM_STATIC void MEM_writeLEST(void* memPtr, size_t val)\n{\n    if (MEM_32bits())\n        MEM_writeLE32(memPtr, (U32)val);\n    else\n        MEM_writeLE64(memPtr, (U64)val);\n}\n\n/*=== Big endian r/w ===*/\n\nMEM_STATIC U32 MEM_readBE32(const void* memPtr)\n{\n    if (MEM_isLittleEndian())\n        return MEM_swap32(MEM_read32(memPtr));\n    else\n        return MEM_read32(memPtr);\n}\n\nMEM_STATIC void MEM_writeBE32(void* memPtr, U32 val32)\n{\n    if (MEM_isLittleEndian())\n        MEM_write32(memPtr, MEM_swap32(val32));\n    else\n        MEM_write32(memPtr, val32);\n}\n\nMEM_STATIC U64 MEM_readBE64(const void* memPtr)\n{\n    if (MEM_isLittleEndian())\n        return MEM_swap64(MEM_read64(memPtr));\n    else\n        return MEM_read64(memPtr);\n}\n\nMEM_STATIC void MEM_writeBE64(void* memPtr, U64 val64)\n{\n    if (MEM_isLittleEndian())\n        MEM_write64(memPtr, MEM_swap64(val64));\n    else\n        MEM_write64(memPtr, val64);\n}\n\nMEM_STATIC size_t MEM_readBEST(const void* memPtr)\n{\n    if (MEM_32bits())\n        return (size_t)MEM_readBE32(memPtr);\n    else\n        return (size_t)MEM_readBE64(memPtr);\n}\n\nMEM_STATIC void MEM_writeBEST(void* memPtr, size_t val)\n{\n    if (MEM_32bits())\n        MEM_writeBE32(memPtr, (U32)val);\n    else\n        MEM_writeBE64(memPtr, (U64)val);\n}\n\n/* code only tested on 32 and 64 bits systems */\nMEM_STATIC void MEM_check(void) { DEBUG_STATIC_ASSERT((sizeof(size_t)==4) || (sizeof(size_t)==8)); }\n\n#endif /* MEM_H_MODULE */\n"
  },
  {
    "path": "lib/common/pool.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n\n/* ======   Dependencies   ======= */\n#include \"../common/allocations.h\"  /* ZSTD_customCalloc, ZSTD_customFree */\n#include \"zstd_deps.h\" /* size_t */\n#include \"debug.h\"     /* assert */\n#include \"pool.h\"\n\n/* ======   Compiler specifics   ====== */\n#if defined(_MSC_VER)\n#  pragma warning(disable : 4204)        /* disable: C4204: non-constant aggregate initializer */\n#endif\n\n\n#ifdef ZSTD_MULTITHREAD\n\n#include \"threading.h\"   /* pthread adaptation */\n\n/* A job is a function and an opaque argument */\ntypedef struct POOL_job_s {\n    POOL_function function;\n    void *opaque;\n} POOL_job;\n\nstruct POOL_ctx_s {\n    ZSTD_customMem customMem;\n    /* Keep track of the threads */\n    ZSTD_pthread_t* threads;\n    size_t threadCapacity;\n    size_t threadLimit;\n\n    /* The queue is a circular buffer */\n    POOL_job *queue;\n    size_t queueHead;\n    size_t queueTail;\n    size_t queueSize;\n\n    /* The number of threads working on jobs */\n    size_t numThreadsBusy;\n    /* Indicates if the queue is empty */\n    int queueEmpty;\n\n    /* The mutex protects the queue */\n    ZSTD_pthread_mutex_t queueMutex;\n    /* Condition variable for pushers to wait on when the queue is full */\n    ZSTD_pthread_cond_t queuePushCond;\n    /* Condition variables for poppers to wait on when the queue is empty */\n    ZSTD_pthread_cond_t queuePopCond;\n    /* Indicates if the queue is shutting down */\n    int shutdown;\n};\n\n/* POOL_thread() :\n * Work thread for the thread pool.\n * Waits for jobs and executes them.\n * @returns : NULL on failure else non-null.\n */\nstatic void* POOL_thread(void* opaque) {\n    POOL_ctx* const ctx = (POOL_ctx*)opaque;\n    if (!ctx) { return NULL; }\n    for (;;) {\n        /* Lock the mutex and wait for a non-empty queue or until shutdown */\n        ZSTD_pthread_mutex_lock(&ctx->queueMutex);\n\n        while ( ctx->queueEmpty\n            || (ctx->numThreadsBusy >= ctx->threadLimit) ) {\n            if (ctx->shutdown) {\n                /* even if !queueEmpty, (possible if numThreadsBusy >= threadLimit),\n                 * a few threads will be shutdown while !queueEmpty,\n                 * but enough threads will remain active to finish the queue */\n                ZSTD_pthread_mutex_unlock(&ctx->queueMutex);\n                return opaque;\n            }\n            ZSTD_pthread_cond_wait(&ctx->queuePopCond, &ctx->queueMutex);\n        }\n        /* Pop a job off the queue */\n        {   POOL_job const job = ctx->queue[ctx->queueHead];\n            ctx->queueHead = (ctx->queueHead + 1) % ctx->queueSize;\n            ctx->numThreadsBusy++;\n            ctx->queueEmpty = (ctx->queueHead == ctx->queueTail);\n            /* Unlock the mutex, signal a pusher, and run the job */\n            ZSTD_pthread_cond_signal(&ctx->queuePushCond);\n            ZSTD_pthread_mutex_unlock(&ctx->queueMutex);\n\n            job.function(job.opaque);\n\n            /* If the intended queue size was 0, signal after finishing job */\n            ZSTD_pthread_mutex_lock(&ctx->queueMutex);\n            ctx->numThreadsBusy--;\n            ZSTD_pthread_cond_signal(&ctx->queuePushCond);\n            ZSTD_pthread_mutex_unlock(&ctx->queueMutex);\n        }\n    }  /* for (;;) */\n    assert(0);  /* Unreachable */\n}\n\n/* ZSTD_createThreadPool() : public access point */\nPOOL_ctx* ZSTD_createThreadPool(size_t numThreads) {\n    return POOL_create (numThreads, 0);\n}\n\nPOOL_ctx* POOL_create(size_t numThreads, size_t queueSize) {\n    return POOL_create_advanced(numThreads, queueSize, ZSTD_defaultCMem);\n}\n\nPOOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize,\n                               ZSTD_customMem customMem)\n{\n    POOL_ctx* ctx;\n    /* Check parameters */\n    if (!numThreads) { return NULL; }\n    /* Allocate the context and zero initialize */\n    ctx = (POOL_ctx*)ZSTD_customCalloc(sizeof(POOL_ctx), customMem);\n    if (!ctx) { return NULL; }\n    /* Initialize the job queue.\n     * It needs one extra space since one space is wasted to differentiate\n     * empty and full queues.\n     */\n    ctx->queueSize = queueSize + 1;\n    ctx->queue = (POOL_job*)ZSTD_customCalloc(ctx->queueSize * sizeof(POOL_job), customMem);\n    ctx->queueHead = 0;\n    ctx->queueTail = 0;\n    ctx->numThreadsBusy = 0;\n    ctx->queueEmpty = 1;\n    {\n        int error = 0;\n        error |= ZSTD_pthread_mutex_init(&ctx->queueMutex, NULL);\n        error |= ZSTD_pthread_cond_init(&ctx->queuePushCond, NULL);\n        error |= ZSTD_pthread_cond_init(&ctx->queuePopCond, NULL);\n        if (error) { POOL_free(ctx); return NULL; }\n    }\n    ctx->shutdown = 0;\n    /* Allocate space for the thread handles */\n    ctx->threads = (ZSTD_pthread_t*)ZSTD_customCalloc(numThreads * sizeof(ZSTD_pthread_t), customMem);\n    ctx->threadCapacity = 0;\n    ctx->threadLimit = numThreads;\n    ctx->customMem = customMem;\n    /* Check for errors */\n    if (!ctx->threads || !ctx->queue) { POOL_free(ctx); return NULL; }\n    /* Initialize the threads */\n    while (ctx->threadCapacity < numThreads) {\n        if (ZSTD_pthread_create(&ctx->threads[ctx->threadCapacity++], NULL, &POOL_thread, ctx)) {\n            --ctx->threadCapacity;\n            POOL_free(ctx);\n            return NULL;\n        }\n    }\n    return ctx;\n}\n\n/*! POOL_join() :\n    Shutdown the queue, wake any sleeping threads, and join all of the threads.\n*/\nstatic void POOL_join(POOL_ctx* ctx) {\n    /* Shut down the queue */\n    ZSTD_pthread_mutex_lock(&ctx->queueMutex);\n    ctx->shutdown = 1;\n    ZSTD_pthread_mutex_unlock(&ctx->queueMutex);\n    /* Wake up sleeping threads */\n    ZSTD_pthread_cond_broadcast(&ctx->queuePushCond);\n    ZSTD_pthread_cond_broadcast(&ctx->queuePopCond);\n    /* Join all of the threads */\n    {   size_t i;\n        for (i = 0; i < ctx->threadCapacity; ++i) {\n            ZSTD_pthread_join(ctx->threads[i]);  /* note : could fail */\n    }   }\n}\n\nvoid POOL_free(POOL_ctx *ctx) {\n    if (!ctx) { return; }\n    POOL_join(ctx);\n    ZSTD_pthread_mutex_destroy(&ctx->queueMutex);\n    ZSTD_pthread_cond_destroy(&ctx->queuePushCond);\n    ZSTD_pthread_cond_destroy(&ctx->queuePopCond);\n    ZSTD_customFree(ctx->queue, ctx->customMem);\n    ZSTD_customFree(ctx->threads, ctx->customMem);\n    ZSTD_customFree(ctx, ctx->customMem);\n}\n\n/*! POOL_joinJobs() :\n *  Waits for all queued jobs to finish executing.\n */\nvoid POOL_joinJobs(POOL_ctx* ctx) {\n    ZSTD_pthread_mutex_lock(&ctx->queueMutex);\n    while(!ctx->queueEmpty || ctx->numThreadsBusy > 0) {\n        ZSTD_pthread_cond_wait(&ctx->queuePushCond, &ctx->queueMutex);\n    }\n    ZSTD_pthread_mutex_unlock(&ctx->queueMutex);\n}\n\nvoid ZSTD_freeThreadPool (ZSTD_threadPool* pool) {\n  POOL_free (pool);\n}\n\nsize_t POOL_sizeof(const POOL_ctx* ctx) {\n    if (ctx==NULL) return 0;  /* supports sizeof NULL */\n    return sizeof(*ctx)\n        + ctx->queueSize * sizeof(POOL_job)\n        + ctx->threadCapacity * sizeof(ZSTD_pthread_t);\n}\n\n\n/* @return : 0 on success, 1 on error */\nstatic int POOL_resize_internal(POOL_ctx* ctx, size_t numThreads)\n{\n    if (numThreads <= ctx->threadCapacity) {\n        if (!numThreads) return 1;\n        ctx->threadLimit = numThreads;\n        return 0;\n    }\n    /* numThreads > threadCapacity */\n    ctx->threadLimit = numThreads;\n    {   ZSTD_pthread_t* const threadPool = (ZSTD_pthread_t*)ZSTD_customCalloc(numThreads * sizeof(ZSTD_pthread_t), ctx->customMem);\n        if (!threadPool) return 1;\n        /* extend existing thread pool */\n        ZSTD_memcpy(threadPool, ctx->threads, ctx->threadCapacity * sizeof(ZSTD_pthread_t));\n        ZSTD_customFree(ctx->threads, ctx->customMem);\n        ctx->threads = threadPool;\n        /* Initialize additional threads */\n        while (ctx->threadCapacity < numThreads) {\n            if (ZSTD_pthread_create(&threadPool[ctx->threadCapacity++], NULL, &POOL_thread, ctx)) {\n                --ctx->threadCapacity;\n                return 1;\n            }\n        }\n    }\n    /* successfully expanded */\n    return 0;\n}\n\n/* @return : 0 on success, 1 on error */\nint POOL_resize(POOL_ctx* ctx, size_t numThreads)\n{\n    int result;\n    if (ctx==NULL) return 1;\n    ZSTD_pthread_mutex_lock(&ctx->queueMutex);\n    result = POOL_resize_internal(ctx, numThreads);\n    ZSTD_pthread_cond_broadcast(&ctx->queuePopCond);\n    ZSTD_pthread_mutex_unlock(&ctx->queueMutex);\n    return result;\n}\n\n/**\n * Returns 1 if the queue is full and 0 otherwise.\n *\n * When queueSize is 1 (pool was created with an intended queueSize of 0),\n * then a queue is empty if there is a thread free _and_ no job is waiting.\n */\nstatic int isQueueFull(POOL_ctx const* ctx) {\n    if (ctx->queueSize > 1) {\n        return ctx->queueHead == ((ctx->queueTail + 1) % ctx->queueSize);\n    } else {\n        return (ctx->numThreadsBusy == ctx->threadLimit) ||\n               !ctx->queueEmpty;\n    }\n}\n\n\nstatic void\nPOOL_add_internal(POOL_ctx* ctx, POOL_function function, void *opaque)\n{\n    POOL_job job;\n    job.function = function;\n    job.opaque = opaque;\n    assert(ctx != NULL);\n    if (ctx->shutdown) return;\n\n    ctx->queueEmpty = 0;\n    ctx->queue[ctx->queueTail] = job;\n    ctx->queueTail = (ctx->queueTail + 1) % ctx->queueSize;\n    ZSTD_pthread_cond_signal(&ctx->queuePopCond);\n}\n\nvoid POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque)\n{\n    assert(ctx != NULL);\n    ZSTD_pthread_mutex_lock(&ctx->queueMutex);\n    /* Wait until there is space in the queue for the new job */\n    while (isQueueFull(ctx) && (!ctx->shutdown)) {\n        ZSTD_pthread_cond_wait(&ctx->queuePushCond, &ctx->queueMutex);\n    }\n    POOL_add_internal(ctx, function, opaque);\n    ZSTD_pthread_mutex_unlock(&ctx->queueMutex);\n}\n\n\nint POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque)\n{\n    assert(ctx != NULL);\n    ZSTD_pthread_mutex_lock(&ctx->queueMutex);\n    if (isQueueFull(ctx)) {\n        ZSTD_pthread_mutex_unlock(&ctx->queueMutex);\n        return 0;\n    }\n    POOL_add_internal(ctx, function, opaque);\n    ZSTD_pthread_mutex_unlock(&ctx->queueMutex);\n    return 1;\n}\n\n\n#else  /* ZSTD_MULTITHREAD  not defined */\n\n/* ========================== */\n/* No multi-threading support */\n/* ========================== */\n\n\n/* We don't need any data, but if it is empty, malloc() might return NULL. */\nstruct POOL_ctx_s {\n    int dummy;\n};\nstatic POOL_ctx g_poolCtx;\n\nPOOL_ctx* POOL_create(size_t numThreads, size_t queueSize) {\n    return POOL_create_advanced(numThreads, queueSize, ZSTD_defaultCMem);\n}\n\nPOOL_ctx*\nPOOL_create_advanced(size_t numThreads, size_t queueSize, ZSTD_customMem customMem)\n{\n    (void)numThreads;\n    (void)queueSize;\n    (void)customMem;\n    return &g_poolCtx;\n}\n\nvoid POOL_free(POOL_ctx* ctx) {\n    assert(!ctx || ctx == &g_poolCtx);\n    (void)ctx;\n}\n\nvoid POOL_joinJobs(POOL_ctx* ctx){\n    assert(!ctx || ctx == &g_poolCtx);\n    (void)ctx;\n}\n\nint POOL_resize(POOL_ctx* ctx, size_t numThreads) {\n    (void)ctx; (void)numThreads;\n    return 0;\n}\n\nvoid POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque) {\n    (void)ctx;\n    function(opaque);\n}\n\nint POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque) {\n    (void)ctx;\n    function(opaque);\n    return 1;\n}\n\nsize_t POOL_sizeof(const POOL_ctx* ctx) {\n    if (ctx==NULL) return 0;  /* supports sizeof NULL */\n    assert(ctx == &g_poolCtx);\n    return sizeof(*ctx);\n}\n\n#endif  /* ZSTD_MULTITHREAD */\n"
  },
  {
    "path": "lib/common/pool.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef POOL_H\n#define POOL_H\n\n\n#include \"zstd_deps.h\"\n#define ZSTD_STATIC_LINKING_ONLY   /* ZSTD_customMem */\n#include \"../zstd.h\"\n\ntypedef struct POOL_ctx_s POOL_ctx;\n\n/*! POOL_create() :\n *  Create a thread pool with at most `numThreads` threads.\n * `numThreads` must be at least 1.\n *  The maximum number of queued jobs before blocking is `queueSize`.\n * @return : POOL_ctx pointer on success, else NULL.\n*/\nPOOL_ctx* POOL_create(size_t numThreads, size_t queueSize);\n\nPOOL_ctx* POOL_create_advanced(size_t numThreads, size_t queueSize,\n                               ZSTD_customMem customMem);\n\n/*! POOL_free() :\n *  Free a thread pool returned by POOL_create().\n */\nvoid POOL_free(POOL_ctx* ctx);\n\n\n/*! POOL_joinJobs() :\n *  Waits for all queued jobs to finish executing.\n */\nvoid POOL_joinJobs(POOL_ctx* ctx);\n\n/*! POOL_resize() :\n *  Expands or shrinks pool's number of threads.\n *  This is more efficient than releasing + creating a new context,\n *  since it tries to preserve and reuse existing threads.\n * `numThreads` must be at least 1.\n * @return : 0 when resize was successful,\n *           !0 (typically 1) if there is an error.\n *    note : only numThreads can be resized, queueSize remains unchanged.\n */\nint POOL_resize(POOL_ctx* ctx, size_t numThreads);\n\n/*! POOL_sizeof() :\n * @return threadpool memory usage\n *  note : compatible with NULL (returns 0 in this case)\n */\nsize_t POOL_sizeof(const POOL_ctx* ctx);\n\n/*! POOL_function :\n *  The function type that can be added to a thread pool.\n */\ntypedef void (*POOL_function)(void*);\n\n/*! POOL_add() :\n *  Add the job `function(opaque)` to the thread pool. `ctx` must be valid.\n *  Possibly blocks until there is room in the queue.\n *  Note : The function may be executed asynchronously,\n *         therefore, `opaque` must live until function has been completed.\n */\nvoid POOL_add(POOL_ctx* ctx, POOL_function function, void* opaque);\n\n\n/*! POOL_tryAdd() :\n *  Add the job `function(opaque)` to thread pool _if_ a queue slot is available.\n *  Returns immediately even if not (does not block).\n * @return : 1 if successful, 0 if not.\n */\nint POOL_tryAdd(POOL_ctx* ctx, POOL_function function, void* opaque);\n\n#endif\n"
  },
  {
    "path": "lib/common/portability_macros.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_PORTABILITY_MACROS_H\n#define ZSTD_PORTABILITY_MACROS_H\n\n/**\n * This header file contains macro definitions to support portability.\n * This header is shared between C and ASM code, so it MUST only\n * contain macro definitions. It MUST not contain any C code.\n *\n * This header ONLY defines macros to detect platforms/feature support.\n *\n */\n\n\n/* compat. with non-clang compilers */\n#ifndef __has_attribute\n  #define __has_attribute(x) 0\n#endif\n\n/* compat. with non-clang compilers */\n#ifndef __has_builtin\n#  define __has_builtin(x) 0\n#endif\n\n/* compat. with non-clang compilers */\n#ifndef __has_feature\n#  define __has_feature(x) 0\n#endif\n\n/* detects whether we are being compiled under msan */\n#ifndef ZSTD_MEMORY_SANITIZER\n#  if __has_feature(memory_sanitizer)\n#    define ZSTD_MEMORY_SANITIZER 1\n#  else\n#    define ZSTD_MEMORY_SANITIZER 0\n#  endif\n#endif\n\n/* detects whether we are being compiled under asan */\n#ifndef ZSTD_ADDRESS_SANITIZER\n#  if __has_feature(address_sanitizer)\n#    define ZSTD_ADDRESS_SANITIZER 1\n#  elif defined(__SANITIZE_ADDRESS__)\n#    define ZSTD_ADDRESS_SANITIZER 1\n#  else\n#    define ZSTD_ADDRESS_SANITIZER 0\n#  endif\n#endif\n\n/* detects whether we are being compiled under dfsan */\n#ifndef ZSTD_DATAFLOW_SANITIZER\n# if __has_feature(dataflow_sanitizer)\n#  define ZSTD_DATAFLOW_SANITIZER 1\n# else\n#  define ZSTD_DATAFLOW_SANITIZER 0\n# endif\n#endif\n\n/* Mark the internal assembly functions as hidden  */\n#ifdef __ELF__\n# define ZSTD_HIDE_ASM_FUNCTION(func) .hidden func\n#elif defined(__APPLE__)\n# define ZSTD_HIDE_ASM_FUNCTION(func) .private_extern func\n#else\n# define ZSTD_HIDE_ASM_FUNCTION(func)\n#endif\n\n/* Compile time determination of BMI2 support */\n#ifndef STATIC_BMI2\n#  if defined(__BMI2__)\n#    define STATIC_BMI2 1\n#  elif defined(_MSC_VER) && defined(__AVX2__)\n#    define STATIC_BMI2 1 /* MSVC does not have a BMI2 specific flag, but every CPU that supports AVX2 also supports BMI2 */\n#  endif\n#endif\n\n#ifndef STATIC_BMI2\n#  define STATIC_BMI2 0\n#endif\n\n/* Enable runtime BMI2 dispatch based on the CPU.\n * Enabled for clang & gcc >=4.8 on x86 when BMI2 isn't enabled by default.\n */\n#ifndef DYNAMIC_BMI2\n#  if ((defined(__clang__) && __has_attribute(__target__)) \\\n      || (defined(__GNUC__) \\\n          && (__GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))) \\\n      && (defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64)) \\\n      && !defined(__BMI2__)\n#    define DYNAMIC_BMI2 1\n#  else\n#    define DYNAMIC_BMI2 0\n#  endif\n#endif\n\n/**\n * Only enable assembly for GNU C compatible compilers,\n * because other platforms may not support GAS assembly syntax.\n *\n * Only enable assembly for Linux / MacOS / Win32, other platforms may\n * work, but they haven't been tested. This could likely be\n * extended to BSD systems.\n *\n * Disable assembly when MSAN is enabled, because MSAN requires\n * 100% of code to be instrumented to work.\n */\n#if defined(__GNUC__)\n#  if defined(__linux__) || defined(__linux) || defined(__APPLE__) || defined(_WIN32)\n#    if ZSTD_MEMORY_SANITIZER\n#      define ZSTD_ASM_SUPPORTED 0\n#    elif ZSTD_DATAFLOW_SANITIZER\n#      define ZSTD_ASM_SUPPORTED 0\n#    else\n#      define ZSTD_ASM_SUPPORTED 1\n#    endif\n#  else\n#    define ZSTD_ASM_SUPPORTED 0\n#  endif\n#else\n#  define ZSTD_ASM_SUPPORTED 0\n#endif\n\n/**\n * Determines whether we should enable assembly for x86-64\n * with BMI2.\n *\n * Enable if all of the following conditions hold:\n * - ASM hasn't been explicitly disabled by defining ZSTD_DISABLE_ASM\n * - Assembly is supported\n * - We are compiling for x86-64 and either:\n *   - DYNAMIC_BMI2 is enabled\n *   - BMI2 is supported at compile time\n */\n#if !defined(ZSTD_DISABLE_ASM) &&                                 \\\n    ZSTD_ASM_SUPPORTED &&                                         \\\n    defined(__x86_64__) &&                                        \\\n    (DYNAMIC_BMI2 || defined(__BMI2__))\n# define ZSTD_ENABLE_ASM_X86_64_BMI2 1\n#else\n# define ZSTD_ENABLE_ASM_X86_64_BMI2 0\n#endif\n\n/*\n * For x86 ELF targets, add .note.gnu.property section for Intel CET in\n * assembly sources when CET is enabled.\n *\n * Additionally, any function that may be called indirectly must begin\n * with ZSTD_CET_ENDBRANCH.\n */\n#if defined(__ELF__) && (defined(__x86_64__) || defined(__i386__)) \\\n    && defined(__has_include)\n# if __has_include()\n#  include \n#  define ZSTD_CET_ENDBRANCH _CET_ENDBR\n# endif\n#endif\n\n#ifndef ZSTD_CET_ENDBRANCH\n# define ZSTD_CET_ENDBRANCH\n#endif\n\n/**\n * ZSTD_IS_DETERMINISTIC_BUILD must be set to 0 if any compilation macro is\n * active that impacts the compressed output.\n *\n * NOTE: ZSTD_MULTITHREAD is allowed to be set or unset.\n */\n#if defined(ZSTD_CLEVEL_DEFAULT) \\\n    || defined(ZSTD_EXCLUDE_DFAST_BLOCK_COMPRESSOR) \\\n    || defined(ZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR) \\\n    || defined(ZSTD_EXCLUDE_LAZY_BLOCK_COMPRESSOR) \\\n    || defined(ZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR) \\\n    || defined(ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR) \\\n    || defined(ZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR) \\\n    || defined(ZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR)\n# define ZSTD_IS_DETERMINISTIC_BUILD 0\n#else\n# define ZSTD_IS_DETERMINISTIC_BUILD 1\n#endif\n\n#endif /* ZSTD_PORTABILITY_MACROS_H */\n"
  },
  {
    "path": "lib/common/threading.c",
    "content": "/**\n * Copyright (c) 2016 Tino Reichardt\n * All rights reserved.\n *\n * You can contact the author at:\n * - zstdmt source repository: https://github.com/mcmilk/zstdmt\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/**\n * This file will hold wrapper for systems, which do not support pthreads\n */\n\n#include \"threading.h\"\n\n/* create fake symbol to avoid empty translation unit warning */\nint g_ZSTD_threading_useless_symbol;\n\n#if defined(ZSTD_MULTITHREAD) && defined(_WIN32)\n\n/**\n * Windows minimalist Pthread Wrapper\n */\n\n\n/* ===  Dependencies  === */\n#include \n#include \n\n\n/* ===  Implementation  === */\n\ntypedef struct {\n    void* (*start_routine)(void*);\n    void* arg;\n    int initialized;\n    ZSTD_pthread_cond_t initialized_cond;\n    ZSTD_pthread_mutex_t initialized_mutex;\n} ZSTD_thread_params_t;\n\nstatic unsigned __stdcall worker(void *arg)\n{\n    void* (*start_routine)(void*);\n    void* thread_arg;\n\n    /* Initialized thread_arg and start_routine and signal main thread that we don't need it\n     * to wait any longer.\n     */\n    {\n        ZSTD_thread_params_t*  thread_param = (ZSTD_thread_params_t*)arg;\n        thread_arg = thread_param->arg;\n        start_routine = thread_param->start_routine;\n\n        /* Signal main thread that we are running and do not depend on its memory anymore */\n        ZSTD_pthread_mutex_lock(&thread_param->initialized_mutex);\n        thread_param->initialized = 1;\n        ZSTD_pthread_cond_signal(&thread_param->initialized_cond);\n        ZSTD_pthread_mutex_unlock(&thread_param->initialized_mutex);\n    }\n\n    start_routine(thread_arg);\n\n    return 0;\n}\n\nint ZSTD_pthread_create(ZSTD_pthread_t* thread, const void* unused,\n            void* (*start_routine) (void*), void* arg)\n{\n    ZSTD_thread_params_t thread_param;\n    (void)unused;\n\n    if (thread==NULL) return -1;\n    *thread = NULL;\n\n    thread_param.start_routine = start_routine;\n    thread_param.arg = arg;\n    thread_param.initialized = 0;\n\n    /* Setup thread initialization synchronization */\n    if(ZSTD_pthread_cond_init(&thread_param.initialized_cond, NULL)) {\n        /* Should never happen on Windows */\n        return -1;\n    }\n    if(ZSTD_pthread_mutex_init(&thread_param.initialized_mutex, NULL)) {\n        /* Should never happen on Windows */\n        ZSTD_pthread_cond_destroy(&thread_param.initialized_cond);\n        return -1;\n    }\n\n    /* Spawn thread */\n    *thread = (HANDLE)_beginthreadex(NULL, 0, worker, &thread_param, 0, NULL);\n    if (*thread==NULL) {\n        ZSTD_pthread_mutex_destroy(&thread_param.initialized_mutex);\n        ZSTD_pthread_cond_destroy(&thread_param.initialized_cond);\n        return errno;\n    }\n\n    /* Wait for thread to be initialized */\n    ZSTD_pthread_mutex_lock(&thread_param.initialized_mutex);\n    while(!thread_param.initialized) {\n        ZSTD_pthread_cond_wait(&thread_param.initialized_cond, &thread_param.initialized_mutex);\n    }\n    ZSTD_pthread_mutex_unlock(&thread_param.initialized_mutex);\n    ZSTD_pthread_mutex_destroy(&thread_param.initialized_mutex);\n    ZSTD_pthread_cond_destroy(&thread_param.initialized_cond);\n\n    return 0;\n}\n\nint ZSTD_pthread_join(ZSTD_pthread_t thread)\n{\n    DWORD result;\n\n    if (!thread) return 0;\n\n    result = WaitForSingleObject(thread, INFINITE);\n    CloseHandle(thread);\n\n    switch (result) {\n    case WAIT_OBJECT_0:\n        return 0;\n    case WAIT_ABANDONED:\n        return EINVAL;\n    default:\n        return GetLastError();\n    }\n}\n\n#endif   /* ZSTD_MULTITHREAD */\n\n#if defined(ZSTD_MULTITHREAD) && DEBUGLEVEL >= 1 && !defined(_WIN32)\n\n#define ZSTD_DEPS_NEED_MALLOC\n#include \"zstd_deps.h\"\n\nint ZSTD_pthread_mutex_init(ZSTD_pthread_mutex_t* mutex, pthread_mutexattr_t const* attr)\n{\n    assert(mutex != NULL);\n    *mutex = (pthread_mutex_t*)ZSTD_malloc(sizeof(pthread_mutex_t));\n    if (!*mutex)\n        return 1;\n    {\n        int const ret = pthread_mutex_init(*mutex, attr);\n        if (ret != 0) {\n            ZSTD_free(*mutex);\n            *mutex = NULL;\n        }\n        return ret;\n    }\n}\n\nint ZSTD_pthread_mutex_destroy(ZSTD_pthread_mutex_t* mutex)\n{\n    assert(mutex != NULL);\n    if (!*mutex)\n        return 0;\n    {\n        int const ret = pthread_mutex_destroy(*mutex);\n        ZSTD_free(*mutex);\n        return ret;\n    }\n}\n\nint ZSTD_pthread_cond_init(ZSTD_pthread_cond_t* cond, pthread_condattr_t const* attr)\n{\n    assert(cond != NULL);\n    *cond = (pthread_cond_t*)ZSTD_malloc(sizeof(pthread_cond_t));\n    if (!*cond)\n        return 1;\n    {\n        int const ret = pthread_cond_init(*cond, attr);\n        if (ret != 0) {\n            ZSTD_free(*cond);\n            *cond = NULL;\n        }\n        return ret;\n    }\n}\n\nint ZSTD_pthread_cond_destroy(ZSTD_pthread_cond_t* cond)\n{\n    assert(cond != NULL);\n    if (!*cond)\n        return 0;\n    {\n        int const ret = pthread_cond_destroy(*cond);\n        ZSTD_free(*cond);\n        return ret;\n    }\n}\n\n#endif\n"
  },
  {
    "path": "lib/common/threading.h",
    "content": "/**\n * Copyright (c) 2016 Tino Reichardt\n * All rights reserved.\n *\n * You can contact the author at:\n * - zstdmt source repository: https://github.com/mcmilk/zstdmt\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef THREADING_H_938743\n#define THREADING_H_938743\n\n#include \"debug.h\"\n\n#if defined(ZSTD_MULTITHREAD) && defined(_WIN32)\n\n/**\n * Windows minimalist Pthread Wrapper\n */\n#ifdef WINVER\n#  undef WINVER\n#endif\n#define WINVER       0x0600\n\n#ifdef _WIN32_WINNT\n#  undef _WIN32_WINNT\n#endif\n#define _WIN32_WINNT 0x0600\n\n#ifndef WIN32_LEAN_AND_MEAN\n#  define WIN32_LEAN_AND_MEAN\n#endif\n\n#undef ERROR   /* reported already defined on VS 2015 (Rich Geldreich) */\n#include \n#undef ERROR\n#define ERROR(name) ZSTD_ERROR(name)\n\n\n/* mutex */\n#define ZSTD_pthread_mutex_t           CRITICAL_SECTION\n#define ZSTD_pthread_mutex_init(a, b)  ((void)(b), InitializeCriticalSection((a)), 0)\n#define ZSTD_pthread_mutex_destroy(a)  DeleteCriticalSection((a))\n#define ZSTD_pthread_mutex_lock(a)     EnterCriticalSection((a))\n#define ZSTD_pthread_mutex_unlock(a)   LeaveCriticalSection((a))\n\n/* condition variable */\n#define ZSTD_pthread_cond_t             CONDITION_VARIABLE\n#define ZSTD_pthread_cond_init(a, b)    ((void)(b), InitializeConditionVariable((a)), 0)\n#define ZSTD_pthread_cond_destroy(a)    ((void)(a))\n#define ZSTD_pthread_cond_wait(a, b)    SleepConditionVariableCS((a), (b), INFINITE)\n#define ZSTD_pthread_cond_signal(a)     WakeConditionVariable((a))\n#define ZSTD_pthread_cond_broadcast(a)  WakeAllConditionVariable((a))\n\n/* ZSTD_pthread_create() and ZSTD_pthread_join() */\ntypedef HANDLE ZSTD_pthread_t;\n\nint ZSTD_pthread_create(ZSTD_pthread_t* thread, const void* unused,\n                   void* (*start_routine) (void*), void* arg);\n\nint ZSTD_pthread_join(ZSTD_pthread_t thread);\n\n/**\n * add here more wrappers as required\n */\n\n#elif defined(ZSTD_MULTITHREAD)    /* posix assumed ; need a better detection method */\n/* ===   POSIX Systems   === */\n#  include \n\n#if DEBUGLEVEL < 1\n\n#define ZSTD_pthread_mutex_t            pthread_mutex_t\n#define ZSTD_pthread_mutex_init(a, b)   pthread_mutex_init((a), (b))\n#define ZSTD_pthread_mutex_destroy(a)   pthread_mutex_destroy((a))\n#define ZSTD_pthread_mutex_lock(a)      pthread_mutex_lock((a))\n#define ZSTD_pthread_mutex_unlock(a)    pthread_mutex_unlock((a))\n\n#define ZSTD_pthread_cond_t             pthread_cond_t\n#define ZSTD_pthread_cond_init(a, b)    pthread_cond_init((a), (b))\n#define ZSTD_pthread_cond_destroy(a)    pthread_cond_destroy((a))\n#define ZSTD_pthread_cond_wait(a, b)    pthread_cond_wait((a), (b))\n#define ZSTD_pthread_cond_signal(a)     pthread_cond_signal((a))\n#define ZSTD_pthread_cond_broadcast(a)  pthread_cond_broadcast((a))\n\n#define ZSTD_pthread_t                  pthread_t\n#define ZSTD_pthread_create(a, b, c, d) pthread_create((a), (b), (c), (d))\n#define ZSTD_pthread_join(a)         pthread_join((a),NULL)\n\n#else /* DEBUGLEVEL >= 1 */\n\n/* Debug implementation of threading.\n * In this implementation we use pointers for mutexes and condition variables.\n * This way, if we forget to init/destroy them the program will crash or ASAN\n * will report leaks.\n */\n\n#define ZSTD_pthread_mutex_t            pthread_mutex_t*\nint ZSTD_pthread_mutex_init(ZSTD_pthread_mutex_t* mutex, pthread_mutexattr_t const* attr);\nint ZSTD_pthread_mutex_destroy(ZSTD_pthread_mutex_t* mutex);\n#define ZSTD_pthread_mutex_lock(a)      pthread_mutex_lock(*(a))\n#define ZSTD_pthread_mutex_unlock(a)    pthread_mutex_unlock(*(a))\n\n#define ZSTD_pthread_cond_t             pthread_cond_t*\nint ZSTD_pthread_cond_init(ZSTD_pthread_cond_t* cond, pthread_condattr_t const* attr);\nint ZSTD_pthread_cond_destroy(ZSTD_pthread_cond_t* cond);\n#define ZSTD_pthread_cond_wait(a, b)    pthread_cond_wait(*(a), *(b))\n#define ZSTD_pthread_cond_signal(a)     pthread_cond_signal(*(a))\n#define ZSTD_pthread_cond_broadcast(a)  pthread_cond_broadcast(*(a))\n\n#define ZSTD_pthread_t                  pthread_t\n#define ZSTD_pthread_create(a, b, c, d) pthread_create((a), (b), (c), (d))\n#define ZSTD_pthread_join(a)         pthread_join((a),NULL)\n\n#endif\n\n#else  /* ZSTD_MULTITHREAD not defined */\n/* No multithreading support */\n\ntypedef int ZSTD_pthread_mutex_t;\n#define ZSTD_pthread_mutex_init(a, b)   ((void)(a), (void)(b), 0)\n#define ZSTD_pthread_mutex_destroy(a)   ((void)(a))\n#define ZSTD_pthread_mutex_lock(a)      ((void)(a))\n#define ZSTD_pthread_mutex_unlock(a)    ((void)(a))\n\ntypedef int ZSTD_pthread_cond_t;\n#define ZSTD_pthread_cond_init(a, b)    ((void)(a), (void)(b), 0)\n#define ZSTD_pthread_cond_destroy(a)    ((void)(a))\n#define ZSTD_pthread_cond_wait(a, b)    ((void)(a), (void)(b))\n#define ZSTD_pthread_cond_signal(a)     ((void)(a))\n#define ZSTD_pthread_cond_broadcast(a)  ((void)(a))\n\n/* do not use ZSTD_pthread_t */\n\n#endif /* ZSTD_MULTITHREAD */\n\n\n#endif /* THREADING_H_938743 */\n"
  },
  {
    "path": "lib/common/xxhash.c",
    "content": "/*\n * xxHash - Extremely Fast Hash algorithm\n * Copyright (c) Yann Collet - Meta Platforms, Inc\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/*\n * xxhash.c instantiates functions defined in xxhash.h\n */\n\n#define XXH_STATIC_LINKING_ONLY /* access advanced declarations */\n#define XXH_IMPLEMENTATION      /* access definitions */\n\n#include \"xxhash.h\"\n"
  },
  {
    "path": "lib/common/xxhash.h",
    "content": "/*\n * xxHash - Extremely Fast Hash algorithm\n * Header File\n * Copyright (c) Yann Collet - Meta Platforms, Inc\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/* Local adaptations for Zstandard */\n\n#ifndef XXH_NO_XXH3\n# define XXH_NO_XXH3\n#endif\n\n#ifndef XXH_NAMESPACE\n# define XXH_NAMESPACE ZSTD_\n#endif\n\n/*!\n * @mainpage xxHash\n *\n * xxHash is an extremely fast non-cryptographic hash algorithm, working at RAM speed\n * limits.\n *\n * It is proposed in four flavors, in three families:\n * 1. @ref XXH32_family\n *   - Classic 32-bit hash function. Simple, compact, and runs on almost all\n *     32-bit and 64-bit systems.\n * 2. @ref XXH64_family\n *   - Classic 64-bit adaptation of XXH32. Just as simple, and runs well on most\n *     64-bit systems (but _not_ 32-bit systems).\n * 3. @ref XXH3_family\n *   - Modern 64-bit and 128-bit hash function family which features improved\n *     strength and performance across the board, especially on smaller data.\n *     It benefits greatly from SIMD and 64-bit without requiring it.\n *\n * Benchmarks\n * ---\n * The reference system uses an Intel i7-9700K CPU, and runs Ubuntu x64 20.04.\n * The open source benchmark program is compiled with clang v10.0 using -O3 flag.\n *\n * | Hash Name            | ISA ext | Width | Large Data Speed | Small Data Velocity |\n * | -------------------- | ------- | ----: | ---------------: | ------------------: |\n * | XXH3_64bits()        | @b AVX2 |    64 |        59.4 GB/s |               133.1 |\n * | MeowHash             | AES-NI  |   128 |        58.2 GB/s |                52.5 |\n * | XXH3_128bits()       | @b AVX2 |   128 |        57.9 GB/s |               118.1 |\n * | CLHash               | PCLMUL  |    64 |        37.1 GB/s |                58.1 |\n * | XXH3_64bits()        | @b SSE2 |    64 |        31.5 GB/s |               133.1 |\n * | XXH3_128bits()       | @b SSE2 |   128 |        29.6 GB/s |               118.1 |\n * | RAM sequential read  |         |   N/A |        28.0 GB/s |                 N/A |\n * | ahash                | AES-NI  |    64 |        22.5 GB/s |               107.2 |\n * | City64               |         |    64 |        22.0 GB/s |                76.6 |\n * | T1ha2                |         |    64 |        22.0 GB/s |                99.0 |\n * | City128              |         |   128 |        21.7 GB/s |                57.7 |\n * | FarmHash             | AES-NI  |    64 |        21.3 GB/s |                71.9 |\n * | XXH64()              |         |    64 |        19.4 GB/s |                71.0 |\n * | SpookyHash           |         |    64 |        19.3 GB/s |                53.2 |\n * | Mum                  |         |    64 |        18.0 GB/s |                67.0 |\n * | CRC32C               | SSE4.2  |    32 |        13.0 GB/s |                57.9 |\n * | XXH32()              |         |    32 |         9.7 GB/s |                71.9 |\n * | City32               |         |    32 |         9.1 GB/s |                66.0 |\n * | Blake3*              | @b AVX2 |   256 |         4.4 GB/s |                 8.1 |\n * | Murmur3              |         |    32 |         3.9 GB/s |                56.1 |\n * | SipHash*             |         |    64 |         3.0 GB/s |                43.2 |\n * | Blake3*              | @b SSE2 |   256 |         2.4 GB/s |                 8.1 |\n * | HighwayHash          |         |    64 |         1.4 GB/s |                 6.0 |\n * | FNV64                |         |    64 |         1.2 GB/s |                62.7 |\n * | Blake2*              |         |   256 |         1.1 GB/s |                 5.1 |\n * | SHA1*                |         |   160 |         0.8 GB/s |                 5.6 |\n * | MD5*                 |         |   128 |         0.6 GB/s |                 7.8 |\n * @note\n *   - Hashes which require a specific ISA extension are noted. SSE2 is also noted,\n *     even though it is mandatory on x64.\n *   - Hashes with an asterisk are cryptographic. Note that MD5 is non-cryptographic\n *     by modern standards.\n *   - Small data velocity is a rough average of algorithm's efficiency for small\n *     data. For more accurate information, see the wiki.\n *   - More benchmarks and strength tests are found on the wiki:\n *         https://github.com/Cyan4973/xxHash/wiki\n *\n * Usage\n * ------\n * All xxHash variants use a similar API. Changing the algorithm is a trivial\n * substitution.\n *\n * @pre\n *    For functions which take an input and length parameter, the following\n *    requirements are assumed:\n *    - The range from [`input`, `input + length`) is valid, readable memory.\n *      - The only exception is if the `length` is `0`, `input` may be `NULL`.\n *    - For C++, the objects must have the *TriviallyCopyable* property, as the\n *      functions access bytes directly as if it was an array of `unsigned char`.\n *\n * @anchor single_shot_example\n * **Single Shot**\n *\n * These functions are stateless functions which hash a contiguous block of memory,\n * immediately returning the result. They are the easiest and usually the fastest\n * option.\n *\n * XXH32(), XXH64(), XXH3_64bits(), XXH3_128bits()\n *\n * @code{.c}\n *   #include \n *   #include \"xxhash.h\"\n *\n *   // Example for a function which hashes a null terminated string with XXH32().\n *   XXH32_hash_t hash_string(const char* string, XXH32_hash_t seed)\n *   {\n *       // NULL pointers are only valid if the length is zero\n *       size_t length = (string == NULL) ? 0 : strlen(string);\n *       return XXH32(string, length, seed);\n *   }\n * @endcode\n *\n *\n * @anchor streaming_example\n * **Streaming**\n *\n * These groups of functions allow incremental hashing of unknown size, even\n * more than what would fit in a size_t.\n *\n * XXH32_reset(), XXH64_reset(), XXH3_64bits_reset(), XXH3_128bits_reset()\n *\n * @code{.c}\n *   #include \n *   #include \n *   #include \"xxhash.h\"\n *   // Example for a function which hashes a FILE incrementally with XXH3_64bits().\n *   XXH64_hash_t hashFile(FILE* f)\n *   {\n *       // Allocate a state struct. Do not just use malloc() or new.\n *       XXH3_state_t* state = XXH3_createState();\n *       assert(state != NULL && \"Out of memory!\");\n *       // Reset the state to start a new hashing session.\n *       XXH3_64bits_reset(state);\n *       char buffer[4096];\n *       size_t count;\n *       // Read the file in chunks\n *       while ((count = fread(buffer, 1, sizeof(buffer), f)) != 0) {\n *           // Run update() as many times as necessary to process the data\n *           XXH3_64bits_update(state, buffer, count);\n *       }\n *       // Retrieve the finalized hash. This will not change the state.\n *       XXH64_hash_t result = XXH3_64bits_digest(state);\n *       // Free the state. Do not use free().\n *       XXH3_freeState(state);\n *       return result;\n *   }\n * @endcode\n *\n * Streaming functions generate the xxHash value from an incremental input.\n * This method is slower than single-call functions, due to state management.\n * For small inputs, prefer `XXH32()` and `XXH64()`, which are better optimized.\n *\n * An XXH state must first be allocated using `XXH*_createState()`.\n *\n * Start a new hash by initializing the state with a seed using `XXH*_reset()`.\n *\n * Then, feed the hash state by calling `XXH*_update()` as many times as necessary.\n *\n * The function returns an error code, with 0 meaning OK, and any other value\n * meaning there is an error.\n *\n * Finally, a hash value can be produced anytime, by using `XXH*_digest()`.\n * This function returns the nn-bits hash as an int or long long.\n *\n * It's still possible to continue inserting input into the hash state after a\n * digest, and generate new hash values later on by invoking `XXH*_digest()`.\n *\n * When done, release the state using `XXH*_freeState()`.\n *\n *\n * @anchor canonical_representation_example\n * **Canonical Representation**\n *\n * The default return values from XXH functions are unsigned 32, 64 and 128 bit\n * integers.\n * This the simplest and fastest format for further post-processing.\n *\n * However, this leaves open the question of what is the order on the byte level,\n * since little and big endian conventions will store the same number differently.\n *\n * The canonical representation settles this issue by mandating big-endian\n * convention, the same convention as human-readable numbers (large digits first).\n *\n * When writing hash values to storage, sending them over a network, or printing\n * them, it's highly recommended to use the canonical representation to ensure\n * portability across a wider range of systems, present and future.\n *\n * The following functions allow transformation of hash values to and from\n * canonical format.\n *\n * XXH32_canonicalFromHash(), XXH32_hashFromCanonical(),\n * XXH64_canonicalFromHash(), XXH64_hashFromCanonical(),\n * XXH128_canonicalFromHash(), XXH128_hashFromCanonical(),\n *\n * @code{.c}\n *   #include \n *   #include \"xxhash.h\"\n *\n *   // Example for a function which prints XXH32_hash_t in human readable format\n *   void printXxh32(XXH32_hash_t hash)\n *   {\n *       XXH32_canonical_t cano;\n *       XXH32_canonicalFromHash(&cano, hash);\n *       size_t i;\n *       for(i = 0; i < sizeof(cano.digest); ++i) {\n *           printf(\"%02x\", cano.digest[i]);\n *       }\n *       printf(\"\\n\");\n *   }\n *\n *   // Example for a function which converts XXH32_canonical_t to XXH32_hash_t\n *   XXH32_hash_t convertCanonicalToXxh32(XXH32_canonical_t cano)\n *   {\n *       XXH32_hash_t hash = XXH32_hashFromCanonical(&cano);\n *       return hash;\n *   }\n * @endcode\n *\n *\n * @file xxhash.h\n * xxHash prototypes and implementation\n */\n\n/* ****************************\n *  INLINE mode\n ******************************/\n/*!\n * @defgroup public Public API\n * Contains details on the public xxHash functions.\n * @{\n */\n#ifdef XXH_DOXYGEN\n/*!\n * @brief Gives access to internal state declaration, required for static allocation.\n *\n * Incompatible with dynamic linking, due to risks of ABI changes.\n *\n * Usage:\n * @code{.c}\n *     #define XXH_STATIC_LINKING_ONLY\n *     #include \"xxhash.h\"\n * @endcode\n */\n#  define XXH_STATIC_LINKING_ONLY\n/* Do not undef XXH_STATIC_LINKING_ONLY for Doxygen */\n\n/*!\n * @brief Gives access to internal definitions.\n *\n * Usage:\n * @code{.c}\n *     #define XXH_STATIC_LINKING_ONLY\n *     #define XXH_IMPLEMENTATION\n *     #include \"xxhash.h\"\n * @endcode\n */\n#  define XXH_IMPLEMENTATION\n/* Do not undef XXH_IMPLEMENTATION for Doxygen */\n\n/*!\n * @brief Exposes the implementation and marks all functions as `inline`.\n *\n * Use these build macros to inline xxhash into the target unit.\n * Inlining improves performance on small inputs, especially when the length is\n * expressed as a compile-time constant:\n *\n *  https://fastcompression.blogspot.com/2018/03/xxhash-for-small-keys-impressive-power.html\n *\n * It also keeps xxHash symbols private to the unit, so they are not exported.\n *\n * Usage:\n * @code{.c}\n *     #define XXH_INLINE_ALL\n *     #include \"xxhash.h\"\n * @endcode\n * Do not compile and link xxhash.o as a separate object, as it is not useful.\n */\n#  define XXH_INLINE_ALL\n#  undef XXH_INLINE_ALL\n/*!\n * @brief Exposes the implementation without marking functions as inline.\n */\n#  define XXH_PRIVATE_API\n#  undef XXH_PRIVATE_API\n/*!\n * @brief Emulate a namespace by transparently prefixing all symbols.\n *\n * If you want to include _and expose_ xxHash functions from within your own\n * library, but also want to avoid symbol collisions with other libraries which\n * may also include xxHash, you can use @ref XXH_NAMESPACE to automatically prefix\n * any public symbol from xxhash library with the value of @ref XXH_NAMESPACE\n * (therefore, avoid empty or numeric values).\n *\n * Note that no change is required within the calling program as long as it\n * includes `xxhash.h`: Regular symbol names will be automatically translated\n * by this header.\n */\n#  define XXH_NAMESPACE /* YOUR NAME HERE */\n#  undef XXH_NAMESPACE\n#endif\n\n#if (defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)) \\\n    && !defined(XXH_INLINE_ALL_31684351384)\n   /* this section should be traversed only once */\n#  define XXH_INLINE_ALL_31684351384\n   /* give access to the advanced API, required to compile implementations */\n#  undef XXH_STATIC_LINKING_ONLY   /* avoid macro redef */\n#  define XXH_STATIC_LINKING_ONLY\n   /* make all functions private */\n#  undef XXH_PUBLIC_API\n#  if defined(__GNUC__)\n#    define XXH_PUBLIC_API static __inline __attribute__((unused))\n#  elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)\n#    define XXH_PUBLIC_API static inline\n#  elif defined(_MSC_VER)\n#    define XXH_PUBLIC_API static __inline\n#  else\n     /* note: this version may generate warnings for unused static functions */\n#    define XXH_PUBLIC_API static\n#  endif\n\n   /*\n    * This part deals with the special case where a unit wants to inline xxHash,\n    * but \"xxhash.h\" has previously been included without XXH_INLINE_ALL,\n    * such as part of some previously included *.h header file.\n    * Without further action, the new include would just be ignored,\n    * and functions would effectively _not_ be inlined (silent failure).\n    * The following macros solve this situation by prefixing all inlined names,\n    * avoiding naming collision with previous inclusions.\n    */\n   /* Before that, we unconditionally #undef all symbols,\n    * in case they were already defined with XXH_NAMESPACE.\n    * They will then be redefined for XXH_INLINE_ALL\n    */\n#  undef XXH_versionNumber\n    /* XXH32 */\n#  undef XXH32\n#  undef XXH32_createState\n#  undef XXH32_freeState\n#  undef XXH32_reset\n#  undef XXH32_update\n#  undef XXH32_digest\n#  undef XXH32_copyState\n#  undef XXH32_canonicalFromHash\n#  undef XXH32_hashFromCanonical\n    /* XXH64 */\n#  undef XXH64\n#  undef XXH64_createState\n#  undef XXH64_freeState\n#  undef XXH64_reset\n#  undef XXH64_update\n#  undef XXH64_digest\n#  undef XXH64_copyState\n#  undef XXH64_canonicalFromHash\n#  undef XXH64_hashFromCanonical\n    /* XXH3_64bits */\n#  undef XXH3_64bits\n#  undef XXH3_64bits_withSecret\n#  undef XXH3_64bits_withSeed\n#  undef XXH3_64bits_withSecretandSeed\n#  undef XXH3_createState\n#  undef XXH3_freeState\n#  undef XXH3_copyState\n#  undef XXH3_64bits_reset\n#  undef XXH3_64bits_reset_withSeed\n#  undef XXH3_64bits_reset_withSecret\n#  undef XXH3_64bits_update\n#  undef XXH3_64bits_digest\n#  undef XXH3_generateSecret\n    /* XXH3_128bits */\n#  undef XXH128\n#  undef XXH3_128bits\n#  undef XXH3_128bits_withSeed\n#  undef XXH3_128bits_withSecret\n#  undef XXH3_128bits_reset\n#  undef XXH3_128bits_reset_withSeed\n#  undef XXH3_128bits_reset_withSecret\n#  undef XXH3_128bits_reset_withSecretandSeed\n#  undef XXH3_128bits_update\n#  undef XXH3_128bits_digest\n#  undef XXH128_isEqual\n#  undef XXH128_cmp\n#  undef XXH128_canonicalFromHash\n#  undef XXH128_hashFromCanonical\n    /* Finally, free the namespace itself */\n#  undef XXH_NAMESPACE\n\n    /* employ the namespace for XXH_INLINE_ALL */\n#  define XXH_NAMESPACE XXH_INLINE_\n   /*\n    * Some identifiers (enums, type names) are not symbols,\n    * but they must nonetheless be renamed to avoid redeclaration.\n    * Alternative solution: do not redeclare them.\n    * However, this requires some #ifdefs, and has a more dispersed impact.\n    * Meanwhile, renaming can be achieved in a single place.\n    */\n#  define XXH_IPREF(Id)   XXH_NAMESPACE ## Id\n#  define XXH_OK XXH_IPREF(XXH_OK)\n#  define XXH_ERROR XXH_IPREF(XXH_ERROR)\n#  define XXH_errorcode XXH_IPREF(XXH_errorcode)\n#  define XXH32_canonical_t  XXH_IPREF(XXH32_canonical_t)\n#  define XXH64_canonical_t  XXH_IPREF(XXH64_canonical_t)\n#  define XXH128_canonical_t XXH_IPREF(XXH128_canonical_t)\n#  define XXH32_state_s XXH_IPREF(XXH32_state_s)\n#  define XXH32_state_t XXH_IPREF(XXH32_state_t)\n#  define XXH64_state_s XXH_IPREF(XXH64_state_s)\n#  define XXH64_state_t XXH_IPREF(XXH64_state_t)\n#  define XXH3_state_s  XXH_IPREF(XXH3_state_s)\n#  define XXH3_state_t  XXH_IPREF(XXH3_state_t)\n#  define XXH128_hash_t XXH_IPREF(XXH128_hash_t)\n   /* Ensure the header is parsed again, even if it was previously included */\n#  undef XXHASH_H_5627135585666179\n#  undef XXHASH_H_STATIC_13879238742\n#endif /* XXH_INLINE_ALL || XXH_PRIVATE_API */\n\n/* ****************************************************************\n *  Stable API\n *****************************************************************/\n#ifndef XXHASH_H_5627135585666179\n#define XXHASH_H_5627135585666179 1\n\n/*! @brief Marks a global symbol. */\n#if !defined(XXH_INLINE_ALL) && !defined(XXH_PRIVATE_API)\n#  if defined(WIN32) && defined(_MSC_VER) && (defined(XXH_IMPORT) || defined(XXH_EXPORT))\n#    ifdef XXH_EXPORT\n#      define XXH_PUBLIC_API __declspec(dllexport)\n#    elif XXH_IMPORT\n#      define XXH_PUBLIC_API __declspec(dllimport)\n#    endif\n#  else\n#    define XXH_PUBLIC_API   /* do nothing */\n#  endif\n#endif\n\n#ifdef XXH_NAMESPACE\n#  define XXH_CAT(A,B) A##B\n#  define XXH_NAME2(A,B) XXH_CAT(A,B)\n#  define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber)\n/* XXH32 */\n#  define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32)\n#  define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState)\n#  define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState)\n#  define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset)\n#  define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update)\n#  define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest)\n#  define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState)\n#  define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash)\n#  define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical)\n/* XXH64 */\n#  define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64)\n#  define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState)\n#  define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState)\n#  define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset)\n#  define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update)\n#  define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest)\n#  define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState)\n#  define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash)\n#  define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical)\n/* XXH3_64bits */\n#  define XXH3_64bits XXH_NAME2(XXH_NAMESPACE, XXH3_64bits)\n#  define XXH3_64bits_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_withSecret)\n#  define XXH3_64bits_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_withSeed)\n#  define XXH3_64bits_withSecretandSeed XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_withSecretandSeed)\n#  define XXH3_createState XXH_NAME2(XXH_NAMESPACE, XXH3_createState)\n#  define XXH3_freeState XXH_NAME2(XXH_NAMESPACE, XXH3_freeState)\n#  define XXH3_copyState XXH_NAME2(XXH_NAMESPACE, XXH3_copyState)\n#  define XXH3_64bits_reset XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_reset)\n#  define XXH3_64bits_reset_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_reset_withSeed)\n#  define XXH3_64bits_reset_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_reset_withSecret)\n#  define XXH3_64bits_reset_withSecretandSeed XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_reset_withSecretandSeed)\n#  define XXH3_64bits_update XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_update)\n#  define XXH3_64bits_digest XXH_NAME2(XXH_NAMESPACE, XXH3_64bits_digest)\n#  define XXH3_generateSecret XXH_NAME2(XXH_NAMESPACE, XXH3_generateSecret)\n#  define XXH3_generateSecret_fromSeed XXH_NAME2(XXH_NAMESPACE, XXH3_generateSecret_fromSeed)\n/* XXH3_128bits */\n#  define XXH128 XXH_NAME2(XXH_NAMESPACE, XXH128)\n#  define XXH3_128bits XXH_NAME2(XXH_NAMESPACE, XXH3_128bits)\n#  define XXH3_128bits_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_withSeed)\n#  define XXH3_128bits_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_withSecret)\n#  define XXH3_128bits_withSecretandSeed XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_withSecretandSeed)\n#  define XXH3_128bits_reset XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_reset)\n#  define XXH3_128bits_reset_withSeed XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_reset_withSeed)\n#  define XXH3_128bits_reset_withSecret XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_reset_withSecret)\n#  define XXH3_128bits_reset_withSecretandSeed XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_reset_withSecretandSeed)\n#  define XXH3_128bits_update XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_update)\n#  define XXH3_128bits_digest XXH_NAME2(XXH_NAMESPACE, XXH3_128bits_digest)\n#  define XXH128_isEqual XXH_NAME2(XXH_NAMESPACE, XXH128_isEqual)\n#  define XXH128_cmp     XXH_NAME2(XXH_NAMESPACE, XXH128_cmp)\n#  define XXH128_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH128_canonicalFromHash)\n#  define XXH128_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH128_hashFromCanonical)\n#endif\n\n\n/* *************************************\n*  Compiler specifics\n***************************************/\n\n/* specific declaration modes for Windows */\n#if !defined(XXH_INLINE_ALL) && !defined(XXH_PRIVATE_API)\n#  if defined(WIN32) && defined(_MSC_VER) && (defined(XXH_IMPORT) || defined(XXH_EXPORT))\n#    ifdef XXH_EXPORT\n#      define XXH_PUBLIC_API __declspec(dllexport)\n#    elif XXH_IMPORT\n#      define XXH_PUBLIC_API __declspec(dllimport)\n#    endif\n#  else\n#    define XXH_PUBLIC_API   /* do nothing */\n#  endif\n#endif\n\n#if defined (__GNUC__)\n# define XXH_CONSTF  __attribute__((const))\n# define XXH_PUREF   __attribute__((pure))\n# define XXH_MALLOCF __attribute__((malloc))\n#else\n# define XXH_CONSTF  /* disable */\n# define XXH_PUREF\n# define XXH_MALLOCF\n#endif\n\n/* *************************************\n*  Version\n***************************************/\n#define XXH_VERSION_MAJOR    0\n#define XXH_VERSION_MINOR    8\n#define XXH_VERSION_RELEASE  2\n/*! @brief Version number, encoded as two digits each */\n#define XXH_VERSION_NUMBER  (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE)\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n/*!\n * @brief Obtains the xxHash version.\n *\n * This is mostly useful when xxHash is compiled as a shared library,\n * since the returned value comes from the library, as opposed to header file.\n *\n * @return @ref XXH_VERSION_NUMBER of the invoked library.\n */\nXXH_PUBLIC_API XXH_CONSTF unsigned XXH_versionNumber (void);\n\n#if defined (__cplusplus)\n}\n#endif\n\n/* ****************************\n*  Common basic types\n******************************/\n#include    /* size_t */\n/*!\n * @brief Exit code for the streaming API.\n */\ntypedef enum {\n    XXH_OK = 0, /*!< OK */\n    XXH_ERROR   /*!< Error */\n} XXH_errorcode;\n\n\n/*-**********************************************************************\n*  32-bit hash\n************************************************************************/\n#if defined(XXH_DOXYGEN) /* Don't show  include */\n/*!\n * @brief An unsigned 32-bit integer.\n *\n * Not necessarily defined to `uint32_t` but functionally equivalent.\n */\ntypedef uint32_t XXH32_hash_t;\n\n#elif !defined (__VMS) \\\n  && (defined (__cplusplus) \\\n  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )\n#   ifdef _AIX\n#     include \n#   else\n#     include \n#   endif\n    typedef uint32_t XXH32_hash_t;\n\n#else\n#   include \n#   if UINT_MAX == 0xFFFFFFFFUL\n      typedef unsigned int XXH32_hash_t;\n#   elif ULONG_MAX == 0xFFFFFFFFUL\n      typedef unsigned long XXH32_hash_t;\n#   else\n#     error \"unsupported platform: need a 32-bit type\"\n#   endif\n#endif\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n\n/*!\n * @}\n *\n * @defgroup XXH32_family XXH32 family\n * @ingroup public\n * Contains functions used in the classic 32-bit xxHash algorithm.\n *\n * @note\n *   XXH32 is useful for older platforms, with no or poor 64-bit performance.\n *   Note that the @ref XXH3_family provides competitive speed for both 32-bit\n *   and 64-bit systems, and offers true 64/128 bit hash results.\n *\n * @see @ref XXH64_family, @ref XXH3_family : Other xxHash families\n * @see @ref XXH32_impl for implementation details\n * @{\n */\n\n/*!\n * @brief Calculates the 32-bit hash of @p input using xxHash32.\n *\n * @param input The block of data to be hashed, at least @p length bytes in size.\n * @param length The length of @p input, in bytes.\n * @param seed The 32-bit seed to alter the hash's output predictably.\n *\n * @pre\n *   The memory between @p input and @p input + @p length must be valid,\n *   readable, contiguous memory. However, if @p length is `0`, @p input may be\n *   `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * @return The calculated 32-bit xxHash32 value.\n *\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH32_hash_t XXH32 (const void* input, size_t length, XXH32_hash_t seed);\n\n#ifndef XXH_NO_STREAM\n/*!\n * @typedef struct XXH32_state_s XXH32_state_t\n * @brief The opaque state struct for the XXH32 streaming API.\n *\n * @see XXH32_state_s for details.\n */\ntypedef struct XXH32_state_s XXH32_state_t;\n\n/*!\n * @brief Allocates an @ref XXH32_state_t.\n *\n * @return An allocated pointer of @ref XXH32_state_t on success.\n * @return `NULL` on failure.\n *\n * @note Must be freed with XXH32_freeState().\n */\nXXH_PUBLIC_API XXH_MALLOCF XXH32_state_t* XXH32_createState(void);\n/*!\n * @brief Frees an @ref XXH32_state_t.\n *\n * @param statePtr A pointer to an @ref XXH32_state_t allocated with @ref XXH32_createState().\n *\n * @return @ref XXH_OK.\n *\n * @note @p statePtr must be allocated with XXH32_createState().\n *\n */\nXXH_PUBLIC_API XXH_errorcode  XXH32_freeState(XXH32_state_t* statePtr);\n/*!\n * @brief Copies one @ref XXH32_state_t to another.\n *\n * @param dst_state The state to copy to.\n * @param src_state The state to copy from.\n * @pre\n *   @p dst_state and @p src_state must not be `NULL` and must not overlap.\n */\nXXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dst_state, const XXH32_state_t* src_state);\n\n/*!\n * @brief Resets an @ref XXH32_state_t to begin a new hash.\n *\n * @param statePtr The state struct to reset.\n * @param seed The 32-bit seed to alter the hash result predictably.\n *\n * @pre\n *   @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note This function resets and seeds a state. Call it before @ref XXH32_update().\n */\nXXH_PUBLIC_API XXH_errorcode XXH32_reset  (XXH32_state_t* statePtr, XXH32_hash_t seed);\n\n/*!\n * @brief Consumes a block of @p input to an @ref XXH32_state_t.\n *\n * @param statePtr The state struct to update.\n * @param input The block of data to be hashed, at least @p length bytes in size.\n * @param length The length of @p input, in bytes.\n *\n * @pre\n *   @p statePtr must not be `NULL`.\n * @pre\n *   The memory between @p input and @p input + @p length must be valid,\n *   readable, contiguous memory. However, if @p length is `0`, @p input may be\n *   `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note Call this to incrementally consume blocks of data.\n */\nXXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length);\n\n/*!\n * @brief Returns the calculated hash value from an @ref XXH32_state_t.\n *\n * @param statePtr The state struct to calculate the hash from.\n *\n * @pre\n *  @p statePtr must not be `NULL`.\n *\n * @return The calculated 32-bit xxHash32 value from that state.\n *\n * @note\n *   Calling XXH32_digest() will not affect @p statePtr, so you can update,\n *   digest, and update again.\n */\nXXH_PUBLIC_API XXH_PUREF XXH32_hash_t XXH32_digest (const XXH32_state_t* statePtr);\n#endif /* !XXH_NO_STREAM */\n\n/*******   Canonical representation   *******/\n\n/*!\n * @brief Canonical (big endian) representation of @ref XXH32_hash_t.\n */\ntypedef struct {\n    unsigned char digest[4]; /*!< Hash bytes, big endian */\n} XXH32_canonical_t;\n\n/*!\n * @brief Converts an @ref XXH32_hash_t to a big endian @ref XXH32_canonical_t.\n *\n * @param dst  The @ref XXH32_canonical_t pointer to be stored to.\n * @param hash The @ref XXH32_hash_t to be converted.\n *\n * @pre\n *   @p dst must not be `NULL`.\n *\n * @see @ref canonical_representation_example \"Canonical Representation Example\"\n */\nXXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash);\n\n/*!\n * @brief Converts an @ref XXH32_canonical_t to a native @ref XXH32_hash_t.\n *\n * @param src The @ref XXH32_canonical_t to convert.\n *\n * @pre\n *   @p src must not be `NULL`.\n *\n * @return The converted hash.\n *\n * @see @ref canonical_representation_example \"Canonical Representation Example\"\n */\nXXH_PUBLIC_API XXH_PUREF XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src);\n\n\n/*! @cond Doxygen ignores this part */\n#ifdef __has_attribute\n# define XXH_HAS_ATTRIBUTE(x) __has_attribute(x)\n#else\n# define XXH_HAS_ATTRIBUTE(x) 0\n#endif\n/*! @endcond */\n\n/*! @cond Doxygen ignores this part */\n/*\n * C23 __STDC_VERSION__ number hasn't been specified yet. For now\n * leave as `201711L` (C17 + 1).\n * TODO: Update to correct value when its been specified.\n */\n#define XXH_C23_VN 201711L\n/*! @endcond */\n\n/*! @cond Doxygen ignores this part */\n/* C-language Attributes are added in C23. */\n#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= XXH_C23_VN) && defined(__has_c_attribute)\n# define XXH_HAS_C_ATTRIBUTE(x) __has_c_attribute(x)\n#else\n# define XXH_HAS_C_ATTRIBUTE(x) 0\n#endif\n/*! @endcond */\n\n/*! @cond Doxygen ignores this part */\n#if defined(__cplusplus) && defined(__has_cpp_attribute)\n# define XXH_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)\n#else\n# define XXH_HAS_CPP_ATTRIBUTE(x) 0\n#endif\n/*! @endcond */\n\n/*! @cond Doxygen ignores this part */\n/*\n * Define XXH_FALLTHROUGH macro for annotating switch case with the 'fallthrough' attribute\n * introduced in CPP17 and C23.\n * CPP17 : https://en.cppreference.com/w/cpp/language/attributes/fallthrough\n * C23   : https://en.cppreference.com/w/c/language/attributes/fallthrough\n */\n#if XXH_HAS_C_ATTRIBUTE(fallthrough) || XXH_HAS_CPP_ATTRIBUTE(fallthrough)\n# define XXH_FALLTHROUGH [[fallthrough]]\n#elif XXH_HAS_ATTRIBUTE(__fallthrough__)\n# define XXH_FALLTHROUGH __attribute__ ((__fallthrough__))\n#else\n# define XXH_FALLTHROUGH /* fallthrough */\n#endif\n/*! @endcond */\n\n/*! @cond Doxygen ignores this part */\n/*\n * Define XXH_NOESCAPE for annotated pointers in public API.\n * https://clang.llvm.org/docs/AttributeReference.html#noescape\n * As of writing this, only supported by clang.\n */\n#if XXH_HAS_ATTRIBUTE(noescape)\n# define XXH_NOESCAPE __attribute__((noescape))\n#else\n# define XXH_NOESCAPE\n#endif\n/*! @endcond */\n\n#if defined (__cplusplus)\n} /* end of extern \"C\" */\n#endif\n\n/*!\n * @}\n * @ingroup public\n * @{\n */\n\n#ifndef XXH_NO_LONG_LONG\n/*-**********************************************************************\n*  64-bit hash\n************************************************************************/\n#if defined(XXH_DOXYGEN) /* don't include  */\n/*!\n * @brief An unsigned 64-bit integer.\n *\n * Not necessarily defined to `uint64_t` but functionally equivalent.\n */\ntypedef uint64_t XXH64_hash_t;\n#elif !defined (__VMS) \\\n  && (defined (__cplusplus) \\\n  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )\n#   ifdef _AIX\n#     include \n#   else\n#     include \n#   endif\n   typedef uint64_t XXH64_hash_t;\n#else\n#  include \n#  if defined(__LP64__) && ULONG_MAX == 0xFFFFFFFFFFFFFFFFULL\n     /* LP64 ABI says uint64_t is unsigned long */\n     typedef unsigned long XXH64_hash_t;\n#  else\n     /* the following type must have a width of 64-bit */\n     typedef unsigned long long XXH64_hash_t;\n#  endif\n#endif\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n/*!\n * @}\n *\n * @defgroup XXH64_family XXH64 family\n * @ingroup public\n * @{\n * Contains functions used in the classic 64-bit xxHash algorithm.\n *\n * @note\n *   XXH3 provides competitive speed for both 32-bit and 64-bit systems,\n *   and offers true 64/128 bit hash results.\n *   It provides better speed for systems with vector processing capabilities.\n */\n\n/*!\n * @brief Calculates the 64-bit hash of @p input using xxHash64.\n *\n * @param input The block of data to be hashed, at least @p length bytes in size.\n * @param length The length of @p input, in bytes.\n * @param seed The 64-bit seed to alter the hash's output predictably.\n *\n * @pre\n *   The memory between @p input and @p input + @p length must be valid,\n *   readable, contiguous memory. However, if @p length is `0`, @p input may be\n *   `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * @return The calculated 64-bit xxHash64 value.\n *\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH64(XXH_NOESCAPE const void* input, size_t length, XXH64_hash_t seed);\n\n/*******   Streaming   *******/\n#ifndef XXH_NO_STREAM\n/*!\n * @brief The opaque state struct for the XXH64 streaming API.\n *\n * @see XXH64_state_s for details.\n */\ntypedef struct XXH64_state_s XXH64_state_t;   /* incomplete type */\n\n/*!\n * @brief Allocates an @ref XXH64_state_t.\n *\n * @return An allocated pointer of @ref XXH64_state_t on success.\n * @return `NULL` on failure.\n *\n * @note Must be freed with XXH64_freeState().\n */\nXXH_PUBLIC_API XXH_MALLOCF XXH64_state_t* XXH64_createState(void);\n\n/*!\n * @brief Frees an @ref XXH64_state_t.\n *\n * @param statePtr A pointer to an @ref XXH64_state_t allocated with @ref XXH64_createState().\n *\n * @return @ref XXH_OK.\n *\n * @note @p statePtr must be allocated with XXH64_createState().\n */\nXXH_PUBLIC_API XXH_errorcode  XXH64_freeState(XXH64_state_t* statePtr);\n\n/*!\n * @brief Copies one @ref XXH64_state_t to another.\n *\n * @param dst_state The state to copy to.\n * @param src_state The state to copy from.\n * @pre\n *   @p dst_state and @p src_state must not be `NULL` and must not overlap.\n */\nXXH_PUBLIC_API void XXH64_copyState(XXH_NOESCAPE XXH64_state_t* dst_state, const XXH64_state_t* src_state);\n\n/*!\n * @brief Resets an @ref XXH64_state_t to begin a new hash.\n *\n * @param statePtr The state struct to reset.\n * @param seed The 64-bit seed to alter the hash result predictably.\n *\n * @pre\n *   @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note This function resets and seeds a state. Call it before @ref XXH64_update().\n */\nXXH_PUBLIC_API XXH_errorcode XXH64_reset  (XXH_NOESCAPE XXH64_state_t* statePtr, XXH64_hash_t seed);\n\n/*!\n * @brief Consumes a block of @p input to an @ref XXH64_state_t.\n *\n * @param statePtr The state struct to update.\n * @param input The block of data to be hashed, at least @p length bytes in size.\n * @param length The length of @p input, in bytes.\n *\n * @pre\n *   @p statePtr must not be `NULL`.\n * @pre\n *   The memory between @p input and @p input + @p length must be valid,\n *   readable, contiguous memory. However, if @p length is `0`, @p input may be\n *   `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note Call this to incrementally consume blocks of data.\n */\nXXH_PUBLIC_API XXH_errorcode XXH64_update (XXH_NOESCAPE XXH64_state_t* statePtr, XXH_NOESCAPE const void* input, size_t length);\n\n/*!\n * @brief Returns the calculated hash value from an @ref XXH64_state_t.\n *\n * @param statePtr The state struct to calculate the hash from.\n *\n * @pre\n *  @p statePtr must not be `NULL`.\n *\n * @return The calculated 64-bit xxHash64 value from that state.\n *\n * @note\n *   Calling XXH64_digest() will not affect @p statePtr, so you can update,\n *   digest, and update again.\n */\nXXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH64_digest (XXH_NOESCAPE const XXH64_state_t* statePtr);\n#endif /* !XXH_NO_STREAM */\n/*******   Canonical representation   *******/\n\n/*!\n * @brief Canonical (big endian) representation of @ref XXH64_hash_t.\n */\ntypedef struct { unsigned char digest[sizeof(XXH64_hash_t)]; } XXH64_canonical_t;\n\n/*!\n * @brief Converts an @ref XXH64_hash_t to a big endian @ref XXH64_canonical_t.\n *\n * @param dst The @ref XXH64_canonical_t pointer to be stored to.\n * @param hash The @ref XXH64_hash_t to be converted.\n *\n * @pre\n *   @p dst must not be `NULL`.\n *\n * @see @ref canonical_representation_example \"Canonical Representation Example\"\n */\nXXH_PUBLIC_API void XXH64_canonicalFromHash(XXH_NOESCAPE XXH64_canonical_t* dst, XXH64_hash_t hash);\n\n/*!\n * @brief Converts an @ref XXH64_canonical_t to a native @ref XXH64_hash_t.\n *\n * @param src The @ref XXH64_canonical_t to convert.\n *\n * @pre\n *   @p src must not be `NULL`.\n *\n * @return The converted hash.\n *\n * @see @ref canonical_representation_example \"Canonical Representation Example\"\n */\nXXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH64_hashFromCanonical(XXH_NOESCAPE const XXH64_canonical_t* src);\n\n#ifndef XXH_NO_XXH3\n\n/*!\n * @}\n * ************************************************************************\n * @defgroup XXH3_family XXH3 family\n * @ingroup public\n * @{\n *\n * XXH3 is a more recent hash algorithm featuring:\n *  - Improved speed for both small and large inputs\n *  - True 64-bit and 128-bit outputs\n *  - SIMD acceleration\n *  - Improved 32-bit viability\n *\n * Speed analysis methodology is explained here:\n *\n *    https://fastcompression.blogspot.com/2019/03/presenting-xxh3.html\n *\n * Compared to XXH64, expect XXH3 to run approximately\n * ~2x faster on large inputs and >3x faster on small ones,\n * exact differences vary depending on platform.\n *\n * XXH3's speed benefits greatly from SIMD and 64-bit arithmetic,\n * but does not require it.\n * Most 32-bit and 64-bit targets that can run XXH32 smoothly can run XXH3\n * at competitive speeds, even without vector support. Further details are\n * explained in the implementation.\n *\n * XXH3 has a fast scalar implementation, but it also includes accelerated SIMD\n * implementations for many common platforms:\n *   - AVX512\n *   - AVX2\n *   - SSE2\n *   - ARM NEON\n *   - WebAssembly SIMD128\n *   - POWER8 VSX\n *   - s390x ZVector\n * This can be controlled via the @ref XXH_VECTOR macro, but it automatically\n * selects the best version according to predefined macros. For the x86 family, an\n * automatic runtime dispatcher is included separately in @ref xxh_x86dispatch.c.\n *\n * XXH3 implementation is portable:\n * it has a generic C90 formulation that can be compiled on any platform,\n * all implementations generate exactly the same hash value on all platforms.\n * Starting from v0.8.0, it's also labelled \"stable\", meaning that\n * any future version will also generate the same hash value.\n *\n * XXH3 offers 2 variants, _64bits and _128bits.\n *\n * When only 64 bits are needed, prefer invoking the _64bits variant, as it\n * reduces the amount of mixing, resulting in faster speed on small inputs.\n * It's also generally simpler to manipulate a scalar return type than a struct.\n *\n * The API supports one-shot hashing, streaming mode, and custom secrets.\n */\n/*-**********************************************************************\n*  XXH3 64-bit variant\n************************************************************************/\n\n/*!\n * @brief Calculates 64-bit unseeded variant of XXH3 hash of @p input.\n *\n * @param input  The block of data to be hashed, at least @p length bytes in size.\n * @param length The length of @p input, in bytes.\n *\n * @pre\n *   The memory between @p input and @p input + @p length must be valid,\n *   readable, contiguous memory. However, if @p length is `0`, @p input may be\n *   `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * @return The calculated 64-bit XXH3 hash value.\n *\n * @note\n *   This is equivalent to @ref XXH3_64bits_withSeed() with a seed of `0`, however\n *   it may have slightly better performance due to constant propagation of the\n *   defaults.\n *\n * @see\n *    XXH3_64bits_withSeed(), XXH3_64bits_withSecret(): other seeding variants\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH3_64bits(XXH_NOESCAPE const void* input, size_t length);\n\n/*!\n * @brief Calculates 64-bit seeded variant of XXH3 hash of @p input.\n *\n * @param input  The block of data to be hashed, at least @p length bytes in size.\n * @param length The length of @p input, in bytes.\n * @param seed   The 64-bit seed to alter the hash result predictably.\n *\n * @pre\n *   The memory between @p input and @p input + @p length must be valid,\n *   readable, contiguous memory. However, if @p length is `0`, @p input may be\n *   `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * @return The calculated 64-bit XXH3 hash value.\n *\n * @note\n *    seed == 0 produces the same results as @ref XXH3_64bits().\n *\n * This variant generates a custom secret on the fly based on default secret\n * altered using the @p seed value.\n *\n * While this operation is decently fast, note that it's not completely free.\n *\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH3_64bits_withSeed(XXH_NOESCAPE const void* input, size_t length, XXH64_hash_t seed);\n\n/*!\n * The bare minimum size for a custom secret.\n *\n * @see\n *  XXH3_64bits_withSecret(), XXH3_64bits_reset_withSecret(),\n *  XXH3_128bits_withSecret(), XXH3_128bits_reset_withSecret().\n */\n#define XXH3_SECRET_SIZE_MIN 136\n\n/*!\n * @brief Calculates 64-bit variant of XXH3 with a custom \"secret\".\n *\n * @param data       The block of data to be hashed, at least @p len bytes in size.\n * @param len        The length of @p data, in bytes.\n * @param secret     The secret data.\n * @param secretSize The length of @p secret, in bytes.\n *\n * @return The calculated 64-bit XXH3 hash value.\n *\n * @pre\n *   The memory between @p data and @p data + @p len must be valid,\n *   readable, contiguous memory. However, if @p length is `0`, @p data may be\n *   `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * It's possible to provide any blob of bytes as a \"secret\" to generate the hash.\n * This makes it more difficult for an external actor to prepare an intentional collision.\n * The main condition is that @p secretSize *must* be large enough (>= @ref XXH3_SECRET_SIZE_MIN).\n * However, the quality of the secret impacts the dispersion of the hash algorithm.\n * Therefore, the secret _must_ look like a bunch of random bytes.\n * Avoid \"trivial\" or structured data such as repeated sequences or a text document.\n * Whenever in doubt about the \"randomness\" of the blob of bytes,\n * consider employing @ref XXH3_generateSecret() instead (see below).\n * It will generate a proper high entropy secret derived from the blob of bytes.\n * Another advantage of using XXH3_generateSecret() is that\n * it guarantees that all bits within the initial blob of bytes\n * will impact every bit of the output.\n * This is not necessarily the case when using the blob of bytes directly\n * because, when hashing _small_ inputs, only a portion of the secret is employed.\n *\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH64_hash_t XXH3_64bits_withSecret(XXH_NOESCAPE const void* data, size_t len, XXH_NOESCAPE const void* secret, size_t secretSize);\n\n\n/*******   Streaming   *******/\n#ifndef XXH_NO_STREAM\n/*\n * Streaming requires state maintenance.\n * This operation costs memory and CPU.\n * As a consequence, streaming is slower than one-shot hashing.\n * For better performance, prefer one-shot functions whenever applicable.\n */\n\n/*!\n * @brief The opaque state struct for the XXH3 streaming API.\n *\n * @see XXH3_state_s for details.\n */\ntypedef struct XXH3_state_s XXH3_state_t;\nXXH_PUBLIC_API XXH_MALLOCF XXH3_state_t* XXH3_createState(void);\nXXH_PUBLIC_API XXH_errorcode XXH3_freeState(XXH3_state_t* statePtr);\n\n/*!\n * @brief Copies one @ref XXH3_state_t to another.\n *\n * @param dst_state The state to copy to.\n * @param src_state The state to copy from.\n * @pre\n *   @p dst_state and @p src_state must not be `NULL` and must not overlap.\n */\nXXH_PUBLIC_API void XXH3_copyState(XXH_NOESCAPE XXH3_state_t* dst_state, XXH_NOESCAPE const XXH3_state_t* src_state);\n\n/*!\n * @brief Resets an @ref XXH3_state_t to begin a new hash.\n *\n * @param statePtr The state struct to reset.\n *\n * @pre\n *   @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note\n *   - This function resets `statePtr` and generate a secret with default parameters.\n *   - Call this function before @ref XXH3_64bits_update().\n *   - Digest will be equivalent to `XXH3_64bits()`.\n *\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset(XXH_NOESCAPE XXH3_state_t* statePtr);\n\n/*!\n * @brief Resets an @ref XXH3_state_t with 64-bit seed to begin a new hash.\n *\n * @param statePtr The state struct to reset.\n * @param seed     The 64-bit seed to alter the hash result predictably.\n *\n * @pre\n *   @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note\n *   - This function resets `statePtr` and generate a secret from `seed`.\n *   - Call this function before @ref XXH3_64bits_update().\n *   - Digest will be equivalent to `XXH3_64bits_withSeed()`.\n *\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH64_hash_t seed);\n\n/*!\n * @brief Resets an @ref XXH3_state_t with secret data to begin a new hash.\n *\n * @param statePtr The state struct to reset.\n * @param secret     The secret data.\n * @param secretSize The length of @p secret, in bytes.\n *\n * @pre\n *   @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note\n *   `secret` is referenced, it _must outlive_ the hash streaming session.\n *\n * Similar to one-shot API, `secretSize` must be >= @ref XXH3_SECRET_SIZE_MIN,\n * and the quality of produced hash values depends on secret's entropy\n * (secret's content should look like a bunch of random bytes).\n * When in doubt about the randomness of a candidate `secret`,\n * consider employing `XXH3_generateSecret()` instead (see below).\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_64bits_reset_withSecret(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize);\n\n/*!\n * @brief Consumes a block of @p input to an @ref XXH3_state_t.\n *\n * @param statePtr The state struct to update.\n * @param input The block of data to be hashed, at least @p length bytes in size.\n * @param length The length of @p input, in bytes.\n *\n * @pre\n *   @p statePtr must not be `NULL`.\n * @pre\n *   The memory between @p input and @p input + @p length must be valid,\n *   readable, contiguous memory. However, if @p length is `0`, @p input may be\n *   `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note Call this to incrementally consume blocks of data.\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_64bits_update (XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* input, size_t length);\n\n/*!\n * @brief Returns the calculated XXH3 64-bit hash value from an @ref XXH3_state_t.\n *\n * @param statePtr The state struct to calculate the hash from.\n *\n * @pre\n *  @p statePtr must not be `NULL`.\n *\n * @return The calculated XXH3 64-bit hash value from that state.\n *\n * @note\n *   Calling XXH3_64bits_digest() will not affect @p statePtr, so you can update,\n *   digest, and update again.\n */\nXXH_PUBLIC_API XXH_PUREF XXH64_hash_t  XXH3_64bits_digest (XXH_NOESCAPE const XXH3_state_t* statePtr);\n#endif /* !XXH_NO_STREAM */\n\n/* note : canonical representation of XXH3 is the same as XXH64\n * since they both produce XXH64_hash_t values */\n\n\n/*-**********************************************************************\n*  XXH3 128-bit variant\n************************************************************************/\n\n/*!\n * @brief The return value from 128-bit hashes.\n *\n * Stored in little endian order, although the fields themselves are in native\n * endianness.\n */\ntypedef struct {\n    XXH64_hash_t low64;   /*!< `value & 0xFFFFFFFFFFFFFFFF` */\n    XXH64_hash_t high64;  /*!< `value >> 64` */\n} XXH128_hash_t;\n\n/*!\n * @brief Calculates 128-bit unseeded variant of XXH3 of @p data.\n *\n * @param data The block of data to be hashed, at least @p length bytes in size.\n * @param len  The length of @p data, in bytes.\n *\n * @return The calculated 128-bit variant of XXH3 value.\n *\n * The 128-bit variant of XXH3 has more strength, but it has a bit of overhead\n * for shorter inputs.\n *\n * This is equivalent to @ref XXH3_128bits_withSeed() with a seed of `0`, however\n * it may have slightly better performance due to constant propagation of the\n * defaults.\n *\n * @see XXH3_128bits_withSeed(), XXH3_128bits_withSecret(): other seeding variants\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH3_128bits(XXH_NOESCAPE const void* data, size_t len);\n/*! @brief Calculates 128-bit seeded variant of XXH3 hash of @p data.\n *\n * @param data The block of data to be hashed, at least @p length bytes in size.\n * @param len  The length of @p data, in bytes.\n * @param seed The 64-bit seed to alter the hash result predictably.\n *\n * @return The calculated 128-bit variant of XXH3 value.\n *\n * @note\n *    seed == 0 produces the same results as @ref XXH3_64bits().\n *\n * This variant generates a custom secret on the fly based on default secret\n * altered using the @p seed value.\n *\n * While this operation is decently fast, note that it's not completely free.\n *\n * @see XXH3_128bits(), XXH3_128bits_withSecret(): other seeding variants\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH3_128bits_withSeed(XXH_NOESCAPE const void* data, size_t len, XXH64_hash_t seed);\n/*!\n * @brief Calculates 128-bit variant of XXH3 with a custom \"secret\".\n *\n * @param data       The block of data to be hashed, at least @p len bytes in size.\n * @param len        The length of @p data, in bytes.\n * @param secret     The secret data.\n * @param secretSize The length of @p secret, in bytes.\n *\n * @return The calculated 128-bit variant of XXH3 value.\n *\n * It's possible to provide any blob of bytes as a \"secret\" to generate the hash.\n * This makes it more difficult for an external actor to prepare an intentional collision.\n * The main condition is that @p secretSize *must* be large enough (>= @ref XXH3_SECRET_SIZE_MIN).\n * However, the quality of the secret impacts the dispersion of the hash algorithm.\n * Therefore, the secret _must_ look like a bunch of random bytes.\n * Avoid \"trivial\" or structured data such as repeated sequences or a text document.\n * Whenever in doubt about the \"randomness\" of the blob of bytes,\n * consider employing @ref XXH3_generateSecret() instead (see below).\n * It will generate a proper high entropy secret derived from the blob of bytes.\n * Another advantage of using XXH3_generateSecret() is that\n * it guarantees that all bits within the initial blob of bytes\n * will impact every bit of the output.\n * This is not necessarily the case when using the blob of bytes directly\n * because, when hashing _small_ inputs, only a portion of the secret is employed.\n *\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH3_128bits_withSecret(XXH_NOESCAPE const void* data, size_t len, XXH_NOESCAPE const void* secret, size_t secretSize);\n\n/*******   Streaming   *******/\n#ifndef XXH_NO_STREAM\n/*\n * Streaming requires state maintenance.\n * This operation costs memory and CPU.\n * As a consequence, streaming is slower than one-shot hashing.\n * For better performance, prefer one-shot functions whenever applicable.\n *\n * XXH3_128bits uses the same XXH3_state_t as XXH3_64bits().\n * Use already declared XXH3_createState() and XXH3_freeState().\n *\n * All reset and streaming functions have same meaning as their 64-bit counterpart.\n */\n\n/*!\n * @brief Resets an @ref XXH3_state_t to begin a new hash.\n *\n * @param statePtr The state struct to reset.\n *\n * @pre\n *   @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note\n *   - This function resets `statePtr` and generate a secret with default parameters.\n *   - Call it before @ref XXH3_128bits_update().\n *   - Digest will be equivalent to `XXH3_128bits()`.\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset(XXH_NOESCAPE XXH3_state_t* statePtr);\n\n/*!\n * @brief Resets an @ref XXH3_state_t with 64-bit seed to begin a new hash.\n *\n * @param statePtr The state struct to reset.\n * @param seed     The 64-bit seed to alter the hash result predictably.\n *\n * @pre\n *   @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note\n *   - This function resets `statePtr` and generate a secret from `seed`.\n *   - Call it before @ref XXH3_128bits_update().\n *   - Digest will be equivalent to `XXH3_128bits_withSeed()`.\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset_withSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH64_hash_t seed);\n/*!\n * @brief Resets an @ref XXH3_state_t with secret data to begin a new hash.\n *\n * @param statePtr   The state struct to reset.\n * @param secret     The secret data.\n * @param secretSize The length of @p secret, in bytes.\n *\n * @pre\n *   @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * `secret` is referenced, it _must outlive_ the hash streaming session.\n * Similar to one-shot API, `secretSize` must be >= @ref XXH3_SECRET_SIZE_MIN,\n * and the quality of produced hash values depends on secret's entropy\n * (secret's content should look like a bunch of random bytes).\n * When in doubt about the randomness of a candidate `secret`,\n * consider employing `XXH3_generateSecret()` instead (see below).\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_128bits_reset_withSecret(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize);\n\n/*!\n * @brief Consumes a block of @p input to an @ref XXH3_state_t.\n *\n * Call this to incrementally consume blocks of data.\n *\n * @param statePtr The state struct to update.\n * @param input The block of data to be hashed, at least @p length bytes in size.\n * @param length The length of @p input, in bytes.\n *\n * @pre\n *   @p statePtr must not be `NULL`.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @note\n *   The memory between @p input and @p input + @p length must be valid,\n *   readable, contiguous memory. However, if @p length is `0`, @p input may be\n *   `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_128bits_update (XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* input, size_t length);\n\n/*!\n * @brief Returns the calculated XXH3 128-bit hash value from an @ref XXH3_state_t.\n *\n * @param statePtr The state struct to calculate the hash from.\n *\n * @pre\n *  @p statePtr must not be `NULL`.\n *\n * @return The calculated XXH3 128-bit hash value from that state.\n *\n * @note\n *   Calling XXH3_128bits_digest() will not affect @p statePtr, so you can update,\n *   digest, and update again.\n *\n */\nXXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH3_128bits_digest (XXH_NOESCAPE const XXH3_state_t* statePtr);\n#endif /* !XXH_NO_STREAM */\n\n/* Following helper functions make it possible to compare XXH128_hast_t values.\n * Since XXH128_hash_t is a structure, this capability is not offered by the language.\n * Note: For better performance, these functions can be inlined using XXH_INLINE_ALL */\n\n/*!\n * @brief Check equality of two XXH128_hash_t values\n *\n * @param h1 The 128-bit hash value.\n * @param h2 Another 128-bit hash value.\n *\n * @return `1` if `h1` and `h2` are equal.\n * @return `0` if they are not.\n */\nXXH_PUBLIC_API XXH_PUREF int XXH128_isEqual(XXH128_hash_t h1, XXH128_hash_t h2);\n\n/*!\n * @brief Compares two @ref XXH128_hash_t\n *\n * This comparator is compatible with stdlib's `qsort()`/`bsearch()`.\n *\n * @param h128_1 Left-hand side value\n * @param h128_2 Right-hand side value\n *\n * @return >0 if @p h128_1  > @p h128_2\n * @return =0 if @p h128_1 == @p h128_2\n * @return <0 if @p h128_1  < @p h128_2\n */\nXXH_PUBLIC_API XXH_PUREF int XXH128_cmp(XXH_NOESCAPE const void* h128_1, XXH_NOESCAPE const void* h128_2);\n\n\n/*******   Canonical representation   *******/\ntypedef struct { unsigned char digest[sizeof(XXH128_hash_t)]; } XXH128_canonical_t;\n\n\n/*!\n * @brief Converts an @ref XXH128_hash_t to a big endian @ref XXH128_canonical_t.\n *\n * @param dst  The @ref XXH128_canonical_t pointer to be stored to.\n * @param hash The @ref XXH128_hash_t to be converted.\n *\n * @pre\n *   @p dst must not be `NULL`.\n * @see @ref canonical_representation_example \"Canonical Representation Example\"\n */\nXXH_PUBLIC_API void XXH128_canonicalFromHash(XXH_NOESCAPE XXH128_canonical_t* dst, XXH128_hash_t hash);\n\n/*!\n * @brief Converts an @ref XXH128_canonical_t to a native @ref XXH128_hash_t.\n *\n * @param src The @ref XXH128_canonical_t to convert.\n *\n * @pre\n *   @p src must not be `NULL`.\n *\n * @return The converted hash.\n * @see @ref canonical_representation_example \"Canonical Representation Example\"\n */\nXXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH128_hashFromCanonical(XXH_NOESCAPE const XXH128_canonical_t* src);\n\n\n#endif  /* !XXH_NO_XXH3 */\n\n#if defined (__cplusplus)\n} /* extern \"C\" */\n#endif\n\n#endif  /* XXH_NO_LONG_LONG */\n\n/*!\n * @}\n */\n#endif /* XXHASH_H_5627135585666179 */\n\n\n\n#if defined(XXH_STATIC_LINKING_ONLY) && !defined(XXHASH_H_STATIC_13879238742)\n#define XXHASH_H_STATIC_13879238742\n/* ****************************************************************************\n * This section contains declarations which are not guaranteed to remain stable.\n * They may change in future versions, becoming incompatible with a different\n * version of the library.\n * These declarations should only be used with static linking.\n * Never use them in association with dynamic linking!\n ***************************************************************************** */\n\n/*\n * These definitions are only present to allow static allocation\n * of XXH states, on stack or in a struct, for example.\n * Never **ever** access their members directly.\n */\n\n/*!\n * @internal\n * @brief Structure for XXH32 streaming API.\n *\n * @note This is only defined when @ref XXH_STATIC_LINKING_ONLY,\n * @ref XXH_INLINE_ALL, or @ref XXH_IMPLEMENTATION is defined. Otherwise it is\n * an opaque type. This allows fields to safely be changed.\n *\n * Typedef'd to @ref XXH32_state_t.\n * Do not access the members of this struct directly.\n * @see XXH64_state_s, XXH3_state_s\n */\nstruct XXH32_state_s {\n   XXH32_hash_t total_len_32; /*!< Total length hashed, modulo 2^32 */\n   XXH32_hash_t large_len;    /*!< Whether the hash is >= 16 (handles @ref total_len_32 overflow) */\n   XXH32_hash_t v[4];         /*!< Accumulator lanes */\n   XXH32_hash_t mem32[4];     /*!< Internal buffer for partial reads. Treated as unsigned char[16]. */\n   XXH32_hash_t memsize;      /*!< Amount of data in @ref mem32 */\n   XXH32_hash_t reserved;     /*!< Reserved field. Do not read nor write to it. */\n};   /* typedef'd to XXH32_state_t */\n\n\n#ifndef XXH_NO_LONG_LONG  /* defined when there is no 64-bit support */\n\n/*!\n * @internal\n * @brief Structure for XXH64 streaming API.\n *\n * @note This is only defined when @ref XXH_STATIC_LINKING_ONLY,\n * @ref XXH_INLINE_ALL, or @ref XXH_IMPLEMENTATION is defined. Otherwise it is\n * an opaque type. This allows fields to safely be changed.\n *\n * Typedef'd to @ref XXH64_state_t.\n * Do not access the members of this struct directly.\n * @see XXH32_state_s, XXH3_state_s\n */\nstruct XXH64_state_s {\n   XXH64_hash_t total_len;    /*!< Total length hashed. This is always 64-bit. */\n   XXH64_hash_t v[4];         /*!< Accumulator lanes */\n   XXH64_hash_t mem64[4];     /*!< Internal buffer for partial reads. Treated as unsigned char[32]. */\n   XXH32_hash_t memsize;      /*!< Amount of data in @ref mem64 */\n   XXH32_hash_t reserved32;   /*!< Reserved field, needed for padding anyways*/\n   XXH64_hash_t reserved64;   /*!< Reserved field. Do not read or write to it. */\n};   /* typedef'd to XXH64_state_t */\n\n#ifndef XXH_NO_XXH3\n\n#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) /* >= C11 */\n#  include \n#  define XXH_ALIGN(n)      alignas(n)\n#elif defined(__cplusplus) && (__cplusplus >= 201103L) /* >= C++11 */\n/* In C++ alignas() is a keyword */\n#  define XXH_ALIGN(n)      alignas(n)\n#elif defined(__GNUC__)\n#  define XXH_ALIGN(n)      __attribute__ ((aligned(n)))\n#elif defined(_MSC_VER)\n#  define XXH_ALIGN(n)      __declspec(align(n))\n#else\n#  define XXH_ALIGN(n)   /* disabled */\n#endif\n\n/* Old GCC versions only accept the attribute after the type in structures. */\n#if !(defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L))   /* C11+ */ \\\n    && ! (defined(__cplusplus) && (__cplusplus >= 201103L)) /* >= C++11 */ \\\n    && defined(__GNUC__)\n#   define XXH_ALIGN_MEMBER(align, type) type XXH_ALIGN(align)\n#else\n#   define XXH_ALIGN_MEMBER(align, type) XXH_ALIGN(align) type\n#endif\n\n/*!\n * @brief The size of the internal XXH3 buffer.\n *\n * This is the optimal update size for incremental hashing.\n *\n * @see XXH3_64b_update(), XXH3_128b_update().\n */\n#define XXH3_INTERNALBUFFER_SIZE 256\n\n/*!\n * @internal\n * @brief Default size of the secret buffer (and @ref XXH3_kSecret).\n *\n * This is the size used in @ref XXH3_kSecret and the seeded functions.\n *\n * Not to be confused with @ref XXH3_SECRET_SIZE_MIN.\n */\n#define XXH3_SECRET_DEFAULT_SIZE 192\n\n/*!\n * @internal\n * @brief Structure for XXH3 streaming API.\n *\n * @note This is only defined when @ref XXH_STATIC_LINKING_ONLY,\n * @ref XXH_INLINE_ALL, or @ref XXH_IMPLEMENTATION is defined.\n * Otherwise it is an opaque type.\n * Never use this definition in combination with dynamic library.\n * This allows fields to safely be changed in the future.\n *\n * @note ** This structure has a strict alignment requirement of 64 bytes!! **\n * Do not allocate this with `malloc()` or `new`,\n * it will not be sufficiently aligned.\n * Use @ref XXH3_createState() and @ref XXH3_freeState(), or stack allocation.\n *\n * Typedef'd to @ref XXH3_state_t.\n * Do never access the members of this struct directly.\n *\n * @see XXH3_INITSTATE() for stack initialization.\n * @see XXH3_createState(), XXH3_freeState().\n * @see XXH32_state_s, XXH64_state_s\n */\nstruct XXH3_state_s {\n   XXH_ALIGN_MEMBER(64, XXH64_hash_t acc[8]);\n       /*!< The 8 accumulators. See @ref XXH32_state_s::v and @ref XXH64_state_s::v */\n   XXH_ALIGN_MEMBER(64, unsigned char customSecret[XXH3_SECRET_DEFAULT_SIZE]);\n       /*!< Used to store a custom secret generated from a seed. */\n   XXH_ALIGN_MEMBER(64, unsigned char buffer[XXH3_INTERNALBUFFER_SIZE]);\n       /*!< The internal buffer. @see XXH32_state_s::mem32 */\n   XXH32_hash_t bufferedSize;\n       /*!< The amount of memory in @ref buffer, @see XXH32_state_s::memsize */\n   XXH32_hash_t useSeed;\n       /*!< Reserved field. Needed for padding on 64-bit. */\n   size_t nbStripesSoFar;\n       /*!< Number or stripes processed. */\n   XXH64_hash_t totalLen;\n       /*!< Total length hashed. 64-bit even on 32-bit targets. */\n   size_t nbStripesPerBlock;\n       /*!< Number of stripes per block. */\n   size_t secretLimit;\n       /*!< Size of @ref customSecret or @ref extSecret */\n   XXH64_hash_t seed;\n       /*!< Seed for _withSeed variants. Must be zero otherwise, @see XXH3_INITSTATE() */\n   XXH64_hash_t reserved64;\n       /*!< Reserved field. */\n   const unsigned char* extSecret;\n       /*!< Reference to an external secret for the _withSecret variants, NULL\n        *   for other variants. */\n   /* note: there may be some padding at the end due to alignment on 64 bytes */\n}; /* typedef'd to XXH3_state_t */\n\n#undef XXH_ALIGN_MEMBER\n\n/*!\n * @brief Initializes a stack-allocated `XXH3_state_s`.\n *\n * When the @ref XXH3_state_t structure is merely emplaced on stack,\n * it should be initialized with XXH3_INITSTATE() or a memset()\n * in case its first reset uses XXH3_NNbits_reset_withSeed().\n * This init can be omitted if the first reset uses default or _withSecret mode.\n * This operation isn't necessary when the state is created with XXH3_createState().\n * Note that this doesn't prepare the state for a streaming operation,\n * it's still necessary to use XXH3_NNbits_reset*() afterwards.\n */\n#define XXH3_INITSTATE(XXH3_state_ptr)                       \\\n    do {                                                     \\\n        XXH3_state_t* tmp_xxh3_state_ptr = (XXH3_state_ptr); \\\n        tmp_xxh3_state_ptr->seed = 0;                        \\\n        tmp_xxh3_state_ptr->extSecret = NULL;                \\\n    } while(0)\n\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n\n/*!\n * @brief Calculates the 128-bit hash of @p data using XXH3.\n *\n * @param data The block of data to be hashed, at least @p len bytes in size.\n * @param len  The length of @p data, in bytes.\n * @param seed The 64-bit seed to alter the hash's output predictably.\n *\n * @pre\n *   The memory between @p data and @p data + @p len must be valid,\n *   readable, contiguous memory. However, if @p len is `0`, @p data may be\n *   `NULL`. In C++, this also must be *TriviallyCopyable*.\n *\n * @return The calculated 128-bit XXH3 value.\n *\n * @see @ref single_shot_example \"Single Shot Example\" for an example.\n */\nXXH_PUBLIC_API XXH_PUREF XXH128_hash_t XXH128(XXH_NOESCAPE const void* data, size_t len, XXH64_hash_t seed);\n\n\n/* ===   Experimental API   === */\n/* Symbols defined below must be considered tied to a specific library version. */\n\n/*!\n * @brief Derive a high-entropy secret from any user-defined content, named customSeed.\n *\n * @param secretBuffer    A writable buffer for derived high-entropy secret data.\n * @param secretSize      Size of secretBuffer, in bytes.  Must be >= XXH3_SECRET_DEFAULT_SIZE.\n * @param customSeed      A user-defined content.\n * @param customSeedSize  Size of customSeed, in bytes.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * The generated secret can be used in combination with `*_withSecret()` functions.\n * The `_withSecret()` variants are useful to provide a higher level of protection\n * than 64-bit seed, as it becomes much more difficult for an external actor to\n * guess how to impact the calculation logic.\n *\n * The function accepts as input a custom seed of any length and any content,\n * and derives from it a high-entropy secret of length @p secretSize into an\n * already allocated buffer @p secretBuffer.\n *\n * The generated secret can then be used with any `*_withSecret()` variant.\n * The functions @ref XXH3_128bits_withSecret(), @ref XXH3_64bits_withSecret(),\n * @ref XXH3_128bits_reset_withSecret() and @ref XXH3_64bits_reset_withSecret()\n * are part of this list. They all accept a `secret` parameter\n * which must be large enough for implementation reasons (>= @ref XXH3_SECRET_SIZE_MIN)\n * _and_ feature very high entropy (consist of random-looking bytes).\n * These conditions can be a high bar to meet, so @ref XXH3_generateSecret() can\n * be employed to ensure proper quality.\n *\n * @p customSeed can be anything. It can have any size, even small ones,\n * and its content can be anything, even \"poor entropy\" sources such as a bunch\n * of zeroes. The resulting `secret` will nonetheless provide all required qualities.\n *\n * @pre\n *   - @p secretSize must be >= @ref XXH3_SECRET_SIZE_MIN\n *   - When @p customSeedSize > 0, supplying NULL as customSeed is undefined behavior.\n *\n * Example code:\n * @code{.c}\n *    #include \n *    #include \n *    #include \n *    #define XXH_STATIC_LINKING_ONLY // expose unstable API\n *    #include \"xxhash.h\"\n *    // Hashes argv[2] using the entropy from argv[1].\n *    int main(int argc, char* argv[])\n *    {\n *        char secret[XXH3_SECRET_SIZE_MIN];\n *        if (argv != 3) { return 1; }\n *        XXH3_generateSecret(secret, sizeof(secret), argv[1], strlen(argv[1]));\n *        XXH64_hash_t h = XXH3_64bits_withSecret(\n *             argv[2], strlen(argv[2]),\n *             secret, sizeof(secret)\n *        );\n *        printf(\"%016llx\\n\", (unsigned long long) h);\n *    }\n * @endcode\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_generateSecret(XXH_NOESCAPE void* secretBuffer, size_t secretSize, XXH_NOESCAPE const void* customSeed, size_t customSeedSize);\n\n/*!\n * @brief Generate the same secret as the _withSeed() variants.\n *\n * @param secretBuffer A writable buffer of @ref XXH3_SECRET_SIZE_MIN bytes\n * @param seed         The 64-bit seed to alter the hash result predictably.\n *\n * The generated secret can be used in combination with\n *`*_withSecret()` and `_withSecretandSeed()` variants.\n *\n * Example C++ `std::string` hash class:\n * @code{.cpp}\n *    #include \n *    #define XXH_STATIC_LINKING_ONLY // expose unstable API\n *    #include \"xxhash.h\"\n *    // Slow, seeds each time\n *    class HashSlow {\n *        XXH64_hash_t seed;\n *    public:\n *        HashSlow(XXH64_hash_t s) : seed{s} {}\n *        size_t operator()(const std::string& x) const {\n *            return size_t{XXH3_64bits_withSeed(x.c_str(), x.length(), seed)};\n *        }\n *    };\n *    // Fast, caches the seeded secret for future uses.\n *    class HashFast {\n *        unsigned char secret[XXH3_SECRET_SIZE_MIN];\n *    public:\n *        HashFast(XXH64_hash_t s) {\n *            XXH3_generateSecret_fromSeed(secret, seed);\n *        }\n *        size_t operator()(const std::string& x) const {\n *            return size_t{\n *                XXH3_64bits_withSecret(x.c_str(), x.length(), secret, sizeof(secret))\n *            };\n *        }\n *    };\n * @endcode\n */\nXXH_PUBLIC_API void XXH3_generateSecret_fromSeed(XXH_NOESCAPE void* secretBuffer, XXH64_hash_t seed);\n\n/*!\n * @brief Calculates 64/128-bit seeded variant of XXH3 hash of @p data.\n *\n * @param data       The block of data to be hashed, at least @p len bytes in size.\n * @param len        The length of @p data, in bytes.\n * @param secret     The secret data.\n * @param secretSize The length of @p secret, in bytes.\n * @param seed       The 64-bit seed to alter the hash result predictably.\n *\n * These variants generate hash values using either\n * @p seed for \"short\" keys (< @ref XXH3_MIDSIZE_MAX = 240 bytes)\n * or @p secret for \"large\" keys (>= @ref XXH3_MIDSIZE_MAX).\n *\n * This generally benefits speed, compared to `_withSeed()` or `_withSecret()`.\n * `_withSeed()` has to generate the secret on the fly for \"large\" keys.\n * It's fast, but can be perceptible for \"not so large\" keys (< 1 KB).\n * `_withSecret()` has to generate the masks on the fly for \"small\" keys,\n * which requires more instructions than _withSeed() variants.\n * Therefore, _withSecretandSeed variant combines the best of both worlds.\n *\n * When @p secret has been generated by XXH3_generateSecret_fromSeed(),\n * this variant produces *exactly* the same results as `_withSeed()` variant,\n * hence offering only a pure speed benefit on \"large\" input,\n * by skipping the need to regenerate the secret for every large input.\n *\n * Another usage scenario is to hash the secret to a 64-bit hash value,\n * for example with XXH3_64bits(), which then becomes the seed,\n * and then employ both the seed and the secret in _withSecretandSeed().\n * On top of speed, an added benefit is that each bit in the secret\n * has a 50% chance to swap each bit in the output, via its impact to the seed.\n *\n * This is not guaranteed when using the secret directly in \"small data\" scenarios,\n * because only portions of the secret are employed for small data.\n */\nXXH_PUBLIC_API XXH_PUREF XXH64_hash_t\nXXH3_64bits_withSecretandSeed(XXH_NOESCAPE const void* data, size_t len,\n                              XXH_NOESCAPE const void* secret, size_t secretSize,\n                              XXH64_hash_t seed);\n/*!\n * @brief Calculates 128-bit seeded variant of XXH3 hash of @p data.\n *\n * @param input      The block of data to be hashed, at least @p len bytes in size.\n * @param length     The length of @p data, in bytes.\n * @param secret     The secret data.\n * @param secretSize The length of @p secret, in bytes.\n * @param seed64     The 64-bit seed to alter the hash result predictably.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @see XXH3_64bits_withSecretandSeed()\n */\nXXH_PUBLIC_API XXH_PUREF XXH128_hash_t\nXXH3_128bits_withSecretandSeed(XXH_NOESCAPE const void* input, size_t length,\n                               XXH_NOESCAPE const void* secret, size_t secretSize,\n                               XXH64_hash_t seed64);\n#ifndef XXH_NO_STREAM\n/*!\n * @brief Resets an @ref XXH3_state_t with secret data to begin a new hash.\n *\n * @param statePtr   A pointer to an @ref XXH3_state_t allocated with @ref XXH3_createState().\n * @param secret     The secret data.\n * @param secretSize The length of @p secret, in bytes.\n * @param seed64     The 64-bit seed to alter the hash result predictably.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @see XXH3_64bits_withSecretandSeed()\n */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_64bits_reset_withSecretandSeed(XXH_NOESCAPE XXH3_state_t* statePtr,\n                                    XXH_NOESCAPE const void* secret, size_t secretSize,\n                                    XXH64_hash_t seed64);\n/*!\n * @brief Resets an @ref XXH3_state_t with secret data to begin a new hash.\n *\n * @param statePtr   A pointer to an @ref XXH3_state_t allocated with @ref XXH3_createState().\n * @param secret     The secret data.\n * @param secretSize The length of @p secret, in bytes.\n * @param seed64     The 64-bit seed to alter the hash result predictably.\n *\n * @return @ref XXH_OK on success.\n * @return @ref XXH_ERROR on failure.\n *\n * @see XXH3_64bits_withSecretandSeed()\n */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_128bits_reset_withSecretandSeed(XXH_NOESCAPE XXH3_state_t* statePtr,\n                                     XXH_NOESCAPE const void* secret, size_t secretSize,\n                                     XXH64_hash_t seed64);\n#endif /* !XXH_NO_STREAM */\n\n#if defined (__cplusplus)\n} /* extern \"C\" */\n#endif\n\n#endif  /* !XXH_NO_XXH3 */\n#endif  /* XXH_NO_LONG_LONG */\n\n#if defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)\n#  define XXH_IMPLEMENTATION\n#endif\n\n#endif  /* defined(XXH_STATIC_LINKING_ONLY) && !defined(XXHASH_H_STATIC_13879238742) */\n\n\n/* ======================================================================== */\n/* ======================================================================== */\n/* ======================================================================== */\n\n\n/*-**********************************************************************\n * xxHash implementation\n *-**********************************************************************\n * xxHash's implementation used to be hosted inside xxhash.c.\n *\n * However, inlining requires implementation to be visible to the compiler,\n * hence be included alongside the header.\n * Previously, implementation was hosted inside xxhash.c,\n * which was then #included when inlining was activated.\n * This construction created issues with a few build and install systems,\n * as it required xxhash.c to be stored in /include directory.\n *\n * xxHash implementation is now directly integrated within xxhash.h.\n * As a consequence, xxhash.c is no longer needed in /include.\n *\n * xxhash.c is still available and is still useful.\n * In a \"normal\" setup, when xxhash is not inlined,\n * xxhash.h only exposes the prototypes and public symbols,\n * while xxhash.c can be built into an object file xxhash.o\n * which can then be linked into the final binary.\n ************************************************************************/\n\n#if ( defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API) \\\n   || defined(XXH_IMPLEMENTATION) ) && !defined(XXH_IMPLEM_13a8737387)\n#  define XXH_IMPLEM_13a8737387\n\n/* *************************************\n*  Tuning parameters\n***************************************/\n\n/*!\n * @defgroup tuning Tuning parameters\n * @{\n *\n * Various macros to control xxHash's behavior.\n */\n#ifdef XXH_DOXYGEN\n/*!\n * @brief Define this to disable 64-bit code.\n *\n * Useful if only using the @ref XXH32_family and you have a strict C90 compiler.\n */\n#  define XXH_NO_LONG_LONG\n#  undef XXH_NO_LONG_LONG /* don't actually */\n/*!\n * @brief Controls how unaligned memory is accessed.\n *\n * By default, access to unaligned memory is controlled by `memcpy()`, which is\n * safe and portable.\n *\n * Unfortunately, on some target/compiler combinations, the generated assembly\n * is sub-optimal.\n *\n * The below switch allow selection of a different access method\n * in the search for improved performance.\n *\n * @par Possible options:\n *\n *  - `XXH_FORCE_MEMORY_ACCESS=0` (default): `memcpy`\n *   @par\n *     Use `memcpy()`. Safe and portable. Note that most modern compilers will\n *     eliminate the function call and treat it as an unaligned access.\n *\n *  - `XXH_FORCE_MEMORY_ACCESS=1`: `__attribute__((aligned(1)))`\n *   @par\n *     Depends on compiler extensions and is therefore not portable.\n *     This method is safe _if_ your compiler supports it,\n *     and *generally* as fast or faster than `memcpy`.\n *\n *  - `XXH_FORCE_MEMORY_ACCESS=2`: Direct cast\n *  @par\n *     Casts directly and dereferences. This method doesn't depend on the\n *     compiler, but it violates the C standard as it directly dereferences an\n *     unaligned pointer. It can generate buggy code on targets which do not\n *     support unaligned memory accesses, but in some circumstances, it's the\n *     only known way to get the most performance.\n *\n *  - `XXH_FORCE_MEMORY_ACCESS=3`: Byteshift\n *  @par\n *     Also portable. This can generate the best code on old compilers which don't\n *     inline small `memcpy()` calls, and it might also be faster on big-endian\n *     systems which lack a native byteswap instruction. However, some compilers\n *     will emit literal byteshifts even if the target supports unaligned access.\n *\n *\n * @warning\n *   Methods 1 and 2 rely on implementation-defined behavior. Use these with\n *   care, as what works on one compiler/platform/optimization level may cause\n *   another to read garbage data or even crash.\n *\n * See https://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html for details.\n *\n * Prefer these methods in priority order (0 > 3 > 1 > 2)\n */\n#  define XXH_FORCE_MEMORY_ACCESS 0\n\n/*!\n * @def XXH_SIZE_OPT\n * @brief Controls how much xxHash optimizes for size.\n *\n * xxHash, when compiled, tends to result in a rather large binary size. This\n * is mostly due to heavy usage to forced inlining and constant folding of the\n * @ref XXH3_family to increase performance.\n *\n * However, some developers prefer size over speed. This option can\n * significantly reduce the size of the generated code. When using the `-Os`\n * or `-Oz` options on GCC or Clang, this is defined to 1 by default,\n * otherwise it is defined to 0.\n *\n * Most of these size optimizations can be controlled manually.\n *\n * This is a number from 0-2.\n *  - `XXH_SIZE_OPT` == 0: Default. xxHash makes no size optimizations. Speed\n *    comes first.\n *  - `XXH_SIZE_OPT` == 1: Default for `-Os` and `-Oz`. xxHash is more\n *    conservative and disables hacks that increase code size. It implies the\n *    options @ref XXH_NO_INLINE_HINTS == 1, @ref XXH_FORCE_ALIGN_CHECK == 0,\n *    and @ref XXH3_NEON_LANES == 8 if they are not already defined.\n *  - `XXH_SIZE_OPT` == 2: xxHash tries to make itself as small as possible.\n *    Performance may cry. For example, the single shot functions just use the\n *    streaming API.\n */\n#  define XXH_SIZE_OPT 0\n\n/*!\n * @def XXH_FORCE_ALIGN_CHECK\n * @brief If defined to non-zero, adds a special path for aligned inputs (XXH32()\n * and XXH64() only).\n *\n * This is an important performance trick for architectures without decent\n * unaligned memory access performance.\n *\n * It checks for input alignment, and when conditions are met, uses a \"fast\n * path\" employing direct 32-bit/64-bit reads, resulting in _dramatically\n * faster_ read speed.\n *\n * The check costs one initial branch per hash, which is generally negligible,\n * but not zero.\n *\n * Moreover, it's not useful to generate an additional code path if memory\n * access uses the same instruction for both aligned and unaligned\n * addresses (e.g. x86 and aarch64).\n *\n * In these cases, the alignment check can be removed by setting this macro to 0.\n * Then the code will always use unaligned memory access.\n * Align check is automatically disabled on x86, x64, ARM64, and some ARM chips\n * which are platforms known to offer good unaligned memory accesses performance.\n *\n * It is also disabled by default when @ref XXH_SIZE_OPT >= 1.\n *\n * This option does not affect XXH3 (only XXH32 and XXH64).\n */\n#  define XXH_FORCE_ALIGN_CHECK 0\n\n/*!\n * @def XXH_NO_INLINE_HINTS\n * @brief When non-zero, sets all functions to `static`.\n *\n * By default, xxHash tries to force the compiler to inline almost all internal\n * functions.\n *\n * This can usually improve performance due to reduced jumping and improved\n * constant folding, but significantly increases the size of the binary which\n * might not be favorable.\n *\n * Additionally, sometimes the forced inlining can be detrimental to performance,\n * depending on the architecture.\n *\n * XXH_NO_INLINE_HINTS marks all internal functions as static, giving the\n * compiler full control on whether to inline or not.\n *\n * When not optimizing (-O0), using `-fno-inline` with GCC or Clang, or if\n * @ref XXH_SIZE_OPT >= 1, this will automatically be defined.\n */\n#  define XXH_NO_INLINE_HINTS 0\n\n/*!\n * @def XXH3_INLINE_SECRET\n * @brief Determines whether to inline the XXH3 withSecret code.\n *\n * When the secret size is known, the compiler can improve the performance\n * of XXH3_64bits_withSecret() and XXH3_128bits_withSecret().\n *\n * However, if the secret size is not known, it doesn't have any benefit. This\n * happens when xxHash is compiled into a global symbol. Therefore, if\n * @ref XXH_INLINE_ALL is *not* defined, this will be defined to 0.\n *\n * Additionally, this defaults to 0 on GCC 12+, which has an issue with function pointers\n * that are *sometimes* force inline on -Og, and it is impossible to automatically\n * detect this optimization level.\n */\n#  define XXH3_INLINE_SECRET 0\n\n/*!\n * @def XXH32_ENDJMP\n * @brief Whether to use a jump for `XXH32_finalize`.\n *\n * For performance, `XXH32_finalize` uses multiple branches in the finalizer.\n * This is generally preferable for performance,\n * but depending on exact architecture, a jmp may be preferable.\n *\n * This setting is only possibly making a difference for very small inputs.\n */\n#  define XXH32_ENDJMP 0\n\n/*!\n * @internal\n * @brief Redefines old internal names.\n *\n * For compatibility with code that uses xxHash's internals before the names\n * were changed to improve namespacing. There is no other reason to use this.\n */\n#  define XXH_OLD_NAMES\n#  undef XXH_OLD_NAMES /* don't actually use, it is ugly. */\n\n/*!\n * @def XXH_NO_STREAM\n * @brief Disables the streaming API.\n *\n * When xxHash is not inlined and the streaming functions are not used, disabling\n * the streaming functions can improve code size significantly, especially with\n * the @ref XXH3_family which tends to make constant folded copies of itself.\n */\n#  define XXH_NO_STREAM\n#  undef XXH_NO_STREAM /* don't actually */\n#endif /* XXH_DOXYGEN */\n/*!\n * @}\n */\n\n#ifndef XXH_FORCE_MEMORY_ACCESS   /* can be defined externally, on command line for example */\n   /* prefer __packed__ structures (method 1) for GCC\n    * < ARMv7 with unaligned access (e.g. Raspbian armhf) still uses byte shifting, so we use memcpy\n    * which for some reason does unaligned loads. */\n#  if defined(__GNUC__) && !(defined(__ARM_ARCH) && __ARM_ARCH < 7 && defined(__ARM_FEATURE_UNALIGNED))\n#    define XXH_FORCE_MEMORY_ACCESS 1\n#  endif\n#endif\n\n#ifndef XXH_SIZE_OPT\n   /* default to 1 for -Os or -Oz */\n#  if (defined(__GNUC__) || defined(__clang__)) && defined(__OPTIMIZE_SIZE__)\n#    define XXH_SIZE_OPT 1\n#  else\n#    define XXH_SIZE_OPT 0\n#  endif\n#endif\n\n#ifndef XXH_FORCE_ALIGN_CHECK  /* can be defined externally */\n   /* don't check on sizeopt, x86, aarch64, or arm when unaligned access is available */\n#  if XXH_SIZE_OPT >= 1 || \\\n      defined(__i386)  || defined(__x86_64__) || defined(__aarch64__) || defined(__ARM_FEATURE_UNALIGNED) \\\n   || defined(_M_IX86) || defined(_M_X64)     || defined(_M_ARM64)    || defined(_M_ARM) /* visual */\n#    define XXH_FORCE_ALIGN_CHECK 0\n#  else\n#    define XXH_FORCE_ALIGN_CHECK 1\n#  endif\n#endif\n\n#ifndef XXH_NO_INLINE_HINTS\n#  if XXH_SIZE_OPT >= 1 || defined(__NO_INLINE__)  /* -O0, -fno-inline */\n#    define XXH_NO_INLINE_HINTS 1\n#  else\n#    define XXH_NO_INLINE_HINTS 0\n#  endif\n#endif\n\n#ifndef XXH3_INLINE_SECRET\n#  if (defined(__GNUC__) && !defined(__clang__) && __GNUC__ >= 12) \\\n     || !defined(XXH_INLINE_ALL)\n#    define XXH3_INLINE_SECRET 0\n#  else\n#    define XXH3_INLINE_SECRET 1\n#  endif\n#endif\n\n#ifndef XXH32_ENDJMP\n/* generally preferable for performance */\n#  define XXH32_ENDJMP 0\n#endif\n\n/*!\n * @defgroup impl Implementation\n * @{\n */\n\n/* *************************************\n*  Includes & Memory related functions\n***************************************/\n#include    /* memcmp, memcpy */\n#include    /* ULLONG_MAX */\n\n#if defined(XXH_NO_STREAM)\n/* nothing */\n#elif defined(XXH_NO_STDLIB)\n\n/* When requesting to disable any mention of stdlib,\n * the library loses the ability to invoked malloc / free.\n * In practice, it means that functions like `XXH*_createState()`\n * will always fail, and return NULL.\n * This flag is useful in situations where\n * xxhash.h is integrated into some kernel, embedded or limited environment\n * without access to dynamic allocation.\n */\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n\nstatic XXH_CONSTF void* XXH_malloc(size_t s) { (void)s; return NULL; }\nstatic void XXH_free(void* p) { (void)p; }\n\n#if defined (__cplusplus)\n} /* extern \"C\" */\n#endif\n\n#else\n\n/*\n * Modify the local functions below should you wish to use\n * different memory routines for malloc() and free()\n */\n#include \n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n/*!\n * @internal\n * @brief Modify this function to use a different routine than malloc().\n */\nstatic XXH_MALLOCF void* XXH_malloc(size_t s) { return malloc(s); }\n\n/*!\n * @internal\n * @brief Modify this function to use a different routine than free().\n */\nstatic void XXH_free(void* p) { free(p); }\n\n#if defined (__cplusplus)\n} /* extern \"C\" */\n#endif\n\n#endif  /* XXH_NO_STDLIB */\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n/*!\n * @internal\n * @brief Modify this function to use a different routine than memcpy().\n */\nstatic void* XXH_memcpy(void* dest, const void* src, size_t size)\n{\n    return memcpy(dest,src,size);\n}\n\n#if defined (__cplusplus)\n} /* extern \"C\" */\n#endif\n\n/* *************************************\n*  Compiler Specific Options\n***************************************/\n#ifdef _MSC_VER /* Visual Studio warning fix */\n#  pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */\n#endif\n\n#if XXH_NO_INLINE_HINTS  /* disable inlining hints */\n#  if defined(__GNUC__) || defined(__clang__)\n#    define XXH_FORCE_INLINE static __attribute__((unused))\n#  else\n#    define XXH_FORCE_INLINE static\n#  endif\n#  define XXH_NO_INLINE static\n/* enable inlining hints */\n#elif defined(__GNUC__) || defined(__clang__)\n#  define XXH_FORCE_INLINE static __inline__ __attribute__((always_inline, unused))\n#  define XXH_NO_INLINE static __attribute__((noinline))\n#elif defined(_MSC_VER)  /* Visual Studio */\n#  define XXH_FORCE_INLINE static __forceinline\n#  define XXH_NO_INLINE static __declspec(noinline)\n#elif defined (__cplusplus) \\\n  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L))   /* C99 */\n#  define XXH_FORCE_INLINE static inline\n#  define XXH_NO_INLINE static\n#else\n#  define XXH_FORCE_INLINE static\n#  define XXH_NO_INLINE static\n#endif\n\n#if XXH3_INLINE_SECRET\n#  define XXH3_WITH_SECRET_INLINE XXH_FORCE_INLINE\n#else\n#  define XXH3_WITH_SECRET_INLINE XXH_NO_INLINE\n#endif\n\n\n/* *************************************\n*  Debug\n***************************************/\n/*!\n * @ingroup tuning\n * @def XXH_DEBUGLEVEL\n * @brief Sets the debugging level.\n *\n * XXH_DEBUGLEVEL is expected to be defined externally, typically via the\n * compiler's command line options. The value must be a number.\n */\n#ifndef XXH_DEBUGLEVEL\n#  ifdef DEBUGLEVEL /* backwards compat */\n#    define XXH_DEBUGLEVEL DEBUGLEVEL\n#  else\n#    define XXH_DEBUGLEVEL 0\n#  endif\n#endif\n\n#if (XXH_DEBUGLEVEL>=1)\n#  include    /* note: can still be disabled with NDEBUG */\n#  define XXH_ASSERT(c)   assert(c)\n#else\n#  if defined(__INTEL_COMPILER)\n#    define XXH_ASSERT(c)   XXH_ASSUME((unsigned char) (c))\n#  else\n#    define XXH_ASSERT(c)   XXH_ASSUME(c)\n#  endif\n#endif\n\n/* note: use after variable declarations */\n#ifndef XXH_STATIC_ASSERT\n#  if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)    /* C11 */\n#    define XXH_STATIC_ASSERT_WITH_MESSAGE(c,m) do { _Static_assert((c),m); } while(0)\n#  elif defined(__cplusplus) && (__cplusplus >= 201103L)            /* C++11 */\n#    define XXH_STATIC_ASSERT_WITH_MESSAGE(c,m) do { static_assert((c),m); } while(0)\n#  else\n#    define XXH_STATIC_ASSERT_WITH_MESSAGE(c,m) do { struct xxh_sa { char x[(c) ? 1 : -1]; }; } while(0)\n#  endif\n#  define XXH_STATIC_ASSERT(c) XXH_STATIC_ASSERT_WITH_MESSAGE((c),#c)\n#endif\n\n/*!\n * @internal\n * @def XXH_COMPILER_GUARD(var)\n * @brief Used to prevent unwanted optimizations for @p var.\n *\n * It uses an empty GCC inline assembly statement with a register constraint\n * which forces @p var into a general purpose register (eg eax, ebx, ecx\n * on x86) and marks it as modified.\n *\n * This is used in a few places to avoid unwanted autovectorization (e.g.\n * XXH32_round()). All vectorization we want is explicit via intrinsics,\n * and _usually_ isn't wanted elsewhere.\n *\n * We also use it to prevent unwanted constant folding for AArch64 in\n * XXH3_initCustomSecret_scalar().\n */\n#if defined(__GNUC__) || defined(__clang__)\n#  define XXH_COMPILER_GUARD(var) __asm__(\"\" : \"+r\" (var))\n#else\n#  define XXH_COMPILER_GUARD(var) ((void)0)\n#endif\n\n/* Specifically for NEON vectors which use the \"w\" constraint, on\n * Clang. */\n#if defined(__clang__) && defined(__ARM_ARCH) && !defined(__wasm__)\n#  define XXH_COMPILER_GUARD_CLANG_NEON(var) __asm__(\"\" : \"+w\" (var))\n#else\n#  define XXH_COMPILER_GUARD_CLANG_NEON(var) ((void)0)\n#endif\n\n/* *************************************\n*  Basic Types\n***************************************/\n#if !defined (__VMS) \\\n && (defined (__cplusplus) \\\n || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )\n# ifdef _AIX\n#   include \n# else\n#   include \n# endif\n  typedef uint8_t xxh_u8;\n#else\n  typedef unsigned char xxh_u8;\n#endif\ntypedef XXH32_hash_t xxh_u32;\n\n#ifdef XXH_OLD_NAMES\n#  warning \"XXH_OLD_NAMES is planned to be removed starting v0.9. If the program depends on it, consider moving away from it by employing newer type names directly\"\n#  define BYTE xxh_u8\n#  define U8   xxh_u8\n#  define U32  xxh_u32\n#endif\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n\n/* ***   Memory access   *** */\n\n/*!\n * @internal\n * @fn xxh_u32 XXH_read32(const void* ptr)\n * @brief Reads an unaligned 32-bit integer from @p ptr in native endianness.\n *\n * Affected by @ref XXH_FORCE_MEMORY_ACCESS.\n *\n * @param ptr The pointer to read from.\n * @return The 32-bit native endian integer from the bytes at @p ptr.\n */\n\n/*!\n * @internal\n * @fn xxh_u32 XXH_readLE32(const void* ptr)\n * @brief Reads an unaligned 32-bit little endian integer from @p ptr.\n *\n * Affected by @ref XXH_FORCE_MEMORY_ACCESS.\n *\n * @param ptr The pointer to read from.\n * @return The 32-bit little endian integer from the bytes at @p ptr.\n */\n\n/*!\n * @internal\n * @fn xxh_u32 XXH_readBE32(const void* ptr)\n * @brief Reads an unaligned 32-bit big endian integer from @p ptr.\n *\n * Affected by @ref XXH_FORCE_MEMORY_ACCESS.\n *\n * @param ptr The pointer to read from.\n * @return The 32-bit big endian integer from the bytes at @p ptr.\n */\n\n/*!\n * @internal\n * @fn xxh_u32 XXH_readLE32_align(const void* ptr, XXH_alignment align)\n * @brief Like @ref XXH_readLE32(), but has an option for aligned reads.\n *\n * Affected by @ref XXH_FORCE_MEMORY_ACCESS.\n * Note that when @ref XXH_FORCE_ALIGN_CHECK == 0, the @p align parameter is\n * always @ref XXH_alignment::XXH_unaligned.\n *\n * @param ptr The pointer to read from.\n * @param align Whether @p ptr is aligned.\n * @pre\n *   If @p align == @ref XXH_alignment::XXH_aligned, @p ptr must be 4 byte\n *   aligned.\n * @return The 32-bit little endian integer from the bytes at @p ptr.\n */\n\n#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==3))\n/*\n * Manual byteshift. Best for old compilers which don't inline memcpy.\n * We actually directly use XXH_readLE32 and XXH_readBE32.\n */\n#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2))\n\n/*\n * Force direct memory access. Only works on CPU which support unaligned memory\n * access in hardware.\n */\nstatic xxh_u32 XXH_read32(const void* memPtr) { return *(const xxh_u32*) memPtr; }\n\n#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))\n\n/*\n * __attribute__((aligned(1))) is supported by gcc and clang. Originally the\n * documentation claimed that it only increased the alignment, but actually it\n * can decrease it on gcc, clang, and icc:\n * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69502,\n * https://gcc.godbolt.org/z/xYez1j67Y.\n */\n#ifdef XXH_OLD_NAMES\ntypedef union { xxh_u32 u32; } __attribute__((packed)) unalign;\n#endif\nstatic xxh_u32 XXH_read32(const void* ptr)\n{\n    typedef __attribute__((aligned(1))) xxh_u32 xxh_unalign32;\n    return *((const xxh_unalign32*)ptr);\n}\n\n#else\n\n/*\n * Portable and safe solution. Generally efficient.\n * see: https://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html\n */\nstatic xxh_u32 XXH_read32(const void* memPtr)\n{\n    xxh_u32 val;\n    XXH_memcpy(&val, memPtr, sizeof(val));\n    return val;\n}\n\n#endif   /* XXH_FORCE_DIRECT_MEMORY_ACCESS */\n\n\n/* ***   Endianness   *** */\n\n/*!\n * @ingroup tuning\n * @def XXH_CPU_LITTLE_ENDIAN\n * @brief Whether the target is little endian.\n *\n * Defined to 1 if the target is little endian, or 0 if it is big endian.\n * It can be defined externally, for example on the compiler command line.\n *\n * If it is not defined,\n * a runtime check (which is usually constant folded) is used instead.\n *\n * @note\n *   This is not necessarily defined to an integer constant.\n *\n * @see XXH_isLittleEndian() for the runtime check.\n */\n#ifndef XXH_CPU_LITTLE_ENDIAN\n/*\n * Try to detect endianness automatically, to avoid the nonstandard behavior\n * in `XXH_isLittleEndian()`\n */\n#  if defined(_WIN32) /* Windows is always little endian */ \\\n     || defined(__LITTLE_ENDIAN__) \\\n     || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)\n#    define XXH_CPU_LITTLE_ENDIAN 1\n#  elif defined(__BIG_ENDIAN__) \\\n     || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)\n#    define XXH_CPU_LITTLE_ENDIAN 0\n#  else\n/*!\n * @internal\n * @brief Runtime check for @ref XXH_CPU_LITTLE_ENDIAN.\n *\n * Most compilers will constant fold this.\n */\nstatic int XXH_isLittleEndian(void)\n{\n    /*\n     * Portable and well-defined behavior.\n     * Don't use static: it is detrimental to performance.\n     */\n    const union { xxh_u32 u; xxh_u8 c[4]; } one = { 1 };\n    return one.c[0];\n}\n#   define XXH_CPU_LITTLE_ENDIAN   XXH_isLittleEndian()\n#  endif\n#endif\n\n\n\n\n/* ****************************************\n*  Compiler-specific Functions and Macros\n******************************************/\n#define XXH_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)\n\n#ifdef __has_builtin\n#  define XXH_HAS_BUILTIN(x) __has_builtin(x)\n#else\n#  define XXH_HAS_BUILTIN(x) 0\n#endif\n\n\n\n/*\n * C23 and future versions have standard \"unreachable()\".\n * Once it has been implemented reliably we can add it as an\n * additional case:\n *\n * ```\n * #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= XXH_C23_VN)\n * #  include \n * #  ifdef unreachable\n * #    define XXH_UNREACHABLE() unreachable()\n * #  endif\n * #endif\n * ```\n *\n * Note C++23 also has std::unreachable() which can be detected\n * as follows:\n * ```\n * #if defined(__cpp_lib_unreachable) && (__cpp_lib_unreachable >= 202202L)\n * #  include \n * #  define XXH_UNREACHABLE() std::unreachable()\n * #endif\n * ```\n * NB: `__cpp_lib_unreachable` is defined in the `` header.\n * We don't use that as including `` in `extern \"C\"` blocks\n * doesn't work on GCC12\n */\n\n#if XXH_HAS_BUILTIN(__builtin_unreachable)\n#  define XXH_UNREACHABLE() __builtin_unreachable()\n\n#elif defined(_MSC_VER)\n#  define XXH_UNREACHABLE() __assume(0)\n\n#else\n#  define XXH_UNREACHABLE()\n#endif\n\n#if XXH_HAS_BUILTIN(__builtin_assume)\n#  define XXH_ASSUME(c) __builtin_assume(c)\n#else\n#  define XXH_ASSUME(c) if (!(c)) { XXH_UNREACHABLE(); }\n#endif\n\n/*!\n * @internal\n * @def XXH_rotl32(x,r)\n * @brief 32-bit rotate left.\n *\n * @param x The 32-bit integer to be rotated.\n * @param r The number of bits to rotate.\n * @pre\n *   @p r > 0 && @p r < 32\n * @note\n *   @p x and @p r may be evaluated multiple times.\n * @return The rotated result.\n */\n#if !defined(NO_CLANG_BUILTIN) && XXH_HAS_BUILTIN(__builtin_rotateleft32) \\\n                               && XXH_HAS_BUILTIN(__builtin_rotateleft64)\n#  define XXH_rotl32 __builtin_rotateleft32\n#  define XXH_rotl64 __builtin_rotateleft64\n/* Note: although _rotl exists for minGW (GCC under windows), performance seems poor */\n#elif defined(_MSC_VER)\n#  define XXH_rotl32(x,r) _rotl(x,r)\n#  define XXH_rotl64(x,r) _rotl64(x,r)\n#else\n#  define XXH_rotl32(x,r) (((x) << (r)) | ((x) >> (32 - (r))))\n#  define XXH_rotl64(x,r) (((x) << (r)) | ((x) >> (64 - (r))))\n#endif\n\n/*!\n * @internal\n * @fn xxh_u32 XXH_swap32(xxh_u32 x)\n * @brief A 32-bit byteswap.\n *\n * @param x The 32-bit integer to byteswap.\n * @return @p x, byteswapped.\n */\n#if defined(_MSC_VER)     /* Visual Studio */\n#  define XXH_swap32 _byteswap_ulong\n#elif XXH_GCC_VERSION >= 403\n#  define XXH_swap32 __builtin_bswap32\n#else\nstatic xxh_u32 XXH_swap32 (xxh_u32 x)\n{\n    return  ((x << 24) & 0xff000000 ) |\n            ((x <<  8) & 0x00ff0000 ) |\n            ((x >>  8) & 0x0000ff00 ) |\n            ((x >> 24) & 0x000000ff );\n}\n#endif\n\n\n/* ***************************\n*  Memory reads\n*****************************/\n\n/*!\n * @internal\n * @brief Enum to indicate whether a pointer is aligned.\n */\ntypedef enum {\n    XXH_aligned,  /*!< Aligned */\n    XXH_unaligned /*!< Possibly unaligned */\n} XXH_alignment;\n\n/*\n * XXH_FORCE_MEMORY_ACCESS==3 is an endian-independent byteshift load.\n *\n * This is ideal for older compilers which don't inline memcpy.\n */\n#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==3))\n\nXXH_FORCE_INLINE xxh_u32 XXH_readLE32(const void* memPtr)\n{\n    const xxh_u8* bytePtr = (const xxh_u8 *)memPtr;\n    return bytePtr[0]\n         | ((xxh_u32)bytePtr[1] << 8)\n         | ((xxh_u32)bytePtr[2] << 16)\n         | ((xxh_u32)bytePtr[3] << 24);\n}\n\nXXH_FORCE_INLINE xxh_u32 XXH_readBE32(const void* memPtr)\n{\n    const xxh_u8* bytePtr = (const xxh_u8 *)memPtr;\n    return bytePtr[3]\n         | ((xxh_u32)bytePtr[2] << 8)\n         | ((xxh_u32)bytePtr[1] << 16)\n         | ((xxh_u32)bytePtr[0] << 24);\n}\n\n#else\nXXH_FORCE_INLINE xxh_u32 XXH_readLE32(const void* ptr)\n{\n    return XXH_CPU_LITTLE_ENDIAN ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr));\n}\n\nstatic xxh_u32 XXH_readBE32(const void* ptr)\n{\n    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap32(XXH_read32(ptr)) : XXH_read32(ptr);\n}\n#endif\n\nXXH_FORCE_INLINE xxh_u32\nXXH_readLE32_align(const void* ptr, XXH_alignment align)\n{\n    if (align==XXH_unaligned) {\n        return XXH_readLE32(ptr);\n    } else {\n        return XXH_CPU_LITTLE_ENDIAN ? *(const xxh_u32*)ptr : XXH_swap32(*(const xxh_u32*)ptr);\n    }\n}\n\n\n/* *************************************\n*  Misc\n***************************************/\n/*! @ingroup public */\nXXH_PUBLIC_API unsigned XXH_versionNumber (void) { return XXH_VERSION_NUMBER; }\n\n\n/* *******************************************************************\n*  32-bit hash functions\n*********************************************************************/\n/*!\n * @}\n * @defgroup XXH32_impl XXH32 implementation\n * @ingroup impl\n *\n * Details on the XXH32 implementation.\n * @{\n */\n /* #define instead of static const, to be used as initializers */\n#define XXH_PRIME32_1  0x9E3779B1U  /*!< 0b10011110001101110111100110110001 */\n#define XXH_PRIME32_2  0x85EBCA77U  /*!< 0b10000101111010111100101001110111 */\n#define XXH_PRIME32_3  0xC2B2AE3DU  /*!< 0b11000010101100101010111000111101 */\n#define XXH_PRIME32_4  0x27D4EB2FU  /*!< 0b00100111110101001110101100101111 */\n#define XXH_PRIME32_5  0x165667B1U  /*!< 0b00010110010101100110011110110001 */\n\n#ifdef XXH_OLD_NAMES\n#  define PRIME32_1 XXH_PRIME32_1\n#  define PRIME32_2 XXH_PRIME32_2\n#  define PRIME32_3 XXH_PRIME32_3\n#  define PRIME32_4 XXH_PRIME32_4\n#  define PRIME32_5 XXH_PRIME32_5\n#endif\n\n/*!\n * @internal\n * @brief Normal stripe processing routine.\n *\n * This shuffles the bits so that any bit from @p input impacts several bits in\n * @p acc.\n *\n * @param acc The accumulator lane.\n * @param input The stripe of input to mix.\n * @return The mixed accumulator lane.\n */\nstatic xxh_u32 XXH32_round(xxh_u32 acc, xxh_u32 input)\n{\n    acc += input * XXH_PRIME32_2;\n    acc  = XXH_rotl32(acc, 13);\n    acc *= XXH_PRIME32_1;\n#if (defined(__SSE4_1__) || defined(__aarch64__) || defined(__wasm_simd128__)) && !defined(XXH_ENABLE_AUTOVECTORIZE)\n    /*\n     * UGLY HACK:\n     * A compiler fence is the only thing that prevents GCC and Clang from\n     * autovectorizing the XXH32 loop (pragmas and attributes don't work for some\n     * reason) without globally disabling SSE4.1.\n     *\n     * The reason we want to avoid vectorization is because despite working on\n     * 4 integers at a time, there are multiple factors slowing XXH32 down on\n     * SSE4:\n     * - There's a ridiculous amount of lag from pmulld (10 cycles of latency on\n     *   newer chips!) making it slightly slower to multiply four integers at\n     *   once compared to four integers independently. Even when pmulld was\n     *   fastest, Sandy/Ivy Bridge, it is still not worth it to go into SSE\n     *   just to multiply unless doing a long operation.\n     *\n     * - Four instructions are required to rotate,\n     *      movqda tmp,  v // not required with VEX encoding\n     *      pslld  tmp, 13 // tmp <<= 13\n     *      psrld  v,   19 // x >>= 19\n     *      por    v,  tmp // x |= tmp\n     *   compared to one for scalar:\n     *      roll   v, 13    // reliably fast across the board\n     *      shldl  v, v, 13 // Sandy Bridge and later prefer this for some reason\n     *\n     * - Instruction level parallelism is actually more beneficial here because\n     *   the SIMD actually serializes this operation: While v1 is rotating, v2\n     *   can load data, while v3 can multiply. SSE forces them to operate\n     *   together.\n     *\n     * This is also enabled on AArch64, as Clang is *very aggressive* in vectorizing\n     * the loop. NEON is only faster on the A53, and with the newer cores, it is less\n     * than half the speed.\n     *\n     * Additionally, this is used on WASM SIMD128 because it JITs to the same\n     * SIMD instructions and has the same issue.\n     */\n    XXH_COMPILER_GUARD(acc);\n#endif\n    return acc;\n}\n\n/*!\n * @internal\n * @brief Mixes all bits to finalize the hash.\n *\n * The final mix ensures that all input bits have a chance to impact any bit in\n * the output digest, resulting in an unbiased distribution.\n *\n * @param hash The hash to avalanche.\n * @return The avalanched hash.\n */\nstatic xxh_u32 XXH32_avalanche(xxh_u32 hash)\n{\n    hash ^= hash >> 15;\n    hash *= XXH_PRIME32_2;\n    hash ^= hash >> 13;\n    hash *= XXH_PRIME32_3;\n    hash ^= hash >> 16;\n    return hash;\n}\n\n#define XXH_get32bits(p) XXH_readLE32_align(p, align)\n\n/*!\n * @internal\n * @brief Processes the last 0-15 bytes of @p ptr.\n *\n * There may be up to 15 bytes remaining to consume from the input.\n * This final stage will digest them to ensure that all input bytes are present\n * in the final mix.\n *\n * @param hash The hash to finalize.\n * @param ptr The pointer to the remaining input.\n * @param len The remaining length, modulo 16.\n * @param align Whether @p ptr is aligned.\n * @return The finalized hash.\n * @see XXH64_finalize().\n */\nstatic XXH_PUREF xxh_u32\nXXH32_finalize(xxh_u32 hash, const xxh_u8* ptr, size_t len, XXH_alignment align)\n{\n#define XXH_PROCESS1 do {                             \\\n    hash += (*ptr++) * XXH_PRIME32_5;                 \\\n    hash = XXH_rotl32(hash, 11) * XXH_PRIME32_1;      \\\n} while (0)\n\n#define XXH_PROCESS4 do {                             \\\n    hash += XXH_get32bits(ptr) * XXH_PRIME32_3;       \\\n    ptr += 4;                                         \\\n    hash  = XXH_rotl32(hash, 17) * XXH_PRIME32_4;     \\\n} while (0)\n\n    if (ptr==NULL) XXH_ASSERT(len == 0);\n\n    /* Compact rerolled version; generally faster */\n    if (!XXH32_ENDJMP) {\n        len &= 15;\n        while (len >= 4) {\n            XXH_PROCESS4;\n            len -= 4;\n        }\n        while (len > 0) {\n            XXH_PROCESS1;\n            --len;\n        }\n        return XXH32_avalanche(hash);\n    } else {\n         switch(len&15) /* or switch(bEnd - p) */ {\n           case 12:      XXH_PROCESS4;\n                         XXH_FALLTHROUGH;  /* fallthrough */\n           case 8:       XXH_PROCESS4;\n                         XXH_FALLTHROUGH;  /* fallthrough */\n           case 4:       XXH_PROCESS4;\n                         return XXH32_avalanche(hash);\n\n           case 13:      XXH_PROCESS4;\n                         XXH_FALLTHROUGH;  /* fallthrough */\n           case 9:       XXH_PROCESS4;\n                         XXH_FALLTHROUGH;  /* fallthrough */\n           case 5:       XXH_PROCESS4;\n                         XXH_PROCESS1;\n                         return XXH32_avalanche(hash);\n\n           case 14:      XXH_PROCESS4;\n                         XXH_FALLTHROUGH;  /* fallthrough */\n           case 10:      XXH_PROCESS4;\n                         XXH_FALLTHROUGH;  /* fallthrough */\n           case 6:       XXH_PROCESS4;\n                         XXH_PROCESS1;\n                         XXH_PROCESS1;\n                         return XXH32_avalanche(hash);\n\n           case 15:      XXH_PROCESS4;\n                         XXH_FALLTHROUGH;  /* fallthrough */\n           case 11:      XXH_PROCESS4;\n                         XXH_FALLTHROUGH;  /* fallthrough */\n           case 7:       XXH_PROCESS4;\n                         XXH_FALLTHROUGH;  /* fallthrough */\n           case 3:       XXH_PROCESS1;\n                         XXH_FALLTHROUGH;  /* fallthrough */\n           case 2:       XXH_PROCESS1;\n                         XXH_FALLTHROUGH;  /* fallthrough */\n           case 1:       XXH_PROCESS1;\n                         XXH_FALLTHROUGH;  /* fallthrough */\n           case 0:       return XXH32_avalanche(hash);\n        }\n        XXH_ASSERT(0);\n        return hash;   /* reaching this point is deemed impossible */\n    }\n}\n\n#ifdef XXH_OLD_NAMES\n#  define PROCESS1 XXH_PROCESS1\n#  define PROCESS4 XXH_PROCESS4\n#else\n#  undef XXH_PROCESS1\n#  undef XXH_PROCESS4\n#endif\n\n/*!\n * @internal\n * @brief The implementation for @ref XXH32().\n *\n * @param input , len , seed Directly passed from @ref XXH32().\n * @param align Whether @p input is aligned.\n * @return The calculated hash.\n */\nXXH_FORCE_INLINE XXH_PUREF xxh_u32\nXXH32_endian_align(const xxh_u8* input, size_t len, xxh_u32 seed, XXH_alignment align)\n{\n    xxh_u32 h32;\n\n    if (input==NULL) XXH_ASSERT(len == 0);\n\n    if (len>=16) {\n        const xxh_u8* const bEnd = input + len;\n        const xxh_u8* const limit = bEnd - 15;\n        xxh_u32 v1 = seed + XXH_PRIME32_1 + XXH_PRIME32_2;\n        xxh_u32 v2 = seed + XXH_PRIME32_2;\n        xxh_u32 v3 = seed + 0;\n        xxh_u32 v4 = seed - XXH_PRIME32_1;\n\n        do {\n            v1 = XXH32_round(v1, XXH_get32bits(input)); input += 4;\n            v2 = XXH32_round(v2, XXH_get32bits(input)); input += 4;\n            v3 = XXH32_round(v3, XXH_get32bits(input)); input += 4;\n            v4 = XXH32_round(v4, XXH_get32bits(input)); input += 4;\n        } while (input < limit);\n\n        h32 = XXH_rotl32(v1, 1)  + XXH_rotl32(v2, 7)\n            + XXH_rotl32(v3, 12) + XXH_rotl32(v4, 18);\n    } else {\n        h32  = seed + XXH_PRIME32_5;\n    }\n\n    h32 += (xxh_u32)len;\n\n    return XXH32_finalize(h32, input, len&15, align);\n}\n\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t len, XXH32_hash_t seed)\n{\n#if !defined(XXH_NO_STREAM) && XXH_SIZE_OPT >= 2\n    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */\n    XXH32_state_t state;\n    XXH32_reset(&state, seed);\n    XXH32_update(&state, (const xxh_u8*)input, len);\n    return XXH32_digest(&state);\n#else\n    if (XXH_FORCE_ALIGN_CHECK) {\n        if ((((size_t)input) & 3) == 0) {   /* Input is 4-bytes aligned, leverage the speed benefit */\n            return XXH32_endian_align((const xxh_u8*)input, len, seed, XXH_aligned);\n    }   }\n\n    return XXH32_endian_align((const xxh_u8*)input, len, seed, XXH_unaligned);\n#endif\n}\n\n\n\n/*******   Hash streaming   *******/\n#ifndef XXH_NO_STREAM\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API XXH32_state_t* XXH32_createState(void)\n{\n    return (XXH32_state_t*)XXH_malloc(sizeof(XXH32_state_t));\n}\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API XXH_errorcode XXH32_freeState(XXH32_state_t* statePtr)\n{\n    XXH_free(statePtr);\n    return XXH_OK;\n}\n\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dstState, const XXH32_state_t* srcState)\n{\n    XXH_memcpy(dstState, srcState, sizeof(*dstState));\n}\n\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, XXH32_hash_t seed)\n{\n    XXH_ASSERT(statePtr != NULL);\n    memset(statePtr, 0, sizeof(*statePtr));\n    statePtr->v[0] = seed + XXH_PRIME32_1 + XXH_PRIME32_2;\n    statePtr->v[1] = seed + XXH_PRIME32_2;\n    statePtr->v[2] = seed + 0;\n    statePtr->v[3] = seed - XXH_PRIME32_1;\n    return XXH_OK;\n}\n\n\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH32_update(XXH32_state_t* state, const void* input, size_t len)\n{\n    if (input==NULL) {\n        XXH_ASSERT(len == 0);\n        return XXH_OK;\n    }\n\n    {   const xxh_u8* p = (const xxh_u8*)input;\n        const xxh_u8* const bEnd = p + len;\n\n        state->total_len_32 += (XXH32_hash_t)len;\n        state->large_len |= (XXH32_hash_t)((len>=16) | (state->total_len_32>=16));\n\n        if (state->memsize + len < 16)  {   /* fill in tmp buffer */\n            XXH_memcpy((xxh_u8*)(state->mem32) + state->memsize, input, len);\n            state->memsize += (XXH32_hash_t)len;\n            return XXH_OK;\n        }\n\n        if (state->memsize) {   /* some data left from previous update */\n            XXH_memcpy((xxh_u8*)(state->mem32) + state->memsize, input, 16-state->memsize);\n            {   const xxh_u32* p32 = state->mem32;\n                state->v[0] = XXH32_round(state->v[0], XXH_readLE32(p32)); p32++;\n                state->v[1] = XXH32_round(state->v[1], XXH_readLE32(p32)); p32++;\n                state->v[2] = XXH32_round(state->v[2], XXH_readLE32(p32)); p32++;\n                state->v[3] = XXH32_round(state->v[3], XXH_readLE32(p32));\n            }\n            p += 16-state->memsize;\n            state->memsize = 0;\n        }\n\n        if (p <= bEnd-16) {\n            const xxh_u8* const limit = bEnd - 16;\n\n            do {\n                state->v[0] = XXH32_round(state->v[0], XXH_readLE32(p)); p+=4;\n                state->v[1] = XXH32_round(state->v[1], XXH_readLE32(p)); p+=4;\n                state->v[2] = XXH32_round(state->v[2], XXH_readLE32(p)); p+=4;\n                state->v[3] = XXH32_round(state->v[3], XXH_readLE32(p)); p+=4;\n            } while (p<=limit);\n\n        }\n\n        if (p < bEnd) {\n            XXH_memcpy(state->mem32, p, (size_t)(bEnd-p));\n            state->memsize = (unsigned)(bEnd-p);\n        }\n    }\n\n    return XXH_OK;\n}\n\n\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API XXH32_hash_t XXH32_digest(const XXH32_state_t* state)\n{\n    xxh_u32 h32;\n\n    if (state->large_len) {\n        h32 = XXH_rotl32(state->v[0], 1)\n            + XXH_rotl32(state->v[1], 7)\n            + XXH_rotl32(state->v[2], 12)\n            + XXH_rotl32(state->v[3], 18);\n    } else {\n        h32 = state->v[2] /* == seed */ + XXH_PRIME32_5;\n    }\n\n    h32 += state->total_len_32;\n\n    return XXH32_finalize(h32, (const xxh_u8*)state->mem32, state->memsize, XXH_aligned);\n}\n#endif /* !XXH_NO_STREAM */\n\n/*******   Canonical representation   *******/\n\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash)\n{\n    XXH_STATIC_ASSERT(sizeof(XXH32_canonical_t) == sizeof(XXH32_hash_t));\n    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap32(hash);\n    XXH_memcpy(dst, &hash, sizeof(*dst));\n}\n/*! @ingroup XXH32_family */\nXXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src)\n{\n    return XXH_readBE32(src);\n}\n\n\n#ifndef XXH_NO_LONG_LONG\n\n/* *******************************************************************\n*  64-bit hash functions\n*********************************************************************/\n/*!\n * @}\n * @ingroup impl\n * @{\n */\n/*******   Memory access   *******/\n\ntypedef XXH64_hash_t xxh_u64;\n\n#ifdef XXH_OLD_NAMES\n#  define U64 xxh_u64\n#endif\n\n#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==3))\n/*\n * Manual byteshift. Best for old compilers which don't inline memcpy.\n * We actually directly use XXH_readLE64 and XXH_readBE64.\n */\n#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==2))\n\n/* Force direct memory access. Only works on CPU which support unaligned memory access in hardware */\nstatic xxh_u64 XXH_read64(const void* memPtr)\n{\n    return *(const xxh_u64*) memPtr;\n}\n\n#elif (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==1))\n\n/*\n * __attribute__((aligned(1))) is supported by gcc and clang. Originally the\n * documentation claimed that it only increased the alignment, but actually it\n * can decrease it on gcc, clang, and icc:\n * https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69502,\n * https://gcc.godbolt.org/z/xYez1j67Y.\n */\n#ifdef XXH_OLD_NAMES\ntypedef union { xxh_u32 u32; xxh_u64 u64; } __attribute__((packed)) unalign64;\n#endif\nstatic xxh_u64 XXH_read64(const void* ptr)\n{\n    typedef __attribute__((aligned(1))) xxh_u64 xxh_unalign64;\n    return *((const xxh_unalign64*)ptr);\n}\n\n#else\n\n/*\n * Portable and safe solution. Generally efficient.\n * see: https://fastcompression.blogspot.com/2015/08/accessing-unaligned-memory.html\n */\nstatic xxh_u64 XXH_read64(const void* memPtr)\n{\n    xxh_u64 val;\n    XXH_memcpy(&val, memPtr, sizeof(val));\n    return val;\n}\n\n#endif   /* XXH_FORCE_DIRECT_MEMORY_ACCESS */\n\n#if defined(_MSC_VER)     /* Visual Studio */\n#  define XXH_swap64 _byteswap_uint64\n#elif XXH_GCC_VERSION >= 403\n#  define XXH_swap64 __builtin_bswap64\n#else\nstatic xxh_u64 XXH_swap64(xxh_u64 x)\n{\n    return  ((x << 56) & 0xff00000000000000ULL) |\n            ((x << 40) & 0x00ff000000000000ULL) |\n            ((x << 24) & 0x0000ff0000000000ULL) |\n            ((x << 8)  & 0x000000ff00000000ULL) |\n            ((x >> 8)  & 0x00000000ff000000ULL) |\n            ((x >> 24) & 0x0000000000ff0000ULL) |\n            ((x >> 40) & 0x000000000000ff00ULL) |\n            ((x >> 56) & 0x00000000000000ffULL);\n}\n#endif\n\n\n/* XXH_FORCE_MEMORY_ACCESS==3 is an endian-independent byteshift load. */\n#if (defined(XXH_FORCE_MEMORY_ACCESS) && (XXH_FORCE_MEMORY_ACCESS==3))\n\nXXH_FORCE_INLINE xxh_u64 XXH_readLE64(const void* memPtr)\n{\n    const xxh_u8* bytePtr = (const xxh_u8 *)memPtr;\n    return bytePtr[0]\n         | ((xxh_u64)bytePtr[1] << 8)\n         | ((xxh_u64)bytePtr[2] << 16)\n         | ((xxh_u64)bytePtr[3] << 24)\n         | ((xxh_u64)bytePtr[4] << 32)\n         | ((xxh_u64)bytePtr[5] << 40)\n         | ((xxh_u64)bytePtr[6] << 48)\n         | ((xxh_u64)bytePtr[7] << 56);\n}\n\nXXH_FORCE_INLINE xxh_u64 XXH_readBE64(const void* memPtr)\n{\n    const xxh_u8* bytePtr = (const xxh_u8 *)memPtr;\n    return bytePtr[7]\n         | ((xxh_u64)bytePtr[6] << 8)\n         | ((xxh_u64)bytePtr[5] << 16)\n         | ((xxh_u64)bytePtr[4] << 24)\n         | ((xxh_u64)bytePtr[3] << 32)\n         | ((xxh_u64)bytePtr[2] << 40)\n         | ((xxh_u64)bytePtr[1] << 48)\n         | ((xxh_u64)bytePtr[0] << 56);\n}\n\n#else\nXXH_FORCE_INLINE xxh_u64 XXH_readLE64(const void* ptr)\n{\n    return XXH_CPU_LITTLE_ENDIAN ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr));\n}\n\nstatic xxh_u64 XXH_readBE64(const void* ptr)\n{\n    return XXH_CPU_LITTLE_ENDIAN ? XXH_swap64(XXH_read64(ptr)) : XXH_read64(ptr);\n}\n#endif\n\nXXH_FORCE_INLINE xxh_u64\nXXH_readLE64_align(const void* ptr, XXH_alignment align)\n{\n    if (align==XXH_unaligned)\n        return XXH_readLE64(ptr);\n    else\n        return XXH_CPU_LITTLE_ENDIAN ? *(const xxh_u64*)ptr : XXH_swap64(*(const xxh_u64*)ptr);\n}\n\n\n/*******   xxh64   *******/\n/*!\n * @}\n * @defgroup XXH64_impl XXH64 implementation\n * @ingroup impl\n *\n * Details on the XXH64 implementation.\n * @{\n */\n/* #define rather that static const, to be used as initializers */\n#define XXH_PRIME64_1  0x9E3779B185EBCA87ULL  /*!< 0b1001111000110111011110011011000110000101111010111100101010000111 */\n#define XXH_PRIME64_2  0xC2B2AE3D27D4EB4FULL  /*!< 0b1100001010110010101011100011110100100111110101001110101101001111 */\n#define XXH_PRIME64_3  0x165667B19E3779F9ULL  /*!< 0b0001011001010110011001111011000110011110001101110111100111111001 */\n#define XXH_PRIME64_4  0x85EBCA77C2B2AE63ULL  /*!< 0b1000010111101011110010100111011111000010101100101010111001100011 */\n#define XXH_PRIME64_5  0x27D4EB2F165667C5ULL  /*!< 0b0010011111010100111010110010111100010110010101100110011111000101 */\n\n#ifdef XXH_OLD_NAMES\n#  define PRIME64_1 XXH_PRIME64_1\n#  define PRIME64_2 XXH_PRIME64_2\n#  define PRIME64_3 XXH_PRIME64_3\n#  define PRIME64_4 XXH_PRIME64_4\n#  define PRIME64_5 XXH_PRIME64_5\n#endif\n\n/*! @copydoc XXH32_round */\nstatic xxh_u64 XXH64_round(xxh_u64 acc, xxh_u64 input)\n{\n    acc += input * XXH_PRIME64_2;\n    acc  = XXH_rotl64(acc, 31);\n    acc *= XXH_PRIME64_1;\n#if (defined(__AVX512F__)) && !defined(XXH_ENABLE_AUTOVECTORIZE)\n    /*\n     * DISABLE AUTOVECTORIZATION:\n     * A compiler fence is used to prevent GCC and Clang from\n     * autovectorizing the XXH64 loop (pragmas and attributes don't work for some\n     * reason) without globally disabling AVX512.\n     *\n     * Autovectorization of XXH64 tends to be detrimental,\n     * though the exact outcome may change depending on exact cpu and compiler version.\n     * For information, it has been reported as detrimental for Skylake-X,\n     * but possibly beneficial for Zen4.\n     *\n     * The default is to disable auto-vectorization,\n     * but you can select to enable it instead using `XXH_ENABLE_AUTOVECTORIZE` build variable.\n     */\n    XXH_COMPILER_GUARD(acc);\n#endif\n    return acc;\n}\n\nstatic xxh_u64 XXH64_mergeRound(xxh_u64 acc, xxh_u64 val)\n{\n    val  = XXH64_round(0, val);\n    acc ^= val;\n    acc  = acc * XXH_PRIME64_1 + XXH_PRIME64_4;\n    return acc;\n}\n\n/*! @copydoc XXH32_avalanche */\nstatic xxh_u64 XXH64_avalanche(xxh_u64 hash)\n{\n    hash ^= hash >> 33;\n    hash *= XXH_PRIME64_2;\n    hash ^= hash >> 29;\n    hash *= XXH_PRIME64_3;\n    hash ^= hash >> 32;\n    return hash;\n}\n\n\n#define XXH_get64bits(p) XXH_readLE64_align(p, align)\n\n/*!\n * @internal\n * @brief Processes the last 0-31 bytes of @p ptr.\n *\n * There may be up to 31 bytes remaining to consume from the input.\n * This final stage will digest them to ensure that all input bytes are present\n * in the final mix.\n *\n * @param hash The hash to finalize.\n * @param ptr The pointer to the remaining input.\n * @param len The remaining length, modulo 32.\n * @param align Whether @p ptr is aligned.\n * @return The finalized hash\n * @see XXH32_finalize().\n */\nstatic XXH_PUREF xxh_u64\nXXH64_finalize(xxh_u64 hash, const xxh_u8* ptr, size_t len, XXH_alignment align)\n{\n    if (ptr==NULL) XXH_ASSERT(len == 0);\n    len &= 31;\n    while (len >= 8) {\n        xxh_u64 const k1 = XXH64_round(0, XXH_get64bits(ptr));\n        ptr += 8;\n        hash ^= k1;\n        hash  = XXH_rotl64(hash,27) * XXH_PRIME64_1 + XXH_PRIME64_4;\n        len -= 8;\n    }\n    if (len >= 4) {\n        hash ^= (xxh_u64)(XXH_get32bits(ptr)) * XXH_PRIME64_1;\n        ptr += 4;\n        hash = XXH_rotl64(hash, 23) * XXH_PRIME64_2 + XXH_PRIME64_3;\n        len -= 4;\n    }\n    while (len > 0) {\n        hash ^= (*ptr++) * XXH_PRIME64_5;\n        hash = XXH_rotl64(hash, 11) * XXH_PRIME64_1;\n        --len;\n    }\n    return  XXH64_avalanche(hash);\n}\n\n#ifdef XXH_OLD_NAMES\n#  define PROCESS1_64 XXH_PROCESS1_64\n#  define PROCESS4_64 XXH_PROCESS4_64\n#  define PROCESS8_64 XXH_PROCESS8_64\n#else\n#  undef XXH_PROCESS1_64\n#  undef XXH_PROCESS4_64\n#  undef XXH_PROCESS8_64\n#endif\n\n/*!\n * @internal\n * @brief The implementation for @ref XXH64().\n *\n * @param input , len , seed Directly passed from @ref XXH64().\n * @param align Whether @p input is aligned.\n * @return The calculated hash.\n */\nXXH_FORCE_INLINE XXH_PUREF xxh_u64\nXXH64_endian_align(const xxh_u8* input, size_t len, xxh_u64 seed, XXH_alignment align)\n{\n    xxh_u64 h64;\n    if (input==NULL) XXH_ASSERT(len == 0);\n\n    if (len>=32) {\n        const xxh_u8* const bEnd = input + len;\n        const xxh_u8* const limit = bEnd - 31;\n        xxh_u64 v1 = seed + XXH_PRIME64_1 + XXH_PRIME64_2;\n        xxh_u64 v2 = seed + XXH_PRIME64_2;\n        xxh_u64 v3 = seed + 0;\n        xxh_u64 v4 = seed - XXH_PRIME64_1;\n\n        do {\n            v1 = XXH64_round(v1, XXH_get64bits(input)); input+=8;\n            v2 = XXH64_round(v2, XXH_get64bits(input)); input+=8;\n            v3 = XXH64_round(v3, XXH_get64bits(input)); input+=8;\n            v4 = XXH64_round(v4, XXH_get64bits(input)); input+=8;\n        } while (input= 2\n    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */\n    XXH64_state_t state;\n    XXH64_reset(&state, seed);\n    XXH64_update(&state, (const xxh_u8*)input, len);\n    return XXH64_digest(&state);\n#else\n    if (XXH_FORCE_ALIGN_CHECK) {\n        if ((((size_t)input) & 7)==0) {  /* Input is aligned, let's leverage the speed advantage */\n            return XXH64_endian_align((const xxh_u8*)input, len, seed, XXH_aligned);\n    }   }\n\n    return XXH64_endian_align((const xxh_u8*)input, len, seed, XXH_unaligned);\n\n#endif\n}\n\n/*******   Hash Streaming   *******/\n#ifndef XXH_NO_STREAM\n/*! @ingroup XXH64_family*/\nXXH_PUBLIC_API XXH64_state_t* XXH64_createState(void)\n{\n    return (XXH64_state_t*)XXH_malloc(sizeof(XXH64_state_t));\n}\n/*! @ingroup XXH64_family */\nXXH_PUBLIC_API XXH_errorcode XXH64_freeState(XXH64_state_t* statePtr)\n{\n    XXH_free(statePtr);\n    return XXH_OK;\n}\n\n/*! @ingroup XXH64_family */\nXXH_PUBLIC_API void XXH64_copyState(XXH_NOESCAPE XXH64_state_t* dstState, const XXH64_state_t* srcState)\n{\n    XXH_memcpy(dstState, srcState, sizeof(*dstState));\n}\n\n/*! @ingroup XXH64_family */\nXXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH_NOESCAPE XXH64_state_t* statePtr, XXH64_hash_t seed)\n{\n    XXH_ASSERT(statePtr != NULL);\n    memset(statePtr, 0, sizeof(*statePtr));\n    statePtr->v[0] = seed + XXH_PRIME64_1 + XXH_PRIME64_2;\n    statePtr->v[1] = seed + XXH_PRIME64_2;\n    statePtr->v[2] = seed + 0;\n    statePtr->v[3] = seed - XXH_PRIME64_1;\n    return XXH_OK;\n}\n\n/*! @ingroup XXH64_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH64_update (XXH_NOESCAPE XXH64_state_t* state, XXH_NOESCAPE const void* input, size_t len)\n{\n    if (input==NULL) {\n        XXH_ASSERT(len == 0);\n        return XXH_OK;\n    }\n\n    {   const xxh_u8* p = (const xxh_u8*)input;\n        const xxh_u8* const bEnd = p + len;\n\n        state->total_len += len;\n\n        if (state->memsize + len < 32) {  /* fill in tmp buffer */\n            XXH_memcpy(((xxh_u8*)state->mem64) + state->memsize, input, len);\n            state->memsize += (xxh_u32)len;\n            return XXH_OK;\n        }\n\n        if (state->memsize) {   /* tmp buffer is full */\n            XXH_memcpy(((xxh_u8*)state->mem64) + state->memsize, input, 32-state->memsize);\n            state->v[0] = XXH64_round(state->v[0], XXH_readLE64(state->mem64+0));\n            state->v[1] = XXH64_round(state->v[1], XXH_readLE64(state->mem64+1));\n            state->v[2] = XXH64_round(state->v[2], XXH_readLE64(state->mem64+2));\n            state->v[3] = XXH64_round(state->v[3], XXH_readLE64(state->mem64+3));\n            p += 32 - state->memsize;\n            state->memsize = 0;\n        }\n\n        if (p+32 <= bEnd) {\n            const xxh_u8* const limit = bEnd - 32;\n\n            do {\n                state->v[0] = XXH64_round(state->v[0], XXH_readLE64(p)); p+=8;\n                state->v[1] = XXH64_round(state->v[1], XXH_readLE64(p)); p+=8;\n                state->v[2] = XXH64_round(state->v[2], XXH_readLE64(p)); p+=8;\n                state->v[3] = XXH64_round(state->v[3], XXH_readLE64(p)); p+=8;\n            } while (p<=limit);\n\n        }\n\n        if (p < bEnd) {\n            XXH_memcpy(state->mem64, p, (size_t)(bEnd-p));\n            state->memsize = (unsigned)(bEnd-p);\n        }\n    }\n\n    return XXH_OK;\n}\n\n\n/*! @ingroup XXH64_family */\nXXH_PUBLIC_API XXH64_hash_t XXH64_digest(XXH_NOESCAPE const XXH64_state_t* state)\n{\n    xxh_u64 h64;\n\n    if (state->total_len >= 32) {\n        h64 = XXH_rotl64(state->v[0], 1) + XXH_rotl64(state->v[1], 7) + XXH_rotl64(state->v[2], 12) + XXH_rotl64(state->v[3], 18);\n        h64 = XXH64_mergeRound(h64, state->v[0]);\n        h64 = XXH64_mergeRound(h64, state->v[1]);\n        h64 = XXH64_mergeRound(h64, state->v[2]);\n        h64 = XXH64_mergeRound(h64, state->v[3]);\n    } else {\n        h64  = state->v[2] /*seed*/ + XXH_PRIME64_5;\n    }\n\n    h64 += (xxh_u64) state->total_len;\n\n    return XXH64_finalize(h64, (const xxh_u8*)state->mem64, (size_t)state->total_len, XXH_aligned);\n}\n#endif /* !XXH_NO_STREAM */\n\n/******* Canonical representation   *******/\n\n/*! @ingroup XXH64_family */\nXXH_PUBLIC_API void XXH64_canonicalFromHash(XXH_NOESCAPE XXH64_canonical_t* dst, XXH64_hash_t hash)\n{\n    XXH_STATIC_ASSERT(sizeof(XXH64_canonical_t) == sizeof(XXH64_hash_t));\n    if (XXH_CPU_LITTLE_ENDIAN) hash = XXH_swap64(hash);\n    XXH_memcpy(dst, &hash, sizeof(*dst));\n}\n\n/*! @ingroup XXH64_family */\nXXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(XXH_NOESCAPE const XXH64_canonical_t* src)\n{\n    return XXH_readBE64(src);\n}\n\n#if defined (__cplusplus)\n}\n#endif\n\n#ifndef XXH_NO_XXH3\n\n/* *********************************************************************\n*  XXH3\n*  New generation hash designed for speed on small keys and vectorization\n************************************************************************ */\n/*!\n * @}\n * @defgroup XXH3_impl XXH3 implementation\n * @ingroup impl\n * @{\n */\n\n/* ===   Compiler specifics   === */\n\n#if ((defined(sun) || defined(__sun)) && __cplusplus) /* Solaris includes __STDC_VERSION__ with C++. Tested with GCC 5.5 */\n#  define XXH_RESTRICT   /* disable */\n#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* >= C99 */\n#  define XXH_RESTRICT   restrict\n#elif (defined (__GNUC__) && ((__GNUC__ > 3) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))) \\\n   || (defined (__clang__)) \\\n   || (defined (_MSC_VER) && (_MSC_VER >= 1400)) \\\n   || (defined (__INTEL_COMPILER) && (__INTEL_COMPILER >= 1300))\n/*\n * There are a LOT more compilers that recognize __restrict but this\n * covers the major ones.\n */\n#  define XXH_RESTRICT   __restrict\n#else\n#  define XXH_RESTRICT   /* disable */\n#endif\n\n#if (defined(__GNUC__) && (__GNUC__ >= 3))  \\\n  || (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 800)) \\\n  || defined(__clang__)\n#    define XXH_likely(x) __builtin_expect(x, 1)\n#    define XXH_unlikely(x) __builtin_expect(x, 0)\n#else\n#    define XXH_likely(x) (x)\n#    define XXH_unlikely(x) (x)\n#endif\n\n#ifndef XXH_HAS_INCLUDE\n#  ifdef __has_include\n/*\n * Not defined as XXH_HAS_INCLUDE(x) (function-like) because\n * this causes segfaults in Apple Clang 4.2 (on Mac OS X 10.7 Lion)\n */\n#    define XXH_HAS_INCLUDE __has_include\n#  else\n#    define XXH_HAS_INCLUDE(x) 0\n#  endif\n#endif\n\n#if defined(__GNUC__) || defined(__clang__)\n#  if defined(__ARM_FEATURE_SVE)\n#    include \n#  endif\n#  if defined(__ARM_NEON__) || defined(__ARM_NEON) \\\n   || (defined(_M_ARM) && _M_ARM >= 7) \\\n   || defined(_M_ARM64) || defined(_M_ARM64EC) \\\n   || (defined(__wasm_simd128__) && XXH_HAS_INCLUDE()) /* WASM SIMD128 via SIMDe */\n#    define inline __inline__  /* circumvent a clang bug */\n#    include \n#    undef inline\n#  elif defined(__AVX2__)\n#    include \n#  elif defined(__SSE2__)\n#    include \n#  endif\n#endif\n\n#if defined(_MSC_VER)\n#  include \n#endif\n\n/*\n * One goal of XXH3 is to make it fast on both 32-bit and 64-bit, while\n * remaining a true 64-bit/128-bit hash function.\n *\n * This is done by prioritizing a subset of 64-bit operations that can be\n * emulated without too many steps on the average 32-bit machine.\n *\n * For example, these two lines seem similar, and run equally fast on 64-bit:\n *\n *   xxh_u64 x;\n *   x ^= (x >> 47); // good\n *   x ^= (x >> 13); // bad\n *\n * However, to a 32-bit machine, there is a major difference.\n *\n * x ^= (x >> 47) looks like this:\n *\n *   x.lo ^= (x.hi >> (47 - 32));\n *\n * while x ^= (x >> 13) looks like this:\n *\n *   // note: funnel shifts are not usually cheap.\n *   x.lo ^= (x.lo >> 13) | (x.hi << (32 - 13));\n *   x.hi ^= (x.hi >> 13);\n *\n * The first one is significantly faster than the second, simply because the\n * shift is larger than 32. This means:\n *  - All the bits we need are in the upper 32 bits, so we can ignore the lower\n *    32 bits in the shift.\n *  - The shift result will always fit in the lower 32 bits, and therefore,\n *    we can ignore the upper 32 bits in the xor.\n *\n * Thanks to this optimization, XXH3 only requires these features to be efficient:\n *\n *  - Usable unaligned access\n *  - A 32-bit or 64-bit ALU\n *      - If 32-bit, a decent ADC instruction\n *  - A 32 or 64-bit multiply with a 64-bit result\n *  - For the 128-bit variant, a decent byteswap helps short inputs.\n *\n * The first two are already required by XXH32, and almost all 32-bit and 64-bit\n * platforms which can run XXH32 can run XXH3 efficiently.\n *\n * Thumb-1, the classic 16-bit only subset of ARM's instruction set, is one\n * notable exception.\n *\n * First of all, Thumb-1 lacks support for the UMULL instruction which\n * performs the important long multiply. This means numerous __aeabi_lmul\n * calls.\n *\n * Second of all, the 8 functional registers are just not enough.\n * Setup for __aeabi_lmul, byteshift loads, pointers, and all arithmetic need\n * Lo registers, and this shuffling results in thousands more MOVs than A32.\n *\n * A32 and T32 don't have this limitation. They can access all 14 registers,\n * do a 32->64 multiply with UMULL, and the flexible operand allowing free\n * shifts is helpful, too.\n *\n * Therefore, we do a quick sanity check.\n *\n * If compiling Thumb-1 for a target which supports ARM instructions, we will\n * emit a warning, as it is not a \"sane\" platform to compile for.\n *\n * Usually, if this happens, it is because of an accident and you probably need\n * to specify -march, as you likely meant to compile for a newer architecture.\n *\n * Credit: large sections of the vectorial and asm source code paths\n *         have been contributed by @easyaspi314\n */\n#if defined(__thumb__) && !defined(__thumb2__) && defined(__ARM_ARCH_ISA_ARM)\n#   warning \"XXH3 is highly inefficient without ARM or Thumb-2.\"\n#endif\n\n/* ==========================================\n * Vectorization detection\n * ========================================== */\n\n#ifdef XXH_DOXYGEN\n/*!\n * @ingroup tuning\n * @brief Overrides the vectorization implementation chosen for XXH3.\n *\n * Can be defined to 0 to disable SIMD or any of the values mentioned in\n * @ref XXH_VECTOR_TYPE.\n *\n * If this is not defined, it uses predefined macros to determine the best\n * implementation.\n */\n#  define XXH_VECTOR XXH_SCALAR\n/*!\n * @ingroup tuning\n * @brief Possible values for @ref XXH_VECTOR.\n *\n * Note that these are actually implemented as macros.\n *\n * If this is not defined, it is detected automatically.\n * internal macro XXH_X86DISPATCH overrides this.\n */\nenum XXH_VECTOR_TYPE /* fake enum */ {\n    XXH_SCALAR = 0,  /*!< Portable scalar version */\n    XXH_SSE2   = 1,  /*!<\n                      * SSE2 for Pentium 4, Opteron, all x86_64.\n                      *\n                      * @note SSE2 is also guaranteed on Windows 10, macOS, and\n                      * Android x86.\n                      */\n    XXH_AVX2   = 2,  /*!< AVX2 for Haswell and Bulldozer */\n    XXH_AVX512 = 3,  /*!< AVX512 for Skylake and Icelake */\n    XXH_NEON   = 4,  /*!<\n                       * NEON for most ARMv7-A, all AArch64, and WASM SIMD128\n                       * via the SIMDeverywhere polyfill provided with the\n                       * Emscripten SDK.\n                       */\n    XXH_VSX    = 5,  /*!< VSX and ZVector for POWER8/z13 (64-bit) */\n    XXH_SVE    = 6,  /*!< SVE for some ARMv8-A and ARMv9-A */\n};\n/*!\n * @ingroup tuning\n * @brief Selects the minimum alignment for XXH3's accumulators.\n *\n * When using SIMD, this should match the alignment required for said vector\n * type, so, for example, 32 for AVX2.\n *\n * Default: Auto detected.\n */\n#  define XXH_ACC_ALIGN 8\n#endif\n\n/* Actual definition */\n#ifndef XXH_DOXYGEN\n#  define XXH_SCALAR 0\n#  define XXH_SSE2   1\n#  define XXH_AVX2   2\n#  define XXH_AVX512 3\n#  define XXH_NEON   4\n#  define XXH_VSX    5\n#  define XXH_SVE    6\n#endif\n\n#ifndef XXH_VECTOR    /* can be defined on command line */\n#  if defined(__ARM_FEATURE_SVE)\n#    define XXH_VECTOR XXH_SVE\n#  elif ( \\\n        defined(__ARM_NEON__) || defined(__ARM_NEON) /* gcc */ \\\n     || defined(_M_ARM) || defined(_M_ARM64) || defined(_M_ARM64EC) /* msvc */ \\\n     || (defined(__wasm_simd128__) && XXH_HAS_INCLUDE()) /* wasm simd128 via SIMDe */ \\\n   ) && ( \\\n        defined(_WIN32) || defined(__LITTLE_ENDIAN__) /* little endian only */ \\\n    || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) \\\n   )\n#    define XXH_VECTOR XXH_NEON\n#  elif defined(__AVX512F__)\n#    define XXH_VECTOR XXH_AVX512\n#  elif defined(__AVX2__)\n#    define XXH_VECTOR XXH_AVX2\n#  elif defined(__SSE2__) || defined(_M_X64) || (defined(_M_IX86_FP) && (_M_IX86_FP == 2))\n#    define XXH_VECTOR XXH_SSE2\n#  elif (defined(__PPC64__) && defined(__POWER8_VECTOR__)) \\\n     || (defined(__s390x__) && defined(__VEC__)) \\\n     && defined(__GNUC__) /* TODO: IBM XL */\n#    define XXH_VECTOR XXH_VSX\n#  else\n#    define XXH_VECTOR XXH_SCALAR\n#  endif\n#endif\n\n/* __ARM_FEATURE_SVE is only supported by GCC & Clang. */\n#if (XXH_VECTOR == XXH_SVE) && !defined(__ARM_FEATURE_SVE)\n#  ifdef _MSC_VER\n#    pragma warning(once : 4606)\n#  else\n#    warning \"__ARM_FEATURE_SVE isn't supported. Use SCALAR instead.\"\n#  endif\n#  undef XXH_VECTOR\n#  define XXH_VECTOR XXH_SCALAR\n#endif\n\n/*\n * Controls the alignment of the accumulator,\n * for compatibility with aligned vector loads, which are usually faster.\n */\n#ifndef XXH_ACC_ALIGN\n#  if defined(XXH_X86DISPATCH)\n#     define XXH_ACC_ALIGN 64  /* for compatibility with avx512 */\n#  elif XXH_VECTOR == XXH_SCALAR  /* scalar */\n#     define XXH_ACC_ALIGN 8\n#  elif XXH_VECTOR == XXH_SSE2  /* sse2 */\n#     define XXH_ACC_ALIGN 16\n#  elif XXH_VECTOR == XXH_AVX2  /* avx2 */\n#     define XXH_ACC_ALIGN 32\n#  elif XXH_VECTOR == XXH_NEON  /* neon */\n#     define XXH_ACC_ALIGN 16\n#  elif XXH_VECTOR == XXH_VSX   /* vsx */\n#     define XXH_ACC_ALIGN 16\n#  elif XXH_VECTOR == XXH_AVX512  /* avx512 */\n#     define XXH_ACC_ALIGN 64\n#  elif XXH_VECTOR == XXH_SVE   /* sve */\n#     define XXH_ACC_ALIGN 64\n#  endif\n#endif\n\n#if defined(XXH_X86DISPATCH) || XXH_VECTOR == XXH_SSE2 \\\n    || XXH_VECTOR == XXH_AVX2 || XXH_VECTOR == XXH_AVX512\n#  define XXH_SEC_ALIGN XXH_ACC_ALIGN\n#elif XXH_VECTOR == XXH_SVE\n#  define XXH_SEC_ALIGN XXH_ACC_ALIGN\n#else\n#  define XXH_SEC_ALIGN 8\n#endif\n\n#if defined(__GNUC__) || defined(__clang__)\n#  define XXH_ALIASING __attribute__((may_alias))\n#else\n#  define XXH_ALIASING /* nothing */\n#endif\n\n/*\n * UGLY HACK:\n * GCC usually generates the best code with -O3 for xxHash.\n *\n * However, when targeting AVX2, it is overzealous in its unrolling resulting\n * in code roughly 3/4 the speed of Clang.\n *\n * There are other issues, such as GCC splitting _mm256_loadu_si256 into\n * _mm_loadu_si128 + _mm256_inserti128_si256. This is an optimization which\n * only applies to Sandy and Ivy Bridge... which don't even support AVX2.\n *\n * That is why when compiling the AVX2 version, it is recommended to use either\n *   -O2 -mavx2 -march=haswell\n * or\n *   -O2 -mavx2 -mno-avx256-split-unaligned-load\n * for decent performance, or to use Clang instead.\n *\n * Fortunately, we can control the first one with a pragma that forces GCC into\n * -O2, but the other one we can't control without \"failed to inline always\n * inline function due to target mismatch\" warnings.\n */\n#if XXH_VECTOR == XXH_AVX2 /* AVX2 */ \\\n  && defined(__GNUC__) && !defined(__clang__) /* GCC, not Clang */ \\\n  && defined(__OPTIMIZE__) && XXH_SIZE_OPT <= 0 /* respect -O0 and -Os */\n#  pragma GCC push_options\n#  pragma GCC optimize(\"-O2\")\n#endif\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n\n#if XXH_VECTOR == XXH_NEON\n\n/*\n * UGLY HACK: While AArch64 GCC on Linux does not seem to care, on macOS, GCC -O3\n * optimizes out the entire hashLong loop because of the aliasing violation.\n *\n * However, GCC is also inefficient at load-store optimization with vld1q/vst1q,\n * so the only option is to mark it as aliasing.\n */\ntypedef uint64x2_t xxh_aliasing_uint64x2_t XXH_ALIASING;\n\n/*!\n * @internal\n * @brief `vld1q_u64` but faster and alignment-safe.\n *\n * On AArch64, unaligned access is always safe, but on ARMv7-a, it is only\n * *conditionally* safe (`vld1` has an alignment bit like `movdq[ua]` in x86).\n *\n * GCC for AArch64 sees `vld1q_u8` as an intrinsic instead of a load, so it\n * prohibits load-store optimizations. Therefore, a direct dereference is used.\n *\n * Otherwise, `vld1q_u8` is used with `vreinterpretq_u8_u64` to do a safe\n * unaligned load.\n */\n#if defined(__aarch64__) && defined(__GNUC__) && !defined(__clang__)\nXXH_FORCE_INLINE uint64x2_t XXH_vld1q_u64(void const* ptr) /* silence -Wcast-align */\n{\n    return *(xxh_aliasing_uint64x2_t const *)ptr;\n}\n#else\nXXH_FORCE_INLINE uint64x2_t XXH_vld1q_u64(void const* ptr)\n{\n    return vreinterpretq_u64_u8(vld1q_u8((uint8_t const*)ptr));\n}\n#endif\n\n/*!\n * @internal\n * @brief `vmlal_u32` on low and high halves of a vector.\n *\n * This is a workaround for AArch64 GCC < 11 which implemented arm_neon.h with\n * inline assembly and were therefore incapable of merging the `vget_{low, high}_u32`\n * with `vmlal_u32`.\n */\n#if defined(__aarch64__) && defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 11\nXXH_FORCE_INLINE uint64x2_t\nXXH_vmlal_low_u32(uint64x2_t acc, uint32x4_t lhs, uint32x4_t rhs)\n{\n    /* Inline assembly is the only way */\n    __asm__(\"umlal   %0.2d, %1.2s, %2.2s\" : \"+w\" (acc) : \"w\" (lhs), \"w\" (rhs));\n    return acc;\n}\nXXH_FORCE_INLINE uint64x2_t\nXXH_vmlal_high_u32(uint64x2_t acc, uint32x4_t lhs, uint32x4_t rhs)\n{\n    /* This intrinsic works as expected */\n    return vmlal_high_u32(acc, lhs, rhs);\n}\n#else\n/* Portable intrinsic versions */\nXXH_FORCE_INLINE uint64x2_t\nXXH_vmlal_low_u32(uint64x2_t acc, uint32x4_t lhs, uint32x4_t rhs)\n{\n    return vmlal_u32(acc, vget_low_u32(lhs), vget_low_u32(rhs));\n}\n/*! @copydoc XXH_vmlal_low_u32\n * Assume the compiler converts this to vmlal_high_u32 on aarch64 */\nXXH_FORCE_INLINE uint64x2_t\nXXH_vmlal_high_u32(uint64x2_t acc, uint32x4_t lhs, uint32x4_t rhs)\n{\n    return vmlal_u32(acc, vget_high_u32(lhs), vget_high_u32(rhs));\n}\n#endif\n\n/*!\n * @ingroup tuning\n * @brief Controls the NEON to scalar ratio for XXH3\n *\n * This can be set to 2, 4, 6, or 8.\n *\n * ARM Cortex CPUs are _very_ sensitive to how their pipelines are used.\n *\n * For example, the Cortex-A73 can dispatch 3 micro-ops per cycle, but only 2 of those\n * can be NEON. If you are only using NEON instructions, you are only using 2/3 of the CPU\n * bandwidth.\n *\n * This is even more noticeable on the more advanced cores like the Cortex-A76 which\n * can dispatch 8 micro-ops per cycle, but still only 2 NEON micro-ops at once.\n *\n * Therefore, to make the most out of the pipeline, it is beneficial to run 6 NEON lanes\n * and 2 scalar lanes, which is chosen by default.\n *\n * This does not apply to Apple processors or 32-bit processors, which run better with\n * full NEON. These will default to 8. Additionally, size-optimized builds run 8 lanes.\n *\n * This change benefits CPUs with large micro-op buffers without negatively affecting\n * most other CPUs:\n *\n *  | Chipset               | Dispatch type       | NEON only | 6:2 hybrid | Diff. |\n *  |:----------------------|:--------------------|----------:|-----------:|------:|\n *  | Snapdragon 730 (A76)  | 2 NEON/8 micro-ops  |  8.8 GB/s |  10.1 GB/s |  ~16% |\n *  | Snapdragon 835 (A73)  | 2 NEON/3 micro-ops  |  5.1 GB/s |   5.3 GB/s |   ~5% |\n *  | Marvell PXA1928 (A53) | In-order dual-issue |  1.9 GB/s |   1.9 GB/s |    0% |\n *  | Apple M1              | 4 NEON/8 micro-ops  | 37.3 GB/s |  36.1 GB/s |  ~-3% |\n *\n * It also seems to fix some bad codegen on GCC, making it almost as fast as clang.\n *\n * When using WASM SIMD128, if this is 2 or 6, SIMDe will scalarize 2 of the lanes meaning\n * it effectively becomes worse 4.\n *\n * @see XXH3_accumulate_512_neon()\n */\n# ifndef XXH3_NEON_LANES\n#  if (defined(__aarch64__) || defined(__arm64__) || defined(_M_ARM64) || defined(_M_ARM64EC)) \\\n   && !defined(__APPLE__) && XXH_SIZE_OPT <= 0\n#   define XXH3_NEON_LANES 6\n#  else\n#   define XXH3_NEON_LANES XXH_ACC_NB\n#  endif\n# endif\n#endif  /* XXH_VECTOR == XXH_NEON */\n\n#if defined (__cplusplus)\n} /* extern \"C\" */\n#endif\n\n/*\n * VSX and Z Vector helpers.\n *\n * This is very messy, and any pull requests to clean this up are welcome.\n *\n * There are a lot of problems with supporting VSX and s390x, due to\n * inconsistent intrinsics, spotty coverage, and multiple endiannesses.\n */\n#if XXH_VECTOR == XXH_VSX\n/* Annoyingly, these headers _may_ define three macros: `bool`, `vector`,\n * and `pixel`. This is a problem for obvious reasons.\n *\n * These keywords are unnecessary; the spec literally says they are\n * equivalent to `__bool`, `__vector`, and `__pixel` and may be undef'd\n * after including the header.\n *\n * We use pragma push_macro/pop_macro to keep the namespace clean. */\n#  pragma push_macro(\"bool\")\n#  pragma push_macro(\"vector\")\n#  pragma push_macro(\"pixel\")\n/* silence potential macro redefined warnings */\n#  undef bool\n#  undef vector\n#  undef pixel\n\n#  if defined(__s390x__)\n#    include \n#  else\n#    include \n#  endif\n\n/* Restore the original macro values, if applicable. */\n#  pragma pop_macro(\"pixel\")\n#  pragma pop_macro(\"vector\")\n#  pragma pop_macro(\"bool\")\n\ntypedef __vector unsigned long long xxh_u64x2;\ntypedef __vector unsigned char xxh_u8x16;\ntypedef __vector unsigned xxh_u32x4;\n\n/*\n * UGLY HACK: Similar to aarch64 macOS GCC, s390x GCC has the same aliasing issue.\n */\ntypedef xxh_u64x2 xxh_aliasing_u64x2 XXH_ALIASING;\n\n# ifndef XXH_VSX_BE\n#  if defined(__BIG_ENDIAN__) \\\n  || (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)\n#    define XXH_VSX_BE 1\n#  elif defined(__VEC_ELEMENT_REG_ORDER__) && __VEC_ELEMENT_REG_ORDER__ == __ORDER_BIG_ENDIAN__\n#    warning \"-maltivec=be is not recommended. Please use native endianness.\"\n#    define XXH_VSX_BE 1\n#  else\n#    define XXH_VSX_BE 0\n#  endif\n# endif /* !defined(XXH_VSX_BE) */\n\n# if XXH_VSX_BE\n#  if defined(__POWER9_VECTOR__) || (defined(__clang__) && defined(__s390x__))\n#    define XXH_vec_revb vec_revb\n#  else\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n/*!\n * A polyfill for POWER9's vec_revb().\n */\nXXH_FORCE_INLINE xxh_u64x2 XXH_vec_revb(xxh_u64x2 val)\n{\n    xxh_u8x16 const vByteSwap = { 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00,\n                                  0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08 };\n    return vec_perm(val, val, vByteSwap);\n}\n#if defined (__cplusplus)\n} /* extern \"C\" */\n#endif\n#  endif\n# endif /* XXH_VSX_BE */\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n/*!\n * Performs an unaligned vector load and byte swaps it on big endian.\n */\nXXH_FORCE_INLINE xxh_u64x2 XXH_vec_loadu(const void *ptr)\n{\n    xxh_u64x2 ret;\n    XXH_memcpy(&ret, ptr, sizeof(xxh_u64x2));\n# if XXH_VSX_BE\n    ret = XXH_vec_revb(ret);\n# endif\n    return ret;\n}\n\n/*\n * vec_mulo and vec_mule are very problematic intrinsics on PowerPC\n *\n * These intrinsics weren't added until GCC 8, despite existing for a while,\n * and they are endian dependent. Also, their meaning swap depending on version.\n * */\n# if defined(__s390x__)\n /* s390x is always big endian, no issue on this platform */\n#  define XXH_vec_mulo vec_mulo\n#  define XXH_vec_mule vec_mule\n# elif defined(__clang__) && XXH_HAS_BUILTIN(__builtin_altivec_vmuleuw) && !defined(__ibmxl__)\n/* Clang has a better way to control this, we can just use the builtin which doesn't swap. */\n /* The IBM XL Compiler (which defined __clang__) only implements the vec_* operations */\n#  define XXH_vec_mulo __builtin_altivec_vmulouw\n#  define XXH_vec_mule __builtin_altivec_vmuleuw\n# else\n/* gcc needs inline assembly */\n/* Adapted from https://github.com/google/highwayhash/blob/master/highwayhash/hh_vsx.h. */\nXXH_FORCE_INLINE xxh_u64x2 XXH_vec_mulo(xxh_u32x4 a, xxh_u32x4 b)\n{\n    xxh_u64x2 result;\n    __asm__(\"vmulouw %0, %1, %2\" : \"=v\" (result) : \"v\" (a), \"v\" (b));\n    return result;\n}\nXXH_FORCE_INLINE xxh_u64x2 XXH_vec_mule(xxh_u32x4 a, xxh_u32x4 b)\n{\n    xxh_u64x2 result;\n    __asm__(\"vmuleuw %0, %1, %2\" : \"=v\" (result) : \"v\" (a), \"v\" (b));\n    return result;\n}\n# endif /* XXH_vec_mulo, XXH_vec_mule */\n\n#if defined (__cplusplus)\n} /* extern \"C\" */\n#endif\n\n#endif /* XXH_VECTOR == XXH_VSX */\n\n#if XXH_VECTOR == XXH_SVE\n#define ACCRND(acc, offset) \\\ndo { \\\n    svuint64_t input_vec = svld1_u64(mask, xinput + offset);         \\\n    svuint64_t secret_vec = svld1_u64(mask, xsecret + offset);       \\\n    svuint64_t mixed = sveor_u64_x(mask, secret_vec, input_vec);     \\\n    svuint64_t swapped = svtbl_u64(input_vec, kSwap);                \\\n    svuint64_t mixed_lo = svextw_u64_x(mask, mixed);                 \\\n    svuint64_t mixed_hi = svlsr_n_u64_x(mask, mixed, 32);            \\\n    svuint64_t mul = svmad_u64_x(mask, mixed_lo, mixed_hi, swapped); \\\n    acc = svadd_u64_x(mask, acc, mul);                               \\\n} while (0)\n#endif /* XXH_VECTOR == XXH_SVE */\n\n/* prefetch\n * can be disabled, by declaring XXH_NO_PREFETCH build macro */\n#if defined(XXH_NO_PREFETCH)\n#  define XXH_PREFETCH(ptr)  (void)(ptr)  /* disabled */\n#else\n#  if XXH_SIZE_OPT >= 1\n#    define XXH_PREFETCH(ptr) (void)(ptr)\n#  elif defined(_MSC_VER) && (defined(_M_X64) || defined(_M_IX86))  /* _mm_prefetch() not defined outside of x86/x64 */\n#    include    /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */\n#    define XXH_PREFETCH(ptr)  _mm_prefetch((const char*)(ptr), _MM_HINT_T0)\n#  elif defined(__GNUC__) && ( (__GNUC__ >= 4) || ( (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1) ) )\n#    define XXH_PREFETCH(ptr)  __builtin_prefetch((ptr), 0 /* rw==read */, 3 /* locality */)\n#  else\n#    define XXH_PREFETCH(ptr) (void)(ptr)  /* disabled */\n#  endif\n#endif  /* XXH_NO_PREFETCH */\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n/* ==========================================\n * XXH3 default settings\n * ========================================== */\n\n#define XXH_SECRET_DEFAULT_SIZE 192   /* minimum XXH3_SECRET_SIZE_MIN */\n\n#if (XXH_SECRET_DEFAULT_SIZE < XXH3_SECRET_SIZE_MIN)\n#  error \"default keyset is not large enough\"\n#endif\n\n/*! Pseudorandom secret taken directly from FARSH. */\nXXH_ALIGN(64) static const xxh_u8 XXH3_kSecret[XXH_SECRET_DEFAULT_SIZE] = {\n    0xb8, 0xfe, 0x6c, 0x39, 0x23, 0xa4, 0x4b, 0xbe, 0x7c, 0x01, 0x81, 0x2c, 0xf7, 0x21, 0xad, 0x1c,\n    0xde, 0xd4, 0x6d, 0xe9, 0x83, 0x90, 0x97, 0xdb, 0x72, 0x40, 0xa4, 0xa4, 0xb7, 0xb3, 0x67, 0x1f,\n    0xcb, 0x79, 0xe6, 0x4e, 0xcc, 0xc0, 0xe5, 0x78, 0x82, 0x5a, 0xd0, 0x7d, 0xcc, 0xff, 0x72, 0x21,\n    0xb8, 0x08, 0x46, 0x74, 0xf7, 0x43, 0x24, 0x8e, 0xe0, 0x35, 0x90, 0xe6, 0x81, 0x3a, 0x26, 0x4c,\n    0x3c, 0x28, 0x52, 0xbb, 0x91, 0xc3, 0x00, 0xcb, 0x88, 0xd0, 0x65, 0x8b, 0x1b, 0x53, 0x2e, 0xa3,\n    0x71, 0x64, 0x48, 0x97, 0xa2, 0x0d, 0xf9, 0x4e, 0x38, 0x19, 0xef, 0x46, 0xa9, 0xde, 0xac, 0xd8,\n    0xa8, 0xfa, 0x76, 0x3f, 0xe3, 0x9c, 0x34, 0x3f, 0xf9, 0xdc, 0xbb, 0xc7, 0xc7, 0x0b, 0x4f, 0x1d,\n    0x8a, 0x51, 0xe0, 0x4b, 0xcd, 0xb4, 0x59, 0x31, 0xc8, 0x9f, 0x7e, 0xc9, 0xd9, 0x78, 0x73, 0x64,\n    0xea, 0xc5, 0xac, 0x83, 0x34, 0xd3, 0xeb, 0xc3, 0xc5, 0x81, 0xa0, 0xff, 0xfa, 0x13, 0x63, 0xeb,\n    0x17, 0x0d, 0xdd, 0x51, 0xb7, 0xf0, 0xda, 0x49, 0xd3, 0x16, 0x55, 0x26, 0x29, 0xd4, 0x68, 0x9e,\n    0x2b, 0x16, 0xbe, 0x58, 0x7d, 0x47, 0xa1, 0xfc, 0x8f, 0xf8, 0xb8, 0xd1, 0x7a, 0xd0, 0x31, 0xce,\n    0x45, 0xcb, 0x3a, 0x8f, 0x95, 0x16, 0x04, 0x28, 0xaf, 0xd7, 0xfb, 0xca, 0xbb, 0x4b, 0x40, 0x7e,\n};\n\nstatic const xxh_u64 PRIME_MX1 = 0x165667919E3779F9ULL;  /*!< 0b0001011001010110011001111001000110011110001101110111100111111001 */\nstatic const xxh_u64 PRIME_MX2 = 0x9FB21C651E98DF25ULL;  /*!< 0b1001111110110010000111000110010100011110100110001101111100100101 */\n\n#ifdef XXH_OLD_NAMES\n#  define kSecret XXH3_kSecret\n#endif\n\n#ifdef XXH_DOXYGEN\n/*!\n * @brief Calculates a 32-bit to 64-bit long multiply.\n *\n * Implemented as a macro.\n *\n * Wraps `__emulu` on MSVC x86 because it tends to call `__allmul` when it doesn't\n * need to (but it shouldn't need to anyways, it is about 7 instructions to do\n * a 64x64 multiply...). Since we know that this will _always_ emit `MULL`, we\n * use that instead of the normal method.\n *\n * If you are compiling for platforms like Thumb-1 and don't have a better option,\n * you may also want to write your own long multiply routine here.\n *\n * @param x, y Numbers to be multiplied\n * @return 64-bit product of the low 32 bits of @p x and @p y.\n */\nXXH_FORCE_INLINE xxh_u64\nXXH_mult32to64(xxh_u64 x, xxh_u64 y)\n{\n   return (x & 0xFFFFFFFF) * (y & 0xFFFFFFFF);\n}\n#elif defined(_MSC_VER) && defined(_M_IX86)\n#    define XXH_mult32to64(x, y) __emulu((unsigned)(x), (unsigned)(y))\n#else\n/*\n * Downcast + upcast is usually better than masking on older compilers like\n * GCC 4.2 (especially 32-bit ones), all without affecting newer compilers.\n *\n * The other method, (x & 0xFFFFFFFF) * (y & 0xFFFFFFFF), will AND both operands\n * and perform a full 64x64 multiply -- entirely redundant on 32-bit.\n */\n#    define XXH_mult32to64(x, y) ((xxh_u64)(xxh_u32)(x) * (xxh_u64)(xxh_u32)(y))\n#endif\n\n/*!\n * @brief Calculates a 64->128-bit long multiply.\n *\n * Uses `__uint128_t` and `_umul128` if available, otherwise uses a scalar\n * version.\n *\n * @param lhs , rhs The 64-bit integers to be multiplied\n * @return The 128-bit result represented in an @ref XXH128_hash_t.\n */\nstatic XXH128_hash_t\nXXH_mult64to128(xxh_u64 lhs, xxh_u64 rhs)\n{\n    /*\n     * GCC/Clang __uint128_t method.\n     *\n     * On most 64-bit targets, GCC and Clang define a __uint128_t type.\n     * This is usually the best way as it usually uses a native long 64-bit\n     * multiply, such as MULQ on x86_64 or MUL + UMULH on aarch64.\n     *\n     * Usually.\n     *\n     * Despite being a 32-bit platform, Clang (and emscripten) define this type\n     * despite not having the arithmetic for it. This results in a laggy\n     * compiler builtin call which calculates a full 128-bit multiply.\n     * In that case it is best to use the portable one.\n     * https://github.com/Cyan4973/xxHash/issues/211#issuecomment-515575677\n     */\n#if (defined(__GNUC__) || defined(__clang__)) && !defined(__wasm__) \\\n    && defined(__SIZEOF_INT128__) \\\n    || (defined(_INTEGRAL_MAX_BITS) && _INTEGRAL_MAX_BITS >= 128)\n\n    __uint128_t const product = (__uint128_t)lhs * (__uint128_t)rhs;\n    XXH128_hash_t r128;\n    r128.low64  = (xxh_u64)(product);\n    r128.high64 = (xxh_u64)(product >> 64);\n    return r128;\n\n    /*\n     * MSVC for x64's _umul128 method.\n     *\n     * xxh_u64 _umul128(xxh_u64 Multiplier, xxh_u64 Multiplicand, xxh_u64 *HighProduct);\n     *\n     * This compiles to single operand MUL on x64.\n     */\n#elif (defined(_M_X64) || defined(_M_IA64)) && !defined(_M_ARM64EC)\n\n#ifndef _MSC_VER\n#   pragma intrinsic(_umul128)\n#endif\n    xxh_u64 product_high;\n    xxh_u64 const product_low = _umul128(lhs, rhs, &product_high);\n    XXH128_hash_t r128;\n    r128.low64  = product_low;\n    r128.high64 = product_high;\n    return r128;\n\n    /*\n     * MSVC for ARM64's __umulh method.\n     *\n     * This compiles to the same MUL + UMULH as GCC/Clang's __uint128_t method.\n     */\n#elif defined(_M_ARM64) || defined(_M_ARM64EC)\n\n#ifndef _MSC_VER\n#   pragma intrinsic(__umulh)\n#endif\n    XXH128_hash_t r128;\n    r128.low64  = lhs * rhs;\n    r128.high64 = __umulh(lhs, rhs);\n    return r128;\n\n#else\n    /*\n     * Portable scalar method. Optimized for 32-bit and 64-bit ALUs.\n     *\n     * This is a fast and simple grade school multiply, which is shown below\n     * with base 10 arithmetic instead of base 0x100000000.\n     *\n     *           9 3 // D2 lhs = 93\n     *         x 7 5 // D2 rhs = 75\n     *     ----------\n     *           1 5 // D2 lo_lo = (93 % 10) * (75 % 10) = 15\n     *         4 5 | // D2 hi_lo = (93 / 10) * (75 % 10) = 45\n     *         2 1 | // D2 lo_hi = (93 % 10) * (75 / 10) = 21\n     *     + 6 3 | | // D2 hi_hi = (93 / 10) * (75 / 10) = 63\n     *     ---------\n     *         2 7 | // D2 cross = (15 / 10) + (45 % 10) + 21 = 27\n     *     + 6 7 | | // D2 upper = (27 / 10) + (45 / 10) + 63 = 67\n     *     ---------\n     *       6 9 7 5 // D4 res = (27 * 10) + (15 % 10) + (67 * 100) = 6975\n     *\n     * The reasons for adding the products like this are:\n     *  1. It avoids manual carry tracking. Just like how\n     *     (9 * 9) + 9 + 9 = 99, the same applies with this for UINT64_MAX.\n     *     This avoids a lot of complexity.\n     *\n     *  2. It hints for, and on Clang, compiles to, the powerful UMAAL\n     *     instruction available in ARM's Digital Signal Processing extension\n     *     in 32-bit ARMv6 and later, which is shown below:\n     *\n     *         void UMAAL(xxh_u32 *RdLo, xxh_u32 *RdHi, xxh_u32 Rn, xxh_u32 Rm)\n     *         {\n     *             xxh_u64 product = (xxh_u64)*RdLo * (xxh_u64)*RdHi + Rn + Rm;\n     *             *RdLo = (xxh_u32)(product & 0xFFFFFFFF);\n     *             *RdHi = (xxh_u32)(product >> 32);\n     *         }\n     *\n     *     This instruction was designed for efficient long multiplication, and\n     *     allows this to be calculated in only 4 instructions at speeds\n     *     comparable to some 64-bit ALUs.\n     *\n     *  3. It isn't terrible on other platforms. Usually this will be a couple\n     *     of 32-bit ADD/ADCs.\n     */\n\n    /* First calculate all of the cross products. */\n    xxh_u64 const lo_lo = XXH_mult32to64(lhs & 0xFFFFFFFF, rhs & 0xFFFFFFFF);\n    xxh_u64 const hi_lo = XXH_mult32to64(lhs >> 32,        rhs & 0xFFFFFFFF);\n    xxh_u64 const lo_hi = XXH_mult32to64(lhs & 0xFFFFFFFF, rhs >> 32);\n    xxh_u64 const hi_hi = XXH_mult32to64(lhs >> 32,        rhs >> 32);\n\n    /* Now add the products together. These will never overflow. */\n    xxh_u64 const cross = (lo_lo >> 32) + (hi_lo & 0xFFFFFFFF) + lo_hi;\n    xxh_u64 const upper = (hi_lo >> 32) + (cross >> 32)        + hi_hi;\n    xxh_u64 const lower = (cross << 32) | (lo_lo & 0xFFFFFFFF);\n\n    XXH128_hash_t r128;\n    r128.low64  = lower;\n    r128.high64 = upper;\n    return r128;\n#endif\n}\n\n/*!\n * @brief Calculates a 64-bit to 128-bit multiply, then XOR folds it.\n *\n * The reason for the separate function is to prevent passing too many structs\n * around by value. This will hopefully inline the multiply, but we don't force it.\n *\n * @param lhs , rhs The 64-bit integers to multiply\n * @return The low 64 bits of the product XOR'd by the high 64 bits.\n * @see XXH_mult64to128()\n */\nstatic xxh_u64\nXXH3_mul128_fold64(xxh_u64 lhs, xxh_u64 rhs)\n{\n    XXH128_hash_t product = XXH_mult64to128(lhs, rhs);\n    return product.low64 ^ product.high64;\n}\n\n/*! Seems to produce slightly better code on GCC for some reason. */\nXXH_FORCE_INLINE XXH_CONSTF xxh_u64 XXH_xorshift64(xxh_u64 v64, int shift)\n{\n    XXH_ASSERT(0 <= shift && shift < 64);\n    return v64 ^ (v64 >> shift);\n}\n\n/*\n * This is a fast avalanche stage,\n * suitable when input bits are already partially mixed\n */\nstatic XXH64_hash_t XXH3_avalanche(xxh_u64 h64)\n{\n    h64 = XXH_xorshift64(h64, 37);\n    h64 *= PRIME_MX1;\n    h64 = XXH_xorshift64(h64, 32);\n    return h64;\n}\n\n/*\n * This is a stronger avalanche,\n * inspired by Pelle Evensen's rrmxmx\n * preferable when input has not been previously mixed\n */\nstatic XXH64_hash_t XXH3_rrmxmx(xxh_u64 h64, xxh_u64 len)\n{\n    /* this mix is inspired by Pelle Evensen's rrmxmx */\n    h64 ^= XXH_rotl64(h64, 49) ^ XXH_rotl64(h64, 24);\n    h64 *= PRIME_MX2;\n    h64 ^= (h64 >> 35) + len ;\n    h64 *= PRIME_MX2;\n    return XXH_xorshift64(h64, 28);\n}\n\n\n/* ==========================================\n * Short keys\n * ==========================================\n * One of the shortcomings of XXH32 and XXH64 was that their performance was\n * sub-optimal on short lengths. It used an iterative algorithm which strongly\n * favored lengths that were a multiple of 4 or 8.\n *\n * Instead of iterating over individual inputs, we use a set of single shot\n * functions which piece together a range of lengths and operate in constant time.\n *\n * Additionally, the number of multiplies has been significantly reduced. This\n * reduces latency, especially when emulating 64-bit multiplies on 32-bit.\n *\n * Depending on the platform, this may or may not be faster than XXH32, but it\n * is almost guaranteed to be faster than XXH64.\n */\n\n/*\n * At very short lengths, there isn't enough input to fully hide secrets, or use\n * the entire secret.\n *\n * There is also only a limited amount of mixing we can do before significantly\n * impacting performance.\n *\n * Therefore, we use different sections of the secret and always mix two secret\n * samples with an XOR. This should have no effect on performance on the\n * seedless or withSeed variants because everything _should_ be constant folded\n * by modern compilers.\n *\n * The XOR mixing hides individual parts of the secret and increases entropy.\n *\n * This adds an extra layer of strength for custom secrets.\n */\nXXH_FORCE_INLINE XXH_PUREF XXH64_hash_t\nXXH3_len_1to3_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)\n{\n    XXH_ASSERT(input != NULL);\n    XXH_ASSERT(1 <= len && len <= 3);\n    XXH_ASSERT(secret != NULL);\n    /*\n     * len = 1: combined = { input[0], 0x01, input[0], input[0] }\n     * len = 2: combined = { input[1], 0x02, input[0], input[1] }\n     * len = 3: combined = { input[2], 0x03, input[0], input[1] }\n     */\n    {   xxh_u8  const c1 = input[0];\n        xxh_u8  const c2 = input[len >> 1];\n        xxh_u8  const c3 = input[len - 1];\n        xxh_u32 const combined = ((xxh_u32)c1 << 16) | ((xxh_u32)c2  << 24)\n                               | ((xxh_u32)c3 <<  0) | ((xxh_u32)len << 8);\n        xxh_u64 const bitflip = (XXH_readLE32(secret) ^ XXH_readLE32(secret+4)) + seed;\n        xxh_u64 const keyed = (xxh_u64)combined ^ bitflip;\n        return XXH64_avalanche(keyed);\n    }\n}\n\nXXH_FORCE_INLINE XXH_PUREF XXH64_hash_t\nXXH3_len_4to8_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)\n{\n    XXH_ASSERT(input != NULL);\n    XXH_ASSERT(secret != NULL);\n    XXH_ASSERT(4 <= len && len <= 8);\n    seed ^= (xxh_u64)XXH_swap32((xxh_u32)seed) << 32;\n    {   xxh_u32 const input1 = XXH_readLE32(input);\n        xxh_u32 const input2 = XXH_readLE32(input + len - 4);\n        xxh_u64 const bitflip = (XXH_readLE64(secret+8) ^ XXH_readLE64(secret+16)) - seed;\n        xxh_u64 const input64 = input2 + (((xxh_u64)input1) << 32);\n        xxh_u64 const keyed = input64 ^ bitflip;\n        return XXH3_rrmxmx(keyed, len);\n    }\n}\n\nXXH_FORCE_INLINE XXH_PUREF XXH64_hash_t\nXXH3_len_9to16_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)\n{\n    XXH_ASSERT(input != NULL);\n    XXH_ASSERT(secret != NULL);\n    XXH_ASSERT(9 <= len && len <= 16);\n    {   xxh_u64 const bitflip1 = (XXH_readLE64(secret+24) ^ XXH_readLE64(secret+32)) + seed;\n        xxh_u64 const bitflip2 = (XXH_readLE64(secret+40) ^ XXH_readLE64(secret+48)) - seed;\n        xxh_u64 const input_lo = XXH_readLE64(input)           ^ bitflip1;\n        xxh_u64 const input_hi = XXH_readLE64(input + len - 8) ^ bitflip2;\n        xxh_u64 const acc = len\n                          + XXH_swap64(input_lo) + input_hi\n                          + XXH3_mul128_fold64(input_lo, input_hi);\n        return XXH3_avalanche(acc);\n    }\n}\n\nXXH_FORCE_INLINE XXH_PUREF XXH64_hash_t\nXXH3_len_0to16_64b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)\n{\n    XXH_ASSERT(len <= 16);\n    {   if (XXH_likely(len >  8)) return XXH3_len_9to16_64b(input, len, secret, seed);\n        if (XXH_likely(len >= 4)) return XXH3_len_4to8_64b(input, len, secret, seed);\n        if (len) return XXH3_len_1to3_64b(input, len, secret, seed);\n        return XXH64_avalanche(seed ^ (XXH_readLE64(secret+56) ^ XXH_readLE64(secret+64)));\n    }\n}\n\n/*\n * DISCLAIMER: There are known *seed-dependent* multicollisions here due to\n * multiplication by zero, affecting hashes of lengths 17 to 240.\n *\n * However, they are very unlikely.\n *\n * Keep this in mind when using the unseeded XXH3_64bits() variant: As with all\n * unseeded non-cryptographic hashes, it does not attempt to defend itself\n * against specially crafted inputs, only random inputs.\n *\n * Compared to classic UMAC where a 1 in 2^31 chance of 4 consecutive bytes\n * cancelling out the secret is taken an arbitrary number of times (addressed\n * in XXH3_accumulate_512), this collision is very unlikely with random inputs\n * and/or proper seeding:\n *\n * This only has a 1 in 2^63 chance of 8 consecutive bytes cancelling out, in a\n * function that is only called up to 16 times per hash with up to 240 bytes of\n * input.\n *\n * This is not too bad for a non-cryptographic hash function, especially with\n * only 64 bit outputs.\n *\n * The 128-bit variant (which trades some speed for strength) is NOT affected\n * by this, although it is always a good idea to use a proper seed if you care\n * about strength.\n */\nXXH_FORCE_INLINE xxh_u64 XXH3_mix16B(const xxh_u8* XXH_RESTRICT input,\n                                     const xxh_u8* XXH_RESTRICT secret, xxh_u64 seed64)\n{\n#if defined(__GNUC__) && !defined(__clang__) /* GCC, not Clang */ \\\n  && defined(__i386__) && defined(__SSE2__)  /* x86 + SSE2 */ \\\n  && !defined(XXH_ENABLE_AUTOVECTORIZE)      /* Define to disable like XXH32 hack */\n    /*\n     * UGLY HACK:\n     * GCC for x86 tends to autovectorize the 128-bit multiply, resulting in\n     * slower code.\n     *\n     * By forcing seed64 into a register, we disrupt the cost model and\n     * cause it to scalarize. See `XXH32_round()`\n     *\n     * FIXME: Clang's output is still _much_ faster -- On an AMD Ryzen 3600,\n     * XXH3_64bits @ len=240 runs at 4.6 GB/s with Clang 9, but 3.3 GB/s on\n     * GCC 9.2, despite both emitting scalar code.\n     *\n     * GCC generates much better scalar code than Clang for the rest of XXH3,\n     * which is why finding a more optimal codepath is an interest.\n     */\n    XXH_COMPILER_GUARD(seed64);\n#endif\n    {   xxh_u64 const input_lo = XXH_readLE64(input);\n        xxh_u64 const input_hi = XXH_readLE64(input+8);\n        return XXH3_mul128_fold64(\n            input_lo ^ (XXH_readLE64(secret)   + seed64),\n            input_hi ^ (XXH_readLE64(secret+8) - seed64)\n        );\n    }\n}\n\n/* For mid range keys, XXH3 uses a Mum-hash variant. */\nXXH_FORCE_INLINE XXH_PUREF XXH64_hash_t\nXXH3_len_17to128_64b(const xxh_u8* XXH_RESTRICT input, size_t len,\n                     const xxh_u8* XXH_RESTRICT secret, size_t secretSize,\n                     XXH64_hash_t seed)\n{\n    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize;\n    XXH_ASSERT(16 < len && len <= 128);\n\n    {   xxh_u64 acc = len * XXH_PRIME64_1;\n#if XXH_SIZE_OPT >= 1\n        /* Smaller and cleaner, but slightly slower. */\n        unsigned int i = (unsigned int)(len - 1) / 32;\n        do {\n            acc += XXH3_mix16B(input+16 * i, secret+32*i, seed);\n            acc += XXH3_mix16B(input+len-16*(i+1), secret+32*i+16, seed);\n        } while (i-- != 0);\n#else\n        if (len > 32) {\n            if (len > 64) {\n                if (len > 96) {\n                    acc += XXH3_mix16B(input+48, secret+96, seed);\n                    acc += XXH3_mix16B(input+len-64, secret+112, seed);\n                }\n                acc += XXH3_mix16B(input+32, secret+64, seed);\n                acc += XXH3_mix16B(input+len-48, secret+80, seed);\n            }\n            acc += XXH3_mix16B(input+16, secret+32, seed);\n            acc += XXH3_mix16B(input+len-32, secret+48, seed);\n        }\n        acc += XXH3_mix16B(input+0, secret+0, seed);\n        acc += XXH3_mix16B(input+len-16, secret+16, seed);\n#endif\n        return XXH3_avalanche(acc);\n    }\n}\n\n/*!\n * @brief Maximum size of \"short\" key in bytes.\n */\n#define XXH3_MIDSIZE_MAX 240\n\nXXH_NO_INLINE XXH_PUREF XXH64_hash_t\nXXH3_len_129to240_64b(const xxh_u8* XXH_RESTRICT input, size_t len,\n                      const xxh_u8* XXH_RESTRICT secret, size_t secretSize,\n                      XXH64_hash_t seed)\n{\n    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize;\n    XXH_ASSERT(128 < len && len <= XXH3_MIDSIZE_MAX);\n\n    #define XXH3_MIDSIZE_STARTOFFSET 3\n    #define XXH3_MIDSIZE_LASTOFFSET  17\n\n    {   xxh_u64 acc = len * XXH_PRIME64_1;\n        xxh_u64 acc_end;\n        unsigned int const nbRounds = (unsigned int)len / 16;\n        unsigned int i;\n        XXH_ASSERT(128 < len && len <= XXH3_MIDSIZE_MAX);\n        for (i=0; i<8; i++) {\n            acc += XXH3_mix16B(input+(16*i), secret+(16*i), seed);\n        }\n        /* last bytes */\n        acc_end = XXH3_mix16B(input + len - 16, secret + XXH3_SECRET_SIZE_MIN - XXH3_MIDSIZE_LASTOFFSET, seed);\n        XXH_ASSERT(nbRounds >= 8);\n        acc = XXH3_avalanche(acc);\n#if defined(__clang__)                                /* Clang */ \\\n    && (defined(__ARM_NEON) || defined(__ARM_NEON__)) /* NEON */ \\\n    && !defined(XXH_ENABLE_AUTOVECTORIZE)             /* Define to disable */\n        /*\n         * UGLY HACK:\n         * Clang for ARMv7-A tries to vectorize this loop, similar to GCC x86.\n         * In everywhere else, it uses scalar code.\n         *\n         * For 64->128-bit multiplies, even if the NEON was 100% optimal, it\n         * would still be slower than UMAAL (see XXH_mult64to128).\n         *\n         * Unfortunately, Clang doesn't handle the long multiplies properly and\n         * converts them to the nonexistent \"vmulq_u64\" intrinsic, which is then\n         * scalarized into an ugly mess of VMOV.32 instructions.\n         *\n         * This mess is difficult to avoid without turning autovectorization\n         * off completely, but they are usually relatively minor and/or not\n         * worth it to fix.\n         *\n         * This loop is the easiest to fix, as unlike XXH32, this pragma\n         * _actually works_ because it is a loop vectorization instead of an\n         * SLP vectorization.\n         */\n        #pragma clang loop vectorize(disable)\n#endif\n        for (i=8 ; i < nbRounds; i++) {\n            /*\n             * Prevents clang for unrolling the acc loop and interleaving with this one.\n             */\n            XXH_COMPILER_GUARD(acc);\n            acc_end += XXH3_mix16B(input+(16*i), secret+(16*(i-8)) + XXH3_MIDSIZE_STARTOFFSET, seed);\n        }\n        return XXH3_avalanche(acc + acc_end);\n    }\n}\n\n\n/* =======     Long Keys     ======= */\n\n#define XXH_STRIPE_LEN 64\n#define XXH_SECRET_CONSUME_RATE 8   /* nb of secret bytes consumed at each accumulation */\n#define XXH_ACC_NB (XXH_STRIPE_LEN / sizeof(xxh_u64))\n\n#ifdef XXH_OLD_NAMES\n#  define STRIPE_LEN XXH_STRIPE_LEN\n#  define ACC_NB XXH_ACC_NB\n#endif\n\n#ifndef XXH_PREFETCH_DIST\n#  ifdef __clang__\n#    define XXH_PREFETCH_DIST 320\n#  else\n#    if (XXH_VECTOR == XXH_AVX512)\n#      define XXH_PREFETCH_DIST 512\n#    else\n#      define XXH_PREFETCH_DIST 384\n#    endif\n#  endif  /* __clang__ */\n#endif  /* XXH_PREFETCH_DIST */\n\n/*\n * These macros are to generate an XXH3_accumulate() function.\n * The two arguments select the name suffix and target attribute.\n *\n * The name of this symbol is XXH3_accumulate_() and it calls\n * XXH3_accumulate_512_().\n *\n * It may be useful to hand implement this function if the compiler fails to\n * optimize the inline function.\n */\n#define XXH3_ACCUMULATE_TEMPLATE(name)                      \\\nvoid                                                        \\\nXXH3_accumulate_##name(xxh_u64* XXH_RESTRICT acc,           \\\n                       const xxh_u8* XXH_RESTRICT input,    \\\n                       const xxh_u8* XXH_RESTRICT secret,   \\\n                       size_t nbStripes)                    \\\n{                                                           \\\n    size_t n;                                               \\\n    for (n = 0; n < nbStripes; n++ ) {                      \\\n        const xxh_u8* const in = input + n*XXH_STRIPE_LEN;  \\\n        XXH_PREFETCH(in + XXH_PREFETCH_DIST);               \\\n        XXH3_accumulate_512_##name(                         \\\n                 acc,                                       \\\n                 in,                                        \\\n                 secret + n*XXH_SECRET_CONSUME_RATE);       \\\n    }                                                       \\\n}\n\n\nXXH_FORCE_INLINE void XXH_writeLE64(void* dst, xxh_u64 v64)\n{\n    if (!XXH_CPU_LITTLE_ENDIAN) v64 = XXH_swap64(v64);\n    XXH_memcpy(dst, &v64, sizeof(v64));\n}\n\n/* Several intrinsic functions below are supposed to accept __int64 as argument,\n * as documented in https://software.intel.com/sites/landingpage/IntrinsicsGuide/ .\n * However, several environments do not define __int64 type,\n * requiring a workaround.\n */\n#if !defined (__VMS) \\\n  && (defined (__cplusplus) \\\n  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )\n    typedef int64_t xxh_i64;\n#else\n    /* the following type must have a width of 64-bit */\n    typedef long long xxh_i64;\n#endif\n\n\n/*\n * XXH3_accumulate_512 is the tightest loop for long inputs, and it is the most optimized.\n *\n * It is a hardened version of UMAC, based off of FARSH's implementation.\n *\n * This was chosen because it adapts quite well to 32-bit, 64-bit, and SIMD\n * implementations, and it is ridiculously fast.\n *\n * We harden it by mixing the original input to the accumulators as well as the product.\n *\n * This means that in the (relatively likely) case of a multiply by zero, the\n * original input is preserved.\n *\n * On 128-bit inputs, we swap 64-bit pairs when we add the input to improve\n * cross-pollination, as otherwise the upper and lower halves would be\n * essentially independent.\n *\n * This doesn't matter on 64-bit hashes since they all get merged together in\n * the end, so we skip the extra step.\n *\n * Both XXH3_64bits and XXH3_128bits use this subroutine.\n */\n\n#if (XXH_VECTOR == XXH_AVX512) \\\n     || (defined(XXH_DISPATCH_AVX512) && XXH_DISPATCH_AVX512 != 0)\n\n#ifndef XXH_TARGET_AVX512\n# define XXH_TARGET_AVX512  /* disable attribute target */\n#endif\n\nXXH_FORCE_INLINE XXH_TARGET_AVX512 void\nXXH3_accumulate_512_avx512(void* XXH_RESTRICT acc,\n                     const void* XXH_RESTRICT input,\n                     const void* XXH_RESTRICT secret)\n{\n    __m512i* const xacc = (__m512i *) acc;\n    XXH_ASSERT((((size_t)acc) & 63) == 0);\n    XXH_STATIC_ASSERT(XXH_STRIPE_LEN == sizeof(__m512i));\n\n    {\n        /* data_vec    = input[0]; */\n        __m512i const data_vec    = _mm512_loadu_si512   (input);\n        /* key_vec     = secret[0]; */\n        __m512i const key_vec     = _mm512_loadu_si512   (secret);\n        /* data_key    = data_vec ^ key_vec; */\n        __m512i const data_key    = _mm512_xor_si512     (data_vec, key_vec);\n        /* data_key_lo = data_key >> 32; */\n        __m512i const data_key_lo = _mm512_srli_epi64 (data_key, 32);\n        /* product     = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */\n        __m512i const product     = _mm512_mul_epu32     (data_key, data_key_lo);\n        /* xacc[0] += swap(data_vec); */\n        __m512i const data_swap = _mm512_shuffle_epi32(data_vec, (_MM_PERM_ENUM)_MM_SHUFFLE(1, 0, 3, 2));\n        __m512i const sum       = _mm512_add_epi64(*xacc, data_swap);\n        /* xacc[0] += product; */\n        *xacc = _mm512_add_epi64(product, sum);\n    }\n}\nXXH_FORCE_INLINE XXH_TARGET_AVX512 XXH3_ACCUMULATE_TEMPLATE(avx512)\n\n/*\n * XXH3_scrambleAcc: Scrambles the accumulators to improve mixing.\n *\n * Multiplication isn't perfect, as explained by Google in HighwayHash:\n *\n *  // Multiplication mixes/scrambles bytes 0-7 of the 64-bit result to\n *  // varying degrees. In descending order of goodness, bytes\n *  // 3 4 2 5 1 6 0 7 have quality 228 224 164 160 100 96 36 32.\n *  // As expected, the upper and lower bytes are much worse.\n *\n * Source: https://github.com/google/highwayhash/blob/0aaf66b/highwayhash/hh_avx2.h#L291\n *\n * Since our algorithm uses a pseudorandom secret to add some variance into the\n * mix, we don't need to (or want to) mix as often or as much as HighwayHash does.\n *\n * This isn't as tight as XXH3_accumulate, but still written in SIMD to avoid\n * extraction.\n *\n * Both XXH3_64bits and XXH3_128bits use this subroutine.\n */\n\nXXH_FORCE_INLINE XXH_TARGET_AVX512 void\nXXH3_scrambleAcc_avx512(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)\n{\n    XXH_ASSERT((((size_t)acc) & 63) == 0);\n    XXH_STATIC_ASSERT(XXH_STRIPE_LEN == sizeof(__m512i));\n    {   __m512i* const xacc = (__m512i*) acc;\n        const __m512i prime32 = _mm512_set1_epi32((int)XXH_PRIME32_1);\n\n        /* xacc[0] ^= (xacc[0] >> 47) */\n        __m512i const acc_vec     = *xacc;\n        __m512i const shifted     = _mm512_srli_epi64    (acc_vec, 47);\n        /* xacc[0] ^= secret; */\n        __m512i const key_vec     = _mm512_loadu_si512   (secret);\n        __m512i const data_key    = _mm512_ternarylogic_epi32(key_vec, acc_vec, shifted, 0x96 /* key_vec ^ acc_vec ^ shifted */);\n\n        /* xacc[0] *= XXH_PRIME32_1; */\n        __m512i const data_key_hi = _mm512_srli_epi64 (data_key, 32);\n        __m512i const prod_lo     = _mm512_mul_epu32     (data_key, prime32);\n        __m512i const prod_hi     = _mm512_mul_epu32     (data_key_hi, prime32);\n        *xacc = _mm512_add_epi64(prod_lo, _mm512_slli_epi64(prod_hi, 32));\n    }\n}\n\nXXH_FORCE_INLINE XXH_TARGET_AVX512 void\nXXH3_initCustomSecret_avx512(void* XXH_RESTRICT customSecret, xxh_u64 seed64)\n{\n    XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 63) == 0);\n    XXH_STATIC_ASSERT(XXH_SEC_ALIGN == 64);\n    XXH_ASSERT(((size_t)customSecret & 63) == 0);\n    (void)(&XXH_writeLE64);\n    {   int const nbRounds = XXH_SECRET_DEFAULT_SIZE / sizeof(__m512i);\n        __m512i const seed_pos = _mm512_set1_epi64((xxh_i64)seed64);\n        __m512i const seed     = _mm512_mask_sub_epi64(seed_pos, 0xAA, _mm512_set1_epi8(0), seed_pos);\n\n        const __m512i* const src  = (const __m512i*) ((const void*) XXH3_kSecret);\n              __m512i* const dest = (      __m512i*) customSecret;\n        int i;\n        XXH_ASSERT(((size_t)src & 63) == 0); /* control alignment */\n        XXH_ASSERT(((size_t)dest & 63) == 0);\n        for (i=0; i < nbRounds; ++i) {\n            dest[i] = _mm512_add_epi64(_mm512_load_si512(src + i), seed);\n    }   }\n}\n\n#endif\n\n#if (XXH_VECTOR == XXH_AVX2) \\\n    || (defined(XXH_DISPATCH_AVX2) && XXH_DISPATCH_AVX2 != 0)\n\n#ifndef XXH_TARGET_AVX2\n# define XXH_TARGET_AVX2  /* disable attribute target */\n#endif\n\nXXH_FORCE_INLINE XXH_TARGET_AVX2 void\nXXH3_accumulate_512_avx2( void* XXH_RESTRICT acc,\n                    const void* XXH_RESTRICT input,\n                    const void* XXH_RESTRICT secret)\n{\n    XXH_ASSERT((((size_t)acc) & 31) == 0);\n    {   __m256i* const xacc    =       (__m256i *) acc;\n        /* Unaligned. This is mainly for pointer arithmetic, and because\n         * _mm256_loadu_si256 requires  a const __m256i * pointer for some reason. */\n        const         __m256i* const xinput  = (const __m256i *) input;\n        /* Unaligned. This is mainly for pointer arithmetic, and because\n         * _mm256_loadu_si256 requires a const __m256i * pointer for some reason. */\n        const         __m256i* const xsecret = (const __m256i *) secret;\n\n        size_t i;\n        for (i=0; i < XXH_STRIPE_LEN/sizeof(__m256i); i++) {\n            /* data_vec    = xinput[i]; */\n            __m256i const data_vec    = _mm256_loadu_si256    (xinput+i);\n            /* key_vec     = xsecret[i]; */\n            __m256i const key_vec     = _mm256_loadu_si256   (xsecret+i);\n            /* data_key    = data_vec ^ key_vec; */\n            __m256i const data_key    = _mm256_xor_si256     (data_vec, key_vec);\n            /* data_key_lo = data_key >> 32; */\n            __m256i const data_key_lo = _mm256_srli_epi64 (data_key, 32);\n            /* product     = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */\n            __m256i const product     = _mm256_mul_epu32     (data_key, data_key_lo);\n            /* xacc[i] += swap(data_vec); */\n            __m256i const data_swap = _mm256_shuffle_epi32(data_vec, _MM_SHUFFLE(1, 0, 3, 2));\n            __m256i const sum       = _mm256_add_epi64(xacc[i], data_swap);\n            /* xacc[i] += product; */\n            xacc[i] = _mm256_add_epi64(product, sum);\n    }   }\n}\nXXH_FORCE_INLINE XXH_TARGET_AVX2 XXH3_ACCUMULATE_TEMPLATE(avx2)\n\nXXH_FORCE_INLINE XXH_TARGET_AVX2 void\nXXH3_scrambleAcc_avx2(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)\n{\n    XXH_ASSERT((((size_t)acc) & 31) == 0);\n    {   __m256i* const xacc = (__m256i*) acc;\n        /* Unaligned. This is mainly for pointer arithmetic, and because\n         * _mm256_loadu_si256 requires a const __m256i * pointer for some reason. */\n        const         __m256i* const xsecret = (const __m256i *) secret;\n        const __m256i prime32 = _mm256_set1_epi32((int)XXH_PRIME32_1);\n\n        size_t i;\n        for (i=0; i < XXH_STRIPE_LEN/sizeof(__m256i); i++) {\n            /* xacc[i] ^= (xacc[i] >> 47) */\n            __m256i const acc_vec     = xacc[i];\n            __m256i const shifted     = _mm256_srli_epi64    (acc_vec, 47);\n            __m256i const data_vec    = _mm256_xor_si256     (acc_vec, shifted);\n            /* xacc[i] ^= xsecret; */\n            __m256i const key_vec     = _mm256_loadu_si256   (xsecret+i);\n            __m256i const data_key    = _mm256_xor_si256     (data_vec, key_vec);\n\n            /* xacc[i] *= XXH_PRIME32_1; */\n            __m256i const data_key_hi = _mm256_srli_epi64 (data_key, 32);\n            __m256i const prod_lo     = _mm256_mul_epu32     (data_key, prime32);\n            __m256i const prod_hi     = _mm256_mul_epu32     (data_key_hi, prime32);\n            xacc[i] = _mm256_add_epi64(prod_lo, _mm256_slli_epi64(prod_hi, 32));\n        }\n    }\n}\n\nXXH_FORCE_INLINE XXH_TARGET_AVX2 void XXH3_initCustomSecret_avx2(void* XXH_RESTRICT customSecret, xxh_u64 seed64)\n{\n    XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 31) == 0);\n    XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE / sizeof(__m256i)) == 6);\n    XXH_STATIC_ASSERT(XXH_SEC_ALIGN <= 64);\n    (void)(&XXH_writeLE64);\n    XXH_PREFETCH(customSecret);\n    {   __m256i const seed = _mm256_set_epi64x((xxh_i64)(0U - seed64), (xxh_i64)seed64, (xxh_i64)(0U - seed64), (xxh_i64)seed64);\n\n        const __m256i* const src  = (const __m256i*) ((const void*) XXH3_kSecret);\n              __m256i*       dest = (      __m256i*) customSecret;\n\n#       if defined(__GNUC__) || defined(__clang__)\n        /*\n         * On GCC & Clang, marking 'dest' as modified will cause the compiler:\n         *   - do not extract the secret from sse registers in the internal loop\n         *   - use less common registers, and avoid pushing these reg into stack\n         */\n        XXH_COMPILER_GUARD(dest);\n#       endif\n        XXH_ASSERT(((size_t)src & 31) == 0); /* control alignment */\n        XXH_ASSERT(((size_t)dest & 31) == 0);\n\n        /* GCC -O2 need unroll loop manually */\n        dest[0] = _mm256_add_epi64(_mm256_load_si256(src+0), seed);\n        dest[1] = _mm256_add_epi64(_mm256_load_si256(src+1), seed);\n        dest[2] = _mm256_add_epi64(_mm256_load_si256(src+2), seed);\n        dest[3] = _mm256_add_epi64(_mm256_load_si256(src+3), seed);\n        dest[4] = _mm256_add_epi64(_mm256_load_si256(src+4), seed);\n        dest[5] = _mm256_add_epi64(_mm256_load_si256(src+5), seed);\n    }\n}\n\n#endif\n\n/* x86dispatch always generates SSE2 */\n#if (XXH_VECTOR == XXH_SSE2) || defined(XXH_X86DISPATCH)\n\n#ifndef XXH_TARGET_SSE2\n# define XXH_TARGET_SSE2  /* disable attribute target */\n#endif\n\nXXH_FORCE_INLINE XXH_TARGET_SSE2 void\nXXH3_accumulate_512_sse2( void* XXH_RESTRICT acc,\n                    const void* XXH_RESTRICT input,\n                    const void* XXH_RESTRICT secret)\n{\n    /* SSE2 is just a half-scale version of the AVX2 version. */\n    XXH_ASSERT((((size_t)acc) & 15) == 0);\n    {   __m128i* const xacc    =       (__m128i *) acc;\n        /* Unaligned. This is mainly for pointer arithmetic, and because\n         * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */\n        const         __m128i* const xinput  = (const __m128i *) input;\n        /* Unaligned. This is mainly for pointer arithmetic, and because\n         * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */\n        const         __m128i* const xsecret = (const __m128i *) secret;\n\n        size_t i;\n        for (i=0; i < XXH_STRIPE_LEN/sizeof(__m128i); i++) {\n            /* data_vec    = xinput[i]; */\n            __m128i const data_vec    = _mm_loadu_si128   (xinput+i);\n            /* key_vec     = xsecret[i]; */\n            __m128i const key_vec     = _mm_loadu_si128   (xsecret+i);\n            /* data_key    = data_vec ^ key_vec; */\n            __m128i const data_key    = _mm_xor_si128     (data_vec, key_vec);\n            /* data_key_lo = data_key >> 32; */\n            __m128i const data_key_lo = _mm_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1));\n            /* product     = (data_key & 0xffffffff) * (data_key_lo & 0xffffffff); */\n            __m128i const product     = _mm_mul_epu32     (data_key, data_key_lo);\n            /* xacc[i] += swap(data_vec); */\n            __m128i const data_swap = _mm_shuffle_epi32(data_vec, _MM_SHUFFLE(1,0,3,2));\n            __m128i const sum       = _mm_add_epi64(xacc[i], data_swap);\n            /* xacc[i] += product; */\n            xacc[i] = _mm_add_epi64(product, sum);\n    }   }\n}\nXXH_FORCE_INLINE XXH_TARGET_SSE2 XXH3_ACCUMULATE_TEMPLATE(sse2)\n\nXXH_FORCE_INLINE XXH_TARGET_SSE2 void\nXXH3_scrambleAcc_sse2(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)\n{\n    XXH_ASSERT((((size_t)acc) & 15) == 0);\n    {   __m128i* const xacc = (__m128i*) acc;\n        /* Unaligned. This is mainly for pointer arithmetic, and because\n         * _mm_loadu_si128 requires a const __m128i * pointer for some reason. */\n        const         __m128i* const xsecret = (const __m128i *) secret;\n        const __m128i prime32 = _mm_set1_epi32((int)XXH_PRIME32_1);\n\n        size_t i;\n        for (i=0; i < XXH_STRIPE_LEN/sizeof(__m128i); i++) {\n            /* xacc[i] ^= (xacc[i] >> 47) */\n            __m128i const acc_vec     = xacc[i];\n            __m128i const shifted     = _mm_srli_epi64    (acc_vec, 47);\n            __m128i const data_vec    = _mm_xor_si128     (acc_vec, shifted);\n            /* xacc[i] ^= xsecret[i]; */\n            __m128i const key_vec     = _mm_loadu_si128   (xsecret+i);\n            __m128i const data_key    = _mm_xor_si128     (data_vec, key_vec);\n\n            /* xacc[i] *= XXH_PRIME32_1; */\n            __m128i const data_key_hi = _mm_shuffle_epi32 (data_key, _MM_SHUFFLE(0, 3, 0, 1));\n            __m128i const prod_lo     = _mm_mul_epu32     (data_key, prime32);\n            __m128i const prod_hi     = _mm_mul_epu32     (data_key_hi, prime32);\n            xacc[i] = _mm_add_epi64(prod_lo, _mm_slli_epi64(prod_hi, 32));\n        }\n    }\n}\n\nXXH_FORCE_INLINE XXH_TARGET_SSE2 void XXH3_initCustomSecret_sse2(void* XXH_RESTRICT customSecret, xxh_u64 seed64)\n{\n    XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 15) == 0);\n    (void)(&XXH_writeLE64);\n    {   int const nbRounds = XXH_SECRET_DEFAULT_SIZE / sizeof(__m128i);\n\n#       if defined(_MSC_VER) && defined(_M_IX86) && _MSC_VER < 1900\n        /* MSVC 32bit mode does not support _mm_set_epi64x before 2015 */\n        XXH_ALIGN(16) const xxh_i64 seed64x2[2] = { (xxh_i64)seed64, (xxh_i64)(0U - seed64) };\n        __m128i const seed = _mm_load_si128((__m128i const*)seed64x2);\n#       else\n        __m128i const seed = _mm_set_epi64x((xxh_i64)(0U - seed64), (xxh_i64)seed64);\n#       endif\n        int i;\n\n        const void* const src16 = XXH3_kSecret;\n        __m128i* dst16 = (__m128i*) customSecret;\n#       if defined(__GNUC__) || defined(__clang__)\n        /*\n         * On GCC & Clang, marking 'dest' as modified will cause the compiler:\n         *   - do not extract the secret from sse registers in the internal loop\n         *   - use less common registers, and avoid pushing these reg into stack\n         */\n        XXH_COMPILER_GUARD(dst16);\n#       endif\n        XXH_ASSERT(((size_t)src16 & 15) == 0); /* control alignment */\n        XXH_ASSERT(((size_t)dst16 & 15) == 0);\n\n        for (i=0; i < nbRounds; ++i) {\n            dst16[i] = _mm_add_epi64(_mm_load_si128((const __m128i *)src16+i), seed);\n    }   }\n}\n\n#endif\n\n#if (XXH_VECTOR == XXH_NEON)\n\n/* forward declarations for the scalar routines */\nXXH_FORCE_INLINE void\nXXH3_scalarRound(void* XXH_RESTRICT acc, void const* XXH_RESTRICT input,\n                 void const* XXH_RESTRICT secret, size_t lane);\n\nXXH_FORCE_INLINE void\nXXH3_scalarScrambleRound(void* XXH_RESTRICT acc,\n                         void const* XXH_RESTRICT secret, size_t lane);\n\n/*!\n * @internal\n * @brief The bulk processing loop for NEON and WASM SIMD128.\n *\n * The NEON code path is actually partially scalar when running on AArch64. This\n * is to optimize the pipelining and can have up to 15% speedup depending on the\n * CPU, and it also mitigates some GCC codegen issues.\n *\n * @see XXH3_NEON_LANES for configuring this and details about this optimization.\n *\n * NEON's 32-bit to 64-bit long multiply takes a half vector of 32-bit\n * integers instead of the other platforms which mask full 64-bit vectors,\n * so the setup is more complicated than just shifting right.\n *\n * Additionally, there is an optimization for 4 lanes at once noted below.\n *\n * Since, as stated, the most optimal amount of lanes for Cortexes is 6,\n * there needs to be *three* versions of the accumulate operation used\n * for the remaining 2 lanes.\n *\n * WASM's SIMD128 uses SIMDe's arm_neon.h polyfill because the intrinsics overlap\n * nearly perfectly.\n */\n\nXXH_FORCE_INLINE void\nXXH3_accumulate_512_neon( void* XXH_RESTRICT acc,\n                    const void* XXH_RESTRICT input,\n                    const void* XXH_RESTRICT secret)\n{\n    XXH_ASSERT((((size_t)acc) & 15) == 0);\n    XXH_STATIC_ASSERT(XXH3_NEON_LANES > 0 && XXH3_NEON_LANES <= XXH_ACC_NB && XXH3_NEON_LANES % 2 == 0);\n    {   /* GCC for darwin arm64 does not like aliasing here */\n        xxh_aliasing_uint64x2_t* const xacc = (xxh_aliasing_uint64x2_t*) acc;\n        /* We don't use a uint32x4_t pointer because it causes bus errors on ARMv7. */\n        uint8_t const* xinput = (const uint8_t *) input;\n        uint8_t const* xsecret  = (const uint8_t *) secret;\n\n        size_t i;\n#ifdef __wasm_simd128__\n        /*\n         * On WASM SIMD128, Clang emits direct address loads when XXH3_kSecret\n         * is constant propagated, which results in it converting it to this\n         * inside the loop:\n         *\n         *    a = v128.load(XXH3_kSecret +  0 + $secret_offset, offset = 0)\n         *    b = v128.load(XXH3_kSecret + 16 + $secret_offset, offset = 0)\n         *    ...\n         *\n         * This requires a full 32-bit address immediate (and therefore a 6 byte\n         * instruction) as well as an add for each offset.\n         *\n         * Putting an asm guard prevents it from folding (at the cost of losing\n         * the alignment hint), and uses the free offset in `v128.load` instead\n         * of adding secret_offset each time which overall reduces code size by\n         * about a kilobyte and improves performance.\n         */\n        XXH_COMPILER_GUARD(xsecret);\n#endif\n        /* Scalar lanes use the normal scalarRound routine */\n        for (i = XXH3_NEON_LANES; i < XXH_ACC_NB; i++) {\n            XXH3_scalarRound(acc, input, secret, i);\n        }\n        i = 0;\n        /* 4 NEON lanes at a time. */\n        for (; i+1 < XXH3_NEON_LANES / 2; i+=2) {\n            /* data_vec = xinput[i]; */\n            uint64x2_t data_vec_1 = XXH_vld1q_u64(xinput  + (i * 16));\n            uint64x2_t data_vec_2 = XXH_vld1q_u64(xinput  + ((i+1) * 16));\n            /* key_vec  = xsecret[i];  */\n            uint64x2_t key_vec_1  = XXH_vld1q_u64(xsecret + (i * 16));\n            uint64x2_t key_vec_2  = XXH_vld1q_u64(xsecret + ((i+1) * 16));\n            /* data_swap = swap(data_vec) */\n            uint64x2_t data_swap_1 = vextq_u64(data_vec_1, data_vec_1, 1);\n            uint64x2_t data_swap_2 = vextq_u64(data_vec_2, data_vec_2, 1);\n            /* data_key = data_vec ^ key_vec; */\n            uint64x2_t data_key_1 = veorq_u64(data_vec_1, key_vec_1);\n            uint64x2_t data_key_2 = veorq_u64(data_vec_2, key_vec_2);\n\n            /*\n             * If we reinterpret the 64x2 vectors as 32x4 vectors, we can use a\n             * de-interleave operation for 4 lanes in 1 step with `vuzpq_u32` to\n             * get one vector with the low 32 bits of each lane, and one vector\n             * with the high 32 bits of each lane.\n             *\n             * The intrinsic returns a double vector because the original ARMv7-a\n             * instruction modified both arguments in place. AArch64 and SIMD128 emit\n             * two instructions from this intrinsic.\n             *\n             *  [ dk11L | dk11H | dk12L | dk12H ] -> [ dk11L | dk12L | dk21L | dk22L ]\n             *  [ dk21L | dk21H | dk22L | dk22H ] -> [ dk11H | dk12H | dk21H | dk22H ]\n             */\n            uint32x4x2_t unzipped = vuzpq_u32(\n                vreinterpretq_u32_u64(data_key_1),\n                vreinterpretq_u32_u64(data_key_2)\n            );\n            /* data_key_lo = data_key & 0xFFFFFFFF */\n            uint32x4_t data_key_lo = unzipped.val[0];\n            /* data_key_hi = data_key >> 32 */\n            uint32x4_t data_key_hi = unzipped.val[1];\n            /*\n             * Then, we can split the vectors horizontally and multiply which, as for most\n             * widening intrinsics, have a variant that works on both high half vectors\n             * for free on AArch64. A similar instruction is available on SIMD128.\n             *\n             * sum = data_swap + (u64x2) data_key_lo * (u64x2) data_key_hi\n             */\n            uint64x2_t sum_1 = XXH_vmlal_low_u32(data_swap_1, data_key_lo, data_key_hi);\n            uint64x2_t sum_2 = XXH_vmlal_high_u32(data_swap_2, data_key_lo, data_key_hi);\n            /*\n             * Clang reorders\n             *    a += b * c;     // umlal   swap.2d, dkl.2s, dkh.2s\n             *    c += a;         // add     acc.2d, acc.2d, swap.2d\n             * to\n             *    c += a;         // add     acc.2d, acc.2d, swap.2d\n             *    c += b * c;     // umlal   acc.2d, dkl.2s, dkh.2s\n             *\n             * While it would make sense in theory since the addition is faster,\n             * for reasons likely related to umlal being limited to certain NEON\n             * pipelines, this is worse. A compiler guard fixes this.\n             */\n            XXH_COMPILER_GUARD_CLANG_NEON(sum_1);\n            XXH_COMPILER_GUARD_CLANG_NEON(sum_2);\n            /* xacc[i] = acc_vec + sum; */\n            xacc[i]   = vaddq_u64(xacc[i], sum_1);\n            xacc[i+1] = vaddq_u64(xacc[i+1], sum_2);\n        }\n        /* Operate on the remaining NEON lanes 2 at a time. */\n        for (; i < XXH3_NEON_LANES / 2; i++) {\n            /* data_vec = xinput[i]; */\n            uint64x2_t data_vec = XXH_vld1q_u64(xinput  + (i * 16));\n            /* key_vec  = xsecret[i];  */\n            uint64x2_t key_vec  = XXH_vld1q_u64(xsecret + (i * 16));\n            /* acc_vec_2 = swap(data_vec) */\n            uint64x2_t data_swap = vextq_u64(data_vec, data_vec, 1);\n            /* data_key = data_vec ^ key_vec; */\n            uint64x2_t data_key = veorq_u64(data_vec, key_vec);\n            /* For two lanes, just use VMOVN and VSHRN. */\n            /* data_key_lo = data_key & 0xFFFFFFFF; */\n            uint32x2_t data_key_lo = vmovn_u64(data_key);\n            /* data_key_hi = data_key >> 32; */\n            uint32x2_t data_key_hi = vshrn_n_u64(data_key, 32);\n            /* sum = data_swap + (u64x2) data_key_lo * (u64x2) data_key_hi; */\n            uint64x2_t sum = vmlal_u32(data_swap, data_key_lo, data_key_hi);\n            /* Same Clang workaround as before */\n            XXH_COMPILER_GUARD_CLANG_NEON(sum);\n            /* xacc[i] = acc_vec + sum; */\n            xacc[i] = vaddq_u64 (xacc[i], sum);\n        }\n    }\n}\nXXH_FORCE_INLINE XXH3_ACCUMULATE_TEMPLATE(neon)\n\nXXH_FORCE_INLINE void\nXXH3_scrambleAcc_neon(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)\n{\n    XXH_ASSERT((((size_t)acc) & 15) == 0);\n\n    {   xxh_aliasing_uint64x2_t* xacc       = (xxh_aliasing_uint64x2_t*) acc;\n        uint8_t const* xsecret = (uint8_t const*) secret;\n\n        size_t i;\n        /* WASM uses operator overloads and doesn't need these. */\n#ifndef __wasm_simd128__\n        /* { prime32_1, prime32_1 } */\n        uint32x2_t const kPrimeLo = vdup_n_u32(XXH_PRIME32_1);\n        /* { 0, prime32_1, 0, prime32_1 } */\n        uint32x4_t const kPrimeHi = vreinterpretq_u32_u64(vdupq_n_u64((xxh_u64)XXH_PRIME32_1 << 32));\n#endif\n\n        /* AArch64 uses both scalar and neon at the same time */\n        for (i = XXH3_NEON_LANES; i < XXH_ACC_NB; i++) {\n            XXH3_scalarScrambleRound(acc, secret, i);\n        }\n        for (i=0; i < XXH3_NEON_LANES / 2; i++) {\n            /* xacc[i] ^= (xacc[i] >> 47); */\n            uint64x2_t acc_vec  = xacc[i];\n            uint64x2_t shifted  = vshrq_n_u64(acc_vec, 47);\n            uint64x2_t data_vec = veorq_u64(acc_vec, shifted);\n\n            /* xacc[i] ^= xsecret[i]; */\n            uint64x2_t key_vec  = XXH_vld1q_u64(xsecret + (i * 16));\n            uint64x2_t data_key = veorq_u64(data_vec, key_vec);\n            /* xacc[i] *= XXH_PRIME32_1 */\n#ifdef __wasm_simd128__\n            /* SIMD128 has multiply by u64x2, use it instead of expanding and scalarizing */\n            xacc[i] = data_key * XXH_PRIME32_1;\n#else\n            /*\n             * Expanded version with portable NEON intrinsics\n             *\n             *    lo(x) * lo(y) + (hi(x) * lo(y) << 32)\n             *\n             * prod_hi = hi(data_key) * lo(prime) << 32\n             *\n             * Since we only need 32 bits of this multiply a trick can be used, reinterpreting the vector\n             * as a uint32x4_t and multiplying by { 0, prime, 0, prime } to cancel out the unwanted bits\n             * and avoid the shift.\n             */\n            uint32x4_t prod_hi = vmulq_u32 (vreinterpretq_u32_u64(data_key), kPrimeHi);\n            /* Extract low bits for vmlal_u32  */\n            uint32x2_t data_key_lo = vmovn_u64(data_key);\n            /* xacc[i] = prod_hi + lo(data_key) * XXH_PRIME32_1; */\n            xacc[i] = vmlal_u32(vreinterpretq_u64_u32(prod_hi), data_key_lo, kPrimeLo);\n#endif\n        }\n    }\n}\n#endif\n\n#if (XXH_VECTOR == XXH_VSX)\n\nXXH_FORCE_INLINE void\nXXH3_accumulate_512_vsx(  void* XXH_RESTRICT acc,\n                    const void* XXH_RESTRICT input,\n                    const void* XXH_RESTRICT secret)\n{\n    /* presumed aligned */\n    xxh_aliasing_u64x2* const xacc = (xxh_aliasing_u64x2*) acc;\n    xxh_u8 const* const xinput   = (xxh_u8 const*) input;   /* no alignment restriction */\n    xxh_u8 const* const xsecret  = (xxh_u8 const*) secret;    /* no alignment restriction */\n    xxh_u64x2 const v32 = { 32, 32 };\n    size_t i;\n    for (i = 0; i < XXH_STRIPE_LEN / sizeof(xxh_u64x2); i++) {\n        /* data_vec = xinput[i]; */\n        xxh_u64x2 const data_vec = XXH_vec_loadu(xinput + 16*i);\n        /* key_vec = xsecret[i]; */\n        xxh_u64x2 const key_vec  = XXH_vec_loadu(xsecret + 16*i);\n        xxh_u64x2 const data_key = data_vec ^ key_vec;\n        /* shuffled = (data_key << 32) | (data_key >> 32); */\n        xxh_u32x4 const shuffled = (xxh_u32x4)vec_rl(data_key, v32);\n        /* product = ((xxh_u64x2)data_key & 0xFFFFFFFF) * ((xxh_u64x2)shuffled & 0xFFFFFFFF); */\n        xxh_u64x2 const product  = XXH_vec_mulo((xxh_u32x4)data_key, shuffled);\n        /* acc_vec = xacc[i]; */\n        xxh_u64x2 acc_vec        = xacc[i];\n        acc_vec += product;\n\n        /* swap high and low halves */\n#ifdef __s390x__\n        acc_vec += vec_permi(data_vec, data_vec, 2);\n#else\n        acc_vec += vec_xxpermdi(data_vec, data_vec, 2);\n#endif\n        xacc[i] = acc_vec;\n    }\n}\nXXH_FORCE_INLINE XXH3_ACCUMULATE_TEMPLATE(vsx)\n\nXXH_FORCE_INLINE void\nXXH3_scrambleAcc_vsx(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)\n{\n    XXH_ASSERT((((size_t)acc) & 15) == 0);\n\n    {   xxh_aliasing_u64x2* const xacc = (xxh_aliasing_u64x2*) acc;\n        const xxh_u8* const xsecret = (const xxh_u8*) secret;\n        /* constants */\n        xxh_u64x2 const v32  = { 32, 32 };\n        xxh_u64x2 const v47 = { 47, 47 };\n        xxh_u32x4 const prime = { XXH_PRIME32_1, XXH_PRIME32_1, XXH_PRIME32_1, XXH_PRIME32_1 };\n        size_t i;\n        for (i = 0; i < XXH_STRIPE_LEN / sizeof(xxh_u64x2); i++) {\n            /* xacc[i] ^= (xacc[i] >> 47); */\n            xxh_u64x2 const acc_vec  = xacc[i];\n            xxh_u64x2 const data_vec = acc_vec ^ (acc_vec >> v47);\n\n            /* xacc[i] ^= xsecret[i]; */\n            xxh_u64x2 const key_vec  = XXH_vec_loadu(xsecret + 16*i);\n            xxh_u64x2 const data_key = data_vec ^ key_vec;\n\n            /* xacc[i] *= XXH_PRIME32_1 */\n            /* prod_lo = ((xxh_u64x2)data_key & 0xFFFFFFFF) * ((xxh_u64x2)prime & 0xFFFFFFFF);  */\n            xxh_u64x2 const prod_even  = XXH_vec_mule((xxh_u32x4)data_key, prime);\n            /* prod_hi = ((xxh_u64x2)data_key >> 32) * ((xxh_u64x2)prime >> 32);  */\n            xxh_u64x2 const prod_odd  = XXH_vec_mulo((xxh_u32x4)data_key, prime);\n            xacc[i] = prod_odd + (prod_even << v32);\n    }   }\n}\n\n#endif\n\n#if (XXH_VECTOR == XXH_SVE)\n\nXXH_FORCE_INLINE void\nXXH3_accumulate_512_sve( void* XXH_RESTRICT acc,\n                   const void* XXH_RESTRICT input,\n                   const void* XXH_RESTRICT secret)\n{\n    uint64_t *xacc = (uint64_t *)acc;\n    const uint64_t *xinput = (const uint64_t *)(const void *)input;\n    const uint64_t *xsecret = (const uint64_t *)(const void *)secret;\n    svuint64_t kSwap = sveor_n_u64_z(svptrue_b64(), svindex_u64(0, 1), 1);\n    uint64_t element_count = svcntd();\n    if (element_count >= 8) {\n        svbool_t mask = svptrue_pat_b64(SV_VL8);\n        svuint64_t vacc = svld1_u64(mask, xacc);\n        ACCRND(vacc, 0);\n        svst1_u64(mask, xacc, vacc);\n    } else if (element_count == 2) {   /* sve128 */\n        svbool_t mask = svptrue_pat_b64(SV_VL2);\n        svuint64_t acc0 = svld1_u64(mask, xacc + 0);\n        svuint64_t acc1 = svld1_u64(mask, xacc + 2);\n        svuint64_t acc2 = svld1_u64(mask, xacc + 4);\n        svuint64_t acc3 = svld1_u64(mask, xacc + 6);\n        ACCRND(acc0, 0);\n        ACCRND(acc1, 2);\n        ACCRND(acc2, 4);\n        ACCRND(acc3, 6);\n        svst1_u64(mask, xacc + 0, acc0);\n        svst1_u64(mask, xacc + 2, acc1);\n        svst1_u64(mask, xacc + 4, acc2);\n        svst1_u64(mask, xacc + 6, acc3);\n    } else {\n        svbool_t mask = svptrue_pat_b64(SV_VL4);\n        svuint64_t acc0 = svld1_u64(mask, xacc + 0);\n        svuint64_t acc1 = svld1_u64(mask, xacc + 4);\n        ACCRND(acc0, 0);\n        ACCRND(acc1, 4);\n        svst1_u64(mask, xacc + 0, acc0);\n        svst1_u64(mask, xacc + 4, acc1);\n    }\n}\n\nXXH_FORCE_INLINE void\nXXH3_accumulate_sve(xxh_u64* XXH_RESTRICT acc,\n               const xxh_u8* XXH_RESTRICT input,\n               const xxh_u8* XXH_RESTRICT secret,\n               size_t nbStripes)\n{\n    if (nbStripes != 0) {\n        uint64_t *xacc = (uint64_t *)acc;\n        const uint64_t *xinput = (const uint64_t *)(const void *)input;\n        const uint64_t *xsecret = (const uint64_t *)(const void *)secret;\n        svuint64_t kSwap = sveor_n_u64_z(svptrue_b64(), svindex_u64(0, 1), 1);\n        uint64_t element_count = svcntd();\n        if (element_count >= 8) {\n            svbool_t mask = svptrue_pat_b64(SV_VL8);\n            svuint64_t vacc = svld1_u64(mask, xacc + 0);\n            do {\n                /* svprfd(svbool_t, void *, enum svfprop); */\n                svprfd(mask, xinput + 128, SV_PLDL1STRM);\n                ACCRND(vacc, 0);\n                xinput += 8;\n                xsecret += 1;\n                nbStripes--;\n           } while (nbStripes != 0);\n\n           svst1_u64(mask, xacc + 0, vacc);\n        } else if (element_count == 2) { /* sve128 */\n            svbool_t mask = svptrue_pat_b64(SV_VL2);\n            svuint64_t acc0 = svld1_u64(mask, xacc + 0);\n            svuint64_t acc1 = svld1_u64(mask, xacc + 2);\n            svuint64_t acc2 = svld1_u64(mask, xacc + 4);\n            svuint64_t acc3 = svld1_u64(mask, xacc + 6);\n            do {\n                svprfd(mask, xinput + 128, SV_PLDL1STRM);\n                ACCRND(acc0, 0);\n                ACCRND(acc1, 2);\n                ACCRND(acc2, 4);\n                ACCRND(acc3, 6);\n                xinput += 8;\n                xsecret += 1;\n                nbStripes--;\n           } while (nbStripes != 0);\n\n           svst1_u64(mask, xacc + 0, acc0);\n           svst1_u64(mask, xacc + 2, acc1);\n           svst1_u64(mask, xacc + 4, acc2);\n           svst1_u64(mask, xacc + 6, acc3);\n        } else {\n            svbool_t mask = svptrue_pat_b64(SV_VL4);\n            svuint64_t acc0 = svld1_u64(mask, xacc + 0);\n            svuint64_t acc1 = svld1_u64(mask, xacc + 4);\n            do {\n                svprfd(mask, xinput + 128, SV_PLDL1STRM);\n                ACCRND(acc0, 0);\n                ACCRND(acc1, 4);\n                xinput += 8;\n                xsecret += 1;\n                nbStripes--;\n           } while (nbStripes != 0);\n\n           svst1_u64(mask, xacc + 0, acc0);\n           svst1_u64(mask, xacc + 4, acc1);\n       }\n    }\n}\n\n#endif\n\n/* scalar variants - universal */\n\n#if defined(__aarch64__) && (defined(__GNUC__) || defined(__clang__))\n/*\n * In XXH3_scalarRound(), GCC and Clang have a similar codegen issue, where they\n * emit an excess mask and a full 64-bit multiply-add (MADD X-form).\n *\n * While this might not seem like much, as AArch64 is a 64-bit architecture, only\n * big Cortex designs have a full 64-bit multiplier.\n *\n * On the little cores, the smaller 32-bit multiplier is used, and full 64-bit\n * multiplies expand to 2-3 multiplies in microcode. This has a major penalty\n * of up to 4 latency cycles and 2 stall cycles in the multiply pipeline.\n *\n * Thankfully, AArch64 still provides the 32-bit long multiply-add (UMADDL) which does\n * not have this penalty and does the mask automatically.\n */\nXXH_FORCE_INLINE xxh_u64\nXXH_mult32to64_add64(xxh_u64 lhs, xxh_u64 rhs, xxh_u64 acc)\n{\n    xxh_u64 ret;\n    /* note: %x = 64-bit register, %w = 32-bit register */\n    __asm__(\"umaddl %x0, %w1, %w2, %x3\" : \"=r\" (ret) : \"r\" (lhs), \"r\" (rhs), \"r\" (acc));\n    return ret;\n}\n#else\nXXH_FORCE_INLINE xxh_u64\nXXH_mult32to64_add64(xxh_u64 lhs, xxh_u64 rhs, xxh_u64 acc)\n{\n    return XXH_mult32to64((xxh_u32)lhs, (xxh_u32)rhs) + acc;\n}\n#endif\n\n/*!\n * @internal\n * @brief Scalar round for @ref XXH3_accumulate_512_scalar().\n *\n * This is extracted to its own function because the NEON path uses a combination\n * of NEON and scalar.\n */\nXXH_FORCE_INLINE void\nXXH3_scalarRound(void* XXH_RESTRICT acc,\n                 void const* XXH_RESTRICT input,\n                 void const* XXH_RESTRICT secret,\n                 size_t lane)\n{\n    xxh_u64* xacc = (xxh_u64*) acc;\n    xxh_u8 const* xinput  = (xxh_u8 const*) input;\n    xxh_u8 const* xsecret = (xxh_u8 const*) secret;\n    XXH_ASSERT(lane < XXH_ACC_NB);\n    XXH_ASSERT(((size_t)acc & (XXH_ACC_ALIGN-1)) == 0);\n    {\n        xxh_u64 const data_val = XXH_readLE64(xinput + lane * 8);\n        xxh_u64 const data_key = data_val ^ XXH_readLE64(xsecret + lane * 8);\n        xacc[lane ^ 1] += data_val; /* swap adjacent lanes */\n        xacc[lane] = XXH_mult32to64_add64(data_key /* & 0xFFFFFFFF */, data_key >> 32, xacc[lane]);\n    }\n}\n\n/*!\n * @internal\n * @brief Processes a 64 byte block of data using the scalar path.\n */\nXXH_FORCE_INLINE void\nXXH3_accumulate_512_scalar(void* XXH_RESTRICT acc,\n                     const void* XXH_RESTRICT input,\n                     const void* XXH_RESTRICT secret)\n{\n    size_t i;\n    /* ARM GCC refuses to unroll this loop, resulting in a 24% slowdown on ARMv6. */\n#if defined(__GNUC__) && !defined(__clang__) \\\n  && (defined(__arm__) || defined(__thumb2__)) \\\n  && defined(__ARM_FEATURE_UNALIGNED) /* no unaligned access just wastes bytes */ \\\n  && XXH_SIZE_OPT <= 0\n#  pragma GCC unroll 8\n#endif\n    for (i=0; i < XXH_ACC_NB; i++) {\n        XXH3_scalarRound(acc, input, secret, i);\n    }\n}\nXXH_FORCE_INLINE XXH3_ACCUMULATE_TEMPLATE(scalar)\n\n/*!\n * @internal\n * @brief Scalar scramble step for @ref XXH3_scrambleAcc_scalar().\n *\n * This is extracted to its own function because the NEON path uses a combination\n * of NEON and scalar.\n */\nXXH_FORCE_INLINE void\nXXH3_scalarScrambleRound(void* XXH_RESTRICT acc,\n                         void const* XXH_RESTRICT secret,\n                         size_t lane)\n{\n    xxh_u64* const xacc = (xxh_u64*) acc;   /* presumed aligned */\n    const xxh_u8* const xsecret = (const xxh_u8*) secret;   /* no alignment restriction */\n    XXH_ASSERT((((size_t)acc) & (XXH_ACC_ALIGN-1)) == 0);\n    XXH_ASSERT(lane < XXH_ACC_NB);\n    {\n        xxh_u64 const key64 = XXH_readLE64(xsecret + lane * 8);\n        xxh_u64 acc64 = xacc[lane];\n        acc64 = XXH_xorshift64(acc64, 47);\n        acc64 ^= key64;\n        acc64 *= XXH_PRIME32_1;\n        xacc[lane] = acc64;\n    }\n}\n\n/*!\n * @internal\n * @brief Scrambles the accumulators after a large chunk has been read\n */\nXXH_FORCE_INLINE void\nXXH3_scrambleAcc_scalar(void* XXH_RESTRICT acc, const void* XXH_RESTRICT secret)\n{\n    size_t i;\n    for (i=0; i < XXH_ACC_NB; i++) {\n        XXH3_scalarScrambleRound(acc, secret, i);\n    }\n}\n\nXXH_FORCE_INLINE void\nXXH3_initCustomSecret_scalar(void* XXH_RESTRICT customSecret, xxh_u64 seed64)\n{\n    /*\n     * We need a separate pointer for the hack below,\n     * which requires a non-const pointer.\n     * Any decent compiler will optimize this out otherwise.\n     */\n    const xxh_u8* kSecretPtr = XXH3_kSecret;\n    XXH_STATIC_ASSERT((XXH_SECRET_DEFAULT_SIZE & 15) == 0);\n\n#if defined(__GNUC__) && defined(__aarch64__)\n    /*\n     * UGLY HACK:\n     * GCC and Clang generate a bunch of MOV/MOVK pairs for aarch64, and they are\n     * placed sequentially, in order, at the top of the unrolled loop.\n     *\n     * While MOVK is great for generating constants (2 cycles for a 64-bit\n     * constant compared to 4 cycles for LDR), it fights for bandwidth with\n     * the arithmetic instructions.\n     *\n     *   I   L   S\n     * MOVK\n     * MOVK\n     * MOVK\n     * MOVK\n     * ADD\n     * SUB      STR\n     *          STR\n     * By forcing loads from memory (as the asm line causes the compiler to assume\n     * that XXH3_kSecretPtr has been changed), the pipelines are used more\n     * efficiently:\n     *   I   L   S\n     *      LDR\n     *  ADD LDR\n     *  SUB     STR\n     *          STR\n     *\n     * See XXH3_NEON_LANES for details on the pipsline.\n     *\n     * XXH3_64bits_withSeed, len == 256, Snapdragon 835\n     *   without hack: 2654.4 MB/s\n     *   with hack:    3202.9 MB/s\n     */\n    XXH_COMPILER_GUARD(kSecretPtr);\n#endif\n    {   int const nbRounds = XXH_SECRET_DEFAULT_SIZE / 16;\n        int i;\n        for (i=0; i < nbRounds; i++) {\n            /*\n             * The asm hack causes the compiler to assume that kSecretPtr aliases with\n             * customSecret, and on aarch64, this prevented LDP from merging two\n             * loads together for free. Putting the loads together before the stores\n             * properly generates LDP.\n             */\n            xxh_u64 lo = XXH_readLE64(kSecretPtr + 16*i)     + seed64;\n            xxh_u64 hi = XXH_readLE64(kSecretPtr + 16*i + 8) - seed64;\n            XXH_writeLE64((xxh_u8*)customSecret + 16*i,     lo);\n            XXH_writeLE64((xxh_u8*)customSecret + 16*i + 8, hi);\n    }   }\n}\n\n\ntypedef void (*XXH3_f_accumulate)(xxh_u64* XXH_RESTRICT, const xxh_u8* XXH_RESTRICT, const xxh_u8* XXH_RESTRICT, size_t);\ntypedef void (*XXH3_f_scrambleAcc)(void* XXH_RESTRICT, const void*);\ntypedef void (*XXH3_f_initCustomSecret)(void* XXH_RESTRICT, xxh_u64);\n\n\n#if (XXH_VECTOR == XXH_AVX512)\n\n#define XXH3_accumulate_512 XXH3_accumulate_512_avx512\n#define XXH3_accumulate     XXH3_accumulate_avx512\n#define XXH3_scrambleAcc    XXH3_scrambleAcc_avx512\n#define XXH3_initCustomSecret XXH3_initCustomSecret_avx512\n\n#elif (XXH_VECTOR == XXH_AVX2)\n\n#define XXH3_accumulate_512 XXH3_accumulate_512_avx2\n#define XXH3_accumulate     XXH3_accumulate_avx2\n#define XXH3_scrambleAcc    XXH3_scrambleAcc_avx2\n#define XXH3_initCustomSecret XXH3_initCustomSecret_avx2\n\n#elif (XXH_VECTOR == XXH_SSE2)\n\n#define XXH3_accumulate_512 XXH3_accumulate_512_sse2\n#define XXH3_accumulate     XXH3_accumulate_sse2\n#define XXH3_scrambleAcc    XXH3_scrambleAcc_sse2\n#define XXH3_initCustomSecret XXH3_initCustomSecret_sse2\n\n#elif (XXH_VECTOR == XXH_NEON)\n\n#define XXH3_accumulate_512 XXH3_accumulate_512_neon\n#define XXH3_accumulate     XXH3_accumulate_neon\n#define XXH3_scrambleAcc    XXH3_scrambleAcc_neon\n#define XXH3_initCustomSecret XXH3_initCustomSecret_scalar\n\n#elif (XXH_VECTOR == XXH_VSX)\n\n#define XXH3_accumulate_512 XXH3_accumulate_512_vsx\n#define XXH3_accumulate     XXH3_accumulate_vsx\n#define XXH3_scrambleAcc    XXH3_scrambleAcc_vsx\n#define XXH3_initCustomSecret XXH3_initCustomSecret_scalar\n\n#elif (XXH_VECTOR == XXH_SVE)\n#define XXH3_accumulate_512 XXH3_accumulate_512_sve\n#define XXH3_accumulate     XXH3_accumulate_sve\n#define XXH3_scrambleAcc    XXH3_scrambleAcc_scalar\n#define XXH3_initCustomSecret XXH3_initCustomSecret_scalar\n\n#else /* scalar */\n\n#define XXH3_accumulate_512 XXH3_accumulate_512_scalar\n#define XXH3_accumulate     XXH3_accumulate_scalar\n#define XXH3_scrambleAcc    XXH3_scrambleAcc_scalar\n#define XXH3_initCustomSecret XXH3_initCustomSecret_scalar\n\n#endif\n\n#if XXH_SIZE_OPT >= 1 /* don't do SIMD for initialization */\n#  undef XXH3_initCustomSecret\n#  define XXH3_initCustomSecret XXH3_initCustomSecret_scalar\n#endif\n\nXXH_FORCE_INLINE void\nXXH3_hashLong_internal_loop(xxh_u64* XXH_RESTRICT acc,\n                      const xxh_u8* XXH_RESTRICT input, size_t len,\n                      const xxh_u8* XXH_RESTRICT secret, size_t secretSize,\n                            XXH3_f_accumulate f_acc,\n                            XXH3_f_scrambleAcc f_scramble)\n{\n    size_t const nbStripesPerBlock = (secretSize - XXH_STRIPE_LEN) / XXH_SECRET_CONSUME_RATE;\n    size_t const block_len = XXH_STRIPE_LEN * nbStripesPerBlock;\n    size_t const nb_blocks = (len - 1) / block_len;\n\n    size_t n;\n\n    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);\n\n    for (n = 0; n < nb_blocks; n++) {\n        f_acc(acc, input + n*block_len, secret, nbStripesPerBlock);\n        f_scramble(acc, secret + secretSize - XXH_STRIPE_LEN);\n    }\n\n    /* last partial block */\n    XXH_ASSERT(len > XXH_STRIPE_LEN);\n    {   size_t const nbStripes = ((len - 1) - (block_len * nb_blocks)) / XXH_STRIPE_LEN;\n        XXH_ASSERT(nbStripes <= (secretSize / XXH_SECRET_CONSUME_RATE));\n        f_acc(acc, input + nb_blocks*block_len, secret, nbStripes);\n\n        /* last stripe */\n        {   const xxh_u8* const p = input + len - XXH_STRIPE_LEN;\n#define XXH_SECRET_LASTACC_START 7  /* not aligned on 8, last secret is different from acc & scrambler */\n            XXH3_accumulate_512(acc, p, secret + secretSize - XXH_STRIPE_LEN - XXH_SECRET_LASTACC_START);\n    }   }\n}\n\nXXH_FORCE_INLINE xxh_u64\nXXH3_mix2Accs(const xxh_u64* XXH_RESTRICT acc, const xxh_u8* XXH_RESTRICT secret)\n{\n    return XXH3_mul128_fold64(\n               acc[0] ^ XXH_readLE64(secret),\n               acc[1] ^ XXH_readLE64(secret+8) );\n}\n\nstatic XXH64_hash_t\nXXH3_mergeAccs(const xxh_u64* XXH_RESTRICT acc, const xxh_u8* XXH_RESTRICT secret, xxh_u64 start)\n{\n    xxh_u64 result64 = start;\n    size_t i = 0;\n\n    for (i = 0; i < 4; i++) {\n        result64 += XXH3_mix2Accs(acc+2*i, secret + 16*i);\n#if defined(__clang__)                                /* Clang */ \\\n    && (defined(__arm__) || defined(__thumb__))       /* ARMv7 */ \\\n    && (defined(__ARM_NEON) || defined(__ARM_NEON__)) /* NEON */  \\\n    && !defined(XXH_ENABLE_AUTOVECTORIZE)             /* Define to disable */\n        /*\n         * UGLY HACK:\n         * Prevent autovectorization on Clang ARMv7-a. Exact same problem as\n         * the one in XXH3_len_129to240_64b. Speeds up shorter keys > 240b.\n         * XXH3_64bits, len == 256, Snapdragon 835:\n         *   without hack: 2063.7 MB/s\n         *   with hack:    2560.7 MB/s\n         */\n        XXH_COMPILER_GUARD(result64);\n#endif\n    }\n\n    return XXH3_avalanche(result64);\n}\n\n#define XXH3_INIT_ACC { XXH_PRIME32_3, XXH_PRIME64_1, XXH_PRIME64_2, XXH_PRIME64_3, \\\n                        XXH_PRIME64_4, XXH_PRIME32_2, XXH_PRIME64_5, XXH_PRIME32_1 }\n\nXXH_FORCE_INLINE XXH64_hash_t\nXXH3_hashLong_64b_internal(const void* XXH_RESTRICT input, size_t len,\n                           const void* XXH_RESTRICT secret, size_t secretSize,\n                           XXH3_f_accumulate f_acc,\n                           XXH3_f_scrambleAcc f_scramble)\n{\n    XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[XXH_ACC_NB] = XXH3_INIT_ACC;\n\n    XXH3_hashLong_internal_loop(acc, (const xxh_u8*)input, len, (const xxh_u8*)secret, secretSize, f_acc, f_scramble);\n\n    /* converge into final hash */\n    XXH_STATIC_ASSERT(sizeof(acc) == 64);\n    /* do not align on 8, so that the secret is different from the accumulator */\n#define XXH_SECRET_MERGEACCS_START 11\n    XXH_ASSERT(secretSize >= sizeof(acc) + XXH_SECRET_MERGEACCS_START);\n    return XXH3_mergeAccs(acc, (const xxh_u8*)secret + XXH_SECRET_MERGEACCS_START, (xxh_u64)len * XXH_PRIME64_1);\n}\n\n/*\n * It's important for performance to transmit secret's size (when it's static)\n * so that the compiler can properly optimize the vectorized loop.\n * This makes a big performance difference for \"medium\" keys (<1 KB) when using AVX instruction set.\n * When the secret size is unknown, or on GCC 12 where the mix of NO_INLINE and FORCE_INLINE\n * breaks -Og, this is XXH_NO_INLINE.\n */\nXXH3_WITH_SECRET_INLINE XXH64_hash_t\nXXH3_hashLong_64b_withSecret(const void* XXH_RESTRICT input, size_t len,\n                             XXH64_hash_t seed64, const xxh_u8* XXH_RESTRICT secret, size_t secretLen)\n{\n    (void)seed64;\n    return XXH3_hashLong_64b_internal(input, len, secret, secretLen, XXH3_accumulate, XXH3_scrambleAcc);\n}\n\n/*\n * It's preferable for performance that XXH3_hashLong is not inlined,\n * as it results in a smaller function for small data, easier to the instruction cache.\n * Note that inside this no_inline function, we do inline the internal loop,\n * and provide a statically defined secret size to allow optimization of vector loop.\n */\nXXH_NO_INLINE XXH_PUREF XXH64_hash_t\nXXH3_hashLong_64b_default(const void* XXH_RESTRICT input, size_t len,\n                          XXH64_hash_t seed64, const xxh_u8* XXH_RESTRICT secret, size_t secretLen)\n{\n    (void)seed64; (void)secret; (void)secretLen;\n    return XXH3_hashLong_64b_internal(input, len, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_accumulate, XXH3_scrambleAcc);\n}\n\n/*\n * XXH3_hashLong_64b_withSeed():\n * Generate a custom key based on alteration of default XXH3_kSecret with the seed,\n * and then use this key for long mode hashing.\n *\n * This operation is decently fast but nonetheless costs a little bit of time.\n * Try to avoid it whenever possible (typically when seed==0).\n *\n * It's important for performance that XXH3_hashLong is not inlined. Not sure\n * why (uop cache maybe?), but the difference is large and easily measurable.\n */\nXXH_FORCE_INLINE XXH64_hash_t\nXXH3_hashLong_64b_withSeed_internal(const void* input, size_t len,\n                                    XXH64_hash_t seed,\n                                    XXH3_f_accumulate f_acc,\n                                    XXH3_f_scrambleAcc f_scramble,\n                                    XXH3_f_initCustomSecret f_initSec)\n{\n#if XXH_SIZE_OPT <= 0\n    if (seed == 0)\n        return XXH3_hashLong_64b_internal(input, len,\n                                          XXH3_kSecret, sizeof(XXH3_kSecret),\n                                          f_acc, f_scramble);\n#endif\n    {   XXH_ALIGN(XXH_SEC_ALIGN) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE];\n        f_initSec(secret, seed);\n        return XXH3_hashLong_64b_internal(input, len, secret, sizeof(secret),\n                                          f_acc, f_scramble);\n    }\n}\n\n/*\n * It's important for performance that XXH3_hashLong is not inlined.\n */\nXXH_NO_INLINE XXH64_hash_t\nXXH3_hashLong_64b_withSeed(const void* XXH_RESTRICT input, size_t len,\n                           XXH64_hash_t seed, const xxh_u8* XXH_RESTRICT secret, size_t secretLen)\n{\n    (void)secret; (void)secretLen;\n    return XXH3_hashLong_64b_withSeed_internal(input, len, seed,\n                XXH3_accumulate, XXH3_scrambleAcc, XXH3_initCustomSecret);\n}\n\n\ntypedef XXH64_hash_t (*XXH3_hashLong64_f)(const void* XXH_RESTRICT, size_t,\n                                          XXH64_hash_t, const xxh_u8* XXH_RESTRICT, size_t);\n\nXXH_FORCE_INLINE XXH64_hash_t\nXXH3_64bits_internal(const void* XXH_RESTRICT input, size_t len,\n                     XXH64_hash_t seed64, const void* XXH_RESTRICT secret, size_t secretLen,\n                     XXH3_hashLong64_f f_hashLong)\n{\n    XXH_ASSERT(secretLen >= XXH3_SECRET_SIZE_MIN);\n    /*\n     * If an action is to be taken if `secretLen` condition is not respected,\n     * it should be done here.\n     * For now, it's a contract pre-condition.\n     * Adding a check and a branch here would cost performance at every hash.\n     * Also, note that function signature doesn't offer room to return an error.\n     */\n    if (len <= 16)\n        return XXH3_len_0to16_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, seed64);\n    if (len <= 128)\n        return XXH3_len_17to128_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64);\n    if (len <= XXH3_MIDSIZE_MAX)\n        return XXH3_len_129to240_64b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64);\n    return f_hashLong(input, len, seed64, (const xxh_u8*)secret, secretLen);\n}\n\n\n/* ===   Public entry point   === */\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH64_hash_t XXH3_64bits(XXH_NOESCAPE const void* input, size_t length)\n{\n    return XXH3_64bits_internal(input, length, 0, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_64b_default);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH64_hash_t\nXXH3_64bits_withSecret(XXH_NOESCAPE const void* input, size_t length, XXH_NOESCAPE const void* secret, size_t secretSize)\n{\n    return XXH3_64bits_internal(input, length, 0, secret, secretSize, XXH3_hashLong_64b_withSecret);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH64_hash_t\nXXH3_64bits_withSeed(XXH_NOESCAPE const void* input, size_t length, XXH64_hash_t seed)\n{\n    return XXH3_64bits_internal(input, length, seed, XXH3_kSecret, sizeof(XXH3_kSecret), XXH3_hashLong_64b_withSeed);\n}\n\nXXH_PUBLIC_API XXH64_hash_t\nXXH3_64bits_withSecretandSeed(XXH_NOESCAPE const void* input, size_t length, XXH_NOESCAPE const void* secret, size_t secretSize, XXH64_hash_t seed)\n{\n    if (length <= XXH3_MIDSIZE_MAX)\n        return XXH3_64bits_internal(input, length, seed, XXH3_kSecret, sizeof(XXH3_kSecret), NULL);\n    return XXH3_hashLong_64b_withSecret(input, length, seed, (const xxh_u8*)secret, secretSize);\n}\n\n\n/* ===   XXH3 streaming   === */\n#ifndef XXH_NO_STREAM\n/*\n * Malloc's a pointer that is always aligned to align.\n *\n * This must be freed with `XXH_alignedFree()`.\n *\n * malloc typically guarantees 16 byte alignment on 64-bit systems and 8 byte\n * alignment on 32-bit. This isn't enough for the 32 byte aligned loads in AVX2\n * or on 32-bit, the 16 byte aligned loads in SSE2 and NEON.\n *\n * This underalignment previously caused a rather obvious crash which went\n * completely unnoticed due to XXH3_createState() not actually being tested.\n * Credit to RedSpah for noticing this bug.\n *\n * The alignment is done manually: Functions like posix_memalign or _mm_malloc\n * are avoided: To maintain portability, we would have to write a fallback\n * like this anyways, and besides, testing for the existence of library\n * functions without relying on external build tools is impossible.\n *\n * The method is simple: Overallocate, manually align, and store the offset\n * to the original behind the returned pointer.\n *\n * Align must be a power of 2 and 8 <= align <= 128.\n */\nstatic XXH_MALLOCF void* XXH_alignedMalloc(size_t s, size_t align)\n{\n    XXH_ASSERT(align <= 128 && align >= 8); /* range check */\n    XXH_ASSERT((align & (align-1)) == 0);   /* power of 2 */\n    XXH_ASSERT(s != 0 && s < (s + align));  /* empty/overflow */\n    {   /* Overallocate to make room for manual realignment and an offset byte */\n        xxh_u8* base = (xxh_u8*)XXH_malloc(s + align);\n        if (base != NULL) {\n            /*\n             * Get the offset needed to align this pointer.\n             *\n             * Even if the returned pointer is aligned, there will always be\n             * at least one byte to store the offset to the original pointer.\n             */\n            size_t offset = align - ((size_t)base & (align - 1)); /* base % align */\n            /* Add the offset for the now-aligned pointer */\n            xxh_u8* ptr = base + offset;\n\n            XXH_ASSERT((size_t)ptr % align == 0);\n\n            /* Store the offset immediately before the returned pointer. */\n            ptr[-1] = (xxh_u8)offset;\n            return ptr;\n        }\n        return NULL;\n    }\n}\n/*\n * Frees an aligned pointer allocated by XXH_alignedMalloc(). Don't pass\n * normal malloc'd pointers, XXH_alignedMalloc has a specific data layout.\n */\nstatic void XXH_alignedFree(void* p)\n{\n    if (p != NULL) {\n        xxh_u8* ptr = (xxh_u8*)p;\n        /* Get the offset byte we added in XXH_malloc. */\n        xxh_u8 offset = ptr[-1];\n        /* Free the original malloc'd pointer */\n        xxh_u8* base = ptr - offset;\n        XXH_free(base);\n    }\n}\n/*! @ingroup XXH3_family */\n/*!\n * @brief Allocate an @ref XXH3_state_t.\n *\n * @return An allocated pointer of @ref XXH3_state_t on success.\n * @return `NULL` on failure.\n *\n * @note Must be freed with XXH3_freeState().\n */\nXXH_PUBLIC_API XXH3_state_t* XXH3_createState(void)\n{\n    XXH3_state_t* const state = (XXH3_state_t*)XXH_alignedMalloc(sizeof(XXH3_state_t), 64);\n    if (state==NULL) return NULL;\n    XXH3_INITSTATE(state);\n    return state;\n}\n\n/*! @ingroup XXH3_family */\n/*!\n * @brief Frees an @ref XXH3_state_t.\n *\n * @param statePtr A pointer to an @ref XXH3_state_t allocated with @ref XXH3_createState().\n *\n * @return @ref XXH_OK.\n *\n * @note Must be allocated with XXH3_createState().\n */\nXXH_PUBLIC_API XXH_errorcode XXH3_freeState(XXH3_state_t* statePtr)\n{\n    XXH_alignedFree(statePtr);\n    return XXH_OK;\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API void\nXXH3_copyState(XXH_NOESCAPE XXH3_state_t* dst_state, XXH_NOESCAPE const XXH3_state_t* src_state)\n{\n    XXH_memcpy(dst_state, src_state, sizeof(*dst_state));\n}\n\nstatic void\nXXH3_reset_internal(XXH3_state_t* statePtr,\n                    XXH64_hash_t seed,\n                    const void* secret, size_t secretSize)\n{\n    size_t const initStart = offsetof(XXH3_state_t, bufferedSize);\n    size_t const initLength = offsetof(XXH3_state_t, nbStripesPerBlock) - initStart;\n    XXH_ASSERT(offsetof(XXH3_state_t, nbStripesPerBlock) > initStart);\n    XXH_ASSERT(statePtr != NULL);\n    /* set members from bufferedSize to nbStripesPerBlock (excluded) to 0 */\n    memset((char*)statePtr + initStart, 0, initLength);\n    statePtr->acc[0] = XXH_PRIME32_3;\n    statePtr->acc[1] = XXH_PRIME64_1;\n    statePtr->acc[2] = XXH_PRIME64_2;\n    statePtr->acc[3] = XXH_PRIME64_3;\n    statePtr->acc[4] = XXH_PRIME64_4;\n    statePtr->acc[5] = XXH_PRIME32_2;\n    statePtr->acc[6] = XXH_PRIME64_5;\n    statePtr->acc[7] = XXH_PRIME32_1;\n    statePtr->seed = seed;\n    statePtr->useSeed = (seed != 0);\n    statePtr->extSecret = (const unsigned char*)secret;\n    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);\n    statePtr->secretLimit = secretSize - XXH_STRIPE_LEN;\n    statePtr->nbStripesPerBlock = statePtr->secretLimit / XXH_SECRET_CONSUME_RATE;\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_64bits_reset(XXH_NOESCAPE XXH3_state_t* statePtr)\n{\n    if (statePtr == NULL) return XXH_ERROR;\n    XXH3_reset_internal(statePtr, 0, XXH3_kSecret, XXH_SECRET_DEFAULT_SIZE);\n    return XXH_OK;\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_64bits_reset_withSecret(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize)\n{\n    if (statePtr == NULL) return XXH_ERROR;\n    XXH3_reset_internal(statePtr, 0, secret, secretSize);\n    if (secret == NULL) return XXH_ERROR;\n    if (secretSize < XXH3_SECRET_SIZE_MIN) return XXH_ERROR;\n    return XXH_OK;\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_64bits_reset_withSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH64_hash_t seed)\n{\n    if (statePtr == NULL) return XXH_ERROR;\n    if (seed==0) return XXH3_64bits_reset(statePtr);\n    if ((seed != statePtr->seed) || (statePtr->extSecret != NULL))\n        XXH3_initCustomSecret(statePtr->customSecret, seed);\n    XXH3_reset_internal(statePtr, seed, NULL, XXH_SECRET_DEFAULT_SIZE);\n    return XXH_OK;\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_64bits_reset_withSecretandSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize, XXH64_hash_t seed64)\n{\n    if (statePtr == NULL) return XXH_ERROR;\n    if (secret == NULL) return XXH_ERROR;\n    if (secretSize < XXH3_SECRET_SIZE_MIN) return XXH_ERROR;\n    XXH3_reset_internal(statePtr, seed64, secret, secretSize);\n    statePtr->useSeed = 1; /* always, even if seed64==0 */\n    return XXH_OK;\n}\n\n/*!\n * @internal\n * @brief Processes a large input for XXH3_update() and XXH3_digest_long().\n *\n * Unlike XXH3_hashLong_internal_loop(), this can process data that overlaps a block.\n *\n * @param acc                Pointer to the 8 accumulator lanes\n * @param nbStripesSoFarPtr  In/out pointer to the number of leftover stripes in the block*\n * @param nbStripesPerBlock  Number of stripes in a block\n * @param input              Input pointer\n * @param nbStripes          Number of stripes to process\n * @param secret             Secret pointer\n * @param secretLimit        Offset of the last block in @p secret\n * @param f_acc              Pointer to an XXH3_accumulate implementation\n * @param f_scramble         Pointer to an XXH3_scrambleAcc implementation\n * @return                   Pointer past the end of @p input after processing\n */\nXXH_FORCE_INLINE const xxh_u8 *\nXXH3_consumeStripes(xxh_u64* XXH_RESTRICT acc,\n                    size_t* XXH_RESTRICT nbStripesSoFarPtr, size_t nbStripesPerBlock,\n                    const xxh_u8* XXH_RESTRICT input, size_t nbStripes,\n                    const xxh_u8* XXH_RESTRICT secret, size_t secretLimit,\n                    XXH3_f_accumulate f_acc,\n                    XXH3_f_scrambleAcc f_scramble)\n{\n    const xxh_u8* initialSecret = secret + *nbStripesSoFarPtr * XXH_SECRET_CONSUME_RATE;\n    /* Process full blocks */\n    if (nbStripes >= (nbStripesPerBlock - *nbStripesSoFarPtr)) {\n        /* Process the initial partial block... */\n        size_t nbStripesThisIter = nbStripesPerBlock - *nbStripesSoFarPtr;\n\n        do {\n            /* Accumulate and scramble */\n            f_acc(acc, input, initialSecret, nbStripesThisIter);\n            f_scramble(acc, secret + secretLimit);\n            input += nbStripesThisIter * XXH_STRIPE_LEN;\n            nbStripes -= nbStripesThisIter;\n            /* Then continue the loop with the full block size */\n            nbStripesThisIter = nbStripesPerBlock;\n            initialSecret = secret;\n        } while (nbStripes >= nbStripesPerBlock);\n        *nbStripesSoFarPtr = 0;\n    }\n    /* Process a partial block */\n    if (nbStripes > 0) {\n        f_acc(acc, input, initialSecret, nbStripes);\n        input += nbStripes * XXH_STRIPE_LEN;\n        *nbStripesSoFarPtr += nbStripes;\n    }\n    /* Return end pointer */\n    return input;\n}\n\n#ifndef XXH3_STREAM_USE_STACK\n# if XXH_SIZE_OPT <= 0 && !defined(__clang__) /* clang doesn't need additional stack space */\n#   define XXH3_STREAM_USE_STACK 1\n# endif\n#endif\n/*\n * Both XXH3_64bits_update and XXH3_128bits_update use this routine.\n */\nXXH_FORCE_INLINE XXH_errorcode\nXXH3_update(XXH3_state_t* XXH_RESTRICT const state,\n            const xxh_u8* XXH_RESTRICT input, size_t len,\n            XXH3_f_accumulate f_acc,\n            XXH3_f_scrambleAcc f_scramble)\n{\n    if (input==NULL) {\n        XXH_ASSERT(len == 0);\n        return XXH_OK;\n    }\n\n    XXH_ASSERT(state != NULL);\n    {   const xxh_u8* const bEnd = input + len;\n        const unsigned char* const secret = (state->extSecret == NULL) ? state->customSecret : state->extSecret;\n#if defined(XXH3_STREAM_USE_STACK) && XXH3_STREAM_USE_STACK >= 1\n        /* For some reason, gcc and MSVC seem to suffer greatly\n         * when operating accumulators directly into state.\n         * Operating into stack space seems to enable proper optimization.\n         * clang, on the other hand, doesn't seem to need this trick */\n        XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[8];\n        XXH_memcpy(acc, state->acc, sizeof(acc));\n#else\n        xxh_u64* XXH_RESTRICT const acc = state->acc;\n#endif\n        state->totalLen += len;\n        XXH_ASSERT(state->bufferedSize <= XXH3_INTERNALBUFFER_SIZE);\n\n        /* small input : just fill in tmp buffer */\n        if (len <= XXH3_INTERNALBUFFER_SIZE - state->bufferedSize) {\n            XXH_memcpy(state->buffer + state->bufferedSize, input, len);\n            state->bufferedSize += (XXH32_hash_t)len;\n            return XXH_OK;\n        }\n\n        /* total input is now > XXH3_INTERNALBUFFER_SIZE */\n        #define XXH3_INTERNALBUFFER_STRIPES (XXH3_INTERNALBUFFER_SIZE / XXH_STRIPE_LEN)\n        XXH_STATIC_ASSERT(XXH3_INTERNALBUFFER_SIZE % XXH_STRIPE_LEN == 0);   /* clean multiple */\n\n        /*\n         * Internal buffer is partially filled (always, except at beginning)\n         * Complete it, then consume it.\n         */\n        if (state->bufferedSize) {\n            size_t const loadSize = XXH3_INTERNALBUFFER_SIZE - state->bufferedSize;\n            XXH_memcpy(state->buffer + state->bufferedSize, input, loadSize);\n            input += loadSize;\n            XXH3_consumeStripes(acc,\n                               &state->nbStripesSoFar, state->nbStripesPerBlock,\n                                state->buffer, XXH3_INTERNALBUFFER_STRIPES,\n                                secret, state->secretLimit,\n                                f_acc, f_scramble);\n            state->bufferedSize = 0;\n        }\n        XXH_ASSERT(input < bEnd);\n        if (bEnd - input > XXH3_INTERNALBUFFER_SIZE) {\n            size_t nbStripes = (size_t)(bEnd - 1 - input) / XXH_STRIPE_LEN;\n            input = XXH3_consumeStripes(acc,\n                                       &state->nbStripesSoFar, state->nbStripesPerBlock,\n                                       input, nbStripes,\n                                       secret, state->secretLimit,\n                                       f_acc, f_scramble);\n            XXH_memcpy(state->buffer + sizeof(state->buffer) - XXH_STRIPE_LEN, input - XXH_STRIPE_LEN, XXH_STRIPE_LEN);\n\n        }\n        /* Some remaining input (always) : buffer it */\n        XXH_ASSERT(input < bEnd);\n        XXH_ASSERT(bEnd - input <= XXH3_INTERNALBUFFER_SIZE);\n        XXH_ASSERT(state->bufferedSize == 0);\n        XXH_memcpy(state->buffer, input, (size_t)(bEnd-input));\n        state->bufferedSize = (XXH32_hash_t)(bEnd-input);\n#if defined(XXH3_STREAM_USE_STACK) && XXH3_STREAM_USE_STACK >= 1\n        /* save stack accumulators into state */\n        XXH_memcpy(state->acc, acc, sizeof(acc));\n#endif\n    }\n\n    return XXH_OK;\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_64bits_update(XXH_NOESCAPE XXH3_state_t* state, XXH_NOESCAPE const void* input, size_t len)\n{\n    return XXH3_update(state, (const xxh_u8*)input, len,\n                       XXH3_accumulate, XXH3_scrambleAcc);\n}\n\n\nXXH_FORCE_INLINE void\nXXH3_digest_long (XXH64_hash_t* acc,\n                  const XXH3_state_t* state,\n                  const unsigned char* secret)\n{\n    xxh_u8 lastStripe[XXH_STRIPE_LEN];\n    const xxh_u8* lastStripePtr;\n\n    /*\n     * Digest on a local copy. This way, the state remains unaltered, and it can\n     * continue ingesting more input afterwards.\n     */\n    XXH_memcpy(acc, state->acc, sizeof(state->acc));\n    if (state->bufferedSize >= XXH_STRIPE_LEN) {\n        /* Consume remaining stripes then point to remaining data in buffer */\n        size_t const nbStripes = (state->bufferedSize - 1) / XXH_STRIPE_LEN;\n        size_t nbStripesSoFar = state->nbStripesSoFar;\n        XXH3_consumeStripes(acc,\n                           &nbStripesSoFar, state->nbStripesPerBlock,\n                            state->buffer, nbStripes,\n                            secret, state->secretLimit,\n                            XXH3_accumulate, XXH3_scrambleAcc);\n        lastStripePtr = state->buffer + state->bufferedSize - XXH_STRIPE_LEN;\n    } else {  /* bufferedSize < XXH_STRIPE_LEN */\n        /* Copy to temp buffer */\n        size_t const catchupSize = XXH_STRIPE_LEN - state->bufferedSize;\n        XXH_ASSERT(state->bufferedSize > 0);  /* there is always some input buffered */\n        XXH_memcpy(lastStripe, state->buffer + sizeof(state->buffer) - catchupSize, catchupSize);\n        XXH_memcpy(lastStripe + catchupSize, state->buffer, state->bufferedSize);\n        lastStripePtr = lastStripe;\n    }\n    /* Last stripe */\n    XXH3_accumulate_512(acc,\n                        lastStripePtr,\n                        secret + state->secretLimit - XXH_SECRET_LASTACC_START);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH64_hash_t XXH3_64bits_digest (XXH_NOESCAPE const XXH3_state_t* state)\n{\n    const unsigned char* const secret = (state->extSecret == NULL) ? state->customSecret : state->extSecret;\n    if (state->totalLen > XXH3_MIDSIZE_MAX) {\n        XXH_ALIGN(XXH_ACC_ALIGN) XXH64_hash_t acc[XXH_ACC_NB];\n        XXH3_digest_long(acc, state, secret);\n        return XXH3_mergeAccs(acc,\n                              secret + XXH_SECRET_MERGEACCS_START,\n                              (xxh_u64)state->totalLen * XXH_PRIME64_1);\n    }\n    /* totalLen <= XXH3_MIDSIZE_MAX: digesting a short input */\n    if (state->useSeed)\n        return XXH3_64bits_withSeed(state->buffer, (size_t)state->totalLen, state->seed);\n    return XXH3_64bits_withSecret(state->buffer, (size_t)(state->totalLen),\n                                  secret, state->secretLimit + XXH_STRIPE_LEN);\n}\n#endif /* !XXH_NO_STREAM */\n\n\n/* ==========================================\n * XXH3 128 bits (a.k.a XXH128)\n * ==========================================\n * XXH3's 128-bit variant has better mixing and strength than the 64-bit variant,\n * even without counting the significantly larger output size.\n *\n * For example, extra steps are taken to avoid the seed-dependent collisions\n * in 17-240 byte inputs (See XXH3_mix16B and XXH128_mix32B).\n *\n * This strength naturally comes at the cost of some speed, especially on short\n * lengths. Note that longer hashes are about as fast as the 64-bit version\n * due to it using only a slight modification of the 64-bit loop.\n *\n * XXH128 is also more oriented towards 64-bit machines. It is still extremely\n * fast for a _128-bit_ hash on 32-bit (it usually clears XXH64).\n */\n\nXXH_FORCE_INLINE XXH_PUREF XXH128_hash_t\nXXH3_len_1to3_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)\n{\n    /* A doubled version of 1to3_64b with different constants. */\n    XXH_ASSERT(input != NULL);\n    XXH_ASSERT(1 <= len && len <= 3);\n    XXH_ASSERT(secret != NULL);\n    /*\n     * len = 1: combinedl = { input[0], 0x01, input[0], input[0] }\n     * len = 2: combinedl = { input[1], 0x02, input[0], input[1] }\n     * len = 3: combinedl = { input[2], 0x03, input[0], input[1] }\n     */\n    {   xxh_u8 const c1 = input[0];\n        xxh_u8 const c2 = input[len >> 1];\n        xxh_u8 const c3 = input[len - 1];\n        xxh_u32 const combinedl = ((xxh_u32)c1 <<16) | ((xxh_u32)c2 << 24)\n                                | ((xxh_u32)c3 << 0) | ((xxh_u32)len << 8);\n        xxh_u32 const combinedh = XXH_rotl32(XXH_swap32(combinedl), 13);\n        xxh_u64 const bitflipl = (XXH_readLE32(secret) ^ XXH_readLE32(secret+4)) + seed;\n        xxh_u64 const bitfliph = (XXH_readLE32(secret+8) ^ XXH_readLE32(secret+12)) - seed;\n        xxh_u64 const keyed_lo = (xxh_u64)combinedl ^ bitflipl;\n        xxh_u64 const keyed_hi = (xxh_u64)combinedh ^ bitfliph;\n        XXH128_hash_t h128;\n        h128.low64  = XXH64_avalanche(keyed_lo);\n        h128.high64 = XXH64_avalanche(keyed_hi);\n        return h128;\n    }\n}\n\nXXH_FORCE_INLINE XXH_PUREF XXH128_hash_t\nXXH3_len_4to8_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)\n{\n    XXH_ASSERT(input != NULL);\n    XXH_ASSERT(secret != NULL);\n    XXH_ASSERT(4 <= len && len <= 8);\n    seed ^= (xxh_u64)XXH_swap32((xxh_u32)seed) << 32;\n    {   xxh_u32 const input_lo = XXH_readLE32(input);\n        xxh_u32 const input_hi = XXH_readLE32(input + len - 4);\n        xxh_u64 const input_64 = input_lo + ((xxh_u64)input_hi << 32);\n        xxh_u64 const bitflip = (XXH_readLE64(secret+16) ^ XXH_readLE64(secret+24)) + seed;\n        xxh_u64 const keyed = input_64 ^ bitflip;\n\n        /* Shift len to the left to ensure it is even, this avoids even multiplies. */\n        XXH128_hash_t m128 = XXH_mult64to128(keyed, XXH_PRIME64_1 + (len << 2));\n\n        m128.high64 += (m128.low64 << 1);\n        m128.low64  ^= (m128.high64 >> 3);\n\n        m128.low64   = XXH_xorshift64(m128.low64, 35);\n        m128.low64  *= PRIME_MX2;\n        m128.low64   = XXH_xorshift64(m128.low64, 28);\n        m128.high64  = XXH3_avalanche(m128.high64);\n        return m128;\n    }\n}\n\nXXH_FORCE_INLINE XXH_PUREF XXH128_hash_t\nXXH3_len_9to16_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)\n{\n    XXH_ASSERT(input != NULL);\n    XXH_ASSERT(secret != NULL);\n    XXH_ASSERT(9 <= len && len <= 16);\n    {   xxh_u64 const bitflipl = (XXH_readLE64(secret+32) ^ XXH_readLE64(secret+40)) - seed;\n        xxh_u64 const bitfliph = (XXH_readLE64(secret+48) ^ XXH_readLE64(secret+56)) + seed;\n        xxh_u64 const input_lo = XXH_readLE64(input);\n        xxh_u64       input_hi = XXH_readLE64(input + len - 8);\n        XXH128_hash_t m128 = XXH_mult64to128(input_lo ^ input_hi ^ bitflipl, XXH_PRIME64_1);\n        /*\n         * Put len in the middle of m128 to ensure that the length gets mixed to\n         * both the low and high bits in the 128x64 multiply below.\n         */\n        m128.low64 += (xxh_u64)(len - 1) << 54;\n        input_hi   ^= bitfliph;\n        /*\n         * Add the high 32 bits of input_hi to the high 32 bits of m128, then\n         * add the long product of the low 32 bits of input_hi and XXH_PRIME32_2 to\n         * the high 64 bits of m128.\n         *\n         * The best approach to this operation is different on 32-bit and 64-bit.\n         */\n        if (sizeof(void *) < sizeof(xxh_u64)) { /* 32-bit */\n            /*\n             * 32-bit optimized version, which is more readable.\n             *\n             * On 32-bit, it removes an ADC and delays a dependency between the two\n             * halves of m128.high64, but it generates an extra mask on 64-bit.\n             */\n            m128.high64 += (input_hi & 0xFFFFFFFF00000000ULL) + XXH_mult32to64((xxh_u32)input_hi, XXH_PRIME32_2);\n        } else {\n            /*\n             * 64-bit optimized (albeit more confusing) version.\n             *\n             * Uses some properties of addition and multiplication to remove the mask:\n             *\n             * Let:\n             *    a = input_hi.lo = (input_hi & 0x00000000FFFFFFFF)\n             *    b = input_hi.hi = (input_hi & 0xFFFFFFFF00000000)\n             *    c = XXH_PRIME32_2\n             *\n             *    a + (b * c)\n             * Inverse Property: x + y - x == y\n             *    a + (b * (1 + c - 1))\n             * Distributive Property: x * (y + z) == (x * y) + (x * z)\n             *    a + (b * 1) + (b * (c - 1))\n             * Identity Property: x * 1 == x\n             *    a + b + (b * (c - 1))\n             *\n             * Substitute a, b, and c:\n             *    input_hi.hi + input_hi.lo + ((xxh_u64)input_hi.lo * (XXH_PRIME32_2 - 1))\n             *\n             * Since input_hi.hi + input_hi.lo == input_hi, we get this:\n             *    input_hi + ((xxh_u64)input_hi.lo * (XXH_PRIME32_2 - 1))\n             */\n            m128.high64 += input_hi + XXH_mult32to64((xxh_u32)input_hi, XXH_PRIME32_2 - 1);\n        }\n        /* m128 ^= XXH_swap64(m128 >> 64); */\n        m128.low64  ^= XXH_swap64(m128.high64);\n\n        {   /* 128x64 multiply: h128 = m128 * XXH_PRIME64_2; */\n            XXH128_hash_t h128 = XXH_mult64to128(m128.low64, XXH_PRIME64_2);\n            h128.high64 += m128.high64 * XXH_PRIME64_2;\n\n            h128.low64   = XXH3_avalanche(h128.low64);\n            h128.high64  = XXH3_avalanche(h128.high64);\n            return h128;\n    }   }\n}\n\n/*\n * Assumption: `secret` size is >= XXH3_SECRET_SIZE_MIN\n */\nXXH_FORCE_INLINE XXH_PUREF XXH128_hash_t\nXXH3_len_0to16_128b(const xxh_u8* input, size_t len, const xxh_u8* secret, XXH64_hash_t seed)\n{\n    XXH_ASSERT(len <= 16);\n    {   if (len > 8) return XXH3_len_9to16_128b(input, len, secret, seed);\n        if (len >= 4) return XXH3_len_4to8_128b(input, len, secret, seed);\n        if (len) return XXH3_len_1to3_128b(input, len, secret, seed);\n        {   XXH128_hash_t h128;\n            xxh_u64 const bitflipl = XXH_readLE64(secret+64) ^ XXH_readLE64(secret+72);\n            xxh_u64 const bitfliph = XXH_readLE64(secret+80) ^ XXH_readLE64(secret+88);\n            h128.low64 = XXH64_avalanche(seed ^ bitflipl);\n            h128.high64 = XXH64_avalanche( seed ^ bitfliph);\n            return h128;\n    }   }\n}\n\n/*\n * A bit slower than XXH3_mix16B, but handles multiply by zero better.\n */\nXXH_FORCE_INLINE XXH128_hash_t\nXXH128_mix32B(XXH128_hash_t acc, const xxh_u8* input_1, const xxh_u8* input_2,\n              const xxh_u8* secret, XXH64_hash_t seed)\n{\n    acc.low64  += XXH3_mix16B (input_1, secret+0, seed);\n    acc.low64  ^= XXH_readLE64(input_2) + XXH_readLE64(input_2 + 8);\n    acc.high64 += XXH3_mix16B (input_2, secret+16, seed);\n    acc.high64 ^= XXH_readLE64(input_1) + XXH_readLE64(input_1 + 8);\n    return acc;\n}\n\n\nXXH_FORCE_INLINE XXH_PUREF XXH128_hash_t\nXXH3_len_17to128_128b(const xxh_u8* XXH_RESTRICT input, size_t len,\n                      const xxh_u8* XXH_RESTRICT secret, size_t secretSize,\n                      XXH64_hash_t seed)\n{\n    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize;\n    XXH_ASSERT(16 < len && len <= 128);\n\n    {   XXH128_hash_t acc;\n        acc.low64 = len * XXH_PRIME64_1;\n        acc.high64 = 0;\n\n#if XXH_SIZE_OPT >= 1\n        {\n            /* Smaller, but slightly slower. */\n            unsigned int i = (unsigned int)(len - 1) / 32;\n            do {\n                acc = XXH128_mix32B(acc, input+16*i, input+len-16*(i+1), secret+32*i, seed);\n            } while (i-- != 0);\n        }\n#else\n        if (len > 32) {\n            if (len > 64) {\n                if (len > 96) {\n                    acc = XXH128_mix32B(acc, input+48, input+len-64, secret+96, seed);\n                }\n                acc = XXH128_mix32B(acc, input+32, input+len-48, secret+64, seed);\n            }\n            acc = XXH128_mix32B(acc, input+16, input+len-32, secret+32, seed);\n        }\n        acc = XXH128_mix32B(acc, input, input+len-16, secret, seed);\n#endif\n        {   XXH128_hash_t h128;\n            h128.low64  = acc.low64 + acc.high64;\n            h128.high64 = (acc.low64    * XXH_PRIME64_1)\n                        + (acc.high64   * XXH_PRIME64_4)\n                        + ((len - seed) * XXH_PRIME64_2);\n            h128.low64  = XXH3_avalanche(h128.low64);\n            h128.high64 = (XXH64_hash_t)0 - XXH3_avalanche(h128.high64);\n            return h128;\n        }\n    }\n}\n\nXXH_NO_INLINE XXH_PUREF XXH128_hash_t\nXXH3_len_129to240_128b(const xxh_u8* XXH_RESTRICT input, size_t len,\n                       const xxh_u8* XXH_RESTRICT secret, size_t secretSize,\n                       XXH64_hash_t seed)\n{\n    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN); (void)secretSize;\n    XXH_ASSERT(128 < len && len <= XXH3_MIDSIZE_MAX);\n\n    {   XXH128_hash_t acc;\n        unsigned i;\n        acc.low64 = len * XXH_PRIME64_1;\n        acc.high64 = 0;\n        /*\n         *  We set as `i` as offset + 32. We do this so that unchanged\n         * `len` can be used as upper bound. This reaches a sweet spot\n         * where both x86 and aarch64 get simple agen and good codegen\n         * for the loop.\n         */\n        for (i = 32; i < 160; i += 32) {\n            acc = XXH128_mix32B(acc,\n                                input  + i - 32,\n                                input  + i - 16,\n                                secret + i - 32,\n                                seed);\n        }\n        acc.low64 = XXH3_avalanche(acc.low64);\n        acc.high64 = XXH3_avalanche(acc.high64);\n        /*\n         * NB: `i <= len` will duplicate the last 32-bytes if\n         * len % 32 was zero. This is an unfortunate necessity to keep\n         * the hash result stable.\n         */\n        for (i=160; i <= len; i += 32) {\n            acc = XXH128_mix32B(acc,\n                                input + i - 32,\n                                input + i - 16,\n                                secret + XXH3_MIDSIZE_STARTOFFSET + i - 160,\n                                seed);\n        }\n        /* last bytes */\n        acc = XXH128_mix32B(acc,\n                            input + len - 16,\n                            input + len - 32,\n                            secret + XXH3_SECRET_SIZE_MIN - XXH3_MIDSIZE_LASTOFFSET - 16,\n                            (XXH64_hash_t)0 - seed);\n\n        {   XXH128_hash_t h128;\n            h128.low64  = acc.low64 + acc.high64;\n            h128.high64 = (acc.low64    * XXH_PRIME64_1)\n                        + (acc.high64   * XXH_PRIME64_4)\n                        + ((len - seed) * XXH_PRIME64_2);\n            h128.low64  = XXH3_avalanche(h128.low64);\n            h128.high64 = (XXH64_hash_t)0 - XXH3_avalanche(h128.high64);\n            return h128;\n        }\n    }\n}\n\nXXH_FORCE_INLINE XXH128_hash_t\nXXH3_hashLong_128b_internal(const void* XXH_RESTRICT input, size_t len,\n                            const xxh_u8* XXH_RESTRICT secret, size_t secretSize,\n                            XXH3_f_accumulate f_acc,\n                            XXH3_f_scrambleAcc f_scramble)\n{\n    XXH_ALIGN(XXH_ACC_ALIGN) xxh_u64 acc[XXH_ACC_NB] = XXH3_INIT_ACC;\n\n    XXH3_hashLong_internal_loop(acc, (const xxh_u8*)input, len, secret, secretSize, f_acc, f_scramble);\n\n    /* converge into final hash */\n    XXH_STATIC_ASSERT(sizeof(acc) == 64);\n    XXH_ASSERT(secretSize >= sizeof(acc) + XXH_SECRET_MERGEACCS_START);\n    {   XXH128_hash_t h128;\n        h128.low64  = XXH3_mergeAccs(acc,\n                                     secret + XXH_SECRET_MERGEACCS_START,\n                                     (xxh_u64)len * XXH_PRIME64_1);\n        h128.high64 = XXH3_mergeAccs(acc,\n                                     secret + secretSize\n                                            - sizeof(acc) - XXH_SECRET_MERGEACCS_START,\n                                     ~((xxh_u64)len * XXH_PRIME64_2));\n        return h128;\n    }\n}\n\n/*\n * It's important for performance that XXH3_hashLong() is not inlined.\n */\nXXH_NO_INLINE XXH_PUREF XXH128_hash_t\nXXH3_hashLong_128b_default(const void* XXH_RESTRICT input, size_t len,\n                           XXH64_hash_t seed64,\n                           const void* XXH_RESTRICT secret, size_t secretLen)\n{\n    (void)seed64; (void)secret; (void)secretLen;\n    return XXH3_hashLong_128b_internal(input, len, XXH3_kSecret, sizeof(XXH3_kSecret),\n                                       XXH3_accumulate, XXH3_scrambleAcc);\n}\n\n/*\n * It's important for performance to pass @p secretLen (when it's static)\n * to the compiler, so that it can properly optimize the vectorized loop.\n *\n * When the secret size is unknown, or on GCC 12 where the mix of NO_INLINE and FORCE_INLINE\n * breaks -Og, this is XXH_NO_INLINE.\n */\nXXH3_WITH_SECRET_INLINE XXH128_hash_t\nXXH3_hashLong_128b_withSecret(const void* XXH_RESTRICT input, size_t len,\n                              XXH64_hash_t seed64,\n                              const void* XXH_RESTRICT secret, size_t secretLen)\n{\n    (void)seed64;\n    return XXH3_hashLong_128b_internal(input, len, (const xxh_u8*)secret, secretLen,\n                                       XXH3_accumulate, XXH3_scrambleAcc);\n}\n\nXXH_FORCE_INLINE XXH128_hash_t\nXXH3_hashLong_128b_withSeed_internal(const void* XXH_RESTRICT input, size_t len,\n                                XXH64_hash_t seed64,\n                                XXH3_f_accumulate f_acc,\n                                XXH3_f_scrambleAcc f_scramble,\n                                XXH3_f_initCustomSecret f_initSec)\n{\n    if (seed64 == 0)\n        return XXH3_hashLong_128b_internal(input, len,\n                                           XXH3_kSecret, sizeof(XXH3_kSecret),\n                                           f_acc, f_scramble);\n    {   XXH_ALIGN(XXH_SEC_ALIGN) xxh_u8 secret[XXH_SECRET_DEFAULT_SIZE];\n        f_initSec(secret, seed64);\n        return XXH3_hashLong_128b_internal(input, len, (const xxh_u8*)secret, sizeof(secret),\n                                           f_acc, f_scramble);\n    }\n}\n\n/*\n * It's important for performance that XXH3_hashLong is not inlined.\n */\nXXH_NO_INLINE XXH128_hash_t\nXXH3_hashLong_128b_withSeed(const void* input, size_t len,\n                            XXH64_hash_t seed64, const void* XXH_RESTRICT secret, size_t secretLen)\n{\n    (void)secret; (void)secretLen;\n    return XXH3_hashLong_128b_withSeed_internal(input, len, seed64,\n                XXH3_accumulate, XXH3_scrambleAcc, XXH3_initCustomSecret);\n}\n\ntypedef XXH128_hash_t (*XXH3_hashLong128_f)(const void* XXH_RESTRICT, size_t,\n                                            XXH64_hash_t, const void* XXH_RESTRICT, size_t);\n\nXXH_FORCE_INLINE XXH128_hash_t\nXXH3_128bits_internal(const void* input, size_t len,\n                      XXH64_hash_t seed64, const void* XXH_RESTRICT secret, size_t secretLen,\n                      XXH3_hashLong128_f f_hl128)\n{\n    XXH_ASSERT(secretLen >= XXH3_SECRET_SIZE_MIN);\n    /*\n     * If an action is to be taken if `secret` conditions are not respected,\n     * it should be done here.\n     * For now, it's a contract pre-condition.\n     * Adding a check and a branch here would cost performance at every hash.\n     */\n    if (len <= 16)\n        return XXH3_len_0to16_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, seed64);\n    if (len <= 128)\n        return XXH3_len_17to128_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64);\n    if (len <= XXH3_MIDSIZE_MAX)\n        return XXH3_len_129to240_128b((const xxh_u8*)input, len, (const xxh_u8*)secret, secretLen, seed64);\n    return f_hl128(input, len, seed64, secret, secretLen);\n}\n\n\n/* ===   Public XXH128 API   === */\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH128_hash_t XXH3_128bits(XXH_NOESCAPE const void* input, size_t len)\n{\n    return XXH3_128bits_internal(input, len, 0,\n                                 XXH3_kSecret, sizeof(XXH3_kSecret),\n                                 XXH3_hashLong_128b_default);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH128_hash_t\nXXH3_128bits_withSecret(XXH_NOESCAPE const void* input, size_t len, XXH_NOESCAPE const void* secret, size_t secretSize)\n{\n    return XXH3_128bits_internal(input, len, 0,\n                                 (const xxh_u8*)secret, secretSize,\n                                 XXH3_hashLong_128b_withSecret);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH128_hash_t\nXXH3_128bits_withSeed(XXH_NOESCAPE const void* input, size_t len, XXH64_hash_t seed)\n{\n    return XXH3_128bits_internal(input, len, seed,\n                                 XXH3_kSecret, sizeof(XXH3_kSecret),\n                                 XXH3_hashLong_128b_withSeed);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH128_hash_t\nXXH3_128bits_withSecretandSeed(XXH_NOESCAPE const void* input, size_t len, XXH_NOESCAPE const void* secret, size_t secretSize, XXH64_hash_t seed)\n{\n    if (len <= XXH3_MIDSIZE_MAX)\n        return XXH3_128bits_internal(input, len, seed, XXH3_kSecret, sizeof(XXH3_kSecret), NULL);\n    return XXH3_hashLong_128b_withSecret(input, len, seed, secret, secretSize);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH128_hash_t\nXXH128(XXH_NOESCAPE const void* input, size_t len, XXH64_hash_t seed)\n{\n    return XXH3_128bits_withSeed(input, len, seed);\n}\n\n\n/* ===   XXH3 128-bit streaming   === */\n#ifndef XXH_NO_STREAM\n/*\n * All initialization and update functions are identical to 64-bit streaming variant.\n * The only difference is the finalization routine.\n */\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_128bits_reset(XXH_NOESCAPE XXH3_state_t* statePtr)\n{\n    return XXH3_64bits_reset(statePtr);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_128bits_reset_withSecret(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize)\n{\n    return XXH3_64bits_reset_withSecret(statePtr, secret, secretSize);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_128bits_reset_withSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH64_hash_t seed)\n{\n    return XXH3_64bits_reset_withSeed(statePtr, seed);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_128bits_reset_withSecretandSeed(XXH_NOESCAPE XXH3_state_t* statePtr, XXH_NOESCAPE const void* secret, size_t secretSize, XXH64_hash_t seed)\n{\n    return XXH3_64bits_reset_withSecretandSeed(statePtr, secret, secretSize, seed);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_128bits_update(XXH_NOESCAPE XXH3_state_t* state, XXH_NOESCAPE const void* input, size_t len)\n{\n    return XXH3_64bits_update(state, input, len);\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH128_hash_t XXH3_128bits_digest (XXH_NOESCAPE const XXH3_state_t* state)\n{\n    const unsigned char* const secret = (state->extSecret == NULL) ? state->customSecret : state->extSecret;\n    if (state->totalLen > XXH3_MIDSIZE_MAX) {\n        XXH_ALIGN(XXH_ACC_ALIGN) XXH64_hash_t acc[XXH_ACC_NB];\n        XXH3_digest_long(acc, state, secret);\n        XXH_ASSERT(state->secretLimit + XXH_STRIPE_LEN >= sizeof(acc) + XXH_SECRET_MERGEACCS_START);\n        {   XXH128_hash_t h128;\n            h128.low64  = XXH3_mergeAccs(acc,\n                                         secret + XXH_SECRET_MERGEACCS_START,\n                                         (xxh_u64)state->totalLen * XXH_PRIME64_1);\n            h128.high64 = XXH3_mergeAccs(acc,\n                                         secret + state->secretLimit + XXH_STRIPE_LEN\n                                                - sizeof(acc) - XXH_SECRET_MERGEACCS_START,\n                                         ~((xxh_u64)state->totalLen * XXH_PRIME64_2));\n            return h128;\n        }\n    }\n    /* len <= XXH3_MIDSIZE_MAX : short code */\n    if (state->seed)\n        return XXH3_128bits_withSeed(state->buffer, (size_t)state->totalLen, state->seed);\n    return XXH3_128bits_withSecret(state->buffer, (size_t)(state->totalLen),\n                                   secret, state->secretLimit + XXH_STRIPE_LEN);\n}\n#endif /* !XXH_NO_STREAM */\n/* 128-bit utility functions */\n\n/* return : 1 is equal, 0 if different */\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API int XXH128_isEqual(XXH128_hash_t h1, XXH128_hash_t h2)\n{\n    /* note : XXH128_hash_t is compact, it has no padding byte */\n    return !(memcmp(&h1, &h2, sizeof(h1)));\n}\n\n/* This prototype is compatible with stdlib's qsort().\n * @return : >0 if *h128_1  > *h128_2\n *           <0 if *h128_1  < *h128_2\n *           =0 if *h128_1 == *h128_2  */\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API int XXH128_cmp(XXH_NOESCAPE const void* h128_1, XXH_NOESCAPE const void* h128_2)\n{\n    XXH128_hash_t const h1 = *(const XXH128_hash_t*)h128_1;\n    XXH128_hash_t const h2 = *(const XXH128_hash_t*)h128_2;\n    int const hcmp = (h1.high64 > h2.high64) - (h2.high64 > h1.high64);\n    /* note : bets that, in most cases, hash values are different */\n    if (hcmp) return hcmp;\n    return (h1.low64 > h2.low64) - (h2.low64 > h1.low64);\n}\n\n\n/*======   Canonical representation   ======*/\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API void\nXXH128_canonicalFromHash(XXH_NOESCAPE XXH128_canonical_t* dst, XXH128_hash_t hash)\n{\n    XXH_STATIC_ASSERT(sizeof(XXH128_canonical_t) == sizeof(XXH128_hash_t));\n    if (XXH_CPU_LITTLE_ENDIAN) {\n        hash.high64 = XXH_swap64(hash.high64);\n        hash.low64  = XXH_swap64(hash.low64);\n    }\n    XXH_memcpy(dst, &hash.high64, sizeof(hash.high64));\n    XXH_memcpy((char*)dst + sizeof(hash.high64), &hash.low64, sizeof(hash.low64));\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH128_hash_t\nXXH128_hashFromCanonical(XXH_NOESCAPE const XXH128_canonical_t* src)\n{\n    XXH128_hash_t h;\n    h.high64 = XXH_readBE64(src);\n    h.low64  = XXH_readBE64(src->digest + 8);\n    return h;\n}\n\n\n\n/* ==========================================\n * Secret generators\n * ==========================================\n */\n#define XXH_MIN(x, y) (((x) > (y)) ? (y) : (x))\n\nXXH_FORCE_INLINE void XXH3_combine16(void* dst, XXH128_hash_t h128)\n{\n    XXH_writeLE64( dst, XXH_readLE64(dst) ^ h128.low64 );\n    XXH_writeLE64( (char*)dst+8, XXH_readLE64((char*)dst+8) ^ h128.high64 );\n}\n\n/*! @ingroup XXH3_family */\nXXH_PUBLIC_API XXH_errorcode\nXXH3_generateSecret(XXH_NOESCAPE void* secretBuffer, size_t secretSize, XXH_NOESCAPE const void* customSeed, size_t customSeedSize)\n{\n#if (XXH_DEBUGLEVEL >= 1)\n    XXH_ASSERT(secretBuffer != NULL);\n    XXH_ASSERT(secretSize >= XXH3_SECRET_SIZE_MIN);\n#else\n    /* production mode, assert() are disabled */\n    if (secretBuffer == NULL) return XXH_ERROR;\n    if (secretSize < XXH3_SECRET_SIZE_MIN) return XXH_ERROR;\n#endif\n\n    if (customSeedSize == 0) {\n        customSeed = XXH3_kSecret;\n        customSeedSize = XXH_SECRET_DEFAULT_SIZE;\n    }\n#if (XXH_DEBUGLEVEL >= 1)\n    XXH_ASSERT(customSeed != NULL);\n#else\n    if (customSeed == NULL) return XXH_ERROR;\n#endif\n\n    /* Fill secretBuffer with a copy of customSeed - repeat as needed */\n    {   size_t pos = 0;\n        while (pos < secretSize) {\n            size_t const toCopy = XXH_MIN((secretSize - pos), customSeedSize);\n            memcpy((char*)secretBuffer + pos, customSeed, toCopy);\n            pos += toCopy;\n    }   }\n\n    {   size_t const nbSeg16 = secretSize / 16;\n        size_t n;\n        XXH128_canonical_t scrambler;\n        XXH128_canonicalFromHash(&scrambler, XXH128(customSeed, customSeedSize, 0));\n        for (n=0; n\n#include \n#include \n\n#if defined(__GNUC__) && __GNUC__ >= 4\n# define ZSTD_memcpy(d,s,l) __builtin_memcpy((d),(s),(l))\n# define ZSTD_memmove(d,s,l) __builtin_memmove((d),(s),(l))\n# define ZSTD_memset(p,v,l) __builtin_memset((p),(v),(l))\n#else\n# define ZSTD_memcpy(d,s,l) memcpy((d),(s),(l))\n# define ZSTD_memmove(d,s,l) memmove((d),(s),(l))\n# define ZSTD_memset(p,v,l) memset((p),(v),(l))\n#endif\n\n#endif /* ZSTD_DEPS_COMMON */\n\n/* Need:\n * ZSTD_malloc()\n * ZSTD_free()\n * ZSTD_calloc()\n */\n#ifdef ZSTD_DEPS_NEED_MALLOC\n#ifndef ZSTD_DEPS_MALLOC\n#define ZSTD_DEPS_MALLOC\n\n#include \n\n#define ZSTD_malloc(s) malloc(s)\n#define ZSTD_calloc(n,s) calloc((n), (s))\n#define ZSTD_free(p) free((p))\n\n#endif /* ZSTD_DEPS_MALLOC */\n#endif /* ZSTD_DEPS_NEED_MALLOC */\n\n/*\n * Provides 64-bit math support.\n * Need:\n * U64 ZSTD_div64(U64 dividend, U32 divisor)\n */\n#ifdef ZSTD_DEPS_NEED_MATH64\n#ifndef ZSTD_DEPS_MATH64\n#define ZSTD_DEPS_MATH64\n\n#define ZSTD_div64(dividend, divisor) ((dividend) / (divisor))\n\n#endif /* ZSTD_DEPS_MATH64 */\n#endif /* ZSTD_DEPS_NEED_MATH64 */\n\n/* Need:\n * assert()\n */\n#ifdef ZSTD_DEPS_NEED_ASSERT\n#ifndef ZSTD_DEPS_ASSERT\n#define ZSTD_DEPS_ASSERT\n\n#include \n\n#endif /* ZSTD_DEPS_ASSERT */\n#endif /* ZSTD_DEPS_NEED_ASSERT */\n\n/* Need:\n * ZSTD_DEBUG_PRINT()\n */\n#ifdef ZSTD_DEPS_NEED_IO\n#ifndef ZSTD_DEPS_IO\n#define ZSTD_DEPS_IO\n\n#include \n#define ZSTD_DEBUG_PRINT(...) fprintf(stderr, __VA_ARGS__)\n\n#endif /* ZSTD_DEPS_IO */\n#endif /* ZSTD_DEPS_NEED_IO */\n\n/* Only requested when  is known to be present.\n * Need:\n * intptr_t\n */\n#ifdef ZSTD_DEPS_NEED_STDINT\n#ifndef ZSTD_DEPS_STDINT\n#define ZSTD_DEPS_STDINT\n\n#include \n\n#endif /* ZSTD_DEPS_STDINT */\n#endif /* ZSTD_DEPS_NEED_STDINT */\n"
  },
  {
    "path": "lib/common/zstd_internal.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_CCOMMON_H_MODULE\n#define ZSTD_CCOMMON_H_MODULE\n\n/* this module contains definitions which must be identical\n * across compression, decompression and dictBuilder.\n * It also contains a few functions useful to at least 2 of them\n * and which benefit from being inlined */\n\n/*-*************************************\n*  Dependencies\n***************************************/\n#include \"compiler.h\"\n#include \"cpu.h\"\n#include \"mem.h\"\n#include \"debug.h\"                 /* assert, DEBUGLOG, RAWLOG, g_debuglevel */\n#include \"error_private.h\"\n#define ZSTD_STATIC_LINKING_ONLY\n#include \"../zstd.h\"\n#define FSE_STATIC_LINKING_ONLY\n#include \"fse.h\"\n#include \"huf.h\"\n#ifndef XXH_STATIC_LINKING_ONLY\n#  define XXH_STATIC_LINKING_ONLY  /* XXH64_state_t */\n#endif\n#include \"xxhash.h\"                /* XXH_reset, update, digest */\n#ifndef ZSTD_NO_TRACE\n#  include \"zstd_trace.h\"\n#else\n#  define ZSTD_TRACE 0\n#endif\n\n/* ---- static assert (debug) --- */\n#define ZSTD_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)\n#define ZSTD_isError ERR_isError   /* for inlining */\n#define FSE_isError  ERR_isError\n#define HUF_isError  ERR_isError\n\n\n/*-*************************************\n*  shared macros\n***************************************/\n#undef MIN\n#undef MAX\n#define MIN(a,b) ((a)<(b) ? (a) : (b))\n#define MAX(a,b) ((a)>(b) ? (a) : (b))\n#define BOUNDED(min,val,max) (MAX(min,MIN(val,max)))\n\n\n/*-*************************************\n*  Common constants\n***************************************/\n#define ZSTD_OPT_NUM    (1<<12)\n\n#define ZSTD_REP_NUM      3                 /* number of repcodes */\nstatic UNUSED_ATTR const U32 repStartValue[ZSTD_REP_NUM] = { 1, 4, 8 };\n\n#define KB *(1 <<10)\n#define MB *(1 <<20)\n#define GB *(1U<<30)\n\n#define BIT7 128\n#define BIT6  64\n#define BIT5  32\n#define BIT4  16\n#define BIT1   2\n#define BIT0   1\n\n#define ZSTD_WINDOWLOG_ABSOLUTEMIN 10\nstatic UNUSED_ATTR const size_t ZSTD_fcs_fieldSize[4] = { 0, 2, 4, 8 };\nstatic UNUSED_ATTR const size_t ZSTD_did_fieldSize[4] = { 0, 1, 2, 4 };\n\n#define ZSTD_FRAMEIDSIZE 4   /* magic number size */\n\n#define ZSTD_BLOCKHEADERSIZE 3   /* C standard doesn't allow `static const` variable to be init using another `static const` variable */\nstatic UNUSED_ATTR const size_t ZSTD_blockHeaderSize = ZSTD_BLOCKHEADERSIZE;\ntypedef enum { bt_raw, bt_rle, bt_compressed, bt_reserved } blockType_e;\n\n#define ZSTD_FRAMECHECKSUMSIZE 4\n\n#define MIN_SEQUENCES_SIZE 1 /* nbSeq==0 */\n#define MIN_CBLOCK_SIZE (1 /*litCSize*/ + 1 /* RLE or RAW */)   /* for a non-null block */\n#define MIN_LITERALS_FOR_4_STREAMS 6\n\ntypedef enum { set_basic, set_rle, set_compressed, set_repeat } SymbolEncodingType_e;\n\n#define LONGNBSEQ 0x7F00\n\n#define MINMATCH 3\n\n#define Litbits  8\n#define LitHufLog 11\n#define MaxLit ((1<= WILDCOPY_VECLEN || diff <= -WILDCOPY_VECLEN);\n        /* Separate out the first COPY16() call because the copy length is\n         * almost certain to be short, so the branches have different\n         * probabilities. Since it is almost certain to be short, only do\n         * one COPY16() in the first call. Then, do two calls per loop since\n         * at that point it is more likely to have a high trip count.\n         */\n        ZSTD_copy16(op, ip);\n        if (16 >= length) return;\n        op += 16;\n        ip += 16;\n        do {\n            COPY16(op, ip);\n            COPY16(op, ip);\n        }\n        while (op < oend);\n    }\n}\n\nMEM_STATIC size_t ZSTD_limitCopy(void* dst, size_t dstCapacity, const void* src, size_t srcSize)\n{\n    size_t const length = MIN(dstCapacity, srcSize);\n    if (length > 0) {\n        ZSTD_memcpy(dst, src, length);\n    }\n    return length;\n}\n\n/* define \"workspace is too large\" as this number of times larger than needed */\n#define ZSTD_WORKSPACETOOLARGE_FACTOR 3\n\n/* when workspace is continuously too large\n * during at least this number of times,\n * context's memory usage is considered wasteful,\n * because it's sized to handle a worst case scenario which rarely happens.\n * In which case, resize it down to free some memory */\n#define ZSTD_WORKSPACETOOLARGE_MAXDURATION 128\n\n/* Controls whether the input/output buffer is buffered or stable. */\ntypedef enum {\n    ZSTD_bm_buffered = 0,  /* Buffer the input/output */\n    ZSTD_bm_stable = 1     /* ZSTD_inBuffer/ZSTD_outBuffer is stable */\n} ZSTD_bufferMode_e;\n\n\n/*-*******************************************\n*  Private declarations\n*********************************************/\n\n/**\n * Contains the compressed frame size and an upper-bound for the decompressed frame size.\n * Note: before using `compressedSize`, check for errors using ZSTD_isError().\n *       similarly, before using `decompressedBound`, check for errors using:\n *          `decompressedBound != ZSTD_CONTENTSIZE_ERROR`\n */\ntypedef struct {\n    size_t nbBlocks;\n    size_t compressedSize;\n    unsigned long long decompressedBound;\n} ZSTD_frameSizeInfo;   /* decompress & legacy */\n\n/* ZSTD_invalidateRepCodes() :\n * ensures next compression will not use repcodes from previous block.\n * Note : only works with regular variant;\n *        do not use with extDict variant ! */\nvoid ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx);   /* zstdmt, adaptive_compression (shouldn't get this definition from here) */\n\n\ntypedef struct {\n    blockType_e blockType;\n    U32 lastBlock;\n    U32 origSize;\n} blockProperties_t;   /* declared here for decompress and fullbench */\n\n/*! ZSTD_getcBlockSize() :\n *  Provides the size of compressed block from block header `src` */\n/*  Used by: decompress, fullbench */\nsize_t ZSTD_getcBlockSize(const void* src, size_t srcSize,\n                          blockProperties_t* bpPtr);\n\n/*! ZSTD_decodeSeqHeaders() :\n *  decode sequence header from src */\n/*  Used by: zstd_decompress_block, fullbench */\nsize_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,\n                       const void* src, size_t srcSize);\n\n/**\n * @returns true iff the CPU supports dynamic BMI2 dispatch.\n */\nMEM_STATIC int ZSTD_cpuSupportsBmi2(void)\n{\n    ZSTD_cpuid_t cpuid = ZSTD_cpuid();\n    return ZSTD_cpuid_bmi1(cpuid) && ZSTD_cpuid_bmi2(cpuid);\n}\n\n#endif   /* ZSTD_CCOMMON_H_MODULE */\n"
  },
  {
    "path": "lib/common/zstd_trace.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_TRACE_H\n#define ZSTD_TRACE_H\n\n#include \n\n/* weak symbol support\n * For now, enable conservatively:\n * - Only GNUC\n * - Only ELF\n * - Only x86-64, i386, aarch64 and risc-v.\n * Also, explicitly disable on platforms known not to work so they aren't\n * forgotten in the future.\n */\n#if !defined(ZSTD_HAVE_WEAK_SYMBOLS) && \\\n    defined(__GNUC__) && defined(__ELF__) && \\\n    (defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || \\\n     defined(_M_IX86) || defined(__aarch64__) || defined(__riscv)) && \\\n    !defined(__APPLE__) && !defined(_WIN32) && !defined(__MINGW32__) && \\\n    !defined(__CYGWIN__) && !defined(_AIX)\n#  define ZSTD_HAVE_WEAK_SYMBOLS 1\n#else\n#  define ZSTD_HAVE_WEAK_SYMBOLS 0\n#endif\n#if ZSTD_HAVE_WEAK_SYMBOLS\n#  define ZSTD_WEAK_ATTR __attribute__((__weak__))\n#else\n#  define ZSTD_WEAK_ATTR\n#endif\n\n/* Only enable tracing when weak symbols are available. */\n#ifndef ZSTD_TRACE\n#  define ZSTD_TRACE ZSTD_HAVE_WEAK_SYMBOLS\n#endif\n\n#if ZSTD_TRACE\n\nstruct ZSTD_CCtx_s;\nstruct ZSTD_DCtx_s;\nstruct ZSTD_CCtx_params_s;\n\ntypedef struct {\n    /**\n     * ZSTD_VERSION_NUMBER\n     *\n     * This is guaranteed to be the first member of ZSTD_trace.\n     * Otherwise, this struct is not stable between versions. If\n     * the version number does not match your expectation, you\n     * should not interpret the rest of the struct.\n     */\n    unsigned version;\n    /**\n     * Non-zero if streaming (de)compression is used.\n     */\n    int streaming;\n    /**\n     * The dictionary ID.\n     */\n    unsigned dictionaryID;\n    /**\n     * Is the dictionary cold?\n     * Only set on decompression.\n     */\n    int dictionaryIsCold;\n    /**\n     * The dictionary size or zero if no dictionary.\n     */\n    size_t dictionarySize;\n    /**\n     * The uncompressed size of the data.\n     */\n    size_t uncompressedSize;\n    /**\n     * The compressed size of the data.\n     */\n    size_t compressedSize;\n    /**\n     * The fully resolved CCtx parameters (NULL on decompression).\n     */\n    struct ZSTD_CCtx_params_s const* params;\n    /**\n     * The ZSTD_CCtx pointer (NULL on decompression).\n     */\n    struct ZSTD_CCtx_s const* cctx;\n    /**\n     * The ZSTD_DCtx pointer (NULL on compression).\n     */\n    struct ZSTD_DCtx_s const* dctx;\n} ZSTD_Trace;\n\n/**\n * A tracing context. It must be 0 when tracing is disabled.\n * Otherwise, any non-zero value returned by a tracing begin()\n * function is presented to any subsequent calls to end().\n *\n * Any non-zero value is treated as tracing is enabled and not\n * interpreted by the library.\n *\n * Two possible uses are:\n * * A timestamp for when the begin() function was called.\n * * A unique key identifying the (de)compression, like the\n *   address of the [dc]ctx pointer if you need to track\n *   more information than just a timestamp.\n */\ntypedef unsigned long long ZSTD_TraceCtx;\n\n/**\n * Trace the beginning of a compression call.\n * @param cctx The dctx pointer for the compression.\n *             It can be used as a key to map begin() to end().\n * @returns Non-zero if tracing is enabled. The return value is\n *          passed to ZSTD_trace_compress_end().\n */\nZSTD_WEAK_ATTR ZSTD_TraceCtx ZSTD_trace_compress_begin(\n    struct ZSTD_CCtx_s const* cctx);\n\n/**\n * Trace the end of a compression call.\n * @param ctx The return value of ZSTD_trace_compress_begin().\n * @param trace The zstd tracing info.\n */\nZSTD_WEAK_ATTR void ZSTD_trace_compress_end(\n    ZSTD_TraceCtx ctx,\n    ZSTD_Trace const* trace);\n\n/**\n * Trace the beginning of a decompression call.\n * @param dctx The dctx pointer for the decompression.\n *             It can be used as a key to map begin() to end().\n * @returns Non-zero if tracing is enabled. The return value is\n *          passed to ZSTD_trace_compress_end().\n */\nZSTD_WEAK_ATTR ZSTD_TraceCtx ZSTD_trace_decompress_begin(\n    struct ZSTD_DCtx_s const* dctx);\n\n/**\n * Trace the end of a decompression call.\n * @param ctx The return value of ZSTD_trace_decompress_begin().\n * @param trace The zstd tracing info.\n */\nZSTD_WEAK_ATTR void ZSTD_trace_decompress_end(\n    ZSTD_TraceCtx ctx,\n    ZSTD_Trace const* trace);\n\n#endif /* ZSTD_TRACE */\n\n#endif /* ZSTD_TRACE_H */\n"
  },
  {
    "path": "lib/compress/clevels.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_CLEVELS_H\n#define ZSTD_CLEVELS_H\n\n#define ZSTD_STATIC_LINKING_ONLY  /* ZSTD_compressionParameters  */\n#include \"../zstd.h\"\n\n/*-=====  Pre-defined compression levels  =====-*/\n\n#define ZSTD_MAX_CLEVEL     22\n\n#ifdef __GNUC__\n__attribute__((__unused__))\n#endif\n\nstatic const ZSTD_compressionParameters ZSTD_defaultCParameters[4][ZSTD_MAX_CLEVEL+1] = {\n{   /* \"default\" - for any srcSize > 256 KB */\n    /* W,  C,  H,  S,  L, TL, strat */\n    { 19, 12, 13,  1,  6,  1, ZSTD_fast    },  /* base for negative levels */\n    { 19, 13, 14,  1,  7,  0, ZSTD_fast    },  /* level  1 */\n    { 20, 15, 16,  1,  6,  0, ZSTD_fast    },  /* level  2 */\n    { 21, 16, 17,  1,  5,  0, ZSTD_dfast   },  /* level  3 */\n    { 21, 18, 18,  1,  5,  0, ZSTD_dfast   },  /* level  4 */\n    { 21, 18, 19,  3,  5,  2, ZSTD_greedy  },  /* level  5 */\n    { 21, 18, 19,  3,  5,  4, ZSTD_lazy    },  /* level  6 */\n    { 21, 19, 20,  4,  5,  8, ZSTD_lazy    },  /* level  7 */\n    { 21, 19, 20,  4,  5, 16, ZSTD_lazy2   },  /* level  8 */\n    { 22, 20, 21,  4,  5, 16, ZSTD_lazy2   },  /* level  9 */\n    { 22, 21, 22,  5,  5, 16, ZSTD_lazy2   },  /* level 10 */\n    { 22, 21, 22,  6,  5, 16, ZSTD_lazy2   },  /* level 11 */\n    { 22, 22, 23,  6,  5, 32, ZSTD_lazy2   },  /* level 12 */\n    { 22, 22, 22,  4,  5, 32, ZSTD_btlazy2 },  /* level 13 */\n    { 22, 22, 23,  5,  5, 32, ZSTD_btlazy2 },  /* level 14 */\n    { 22, 23, 23,  6,  5, 32, ZSTD_btlazy2 },  /* level 15 */\n    { 22, 22, 22,  5,  5, 48, ZSTD_btopt   },  /* level 16 */\n    { 23, 23, 22,  5,  4, 64, ZSTD_btopt   },  /* level 17 */\n    { 23, 23, 22,  6,  3, 64, ZSTD_btultra },  /* level 18 */\n    { 23, 24, 22,  7,  3,256, ZSTD_btultra2},  /* level 19 */\n    { 25, 25, 23,  7,  3,256, ZSTD_btultra2},  /* level 20 */\n    { 26, 26, 24,  7,  3,512, ZSTD_btultra2},  /* level 21 */\n    { 27, 27, 25,  9,  3,999, ZSTD_btultra2},  /* level 22 */\n},\n{   /* for srcSize <= 256 KB */\n    /* W,  C,  H,  S,  L,  T, strat */\n    { 18, 12, 13,  1,  5,  1, ZSTD_fast    },  /* base for negative levels */\n    { 18, 13, 14,  1,  6,  0, ZSTD_fast    },  /* level  1 */\n    { 18, 14, 14,  1,  5,  0, ZSTD_dfast   },  /* level  2 */\n    { 18, 16, 16,  1,  4,  0, ZSTD_dfast   },  /* level  3 */\n    { 18, 16, 17,  3,  5,  2, ZSTD_greedy  },  /* level  4.*/\n    { 18, 17, 18,  5,  5,  2, ZSTD_greedy  },  /* level  5.*/\n    { 18, 18, 19,  3,  5,  4, ZSTD_lazy    },  /* level  6.*/\n    { 18, 18, 19,  4,  4,  4, ZSTD_lazy    },  /* level  7 */\n    { 18, 18, 19,  4,  4,  8, ZSTD_lazy2   },  /* level  8 */\n    { 18, 18, 19,  5,  4,  8, ZSTD_lazy2   },  /* level  9 */\n    { 18, 18, 19,  6,  4,  8, ZSTD_lazy2   },  /* level 10 */\n    { 18, 18, 19,  5,  4, 12, ZSTD_btlazy2 },  /* level 11.*/\n    { 18, 19, 19,  7,  4, 12, ZSTD_btlazy2 },  /* level 12.*/\n    { 18, 18, 19,  4,  4, 16, ZSTD_btopt   },  /* level 13 */\n    { 18, 18, 19,  4,  3, 32, ZSTD_btopt   },  /* level 14.*/\n    { 18, 18, 19,  6,  3,128, ZSTD_btopt   },  /* level 15.*/\n    { 18, 19, 19,  6,  3,128, ZSTD_btultra },  /* level 16.*/\n    { 18, 19, 19,  8,  3,256, ZSTD_btultra },  /* level 17.*/\n    { 18, 19, 19,  6,  3,128, ZSTD_btultra2},  /* level 18.*/\n    { 18, 19, 19,  8,  3,256, ZSTD_btultra2},  /* level 19.*/\n    { 18, 19, 19, 10,  3,512, ZSTD_btultra2},  /* level 20.*/\n    { 18, 19, 19, 12,  3,512, ZSTD_btultra2},  /* level 21.*/\n    { 18, 19, 19, 13,  3,999, ZSTD_btultra2},  /* level 22.*/\n},\n{   /* for srcSize <= 128 KB */\n    /* W,  C,  H,  S,  L,  T, strat */\n    { 17, 12, 12,  1,  5,  1, ZSTD_fast    },  /* base for negative levels */\n    { 17, 12, 13,  1,  6,  0, ZSTD_fast    },  /* level  1 */\n    { 17, 13, 15,  1,  5,  0, ZSTD_fast    },  /* level  2 */\n    { 17, 15, 16,  2,  5,  0, ZSTD_dfast   },  /* level  3 */\n    { 17, 17, 17,  2,  4,  0, ZSTD_dfast   },  /* level  4 */\n    { 17, 16, 17,  3,  4,  2, ZSTD_greedy  },  /* level  5 */\n    { 17, 16, 17,  3,  4,  4, ZSTD_lazy    },  /* level  6 */\n    { 17, 16, 17,  3,  4,  8, ZSTD_lazy2   },  /* level  7 */\n    { 17, 16, 17,  4,  4,  8, ZSTD_lazy2   },  /* level  8 */\n    { 17, 16, 17,  5,  4,  8, ZSTD_lazy2   },  /* level  9 */\n    { 17, 16, 17,  6,  4,  8, ZSTD_lazy2   },  /* level 10 */\n    { 17, 17, 17,  5,  4,  8, ZSTD_btlazy2 },  /* level 11 */\n    { 17, 18, 17,  7,  4, 12, ZSTD_btlazy2 },  /* level 12 */\n    { 17, 18, 17,  3,  4, 12, ZSTD_btopt   },  /* level 13.*/\n    { 17, 18, 17,  4,  3, 32, ZSTD_btopt   },  /* level 14.*/\n    { 17, 18, 17,  6,  3,256, ZSTD_btopt   },  /* level 15.*/\n    { 17, 18, 17,  6,  3,128, ZSTD_btultra },  /* level 16.*/\n    { 17, 18, 17,  8,  3,256, ZSTD_btultra },  /* level 17.*/\n    { 17, 18, 17, 10,  3,512, ZSTD_btultra },  /* level 18.*/\n    { 17, 18, 17,  5,  3,256, ZSTD_btultra2},  /* level 19.*/\n    { 17, 18, 17,  7,  3,512, ZSTD_btultra2},  /* level 20.*/\n    { 17, 18, 17,  9,  3,512, ZSTD_btultra2},  /* level 21.*/\n    { 17, 18, 17, 11,  3,999, ZSTD_btultra2},  /* level 22.*/\n},\n{   /* for srcSize <= 16 KB */\n    /* W,  C,  H,  S,  L,  T, strat */\n    { 14, 12, 13,  1,  5,  1, ZSTD_fast    },  /* base for negative levels */\n    { 14, 14, 15,  1,  5,  0, ZSTD_fast    },  /* level  1 */\n    { 14, 14, 15,  1,  4,  0, ZSTD_fast    },  /* level  2 */\n    { 14, 14, 15,  2,  4,  0, ZSTD_dfast   },  /* level  3 */\n    { 14, 14, 14,  4,  4,  2, ZSTD_greedy  },  /* level  4 */\n    { 14, 14, 14,  3,  4,  4, ZSTD_lazy    },  /* level  5.*/\n    { 14, 14, 14,  4,  4,  8, ZSTD_lazy2   },  /* level  6 */\n    { 14, 14, 14,  6,  4,  8, ZSTD_lazy2   },  /* level  7 */\n    { 14, 14, 14,  8,  4,  8, ZSTD_lazy2   },  /* level  8.*/\n    { 14, 15, 14,  5,  4,  8, ZSTD_btlazy2 },  /* level  9.*/\n    { 14, 15, 14,  9,  4,  8, ZSTD_btlazy2 },  /* level 10.*/\n    { 14, 15, 14,  3,  4, 12, ZSTD_btopt   },  /* level 11.*/\n    { 14, 15, 14,  4,  3, 24, ZSTD_btopt   },  /* level 12.*/\n    { 14, 15, 14,  5,  3, 32, ZSTD_btultra },  /* level 13.*/\n    { 14, 15, 15,  6,  3, 64, ZSTD_btultra },  /* level 14.*/\n    { 14, 15, 15,  7,  3,256, ZSTD_btultra },  /* level 15.*/\n    { 14, 15, 15,  5,  3, 48, ZSTD_btultra2},  /* level 16.*/\n    { 14, 15, 15,  6,  3,128, ZSTD_btultra2},  /* level 17.*/\n    { 14, 15, 15,  7,  3,256, ZSTD_btultra2},  /* level 18.*/\n    { 14, 15, 15,  8,  3,256, ZSTD_btultra2},  /* level 19.*/\n    { 14, 15, 15,  8,  3,512, ZSTD_btultra2},  /* level 20.*/\n    { 14, 15, 15,  9,  3,512, ZSTD_btultra2},  /* level 21.*/\n    { 14, 15, 15, 10,  3,999, ZSTD_btultra2},  /* level 22.*/\n},\n};\n\n\n\n#endif  /* ZSTD_CLEVELS_H */\n"
  },
  {
    "path": "lib/compress/fse_compress.c",
    "content": "/* ******************************************************************\n * FSE : Finite State Entropy encoder\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n *  You can contact the author at :\n *  - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy\n *  - Public forum : https://groups.google.com/forum/#!forum/lz4c\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n****************************************************************** */\n\n/* **************************************************************\n*  Includes\n****************************************************************/\n#include \"../common/compiler.h\"\n#include \"../common/mem.h\"        /* U32, U16, etc. */\n#include \"../common/debug.h\"      /* assert, DEBUGLOG */\n#include \"hist.h\"       /* HIST_count_wksp */\n#include \"../common/bitstream.h\"\n#define FSE_STATIC_LINKING_ONLY\n#include \"../common/fse.h\"\n#include \"../common/error_private.h\"\n#define ZSTD_DEPS_NEED_MALLOC\n#define ZSTD_DEPS_NEED_MATH64\n#include \"../common/zstd_deps.h\"  /* ZSTD_memset */\n#include \"../common/bits.h\" /* ZSTD_highbit32 */\n\n\n/* **************************************************************\n*  Error Management\n****************************************************************/\n#define FSE_isError ERR_isError\n\n\n/* **************************************************************\n*  Templates\n****************************************************************/\n/*\n  designed to be included\n  for type-specific functions (template emulation in C)\n  Objective is to write these functions only once, for improved maintenance\n*/\n\n/* safety checks */\n#ifndef FSE_FUNCTION_EXTENSION\n#  error \"FSE_FUNCTION_EXTENSION must be defined\"\n#endif\n#ifndef FSE_FUNCTION_TYPE\n#  error \"FSE_FUNCTION_TYPE must be defined\"\n#endif\n\n/* Function names */\n#define FSE_CAT(X,Y) X##Y\n#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)\n#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)\n\n\n/* Function templates */\n\n/* FSE_buildCTable_wksp() :\n * Same as FSE_buildCTable(), but using an externally allocated scratch buffer (`workSpace`).\n * wkspSize should be sized to handle worst case situation, which is `1<>1 : 1) ;\n    FSE_symbolCompressionTransform* const symbolTT = (FSE_symbolCompressionTransform*) (FSCT);\n    U32 const step = FSE_TABLESTEP(tableSize);\n    U32 const maxSV1 = maxSymbolValue+1;\n\n    U16* cumul = (U16*)workSpace;   /* size = maxSV1 */\n    FSE_FUNCTION_TYPE* const tableSymbol = (FSE_FUNCTION_TYPE*)(cumul + (maxSV1+1));  /* size = tableSize */\n\n    U32 highThreshold = tableSize-1;\n\n    assert(((size_t)workSpace & 1) == 0);  /* Must be 2 bytes-aligned */\n    if (FSE_BUILD_CTABLE_WORKSPACE_SIZE(maxSymbolValue, tableLog) > wkspSize) return ERROR(tableLog_tooLarge);\n    /* CTable header */\n    tableU16[-2] = (U16) tableLog;\n    tableU16[-1] = (U16) maxSymbolValue;\n    assert(tableLog < 16);   /* required for threshold strategy to work */\n\n    /* For explanations on how to distribute symbol values over the table :\n     * https://fastcompression.blogspot.fr/2014/02/fse-distributing-symbol-values.html */\n\n     #ifdef __clang_analyzer__\n     ZSTD_memset(tableSymbol, 0, sizeof(*tableSymbol) * tableSize);   /* useless initialization, just to keep scan-build happy */\n     #endif\n\n    /* symbol start positions */\n    {   U32 u;\n        cumul[0] = 0;\n        for (u=1; u <= maxSV1; u++) {\n            if (normalizedCounter[u-1]==-1) {  /* Low proba symbol */\n                cumul[u] = cumul[u-1] + 1;\n                tableSymbol[highThreshold--] = (FSE_FUNCTION_TYPE)(u-1);\n            } else {\n                assert(normalizedCounter[u-1] >= 0);\n                cumul[u] = cumul[u-1] + (U16)normalizedCounter[u-1];\n                assert(cumul[u] >= cumul[u-1]);  /* no overflow */\n        }   }\n        cumul[maxSV1] = (U16)(tableSize+1);\n    }\n\n    /* Spread symbols */\n    if (highThreshold == tableSize - 1) {\n        /* Case for no low prob count symbols. Lay down 8 bytes at a time\n         * to reduce branch misses since we are operating on a small block\n         */\n        BYTE* const spread = tableSymbol + tableSize; /* size = tableSize + 8 (may write beyond tableSize) */\n        {   U64 const add = 0x0101010101010101ull;\n            size_t pos = 0;\n            U64 sv = 0;\n            U32 s;\n            for (s=0; s=0);\n                pos += (size_t)n;\n            }\n        }\n        /* Spread symbols across the table. Lack of lowprob symbols means that\n         * we don't need variable sized inner loop, so we can unroll the loop and\n         * reduce branch misses.\n         */\n        {   size_t position = 0;\n            size_t s;\n            size_t const unroll = 2; /* Experimentally determined optimal unroll */\n            assert(tableSize % unroll == 0); /* FSE_MIN_TABLELOG is 5 */\n            for (s = 0; s < (size_t)tableSize; s += unroll) {\n                size_t u;\n                for (u = 0; u < unroll; ++u) {\n                    size_t const uPosition = (position + (u * step)) & tableMask;\n                    tableSymbol[uPosition] = spread[s + u];\n                }\n                position = (position + (unroll * step)) & tableMask;\n            }\n            assert(position == 0);   /* Must have initialized all positions */\n        }\n    } else {\n        U32 position = 0;\n        U32 symbol;\n        for (symbol=0; symbol highThreshold)\n                    position = (position + step) & tableMask;   /* Low proba area */\n        }   }\n        assert(position==0);  /* Must have initialized all positions */\n    }\n\n    /* Build table */\n    {   U32 u; for (u=0; u 1);\n                {   U32 const maxBitsOut = tableLog - ZSTD_highbit32 ((U32)normalizedCounter[s]-1);\n                    U32 const minStatePlus = (U32)normalizedCounter[s] << maxBitsOut;\n                    symbolTT[s].deltaNbBits = (maxBitsOut << 16) - minStatePlus;\n                    symbolTT[s].deltaFindState = (int)(total - (unsigned)normalizedCounter[s]);\n                    total +=  (unsigned)normalizedCounter[s];\n    }   }   }   }\n\n#if 0  /* debug : symbol costs */\n    DEBUGLOG(5, \"\\n --- table statistics : \");\n    {   U32 symbol;\n        for (symbol=0; symbol<=maxSymbolValue; symbol++) {\n            DEBUGLOG(5, \"%3u: w=%3i,   maxBits=%u, fracBits=%.2f\",\n                symbol, normalizedCounter[symbol],\n                FSE_getMaxNbBits(symbolTT, symbol),\n                (double)FSE_bitCost(symbolTT, tableLog, symbol, 8) / 256);\n    }   }\n#endif\n\n    return 0;\n}\n\n\n\n#ifndef FSE_COMMONDEFS_ONLY\n\n/*-**************************************************************\n*  FSE NCount encoding\n****************************************************************/\nsize_t FSE_NCountWriteBound(unsigned maxSymbolValue, unsigned tableLog)\n{\n    size_t const maxHeaderSize = (((maxSymbolValue+1) * tableLog\n                                   + 4 /* bitCount initialized at 4 */\n                                   + 2 /* first two symbols may use one additional bit each */) / 8)\n                                   + 1 /* round up to whole nb bytes */\n                                   + 2 /* additional two bytes for bitstream flush */;\n    return maxSymbolValue ? maxHeaderSize : FSE_NCOUNTBOUND;  /* maxSymbolValue==0 ? use default */\n}\n\nstatic size_t\nFSE_writeNCount_generic (void* header, size_t headerBufferSize,\n                   const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog,\n                         unsigned writeIsSafe)\n{\n    BYTE* const ostart = (BYTE*) header;\n    BYTE* out = ostart;\n    BYTE* const oend = ostart + headerBufferSize;\n    int nbBits;\n    const int tableSize = 1 << tableLog;\n    int remaining;\n    int threshold;\n    U32 bitStream = 0;\n    int bitCount = 0;\n    unsigned symbol = 0;\n    unsigned const alphabetSize = maxSymbolValue + 1;\n    int previousIs0 = 0;\n\n    /* Table Size */\n    bitStream += (tableLog-FSE_MIN_TABLELOG) << bitCount;\n    bitCount  += 4;\n\n    /* Init */\n    remaining = tableSize+1;   /* +1 for extra accuracy */\n    threshold = tableSize;\n    nbBits = (int)tableLog+1;\n\n    while ((symbol < alphabetSize) && (remaining>1)) {  /* stops at 1 */\n        if (previousIs0) {\n            unsigned start = symbol;\n            while ((symbol < alphabetSize) && !normalizedCounter[symbol]) symbol++;\n            if (symbol == alphabetSize) break;   /* incorrect distribution */\n            while (symbol >= start+24) {\n                start+=24;\n                bitStream += 0xFFFFU << bitCount;\n                if ((!writeIsSafe) && (out > oend-2))\n                    return ERROR(dstSize_tooSmall);   /* Buffer overflow */\n                out[0] = (BYTE) bitStream;\n                out[1] = (BYTE)(bitStream>>8);\n                out+=2;\n                bitStream>>=16;\n            }\n            while (symbol >= start+3) {\n                start+=3;\n                bitStream += 3U << bitCount;\n                bitCount += 2;\n            }\n            bitStream += (symbol-start) << bitCount;\n            bitCount += 2;\n            if (bitCount>16) {\n                if ((!writeIsSafe) && (out > oend - 2))\n                    return ERROR(dstSize_tooSmall);   /* Buffer overflow */\n                out[0] = (BYTE)bitStream;\n                out[1] = (BYTE)(bitStream>>8);\n                out += 2;\n                bitStream >>= 16;\n                bitCount -= 16;\n        }   }\n        {   int count = normalizedCounter[symbol++];\n            int const max = (2*threshold-1) - remaining;\n            remaining -= count < 0 ? -count : count;\n            count++;   /* +1 for extra accuracy */\n            if (count>=threshold)\n                count += max;   /* [0..max[ [max..threshold[ (...) [threshold+max 2*threshold[ */\n            bitStream += (U32)count << bitCount;\n            bitCount  += nbBits;\n            bitCount  -= (count>=1; }\n        }\n        if (bitCount>16) {\n            if ((!writeIsSafe) && (out > oend - 2))\n                return ERROR(dstSize_tooSmall);   /* Buffer overflow */\n            out[0] = (BYTE)bitStream;\n            out[1] = (BYTE)(bitStream>>8);\n            out += 2;\n            bitStream >>= 16;\n            bitCount -= 16;\n    }   }\n\n    if (remaining != 1)\n        return ERROR(GENERIC);  /* incorrect normalized distribution */\n    assert(symbol <= alphabetSize);\n\n    /* flush remaining bitStream */\n    if ((!writeIsSafe) && (out > oend - 2))\n        return ERROR(dstSize_tooSmall);   /* Buffer overflow */\n    out[0] = (BYTE)bitStream;\n    out[1] = (BYTE)(bitStream>>8);\n    out+= (bitCount+7) /8;\n\n    assert(out >= ostart);\n    return (size_t)(out-ostart);\n}\n\n\nsize_t FSE_writeNCount (void* buffer, size_t bufferSize,\n                  const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)\n{\n    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);   /* Unsupported */\n    if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC);   /* Unsupported */\n\n    if (bufferSize < FSE_NCountWriteBound(maxSymbolValue, tableLog))\n        return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 0);\n\n    return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 1 /* write in buffer is safe */);\n}\n\n\n/*-**************************************************************\n*  FSE Compression Code\n****************************************************************/\n\n/* provides the minimum logSize to safely represent a distribution */\nstatic unsigned FSE_minTableLog(size_t srcSize, unsigned maxSymbolValue)\n{\n    U32 minBitsSrc = ZSTD_highbit32((U32)(srcSize)) + 1;\n    U32 minBitsSymbols = ZSTD_highbit32(maxSymbolValue) + 2;\n    U32 minBits = minBitsSrc < minBitsSymbols ? minBitsSrc : minBitsSymbols;\n    assert(srcSize > 1); /* Not supported, RLE should be used instead */\n    return minBits;\n}\n\nunsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus)\n{\n    U32 maxBitsSrc = ZSTD_highbit32((U32)(srcSize - 1)) - minus;\n    U32 tableLog = maxTableLog;\n    U32 minBits = FSE_minTableLog(srcSize, maxSymbolValue);\n    assert(srcSize > 1); /* Not supported, RLE should be used instead */\n    if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG;\n    if (maxBitsSrc < tableLog) tableLog = maxBitsSrc;   /* Accuracy can be reduced */\n    if (minBits > tableLog) tableLog = minBits;   /* Need a minimum to safely represent all symbol values */\n    if (tableLog < FSE_MIN_TABLELOG) tableLog = FSE_MIN_TABLELOG;\n    if (tableLog > FSE_MAX_TABLELOG) tableLog = FSE_MAX_TABLELOG;\n    return tableLog;\n}\n\nunsigned FSE_optimalTableLog(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue)\n{\n    return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 2);\n}\n\n/* Secondary normalization method.\n   To be used when primary method fails. */\n\nstatic size_t FSE_normalizeM2(short* norm, U32 tableLog, const unsigned* count, size_t total, U32 maxSymbolValue, short lowProbCount)\n{\n    short const NOT_YET_ASSIGNED = -2;\n    U32 s;\n    U32 distributed = 0;\n    U32 ToDistribute;\n\n    /* Init */\n    U32 const lowThreshold = (U32)(total >> tableLog);\n    U32 lowOne = (U32)((total * 3) >> (tableLog + 1));\n\n    for (s=0; s<=maxSymbolValue; s++) {\n        if (count[s] == 0) {\n            norm[s]=0;\n            continue;\n        }\n        if (count[s] <= lowThreshold) {\n            norm[s] = lowProbCount;\n            distributed++;\n            total -= count[s];\n            continue;\n        }\n        if (count[s] <= lowOne) {\n            norm[s] = 1;\n            distributed++;\n            total -= count[s];\n            continue;\n        }\n\n        norm[s]=NOT_YET_ASSIGNED;\n    }\n    ToDistribute = (1 << tableLog) - distributed;\n\n    if (ToDistribute == 0)\n        return 0;\n\n    if ((total / ToDistribute) > lowOne) {\n        /* risk of rounding to zero */\n        lowOne = (U32)((total * 3) / (ToDistribute * 2));\n        for (s=0; s<=maxSymbolValue; s++) {\n            if ((norm[s] == NOT_YET_ASSIGNED) && (count[s] <= lowOne)) {\n                norm[s] = 1;\n                distributed++;\n                total -= count[s];\n                continue;\n        }   }\n        ToDistribute = (1 << tableLog) - distributed;\n    }\n\n    if (distributed == maxSymbolValue+1) {\n        /* all values are pretty poor;\n           probably incompressible data (should have already been detected);\n           find max, then give all remaining points to max */\n        U32 maxV = 0, maxC = 0;\n        for (s=0; s<=maxSymbolValue; s++)\n            if (count[s] > maxC) { maxV=s; maxC=count[s]; }\n        norm[maxV] += (short)ToDistribute;\n        return 0;\n    }\n\n    if (total == 0) {\n        /* all of the symbols were low enough for the lowOne or lowThreshold */\n        for (s=0; ToDistribute > 0; s = (s+1)%(maxSymbolValue+1))\n            if (norm[s] > 0) { ToDistribute--; norm[s]++; }\n        return 0;\n    }\n\n    {   U64 const vStepLog = 62 - tableLog;\n        U64 const mid = (1ULL << (vStepLog-1)) - 1;\n        U64 const rStep = ZSTD_div64((((U64)1<> vStepLog);\n                U32 const sEnd = (U32)(end >> vStepLog);\n                U32 const weight = sEnd - sStart;\n                if (weight < 1)\n                    return ERROR(GENERIC);\n                norm[s] = (short)weight;\n                tmpTotal = end;\n    }   }   }\n\n    return 0;\n}\n\nsize_t FSE_normalizeCount (short* normalizedCounter, unsigned tableLog,\n                           const unsigned* count, size_t total,\n                           unsigned maxSymbolValue, unsigned useLowProbCount)\n{\n    /* Sanity checks */\n    if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG;\n    if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC);   /* Unsupported size */\n    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);   /* Unsupported size */\n    if (tableLog < FSE_minTableLog(total, maxSymbolValue)) return ERROR(GENERIC);   /* Too small tableLog, compression potentially impossible */\n\n    {   static U32 const rtbTable[] = {     0, 473195, 504333, 520860, 550000, 700000, 750000, 830000 };\n        short const lowProbCount = useLowProbCount ? -1 : 1;\n        U64 const scale = 62 - tableLog;\n        U64 const step = ZSTD_div64((U64)1<<62, (U32)total);   /* <== here, one division ! */\n        U64 const vStep = 1ULL<<(scale-20);\n        int stillToDistribute = 1<> tableLog);\n\n        for (s=0; s<=maxSymbolValue; s++) {\n            if (count[s] == total) return 0;   /* rle special case */\n            if (count[s] == 0) { normalizedCounter[s]=0; continue; }\n            if (count[s] <= lowThreshold) {\n                normalizedCounter[s] = lowProbCount;\n                stillToDistribute--;\n            } else {\n                short proba = (short)((count[s]*step) >> scale);\n                if (proba<8) {\n                    U64 restToBeat = vStep * rtbTable[proba];\n                    proba += (count[s]*step) - ((U64)proba< restToBeat;\n                }\n                if (proba > largestP) { largestP=proba; largest=s; }\n                normalizedCounter[s] = proba;\n                stillToDistribute -= proba;\n        }   }\n        if (-stillToDistribute >= (normalizedCounter[largest] >> 1)) {\n            /* corner case, need another normalization method */\n            size_t const errorCode = FSE_normalizeM2(normalizedCounter, tableLog, count, total, maxSymbolValue, lowProbCount);\n            if (FSE_isError(errorCode)) return errorCode;\n        }\n        else normalizedCounter[largest] += (short)stillToDistribute;\n    }\n\n#if 0\n    {   /* Print Table (debug) */\n        U32 s;\n        U32 nTotal = 0;\n        for (s=0; s<=maxSymbolValue; s++)\n            RAWLOG(2, \"%3i: %4i \\n\", s, normalizedCounter[s]);\n        for (s=0; s<=maxSymbolValue; s++)\n            nTotal += abs(normalizedCounter[s]);\n        if (nTotal != (1U< FSE_MAX_TABLELOG*4+7 ) && (srcSize & 2)) {  /* test bit 2 */\n        FSE_encodeSymbol(&bitC, &CState2, *--ip);\n        FSE_encodeSymbol(&bitC, &CState1, *--ip);\n        FSE_FLUSHBITS(&bitC);\n    }\n\n    /* 2 or 4 encoding per loop */\n    while ( ip>istart ) {\n\n        FSE_encodeSymbol(&bitC, &CState2, *--ip);\n\n        if (sizeof(bitC.bitContainer)*8 < FSE_MAX_TABLELOG*2+7 )   /* this test must be static */\n            FSE_FLUSHBITS(&bitC);\n\n        FSE_encodeSymbol(&bitC, &CState1, *--ip);\n\n        if (sizeof(bitC.bitContainer)*8 > FSE_MAX_TABLELOG*4+7 ) {  /* this test must be static */\n            FSE_encodeSymbol(&bitC, &CState2, *--ip);\n            FSE_encodeSymbol(&bitC, &CState1, *--ip);\n        }\n\n        FSE_FLUSHBITS(&bitC);\n    }\n\n    FSE_flushCState(&bitC, &CState2);\n    FSE_flushCState(&bitC, &CState1);\n    return BIT_closeCStream(&bitC);\n}\n\nsize_t FSE_compress_usingCTable (void* dst, size_t dstSize,\n                           const void* src, size_t srcSize,\n                           const FSE_CTable* ct)\n{\n    unsigned const fast = (dstSize >= FSE_BLOCKBOUND(srcSize));\n\n    if (fast)\n        return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 1);\n    else\n        return FSE_compress_usingCTable_generic(dst, dstSize, src, srcSize, ct, 0);\n}\n\n\nsize_t FSE_compressBound(size_t size) { return FSE_COMPRESSBOUND(size); }\n\n#endif   /* FSE_COMMONDEFS_ONLY */\n"
  },
  {
    "path": "lib/compress/hist.c",
    "content": "/* ******************************************************************\n * hist : Histogram functions\n * part of Finite State Entropy project\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n *  You can contact the author at :\n *  - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy\n *  - Public forum : https://groups.google.com/forum/#!forum/lz4c\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n****************************************************************** */\n\n/* --- dependencies --- */\n#include \"../common/mem.h\"             /* U32, BYTE, etc. */\n#include \"../common/debug.h\"           /* assert, DEBUGLOG */\n#include \"../common/error_private.h\"   /* ERROR */\n#include \"hist.h\"\n\n#if defined(ZSTD_ARCH_ARM_SVE2)\n#define HIST_FAST_THRESHOLD 500\n#else\n#define HIST_FAST_THRESHOLD 1500\n#endif\n\n\n/* --- Error management --- */\nunsigned HIST_isError(size_t code) { return ERR_isError(code); }\n\n/*-**************************************************************\n *  Histogram functions\n ****************************************************************/\nvoid HIST_add(unsigned* count, const void* src, size_t srcSize)\n{\n    const BYTE* ip = (const BYTE*)src;\n    const BYTE* const end = ip + srcSize;\n\n    while (ip largestCount) largestCount = count[s];\n    }\n\n    return largestCount;\n}\n\ntypedef enum { trustInput, checkMaxSymbolValue } HIST_checkInput_e;\n\n#if defined(ZSTD_ARCH_ARM_SVE2)\nFORCE_INLINE_TEMPLATE size_t min_size(size_t a, size_t b) { return a < b ? a : b; }\n\nstatic\nsvuint16_t HIST_count_6_sve2(const BYTE* const src, size_t size, U32* const dst,\n                             const svuint8_t c0, const svuint8_t c1,\n                             const svuint8_t c2, const svuint8_t c3,\n                             const svuint8_t c4, const svuint8_t c5,\n                             const svuint16_t histmax, size_t maxCount)\n{\n    const svbool_t vl128 = svptrue_pat_b8(SV_VL16);\n    svuint16_t hh0 = svdup_n_u16(0);\n    svuint16_t hh1 = svdup_n_u16(0);\n    svuint16_t hh2 = svdup_n_u16(0);\n    svuint16_t hh3 = svdup_n_u16(0);\n    svuint16_t hh4 = svdup_n_u16(0);\n    svuint16_t hh5 = svdup_n_u16(0);\n    svuint16_t hh6 = svdup_n_u16(0);\n    svuint16_t hh7 = svdup_n_u16(0);\n    svuint16_t hh8 = svdup_n_u16(0);\n    svuint16_t hh9 = svdup_n_u16(0);\n    svuint16_t hha = svdup_n_u16(0);\n    svuint16_t hhb = svdup_n_u16(0);\n\n    size_t i = 0;\n    while (i < size) {\n        /* We can only accumulate 15 (15 * 16 <= 255) iterations of histogram\n         * in 8-bit accumulators! */\n        const size_t size240 = min_size(i + 240, size);\n\n        svbool_t pred = svwhilelt_b8_u64(i, size);\n        svuint8_t c = svld1rq_u8(pred, src + i);\n        svuint8_t h0 = svhistseg_u8(c0, c);\n        svuint8_t h1 = svhistseg_u8(c1, c);\n        svuint8_t h2 = svhistseg_u8(c2, c);\n        svuint8_t h3 = svhistseg_u8(c3, c);\n        svuint8_t h4 = svhistseg_u8(c4, c);\n        svuint8_t h5 = svhistseg_u8(c5, c);\n\n        for (i += 16; i < size240; i += 16) {\n            pred = svwhilelt_b8_u64(i, size);\n            c = svld1rq_u8(pred, src + i);\n            h0 = svadd_u8_x(vl128, h0, svhistseg_u8(c0, c));\n            h1 = svadd_u8_x(vl128, h1, svhistseg_u8(c1, c));\n            h2 = svadd_u8_x(vl128, h2, svhistseg_u8(c2, c));\n            h3 = svadd_u8_x(vl128, h3, svhistseg_u8(c3, c));\n            h4 = svadd_u8_x(vl128, h4, svhistseg_u8(c4, c));\n            h5 = svadd_u8_x(vl128, h5, svhistseg_u8(c5, c));\n        }\n\n        hh0 = svaddwb_u16(hh0, h0);\n        hh1 = svaddwt_u16(hh1, h0);\n        hh2 = svaddwb_u16(hh2, h1);\n        hh3 = svaddwt_u16(hh3, h1);\n        hh4 = svaddwb_u16(hh4, h2);\n        hh5 = svaddwt_u16(hh5, h2);\n        hh6 = svaddwb_u16(hh6, h3);\n        hh7 = svaddwt_u16(hh7, h3);\n        hh8 = svaddwb_u16(hh8, h4);\n        hh9 = svaddwt_u16(hh9, h4);\n        hha = svaddwb_u16(hha, h5);\n        hhb = svaddwt_u16(hhb, h5);\n    }\n\n    svst1_u32(svwhilelt_b32_u64( 0, maxCount), dst +  0, svshllb_n_u32(hh0, 0));\n    svst1_u32(svwhilelt_b32_u64( 4, maxCount), dst +  4, svshllt_n_u32(hh0, 0));\n    svst1_u32(svwhilelt_b32_u64( 8, maxCount), dst +  8, svshllb_n_u32(hh1, 0));\n    svst1_u32(svwhilelt_b32_u64(12, maxCount), dst + 12, svshllt_n_u32(hh1, 0));\n    svst1_u32(svwhilelt_b32_u64(16, maxCount), dst + 16, svshllb_n_u32(hh2, 0));\n    svst1_u32(svwhilelt_b32_u64(20, maxCount), dst + 20, svshllt_n_u32(hh2, 0));\n    svst1_u32(svwhilelt_b32_u64(24, maxCount), dst + 24, svshllb_n_u32(hh3, 0));\n    svst1_u32(svwhilelt_b32_u64(28, maxCount), dst + 28, svshllt_n_u32(hh3, 0));\n    svst1_u32(svwhilelt_b32_u64(32, maxCount), dst + 32, svshllb_n_u32(hh4, 0));\n    svst1_u32(svwhilelt_b32_u64(36, maxCount), dst + 36, svshllt_n_u32(hh4, 0));\n    svst1_u32(svwhilelt_b32_u64(40, maxCount), dst + 40, svshllb_n_u32(hh5, 0));\n    svst1_u32(svwhilelt_b32_u64(44, maxCount), dst + 44, svshllt_n_u32(hh5, 0));\n    svst1_u32(svwhilelt_b32_u64(48, maxCount), dst + 48, svshllb_n_u32(hh6, 0));\n    svst1_u32(svwhilelt_b32_u64(52, maxCount), dst + 52, svshllt_n_u32(hh6, 0));\n    svst1_u32(svwhilelt_b32_u64(56, maxCount), dst + 56, svshllb_n_u32(hh7, 0));\n    svst1_u32(svwhilelt_b32_u64(60, maxCount), dst + 60, svshllt_n_u32(hh7, 0));\n    svst1_u32(svwhilelt_b32_u64(64, maxCount), dst + 64, svshllb_n_u32(hh8, 0));\n    svst1_u32(svwhilelt_b32_u64(68, maxCount), dst + 68, svshllt_n_u32(hh8, 0));\n    svst1_u32(svwhilelt_b32_u64(72, maxCount), dst + 72, svshllb_n_u32(hh9, 0));\n    svst1_u32(svwhilelt_b32_u64(76, maxCount), dst + 76, svshllt_n_u32(hh9, 0));\n    svst1_u32(svwhilelt_b32_u64(80, maxCount), dst + 80, svshllb_n_u32(hha, 0));\n    svst1_u32(svwhilelt_b32_u64(84, maxCount), dst + 84, svshllt_n_u32(hha, 0));\n    svst1_u32(svwhilelt_b32_u64(88, maxCount), dst + 88, svshllb_n_u32(hhb, 0));\n    svst1_u32(svwhilelt_b32_u64(92, maxCount), dst + 92, svshllt_n_u32(hhb, 0));\n\n    hh0 = svmax_u16_x(vl128, hh0, hh1);\n    hh2 = svmax_u16_x(vl128, hh2, hh3);\n    hh4 = svmax_u16_x(vl128, hh4, hh5);\n    hh6 = svmax_u16_x(vl128, hh6, hh7);\n    hh8 = svmax_u16_x(vl128, hh8, hh9);\n    hha = svmax_u16_x(vl128, hha, hhb);\n    hh0 = svmax_u16_x(vl128, hh0, hh2);\n    hh4 = svmax_u16_x(vl128, hh4, hh6);\n    hh8 = svmax_u16_x(vl128, hh8, hha);\n    hh0 = svmax_u16_x(vl128, hh0, hh4);\n    hh8 = svmax_u16_x(vl128, hh8, histmax);\n    return svmax_u16_x(vl128, hh0, hh8);\n}\n\nstatic size_t HIST_count_sve2(unsigned* count, unsigned* maxSymbolValuePtr,\n                              const void* source, size_t sourceSize,\n                              HIST_checkInput_e check)\n{\n    const BYTE* ip = (const BYTE*)source;\n    const size_t maxCount = *maxSymbolValuePtr + 1;\n\n    assert(*maxSymbolValuePtr <= 255);\n    if (!sourceSize) {\n        ZSTD_memset(count, 0, maxCount * sizeof(*count));\n        *maxSymbolValuePtr = 0;\n        return 0;\n    }\n\n    {   const svbool_t vl128 = svptrue_pat_b8(SV_VL16);\n        const svuint8_t c0 = svreinterpret_u8(svindex_u32(0x0C040800, 0x01010101));\n        const svuint8_t c1 = svadd_n_u8_x(vl128, c0, 16);\n        const svuint8_t c2 = svadd_n_u8_x(vl128, c0, 32);\n        const svuint8_t c3 = svadd_n_u8_x(vl128, c1, 32);\n\n        svuint8_t symbolMax = svdup_n_u8(0);\n        svuint16_t hh0 = svdup_n_u16(0);\n        svuint16_t hh1 = svdup_n_u16(0);\n        svuint16_t hh2 = svdup_n_u16(0);\n        svuint16_t hh3 = svdup_n_u16(0);\n        svuint16_t hh4 = svdup_n_u16(0);\n        svuint16_t hh5 = svdup_n_u16(0);\n        svuint16_t hh6 = svdup_n_u16(0);\n        svuint16_t hh7 = svdup_n_u16(0);\n        svuint16_t max;\n        size_t maxSymbolValue;\n\n        size_t i = 0;\n        while (i < sourceSize) {\n            /* We can only accumulate 15 (15 * 16 <= 255) iterations of\n             * histogram in 8-bit accumulators! */\n            const size_t size240 = min_size(i + 240, sourceSize);\n\n            svbool_t pred = svwhilelt_b8_u64(i, sourceSize);\n            svuint8_t c = svld1rq_u8(pred, ip + i);\n            svuint8_t h0 = svhistseg_u8(c0, c);\n            svuint8_t h1 = svhistseg_u8(c1, c);\n            svuint8_t h2 = svhistseg_u8(c2, c);\n            svuint8_t h3 = svhistseg_u8(c3, c);\n            symbolMax = svmax_u8_x(vl128, symbolMax, c);\n\n            for (i += 16; i < size240; i += 16) {\n                pred = svwhilelt_b8_u64(i, sourceSize);\n                c = svld1rq_u8(pred, ip + i);\n                h0 = svadd_u8_x(vl128, h0, svhistseg_u8(c0, c));\n                h1 = svadd_u8_x(vl128, h1, svhistseg_u8(c1, c));\n                h2 = svadd_u8_x(vl128, h2, svhistseg_u8(c2, c));\n                h3 = svadd_u8_x(vl128, h3, svhistseg_u8(c3, c));\n                symbolMax = svmax_u8_x(vl128, symbolMax, c);\n            }\n\n            hh0 = svaddwb_u16(hh0, h0);\n            hh1 = svaddwt_u16(hh1, h0);\n            hh2 = svaddwb_u16(hh2, h1);\n            hh3 = svaddwt_u16(hh3, h1);\n            hh4 = svaddwb_u16(hh4, h2);\n            hh5 = svaddwt_u16(hh5, h2);\n            hh6 = svaddwb_u16(hh6, h3);\n            hh7 = svaddwt_u16(hh7, h3);\n        }\n        maxSymbolValue = svmaxv_u8(vl128, symbolMax);\n\n        if (check && maxSymbolValue > *maxSymbolValuePtr) return ERROR(maxSymbolValue_tooSmall);\n        *maxSymbolValuePtr = maxSymbolValue;\n\n        /* If the buffer size is not divisible by 16, the last elements of the final\n         * vector register read will be zeros, and these elements must be subtracted\n         * from the histogram.\n         */\n        hh0 = svsub_n_u16_m(svptrue_pat_b32(SV_VL1), hh0, -sourceSize & 15);\n\n        svst1_u32(svwhilelt_b32_u64( 0, maxCount), count +  0, svshllb_n_u32(hh0, 0));\n        svst1_u32(svwhilelt_b32_u64( 4, maxCount), count +  4, svshllt_n_u32(hh0, 0));\n        svst1_u32(svwhilelt_b32_u64( 8, maxCount), count +  8, svshllb_n_u32(hh1, 0));\n        svst1_u32(svwhilelt_b32_u64(12, maxCount), count + 12, svshllt_n_u32(hh1, 0));\n        svst1_u32(svwhilelt_b32_u64(16, maxCount), count + 16, svshllb_n_u32(hh2, 0));\n        svst1_u32(svwhilelt_b32_u64(20, maxCount), count + 20, svshllt_n_u32(hh2, 0));\n        svst1_u32(svwhilelt_b32_u64(24, maxCount), count + 24, svshllb_n_u32(hh3, 0));\n        svst1_u32(svwhilelt_b32_u64(28, maxCount), count + 28, svshllt_n_u32(hh3, 0));\n        svst1_u32(svwhilelt_b32_u64(32, maxCount), count + 32, svshllb_n_u32(hh4, 0));\n        svst1_u32(svwhilelt_b32_u64(36, maxCount), count + 36, svshllt_n_u32(hh4, 0));\n        svst1_u32(svwhilelt_b32_u64(40, maxCount), count + 40, svshllb_n_u32(hh5, 0));\n        svst1_u32(svwhilelt_b32_u64(44, maxCount), count + 44, svshllt_n_u32(hh5, 0));\n        svst1_u32(svwhilelt_b32_u64(48, maxCount), count + 48, svshllb_n_u32(hh6, 0));\n        svst1_u32(svwhilelt_b32_u64(52, maxCount), count + 52, svshllt_n_u32(hh6, 0));\n        svst1_u32(svwhilelt_b32_u64(56, maxCount), count + 56, svshllb_n_u32(hh7, 0));\n        svst1_u32(svwhilelt_b32_u64(60, maxCount), count + 60, svshllt_n_u32(hh7, 0));\n\n        hh0 = svmax_u16_x(vl128, hh0, hh1);\n        hh2 = svmax_u16_x(vl128, hh2, hh3);\n        hh4 = svmax_u16_x(vl128, hh4, hh5);\n        hh6 = svmax_u16_x(vl128, hh6, hh7);\n        hh0 = svmax_u16_x(vl128, hh0, hh2);\n        hh4 = svmax_u16_x(vl128, hh4, hh6);\n        max = svmax_u16_x(vl128, hh0, hh4);\n\n        maxSymbolValue = min_size(maxSymbolValue, maxCount);\n        if (maxSymbolValue >= 64) {\n            const svuint8_t c4 = svadd_n_u8_x(vl128, c0,  64);\n            const svuint8_t c5 = svadd_n_u8_x(vl128, c1,  64);\n            const svuint8_t c6 = svadd_n_u8_x(vl128, c2,  64);\n            const svuint8_t c7 = svadd_n_u8_x(vl128, c3,  64);\n            const svuint8_t c8 = svadd_n_u8_x(vl128, c0, 128);\n            const svuint8_t c9 = svadd_n_u8_x(vl128, c1, 128);\n\n            max = HIST_count_6_sve2(ip, sourceSize, count + 64, c4, c5, c6, c7,\n                                    c8, c9, max, maxCount - 64);\n\n            if (maxSymbolValue >= 160) {\n                const svuint8_t ca = svadd_n_u8_x(vl128, c2, 128);\n                const svuint8_t cb = svadd_n_u8_x(vl128, c3, 128);\n                const svuint8_t cc = svadd_n_u8_x(vl128, c4, 128);\n                const svuint8_t cd = svadd_n_u8_x(vl128, c5, 128);\n                const svuint8_t ce = svadd_n_u8_x(vl128, c6, 128);\n                const svuint8_t cf = svadd_n_u8_x(vl128, c7, 128);\n\n                max = HIST_count_6_sve2(ip, sourceSize, count + 160, ca, cb, cc,\n                                        cd, ce, cf, max, maxCount - 160);\n            } else if (maxCount > 160) {\n                ZSTD_memset(count + 160, 0, (maxCount - 160) * sizeof(*count));\n            }\n        } else if (maxCount > 64) {\n            ZSTD_memset(count + 64, 0, (maxCount - 64) * sizeof(*count));\n        }\n\n        return svmaxv_u16(vl128, max);\n    }\n}\n#endif\n\n/* HIST_count_parallel_wksp() :\n * store histogram into 4 intermediate tables, recombined at the end.\n * this design makes better use of OoO cpus,\n * and is noticeably faster when some values are heavily repeated.\n * But it needs some additional workspace for intermediate tables.\n * `workSpace` must be a U32 table of size >= HIST_WKSP_SIZE_U32.\n * @return : largest histogram frequency,\n *           or an error code (notably when histogram's alphabet is larger than *maxSymbolValuePtr) */\nstatic UNUSED_ATTR\nsize_t HIST_count_parallel_wksp(unsigned* count, unsigned* maxSymbolValuePtr,\n                                const void* source, size_t sourceSize,\n                                HIST_checkInput_e check,\n                                U32* const workSpace)\n{\n    const BYTE* ip = (const BYTE*)source;\n    const BYTE* const iend = ip+sourceSize;\n    size_t const countSize = (*maxSymbolValuePtr + 1) * sizeof(*count);\n    unsigned max=0;\n    U32* const Counting1 = workSpace;\n    U32* const Counting2 = Counting1 + 256;\n    U32* const Counting3 = Counting2 + 256;\n    U32* const Counting4 = Counting3 + 256;\n\n    /* safety checks */\n    assert(*maxSymbolValuePtr <= 255);\n    if (!sourceSize) {\n        ZSTD_memset(count, 0, countSize);\n        *maxSymbolValuePtr = 0;\n        return 0;\n    }\n    ZSTD_memset(workSpace, 0, 4*256*sizeof(unsigned));\n\n    /* by stripes of 16 bytes */\n    {   U32 cached = MEM_read32(ip); ip += 4;\n        while (ip < iend-15) {\n            U32 c = cached; cached = MEM_read32(ip); ip += 4;\n            Counting1[(BYTE) c     ]++;\n            Counting2[(BYTE)(c>>8) ]++;\n            Counting3[(BYTE)(c>>16)]++;\n            Counting4[       c>>24 ]++;\n            c = cached; cached = MEM_read32(ip); ip += 4;\n            Counting1[(BYTE) c     ]++;\n            Counting2[(BYTE)(c>>8) ]++;\n            Counting3[(BYTE)(c>>16)]++;\n            Counting4[       c>>24 ]++;\n            c = cached; cached = MEM_read32(ip); ip += 4;\n            Counting1[(BYTE) c     ]++;\n            Counting2[(BYTE)(c>>8) ]++;\n            Counting3[(BYTE)(c>>16)]++;\n            Counting4[       c>>24 ]++;\n            c = cached; cached = MEM_read32(ip); ip += 4;\n            Counting1[(BYTE) c     ]++;\n            Counting2[(BYTE)(c>>8) ]++;\n            Counting3[(BYTE)(c>>16)]++;\n            Counting4[       c>>24 ]++;\n        }\n        ip-=4;\n    }\n\n    /* finish last symbols */\n    while (ip max) max = Counting1[s];\n    }   }\n\n    {   unsigned maxSymbolValue = 255;\n        while (!Counting1[maxSymbolValue]) maxSymbolValue--;\n        if (check && maxSymbolValue > *maxSymbolValuePtr) return ERROR(maxSymbolValue_tooSmall);\n        *maxSymbolValuePtr = maxSymbolValue;\n        ZSTD_memmove(count, Counting1, countSize);   /* in case count & Counting1 are overlapping */\n    }\n    return (size_t)max;\n}\n\n/* HIST_countFast_wksp() :\n * Same as HIST_countFast(), but using an externally provided scratch buffer.\n * `workSpace` is a writable buffer which must be 4-bytes aligned,\n * `workSpaceSize` must be >= HIST_WKSP_SIZE\n */\nsize_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,\n                          const void* source, size_t sourceSize,\n                          void* workSpace, size_t workSpaceSize)\n{\n    if (sourceSize < HIST_FAST_THRESHOLD) /* heuristic threshold */\n        return HIST_count_simple(count, maxSymbolValuePtr, source, sourceSize);\n#if defined(ZSTD_ARCH_ARM_SVE2)\n    (void)workSpace;\n    (void)workSpaceSize;\n    return HIST_count_sve2(count, maxSymbolValuePtr, source, sourceSize, trustInput);\n#else\n    if ((size_t)workSpace & 3) return ERROR(GENERIC);  /* must be aligned on 4-bytes boundaries */\n    if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall);\n    return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, trustInput, (U32*)workSpace);\n#endif\n}\n\n/* HIST_count_wksp() :\n * Same as HIST_count(), but using an externally provided scratch buffer.\n * `workSpace` size must be table of >= HIST_WKSP_SIZE_U32 unsigned */\nsize_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,\n                       const void* source, size_t sourceSize,\n                       void* workSpace, size_t workSpaceSize)\n{\n#if defined(ZSTD_ARCH_ARM_SVE2)\n    if (*maxSymbolValuePtr < 255)\n        return HIST_count_sve2(count, maxSymbolValuePtr, source, sourceSize, checkMaxSymbolValue);\n#else\n    if ((size_t)workSpace & 3) return ERROR(GENERIC);  /* must be aligned on 4-bytes boundaries */\n    if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall);\n    if (*maxSymbolValuePtr < 255)\n        return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, checkMaxSymbolValue, (U32*)workSpace);\n#endif\n    *maxSymbolValuePtr = 255;\n    return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, workSpace, workSpaceSize);\n}\n\n#ifndef ZSTD_NO_UNUSED_FUNCTIONS\n/* fast variant (unsafe : won't check if src contains values beyond count[] limit) */\nsize_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr,\n                     const void* source, size_t sourceSize)\n{\n    unsigned tmpCounters[HIST_WKSP_SIZE_U32];\n    return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, tmpCounters, sizeof(tmpCounters));\n}\n\nsize_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr,\n                 const void* src, size_t srcSize)\n{\n    unsigned tmpCounters[HIST_WKSP_SIZE_U32];\n    return HIST_count_wksp(count, maxSymbolValuePtr, src, srcSize, tmpCounters, sizeof(tmpCounters));\n}\n#endif\n"
  },
  {
    "path": "lib/compress/hist.h",
    "content": "/* ******************************************************************\n * hist : Histogram functions\n * part of Finite State Entropy project\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n *  You can contact the author at :\n *  - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy\n *  - Public forum : https://groups.google.com/forum/#!forum/lz4c\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n****************************************************************** */\n\n/* --- dependencies --- */\n#include \"../common/zstd_deps.h\"   /* size_t */\n\n\n/* --- simple histogram functions --- */\n\n/*! HIST_count():\n *  Provides the precise count of each byte within a table 'count'.\n * 'count' is a table of unsigned int, of minimum size (*maxSymbolValuePtr+1).\n *  Updates *maxSymbolValuePtr with actual largest symbol value detected.\n * @return : count of the most frequent symbol (which isn't identified).\n *           or an error code, which can be tested using HIST_isError().\n *           note : if return == srcSize, there is only one symbol.\n */\nsize_t HIST_count(unsigned* count, unsigned* maxSymbolValuePtr,\n                  const void* src, size_t srcSize);\n\nunsigned HIST_isError(size_t code);  /**< tells if a return value is an error code */\n\n\n/* --- advanced histogram functions --- */\n\n#if defined(__ARM_FEATURE_SVE2)\n#define HIST_WKSP_SIZE_U32 0\n#else\n#define HIST_WKSP_SIZE_U32 1024\n#endif\n#define HIST_WKSP_SIZE    (HIST_WKSP_SIZE_U32 * sizeof(unsigned))\n/** HIST_count_wksp() :\n *  Same as HIST_count(), but using an externally provided scratch buffer.\n *  Benefit is this function will use very little stack space.\n * `workSpace` is a writable buffer which must be 4-bytes aligned,\n * `workSpaceSize` must be >= HIST_WKSP_SIZE\n */\nsize_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,\n                       const void* src, size_t srcSize,\n                       void* workSpace, size_t workSpaceSize);\n\n/** HIST_countFast() :\n *  same as HIST_count(), but blindly trusts that all byte values within src are <= *maxSymbolValuePtr.\n *  This function is unsafe, and will segfault if any value within `src` is `> *maxSymbolValuePtr`\n */\nsize_t HIST_countFast(unsigned* count, unsigned* maxSymbolValuePtr,\n                      const void* src, size_t srcSize);\n\n/** HIST_countFast_wksp() :\n *  Same as HIST_countFast(), but using an externally provided scratch buffer.\n * `workSpace` is a writable buffer which must be 4-bytes aligned,\n * `workSpaceSize` must be >= HIST_WKSP_SIZE\n */\nsize_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,\n                           const void* src, size_t srcSize,\n                           void* workSpace, size_t workSpaceSize);\n\n/*! HIST_count_simple() :\n *  Same as HIST_countFast(), this function is unsafe,\n *  and will segfault if any value within `src` is `> *maxSymbolValuePtr`.\n *  It is also a bit slower for large inputs.\n *  However, it does not need any additional memory (not even on stack).\n * @return : count of the most frequent symbol.\n *  Note this function doesn't produce any error (i.e. it must succeed).\n */\nunsigned HIST_count_simple(unsigned* count, unsigned* maxSymbolValuePtr,\n                           const void* src, size_t srcSize);\n\n/*! HIST_add() :\n *  Lowest level: just add nb of occurrences of characters from @src into @count.\n *  @count is not reset. @count array is presumed large enough (i.e. 1 KB).\n @  This function does not need any additional stack memory.\n */\nvoid HIST_add(unsigned* count, const void* src, size_t srcSize);\n"
  },
  {
    "path": "lib/compress/huf_compress.c",
    "content": "/* ******************************************************************\n * Huffman encoder, part of New Generation Entropy library\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n *  You can contact the author at :\n *  - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy\n *  - Public forum : https://groups.google.com/forum/#!forum/lz4c\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n****************************************************************** */\n\n/* **************************************************************\n*  Compiler specifics\n****************************************************************/\n#ifdef _MSC_VER    /* Visual Studio */\n#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */\n#endif\n\n\n/* **************************************************************\n*  Includes\n****************************************************************/\n#include \"../common/zstd_deps.h\"     /* ZSTD_memcpy, ZSTD_memset */\n#include \"../common/compiler.h\"\n#include \"../common/bitstream.h\"\n#include \"hist.h\"\n#define FSE_STATIC_LINKING_ONLY   /* FSE_optimalTableLog_internal */\n#include \"../common/fse.h\"        /* header compression */\n#include \"../common/huf.h\"\n#include \"../common/error_private.h\"\n#include \"../common/bits.h\"       /* ZSTD_highbit32 */\n\n\n/* **************************************************************\n*  Error Management\n****************************************************************/\n#define HUF_isError ERR_isError\n#define HUF_STATIC_ASSERT(c) DEBUG_STATIC_ASSERT(c)   /* use only *after* variable declarations */\n\n\n/* **************************************************************\n*  Required declarations\n****************************************************************/\ntypedef struct nodeElt_s {\n    U32 count;\n    U16 parent;\n    BYTE byte;\n    BYTE nbBits;\n} nodeElt;\n\n\n/* **************************************************************\n*  Debug Traces\n****************************************************************/\n\n#if DEBUGLEVEL >= 2\n\nstatic size_t showU32(const U32* arr, size_t size)\n{\n    size_t u;\n    for (u=0; u= add) {\n        assert(add < align);\n        assert(((size_t)aligned & mask) == 0);\n        *workspaceSizePtr -= add;\n        return aligned;\n    } else {\n        *workspaceSizePtr = 0;\n        return NULL;\n    }\n}\n\n\n/* HUF_compressWeights() :\n * Same as FSE_compress(), but dedicated to huff0's weights compression.\n * The use case needs much less stack memory.\n * Note : all elements within weightTable are supposed to be <= HUF_TABLELOG_MAX.\n */\n#define MAX_FSE_TABLELOG_FOR_HUFF_HEADER 6\n\ntypedef struct {\n    FSE_CTable CTable[FSE_CTABLE_SIZE_U32(MAX_FSE_TABLELOG_FOR_HUFF_HEADER, HUF_TABLELOG_MAX)];\n    U32 scratchBuffer[FSE_BUILD_CTABLE_WORKSPACE_SIZE_U32(HUF_TABLELOG_MAX, MAX_FSE_TABLELOG_FOR_HUFF_HEADER)];\n    unsigned count[HUF_TABLELOG_MAX+1];\n    S16 norm[HUF_TABLELOG_MAX+1];\n} HUF_CompressWeightsWksp;\n\nstatic size_t\nHUF_compressWeights(void* dst, size_t dstSize,\n              const void* weightTable, size_t wtSize,\n                    void* workspace, size_t workspaceSize)\n{\n    BYTE* const ostart = (BYTE*) dst;\n    BYTE* op = ostart;\n    BYTE* const oend = ostart + dstSize;\n\n    unsigned maxSymbolValue = HUF_TABLELOG_MAX;\n    U32 tableLog = MAX_FSE_TABLELOG_FOR_HUFF_HEADER;\n    HUF_CompressWeightsWksp* wksp = (HUF_CompressWeightsWksp*)HUF_alignUpWorkspace(workspace, &workspaceSize, ZSTD_ALIGNOF(U32));\n\n    if (workspaceSize < sizeof(HUF_CompressWeightsWksp)) return ERROR(GENERIC);\n\n    /* init conditions */\n    if (wtSize <= 1) return 0;  /* Not compressible */\n\n    /* Scan input and build symbol stats */\n    {   unsigned const maxCount = HIST_count_simple(wksp->count, &maxSymbolValue, weightTable, wtSize);   /* never fails */\n        if (maxCount == wtSize) return 1;   /* only a single symbol in src : rle */\n        if (maxCount == 1) return 0;        /* each symbol present maximum once => not compressible */\n    }\n\n    tableLog = FSE_optimalTableLog(tableLog, wtSize, maxSymbolValue);\n    CHECK_F( FSE_normalizeCount(wksp->norm, tableLog, wksp->count, wtSize, maxSymbolValue, /* useLowProbCount */ 0) );\n\n    /* Write table description header */\n    {   CHECK_V_F(hSize, FSE_writeNCount(op, (size_t)(oend-op), wksp->norm, maxSymbolValue, tableLog) );\n        op += hSize;\n    }\n\n    /* Compress */\n    CHECK_F( FSE_buildCTable_wksp(wksp->CTable, wksp->norm, maxSymbolValue, tableLog, wksp->scratchBuffer, sizeof(wksp->scratchBuffer)) );\n    {   CHECK_V_F(cSize, FSE_compress_usingCTable(op, (size_t)(oend - op), weightTable, wtSize, wksp->CTable) );\n        if (cSize == 0) return 0;   /* not enough space for compressed data */\n        op += cSize;\n    }\n\n    return (size_t)(op-ostart);\n}\n\nstatic size_t HUF_getNbBits(HUF_CElt elt)\n{\n    return elt & 0xFF;\n}\n\nstatic size_t HUF_getNbBitsFast(HUF_CElt elt)\n{\n    return elt;\n}\n\nstatic size_t HUF_getValue(HUF_CElt elt)\n{\n    return elt & ~(size_t)0xFF;\n}\n\nstatic size_t HUF_getValueFast(HUF_CElt elt)\n{\n    return elt;\n}\n\nstatic void HUF_setNbBits(HUF_CElt* elt, size_t nbBits)\n{\n    assert(nbBits <= HUF_TABLELOG_ABSOLUTEMAX);\n    *elt = nbBits;\n}\n\nstatic void HUF_setValue(HUF_CElt* elt, size_t value)\n{\n    size_t const nbBits = HUF_getNbBits(*elt);\n    if (nbBits > 0) {\n        assert((value >> nbBits) == 0);\n        *elt |= value << (sizeof(HUF_CElt) * 8 - nbBits);\n    }\n}\n\nHUF_CTableHeader HUF_readCTableHeader(HUF_CElt const* ctable)\n{\n    HUF_CTableHeader header;\n    ZSTD_memcpy(&header, ctable, sizeof(header));\n    return header;\n}\n\nstatic void HUF_writeCTableHeader(HUF_CElt* ctable, U32 tableLog, U32 maxSymbolValue)\n{\n    HUF_CTableHeader header;\n    HUF_STATIC_ASSERT(sizeof(ctable[0]) == sizeof(header));\n    ZSTD_memset(&header, 0, sizeof(header));\n    assert(tableLog < 256);\n    header.tableLog = (BYTE)tableLog;\n    assert(maxSymbolValue < 256);\n    header.maxSymbolValue = (BYTE)maxSymbolValue;\n    ZSTD_memcpy(ctable, &header, sizeof(header));\n}\n\ntypedef struct {\n    HUF_CompressWeightsWksp wksp;\n    BYTE bitsToWeight[HUF_TABLELOG_MAX + 1];   /* precomputed conversion table */\n    BYTE huffWeight[HUF_SYMBOLVALUE_MAX];\n} HUF_WriteCTableWksp;\n\nsize_t HUF_writeCTable_wksp(void* dst, size_t maxDstSize,\n                            const HUF_CElt* CTable, unsigned maxSymbolValue, unsigned huffLog,\n                            void* workspace, size_t workspaceSize)\n{\n    HUF_CElt const* const ct = CTable + 1;\n    BYTE* op = (BYTE*)dst;\n    U32 n;\n    HUF_WriteCTableWksp* wksp = (HUF_WriteCTableWksp*)HUF_alignUpWorkspace(workspace, &workspaceSize, ZSTD_ALIGNOF(U32));\n\n    HUF_STATIC_ASSERT(HUF_CTABLE_WORKSPACE_SIZE >= sizeof(HUF_WriteCTableWksp));\n\n    assert(HUF_readCTableHeader(CTable).maxSymbolValue == maxSymbolValue);\n    assert(HUF_readCTableHeader(CTable).tableLog == huffLog);\n\n    /* check conditions */\n    if (workspaceSize < sizeof(HUF_WriteCTableWksp)) return ERROR(GENERIC);\n    if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge);\n\n    /* convert to weight */\n    wksp->bitsToWeight[0] = 0;\n    for (n=1; nbitsToWeight[n] = (BYTE)(huffLog + 1 - n);\n    for (n=0; nhuffWeight[n] = wksp->bitsToWeight[HUF_getNbBits(ct[n])];\n\n    /* attempt weights compression by FSE */\n    if (maxDstSize < 1) return ERROR(dstSize_tooSmall);\n    {   CHECK_V_F(hSize, HUF_compressWeights(op+1, maxDstSize-1, wksp->huffWeight, maxSymbolValue, &wksp->wksp, sizeof(wksp->wksp)) );\n        if ((hSize>1) & (hSize < maxSymbolValue/2)) {   /* FSE compressed */\n            op[0] = (BYTE)hSize;\n            return hSize+1;\n    }   }\n\n    /* write raw values as 4-bits (max : 15) */\n    if (maxSymbolValue > (256-128)) return ERROR(GENERIC);   /* should not happen : likely means source cannot be compressed */\n    if (((maxSymbolValue+1)/2) + 1 > maxDstSize) return ERROR(dstSize_tooSmall);   /* not enough space within dst buffer */\n    op[0] = (BYTE)(128 /*special case*/ + (maxSymbolValue-1));\n    wksp->huffWeight[maxSymbolValue] = 0;   /* to be sure it doesn't cause msan issue in final combination */\n    for (n=0; nhuffWeight[n] << 4) + wksp->huffWeight[n+1]);\n    return ((maxSymbolValue+1)/2) + 1;\n}\n\n\nsize_t HUF_readCTable (HUF_CElt* CTable, unsigned* maxSymbolValuePtr, const void* src, size_t srcSize, unsigned* hasZeroWeights)\n{\n    BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1];   /* init not required, even though some static analyzer may complain */\n    U32 rankVal[HUF_TABLELOG_ABSOLUTEMAX + 1];   /* large enough for values from 0 to 16 */\n    U32 tableLog = 0;\n    U32 nbSymbols = 0;\n    HUF_CElt* const ct = CTable + 1;\n\n    /* get symbol weights */\n    CHECK_V_F(readSize, HUF_readStats(huffWeight, HUF_SYMBOLVALUE_MAX+1, rankVal, &nbSymbols, &tableLog, src, srcSize));\n    *hasZeroWeights = (rankVal[0] > 0);\n\n    /* check result */\n    if (tableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);\n    if (nbSymbols > *maxSymbolValuePtr+1) return ERROR(maxSymbolValue_tooSmall);\n\n    *maxSymbolValuePtr = nbSymbols - 1;\n\n    HUF_writeCTableHeader(CTable, tableLog, *maxSymbolValuePtr);\n\n    /* Prepare base value per rank */\n    {   U32 n, nextRankStart = 0;\n        for (n=1; n<=tableLog; n++) {\n            U32 curr = nextRankStart;\n            nextRankStart += (rankVal[n] << (n-1));\n            rankVal[n] = curr;\n    }   }\n\n    /* fill nbBits */\n    {   U32 n; for (n=0; nn=tableLog+1 */\n        U16 valPerRank[HUF_TABLELOG_MAX+2] = {0};\n        { U32 n; for (n=0; n0; n--) {  /* start at n=tablelog <-> w=1 */\n                valPerRank[n] = min;     /* get starting value within each rank */\n                min += nbPerRank[n];\n                min >>= 1;\n        }   }\n        /* assign value within rank, symbol order */\n        { U32 n; for (n=0; n HUF_readCTableHeader(CTable).maxSymbolValue)\n        return 0;\n    return (U32)HUF_getNbBits(ct[symbolValue]);\n}\n\n\n/**\n * HUF_setMaxHeight():\n * Try to enforce @targetNbBits on the Huffman tree described in @huffNode.\n *\n * It attempts to convert all nodes with nbBits > @targetNbBits\n * to employ @targetNbBits instead. Then it adjusts the tree\n * so that it remains a valid canonical Huffman tree.\n *\n * @pre               The sum of the ranks of each symbol == 2^largestBits,\n *                    where largestBits == huffNode[lastNonNull].nbBits.\n * @post              The sum of the ranks of each symbol == 2^largestBits,\n *                    where largestBits is the return value (expected <= targetNbBits).\n *\n * @param huffNode    The Huffman tree modified in place to enforce targetNbBits.\n *                    It's presumed sorted, from most frequent to rarest symbol.\n * @param lastNonNull The symbol with the lowest count in the Huffman tree.\n * @param targetNbBits  The allowed number of bits, which the Huffman tree\n *                    may not respect. After this function the Huffman tree will\n *                    respect targetNbBits.\n * @return            The maximum number of bits of the Huffman tree after adjustment.\n */\nstatic U32 HUF_setMaxHeight(nodeElt* huffNode, U32 lastNonNull, U32 targetNbBits)\n{\n    const U32 largestBits = huffNode[lastNonNull].nbBits;\n    /* early exit : no elt > targetNbBits, so the tree is already valid. */\n    if (largestBits <= targetNbBits) return largestBits;\n\n    DEBUGLOG(5, \"HUF_setMaxHeight (targetNbBits = %u)\", targetNbBits);\n\n    /* there are several too large elements (at least >= 2) */\n    {   int totalCost = 0;\n        const U32 baseCost = 1 << (largestBits - targetNbBits);\n        int n = (int)lastNonNull;\n\n        /* Adjust any ranks > targetNbBits to targetNbBits.\n         * Compute totalCost, which is how far the sum of the ranks is\n         * we are over 2^largestBits after adjust the offending ranks.\n         */\n        while (huffNode[n].nbBits > targetNbBits) {\n            totalCost += baseCost - (1 << (largestBits - huffNode[n].nbBits));\n            huffNode[n].nbBits = (BYTE)targetNbBits;\n            n--;\n        }\n        /* n stops at huffNode[n].nbBits <= targetNbBits */\n        assert(huffNode[n].nbBits <= targetNbBits);\n        /* n end at index of smallest symbol using < targetNbBits */\n        while (huffNode[n].nbBits == targetNbBits) --n;\n\n        /* renorm totalCost from 2^largestBits to 2^targetNbBits\n         * note : totalCost is necessarily a multiple of baseCost */\n        assert(((U32)totalCost & (baseCost - 1)) == 0);\n        totalCost >>= (largestBits - targetNbBits);\n        assert(totalCost > 0);\n\n        /* repay normalized cost */\n        {   U32 const noSymbol = 0xF0F0F0F0;\n            U32 rankLast[HUF_TABLELOG_MAX+2];\n\n            /* Get pos of last (smallest = lowest cum. count) symbol per rank */\n            ZSTD_memset(rankLast, 0xF0, sizeof(rankLast));\n            {   U32 currentNbBits = targetNbBits;\n                int pos;\n                for (pos=n ; pos >= 0; pos--) {\n                    if (huffNode[pos].nbBits >= currentNbBits) continue;\n                    currentNbBits = huffNode[pos].nbBits;   /* < targetNbBits */\n                    rankLast[targetNbBits-currentNbBits] = (U32)pos;\n            }   }\n\n            while (totalCost > 0) {\n                /* Try to reduce the next power of 2 above totalCost because we\n                 * gain back half the rank.\n                 */\n                U32 nBitsToDecrease = ZSTD_highbit32((U32)totalCost) + 1;\n                assert(nBitsToDecrease <= HUF_TABLELOG_MAX+1);\n                for ( ; nBitsToDecrease > 1; nBitsToDecrease--) {\n                    U32 const highPos = rankLast[nBitsToDecrease];\n                    U32 const lowPos = rankLast[nBitsToDecrease-1];\n                    if (highPos == noSymbol) continue;\n                    /* Decrease highPos if no symbols of lowPos or if it is\n                     * not cheaper to remove 2 lowPos than highPos.\n                     */\n                    if (lowPos == noSymbol) break;\n                    {   U32 const highTotal = huffNode[highPos].count;\n                        U32 const lowTotal = 2 * huffNode[lowPos].count;\n                        if (highTotal <= lowTotal) break;\n                }   }\n                /* only triggered when no more rank 1 symbol left => find closest one (note : there is necessarily at least one !) */\n                assert(rankLast[nBitsToDecrease] != noSymbol || nBitsToDecrease == 1);\n                /* HUF_MAX_TABLELOG test just to please gcc 5+; but it should not be necessary */\n                while ((nBitsToDecrease<=HUF_TABLELOG_MAX) && (rankLast[nBitsToDecrease] == noSymbol))\n                    nBitsToDecrease++;\n                assert(rankLast[nBitsToDecrease] != noSymbol);\n                /* Increase the number of bits to gain back half the rank cost. */\n                totalCost -= 1 << (nBitsToDecrease-1);\n                huffNode[rankLast[nBitsToDecrease]].nbBits++;\n\n                /* Fix up the new rank.\n                 * If the new rank was empty, this symbol is now its smallest.\n                 * Otherwise, this symbol will be the largest in the new rank so no adjustment.\n                 */\n                if (rankLast[nBitsToDecrease-1] == noSymbol)\n                    rankLast[nBitsToDecrease-1] = rankLast[nBitsToDecrease];\n                /* Fix up the old rank.\n                 * If the symbol was at position 0, meaning it was the highest weight symbol in the tree,\n                 * it must be the only symbol in its rank, so the old rank now has no symbols.\n                 * Otherwise, since the Huffman nodes are sorted by count, the previous position is now\n                 * the smallest node in the rank. If the previous position belongs to a different rank,\n                 * then the rank is now empty.\n                 */\n                if (rankLast[nBitsToDecrease] == 0)    /* special case, reached largest symbol */\n                    rankLast[nBitsToDecrease] = noSymbol;\n                else {\n                    rankLast[nBitsToDecrease]--;\n                    if (huffNode[rankLast[nBitsToDecrease]].nbBits != targetNbBits-nBitsToDecrease)\n                        rankLast[nBitsToDecrease] = noSymbol;   /* this rank is now empty */\n                }\n            }   /* while (totalCost > 0) */\n\n            /* If we've removed too much weight, then we have to add it back.\n             * To avoid overshooting again, we only adjust the smallest rank.\n             * We take the largest nodes from the lowest rank 0 and move them\n             * to rank 1. There's guaranteed to be enough rank 0 symbols because\n             * TODO.\n             */\n            while (totalCost < 0) {  /* Sometimes, cost correction overshoot */\n                /* special case : no rank 1 symbol (using targetNbBits-1);\n                 * let's create one from largest rank 0 (using targetNbBits).\n                 */\n                if (rankLast[1] == noSymbol) {\n                    while (huffNode[n].nbBits == targetNbBits) n--;\n                    huffNode[n+1].nbBits--;\n                    assert(n >= 0);\n                    rankLast[1] = (U32)(n+1);\n                    totalCost++;\n                    continue;\n                }\n                huffNode[ rankLast[1] + 1 ].nbBits--;\n                rankLast[1]++;\n                totalCost ++;\n            }\n        }   /* repay normalized cost */\n    }   /* there are several too large elements (at least >= 2) */\n\n    return targetNbBits;\n}\n\ntypedef struct {\n    U16 base;\n    U16 curr;\n} rankPos;\n\ntypedef nodeElt huffNodeTable[2 * (HUF_SYMBOLVALUE_MAX + 1)];\n\n/* Number of buckets available for HUF_sort() */\n#define RANK_POSITION_TABLE_SIZE 192\n\ntypedef struct {\n  huffNodeTable huffNodeTbl;\n  rankPos rankPosition[RANK_POSITION_TABLE_SIZE];\n} HUF_buildCTable_wksp_tables;\n\n/* RANK_POSITION_DISTINCT_COUNT_CUTOFF == Cutoff point in HUF_sort() buckets for which we use log2 bucketing.\n * Strategy is to use as many buckets as possible for representing distinct\n * counts while using the remainder to represent all \"large\" counts.\n *\n * To satisfy this requirement for 192 buckets, we can do the following:\n * Let buckets 0-166 represent distinct counts of [0, 166]\n * Let buckets 166 to 192 represent all remaining counts up to RANK_POSITION_MAX_COUNT_LOG using log2 bucketing.\n */\n#define RANK_POSITION_MAX_COUNT_LOG 32\n#define RANK_POSITION_LOG_BUCKETS_BEGIN ((RANK_POSITION_TABLE_SIZE - 1) - RANK_POSITION_MAX_COUNT_LOG - 1 /* == 158 */)\n#define RANK_POSITION_DISTINCT_COUNT_CUTOFF (RANK_POSITION_LOG_BUCKETS_BEGIN + ZSTD_highbit32(RANK_POSITION_LOG_BUCKETS_BEGIN) /* == 166 */)\n\n/* Return the appropriate bucket index for a given count. See definition of\n * RANK_POSITION_DISTINCT_COUNT_CUTOFF for explanation of bucketing strategy.\n */\nstatic U32 HUF_getIndex(U32 const count) {\n    return (count < RANK_POSITION_DISTINCT_COUNT_CUTOFF)\n        ? count\n        : ZSTD_highbit32(count) + RANK_POSITION_LOG_BUCKETS_BEGIN;\n}\n\n/* Helper swap function for HUF_quickSortPartition() */\nstatic void HUF_swapNodes(nodeElt* a, nodeElt* b) {\n\tnodeElt tmp = *a;\n\t*a = *b;\n\t*b = tmp;\n}\n\n/* Returns 0 if the huffNode array is not sorted by descending count */\nMEM_STATIC int HUF_isSorted(nodeElt huffNode[], U32 const maxSymbolValue1) {\n    U32 i;\n    for (i = 1; i < maxSymbolValue1; ++i) {\n        if (huffNode[i].count > huffNode[i-1].count) {\n            return 0;\n        }\n    }\n    return 1;\n}\n\n/* Insertion sort by descending order */\nHINT_INLINE void HUF_insertionSort(nodeElt huffNode[], int const low, int const high) {\n    int i;\n    int const size = high-low+1;\n    huffNode += low;\n    for (i = 1; i < size; ++i) {\n        nodeElt const key = huffNode[i];\n        int j = i - 1;\n        while (j >= 0 && huffNode[j].count < key.count) {\n            huffNode[j + 1] = huffNode[j];\n            j--;\n        }\n        huffNode[j + 1] = key;\n    }\n}\n\n/* Pivot helper function for quicksort. */\nstatic int HUF_quickSortPartition(nodeElt arr[], int const low, int const high) {\n    /* Simply select rightmost element as pivot. \"Better\" selectors like\n     * median-of-three don't experimentally appear to have any benefit.\n     */\n    U32 const pivot = arr[high].count;\n    int i = low - 1;\n    int j = low;\n    for ( ; j < high; j++) {\n        if (arr[j].count > pivot) {\n            i++;\n            HUF_swapNodes(&arr[i], &arr[j]);\n        }\n    }\n    HUF_swapNodes(&arr[i + 1], &arr[high]);\n    return i + 1;\n}\n\n/* Classic quicksort by descending with partially iterative calls\n * to reduce worst case callstack size.\n */\nstatic void HUF_simpleQuickSort(nodeElt arr[], int low, int high) {\n    int const kInsertionSortThreshold = 8;\n    if (high - low < kInsertionSortThreshold) {\n        HUF_insertionSort(arr, low, high);\n        return;\n    }\n    while (low < high) {\n        int const idx = HUF_quickSortPartition(arr, low, high);\n        if (idx - low < high - idx) {\n            HUF_simpleQuickSort(arr, low, idx - 1);\n            low = idx + 1;\n        } else {\n            HUF_simpleQuickSort(arr, idx + 1, high);\n            high = idx - 1;\n        }\n    }\n}\n\n/**\n * HUF_sort():\n * Sorts the symbols [0, maxSymbolValue] by count[symbol] in decreasing order.\n * This is a typical bucket sorting strategy that uses either quicksort or insertion sort to sort each bucket.\n *\n * @param[out] huffNode       Sorted symbols by decreasing count. Only members `.count` and `.byte` are filled.\n *                            Must have (maxSymbolValue + 1) entries.\n * @param[in]  count          Histogram of the symbols.\n * @param[in]  maxSymbolValue Maximum symbol value.\n * @param      rankPosition   This is a scratch workspace. Must have RANK_POSITION_TABLE_SIZE entries.\n */\nstatic void HUF_sort(nodeElt huffNode[], const unsigned count[], U32 const maxSymbolValue, rankPos rankPosition[]) {\n    U32 n;\n    U32 const maxSymbolValue1 = maxSymbolValue+1;\n\n    /* Compute base and set curr to base.\n     * For symbol s let lowerRank = HUF_getIndex(count[n]) and rank = lowerRank + 1.\n     * See HUF_getIndex to see bucketing strategy.\n     * We attribute each symbol to lowerRank's base value, because we want to know where\n     * each rank begins in the output, so for rank R we want to count ranks R+1 and above.\n     */\n    ZSTD_memset(rankPosition, 0, sizeof(*rankPosition) * RANK_POSITION_TABLE_SIZE);\n    for (n = 0; n < maxSymbolValue1; ++n) {\n        U32 lowerRank = HUF_getIndex(count[n]);\n        assert(lowerRank < RANK_POSITION_TABLE_SIZE - 1);\n        rankPosition[lowerRank].base++;\n    }\n\n    assert(rankPosition[RANK_POSITION_TABLE_SIZE - 1].base == 0);\n    /* Set up the rankPosition table */\n    for (n = RANK_POSITION_TABLE_SIZE - 1; n > 0; --n) {\n        rankPosition[n-1].base += rankPosition[n].base;\n        rankPosition[n-1].curr = rankPosition[n-1].base;\n    }\n\n    /* Insert each symbol into their appropriate bucket, setting up rankPosition table. */\n    for (n = 0; n < maxSymbolValue1; ++n) {\n        U32 const c = count[n];\n        U32 const r = HUF_getIndex(c) + 1;\n        U32 const pos = rankPosition[r].curr++;\n        assert(pos < maxSymbolValue1);\n        huffNode[pos].count = c;\n        huffNode[pos].byte  = (BYTE)n;\n    }\n\n    /* Sort each bucket. */\n    for (n = RANK_POSITION_DISTINCT_COUNT_CUTOFF; n < RANK_POSITION_TABLE_SIZE - 1; ++n) {\n        int const bucketSize = rankPosition[n].curr - rankPosition[n].base;\n        U32 const bucketStartIdx = rankPosition[n].base;\n        if (bucketSize > 1) {\n            assert(bucketStartIdx < maxSymbolValue1);\n            HUF_simpleQuickSort(huffNode + bucketStartIdx, 0, bucketSize-1);\n        }\n    }\n\n    assert(HUF_isSorted(huffNode, maxSymbolValue1));\n}\n\n\n/** HUF_buildCTable_wksp() :\n *  Same as HUF_buildCTable(), but using externally allocated scratch buffer.\n *  `workSpace` must be aligned on 4-bytes boundaries, and be at least as large as sizeof(HUF_buildCTable_wksp_tables).\n */\n#define STARTNODE (HUF_SYMBOLVALUE_MAX+1)\n\n/* HUF_buildTree():\n * Takes the huffNode array sorted by HUF_sort() and builds an unlimited-depth Huffman tree.\n *\n * @param huffNode        The array sorted by HUF_sort(). Builds the Huffman tree in this array.\n * @param maxSymbolValue  The maximum symbol value.\n * @return                The smallest node in the Huffman tree (by count).\n */\nstatic int HUF_buildTree(nodeElt* huffNode, U32 maxSymbolValue)\n{\n    nodeElt* const huffNode0 = huffNode - 1;\n    int nonNullRank;\n    int lowS, lowN;\n    int nodeNb = STARTNODE;\n    int n, nodeRoot;\n    DEBUGLOG(5, \"HUF_buildTree (alphabet size = %u)\", maxSymbolValue + 1);\n    /* init for parents */\n    nonNullRank = (int)maxSymbolValue;\n    while(huffNode[nonNullRank].count == 0) nonNullRank--;\n    lowS = nonNullRank; nodeRoot = nodeNb + lowS - 1; lowN = nodeNb;\n    huffNode[nodeNb].count = huffNode[lowS].count + huffNode[lowS-1].count;\n    huffNode[lowS].parent = huffNode[lowS-1].parent = (U16)nodeNb;\n    nodeNb++; lowS-=2;\n    for (n=nodeNb; n<=nodeRoot; n++) huffNode[n].count = (U32)(1U<<30);\n    huffNode0[0].count = (U32)(1U<<31);  /* fake entry, strong barrier */\n\n    /* create parents */\n    while (nodeNb <= nodeRoot) {\n        int const n1 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++;\n        int const n2 = (huffNode[lowS].count < huffNode[lowN].count) ? lowS-- : lowN++;\n        huffNode[nodeNb].count = huffNode[n1].count + huffNode[n2].count;\n        huffNode[n1].parent = huffNode[n2].parent = (U16)nodeNb;\n        nodeNb++;\n    }\n\n    /* distribute weights (unlimited tree height) */\n    huffNode[nodeRoot].nbBits = 0;\n    for (n=nodeRoot-1; n>=STARTNODE; n--)\n        huffNode[n].nbBits = huffNode[ huffNode[n].parent ].nbBits + 1;\n    for (n=0; n<=nonNullRank; n++)\n        huffNode[n].nbBits = huffNode[ huffNode[n].parent ].nbBits + 1;\n\n    DEBUGLOG(6, \"Initial distribution of bits completed (%zu sorted symbols)\", showHNodeBits(huffNode, maxSymbolValue+1));\n\n    return nonNullRank;\n}\n\n/**\n * HUF_buildCTableFromTree():\n * Build the CTable given the Huffman tree in huffNode.\n *\n * @param[out] CTable         The output Huffman CTable.\n * @param      huffNode       The Huffman tree.\n * @param      nonNullRank    The last and smallest node in the Huffman tree.\n * @param      maxSymbolValue The maximum symbol value.\n * @param      maxNbBits      The exact maximum number of bits used in the Huffman tree.\n */\nstatic void HUF_buildCTableFromTree(HUF_CElt* CTable, nodeElt const* huffNode, int nonNullRank, U32 maxSymbolValue, U32 maxNbBits)\n{\n    HUF_CElt* const ct = CTable + 1;\n    /* fill result into ctable (val, nbBits) */\n    int n;\n    U16 nbPerRank[HUF_TABLELOG_MAX+1] = {0};\n    U16 valPerRank[HUF_TABLELOG_MAX+1] = {0};\n    int const alphabetSize = (int)(maxSymbolValue + 1);\n    for (n=0; n<=nonNullRank; n++)\n        nbPerRank[huffNode[n].nbBits]++;\n    /* determine starting value per rank */\n    {   U16 min = 0;\n        for (n=(int)maxNbBits; n>0; n--) {\n            valPerRank[n] = min;      /* get starting value within each rank */\n            min += nbPerRank[n];\n            min >>= 1;\n    }   }\n    for (n=0; nhuffNodeTbl;\n    nodeElt* const huffNode = huffNode0+1;\n    int nonNullRank;\n\n    HUF_STATIC_ASSERT(HUF_CTABLE_WORKSPACE_SIZE == sizeof(HUF_buildCTable_wksp_tables));\n\n    DEBUGLOG(5, \"HUF_buildCTable_wksp (alphabet size = %u)\", maxSymbolValue+1);\n\n    /* safety checks */\n    if (wkspSize < sizeof(HUF_buildCTable_wksp_tables))\n        return ERROR(workSpace_tooSmall);\n    if (maxNbBits == 0) maxNbBits = HUF_TABLELOG_DEFAULT;\n    if (maxSymbolValue > HUF_SYMBOLVALUE_MAX)\n        return ERROR(maxSymbolValue_tooLarge);\n    ZSTD_memset(huffNode0, 0, sizeof(huffNodeTable));\n\n    /* sort, decreasing order */\n    HUF_sort(huffNode, count, maxSymbolValue, wksp_tables->rankPosition);\n    DEBUGLOG(6, \"sorted symbols completed (%zu symbols)\", showHNodeSymbols(huffNode, maxSymbolValue+1));\n\n    /* build tree */\n    nonNullRank = HUF_buildTree(huffNode, maxSymbolValue);\n\n    /* determine and enforce maxTableLog */\n    maxNbBits = HUF_setMaxHeight(huffNode, (U32)nonNullRank, maxNbBits);\n    if (maxNbBits > HUF_TABLELOG_MAX) return ERROR(GENERIC);   /* check fit into table */\n\n    HUF_buildCTableFromTree(CTable, huffNode, nonNullRank, maxSymbolValue, maxNbBits);\n\n    return maxNbBits;\n}\n\nsize_t HUF_estimateCompressedSize(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue)\n{\n    HUF_CElt const* ct = CTable + 1;\n    size_t nbBits = 0;\n    int s;\n    for (s = 0; s <= (int)maxSymbolValue; ++s) {\n        nbBits += HUF_getNbBits(ct[s]) * count[s];\n    }\n    return nbBits >> 3;\n}\n\nint HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue) {\n    HUF_CTableHeader header = HUF_readCTableHeader(CTable);\n    HUF_CElt const* ct = CTable + 1;\n    int bad = 0;\n    int s;\n\n    assert(header.tableLog <= HUF_TABLELOG_ABSOLUTEMAX);\n\n    if (header.maxSymbolValue < maxSymbolValue)\n        return 0;\n\n    for (s = 0; s <= (int)maxSymbolValue; ++s) {\n        bad |= (count[s] != 0) & (HUF_getNbBits(ct[s]) == 0);\n    }\n    return !bad;\n}\n\nsize_t HUF_compressBound(size_t size) { return HUF_COMPRESSBOUND(size); }\n\n/** HUF_CStream_t:\n * Huffman uses its own BIT_CStream_t implementation.\n * There are three major differences from BIT_CStream_t:\n *   1. HUF_addBits() takes a HUF_CElt (size_t) which is\n *      the pair (nbBits, value) in the format:\n *      format:\n *        - Bits [0, 4)            = nbBits\n *        - Bits [4, 64 - nbBits)  = 0\n *        - Bits [64 - nbBits, 64) = value\n *   2. The bitContainer is built from the upper bits and\n *      right shifted. E.g. to add a new value of N bits\n *      you right shift the bitContainer by N, then or in\n *      the new value into the N upper bits.\n *   3. The bitstream has two bit containers. You can add\n *      bits to the second container and merge them into\n *      the first container.\n */\n\n#define HUF_BITS_IN_CONTAINER (sizeof(size_t) * 8)\n\ntypedef struct {\n    size_t bitContainer[2];\n    size_t bitPos[2];\n\n    BYTE* startPtr;\n    BYTE* ptr;\n    BYTE* endPtr;\n} HUF_CStream_t;\n\n/**! HUF_initCStream():\n * Initializes the bitstream.\n * @returns 0 or an error code.\n */\nstatic size_t HUF_initCStream(HUF_CStream_t* bitC,\n                                  void* startPtr, size_t dstCapacity)\n{\n    ZSTD_memset(bitC, 0, sizeof(*bitC));\n    bitC->startPtr = (BYTE*)startPtr;\n    bitC->ptr = bitC->startPtr;\n    bitC->endPtr = bitC->startPtr + dstCapacity - sizeof(bitC->bitContainer[0]);\n    if (dstCapacity <= sizeof(bitC->bitContainer[0])) return ERROR(dstSize_tooSmall);\n    return 0;\n}\n\n/*! HUF_addBits():\n * Adds the symbol stored in HUF_CElt elt to the bitstream.\n *\n * @param elt   The element we're adding. This is a (nbBits, value) pair.\n *              See the HUF_CStream_t docs for the format.\n * @param idx   Insert into the bitstream at this idx.\n * @param kFast This is a template parameter. If the bitstream is guaranteed\n *              to have at least 4 unused bits after this call it may be 1,\n *              otherwise it must be 0. HUF_addBits() is faster when fast is set.\n */\nFORCE_INLINE_TEMPLATE void HUF_addBits(HUF_CStream_t* bitC, HUF_CElt elt, int idx, int kFast)\n{\n    assert(idx <= 1);\n    assert(HUF_getNbBits(elt) <= HUF_TABLELOG_ABSOLUTEMAX);\n    /* This is efficient on x86-64 with BMI2 because shrx\n     * only reads the low 6 bits of the register. The compiler\n     * knows this and elides the mask. When fast is set,\n     * every operation can use the same value loaded from elt.\n     */\n    bitC->bitContainer[idx] >>= HUF_getNbBits(elt);\n    bitC->bitContainer[idx] |= kFast ? HUF_getValueFast(elt) : HUF_getValue(elt);\n    /* We only read the low 8 bits of bitC->bitPos[idx] so it\n     * doesn't matter that the high bits have noise from the value.\n     */\n    bitC->bitPos[idx] += HUF_getNbBitsFast(elt);\n    assert((bitC->bitPos[idx] & 0xFF) <= HUF_BITS_IN_CONTAINER);\n    /* The last 4-bits of elt are dirty if fast is set,\n     * so we must not be overwriting bits that have already been\n     * inserted into the bit container.\n     */\n#if DEBUGLEVEL >= 1\n    {\n        size_t const nbBits = HUF_getNbBits(elt);\n        size_t const dirtyBits = nbBits == 0 ? 0 : ZSTD_highbit32((U32)nbBits) + 1;\n        (void)dirtyBits;\n        /* Middle bits are 0. */\n        assert(((elt >> dirtyBits) << (dirtyBits + nbBits)) == 0);\n        /* We didn't overwrite any bits in the bit container. */\n        assert(!kFast || (bitC->bitPos[idx] & 0xFF) <= HUF_BITS_IN_CONTAINER);\n        (void)dirtyBits;\n    }\n#endif\n}\n\nFORCE_INLINE_TEMPLATE void HUF_zeroIndex1(HUF_CStream_t* bitC)\n{\n    bitC->bitContainer[1] = 0;\n    bitC->bitPos[1] = 0;\n}\n\n/*! HUF_mergeIndex1() :\n * Merges the bit container @ index 1 into the bit container @ index 0\n * and zeros the bit container @ index 1.\n */\nFORCE_INLINE_TEMPLATE void HUF_mergeIndex1(HUF_CStream_t* bitC)\n{\n    assert((bitC->bitPos[1] & 0xFF) < HUF_BITS_IN_CONTAINER);\n    bitC->bitContainer[0] >>= (bitC->bitPos[1] & 0xFF);\n    bitC->bitContainer[0] |= bitC->bitContainer[1];\n    bitC->bitPos[0] += bitC->bitPos[1];\n    assert((bitC->bitPos[0] & 0xFF) <= HUF_BITS_IN_CONTAINER);\n}\n\n/*! HUF_flushBits() :\n* Flushes the bits in the bit container @ index 0.\n*\n* @post bitPos will be < 8.\n* @param kFast If kFast is set then we must know a-priori that\n*              the bit container will not overflow.\n*/\nFORCE_INLINE_TEMPLATE void HUF_flushBits(HUF_CStream_t* bitC, int kFast)\n{\n    /* The upper bits of bitPos are noisy, so we must mask by 0xFF. */\n    size_t const nbBits = bitC->bitPos[0] & 0xFF;\n    size_t const nbBytes = nbBits >> 3;\n    /* The top nbBits bits of bitContainer are the ones we need. */\n    size_t const bitContainer = bitC->bitContainer[0] >> (HUF_BITS_IN_CONTAINER - nbBits);\n    /* Mask bitPos to account for the bytes we consumed. */\n    bitC->bitPos[0] &= 7;\n    assert(nbBits > 0);\n    assert(nbBits <= sizeof(bitC->bitContainer[0]) * 8);\n    assert(bitC->ptr <= bitC->endPtr);\n    MEM_writeLEST(bitC->ptr, bitContainer);\n    bitC->ptr += nbBytes;\n    assert(!kFast || bitC->ptr <= bitC->endPtr);\n    if (!kFast && bitC->ptr > bitC->endPtr) bitC->ptr = bitC->endPtr;\n    /* bitContainer doesn't need to be modified because the leftover\n     * bits are already the top bitPos bits. And we don't care about\n     * noise in the lower values.\n     */\n}\n\n/*! HUF_endMark()\n * @returns The Huffman stream end mark: A 1-bit value = 1.\n */\nstatic HUF_CElt HUF_endMark(void)\n{\n    HUF_CElt endMark;\n    HUF_setNbBits(&endMark, 1);\n    HUF_setValue(&endMark, 1);\n    return endMark;\n}\n\n/*! HUF_closeCStream() :\n *  @return Size of CStream, in bytes,\n *          or 0 if it could not fit into dstBuffer */\nstatic size_t HUF_closeCStream(HUF_CStream_t* bitC)\n{\n    HUF_addBits(bitC, HUF_endMark(), /* idx */ 0, /* kFast */ 0);\n    HUF_flushBits(bitC, /* kFast */ 0);\n    {\n        size_t const nbBits = bitC->bitPos[0] & 0xFF;\n        if (bitC->ptr >= bitC->endPtr) return 0; /* overflow detected */\n        return (size_t)(bitC->ptr - bitC->startPtr) + (nbBits > 0);\n    }\n}\n\nFORCE_INLINE_TEMPLATE void\nHUF_encodeSymbol(HUF_CStream_t* bitCPtr, U32 symbol, const HUF_CElt* CTable, int idx, int fast)\n{\n    HUF_addBits(bitCPtr, CTable[symbol], idx, fast);\n}\n\nFORCE_INLINE_TEMPLATE void\nHUF_compress1X_usingCTable_internal_body_loop(HUF_CStream_t* bitC,\n                                   const BYTE* ip, size_t srcSize,\n                                   const HUF_CElt* ct,\n                                   int kUnroll, int kFastFlush, int kLastFast)\n{\n    /* Join to kUnroll */\n    int n = (int)srcSize;\n    int rem = n % kUnroll;\n    if (rem > 0) {\n        for (; rem > 0; --rem) {\n            HUF_encodeSymbol(bitC, ip[--n], ct, 0, /* fast */ 0);\n        }\n        HUF_flushBits(bitC, kFastFlush);\n    }\n    assert(n % kUnroll == 0);\n\n    /* Join to 2 * kUnroll */\n    if (n % (2 * kUnroll)) {\n        int u;\n        for (u = 1; u < kUnroll; ++u) {\n            HUF_encodeSymbol(bitC, ip[n - u], ct, 0, 1);\n        }\n        HUF_encodeSymbol(bitC, ip[n - kUnroll], ct, 0, kLastFast);\n        HUF_flushBits(bitC, kFastFlush);\n        n -= kUnroll;\n    }\n    assert(n % (2 * kUnroll) == 0);\n\n    for (; n>0; n-= 2 * kUnroll) {\n        /* Encode kUnroll symbols into the bitstream @ index 0. */\n        int u;\n        for (u = 1; u < kUnroll; ++u) {\n            HUF_encodeSymbol(bitC, ip[n - u], ct, /* idx */ 0, /* fast */ 1);\n        }\n        HUF_encodeSymbol(bitC, ip[n - kUnroll], ct, /* idx */ 0, /* fast */ kLastFast);\n        HUF_flushBits(bitC, kFastFlush);\n        /* Encode kUnroll symbols into the bitstream @ index 1.\n         * This allows us to start filling the bit container\n         * without any data dependencies.\n         */\n        HUF_zeroIndex1(bitC);\n        for (u = 1; u < kUnroll; ++u) {\n            HUF_encodeSymbol(bitC, ip[n - kUnroll - u], ct, /* idx */ 1, /* fast */ 1);\n        }\n        HUF_encodeSymbol(bitC, ip[n - kUnroll - kUnroll], ct, /* idx */ 1, /* fast */ kLastFast);\n        /* Merge bitstream @ index 1 into the bitstream @ index 0 */\n        HUF_mergeIndex1(bitC);\n        HUF_flushBits(bitC, kFastFlush);\n    }\n    assert(n == 0);\n\n}\n\n/**\n * Returns a tight upper bound on the output space needed by Huffman\n * with 8 bytes buffer to handle over-writes. If the output is at least\n * this large we don't need to do bounds checks during Huffman encoding.\n */\nstatic size_t HUF_tightCompressBound(size_t srcSize, size_t tableLog)\n{\n    return ((srcSize * tableLog) >> 3) + 8;\n}\n\n\nFORCE_INLINE_TEMPLATE size_t\nHUF_compress1X_usingCTable_internal_body(void* dst, size_t dstSize,\n                                   const void* src, size_t srcSize,\n                                   const HUF_CElt* CTable)\n{\n    U32 const tableLog = HUF_readCTableHeader(CTable).tableLog;\n    HUF_CElt const* ct = CTable + 1;\n    const BYTE* ip = (const BYTE*) src;\n    BYTE* const ostart = (BYTE*)dst;\n    BYTE* const oend = ostart + dstSize;\n    HUF_CStream_t bitC;\n\n    /* init */\n    if (dstSize < 8) return 0;   /* not enough space to compress */\n    { BYTE* op = ostart;\n      size_t const initErr = HUF_initCStream(&bitC, op, (size_t)(oend-op));\n      if (HUF_isError(initErr)) return 0; }\n\n    if (dstSize < HUF_tightCompressBound(srcSize, (size_t)tableLog) || tableLog > 11)\n        HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ MEM_32bits() ? 2 : 4, /* kFast */ 0, /* kLastFast */ 0);\n    else {\n        if (MEM_32bits()) {\n            switch (tableLog) {\n            case 11:\n                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 2, /* kFastFlush */ 1, /* kLastFast */ 0);\n                break;\n            case 10: ZSTD_FALLTHROUGH;\n            case 9: ZSTD_FALLTHROUGH;\n            case 8:\n                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 2, /* kFastFlush */ 1, /* kLastFast */ 1);\n                break;\n            case 7: ZSTD_FALLTHROUGH;\n            default:\n                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 3, /* kFastFlush */ 1, /* kLastFast */ 1);\n                break;\n            }\n        } else {\n            switch (tableLog) {\n            case 11:\n                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 5, /* kFastFlush */ 1, /* kLastFast */ 0);\n                break;\n            case 10:\n                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 5, /* kFastFlush */ 1, /* kLastFast */ 1);\n                break;\n            case 9:\n                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 6, /* kFastFlush */ 1, /* kLastFast */ 0);\n                break;\n            case 8:\n                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 7, /* kFastFlush */ 1, /* kLastFast */ 0);\n                break;\n            case 7:\n                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 8, /* kFastFlush */ 1, /* kLastFast */ 0);\n                break;\n            case 6: ZSTD_FALLTHROUGH;\n            default:\n                HUF_compress1X_usingCTable_internal_body_loop(&bitC, ip, srcSize, ct, /* kUnroll */ 9, /* kFastFlush */ 1, /* kLastFast */ 1);\n                break;\n            }\n        }\n    }\n    assert(bitC.ptr <= bitC.endPtr);\n\n    return HUF_closeCStream(&bitC);\n}\n\n#if DYNAMIC_BMI2\n\nstatic BMI2_TARGET_ATTRIBUTE size_t\nHUF_compress1X_usingCTable_internal_bmi2(void* dst, size_t dstSize,\n                                   const void* src, size_t srcSize,\n                                   const HUF_CElt* CTable)\n{\n    return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);\n}\n\nstatic size_t\nHUF_compress1X_usingCTable_internal_default(void* dst, size_t dstSize,\n                                      const void* src, size_t srcSize,\n                                      const HUF_CElt* CTable)\n{\n    return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);\n}\n\nstatic size_t\nHUF_compress1X_usingCTable_internal(void* dst, size_t dstSize,\n                              const void* src, size_t srcSize,\n                              const HUF_CElt* CTable, const int flags)\n{\n    if (flags & HUF_flags_bmi2) {\n        return HUF_compress1X_usingCTable_internal_bmi2(dst, dstSize, src, srcSize, CTable);\n    }\n    return HUF_compress1X_usingCTable_internal_default(dst, dstSize, src, srcSize, CTable);\n}\n\n#else\n\nstatic size_t\nHUF_compress1X_usingCTable_internal(void* dst, size_t dstSize,\n                              const void* src, size_t srcSize,\n                              const HUF_CElt* CTable, const int flags)\n{\n    (void)flags;\n    return HUF_compress1X_usingCTable_internal_body(dst, dstSize, src, srcSize, CTable);\n}\n\n#endif\n\nsize_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, int flags)\n{\n    return HUF_compress1X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, flags);\n}\n\nstatic size_t\nHUF_compress4X_usingCTable_internal(void* dst, size_t dstSize,\n                              const void* src, size_t srcSize,\n                              const HUF_CElt* CTable, int flags)\n{\n    size_t const segmentSize = (srcSize+3)/4;   /* first 3 segments */\n    const BYTE* ip = (const BYTE*) src;\n    const BYTE* const iend = ip + srcSize;\n    BYTE* const ostart = (BYTE*) dst;\n    BYTE* const oend = ostart + dstSize;\n    BYTE* op = ostart;\n\n    if (dstSize < 6 + 1 + 1 + 1 + 8) return 0;   /* minimum space to compress successfully */\n    if (srcSize < 12) return 0;   /* no saving possible : too small input */\n    op += 6;   /* jumpTable */\n\n    assert(op <= oend);\n    {   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip, segmentSize, CTable, flags) );\n        if (cSize == 0 || cSize > 65535) return 0;\n        MEM_writeLE16(ostart, (U16)cSize);\n        op += cSize;\n    }\n\n    ip += segmentSize;\n    assert(op <= oend);\n    {   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip, segmentSize, CTable, flags) );\n        if (cSize == 0 || cSize > 65535) return 0;\n        MEM_writeLE16(ostart+2, (U16)cSize);\n        op += cSize;\n    }\n\n    ip += segmentSize;\n    assert(op <= oend);\n    {   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip, segmentSize, CTable, flags) );\n        if (cSize == 0 || cSize > 65535) return 0;\n        MEM_writeLE16(ostart+4, (U16)cSize);\n        op += cSize;\n    }\n\n    ip += segmentSize;\n    assert(op <= oend);\n    assert(ip <= iend);\n    {   CHECK_V_F(cSize, HUF_compress1X_usingCTable_internal(op, (size_t)(oend-op), ip, (size_t)(iend-ip), CTable, flags) );\n        if (cSize == 0 || cSize > 65535) return 0;\n        op += cSize;\n    }\n\n    return (size_t)(op-ostart);\n}\n\nsize_t HUF_compress4X_usingCTable(void* dst, size_t dstSize, const void* src, size_t srcSize, const HUF_CElt* CTable, int flags)\n{\n    return HUF_compress4X_usingCTable_internal(dst, dstSize, src, srcSize, CTable, flags);\n}\n\ntypedef enum { HUF_singleStream, HUF_fourStreams } HUF_nbStreams_e;\n\nstatic size_t HUF_compressCTable_internal(\n                BYTE* const ostart, BYTE* op, BYTE* const oend,\n                const void* src, size_t srcSize,\n                HUF_nbStreams_e nbStreams, const HUF_CElt* CTable, const int flags)\n{\n    size_t const cSize = (nbStreams==HUF_singleStream) ?\n                         HUF_compress1X_usingCTable_internal(op, (size_t)(oend - op), src, srcSize, CTable, flags) :\n                         HUF_compress4X_usingCTable_internal(op, (size_t)(oend - op), src, srcSize, CTable, flags);\n    if (HUF_isError(cSize)) { return cSize; }\n    if (cSize==0) { return 0; }   /* uncompressible */\n    op += cSize;\n    /* check compressibility */\n    assert(op >= ostart);\n    if ((size_t)(op-ostart) >= srcSize-1) { return 0; }\n    return (size_t)(op-ostart);\n}\n\ntypedef struct {\n    unsigned count[HUF_SYMBOLVALUE_MAX + 1];\n    HUF_CElt CTable[HUF_CTABLE_SIZE_ST(HUF_SYMBOLVALUE_MAX)];\n    union {\n        HUF_buildCTable_wksp_tables buildCTable_wksp;\n        HUF_WriteCTableWksp writeCTable_wksp;\n        U32 hist_wksp[HIST_WKSP_SIZE_U32];\n    } wksps;\n} HUF_compress_tables_t;\n\n#define SUSPECT_INCOMPRESSIBLE_SAMPLE_SIZE 4096\n#define SUSPECT_INCOMPRESSIBLE_SAMPLE_RATIO 10  /* Must be >= 2 */\n\nunsigned HUF_cardinality(const unsigned* count, unsigned maxSymbolValue)\n{\n    unsigned cardinality = 0;\n    unsigned i;\n\n    for (i = 0; i < maxSymbolValue + 1; i++) {\n        if (count[i] != 0) cardinality += 1;\n    }\n\n    return cardinality;\n}\n\nunsigned HUF_minTableLog(unsigned symbolCardinality)\n{\n    U32 minBitsSymbols = ZSTD_highbit32(symbolCardinality) + 1;\n    return minBitsSymbols;\n}\n\nunsigned HUF_optimalTableLog(\n            unsigned maxTableLog,\n            size_t srcSize,\n            unsigned maxSymbolValue,\n            void* workSpace, size_t wkspSize,\n            HUF_CElt* table,\n      const unsigned* count,\n            int flags)\n{\n    assert(srcSize > 1); /* Not supported, RLE should be used instead */\n    assert(wkspSize >= sizeof(HUF_buildCTable_wksp_tables));\n\n    if (!(flags & HUF_flags_optimalDepth)) {\n        /* cheap evaluation, based on FSE */\n        return FSE_optimalTableLog_internal(maxTableLog, srcSize, maxSymbolValue, 1);\n    }\n\n    {   BYTE* dst = (BYTE*)workSpace + sizeof(HUF_WriteCTableWksp);\n        size_t dstSize = wkspSize - sizeof(HUF_WriteCTableWksp);\n        size_t hSize, newSize;\n        const unsigned symbolCardinality = HUF_cardinality(count, maxSymbolValue);\n        const unsigned minTableLog = HUF_minTableLog(symbolCardinality);\n        size_t optSize = ((size_t) ~0) - 1;\n        unsigned optLog = maxTableLog, optLogGuess;\n\n        DEBUGLOG(6, \"HUF_optimalTableLog: probing huf depth (srcSize=%zu)\", srcSize);\n\n        /* Search until size increases */\n        for (optLogGuess = minTableLog; optLogGuess <= maxTableLog; optLogGuess++) {\n            DEBUGLOG(7, \"checking for huffLog=%u\", optLogGuess);\n\n            {   size_t maxBits = HUF_buildCTable_wksp(table, count, maxSymbolValue, optLogGuess, workSpace, wkspSize);\n                if (ERR_isError(maxBits)) continue;\n\n                if (maxBits < optLogGuess && optLogGuess > minTableLog) break;\n\n                hSize = HUF_writeCTable_wksp(dst, dstSize, table, maxSymbolValue, (U32)maxBits, workSpace, wkspSize);\n            }\n\n            if (ERR_isError(hSize)) continue;\n\n            newSize = HUF_estimateCompressedSize(table, count, maxSymbolValue) + hSize;\n\n            if (newSize > optSize + 1) {\n                break;\n            }\n\n            if (newSize < optSize) {\n                optSize = newSize;\n                optLog = optLogGuess;\n            }\n        }\n        assert(optLog <= HUF_TABLELOG_MAX);\n        return optLog;\n    }\n}\n\n/* HUF_compress_internal() :\n * `workSpace_align4` must be aligned on 4-bytes boundaries,\n * and occupies the same space as a table of HUF_WORKSPACE_SIZE_U64 unsigned */\nstatic size_t\nHUF_compress_internal (void* dst, size_t dstSize,\n                 const void* src, size_t srcSize,\n                       unsigned maxSymbolValue, unsigned huffLog,\n                       HUF_nbStreams_e nbStreams,\n                       void* workSpace, size_t wkspSize,\n                       HUF_CElt* oldHufTable, HUF_repeat* repeat, int flags)\n{\n    HUF_compress_tables_t* const table = (HUF_compress_tables_t*)HUF_alignUpWorkspace(workSpace, &wkspSize, ZSTD_ALIGNOF(size_t));\n    BYTE* const ostart = (BYTE*)dst;\n    BYTE* const oend = ostart + dstSize;\n    BYTE* op = ostart;\n\n    DEBUGLOG(5, \"HUF_compress_internal (srcSize=%zu)\", srcSize);\n    HUF_STATIC_ASSERT(sizeof(*table) + HUF_WORKSPACE_MAX_ALIGNMENT <= HUF_WORKSPACE_SIZE);\n\n    /* checks & inits */\n    if (wkspSize < sizeof(*table)) return ERROR(workSpace_tooSmall);\n    if (!srcSize) return 0;  /* Uncompressed */\n    if (!dstSize) return 0;  /* cannot fit anything within dst budget */\n    if (srcSize > HUF_BLOCKSIZE_MAX) return ERROR(srcSize_wrong);   /* current block size limit */\n    if (huffLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);\n    if (maxSymbolValue > HUF_SYMBOLVALUE_MAX) return ERROR(maxSymbolValue_tooLarge);\n    if (!maxSymbolValue) maxSymbolValue = HUF_SYMBOLVALUE_MAX;\n    if (!huffLog) huffLog = HUF_TABLELOG_DEFAULT;\n\n    /* Heuristic : If old table is valid, use it for small inputs */\n    if ((flags & HUF_flags_preferRepeat) && repeat && *repeat == HUF_repeat_valid) {\n        return HUF_compressCTable_internal(ostart, op, oend,\n                                           src, srcSize,\n                                           nbStreams, oldHufTable, flags);\n    }\n\n    /* If uncompressible data is suspected, do a smaller sampling first */\n    DEBUG_STATIC_ASSERT(SUSPECT_INCOMPRESSIBLE_SAMPLE_RATIO >= 2);\n    if ((flags & HUF_flags_suspectUncompressible) && srcSize >= (SUSPECT_INCOMPRESSIBLE_SAMPLE_SIZE * SUSPECT_INCOMPRESSIBLE_SAMPLE_RATIO)) {\n        size_t largestTotal = 0;\n        DEBUGLOG(5, \"input suspected incompressible : sampling to check\");\n        {   unsigned maxSymbolValueBegin = maxSymbolValue;\n            CHECK_V_F(largestBegin, HIST_count_simple (table->count, &maxSymbolValueBegin, (const BYTE*)src, SUSPECT_INCOMPRESSIBLE_SAMPLE_SIZE) );\n            largestTotal += largestBegin;\n        }\n        {   unsigned maxSymbolValueEnd = maxSymbolValue;\n            CHECK_V_F(largestEnd, HIST_count_simple (table->count, &maxSymbolValueEnd, (const BYTE*)src + srcSize - SUSPECT_INCOMPRESSIBLE_SAMPLE_SIZE, SUSPECT_INCOMPRESSIBLE_SAMPLE_SIZE) );\n            largestTotal += largestEnd;\n        }\n        if (largestTotal <= ((2 * SUSPECT_INCOMPRESSIBLE_SAMPLE_SIZE) >> 7)+4) return 0;   /* heuristic : probably not compressible enough */\n    }\n\n    /* Scan input and build symbol stats */\n    {   CHECK_V_F(largest, HIST_count_wksp (table->count, &maxSymbolValue, (const BYTE*)src, srcSize, table->wksps.hist_wksp, sizeof(table->wksps.hist_wksp)) );\n        if (largest == srcSize) { *ostart = ((const BYTE*)src)[0]; return 1; }   /* single symbol, rle */\n        if (largest <= (srcSize >> 7)+4) return 0;   /* heuristic : probably not compressible enough */\n    }\n    DEBUGLOG(6, \"histogram detail completed (%zu symbols)\", showU32(table->count, maxSymbolValue+1));\n\n    /* Check validity of previous table */\n    if ( repeat\n      && *repeat == HUF_repeat_check\n      && !HUF_validateCTable(oldHufTable, table->count, maxSymbolValue)) {\n        *repeat = HUF_repeat_none;\n    }\n    /* Heuristic : use existing table for small inputs */\n    if ((flags & HUF_flags_preferRepeat) && repeat && *repeat != HUF_repeat_none) {\n        return HUF_compressCTable_internal(ostart, op, oend,\n                                           src, srcSize,\n                                           nbStreams, oldHufTable, flags);\n    }\n\n    /* Build Huffman Tree */\n    huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue, &table->wksps, sizeof(table->wksps), table->CTable, table->count, flags);\n    {   size_t const maxBits = HUF_buildCTable_wksp(table->CTable, table->count,\n                                            maxSymbolValue, huffLog,\n                                            &table->wksps.buildCTable_wksp, sizeof(table->wksps.buildCTable_wksp));\n        CHECK_F(maxBits);\n        huffLog = (U32)maxBits;\n        DEBUGLOG(6, \"bit distribution completed (%zu symbols)\", showCTableBits(table->CTable + 1, maxSymbolValue+1));\n    }\n\n    /* Write table description header */\n    {   CHECK_V_F(hSize, HUF_writeCTable_wksp(op, dstSize, table->CTable, maxSymbolValue, huffLog,\n                                              &table->wksps.writeCTable_wksp, sizeof(table->wksps.writeCTable_wksp)) );\n        /* Check if using previous huffman table is beneficial */\n        if (repeat && *repeat != HUF_repeat_none) {\n            size_t const oldSize = HUF_estimateCompressedSize(oldHufTable, table->count, maxSymbolValue);\n            size_t const newSize = HUF_estimateCompressedSize(table->CTable, table->count, maxSymbolValue);\n            if (oldSize <= hSize + newSize || hSize + 12 >= srcSize) {\n                return HUF_compressCTable_internal(ostart, op, oend,\n                                                   src, srcSize,\n                                                   nbStreams, oldHufTable, flags);\n        }   }\n\n        /* Use the new huffman table */\n        if (hSize + 12ul >= srcSize) { return 0; }\n        op += hSize;\n        if (repeat) { *repeat = HUF_repeat_none; }\n        if (oldHufTable)\n            ZSTD_memcpy(oldHufTable, table->CTable, sizeof(table->CTable));  /* Save new table */\n    }\n    return HUF_compressCTable_internal(ostart, op, oend,\n                                       src, srcSize,\n                                       nbStreams, table->CTable, flags);\n}\n\nsize_t HUF_compress1X_repeat (void* dst, size_t dstSize,\n                      const void* src, size_t srcSize,\n                      unsigned maxSymbolValue, unsigned huffLog,\n                      void* workSpace, size_t wkspSize,\n                      HUF_CElt* hufTable, HUF_repeat* repeat, int flags)\n{\n    DEBUGLOG(5, \"HUF_compress1X_repeat (srcSize = %zu)\", srcSize);\n    return HUF_compress_internal(dst, dstSize, src, srcSize,\n                                 maxSymbolValue, huffLog, HUF_singleStream,\n                                 workSpace, wkspSize, hufTable,\n                                 repeat, flags);\n}\n\n/* HUF_compress4X_repeat():\n * compress input using 4 streams.\n * consider skipping quickly\n * reuse an existing huffman compression table */\nsize_t HUF_compress4X_repeat (void* dst, size_t dstSize,\n                      const void* src, size_t srcSize,\n                      unsigned maxSymbolValue, unsigned huffLog,\n                      void* workSpace, size_t wkspSize,\n                      HUF_CElt* hufTable, HUF_repeat* repeat, int flags)\n{\n    DEBUGLOG(5, \"HUF_compress4X_repeat (srcSize = %zu)\", srcSize);\n    return HUF_compress_internal(dst, dstSize, src, srcSize,\n                                 maxSymbolValue, huffLog, HUF_fourStreams,\n                                 workSpace, wkspSize,\n                                 hufTable, repeat, flags);\n}\n"
  },
  {
    "path": "lib/compress/zstd_compress.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/*-*************************************\n*  Dependencies\n***************************************/\n#include \"../common/allocations.h\"  /* ZSTD_customMalloc, ZSTD_customCalloc, ZSTD_customFree */\n#include \"../common/zstd_deps.h\"  /* INT_MAX, ZSTD_memset, ZSTD_memcpy */\n#include \"../common/mem.h\"\n#include \"../common/error_private.h\"\n#include \"hist.h\"           /* HIST_countFast_wksp */\n#define FSE_STATIC_LINKING_ONLY   /* FSE_encodeSymbol */\n#include \"../common/fse.h\"\n#include \"../common/huf.h\"\n#include \"zstd_compress_internal.h\"\n#include \"zstd_compress_sequences.h\"\n#include \"zstd_compress_literals.h\"\n#include \"zstd_fast.h\"\n#include \"zstd_double_fast.h\"\n#include \"zstd_lazy.h\"\n#include \"zstd_opt.h\"\n#include \"zstd_ldm.h\"\n#include \"zstd_compress_superblock.h\"\n#include  \"../common/bits.h\"      /* ZSTD_highbit32, ZSTD_rotateRight_U64 */\n\n/* ***************************************************************\n*  Tuning parameters\n*****************************************************************/\n/*!\n * COMPRESS_HEAPMODE :\n * Select how default decompression function ZSTD_compress() allocates its context,\n * on stack (0, default), or into heap (1).\n * Note that functions with explicit context such as ZSTD_compressCCtx() are unaffected.\n */\n#ifndef ZSTD_COMPRESS_HEAPMODE\n#  define ZSTD_COMPRESS_HEAPMODE 0\n#endif\n\n/*!\n * ZSTD_HASHLOG3_MAX :\n * Maximum size of the hash table dedicated to find 3-bytes matches,\n * in log format, aka 17 => 1 << 17 == 128Ki positions.\n * This structure is only used in zstd_opt.\n * Since allocation is centralized for all strategies, it has to be known here.\n * The actual (selected) size of the hash table is then stored in ZSTD_MatchState_t.hashLog3,\n * so that zstd_opt.c doesn't need to know about this constant.\n */\n#ifndef ZSTD_HASHLOG3_MAX\n#  define ZSTD_HASHLOG3_MAX 17\n#endif\n\n\n/*-*************************************\n*  Forward declarations\n***************************************/\nsize_t convertSequences_noRepcodes(SeqDef* dstSeqs, const ZSTD_Sequence* inSeqs,\n    size_t nbSequences);\n\n\n/*-*************************************\n*  Helper functions\n***************************************/\n/* ZSTD_compressBound()\n * Note that the result from this function is only valid for\n * the one-pass compression functions.\n * When employing the streaming mode,\n * if flushes are frequently altering the size of blocks,\n * the overhead from block headers can make the compressed data larger\n * than the return value of ZSTD_compressBound().\n */\nsize_t ZSTD_compressBound(size_t srcSize) {\n    size_t const r = ZSTD_COMPRESSBOUND(srcSize);\n    if (r==0) return ERROR(srcSize_wrong);\n    return r;\n}\n\n\n/*-*************************************\n*  Context memory management\n***************************************/\nstruct ZSTD_CDict_s {\n    const void* dictContent;\n    size_t dictContentSize;\n    ZSTD_dictContentType_e dictContentType; /* The dictContentType the CDict was created with */\n    U32* entropyWorkspace; /* entropy workspace of HUF_WORKSPACE_SIZE bytes */\n    ZSTD_cwksp workspace;\n    ZSTD_MatchState_t matchState;\n    ZSTD_compressedBlockState_t cBlockState;\n    ZSTD_customMem customMem;\n    U32 dictID;\n    int compressionLevel; /* 0 indicates that advanced API was used to select CDict params */\n    ZSTD_ParamSwitch_e useRowMatchFinder; /* Indicates whether the CDict was created with params that would use\n                                           * row-based matchfinder. Unless the cdict is reloaded, we will use\n                                           * the same greedy/lazy matchfinder at compression time.\n                                           */\n};  /* typedef'd to ZSTD_CDict within \"zstd.h\" */\n\nZSTD_CCtx* ZSTD_createCCtx(void)\n{\n    return ZSTD_createCCtx_advanced(ZSTD_defaultCMem);\n}\n\nstatic void ZSTD_initCCtx(ZSTD_CCtx* cctx, ZSTD_customMem memManager)\n{\n    assert(cctx != NULL);\n    ZSTD_memset(cctx, 0, sizeof(*cctx));\n    cctx->customMem = memManager;\n    cctx->bmi2 = ZSTD_cpuSupportsBmi2();\n    {   size_t const err = ZSTD_CCtx_reset(cctx, ZSTD_reset_parameters);\n        assert(!ZSTD_isError(err));\n        (void)err;\n    }\n}\n\nZSTD_CCtx* ZSTD_createCCtx_advanced(ZSTD_customMem customMem)\n{\n    ZSTD_STATIC_ASSERT(zcss_init==0);\n    ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN==(0ULL - 1));\n    if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;\n    {   ZSTD_CCtx* const cctx = (ZSTD_CCtx*)ZSTD_customMalloc(sizeof(ZSTD_CCtx), customMem);\n        if (!cctx) return NULL;\n        ZSTD_initCCtx(cctx, customMem);\n        return cctx;\n    }\n}\n\nZSTD_CCtx* ZSTD_initStaticCCtx(void* workspace, size_t workspaceSize)\n{\n    ZSTD_cwksp ws;\n    ZSTD_CCtx* cctx;\n    if (workspaceSize <= sizeof(ZSTD_CCtx)) return NULL;  /* minimum size */\n    if ((size_t)workspace & 7) return NULL;  /* must be 8-aligned */\n    ZSTD_cwksp_init(&ws, workspace, workspaceSize, ZSTD_cwksp_static_alloc);\n\n    cctx = (ZSTD_CCtx*)ZSTD_cwksp_reserve_object(&ws, sizeof(ZSTD_CCtx));\n    if (cctx == NULL) return NULL;\n\n    ZSTD_memset(cctx, 0, sizeof(ZSTD_CCtx));\n    ZSTD_cwksp_move(&cctx->workspace, &ws);\n    cctx->staticSize = workspaceSize;\n\n    /* statically sized space. tmpWorkspace never moves (but prev/next block swap places) */\n    if (!ZSTD_cwksp_check_available(&cctx->workspace, TMP_WORKSPACE_SIZE + 2 * sizeof(ZSTD_compressedBlockState_t))) return NULL;\n    cctx->blockState.prevCBlock = (ZSTD_compressedBlockState_t*)ZSTD_cwksp_reserve_object(&cctx->workspace, sizeof(ZSTD_compressedBlockState_t));\n    cctx->blockState.nextCBlock = (ZSTD_compressedBlockState_t*)ZSTD_cwksp_reserve_object(&cctx->workspace, sizeof(ZSTD_compressedBlockState_t));\n    cctx->tmpWorkspace = ZSTD_cwksp_reserve_object(&cctx->workspace, TMP_WORKSPACE_SIZE);\n    cctx->tmpWkspSize = TMP_WORKSPACE_SIZE;\n    cctx->bmi2 = ZSTD_cpuid_bmi2(ZSTD_cpuid());\n    return cctx;\n}\n\n/**\n * Clears and frees all of the dictionaries in the CCtx.\n */\nstatic void ZSTD_clearAllDicts(ZSTD_CCtx* cctx)\n{\n    ZSTD_customFree(cctx->localDict.dictBuffer, cctx->customMem);\n    ZSTD_freeCDict(cctx->localDict.cdict);\n    ZSTD_memset(&cctx->localDict, 0, sizeof(cctx->localDict));\n    ZSTD_memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));\n    cctx->cdict = NULL;\n}\n\nstatic size_t ZSTD_sizeof_localDict(ZSTD_localDict dict)\n{\n    size_t const bufferSize = dict.dictBuffer != NULL ? dict.dictSize : 0;\n    size_t const cdictSize = ZSTD_sizeof_CDict(dict.cdict);\n    return bufferSize + cdictSize;\n}\n\nstatic void ZSTD_freeCCtxContent(ZSTD_CCtx* cctx)\n{\n    assert(cctx != NULL);\n    assert(cctx->staticSize == 0);\n    ZSTD_clearAllDicts(cctx);\n#ifdef ZSTD_MULTITHREAD\n    ZSTDMT_freeCCtx(cctx->mtctx); cctx->mtctx = NULL;\n#endif\n    ZSTD_cwksp_free(&cctx->workspace, cctx->customMem);\n}\n\nsize_t ZSTD_freeCCtx(ZSTD_CCtx* cctx)\n{\n    DEBUGLOG(3, \"ZSTD_freeCCtx (address: %p)\", (void*)cctx);\n    if (cctx==NULL) return 0;   /* support free on NULL */\n    RETURN_ERROR_IF(cctx->staticSize, memory_allocation,\n                    \"not compatible with static CCtx\");\n    {   int cctxInWorkspace = ZSTD_cwksp_owns_buffer(&cctx->workspace, cctx);\n        ZSTD_freeCCtxContent(cctx);\n        if (!cctxInWorkspace) ZSTD_customFree(cctx, cctx->customMem);\n    }\n    return 0;\n}\n\n\nstatic size_t ZSTD_sizeof_mtctx(const ZSTD_CCtx* cctx)\n{\n#ifdef ZSTD_MULTITHREAD\n    return ZSTDMT_sizeof_CCtx(cctx->mtctx);\n#else\n    (void)cctx;\n    return 0;\n#endif\n}\n\n\nsize_t ZSTD_sizeof_CCtx(const ZSTD_CCtx* cctx)\n{\n    if (cctx==NULL) return 0;   /* support sizeof on NULL */\n    /* cctx may be in the workspace */\n    return (cctx->workspace.workspace == cctx ? 0 : sizeof(*cctx))\n           + ZSTD_cwksp_sizeof(&cctx->workspace)\n           + ZSTD_sizeof_localDict(cctx->localDict)\n           + ZSTD_sizeof_mtctx(cctx);\n}\n\nsize_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs)\n{\n    return ZSTD_sizeof_CCtx(zcs);  /* same object */\n}\n\n/* private API call, for dictBuilder only */\nconst SeqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx) { return &(ctx->seqStore); }\n\n/* Returns true if the strategy supports using a row based matchfinder */\nstatic int ZSTD_rowMatchFinderSupported(const ZSTD_strategy strategy) {\n    return (strategy >= ZSTD_greedy && strategy <= ZSTD_lazy2);\n}\n\n/* Returns true if the strategy and useRowMatchFinder mode indicate that we will use the row based matchfinder\n * for this compression.\n */\nstatic int ZSTD_rowMatchFinderUsed(const ZSTD_strategy strategy, const ZSTD_ParamSwitch_e mode) {\n    assert(mode != ZSTD_ps_auto);\n    return ZSTD_rowMatchFinderSupported(strategy) && (mode == ZSTD_ps_enable);\n}\n\n/* Returns row matchfinder usage given an initial mode and cParams */\nstatic ZSTD_ParamSwitch_e ZSTD_resolveRowMatchFinderMode(ZSTD_ParamSwitch_e mode,\n                                                         const ZSTD_compressionParameters* const cParams) {\n#ifdef ZSTD_LINUX_KERNEL\n    /* The Linux Kernel does not use SIMD, and 128KB is a very common size, e.g. in BtrFS.\n     * The row match finder is slower for this size without SIMD, so disable it.\n     */\n    const unsigned kWindowLogLowerBound = 17;\n#else\n    const unsigned kWindowLogLowerBound = 14;\n#endif\n    if (mode != ZSTD_ps_auto) return mode; /* if requested enabled, but no SIMD, we still will use row matchfinder */\n    mode = ZSTD_ps_disable;\n    if (!ZSTD_rowMatchFinderSupported(cParams->strategy)) return mode;\n    if (cParams->windowLog > kWindowLogLowerBound) mode = ZSTD_ps_enable;\n    return mode;\n}\n\n/* Returns block splitter usage (generally speaking, when using slower/stronger compression modes) */\nstatic ZSTD_ParamSwitch_e ZSTD_resolveBlockSplitterMode(ZSTD_ParamSwitch_e mode,\n                                                        const ZSTD_compressionParameters* const cParams) {\n    if (mode != ZSTD_ps_auto) return mode;\n    return (cParams->strategy >= ZSTD_btopt && cParams->windowLog >= 17) ? ZSTD_ps_enable : ZSTD_ps_disable;\n}\n\n/* Returns 1 if the arguments indicate that we should allocate a chainTable, 0 otherwise */\nstatic int ZSTD_allocateChainTable(const ZSTD_strategy strategy,\n                                   const ZSTD_ParamSwitch_e useRowMatchFinder,\n                                   const U32 forDDSDict) {\n    assert(useRowMatchFinder != ZSTD_ps_auto);\n    /* We always should allocate a chaintable if we are allocating a matchstate for a DDS dictionary matchstate.\n     * We do not allocate a chaintable if we are using ZSTD_fast, or are using the row-based matchfinder.\n     */\n    return forDDSDict || ((strategy != ZSTD_fast) && !ZSTD_rowMatchFinderUsed(strategy, useRowMatchFinder));\n}\n\n/* Returns ZSTD_ps_enable if compression parameters are such that we should\n * enable long distance matching (wlog >= 27, strategy >= btopt).\n * Returns ZSTD_ps_disable otherwise.\n */\nstatic ZSTD_ParamSwitch_e ZSTD_resolveEnableLdm(ZSTD_ParamSwitch_e mode,\n                                 const ZSTD_compressionParameters* const cParams) {\n    if (mode != ZSTD_ps_auto) return mode;\n    return (cParams->strategy >= ZSTD_btopt && cParams->windowLog >= 27) ? ZSTD_ps_enable : ZSTD_ps_disable;\n}\n\nstatic int ZSTD_resolveExternalSequenceValidation(int mode) {\n    return mode;\n}\n\n/* Resolves maxBlockSize to the default if no value is present. */\nstatic size_t ZSTD_resolveMaxBlockSize(size_t maxBlockSize) {\n    if (maxBlockSize == 0) {\n        return ZSTD_BLOCKSIZE_MAX;\n    } else {\n        return maxBlockSize;\n    }\n}\n\nstatic ZSTD_ParamSwitch_e ZSTD_resolveExternalRepcodeSearch(ZSTD_ParamSwitch_e value, int cLevel) {\n    if (value != ZSTD_ps_auto) return value;\n    if (cLevel < 10) {\n        return ZSTD_ps_disable;\n    } else {\n        return ZSTD_ps_enable;\n    }\n}\n\n/* Returns 1 if compression parameters are such that CDict hashtable and chaintable indices are tagged.\n * If so, the tags need to be removed in ZSTD_resetCCtx_byCopyingCDict. */\nstatic int ZSTD_CDictIndicesAreTagged(const ZSTD_compressionParameters* const cParams) {\n    return cParams->strategy == ZSTD_fast || cParams->strategy == ZSTD_dfast;\n}\n\nstatic ZSTD_CCtx_params ZSTD_makeCCtxParamsFromCParams(\n        ZSTD_compressionParameters cParams)\n{\n    ZSTD_CCtx_params cctxParams;\n    /* should not matter, as all cParams are presumed properly defined */\n    ZSTD_CCtxParams_init(&cctxParams, ZSTD_CLEVEL_DEFAULT);\n    cctxParams.cParams = cParams;\n\n    /* Adjust advanced params according to cParams */\n    cctxParams.ldmParams.enableLdm = ZSTD_resolveEnableLdm(cctxParams.ldmParams.enableLdm, &cParams);\n    if (cctxParams.ldmParams.enableLdm == ZSTD_ps_enable) {\n        ZSTD_ldm_adjustParameters(&cctxParams.ldmParams, &cParams);\n        assert(cctxParams.ldmParams.hashLog >= cctxParams.ldmParams.bucketSizeLog);\n        assert(cctxParams.ldmParams.hashRateLog < 32);\n    }\n    cctxParams.postBlockSplitter = ZSTD_resolveBlockSplitterMode(cctxParams.postBlockSplitter, &cParams);\n    cctxParams.useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(cctxParams.useRowMatchFinder, &cParams);\n    cctxParams.validateSequences = ZSTD_resolveExternalSequenceValidation(cctxParams.validateSequences);\n    cctxParams.maxBlockSize = ZSTD_resolveMaxBlockSize(cctxParams.maxBlockSize);\n    cctxParams.searchForExternalRepcodes = ZSTD_resolveExternalRepcodeSearch(cctxParams.searchForExternalRepcodes,\n                                                                             cctxParams.compressionLevel);\n    assert(!ZSTD_checkCParams(cParams));\n    return cctxParams;\n}\n\nstatic ZSTD_CCtx_params* ZSTD_createCCtxParams_advanced(\n        ZSTD_customMem customMem)\n{\n    ZSTD_CCtx_params* params;\n    if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;\n    params = (ZSTD_CCtx_params*)ZSTD_customCalloc(\n            sizeof(ZSTD_CCtx_params), customMem);\n    if (!params) { return NULL; }\n    ZSTD_CCtxParams_init(params, ZSTD_CLEVEL_DEFAULT);\n    params->customMem = customMem;\n    return params;\n}\n\nZSTD_CCtx_params* ZSTD_createCCtxParams(void)\n{\n    return ZSTD_createCCtxParams_advanced(ZSTD_defaultCMem);\n}\n\nsize_t ZSTD_freeCCtxParams(ZSTD_CCtx_params* params)\n{\n    if (params == NULL) { return 0; }\n    ZSTD_customFree(params, params->customMem);\n    return 0;\n}\n\nsize_t ZSTD_CCtxParams_reset(ZSTD_CCtx_params* params)\n{\n    return ZSTD_CCtxParams_init(params, ZSTD_CLEVEL_DEFAULT);\n}\n\nsize_t ZSTD_CCtxParams_init(ZSTD_CCtx_params* cctxParams, int compressionLevel) {\n    RETURN_ERROR_IF(!cctxParams, GENERIC, \"NULL pointer!\");\n    ZSTD_memset(cctxParams, 0, sizeof(*cctxParams));\n    cctxParams->compressionLevel = compressionLevel;\n    cctxParams->fParams.contentSizeFlag = 1;\n    return 0;\n}\n\n#define ZSTD_NO_CLEVEL 0\n\n/**\n * Initializes `cctxParams` from `params` and `compressionLevel`.\n * @param compressionLevel If params are derived from a compression level then that compression level, otherwise ZSTD_NO_CLEVEL.\n */\nstatic void\nZSTD_CCtxParams_init_internal(ZSTD_CCtx_params* cctxParams,\n                        const ZSTD_parameters* params,\n                              int compressionLevel)\n{\n    assert(!ZSTD_checkCParams(params->cParams));\n    ZSTD_memset(cctxParams, 0, sizeof(*cctxParams));\n    cctxParams->cParams = params->cParams;\n    cctxParams->fParams = params->fParams;\n    /* Should not matter, as all cParams are presumed properly defined.\n     * But, set it for tracing anyway.\n     */\n    cctxParams->compressionLevel = compressionLevel;\n    cctxParams->useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(cctxParams->useRowMatchFinder, ¶ms->cParams);\n    cctxParams->postBlockSplitter = ZSTD_resolveBlockSplitterMode(cctxParams->postBlockSplitter, ¶ms->cParams);\n    cctxParams->ldmParams.enableLdm = ZSTD_resolveEnableLdm(cctxParams->ldmParams.enableLdm, ¶ms->cParams);\n    cctxParams->validateSequences = ZSTD_resolveExternalSequenceValidation(cctxParams->validateSequences);\n    cctxParams->maxBlockSize = ZSTD_resolveMaxBlockSize(cctxParams->maxBlockSize);\n    cctxParams->searchForExternalRepcodes = ZSTD_resolveExternalRepcodeSearch(cctxParams->searchForExternalRepcodes, compressionLevel);\n    DEBUGLOG(4, \"ZSTD_CCtxParams_init_internal: useRowMatchFinder=%d, useBlockSplitter=%d ldm=%d\",\n                cctxParams->useRowMatchFinder, cctxParams->postBlockSplitter, cctxParams->ldmParams.enableLdm);\n}\n\nsize_t ZSTD_CCtxParams_init_advanced(ZSTD_CCtx_params* cctxParams, ZSTD_parameters params)\n{\n    RETURN_ERROR_IF(!cctxParams, GENERIC, \"NULL pointer!\");\n    FORWARD_IF_ERROR( ZSTD_checkCParams(params.cParams) , \"\");\n    ZSTD_CCtxParams_init_internal(cctxParams, ¶ms, ZSTD_NO_CLEVEL);\n    return 0;\n}\n\n/**\n * Sets cctxParams' cParams and fParams from params, but otherwise leaves them alone.\n * @param params Validated zstd parameters.\n */\nstatic void ZSTD_CCtxParams_setZstdParams(\n        ZSTD_CCtx_params* cctxParams, const ZSTD_parameters* params)\n{\n    assert(!ZSTD_checkCParams(params->cParams));\n    cctxParams->cParams = params->cParams;\n    cctxParams->fParams = params->fParams;\n    /* Should not matter, as all cParams are presumed properly defined.\n     * But, set it for tracing anyway.\n     */\n    cctxParams->compressionLevel = ZSTD_NO_CLEVEL;\n}\n\nZSTD_bounds ZSTD_cParam_getBounds(ZSTD_cParameter param)\n{\n    ZSTD_bounds bounds = { 0, 0, 0 };\n\n    switch(param)\n    {\n    case ZSTD_c_compressionLevel:\n        bounds.lowerBound = ZSTD_minCLevel();\n        bounds.upperBound = ZSTD_maxCLevel();\n        return bounds;\n\n    case ZSTD_c_windowLog:\n        bounds.lowerBound = ZSTD_WINDOWLOG_MIN;\n        bounds.upperBound = ZSTD_WINDOWLOG_MAX;\n        return bounds;\n\n    case ZSTD_c_hashLog:\n        bounds.lowerBound = ZSTD_HASHLOG_MIN;\n        bounds.upperBound = ZSTD_HASHLOG_MAX;\n        return bounds;\n\n    case ZSTD_c_chainLog:\n        bounds.lowerBound = ZSTD_CHAINLOG_MIN;\n        bounds.upperBound = ZSTD_CHAINLOG_MAX;\n        return bounds;\n\n    case ZSTD_c_searchLog:\n        bounds.lowerBound = ZSTD_SEARCHLOG_MIN;\n        bounds.upperBound = ZSTD_SEARCHLOG_MAX;\n        return bounds;\n\n    case ZSTD_c_minMatch:\n        bounds.lowerBound = ZSTD_MINMATCH_MIN;\n        bounds.upperBound = ZSTD_MINMATCH_MAX;\n        return bounds;\n\n    case ZSTD_c_targetLength:\n        bounds.lowerBound = ZSTD_TARGETLENGTH_MIN;\n        bounds.upperBound = ZSTD_TARGETLENGTH_MAX;\n        return bounds;\n\n    case ZSTD_c_strategy:\n        bounds.lowerBound = ZSTD_STRATEGY_MIN;\n        bounds.upperBound = ZSTD_STRATEGY_MAX;\n        return bounds;\n\n    case ZSTD_c_contentSizeFlag:\n        bounds.lowerBound = 0;\n        bounds.upperBound = 1;\n        return bounds;\n\n    case ZSTD_c_checksumFlag:\n        bounds.lowerBound = 0;\n        bounds.upperBound = 1;\n        return bounds;\n\n    case ZSTD_c_dictIDFlag:\n        bounds.lowerBound = 0;\n        bounds.upperBound = 1;\n        return bounds;\n\n    case ZSTD_c_nbWorkers:\n        bounds.lowerBound = 0;\n#ifdef ZSTD_MULTITHREAD\n        bounds.upperBound = ZSTDMT_NBWORKERS_MAX;\n#else\n        bounds.upperBound = 0;\n#endif\n        return bounds;\n\n    case ZSTD_c_jobSize:\n        bounds.lowerBound = 0;\n#ifdef ZSTD_MULTITHREAD\n        bounds.upperBound = ZSTDMT_JOBSIZE_MAX;\n#else\n        bounds.upperBound = 0;\n#endif\n        return bounds;\n\n    case ZSTD_c_overlapLog:\n#ifdef ZSTD_MULTITHREAD\n        bounds.lowerBound = ZSTD_OVERLAPLOG_MIN;\n        bounds.upperBound = ZSTD_OVERLAPLOG_MAX;\n#else\n        bounds.lowerBound = 0;\n        bounds.upperBound = 0;\n#endif\n        return bounds;\n\n    case ZSTD_c_enableDedicatedDictSearch:\n        bounds.lowerBound = 0;\n        bounds.upperBound = 1;\n        return bounds;\n\n    case ZSTD_c_enableLongDistanceMatching:\n        bounds.lowerBound = (int)ZSTD_ps_auto;\n        bounds.upperBound = (int)ZSTD_ps_disable;\n        return bounds;\n\n    case ZSTD_c_ldmHashLog:\n        bounds.lowerBound = ZSTD_LDM_HASHLOG_MIN;\n        bounds.upperBound = ZSTD_LDM_HASHLOG_MAX;\n        return bounds;\n\n    case ZSTD_c_ldmMinMatch:\n        bounds.lowerBound = ZSTD_LDM_MINMATCH_MIN;\n        bounds.upperBound = ZSTD_LDM_MINMATCH_MAX;\n        return bounds;\n\n    case ZSTD_c_ldmBucketSizeLog:\n        bounds.lowerBound = ZSTD_LDM_BUCKETSIZELOG_MIN;\n        bounds.upperBound = ZSTD_LDM_BUCKETSIZELOG_MAX;\n        return bounds;\n\n    case ZSTD_c_ldmHashRateLog:\n        bounds.lowerBound = ZSTD_LDM_HASHRATELOG_MIN;\n        bounds.upperBound = ZSTD_LDM_HASHRATELOG_MAX;\n        return bounds;\n\n    /* experimental parameters */\n    case ZSTD_c_rsyncable:\n        bounds.lowerBound = 0;\n        bounds.upperBound = 1;\n        return bounds;\n\n    case ZSTD_c_forceMaxWindow :\n        bounds.lowerBound = 0;\n        bounds.upperBound = 1;\n        return bounds;\n\n    case ZSTD_c_format:\n        ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless);\n        bounds.lowerBound = ZSTD_f_zstd1;\n        bounds.upperBound = ZSTD_f_zstd1_magicless;   /* note : how to ensure at compile time that this is the highest value enum ? */\n        return bounds;\n\n    case ZSTD_c_forceAttachDict:\n        ZSTD_STATIC_ASSERT(ZSTD_dictDefaultAttach < ZSTD_dictForceLoad);\n        bounds.lowerBound = ZSTD_dictDefaultAttach;\n        bounds.upperBound = ZSTD_dictForceLoad;       /* note : how to ensure at compile time that this is the highest value enum ? */\n        return bounds;\n\n    case ZSTD_c_literalCompressionMode:\n        ZSTD_STATIC_ASSERT(ZSTD_ps_auto < ZSTD_ps_enable && ZSTD_ps_enable < ZSTD_ps_disable);\n        bounds.lowerBound = (int)ZSTD_ps_auto;\n        bounds.upperBound = (int)ZSTD_ps_disable;\n        return bounds;\n\n    case ZSTD_c_targetCBlockSize:\n        bounds.lowerBound = ZSTD_TARGETCBLOCKSIZE_MIN;\n        bounds.upperBound = ZSTD_TARGETCBLOCKSIZE_MAX;\n        return bounds;\n\n    case ZSTD_c_srcSizeHint:\n        bounds.lowerBound = ZSTD_SRCSIZEHINT_MIN;\n        bounds.upperBound = ZSTD_SRCSIZEHINT_MAX;\n        return bounds;\n\n    case ZSTD_c_stableInBuffer:\n    case ZSTD_c_stableOutBuffer:\n        bounds.lowerBound = (int)ZSTD_bm_buffered;\n        bounds.upperBound = (int)ZSTD_bm_stable;\n        return bounds;\n\n    case ZSTD_c_blockDelimiters:\n        bounds.lowerBound = (int)ZSTD_sf_noBlockDelimiters;\n        bounds.upperBound = (int)ZSTD_sf_explicitBlockDelimiters;\n        return bounds;\n\n    case ZSTD_c_validateSequences:\n        bounds.lowerBound = 0;\n        bounds.upperBound = 1;\n        return bounds;\n\n    case ZSTD_c_splitAfterSequences:\n        bounds.lowerBound = (int)ZSTD_ps_auto;\n        bounds.upperBound = (int)ZSTD_ps_disable;\n        return bounds;\n\n    case ZSTD_c_blockSplitterLevel:\n        bounds.lowerBound = 0;\n        bounds.upperBound = ZSTD_BLOCKSPLITTER_LEVEL_MAX;\n        return bounds;\n\n    case ZSTD_c_useRowMatchFinder:\n        bounds.lowerBound = (int)ZSTD_ps_auto;\n        bounds.upperBound = (int)ZSTD_ps_disable;\n        return bounds;\n\n    case ZSTD_c_deterministicRefPrefix:\n        bounds.lowerBound = 0;\n        bounds.upperBound = 1;\n        return bounds;\n\n    case ZSTD_c_prefetchCDictTables:\n        bounds.lowerBound = (int)ZSTD_ps_auto;\n        bounds.upperBound = (int)ZSTD_ps_disable;\n        return bounds;\n\n    case ZSTD_c_enableSeqProducerFallback:\n        bounds.lowerBound = 0;\n        bounds.upperBound = 1;\n        return bounds;\n\n    case ZSTD_c_maxBlockSize:\n        bounds.lowerBound = ZSTD_BLOCKSIZE_MAX_MIN;\n        bounds.upperBound = ZSTD_BLOCKSIZE_MAX;\n        return bounds;\n\n    case ZSTD_c_repcodeResolution:\n        bounds.lowerBound = (int)ZSTD_ps_auto;\n        bounds.upperBound = (int)ZSTD_ps_disable;\n        return bounds;\n\n    default:\n        bounds.error = ERROR(parameter_unsupported);\n        return bounds;\n    }\n}\n\n/* ZSTD_cParam_clampBounds:\n * Clamps the value into the bounded range.\n */\nstatic size_t ZSTD_cParam_clampBounds(ZSTD_cParameter cParam, int* value)\n{\n    ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);\n    if (ZSTD_isError(bounds.error)) return bounds.error;\n    if (*value < bounds.lowerBound) *value = bounds.lowerBound;\n    if (*value > bounds.upperBound) *value = bounds.upperBound;\n    return 0;\n}\n\n#define BOUNDCHECK(cParam, val)                                       \\\n    do {                                                              \\\n        RETURN_ERROR_IF(!ZSTD_cParam_withinBounds(cParam,val),        \\\n                        parameter_outOfBound, \"Param out of bounds\"); \\\n    } while (0)\n\n\nstatic int ZSTD_isUpdateAuthorized(ZSTD_cParameter param)\n{\n    switch(param)\n    {\n    case ZSTD_c_compressionLevel:\n    case ZSTD_c_hashLog:\n    case ZSTD_c_chainLog:\n    case ZSTD_c_searchLog:\n    case ZSTD_c_minMatch:\n    case ZSTD_c_targetLength:\n    case ZSTD_c_strategy:\n    case ZSTD_c_blockSplitterLevel:\n        return 1;\n\n    case ZSTD_c_format:\n    case ZSTD_c_windowLog:\n    case ZSTD_c_contentSizeFlag:\n    case ZSTD_c_checksumFlag:\n    case ZSTD_c_dictIDFlag:\n    case ZSTD_c_forceMaxWindow :\n    case ZSTD_c_nbWorkers:\n    case ZSTD_c_jobSize:\n    case ZSTD_c_overlapLog:\n    case ZSTD_c_rsyncable:\n    case ZSTD_c_enableDedicatedDictSearch:\n    case ZSTD_c_enableLongDistanceMatching:\n    case ZSTD_c_ldmHashLog:\n    case ZSTD_c_ldmMinMatch:\n    case ZSTD_c_ldmBucketSizeLog:\n    case ZSTD_c_ldmHashRateLog:\n    case ZSTD_c_forceAttachDict:\n    case ZSTD_c_literalCompressionMode:\n    case ZSTD_c_targetCBlockSize:\n    case ZSTD_c_srcSizeHint:\n    case ZSTD_c_stableInBuffer:\n    case ZSTD_c_stableOutBuffer:\n    case ZSTD_c_blockDelimiters:\n    case ZSTD_c_validateSequences:\n    case ZSTD_c_splitAfterSequences:\n    case ZSTD_c_useRowMatchFinder:\n    case ZSTD_c_deterministicRefPrefix:\n    case ZSTD_c_prefetchCDictTables:\n    case ZSTD_c_enableSeqProducerFallback:\n    case ZSTD_c_maxBlockSize:\n    case ZSTD_c_repcodeResolution:\n    default:\n        return 0;\n    }\n}\n\nsize_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, int value)\n{\n    DEBUGLOG(4, \"ZSTD_CCtx_setParameter (%i, %i)\", (int)param, value);\n    if (cctx->streamStage != zcss_init) {\n        if (ZSTD_isUpdateAuthorized(param)) {\n            cctx->cParamsChanged = 1;\n        } else {\n            RETURN_ERROR(stage_wrong, \"can only set params in cctx init stage\");\n    }   }\n\n    switch(param)\n    {\n    case ZSTD_c_nbWorkers:\n        RETURN_ERROR_IF((value!=0) && cctx->staticSize, parameter_unsupported,\n                        \"MT not compatible with static alloc\");\n        break;\n\n    case ZSTD_c_compressionLevel:\n    case ZSTD_c_windowLog:\n    case ZSTD_c_hashLog:\n    case ZSTD_c_chainLog:\n    case ZSTD_c_searchLog:\n    case ZSTD_c_minMatch:\n    case ZSTD_c_targetLength:\n    case ZSTD_c_strategy:\n    case ZSTD_c_ldmHashRateLog:\n    case ZSTD_c_format:\n    case ZSTD_c_contentSizeFlag:\n    case ZSTD_c_checksumFlag:\n    case ZSTD_c_dictIDFlag:\n    case ZSTD_c_forceMaxWindow:\n    case ZSTD_c_forceAttachDict:\n    case ZSTD_c_literalCompressionMode:\n    case ZSTD_c_jobSize:\n    case ZSTD_c_overlapLog:\n    case ZSTD_c_rsyncable:\n    case ZSTD_c_enableDedicatedDictSearch:\n    case ZSTD_c_enableLongDistanceMatching:\n    case ZSTD_c_ldmHashLog:\n    case ZSTD_c_ldmMinMatch:\n    case ZSTD_c_ldmBucketSizeLog:\n    case ZSTD_c_targetCBlockSize:\n    case ZSTD_c_srcSizeHint:\n    case ZSTD_c_stableInBuffer:\n    case ZSTD_c_stableOutBuffer:\n    case ZSTD_c_blockDelimiters:\n    case ZSTD_c_validateSequences:\n    case ZSTD_c_splitAfterSequences:\n    case ZSTD_c_blockSplitterLevel:\n    case ZSTD_c_useRowMatchFinder:\n    case ZSTD_c_deterministicRefPrefix:\n    case ZSTD_c_prefetchCDictTables:\n    case ZSTD_c_enableSeqProducerFallback:\n    case ZSTD_c_maxBlockSize:\n    case ZSTD_c_repcodeResolution:\n        break;\n\n    default: RETURN_ERROR(parameter_unsupported, \"unknown parameter\");\n    }\n    return ZSTD_CCtxParams_setParameter(&cctx->requestedParams, param, value);\n}\n\nsize_t ZSTD_CCtxParams_setParameter(ZSTD_CCtx_params* CCtxParams,\n                                    ZSTD_cParameter param, int value)\n{\n    DEBUGLOG(4, \"ZSTD_CCtxParams_setParameter (%i, %i)\", (int)param, value);\n    switch(param)\n    {\n    case ZSTD_c_format :\n        BOUNDCHECK(ZSTD_c_format, value);\n        CCtxParams->format = (ZSTD_format_e)value;\n        return (size_t)CCtxParams->format;\n\n    case ZSTD_c_compressionLevel : {\n        FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value), \"\");\n        if (value == 0)\n            CCtxParams->compressionLevel = ZSTD_CLEVEL_DEFAULT; /* 0 == default */\n        else\n            CCtxParams->compressionLevel = value;\n        if (CCtxParams->compressionLevel >= 0) return (size_t)CCtxParams->compressionLevel;\n        return 0;  /* return type (size_t) cannot represent negative values */\n    }\n\n    case ZSTD_c_windowLog :\n        if (value!=0)   /* 0 => use default */\n            BOUNDCHECK(ZSTD_c_windowLog, value);\n        CCtxParams->cParams.windowLog = (U32)value;\n        return CCtxParams->cParams.windowLog;\n\n    case ZSTD_c_hashLog :\n        if (value!=0)   /* 0 => use default */\n            BOUNDCHECK(ZSTD_c_hashLog, value);\n        CCtxParams->cParams.hashLog = (U32)value;\n        return CCtxParams->cParams.hashLog;\n\n    case ZSTD_c_chainLog :\n        if (value!=0)   /* 0 => use default */\n            BOUNDCHECK(ZSTD_c_chainLog, value);\n        CCtxParams->cParams.chainLog = (U32)value;\n        return CCtxParams->cParams.chainLog;\n\n    case ZSTD_c_searchLog :\n        if (value!=0)   /* 0 => use default */\n            BOUNDCHECK(ZSTD_c_searchLog, value);\n        CCtxParams->cParams.searchLog = (U32)value;\n        return (size_t)value;\n\n    case ZSTD_c_minMatch :\n        if (value!=0)   /* 0 => use default */\n            BOUNDCHECK(ZSTD_c_minMatch, value);\n        CCtxParams->cParams.minMatch = (U32)value;\n        return CCtxParams->cParams.minMatch;\n\n    case ZSTD_c_targetLength :\n        BOUNDCHECK(ZSTD_c_targetLength, value);\n        CCtxParams->cParams.targetLength = (U32)value;\n        return CCtxParams->cParams.targetLength;\n\n    case ZSTD_c_strategy :\n        if (value!=0)   /* 0 => use default */\n            BOUNDCHECK(ZSTD_c_strategy, value);\n        CCtxParams->cParams.strategy = (ZSTD_strategy)value;\n        return (size_t)CCtxParams->cParams.strategy;\n\n    case ZSTD_c_contentSizeFlag :\n        /* Content size written in frame header _when known_ (default:1) */\n        DEBUGLOG(4, \"set content size flag = %u\", (value!=0));\n        CCtxParams->fParams.contentSizeFlag = value != 0;\n        return (size_t)CCtxParams->fParams.contentSizeFlag;\n\n    case ZSTD_c_checksumFlag :\n        /* A 32-bits content checksum will be calculated and written at end of frame (default:0) */\n        CCtxParams->fParams.checksumFlag = value != 0;\n        return (size_t)CCtxParams->fParams.checksumFlag;\n\n    case ZSTD_c_dictIDFlag : /* When applicable, dictionary's dictID is provided in frame header (default:1) */\n        DEBUGLOG(4, \"set dictIDFlag = %u\", (value!=0));\n        CCtxParams->fParams.noDictIDFlag = !value;\n        return !CCtxParams->fParams.noDictIDFlag;\n\n    case ZSTD_c_forceMaxWindow :\n        CCtxParams->forceWindow = (value != 0);\n        return (size_t)CCtxParams->forceWindow;\n\n    case ZSTD_c_forceAttachDict : {\n        const ZSTD_dictAttachPref_e pref = (ZSTD_dictAttachPref_e)value;\n        BOUNDCHECK(ZSTD_c_forceAttachDict, (int)pref);\n        CCtxParams->attachDictPref = pref;\n        return CCtxParams->attachDictPref;\n    }\n\n    case ZSTD_c_literalCompressionMode : {\n        const ZSTD_ParamSwitch_e lcm = (ZSTD_ParamSwitch_e)value;\n        BOUNDCHECK(ZSTD_c_literalCompressionMode, (int)lcm);\n        CCtxParams->literalCompressionMode = lcm;\n        return CCtxParams->literalCompressionMode;\n    }\n\n    case ZSTD_c_nbWorkers :\n#ifndef ZSTD_MULTITHREAD\n        RETURN_ERROR_IF(value!=0, parameter_unsupported, \"not compiled with multithreading\");\n        return 0;\n#else\n        FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value), \"\");\n        CCtxParams->nbWorkers = value;\n        return (size_t)(CCtxParams->nbWorkers);\n#endif\n\n    case ZSTD_c_jobSize :\n#ifndef ZSTD_MULTITHREAD\n        RETURN_ERROR_IF(value!=0, parameter_unsupported, \"not compiled with multithreading\");\n        return 0;\n#else\n        /* Adjust to the minimum non-default value. */\n        if (value != 0 && value < ZSTDMT_JOBSIZE_MIN)\n            value = ZSTDMT_JOBSIZE_MIN;\n        FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(param, &value), \"\");\n        assert(value >= 0);\n        CCtxParams->jobSize = (size_t)value;\n        return CCtxParams->jobSize;\n#endif\n\n    case ZSTD_c_overlapLog :\n#ifndef ZSTD_MULTITHREAD\n        RETURN_ERROR_IF(value!=0, parameter_unsupported, \"not compiled with multithreading\");\n        return 0;\n#else\n        FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(ZSTD_c_overlapLog, &value), \"\");\n        CCtxParams->overlapLog = value;\n        return (size_t)CCtxParams->overlapLog;\n#endif\n\n    case ZSTD_c_rsyncable :\n#ifndef ZSTD_MULTITHREAD\n        RETURN_ERROR_IF(value!=0, parameter_unsupported, \"not compiled with multithreading\");\n        return 0;\n#else\n        FORWARD_IF_ERROR(ZSTD_cParam_clampBounds(ZSTD_c_overlapLog, &value), \"\");\n        CCtxParams->rsyncable = value;\n        return (size_t)CCtxParams->rsyncable;\n#endif\n\n    case ZSTD_c_enableDedicatedDictSearch :\n        CCtxParams->enableDedicatedDictSearch = (value!=0);\n        return (size_t)CCtxParams->enableDedicatedDictSearch;\n\n    case ZSTD_c_enableLongDistanceMatching :\n        BOUNDCHECK(ZSTD_c_enableLongDistanceMatching, value);\n        CCtxParams->ldmParams.enableLdm = (ZSTD_ParamSwitch_e)value;\n        return CCtxParams->ldmParams.enableLdm;\n\n    case ZSTD_c_ldmHashLog :\n        if (value!=0)   /* 0 ==> auto */\n            BOUNDCHECK(ZSTD_c_ldmHashLog, value);\n        CCtxParams->ldmParams.hashLog = (U32)value;\n        return CCtxParams->ldmParams.hashLog;\n\n    case ZSTD_c_ldmMinMatch :\n        if (value!=0)   /* 0 ==> default */\n            BOUNDCHECK(ZSTD_c_ldmMinMatch, value);\n        CCtxParams->ldmParams.minMatchLength = (U32)value;\n        return CCtxParams->ldmParams.minMatchLength;\n\n    case ZSTD_c_ldmBucketSizeLog :\n        if (value!=0)   /* 0 ==> default */\n            BOUNDCHECK(ZSTD_c_ldmBucketSizeLog, value);\n        CCtxParams->ldmParams.bucketSizeLog = (U32)value;\n        return CCtxParams->ldmParams.bucketSizeLog;\n\n    case ZSTD_c_ldmHashRateLog :\n        if (value!=0)   /* 0 ==> default */\n            BOUNDCHECK(ZSTD_c_ldmHashRateLog, value);\n        CCtxParams->ldmParams.hashRateLog = (U32)value;\n        return CCtxParams->ldmParams.hashRateLog;\n\n    case ZSTD_c_targetCBlockSize :\n        if (value!=0) {  /* 0 ==> default */\n            value = MAX(value, ZSTD_TARGETCBLOCKSIZE_MIN);\n            BOUNDCHECK(ZSTD_c_targetCBlockSize, value);\n        }\n        CCtxParams->targetCBlockSize = (U32)value;\n        return CCtxParams->targetCBlockSize;\n\n    case ZSTD_c_srcSizeHint :\n        if (value!=0)    /* 0 ==> default */\n            BOUNDCHECK(ZSTD_c_srcSizeHint, value);\n        CCtxParams->srcSizeHint = value;\n        return (size_t)CCtxParams->srcSizeHint;\n\n    case ZSTD_c_stableInBuffer:\n        BOUNDCHECK(ZSTD_c_stableInBuffer, value);\n        CCtxParams->inBufferMode = (ZSTD_bufferMode_e)value;\n        return CCtxParams->inBufferMode;\n\n    case ZSTD_c_stableOutBuffer:\n        BOUNDCHECK(ZSTD_c_stableOutBuffer, value);\n        CCtxParams->outBufferMode = (ZSTD_bufferMode_e)value;\n        return CCtxParams->outBufferMode;\n\n    case ZSTD_c_blockDelimiters:\n        BOUNDCHECK(ZSTD_c_blockDelimiters, value);\n        CCtxParams->blockDelimiters = (ZSTD_SequenceFormat_e)value;\n        return CCtxParams->blockDelimiters;\n\n    case ZSTD_c_validateSequences:\n        BOUNDCHECK(ZSTD_c_validateSequences, value);\n        CCtxParams->validateSequences = value;\n        return (size_t)CCtxParams->validateSequences;\n\n    case ZSTD_c_splitAfterSequences:\n        BOUNDCHECK(ZSTD_c_splitAfterSequences, value);\n        CCtxParams->postBlockSplitter = (ZSTD_ParamSwitch_e)value;\n        return CCtxParams->postBlockSplitter;\n\n    case ZSTD_c_blockSplitterLevel:\n        BOUNDCHECK(ZSTD_c_blockSplitterLevel, value);\n        CCtxParams->preBlockSplitter_level = value;\n        return (size_t)CCtxParams->preBlockSplitter_level;\n\n    case ZSTD_c_useRowMatchFinder:\n        BOUNDCHECK(ZSTD_c_useRowMatchFinder, value);\n        CCtxParams->useRowMatchFinder = (ZSTD_ParamSwitch_e)value;\n        return CCtxParams->useRowMatchFinder;\n\n    case ZSTD_c_deterministicRefPrefix:\n        BOUNDCHECK(ZSTD_c_deterministicRefPrefix, value);\n        CCtxParams->deterministicRefPrefix = !!value;\n        return (size_t)CCtxParams->deterministicRefPrefix;\n\n    case ZSTD_c_prefetchCDictTables:\n        BOUNDCHECK(ZSTD_c_prefetchCDictTables, value);\n        CCtxParams->prefetchCDictTables = (ZSTD_ParamSwitch_e)value;\n        return CCtxParams->prefetchCDictTables;\n\n    case ZSTD_c_enableSeqProducerFallback:\n        BOUNDCHECK(ZSTD_c_enableSeqProducerFallback, value);\n        CCtxParams->enableMatchFinderFallback = value;\n        return (size_t)CCtxParams->enableMatchFinderFallback;\n\n    case ZSTD_c_maxBlockSize:\n        if (value!=0)    /* 0 ==> default */\n            BOUNDCHECK(ZSTD_c_maxBlockSize, value);\n        assert(value>=0);\n        CCtxParams->maxBlockSize = (size_t)value;\n        return CCtxParams->maxBlockSize;\n\n    case ZSTD_c_repcodeResolution:\n        BOUNDCHECK(ZSTD_c_repcodeResolution, value);\n        CCtxParams->searchForExternalRepcodes = (ZSTD_ParamSwitch_e)value;\n        return CCtxParams->searchForExternalRepcodes;\n\n    default: RETURN_ERROR(parameter_unsupported, \"unknown parameter\");\n    }\n}\n\nsize_t ZSTD_CCtx_getParameter(ZSTD_CCtx const* cctx, ZSTD_cParameter param, int* value)\n{\n    return ZSTD_CCtxParams_getParameter(&cctx->requestedParams, param, value);\n}\n\nsize_t ZSTD_CCtxParams_getParameter(\n        ZSTD_CCtx_params const* CCtxParams, ZSTD_cParameter param, int* value)\n{\n    switch(param)\n    {\n    case ZSTD_c_format :\n        *value = (int)CCtxParams->format;\n        break;\n    case ZSTD_c_compressionLevel :\n        *value = CCtxParams->compressionLevel;\n        break;\n    case ZSTD_c_windowLog :\n        *value = (int)CCtxParams->cParams.windowLog;\n        break;\n    case ZSTD_c_hashLog :\n        *value = (int)CCtxParams->cParams.hashLog;\n        break;\n    case ZSTD_c_chainLog :\n        *value = (int)CCtxParams->cParams.chainLog;\n        break;\n    case ZSTD_c_searchLog :\n        *value = (int)CCtxParams->cParams.searchLog;\n        break;\n    case ZSTD_c_minMatch :\n        *value = (int)CCtxParams->cParams.minMatch;\n        break;\n    case ZSTD_c_targetLength :\n        *value = (int)CCtxParams->cParams.targetLength;\n        break;\n    case ZSTD_c_strategy :\n        *value = (int)CCtxParams->cParams.strategy;\n        break;\n    case ZSTD_c_contentSizeFlag :\n        *value = CCtxParams->fParams.contentSizeFlag;\n        break;\n    case ZSTD_c_checksumFlag :\n        *value = CCtxParams->fParams.checksumFlag;\n        break;\n    case ZSTD_c_dictIDFlag :\n        *value = !CCtxParams->fParams.noDictIDFlag;\n        break;\n    case ZSTD_c_forceMaxWindow :\n        *value = CCtxParams->forceWindow;\n        break;\n    case ZSTD_c_forceAttachDict :\n        *value = (int)CCtxParams->attachDictPref;\n        break;\n    case ZSTD_c_literalCompressionMode :\n        *value = (int)CCtxParams->literalCompressionMode;\n        break;\n    case ZSTD_c_nbWorkers :\n#ifndef ZSTD_MULTITHREAD\n        assert(CCtxParams->nbWorkers == 0);\n#endif\n        *value = CCtxParams->nbWorkers;\n        break;\n    case ZSTD_c_jobSize :\n#ifndef ZSTD_MULTITHREAD\n        RETURN_ERROR(parameter_unsupported, \"not compiled with multithreading\");\n#else\n        assert(CCtxParams->jobSize <= INT_MAX);\n        *value = (int)CCtxParams->jobSize;\n        break;\n#endif\n    case ZSTD_c_overlapLog :\n#ifndef ZSTD_MULTITHREAD\n        RETURN_ERROR(parameter_unsupported, \"not compiled with multithreading\");\n#else\n        *value = CCtxParams->overlapLog;\n        break;\n#endif\n    case ZSTD_c_rsyncable :\n#ifndef ZSTD_MULTITHREAD\n        RETURN_ERROR(parameter_unsupported, \"not compiled with multithreading\");\n#else\n        *value = CCtxParams->rsyncable;\n        break;\n#endif\n    case ZSTD_c_enableDedicatedDictSearch :\n        *value = CCtxParams->enableDedicatedDictSearch;\n        break;\n    case ZSTD_c_enableLongDistanceMatching :\n        *value = (int)CCtxParams->ldmParams.enableLdm;\n        break;\n    case ZSTD_c_ldmHashLog :\n        *value = (int)CCtxParams->ldmParams.hashLog;\n        break;\n    case ZSTD_c_ldmMinMatch :\n        *value = (int)CCtxParams->ldmParams.minMatchLength;\n        break;\n    case ZSTD_c_ldmBucketSizeLog :\n        *value = (int)CCtxParams->ldmParams.bucketSizeLog;\n        break;\n    case ZSTD_c_ldmHashRateLog :\n        *value = (int)CCtxParams->ldmParams.hashRateLog;\n        break;\n    case ZSTD_c_targetCBlockSize :\n        *value = (int)CCtxParams->targetCBlockSize;\n        break;\n    case ZSTD_c_srcSizeHint :\n        *value = (int)CCtxParams->srcSizeHint;\n        break;\n    case ZSTD_c_stableInBuffer :\n        *value = (int)CCtxParams->inBufferMode;\n        break;\n    case ZSTD_c_stableOutBuffer :\n        *value = (int)CCtxParams->outBufferMode;\n        break;\n    case ZSTD_c_blockDelimiters :\n        *value = (int)CCtxParams->blockDelimiters;\n        break;\n    case ZSTD_c_validateSequences :\n        *value = (int)CCtxParams->validateSequences;\n        break;\n    case ZSTD_c_splitAfterSequences :\n        *value = (int)CCtxParams->postBlockSplitter;\n        break;\n    case ZSTD_c_blockSplitterLevel :\n        *value = CCtxParams->preBlockSplitter_level;\n        break;\n    case ZSTD_c_useRowMatchFinder :\n        *value = (int)CCtxParams->useRowMatchFinder;\n        break;\n    case ZSTD_c_deterministicRefPrefix:\n        *value = (int)CCtxParams->deterministicRefPrefix;\n        break;\n    case ZSTD_c_prefetchCDictTables:\n        *value = (int)CCtxParams->prefetchCDictTables;\n        break;\n    case ZSTD_c_enableSeqProducerFallback:\n        *value = CCtxParams->enableMatchFinderFallback;\n        break;\n    case ZSTD_c_maxBlockSize:\n        *value = (int)CCtxParams->maxBlockSize;\n        break;\n    case ZSTD_c_repcodeResolution:\n        *value = (int)CCtxParams->searchForExternalRepcodes;\n        break;\n    default: RETURN_ERROR(parameter_unsupported, \"unknown parameter\");\n    }\n    return 0;\n}\n\n/** ZSTD_CCtx_setParametersUsingCCtxParams() :\n *  just applies `params` into `cctx`\n *  no action is performed, parameters are merely stored.\n *  If ZSTDMT is enabled, parameters are pushed to cctx->mtctx.\n *    This is possible even if a compression is ongoing.\n *    In which case, new parameters will be applied on the fly, starting with next compression job.\n */\nsize_t ZSTD_CCtx_setParametersUsingCCtxParams(\n        ZSTD_CCtx* cctx, const ZSTD_CCtx_params* params)\n{\n    DEBUGLOG(4, \"ZSTD_CCtx_setParametersUsingCCtxParams\");\n    RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,\n                    \"The context is in the wrong stage!\");\n    RETURN_ERROR_IF(cctx->cdict, stage_wrong,\n                    \"Can't override parameters with cdict attached (some must \"\n                    \"be inherited from the cdict).\");\n\n    cctx->requestedParams = *params;\n    return 0;\n}\n\nsize_t ZSTD_CCtx_setCParams(ZSTD_CCtx* cctx, ZSTD_compressionParameters cparams)\n{\n    ZSTD_STATIC_ASSERT(sizeof(cparams) == 7 * 4 /* all params are listed below */);\n    DEBUGLOG(4, \"ZSTD_CCtx_setCParams\");\n    /* only update if all parameters are valid */\n    FORWARD_IF_ERROR(ZSTD_checkCParams(cparams), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_windowLog, (int)cparams.windowLog), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_chainLog, (int)cparams.chainLog), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_hashLog, (int)cparams.hashLog), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_searchLog, (int)cparams.searchLog), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_minMatch, (int)cparams.minMatch), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_targetLength, (int)cparams.targetLength), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_strategy, (int)cparams.strategy), \"\");\n    return 0;\n}\n\nsize_t ZSTD_CCtx_setFParams(ZSTD_CCtx* cctx, ZSTD_frameParameters fparams)\n{\n    ZSTD_STATIC_ASSERT(sizeof(fparams) == 3 * 4 /* all params are listed below */);\n    DEBUGLOG(4, \"ZSTD_CCtx_setFParams\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_contentSizeFlag, fparams.contentSizeFlag != 0), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_checksumFlag, fparams.checksumFlag != 0), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_dictIDFlag, fparams.noDictIDFlag == 0), \"\");\n    return 0;\n}\n\nsize_t ZSTD_CCtx_setParams(ZSTD_CCtx* cctx, ZSTD_parameters params)\n{\n    DEBUGLOG(4, \"ZSTD_CCtx_setParams\");\n    /* First check cParams, because we want to update all or none. */\n    FORWARD_IF_ERROR(ZSTD_checkCParams(params.cParams), \"\");\n    /* Next set fParams, because this could fail if the cctx isn't in init stage. */\n    FORWARD_IF_ERROR(ZSTD_CCtx_setFParams(cctx, params.fParams), \"\");\n    /* Finally set cParams, which should succeed. */\n    FORWARD_IF_ERROR(ZSTD_CCtx_setCParams(cctx, params.cParams), \"\");\n    return 0;\n}\n\nsize_t ZSTD_CCtx_setPledgedSrcSize(ZSTD_CCtx* cctx, unsigned long long pledgedSrcSize)\n{\n    DEBUGLOG(4, \"ZSTD_CCtx_setPledgedSrcSize to %llu bytes\", pledgedSrcSize);\n    RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,\n                    \"Can't set pledgedSrcSize when not in init stage.\");\n    cctx->pledgedSrcSizePlusOne = pledgedSrcSize+1;\n    return 0;\n}\n\nstatic ZSTD_compressionParameters ZSTD_dedicatedDictSearch_getCParams(\n        int const compressionLevel,\n        size_t const dictSize);\nstatic int ZSTD_dedicatedDictSearch_isSupported(\n        const ZSTD_compressionParameters* cParams);\nstatic void ZSTD_dedicatedDictSearch_revertCParams(\n        ZSTD_compressionParameters* cParams);\n\n/**\n * Initializes the local dictionary using requested parameters.\n * NOTE: Initialization does not employ the pledged src size,\n * because the dictionary may be used for multiple compressions.\n */\nstatic size_t ZSTD_initLocalDict(ZSTD_CCtx* cctx)\n{\n    ZSTD_localDict* const dl = &cctx->localDict;\n    if (dl->dict == NULL) {\n        /* No local dictionary. */\n        assert(dl->dictBuffer == NULL);\n        assert(dl->cdict == NULL);\n        assert(dl->dictSize == 0);\n        return 0;\n    }\n    if (dl->cdict != NULL) {\n        /* Local dictionary already initialized. */\n        assert(cctx->cdict == dl->cdict);\n        return 0;\n    }\n    assert(dl->dictSize > 0);\n    assert(cctx->cdict == NULL);\n    assert(cctx->prefixDict.dict == NULL);\n\n    dl->cdict = ZSTD_createCDict_advanced2(\n            dl->dict,\n            dl->dictSize,\n            ZSTD_dlm_byRef,\n            dl->dictContentType,\n            &cctx->requestedParams,\n            cctx->customMem);\n    RETURN_ERROR_IF(!dl->cdict, memory_allocation, \"ZSTD_createCDict_advanced failed\");\n    cctx->cdict = dl->cdict;\n    return 0;\n}\n\nsize_t ZSTD_CCtx_loadDictionary_advanced(\n        ZSTD_CCtx* cctx,\n        const void* dict, size_t dictSize,\n        ZSTD_dictLoadMethod_e dictLoadMethod,\n        ZSTD_dictContentType_e dictContentType)\n{\n    DEBUGLOG(4, \"ZSTD_CCtx_loadDictionary_advanced (size: %u)\", (U32)dictSize);\n    RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,\n                    \"Can't load a dictionary when cctx is not in init stage.\");\n    ZSTD_clearAllDicts(cctx);  /* erase any previously set dictionary */\n    if (dict == NULL || dictSize == 0)  /* no dictionary */\n        return 0;\n    if (dictLoadMethod == ZSTD_dlm_byRef) {\n        cctx->localDict.dict = dict;\n    } else {\n        /* copy dictionary content inside CCtx to own its lifetime */\n        void* dictBuffer;\n        RETURN_ERROR_IF(cctx->staticSize, memory_allocation,\n                        \"static CCtx can't allocate for an internal copy of dictionary\");\n        dictBuffer = ZSTD_customMalloc(dictSize, cctx->customMem);\n        RETURN_ERROR_IF(dictBuffer==NULL, memory_allocation,\n                        \"allocation failed for dictionary content\");\n        ZSTD_memcpy(dictBuffer, dict, dictSize);\n        cctx->localDict.dictBuffer = dictBuffer;  /* owned ptr to free */\n        cctx->localDict.dict = dictBuffer;        /* read-only reference */\n    }\n    cctx->localDict.dictSize = dictSize;\n    cctx->localDict.dictContentType = dictContentType;\n    return 0;\n}\n\nsize_t ZSTD_CCtx_loadDictionary_byReference(\n      ZSTD_CCtx* cctx, const void* dict, size_t dictSize)\n{\n    return ZSTD_CCtx_loadDictionary_advanced(\n            cctx, dict, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto);\n}\n\nsize_t ZSTD_CCtx_loadDictionary(ZSTD_CCtx* cctx, const void* dict, size_t dictSize)\n{\n    return ZSTD_CCtx_loadDictionary_advanced(\n            cctx, dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto);\n}\n\n\nsize_t ZSTD_CCtx_refCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict)\n{\n    RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,\n                    \"Can't ref a dict when ctx not in init stage.\");\n    /* Free the existing local cdict (if any) to save memory. */\n    ZSTD_clearAllDicts(cctx);\n    cctx->cdict = cdict;\n    return 0;\n}\n\nsize_t ZSTD_CCtx_refThreadPool(ZSTD_CCtx* cctx, ZSTD_threadPool* pool)\n{\n    RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,\n                    \"Can't ref a pool when ctx not in init stage.\");\n    cctx->pool = pool;\n    return 0;\n}\n\nsize_t ZSTD_CCtx_refPrefix(ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize)\n{\n    return ZSTD_CCtx_refPrefix_advanced(cctx, prefix, prefixSize, ZSTD_dct_rawContent);\n}\n\nsize_t ZSTD_CCtx_refPrefix_advanced(\n        ZSTD_CCtx* cctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType)\n{\n    RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,\n                    \"Can't ref a prefix when ctx not in init stage.\");\n    ZSTD_clearAllDicts(cctx);\n    if (prefix != NULL && prefixSize > 0) {\n        cctx->prefixDict.dict = prefix;\n        cctx->prefixDict.dictSize = prefixSize;\n        cctx->prefixDict.dictContentType = dictContentType;\n    }\n    return 0;\n}\n\n/*! ZSTD_CCtx_reset() :\n *  Also dumps dictionary */\nsize_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset)\n{\n    if ( (reset == ZSTD_reset_session_only)\n      || (reset == ZSTD_reset_session_and_parameters) ) {\n        cctx->streamStage = zcss_init;\n        cctx->pledgedSrcSizePlusOne = 0;\n    }\n    if ( (reset == ZSTD_reset_parameters)\n      || (reset == ZSTD_reset_session_and_parameters) ) {\n        RETURN_ERROR_IF(cctx->streamStage != zcss_init, stage_wrong,\n                        \"Reset parameters is only possible during init stage.\");\n        ZSTD_clearAllDicts(cctx);\n        return ZSTD_CCtxParams_reset(&cctx->requestedParams);\n    }\n    return 0;\n}\n\n\n/** ZSTD_checkCParams() :\n    control CParam values remain within authorized range.\n    @return : 0, or an error code if one value is beyond authorized range */\nsize_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)\n{\n    BOUNDCHECK(ZSTD_c_windowLog, (int)cParams.windowLog);\n    BOUNDCHECK(ZSTD_c_chainLog,  (int)cParams.chainLog);\n    BOUNDCHECK(ZSTD_c_hashLog,   (int)cParams.hashLog);\n    BOUNDCHECK(ZSTD_c_searchLog, (int)cParams.searchLog);\n    BOUNDCHECK(ZSTD_c_minMatch,  (int)cParams.minMatch);\n    BOUNDCHECK(ZSTD_c_targetLength,(int)cParams.targetLength);\n    BOUNDCHECK(ZSTD_c_strategy,  (int)cParams.strategy);\n    return 0;\n}\n\n/** ZSTD_clampCParams() :\n *  make CParam values within valid range.\n *  @return : valid CParams */\nstatic ZSTD_compressionParameters\nZSTD_clampCParams(ZSTD_compressionParameters cParams)\n{\n#   define CLAMP_TYPE(cParam, val, type)                                      \\\n        do {                                                                  \\\n            ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);         \\\n            if ((int)valbounds.upperBound) val=(type)bounds.upperBound; \\\n        } while (0)\n#   define CLAMP(cParam, val) CLAMP_TYPE(cParam, val, unsigned)\n    CLAMP(ZSTD_c_windowLog, cParams.windowLog);\n    CLAMP(ZSTD_c_chainLog,  cParams.chainLog);\n    CLAMP(ZSTD_c_hashLog,   cParams.hashLog);\n    CLAMP(ZSTD_c_searchLog, cParams.searchLog);\n    CLAMP(ZSTD_c_minMatch,  cParams.minMatch);\n    CLAMP(ZSTD_c_targetLength,cParams.targetLength);\n    CLAMP_TYPE(ZSTD_c_strategy,cParams.strategy, ZSTD_strategy);\n    return cParams;\n}\n\n/** ZSTD_cycleLog() :\n *  condition for correct operation : hashLog > 1 */\nU32 ZSTD_cycleLog(U32 hashLog, ZSTD_strategy strat)\n{\n    U32 const btScale = ((U32)strat >= (U32)ZSTD_btlazy2);\n    return hashLog - btScale;\n}\n\n/** ZSTD_dictAndWindowLog() :\n * Returns an adjusted window log that is large enough to fit the source and the dictionary.\n * The zstd format says that the entire dictionary is valid if one byte of the dictionary\n * is within the window. So the hashLog and chainLog should be large enough to reference both\n * the dictionary and the window. So we must use this adjusted dictAndWindowLog when downsizing\n * the hashLog and windowLog.\n * NOTE: srcSize must not be ZSTD_CONTENTSIZE_UNKNOWN.\n */\nstatic U32 ZSTD_dictAndWindowLog(U32 windowLog, U64 srcSize, U64 dictSize)\n{\n    const U64 maxWindowSize = 1ULL << ZSTD_WINDOWLOG_MAX;\n    /* No dictionary ==> No change */\n    if (dictSize == 0) {\n        return windowLog;\n    }\n    assert(windowLog <= ZSTD_WINDOWLOG_MAX);\n    assert(srcSize != ZSTD_CONTENTSIZE_UNKNOWN); /* Handled in ZSTD_adjustCParams_internal() */\n    {\n        U64 const windowSize = 1ULL << windowLog;\n        U64 const dictAndWindowSize = dictSize + windowSize;\n        /* If the window size is already large enough to fit both the source and the dictionary\n         * then just use the window size. Otherwise adjust so that it fits the dictionary and\n         * the window.\n         */\n        if (windowSize >= dictSize + srcSize) {\n            return windowLog; /* Window size large enough already */\n        } else if (dictAndWindowSize >= maxWindowSize) {\n            return ZSTD_WINDOWLOG_MAX; /* Larger than max window log */\n        } else  {\n            return ZSTD_highbit32((U32)dictAndWindowSize - 1) + 1;\n        }\n    }\n}\n\n/** ZSTD_adjustCParams_internal() :\n *  optimize `cPar` for a specified input (`srcSize` and `dictSize`).\n *  mostly downsize to reduce memory consumption and initialization latency.\n * `srcSize` can be ZSTD_CONTENTSIZE_UNKNOWN when not known.\n * `mode` is the mode for parameter adjustment. See docs for `ZSTD_CParamMode_e`.\n *  note : `srcSize==0` means 0!\n *  condition : cPar is presumed validated (can be checked using ZSTD_checkCParams()). */\nstatic ZSTD_compressionParameters\nZSTD_adjustCParams_internal(ZSTD_compressionParameters cPar,\n                            unsigned long long srcSize,\n                            size_t dictSize,\n                            ZSTD_CParamMode_e mode,\n                            ZSTD_ParamSwitch_e useRowMatchFinder)\n{\n    const U64 minSrcSize = 513; /* (1<<9) + 1 */\n    const U64 maxWindowResize = 1ULL << (ZSTD_WINDOWLOG_MAX-1);\n    assert(ZSTD_checkCParams(cPar)==0);\n\n    /* Cascade the selected strategy down to the next-highest one built into\n     * this binary. */\n#ifdef ZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR\n    if (cPar.strategy == ZSTD_btultra2) {\n        cPar.strategy = ZSTD_btultra;\n    }\n    if (cPar.strategy == ZSTD_btultra) {\n        cPar.strategy = ZSTD_btopt;\n    }\n#endif\n#ifdef ZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR\n    if (cPar.strategy == ZSTD_btopt) {\n        cPar.strategy = ZSTD_btlazy2;\n    }\n#endif\n#ifdef ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR\n    if (cPar.strategy == ZSTD_btlazy2) {\n        cPar.strategy = ZSTD_lazy2;\n    }\n#endif\n#ifdef ZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR\n    if (cPar.strategy == ZSTD_lazy2) {\n        cPar.strategy = ZSTD_lazy;\n    }\n#endif\n#ifdef ZSTD_EXCLUDE_LAZY_BLOCK_COMPRESSOR\n    if (cPar.strategy == ZSTD_lazy) {\n        cPar.strategy = ZSTD_greedy;\n    }\n#endif\n#ifdef ZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR\n    if (cPar.strategy == ZSTD_greedy) {\n        cPar.strategy = ZSTD_dfast;\n    }\n#endif\n#ifdef ZSTD_EXCLUDE_DFAST_BLOCK_COMPRESSOR\n    if (cPar.strategy == ZSTD_dfast) {\n        cPar.strategy = ZSTD_fast;\n        cPar.targetLength = 0;\n    }\n#endif\n\n    switch (mode) {\n    case ZSTD_cpm_unknown:\n    case ZSTD_cpm_noAttachDict:\n        /* If we don't know the source size, don't make any\n         * assumptions about it. We will already have selected\n         * smaller parameters if a dictionary is in use.\n         */\n        break;\n    case ZSTD_cpm_createCDict:\n        /* Assume a small source size when creating a dictionary\n         * with an unknown source size.\n         */\n        if (dictSize && srcSize == ZSTD_CONTENTSIZE_UNKNOWN)\n            srcSize = minSrcSize;\n        break;\n    case ZSTD_cpm_attachDict:\n        /* Dictionary has its own dedicated parameters which have\n         * already been selected. We are selecting parameters\n         * for only the source.\n         */\n        dictSize = 0;\n        break;\n    default:\n        assert(0);\n        break;\n    }\n\n    /* resize windowLog if input is small enough, to use less memory */\n    if ( (srcSize <= maxWindowResize)\n      && (dictSize <= maxWindowResize) )  {\n        U32 const tSize = (U32)(srcSize + dictSize);\n        static U32 const hashSizeMin = 1 << ZSTD_HASHLOG_MIN;\n        U32 const srcLog = (tSize < hashSizeMin) ? ZSTD_HASHLOG_MIN :\n                            ZSTD_highbit32(tSize-1) + 1;\n        if (cPar.windowLog > srcLog) cPar.windowLog = srcLog;\n    }\n    if (srcSize != ZSTD_CONTENTSIZE_UNKNOWN) {\n        U32 const dictAndWindowLog = ZSTD_dictAndWindowLog(cPar.windowLog, (U64)srcSize, (U64)dictSize);\n        U32 const cycleLog = ZSTD_cycleLog(cPar.chainLog, cPar.strategy);\n        if (cPar.hashLog > dictAndWindowLog+1) cPar.hashLog = dictAndWindowLog+1;\n        if (cycleLog > dictAndWindowLog)\n            cPar.chainLog -= (cycleLog - dictAndWindowLog);\n    }\n\n    if (cPar.windowLog < ZSTD_WINDOWLOG_ABSOLUTEMIN)\n        cPar.windowLog = ZSTD_WINDOWLOG_ABSOLUTEMIN;  /* minimum wlog required for valid frame header */\n\n    /* We can't use more than 32 bits of hash in total, so that means that we require:\n     * (hashLog + 8) <= 32 && (chainLog + 8) <= 32\n     */\n    if (mode == ZSTD_cpm_createCDict && ZSTD_CDictIndicesAreTagged(&cPar)) {\n        U32 const maxShortCacheHashLog = 32 - ZSTD_SHORT_CACHE_TAG_BITS;\n        if (cPar.hashLog > maxShortCacheHashLog) {\n            cPar.hashLog = maxShortCacheHashLog;\n        }\n        if (cPar.chainLog > maxShortCacheHashLog) {\n            cPar.chainLog = maxShortCacheHashLog;\n        }\n    }\n\n\n    /* At this point, we aren't 100% sure if we are using the row match finder.\n     * Unless it is explicitly disabled, conservatively assume that it is enabled.\n     * In this case it will only be disabled for small sources, so shrinking the\n     * hash log a little bit shouldn't result in any ratio loss.\n     */\n    if (useRowMatchFinder == ZSTD_ps_auto)\n        useRowMatchFinder = ZSTD_ps_enable;\n\n    /* We can't hash more than 32-bits in total. So that means that we require:\n     * (hashLog - rowLog + 8) <= 32\n     */\n    if (ZSTD_rowMatchFinderUsed(cPar.strategy, useRowMatchFinder)) {\n        /* Switch to 32-entry rows if searchLog is 5 (or more) */\n        U32 const rowLog = BOUNDED(4, cPar.searchLog, 6);\n        U32 const maxRowHashLog = 32 - ZSTD_ROW_HASH_TAG_BITS;\n        U32 const maxHashLog = maxRowHashLog + rowLog;\n        assert(cPar.hashLog >= rowLog);\n        if (cPar.hashLog > maxHashLog) {\n            cPar.hashLog = maxHashLog;\n        }\n    }\n\n    return cPar;\n}\n\nZSTD_compressionParameters\nZSTD_adjustCParams(ZSTD_compressionParameters cPar,\n                   unsigned long long srcSize,\n                   size_t dictSize)\n{\n    cPar = ZSTD_clampCParams(cPar);   /* resulting cPar is necessarily valid (all parameters within range) */\n    if (srcSize == 0) srcSize = ZSTD_CONTENTSIZE_UNKNOWN;\n    return ZSTD_adjustCParams_internal(cPar, srcSize, dictSize, ZSTD_cpm_unknown, ZSTD_ps_auto);\n}\n\nstatic ZSTD_compressionParameters ZSTD_getCParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_CParamMode_e mode);\nstatic ZSTD_parameters ZSTD_getParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_CParamMode_e mode);\n\nstatic void ZSTD_overrideCParams(\n              ZSTD_compressionParameters* cParams,\n        const ZSTD_compressionParameters* overrides)\n{\n    if (overrides->windowLog)    cParams->windowLog    = overrides->windowLog;\n    if (overrides->hashLog)      cParams->hashLog      = overrides->hashLog;\n    if (overrides->chainLog)     cParams->chainLog     = overrides->chainLog;\n    if (overrides->searchLog)    cParams->searchLog    = overrides->searchLog;\n    if (overrides->minMatch)     cParams->minMatch     = overrides->minMatch;\n    if (overrides->targetLength) cParams->targetLength = overrides->targetLength;\n    if (overrides->strategy)     cParams->strategy     = overrides->strategy;\n}\n\nZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams(\n        const ZSTD_CCtx_params* CCtxParams, U64 srcSizeHint, size_t dictSize, ZSTD_CParamMode_e mode)\n{\n    ZSTD_compressionParameters cParams;\n    if (srcSizeHint == ZSTD_CONTENTSIZE_UNKNOWN && CCtxParams->srcSizeHint > 0) {\n        assert(CCtxParams->srcSizeHint>=0);\n        srcSizeHint = (U64)CCtxParams->srcSizeHint;\n    }\n    cParams = ZSTD_getCParams_internal(CCtxParams->compressionLevel, srcSizeHint, dictSize, mode);\n    if (CCtxParams->ldmParams.enableLdm == ZSTD_ps_enable) cParams.windowLog = ZSTD_LDM_DEFAULT_WINDOW_LOG;\n    ZSTD_overrideCParams(&cParams, &CCtxParams->cParams);\n    assert(!ZSTD_checkCParams(cParams));\n    /* srcSizeHint == 0 means 0 */\n    return ZSTD_adjustCParams_internal(cParams, srcSizeHint, dictSize, mode, CCtxParams->useRowMatchFinder);\n}\n\nstatic size_t\nZSTD_sizeof_matchState(const ZSTD_compressionParameters* const cParams,\n                       const ZSTD_ParamSwitch_e useRowMatchFinder,\n                       const int enableDedicatedDictSearch,\n                       const U32 forCCtx)\n{\n    /* chain table size should be 0 for fast or row-hash strategies */\n    size_t const chainSize = ZSTD_allocateChainTable(cParams->strategy, useRowMatchFinder, enableDedicatedDictSearch && !forCCtx)\n                                ? ((size_t)1 << cParams->chainLog)\n                                : 0;\n    size_t const hSize = ((size_t)1) << cParams->hashLog;\n    U32    const hashLog3 = (forCCtx && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;\n    size_t const h3Size = hashLog3 ? ((size_t)1) << hashLog3 : 0;\n    /* We don't use ZSTD_cwksp_alloc_size() here because the tables aren't\n     * surrounded by redzones in ASAN. */\n    size_t const tableSpace = chainSize * sizeof(U32)\n                            + hSize * sizeof(U32)\n                            + h3Size * sizeof(U32);\n    size_t const optPotentialSpace =\n        ZSTD_cwksp_aligned64_alloc_size((MaxML+1) * sizeof(U32))\n      + ZSTD_cwksp_aligned64_alloc_size((MaxLL+1) * sizeof(U32))\n      + ZSTD_cwksp_aligned64_alloc_size((MaxOff+1) * sizeof(U32))\n      + ZSTD_cwksp_aligned64_alloc_size((1<strategy, useRowMatchFinder)\n                                            ? ZSTD_cwksp_aligned64_alloc_size(hSize)\n                                            : 0;\n    size_t const optSpace = (forCCtx && (cParams->strategy >= ZSTD_btopt))\n                                ? optPotentialSpace\n                                : 0;\n    size_t const slackSpace = ZSTD_cwksp_slack_space_required();\n\n    /* tables are guaranteed to be sized in multiples of 64 bytes (or 16 uint32_t) */\n    ZSTD_STATIC_ASSERT(ZSTD_HASHLOG_MIN >= 4 && ZSTD_WINDOWLOG_MIN >= 4 && ZSTD_CHAINLOG_MIN >= 4);\n    assert(useRowMatchFinder != ZSTD_ps_auto);\n\n    DEBUGLOG(4, \"chainSize: %u - hSize: %u - h3Size: %u\",\n                (U32)chainSize, (U32)hSize, (U32)h3Size);\n    return tableSpace + optSpace + slackSpace + lazyAdditionalSpace;\n}\n\n/* Helper function for calculating memory requirements.\n * Gives a tighter bound than ZSTD_sequenceBound() by taking minMatch into account. */\nstatic size_t ZSTD_maxNbSeq(size_t blockSize, unsigned minMatch, int useSequenceProducer) {\n    U32 const divider = (minMatch==3 || useSequenceProducer) ? 3 : 4;\n    return blockSize / divider;\n}\n\nstatic size_t ZSTD_estimateCCtxSize_usingCCtxParams_internal(\n        const ZSTD_compressionParameters* cParams,\n        const ldmParams_t* ldmParams,\n        const int isStatic,\n        const ZSTD_ParamSwitch_e useRowMatchFinder,\n        const size_t buffInSize,\n        const size_t buffOutSize,\n        const U64 pledgedSrcSize,\n        int useSequenceProducer,\n        size_t maxBlockSize)\n{\n    size_t const windowSize = (size_t) BOUNDED(1ULL, 1ULL << cParams->windowLog, pledgedSrcSize);\n    size_t const blockSize = MIN(ZSTD_resolveMaxBlockSize(maxBlockSize), windowSize);\n    size_t const maxNbSeq = ZSTD_maxNbSeq(blockSize, cParams->minMatch, useSequenceProducer);\n    size_t const tokenSpace = ZSTD_cwksp_alloc_size(WILDCOPY_OVERLENGTH + blockSize)\n                            + ZSTD_cwksp_aligned64_alloc_size(maxNbSeq * sizeof(SeqDef))\n                            + 3 * ZSTD_cwksp_alloc_size(maxNbSeq * sizeof(BYTE));\n    size_t const tmpWorkSpace = ZSTD_cwksp_alloc_size(TMP_WORKSPACE_SIZE);\n    size_t const blockStateSpace = 2 * ZSTD_cwksp_alloc_size(sizeof(ZSTD_compressedBlockState_t));\n    size_t const matchStateSize = ZSTD_sizeof_matchState(cParams, useRowMatchFinder, /* enableDedicatedDictSearch */ 0, /* forCCtx */ 1);\n\n    size_t const ldmSpace = ZSTD_ldm_getTableSize(*ldmParams);\n    size_t const maxNbLdmSeq = ZSTD_ldm_getMaxNbSeq(*ldmParams, blockSize);\n    size_t const ldmSeqSpace = ldmParams->enableLdm == ZSTD_ps_enable ?\n        ZSTD_cwksp_aligned64_alloc_size(maxNbLdmSeq * sizeof(rawSeq)) : 0;\n\n\n    size_t const bufferSpace = ZSTD_cwksp_alloc_size(buffInSize)\n                             + ZSTD_cwksp_alloc_size(buffOutSize);\n\n    size_t const cctxSpace = isStatic ? ZSTD_cwksp_alloc_size(sizeof(ZSTD_CCtx)) : 0;\n\n    size_t const maxNbExternalSeq = ZSTD_sequenceBound(blockSize);\n    size_t const externalSeqSpace = useSequenceProducer\n        ? ZSTD_cwksp_aligned64_alloc_size(maxNbExternalSeq * sizeof(ZSTD_Sequence))\n        : 0;\n\n    size_t const neededSpace =\n        cctxSpace +\n        tmpWorkSpace +\n        blockStateSpace +\n        ldmSpace +\n        ldmSeqSpace +\n        matchStateSize +\n        tokenSpace +\n        bufferSpace +\n        externalSeqSpace;\n\n    DEBUGLOG(5, \"estimate workspace : %u\", (U32)neededSpace);\n    return neededSpace;\n}\n\nsize_t ZSTD_estimateCCtxSize_usingCCtxParams(const ZSTD_CCtx_params* params)\n{\n    ZSTD_compressionParameters const cParams =\n                ZSTD_getCParamsFromCCtxParams(params, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_cpm_noAttachDict);\n    ldmParams_t ldmParams = params->ldmParams;\n    ZSTD_ParamSwitch_e const useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(params->useRowMatchFinder,\n                                                                               &cParams);\n\n    RETURN_ERROR_IF(params->nbWorkers > 0, GENERIC, \"Estimate CCtx size is supported for single-threaded compression only.\");\n    if (ldmParams.enableLdm == ZSTD_ps_enable) {\n        ZSTD_ldm_adjustParameters(&ldmParams, &cParams);\n    }\n    /* estimateCCtxSize is for one-shot compression. So no buffers should\n     * be needed. However, we still allocate two 0-sized buffers, which can\n     * take space under ASAN. */\n    return ZSTD_estimateCCtxSize_usingCCtxParams_internal(\n        &cParams, &ldmParams, 1, useRowMatchFinder, 0, 0, ZSTD_CONTENTSIZE_UNKNOWN, ZSTD_hasExtSeqProd(params), params->maxBlockSize);\n}\n\nsize_t ZSTD_estimateCCtxSize_usingCParams(ZSTD_compressionParameters cParams)\n{\n    ZSTD_CCtx_params initialParams = ZSTD_makeCCtxParamsFromCParams(cParams);\n    if (ZSTD_rowMatchFinderSupported(cParams.strategy)) {\n        /* Pick bigger of not using and using row-based matchfinder for greedy and lazy strategies */\n        size_t noRowCCtxSize;\n        size_t rowCCtxSize;\n        initialParams.useRowMatchFinder = ZSTD_ps_disable;\n        noRowCCtxSize = ZSTD_estimateCCtxSize_usingCCtxParams(&initialParams);\n        initialParams.useRowMatchFinder = ZSTD_ps_enable;\n        rowCCtxSize = ZSTD_estimateCCtxSize_usingCCtxParams(&initialParams);\n        return MAX(noRowCCtxSize, rowCCtxSize);\n    } else {\n        return ZSTD_estimateCCtxSize_usingCCtxParams(&initialParams);\n    }\n}\n\nstatic size_t ZSTD_estimateCCtxSize_internal(int compressionLevel)\n{\n    int tier = 0;\n    size_t largestSize = 0;\n    static const unsigned long long srcSizeTiers[4] = {16 KB, 128 KB, 256 KB, ZSTD_CONTENTSIZE_UNKNOWN};\n    for (; tier < 4; ++tier) {\n        /* Choose the set of cParams for a given level across all srcSizes that give the largest cctxSize */\n        ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, srcSizeTiers[tier], 0, ZSTD_cpm_noAttachDict);\n        largestSize = MAX(ZSTD_estimateCCtxSize_usingCParams(cParams), largestSize);\n    }\n    return largestSize;\n}\n\nsize_t ZSTD_estimateCCtxSize(int compressionLevel)\n{\n    int level;\n    size_t memBudget = 0;\n    for (level=MIN(compressionLevel, 1); level<=compressionLevel; level++) {\n        /* Ensure monotonically increasing memory usage as compression level increases */\n        size_t const newMB = ZSTD_estimateCCtxSize_internal(level);\n        if (newMB > memBudget) memBudget = newMB;\n    }\n    return memBudget;\n}\n\nsize_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params)\n{\n    RETURN_ERROR_IF(params->nbWorkers > 0, GENERIC, \"Estimate CCtx size is supported for single-threaded compression only.\");\n    {   ZSTD_compressionParameters const cParams =\n                ZSTD_getCParamsFromCCtxParams(params, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_cpm_noAttachDict);\n        ldmParams_t ldmParams = params->ldmParams;\n        size_t const blockSize = MIN(ZSTD_resolveMaxBlockSize(params->maxBlockSize), (size_t)1 << cParams.windowLog);\n        size_t const inBuffSize = (params->inBufferMode == ZSTD_bm_buffered)\n                ? ((size_t)1 << cParams.windowLog) + blockSize\n                : 0;\n        size_t const outBuffSize = (params->outBufferMode == ZSTD_bm_buffered)\n                ? ZSTD_compressBound(blockSize) + 1\n                : 0;\n        ZSTD_ParamSwitch_e const useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(params->useRowMatchFinder, ¶ms->cParams);\n\n        if (ldmParams.enableLdm == ZSTD_ps_enable) {\n            ZSTD_ldm_adjustParameters(&ldmParams, &cParams);\n        }\n        return ZSTD_estimateCCtxSize_usingCCtxParams_internal(\n            &cParams, &ldmParams, 1, useRowMatchFinder, inBuffSize, outBuffSize,\n            ZSTD_CONTENTSIZE_UNKNOWN, ZSTD_hasExtSeqProd(params), params->maxBlockSize);\n    }\n}\n\nsize_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams)\n{\n    ZSTD_CCtx_params initialParams = ZSTD_makeCCtxParamsFromCParams(cParams);\n    if (ZSTD_rowMatchFinderSupported(cParams.strategy)) {\n        /* Pick bigger of not using and using row-based matchfinder for greedy and lazy strategies */\n        size_t noRowCCtxSize;\n        size_t rowCCtxSize;\n        initialParams.useRowMatchFinder = ZSTD_ps_disable;\n        noRowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams);\n        initialParams.useRowMatchFinder = ZSTD_ps_enable;\n        rowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams);\n        return MAX(noRowCCtxSize, rowCCtxSize);\n    } else {\n        return ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams);\n    }\n}\n\nstatic size_t ZSTD_estimateCStreamSize_internal(int compressionLevel)\n{\n    ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_cpm_noAttachDict);\n    return ZSTD_estimateCStreamSize_usingCParams(cParams);\n}\n\nsize_t ZSTD_estimateCStreamSize(int compressionLevel)\n{\n    int level;\n    size_t memBudget = 0;\n    for (level=MIN(compressionLevel, 1); level<=compressionLevel; level++) {\n        size_t const newMB = ZSTD_estimateCStreamSize_internal(level);\n        if (newMB > memBudget) memBudget = newMB;\n    }\n    return memBudget;\n}\n\n/* ZSTD_getFrameProgression():\n * tells how much data has been consumed (input) and produced (output) for current frame.\n * able to count progression inside worker threads (non-blocking mode).\n */\nZSTD_frameProgression ZSTD_getFrameProgression(const ZSTD_CCtx* cctx)\n{\n#ifdef ZSTD_MULTITHREAD\n    if (cctx->appliedParams.nbWorkers > 0) {\n        return ZSTDMT_getFrameProgression(cctx->mtctx);\n    }\n#endif\n    {   ZSTD_frameProgression fp;\n        size_t const buffered = (cctx->inBuff == NULL) ? 0 :\n                                cctx->inBuffPos - cctx->inToCompress;\n        if (buffered) assert(cctx->inBuffPos >= cctx->inToCompress);\n        assert(buffered <= ZSTD_BLOCKSIZE_MAX);\n        fp.ingested = cctx->consumedSrcSize + buffered;\n        fp.consumed = cctx->consumedSrcSize;\n        fp.produced = cctx->producedCSize;\n        fp.flushed  = cctx->producedCSize;   /* simplified; some data might still be left within streaming output buffer */\n        fp.currentJobID = 0;\n        fp.nbActiveWorkers = 0;\n        return fp;\n}   }\n\n/*! ZSTD_toFlushNow()\n *  Only useful for multithreading scenarios currently (nbWorkers >= 1).\n */\nsize_t ZSTD_toFlushNow(ZSTD_CCtx* cctx)\n{\n#ifdef ZSTD_MULTITHREAD\n    if (cctx->appliedParams.nbWorkers > 0) {\n        return ZSTDMT_toFlushNow(cctx->mtctx);\n    }\n#endif\n    (void)cctx;\n    return 0;   /* over-simplification; could also check if context is currently running in streaming mode, and in which case, report how many bytes are left to be flushed within output buffer */\n}\n\nstatic void ZSTD_assertEqualCParams(ZSTD_compressionParameters cParams1,\n                                    ZSTD_compressionParameters cParams2)\n{\n    (void)cParams1;\n    (void)cParams2;\n    assert(cParams1.windowLog    == cParams2.windowLog);\n    assert(cParams1.chainLog     == cParams2.chainLog);\n    assert(cParams1.hashLog      == cParams2.hashLog);\n    assert(cParams1.searchLog    == cParams2.searchLog);\n    assert(cParams1.minMatch     == cParams2.minMatch);\n    assert(cParams1.targetLength == cParams2.targetLength);\n    assert(cParams1.strategy     == cParams2.strategy);\n}\n\nvoid ZSTD_reset_compressedBlockState(ZSTD_compressedBlockState_t* bs)\n{\n    int i;\n    for (i = 0; i < ZSTD_REP_NUM; ++i)\n        bs->rep[i] = repStartValue[i];\n    bs->entropy.huf.repeatMode = HUF_repeat_none;\n    bs->entropy.fse.offcode_repeatMode = FSE_repeat_none;\n    bs->entropy.fse.matchlength_repeatMode = FSE_repeat_none;\n    bs->entropy.fse.litlength_repeatMode = FSE_repeat_none;\n}\n\n/*! ZSTD_invalidateMatchState()\n *  Invalidate all the matches in the match finder tables.\n *  Requires nextSrc and base to be set (can be NULL).\n */\nstatic void ZSTD_invalidateMatchState(ZSTD_MatchState_t* ms)\n{\n    ZSTD_window_clear(&ms->window);\n\n    ms->nextToUpdate = ms->window.dictLimit;\n    ms->loadedDictEnd = 0;\n    ms->opt.litLengthSum = 0;  /* force reset of btopt stats */\n    ms->dictMatchState = NULL;\n}\n\n/**\n * Controls, for this matchState reset, whether the tables need to be cleared /\n * prepared for the coming compression (ZSTDcrp_makeClean), or whether the\n * tables can be left unclean (ZSTDcrp_leaveDirty), because we know that a\n * subsequent operation will overwrite the table space anyways (e.g., copying\n * the matchState contents in from a CDict).\n */\ntypedef enum {\n    ZSTDcrp_makeClean,\n    ZSTDcrp_leaveDirty\n} ZSTD_compResetPolicy_e;\n\n/**\n * Controls, for this matchState reset, whether indexing can continue where it\n * left off (ZSTDirp_continue), or whether it needs to be restarted from zero\n * (ZSTDirp_reset).\n */\ntypedef enum {\n    ZSTDirp_continue,\n    ZSTDirp_reset\n} ZSTD_indexResetPolicy_e;\n\ntypedef enum {\n    ZSTD_resetTarget_CDict,\n    ZSTD_resetTarget_CCtx\n} ZSTD_resetTarget_e;\n\n/* Mixes bits in a 64 bits in a value, based on XXH3_rrmxmx */\nstatic U64 ZSTD_bitmix(U64 val, U64 len) {\n    val ^= ZSTD_rotateRight_U64(val, 49) ^ ZSTD_rotateRight_U64(val, 24);\n    val *= 0x9FB21C651E98DF25ULL;\n    val ^= (val >> 35) + len ;\n    val *= 0x9FB21C651E98DF25ULL;\n    return val ^ (val >> 28);\n}\n\n/* Mixes in the hashSalt and hashSaltEntropy to create a new hashSalt */\nstatic void ZSTD_advanceHashSalt(ZSTD_MatchState_t* ms) {\n    ms->hashSalt = ZSTD_bitmix(ms->hashSalt, 8) ^ ZSTD_bitmix((U64) ms->hashSaltEntropy, 4);\n}\n\nstatic size_t\nZSTD_reset_matchState(ZSTD_MatchState_t* ms,\n                      ZSTD_cwksp* ws,\n                const ZSTD_compressionParameters* cParams,\n                const ZSTD_ParamSwitch_e useRowMatchFinder,\n                const ZSTD_compResetPolicy_e crp,\n                const ZSTD_indexResetPolicy_e forceResetIndex,\n                const ZSTD_resetTarget_e forWho)\n{\n    /* disable chain table allocation for fast or row-based strategies */\n    size_t const chainSize = ZSTD_allocateChainTable(cParams->strategy, useRowMatchFinder,\n                                                     ms->dedicatedDictSearch && (forWho == ZSTD_resetTarget_CDict))\n                                ? ((size_t)1 << cParams->chainLog)\n                                : 0;\n    size_t const hSize = ((size_t)1) << cParams->hashLog;\n    U32    const hashLog3 = ((forWho == ZSTD_resetTarget_CCtx) && cParams->minMatch==3) ? MIN(ZSTD_HASHLOG3_MAX, cParams->windowLog) : 0;\n    size_t const h3Size = hashLog3 ? ((size_t)1) << hashLog3 : 0;\n\n    DEBUGLOG(4, \"reset indices : %u\", forceResetIndex == ZSTDirp_reset);\n    assert(useRowMatchFinder != ZSTD_ps_auto);\n    if (forceResetIndex == ZSTDirp_reset) {\n        ZSTD_window_init(&ms->window);\n        ZSTD_cwksp_mark_tables_dirty(ws);\n    }\n\n    ms->hashLog3 = hashLog3;\n    ms->lazySkipping = 0;\n\n    ZSTD_invalidateMatchState(ms);\n\n    assert(!ZSTD_cwksp_reserve_failed(ws)); /* check that allocation hasn't already failed */\n\n    ZSTD_cwksp_clear_tables(ws);\n\n    DEBUGLOG(5, \"reserving table space\");\n    /* table Space */\n    ms->hashTable = (U32*)ZSTD_cwksp_reserve_table(ws, hSize * sizeof(U32));\n    ms->chainTable = (U32*)ZSTD_cwksp_reserve_table(ws, chainSize * sizeof(U32));\n    ms->hashTable3 = (U32*)ZSTD_cwksp_reserve_table(ws, h3Size * sizeof(U32));\n    RETURN_ERROR_IF(ZSTD_cwksp_reserve_failed(ws), memory_allocation,\n                    \"failed a workspace allocation in ZSTD_reset_matchState\");\n\n    DEBUGLOG(4, \"reset table : %u\", crp!=ZSTDcrp_leaveDirty);\n    if (crp!=ZSTDcrp_leaveDirty) {\n        /* reset tables only */\n        ZSTD_cwksp_clean_tables(ws);\n    }\n\n    if (ZSTD_rowMatchFinderUsed(cParams->strategy, useRowMatchFinder)) {\n        /* Row match finder needs an additional table of hashes (\"tags\") */\n        size_t const tagTableSize = hSize;\n        /* We want to generate a new salt in case we reset a Cctx, but we always want to use\n         * 0 when we reset a Cdict */\n        if(forWho == ZSTD_resetTarget_CCtx) {\n            ms->tagTable = (BYTE*) ZSTD_cwksp_reserve_aligned_init_once(ws, tagTableSize);\n            ZSTD_advanceHashSalt(ms);\n        } else {\n            /* When we are not salting we want to always memset the memory */\n            ms->tagTable = (BYTE*) ZSTD_cwksp_reserve_aligned64(ws, tagTableSize);\n            ZSTD_memset(ms->tagTable, 0, tagTableSize);\n            ms->hashSalt = 0;\n        }\n        {   /* Switch to 32-entry rows if searchLog is 5 (or more) */\n            U32 const rowLog = BOUNDED(4, cParams->searchLog, 6);\n            assert(cParams->hashLog >= rowLog);\n            ms->rowHashLog = cParams->hashLog - rowLog;\n        }\n    }\n\n    /* opt parser space */\n    if ((forWho == ZSTD_resetTarget_CCtx) && (cParams->strategy >= ZSTD_btopt)) {\n        DEBUGLOG(4, \"reserving optimal parser space\");\n        ms->opt.litFreq = (unsigned*)ZSTD_cwksp_reserve_aligned64(ws, (1<opt.litLengthFreq = (unsigned*)ZSTD_cwksp_reserve_aligned64(ws, (MaxLL+1) * sizeof(unsigned));\n        ms->opt.matchLengthFreq = (unsigned*)ZSTD_cwksp_reserve_aligned64(ws, (MaxML+1) * sizeof(unsigned));\n        ms->opt.offCodeFreq = (unsigned*)ZSTD_cwksp_reserve_aligned64(ws, (MaxOff+1) * sizeof(unsigned));\n        ms->opt.matchTable = (ZSTD_match_t*)ZSTD_cwksp_reserve_aligned64(ws, ZSTD_OPT_SIZE * sizeof(ZSTD_match_t));\n        ms->opt.priceTable = (ZSTD_optimal_t*)ZSTD_cwksp_reserve_aligned64(ws, ZSTD_OPT_SIZE * sizeof(ZSTD_optimal_t));\n    }\n\n    ms->cParams = *cParams;\n\n    RETURN_ERROR_IF(ZSTD_cwksp_reserve_failed(ws), memory_allocation,\n                    \"failed a workspace allocation in ZSTD_reset_matchState\");\n    return 0;\n}\n\n/* ZSTD_indexTooCloseToMax() :\n * minor optimization : prefer memset() rather than reduceIndex()\n * which is measurably slow in some circumstances (reported for Visual Studio).\n * Works when re-using a context for a lot of smallish inputs :\n * if all inputs are smaller than ZSTD_INDEXOVERFLOW_MARGIN,\n * memset() will be triggered before reduceIndex().\n */\n#define ZSTD_INDEXOVERFLOW_MARGIN (16 MB)\nstatic int ZSTD_indexTooCloseToMax(ZSTD_window_t w)\n{\n    return (size_t)(w.nextSrc - w.base) > (ZSTD_CURRENT_MAX - ZSTD_INDEXOVERFLOW_MARGIN);\n}\n\n/** ZSTD_dictTooBig():\n * When dictionaries are larger than ZSTD_CHUNKSIZE_MAX they can't be loaded in\n * one go generically. So we ensure that in that case we reset the tables to zero,\n * so that we can load as much of the dictionary as possible.\n */\nstatic int ZSTD_dictTooBig(size_t const loadedDictSize)\n{\n    return loadedDictSize > ZSTD_CHUNKSIZE_MAX;\n}\n\n/*! ZSTD_resetCCtx_internal() :\n * @param loadedDictSize The size of the dictionary to be loaded\n * into the context, if any. If no dictionary is used, or the\n * dictionary is being attached / copied, then pass 0.\n * note : `params` are assumed fully validated at this stage.\n */\nstatic size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,\n                                      ZSTD_CCtx_params const* params,\n                                      U64 const pledgedSrcSize,\n                                      size_t const loadedDictSize,\n                                      ZSTD_compResetPolicy_e const crp,\n                                      ZSTD_buffered_policy_e const zbuff)\n{\n    ZSTD_cwksp* const ws = &zc->workspace;\n    DEBUGLOG(4, \"ZSTD_resetCCtx_internal: pledgedSrcSize=%u, wlog=%u, useRowMatchFinder=%d useBlockSplitter=%d\",\n                (U32)pledgedSrcSize, params->cParams.windowLog, (int)params->useRowMatchFinder, (int)params->postBlockSplitter);\n    assert(!ZSTD_isError(ZSTD_checkCParams(params->cParams)));\n\n    zc->isFirstBlock = 1;\n\n    /* Set applied params early so we can modify them for LDM,\n     * and point params at the applied params.\n     */\n    zc->appliedParams = *params;\n    params = &zc->appliedParams;\n\n    assert(params->useRowMatchFinder != ZSTD_ps_auto);\n    assert(params->postBlockSplitter != ZSTD_ps_auto);\n    assert(params->ldmParams.enableLdm != ZSTD_ps_auto);\n    assert(params->maxBlockSize != 0);\n    if (params->ldmParams.enableLdm == ZSTD_ps_enable) {\n        /* Adjust long distance matching parameters */\n        ZSTD_ldm_adjustParameters(&zc->appliedParams.ldmParams, ¶ms->cParams);\n        assert(params->ldmParams.hashLog >= params->ldmParams.bucketSizeLog);\n        assert(params->ldmParams.hashRateLog < 32);\n    }\n\n    {   size_t const windowSize = MAX(1, (size_t)MIN(((U64)1 << params->cParams.windowLog), pledgedSrcSize));\n        size_t const blockSize = MIN(params->maxBlockSize, windowSize);\n        size_t const maxNbSeq = ZSTD_maxNbSeq(blockSize, params->cParams.minMatch, ZSTD_hasExtSeqProd(params));\n        size_t const buffOutSize = (zbuff == ZSTDb_buffered && params->outBufferMode == ZSTD_bm_buffered)\n                ? ZSTD_compressBound(blockSize) + 1\n                : 0;\n        size_t const buffInSize = (zbuff == ZSTDb_buffered && params->inBufferMode == ZSTD_bm_buffered)\n                ? windowSize + blockSize\n                : 0;\n        size_t const maxNbLdmSeq = ZSTD_ldm_getMaxNbSeq(params->ldmParams, blockSize);\n\n        int const indexTooClose = ZSTD_indexTooCloseToMax(zc->blockState.matchState.window);\n        int const dictTooBig = ZSTD_dictTooBig(loadedDictSize);\n        ZSTD_indexResetPolicy_e needsIndexReset =\n            (indexTooClose || dictTooBig || !zc->initialized) ? ZSTDirp_reset : ZSTDirp_continue;\n\n        size_t const neededSpace =\n            ZSTD_estimateCCtxSize_usingCCtxParams_internal(\n                ¶ms->cParams, ¶ms->ldmParams, zc->staticSize != 0, params->useRowMatchFinder,\n                buffInSize, buffOutSize, pledgedSrcSize, ZSTD_hasExtSeqProd(params), params->maxBlockSize);\n\n        FORWARD_IF_ERROR(neededSpace, \"cctx size estimate failed!\");\n\n        if (!zc->staticSize) ZSTD_cwksp_bump_oversized_duration(ws, 0);\n\n        {   /* Check if workspace is large enough, alloc a new one if needed */\n            int const workspaceTooSmall = ZSTD_cwksp_sizeof(ws) < neededSpace;\n            int const workspaceWasteful = ZSTD_cwksp_check_wasteful(ws, neededSpace);\n            int resizeWorkspace = workspaceTooSmall || workspaceWasteful;\n            DEBUGLOG(4, \"Need %zu B workspace\", neededSpace);\n            DEBUGLOG(4, \"windowSize: %zu - blockSize: %zu\", windowSize, blockSize);\n\n            if (resizeWorkspace) {\n                DEBUGLOG(4, \"Resize workspaceSize from %zuKB to %zuKB\",\n                            ZSTD_cwksp_sizeof(ws) >> 10,\n                            neededSpace >> 10);\n\n                RETURN_ERROR_IF(zc->staticSize, memory_allocation, \"static cctx : no resize\");\n\n                needsIndexReset = ZSTDirp_reset;\n\n                ZSTD_cwksp_free(ws, zc->customMem);\n                FORWARD_IF_ERROR(ZSTD_cwksp_create(ws, neededSpace, zc->customMem), \"\");\n\n                DEBUGLOG(5, \"reserving object space\");\n                /* Statically sized space.\n                 * tmpWorkspace never moves,\n                 * though prev/next block swap places */\n                assert(ZSTD_cwksp_check_available(ws, 2 * sizeof(ZSTD_compressedBlockState_t)));\n                zc->blockState.prevCBlock = (ZSTD_compressedBlockState_t*) ZSTD_cwksp_reserve_object(ws, sizeof(ZSTD_compressedBlockState_t));\n                RETURN_ERROR_IF(zc->blockState.prevCBlock == NULL, memory_allocation, \"couldn't allocate prevCBlock\");\n                zc->blockState.nextCBlock = (ZSTD_compressedBlockState_t*) ZSTD_cwksp_reserve_object(ws, sizeof(ZSTD_compressedBlockState_t));\n                RETURN_ERROR_IF(zc->blockState.nextCBlock == NULL, memory_allocation, \"couldn't allocate nextCBlock\");\n                zc->tmpWorkspace = ZSTD_cwksp_reserve_object(ws, TMP_WORKSPACE_SIZE);\n                RETURN_ERROR_IF(zc->tmpWorkspace == NULL, memory_allocation, \"couldn't allocate tmpWorkspace\");\n                zc->tmpWkspSize = TMP_WORKSPACE_SIZE;\n        }   }\n\n        ZSTD_cwksp_clear(ws);\n\n        /* init params */\n        zc->blockState.matchState.cParams = params->cParams;\n        zc->blockState.matchState.prefetchCDictTables = params->prefetchCDictTables == ZSTD_ps_enable;\n        zc->pledgedSrcSizePlusOne = pledgedSrcSize+1;\n        zc->consumedSrcSize = 0;\n        zc->producedCSize = 0;\n        if (pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN)\n            zc->appliedParams.fParams.contentSizeFlag = 0;\n        DEBUGLOG(4, \"pledged content size : %u ; flag : %u\",\n            (unsigned)pledgedSrcSize, zc->appliedParams.fParams.contentSizeFlag);\n        zc->blockSizeMax = blockSize;\n\n        XXH64_reset(&zc->xxhState, 0);\n        zc->stage = ZSTDcs_init;\n        zc->dictID = 0;\n        zc->dictContentSize = 0;\n\n        ZSTD_reset_compressedBlockState(zc->blockState.prevCBlock);\n\n        FORWARD_IF_ERROR(ZSTD_reset_matchState(\n                &zc->blockState.matchState,\n                ws,\n                ¶ms->cParams,\n                params->useRowMatchFinder,\n                crp,\n                needsIndexReset,\n                ZSTD_resetTarget_CCtx), \"\");\n\n        zc->seqStore.sequencesStart = (SeqDef*)ZSTD_cwksp_reserve_aligned64(ws, maxNbSeq * sizeof(SeqDef));\n\n        /* ldm hash table */\n        if (params->ldmParams.enableLdm == ZSTD_ps_enable) {\n            /* TODO: avoid memset? */\n            size_t const ldmHSize = ((size_t)1) << params->ldmParams.hashLog;\n            zc->ldmState.hashTable = (ldmEntry_t*)ZSTD_cwksp_reserve_aligned64(ws, ldmHSize * sizeof(ldmEntry_t));\n            ZSTD_memset(zc->ldmState.hashTable, 0, ldmHSize * sizeof(ldmEntry_t));\n            zc->ldmSequences = (rawSeq*)ZSTD_cwksp_reserve_aligned64(ws, maxNbLdmSeq * sizeof(rawSeq));\n            zc->maxNbLdmSequences = maxNbLdmSeq;\n\n            ZSTD_window_init(&zc->ldmState.window);\n            zc->ldmState.loadedDictEnd = 0;\n        }\n\n        /* reserve space for block-level external sequences */\n        if (ZSTD_hasExtSeqProd(params)) {\n            size_t const maxNbExternalSeq = ZSTD_sequenceBound(blockSize);\n            zc->extSeqBufCapacity = maxNbExternalSeq;\n            zc->extSeqBuf =\n                (ZSTD_Sequence*)ZSTD_cwksp_reserve_aligned64(ws, maxNbExternalSeq * sizeof(ZSTD_Sequence));\n        }\n\n        /* buffers */\n\n        /* ZSTD_wildcopy() is used to copy into the literals buffer,\n         * so we have to oversize the buffer by WILDCOPY_OVERLENGTH bytes.\n         */\n        zc->seqStore.litStart = ZSTD_cwksp_reserve_buffer(ws, blockSize + WILDCOPY_OVERLENGTH);\n        zc->seqStore.maxNbLit = blockSize;\n\n        zc->bufferedPolicy = zbuff;\n        zc->inBuffSize = buffInSize;\n        zc->inBuff = (char*)ZSTD_cwksp_reserve_buffer(ws, buffInSize);\n        zc->outBuffSize = buffOutSize;\n        zc->outBuff = (char*)ZSTD_cwksp_reserve_buffer(ws, buffOutSize);\n\n        /* ldm bucketOffsets table */\n        if (params->ldmParams.enableLdm == ZSTD_ps_enable) {\n            /* TODO: avoid memset? */\n            size_t const numBuckets =\n                  ((size_t)1) << (params->ldmParams.hashLog -\n                                  params->ldmParams.bucketSizeLog);\n            zc->ldmState.bucketOffsets = ZSTD_cwksp_reserve_buffer(ws, numBuckets);\n            ZSTD_memset(zc->ldmState.bucketOffsets, 0, numBuckets);\n        }\n\n        /* sequences storage */\n        ZSTD_referenceExternalSequences(zc, NULL, 0);\n        zc->seqStore.maxNbSeq = maxNbSeq;\n        zc->seqStore.llCode = ZSTD_cwksp_reserve_buffer(ws, maxNbSeq * sizeof(BYTE));\n        zc->seqStore.mlCode = ZSTD_cwksp_reserve_buffer(ws, maxNbSeq * sizeof(BYTE));\n        zc->seqStore.ofCode = ZSTD_cwksp_reserve_buffer(ws, maxNbSeq * sizeof(BYTE));\n\n        DEBUGLOG(3, \"wksp: finished allocating, %zd bytes remain available\", ZSTD_cwksp_available_space(ws));\n        assert(ZSTD_cwksp_estimated_space_within_bounds(ws, neededSpace));\n\n        zc->initialized = 1;\n\n        return 0;\n    }\n}\n\n/* ZSTD_invalidateRepCodes() :\n * ensures next compression will not use repcodes from previous block.\n * Note : only works with regular variant;\n *        do not use with extDict variant ! */\nvoid ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx) {\n    int i;\n    for (i=0; iblockState.prevCBlock->rep[i] = 0;\n    assert(!ZSTD_window_hasExtDict(cctx->blockState.matchState.window));\n}\n\n/* These are the approximate sizes for each strategy past which copying the\n * dictionary tables into the working context is faster than using them\n * in-place.\n */\nstatic const size_t attachDictSizeCutoffs[ZSTD_STRATEGY_MAX+1] = {\n    8 KB,  /* unused */\n    8 KB,  /* ZSTD_fast */\n    16 KB, /* ZSTD_dfast */\n    32 KB, /* ZSTD_greedy */\n    32 KB, /* ZSTD_lazy */\n    32 KB, /* ZSTD_lazy2 */\n    32 KB, /* ZSTD_btlazy2 */\n    32 KB, /* ZSTD_btopt */\n    8 KB,  /* ZSTD_btultra */\n    8 KB   /* ZSTD_btultra2 */\n};\n\nstatic int ZSTD_shouldAttachDict(const ZSTD_CDict* cdict,\n                                 const ZSTD_CCtx_params* params,\n                                 U64 pledgedSrcSize)\n{\n    size_t cutoff = attachDictSizeCutoffs[cdict->matchState.cParams.strategy];\n    int const dedicatedDictSearch = cdict->matchState.dedicatedDictSearch;\n    return dedicatedDictSearch\n        || ( ( pledgedSrcSize <= cutoff\n            || pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN\n            || params->attachDictPref == ZSTD_dictForceAttach )\n          && params->attachDictPref != ZSTD_dictForceCopy\n          && !params->forceWindow ); /* dictMatchState isn't correctly\n                                      * handled in _enforceMaxDist */\n}\n\nstatic size_t\nZSTD_resetCCtx_byAttachingCDict(ZSTD_CCtx* cctx,\n                        const ZSTD_CDict* cdict,\n                        ZSTD_CCtx_params params,\n                        U64 pledgedSrcSize,\n                        ZSTD_buffered_policy_e zbuff)\n{\n    DEBUGLOG(4, \"ZSTD_resetCCtx_byAttachingCDict() pledgedSrcSize=%llu\",\n                (unsigned long long)pledgedSrcSize);\n    {\n        ZSTD_compressionParameters adjusted_cdict_cParams = cdict->matchState.cParams;\n        unsigned const windowLog = params.cParams.windowLog;\n        assert(windowLog != 0);\n        /* Resize working context table params for input only, since the dict\n         * has its own tables. */\n        /* pledgedSrcSize == 0 means 0! */\n\n        if (cdict->matchState.dedicatedDictSearch) {\n            ZSTD_dedicatedDictSearch_revertCParams(&adjusted_cdict_cParams);\n        }\n\n        params.cParams = ZSTD_adjustCParams_internal(adjusted_cdict_cParams, pledgedSrcSize,\n                                                     cdict->dictContentSize, ZSTD_cpm_attachDict,\n                                                     params.useRowMatchFinder);\n        params.cParams.windowLog = windowLog;\n        params.useRowMatchFinder = cdict->useRowMatchFinder;    /* cdict overrides */\n        FORWARD_IF_ERROR(ZSTD_resetCCtx_internal(cctx, ¶ms, pledgedSrcSize,\n                                                 /* loadedDictSize */ 0,\n                                                 ZSTDcrp_makeClean, zbuff), \"\");\n        assert(cctx->appliedParams.cParams.strategy == adjusted_cdict_cParams.strategy);\n    }\n\n    {   const U32 cdictEnd = (U32)( cdict->matchState.window.nextSrc\n                                  - cdict->matchState.window.base);\n        const U32 cdictLen = cdictEnd - cdict->matchState.window.dictLimit;\n        if (cdictLen == 0) {\n            /* don't even attach dictionaries with no contents */\n            DEBUGLOG(4, \"skipping attaching empty dictionary\");\n        } else {\n            DEBUGLOG(4, \"attaching dictionary into context\");\n            cctx->blockState.matchState.dictMatchState = &cdict->matchState;\n\n            /* prep working match state so dict matches never have negative indices\n             * when they are translated to the working context's index space. */\n            if (cctx->blockState.matchState.window.dictLimit < cdictEnd) {\n                cctx->blockState.matchState.window.nextSrc =\n                    cctx->blockState.matchState.window.base + cdictEnd;\n                ZSTD_window_clear(&cctx->blockState.matchState.window);\n            }\n            /* loadedDictEnd is expressed within the referential of the active context */\n            cctx->blockState.matchState.loadedDictEnd = cctx->blockState.matchState.window.dictLimit;\n    }   }\n\n    cctx->dictID = cdict->dictID;\n    cctx->dictContentSize = cdict->dictContentSize;\n\n    /* copy block state */\n    ZSTD_memcpy(cctx->blockState.prevCBlock, &cdict->cBlockState, sizeof(cdict->cBlockState));\n\n    return 0;\n}\n\nstatic void ZSTD_copyCDictTableIntoCCtx(U32* dst, U32 const* src, size_t tableSize,\n                                        ZSTD_compressionParameters const* cParams) {\n    if (ZSTD_CDictIndicesAreTagged(cParams)){\n        /* Remove tags from the CDict table if they are present.\n         * See docs on \"short cache\" in zstd_compress_internal.h for context. */\n        size_t i;\n        for (i = 0; i < tableSize; i++) {\n            U32 const taggedIndex = src[i];\n            U32 const index = taggedIndex >> ZSTD_SHORT_CACHE_TAG_BITS;\n            dst[i] = index;\n        }\n    } else {\n        ZSTD_memcpy(dst, src, tableSize * sizeof(U32));\n    }\n}\n\nstatic size_t ZSTD_resetCCtx_byCopyingCDict(ZSTD_CCtx* cctx,\n                            const ZSTD_CDict* cdict,\n                            ZSTD_CCtx_params params,\n                            U64 pledgedSrcSize,\n                            ZSTD_buffered_policy_e zbuff)\n{\n    const ZSTD_compressionParameters *cdict_cParams = &cdict->matchState.cParams;\n\n    assert(!cdict->matchState.dedicatedDictSearch);\n    DEBUGLOG(4, \"ZSTD_resetCCtx_byCopyingCDict() pledgedSrcSize=%llu\",\n                (unsigned long long)pledgedSrcSize);\n\n    {   unsigned const windowLog = params.cParams.windowLog;\n        assert(windowLog != 0);\n        /* Copy only compression parameters related to tables. */\n        params.cParams = *cdict_cParams;\n        params.cParams.windowLog = windowLog;\n        params.useRowMatchFinder = cdict->useRowMatchFinder;\n        FORWARD_IF_ERROR(ZSTD_resetCCtx_internal(cctx, ¶ms, pledgedSrcSize,\n                                                 /* loadedDictSize */ 0,\n                                                 ZSTDcrp_leaveDirty, zbuff), \"\");\n        assert(cctx->appliedParams.cParams.strategy == cdict_cParams->strategy);\n        assert(cctx->appliedParams.cParams.hashLog == cdict_cParams->hashLog);\n        assert(cctx->appliedParams.cParams.chainLog == cdict_cParams->chainLog);\n    }\n\n    ZSTD_cwksp_mark_tables_dirty(&cctx->workspace);\n    assert(params.useRowMatchFinder != ZSTD_ps_auto);\n\n    /* copy tables */\n    {   size_t const chainSize = ZSTD_allocateChainTable(cdict_cParams->strategy, cdict->useRowMatchFinder, 0 /* DDS guaranteed disabled */)\n                                                            ? ((size_t)1 << cdict_cParams->chainLog)\n                                                            : 0;\n        size_t const hSize =  (size_t)1 << cdict_cParams->hashLog;\n\n        ZSTD_copyCDictTableIntoCCtx(cctx->blockState.matchState.hashTable,\n                                cdict->matchState.hashTable,\n                                hSize, cdict_cParams);\n\n        /* Do not copy cdict's chainTable if cctx has parameters such that it would not use chainTable */\n        if (ZSTD_allocateChainTable(cctx->appliedParams.cParams.strategy, cctx->appliedParams.useRowMatchFinder, 0 /* forDDSDict */)) {\n            ZSTD_copyCDictTableIntoCCtx(cctx->blockState.matchState.chainTable,\n                                    cdict->matchState.chainTable,\n                                    chainSize, cdict_cParams);\n        }\n        /* copy tag table */\n        if (ZSTD_rowMatchFinderUsed(cdict_cParams->strategy, cdict->useRowMatchFinder)) {\n            size_t const tagTableSize = hSize;\n            ZSTD_memcpy(cctx->blockState.matchState.tagTable,\n                        cdict->matchState.tagTable,\n                        tagTableSize);\n            cctx->blockState.matchState.hashSalt = cdict->matchState.hashSalt;\n        }\n    }\n\n    /* Zero the hashTable3, since the cdict never fills it */\n    assert(cctx->blockState.matchState.hashLog3 <= 31);\n    {   U32 const h3log = cctx->blockState.matchState.hashLog3;\n        size_t const h3Size = h3log ? ((size_t)1 << h3log) : 0;\n        assert(cdict->matchState.hashLog3 == 0);\n        ZSTD_memset(cctx->blockState.matchState.hashTable3, 0, h3Size * sizeof(U32));\n    }\n\n    ZSTD_cwksp_mark_tables_clean(&cctx->workspace);\n\n    /* copy dictionary offsets */\n    {   ZSTD_MatchState_t const* srcMatchState = &cdict->matchState;\n        ZSTD_MatchState_t* dstMatchState = &cctx->blockState.matchState;\n        dstMatchState->window       = srcMatchState->window;\n        dstMatchState->nextToUpdate = srcMatchState->nextToUpdate;\n        dstMatchState->loadedDictEnd= srcMatchState->loadedDictEnd;\n    }\n\n    cctx->dictID = cdict->dictID;\n    cctx->dictContentSize = cdict->dictContentSize;\n\n    /* copy block state */\n    ZSTD_memcpy(cctx->blockState.prevCBlock, &cdict->cBlockState, sizeof(cdict->cBlockState));\n\n    return 0;\n}\n\n/* We have a choice between copying the dictionary context into the working\n * context, or referencing the dictionary context from the working context\n * in-place. We decide here which strategy to use. */\nstatic size_t ZSTD_resetCCtx_usingCDict(ZSTD_CCtx* cctx,\n                            const ZSTD_CDict* cdict,\n                            const ZSTD_CCtx_params* params,\n                            U64 pledgedSrcSize,\n                            ZSTD_buffered_policy_e zbuff)\n{\n\n    DEBUGLOG(4, \"ZSTD_resetCCtx_usingCDict (pledgedSrcSize=%u)\",\n                (unsigned)pledgedSrcSize);\n\n    if (ZSTD_shouldAttachDict(cdict, params, pledgedSrcSize)) {\n        return ZSTD_resetCCtx_byAttachingCDict(\n            cctx, cdict, *params, pledgedSrcSize, zbuff);\n    } else {\n        return ZSTD_resetCCtx_byCopyingCDict(\n            cctx, cdict, *params, pledgedSrcSize, zbuff);\n    }\n}\n\n/*! ZSTD_copyCCtx_internal() :\n *  Duplicate an existing context `srcCCtx` into another one `dstCCtx`.\n *  Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()).\n *  The \"context\", in this case, refers to the hash and chain tables,\n *  entropy tables, and dictionary references.\n * `windowLog` value is enforced if != 0, otherwise value is copied from srcCCtx.\n * @return : 0, or an error code */\nstatic size_t ZSTD_copyCCtx_internal(ZSTD_CCtx* dstCCtx,\n                            const ZSTD_CCtx* srcCCtx,\n                            ZSTD_frameParameters fParams,\n                            U64 pledgedSrcSize,\n                            ZSTD_buffered_policy_e zbuff)\n{\n    RETURN_ERROR_IF(srcCCtx->stage!=ZSTDcs_init, stage_wrong,\n                    \"Can't copy a ctx that's not in init stage.\");\n    DEBUGLOG(5, \"ZSTD_copyCCtx_internal\");\n    ZSTD_memcpy(&dstCCtx->customMem, &srcCCtx->customMem, sizeof(ZSTD_customMem));\n    {   ZSTD_CCtx_params params = dstCCtx->requestedParams;\n        /* Copy only compression parameters related to tables. */\n        params.cParams = srcCCtx->appliedParams.cParams;\n        assert(srcCCtx->appliedParams.useRowMatchFinder != ZSTD_ps_auto);\n        assert(srcCCtx->appliedParams.postBlockSplitter != ZSTD_ps_auto);\n        assert(srcCCtx->appliedParams.ldmParams.enableLdm != ZSTD_ps_auto);\n        params.useRowMatchFinder = srcCCtx->appliedParams.useRowMatchFinder;\n        params.postBlockSplitter = srcCCtx->appliedParams.postBlockSplitter;\n        params.ldmParams = srcCCtx->appliedParams.ldmParams;\n        params.fParams = fParams;\n        params.maxBlockSize = srcCCtx->appliedParams.maxBlockSize;\n        ZSTD_resetCCtx_internal(dstCCtx, ¶ms, pledgedSrcSize,\n                                /* loadedDictSize */ 0,\n                                ZSTDcrp_leaveDirty, zbuff);\n        assert(dstCCtx->appliedParams.cParams.windowLog == srcCCtx->appliedParams.cParams.windowLog);\n        assert(dstCCtx->appliedParams.cParams.strategy == srcCCtx->appliedParams.cParams.strategy);\n        assert(dstCCtx->appliedParams.cParams.hashLog == srcCCtx->appliedParams.cParams.hashLog);\n        assert(dstCCtx->appliedParams.cParams.chainLog == srcCCtx->appliedParams.cParams.chainLog);\n        assert(dstCCtx->blockState.matchState.hashLog3 == srcCCtx->blockState.matchState.hashLog3);\n    }\n\n    ZSTD_cwksp_mark_tables_dirty(&dstCCtx->workspace);\n\n    /* copy tables */\n    {   size_t const chainSize = ZSTD_allocateChainTable(srcCCtx->appliedParams.cParams.strategy,\n                                                         srcCCtx->appliedParams.useRowMatchFinder,\n                                                         0 /* forDDSDict */)\n                                    ? ((size_t)1 << srcCCtx->appliedParams.cParams.chainLog)\n                                    : 0;\n        size_t const hSize =  (size_t)1 << srcCCtx->appliedParams.cParams.hashLog;\n        U32 const h3log = srcCCtx->blockState.matchState.hashLog3;\n        size_t const h3Size = h3log ? ((size_t)1 << h3log) : 0;\n\n        ZSTD_memcpy(dstCCtx->blockState.matchState.hashTable,\n               srcCCtx->blockState.matchState.hashTable,\n               hSize * sizeof(U32));\n        ZSTD_memcpy(dstCCtx->blockState.matchState.chainTable,\n               srcCCtx->blockState.matchState.chainTable,\n               chainSize * sizeof(U32));\n        ZSTD_memcpy(dstCCtx->blockState.matchState.hashTable3,\n               srcCCtx->blockState.matchState.hashTable3,\n               h3Size * sizeof(U32));\n    }\n\n    ZSTD_cwksp_mark_tables_clean(&dstCCtx->workspace);\n\n    /* copy dictionary offsets */\n    {\n        const ZSTD_MatchState_t* srcMatchState = &srcCCtx->blockState.matchState;\n        ZSTD_MatchState_t* dstMatchState = &dstCCtx->blockState.matchState;\n        dstMatchState->window       = srcMatchState->window;\n        dstMatchState->nextToUpdate = srcMatchState->nextToUpdate;\n        dstMatchState->loadedDictEnd= srcMatchState->loadedDictEnd;\n    }\n    dstCCtx->dictID = srcCCtx->dictID;\n    dstCCtx->dictContentSize = srcCCtx->dictContentSize;\n\n    /* copy block state */\n    ZSTD_memcpy(dstCCtx->blockState.prevCBlock, srcCCtx->blockState.prevCBlock, sizeof(*srcCCtx->blockState.prevCBlock));\n\n    return 0;\n}\n\n/*! ZSTD_copyCCtx() :\n *  Duplicate an existing context `srcCCtx` into another one `dstCCtx`.\n *  Only works during stage ZSTDcs_init (i.e. after creation, but before first call to ZSTD_compressContinue()).\n *  pledgedSrcSize==0 means \"unknown\".\n*   @return : 0, or an error code */\nsize_t ZSTD_copyCCtx(ZSTD_CCtx* dstCCtx, const ZSTD_CCtx* srcCCtx, unsigned long long pledgedSrcSize)\n{\n    ZSTD_frameParameters fParams = { 1 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ };\n    ZSTD_buffered_policy_e const zbuff = srcCCtx->bufferedPolicy;\n    ZSTD_STATIC_ASSERT((U32)ZSTDb_buffered==1);\n    if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;\n    fParams.contentSizeFlag = (pledgedSrcSize != ZSTD_CONTENTSIZE_UNKNOWN);\n\n    return ZSTD_copyCCtx_internal(dstCCtx, srcCCtx,\n                                fParams, pledgedSrcSize,\n                                zbuff);\n}\n\n\n#define ZSTD_ROWSIZE 16\n/*! ZSTD_reduceTable() :\n *  reduce table indexes by `reducerValue`, or squash to zero.\n *  PreserveMark preserves \"unsorted mark\" for btlazy2 strategy.\n *  It must be set to a clear 0/1 value, to remove branch during inlining.\n *  Presume table size is a multiple of ZSTD_ROWSIZE\n *  to help auto-vectorization */\nFORCE_INLINE_TEMPLATE void\nZSTD_reduceTable_internal (U32* const table, U32 const size, U32 const reducerValue, int const preserveMark)\n{\n    int const nbRows = (int)size / ZSTD_ROWSIZE;\n    int cellNb = 0;\n    int rowNb;\n    /* Protect special index values < ZSTD_WINDOW_START_INDEX. */\n    U32 const reducerThreshold = reducerValue + ZSTD_WINDOW_START_INDEX;\n    assert((size & (ZSTD_ROWSIZE-1)) == 0);  /* multiple of ZSTD_ROWSIZE */\n    assert(size < (1U<<31));   /* can be cast to int */\n\n#if ZSTD_MEMORY_SANITIZER && !defined (ZSTD_MSAN_DONT_POISON_WORKSPACE)\n    /* To validate that the table reuse logic is sound, and that we don't\n     * access table space that we haven't cleaned, we re-\"poison\" the table\n     * space every time we mark it dirty.\n     *\n     * This function however is intended to operate on those dirty tables and\n     * re-clean them. So when this function is used correctly, we can unpoison\n     * the memory it operated on. This introduces a blind spot though, since\n     * if we now try to operate on __actually__ poisoned memory, we will not\n     * detect that. */\n    __msan_unpoison(table, size * sizeof(U32));\n#endif\n\n    for (rowNb=0 ; rowNb < nbRows ; rowNb++) {\n        int column;\n        for (column=0; columncParams.hashLog;\n        ZSTD_reduceTable(ms->hashTable, hSize, reducerValue);\n    }\n\n    if (ZSTD_allocateChainTable(params->cParams.strategy, params->useRowMatchFinder, (U32)ms->dedicatedDictSearch)) {\n        U32 const chainSize = (U32)1 << params->cParams.chainLog;\n        if (params->cParams.strategy == ZSTD_btlazy2)\n            ZSTD_reduceTable_btlazy2(ms->chainTable, chainSize, reducerValue);\n        else\n            ZSTD_reduceTable(ms->chainTable, chainSize, reducerValue);\n    }\n\n    if (ms->hashLog3) {\n        U32 const h3Size = (U32)1 << ms->hashLog3;\n        ZSTD_reduceTable(ms->hashTable3, h3Size, reducerValue);\n    }\n}\n\n\n/*-*******************************************************\n*  Block entropic compression\n*********************************************************/\n\n/* See doc/zstd_compression_format.md for detailed format description */\n\nint ZSTD_seqToCodes(const SeqStore_t* seqStorePtr)\n{\n    const SeqDef* const sequences = seqStorePtr->sequencesStart;\n    BYTE* const llCodeTable = seqStorePtr->llCode;\n    BYTE* const ofCodeTable = seqStorePtr->ofCode;\n    BYTE* const mlCodeTable = seqStorePtr->mlCode;\n    U32 const nbSeq = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);\n    U32 u;\n    int longOffsets = 0;\n    assert(nbSeq <= seqStorePtr->maxNbSeq);\n    for (u=0; u= STREAM_ACCUMULATOR_MIN));\n        if (MEM_32bits() && ofCode >= STREAM_ACCUMULATOR_MIN)\n            longOffsets = 1;\n    }\n    if (seqStorePtr->longLengthType==ZSTD_llt_literalLength)\n        llCodeTable[seqStorePtr->longLengthPos] = MaxLL;\n    if (seqStorePtr->longLengthType==ZSTD_llt_matchLength)\n        mlCodeTable[seqStorePtr->longLengthPos] = MaxML;\n    return longOffsets;\n}\n\n/* ZSTD_useTargetCBlockSize():\n * Returns if target compressed block size param is being used.\n * If used, compression will do best effort to make a compressed block size to be around targetCBlockSize.\n * Returns 1 if true, 0 otherwise. */\nstatic int ZSTD_useTargetCBlockSize(const ZSTD_CCtx_params* cctxParams)\n{\n    DEBUGLOG(5, \"ZSTD_useTargetCBlockSize (targetCBlockSize=%zu)\", cctxParams->targetCBlockSize);\n    return (cctxParams->targetCBlockSize != 0);\n}\n\n/* ZSTD_blockSplitterEnabled():\n * Returns if block splitting param is being used\n * If used, compression will do best effort to split a block in order to improve compression ratio.\n * At the time this function is called, the parameter must be finalized.\n * Returns 1 if true, 0 otherwise. */\nstatic int ZSTD_blockSplitterEnabled(ZSTD_CCtx_params* cctxParams)\n{\n    DEBUGLOG(5, \"ZSTD_blockSplitterEnabled (postBlockSplitter=%d)\", cctxParams->postBlockSplitter);\n    assert(cctxParams->postBlockSplitter != ZSTD_ps_auto);\n    return (cctxParams->postBlockSplitter == ZSTD_ps_enable);\n}\n\n/* Type returned by ZSTD_buildSequencesStatistics containing finalized symbol encoding types\n * and size of the sequences statistics\n */\ntypedef struct {\n    U32 LLtype;\n    U32 Offtype;\n    U32 MLtype;\n    size_t size;\n    size_t lastCountSize; /* Accounts for bug in 1.3.4. More detail in ZSTD_entropyCompressSeqStore_internal() */\n    int longOffsets;\n} ZSTD_symbolEncodingTypeStats_t;\n\n/* ZSTD_buildSequencesStatistics():\n * Returns a ZSTD_symbolEncodingTypeStats_t, or a zstd error code in the `size` field.\n * Modifies `nextEntropy` to have the appropriate values as a side effect.\n * nbSeq must be greater than 0.\n *\n * entropyWkspSize must be of size at least ENTROPY_WORKSPACE_SIZE - (MaxSeq + 1)*sizeof(U32)\n */\nstatic ZSTD_symbolEncodingTypeStats_t\nZSTD_buildSequencesStatistics(\n                const SeqStore_t* seqStorePtr, size_t nbSeq,\n                const ZSTD_fseCTables_t* prevEntropy, ZSTD_fseCTables_t* nextEntropy,\n                      BYTE* dst, const BYTE* const dstEnd,\n                      ZSTD_strategy strategy, unsigned* countWorkspace,\n                      void* entropyWorkspace, size_t entropyWkspSize)\n{\n    BYTE* const ostart = dst;\n    const BYTE* const oend = dstEnd;\n    BYTE* op = ostart;\n    FSE_CTable* CTable_LitLength = nextEntropy->litlengthCTable;\n    FSE_CTable* CTable_OffsetBits = nextEntropy->offcodeCTable;\n    FSE_CTable* CTable_MatchLength = nextEntropy->matchlengthCTable;\n    const BYTE* const ofCodeTable = seqStorePtr->ofCode;\n    const BYTE* const llCodeTable = seqStorePtr->llCode;\n    const BYTE* const mlCodeTable = seqStorePtr->mlCode;\n    ZSTD_symbolEncodingTypeStats_t stats;\n\n    stats.lastCountSize = 0;\n    /* convert length/distances into codes */\n    stats.longOffsets = ZSTD_seqToCodes(seqStorePtr);\n    assert(op <= oend);\n    assert(nbSeq != 0); /* ZSTD_selectEncodingType() divides by nbSeq */\n    /* build CTable for Literal Lengths */\n    {   unsigned max = MaxLL;\n        size_t const mostFrequent = HIST_countFast_wksp(countWorkspace, &max, llCodeTable, nbSeq, entropyWorkspace, entropyWkspSize);   /* can't fail */\n        DEBUGLOG(5, \"Building LL table\");\n        nextEntropy->litlength_repeatMode = prevEntropy->litlength_repeatMode;\n        stats.LLtype = ZSTD_selectEncodingType(&nextEntropy->litlength_repeatMode,\n                                        countWorkspace, max, mostFrequent, nbSeq,\n                                        LLFSELog, prevEntropy->litlengthCTable,\n                                        LL_defaultNorm, LL_defaultNormLog,\n                                        ZSTD_defaultAllowed, strategy);\n        assert(set_basic < set_compressed && set_rle < set_compressed);\n        assert(!(stats.LLtype < set_compressed && nextEntropy->litlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */\n        {   size_t const countSize = ZSTD_buildCTable(\n                op, (size_t)(oend - op),\n                CTable_LitLength, LLFSELog, (SymbolEncodingType_e)stats.LLtype,\n                countWorkspace, max, llCodeTable, nbSeq,\n                LL_defaultNorm, LL_defaultNormLog, MaxLL,\n                prevEntropy->litlengthCTable,\n                sizeof(prevEntropy->litlengthCTable),\n                entropyWorkspace, entropyWkspSize);\n            if (ZSTD_isError(countSize)) {\n                DEBUGLOG(3, \"ZSTD_buildCTable for LitLens failed\");\n                stats.size = countSize;\n                return stats;\n            }\n            if (stats.LLtype == set_compressed)\n                stats.lastCountSize = countSize;\n            op += countSize;\n            assert(op <= oend);\n    }   }\n    /* build CTable for Offsets */\n    {   unsigned max = MaxOff;\n        size_t const mostFrequent = HIST_countFast_wksp(\n            countWorkspace, &max, ofCodeTable, nbSeq, entropyWorkspace, entropyWkspSize);  /* can't fail */\n        /* We can only use the basic table if max <= DefaultMaxOff, otherwise the offsets are too large */\n        ZSTD_DefaultPolicy_e const defaultPolicy = (max <= DefaultMaxOff) ? ZSTD_defaultAllowed : ZSTD_defaultDisallowed;\n        DEBUGLOG(5, \"Building OF table\");\n        nextEntropy->offcode_repeatMode = prevEntropy->offcode_repeatMode;\n        stats.Offtype = ZSTD_selectEncodingType(&nextEntropy->offcode_repeatMode,\n                                        countWorkspace, max, mostFrequent, nbSeq,\n                                        OffFSELog, prevEntropy->offcodeCTable,\n                                        OF_defaultNorm, OF_defaultNormLog,\n                                        defaultPolicy, strategy);\n        assert(!(stats.Offtype < set_compressed && nextEntropy->offcode_repeatMode != FSE_repeat_none)); /* We don't copy tables */\n        {   size_t const countSize = ZSTD_buildCTable(\n                op, (size_t)(oend - op),\n                CTable_OffsetBits, OffFSELog, (SymbolEncodingType_e)stats.Offtype,\n                countWorkspace, max, ofCodeTable, nbSeq,\n                OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff,\n                prevEntropy->offcodeCTable,\n                sizeof(prevEntropy->offcodeCTable),\n                entropyWorkspace, entropyWkspSize);\n            if (ZSTD_isError(countSize)) {\n                DEBUGLOG(3, \"ZSTD_buildCTable for Offsets failed\");\n                stats.size = countSize;\n                return stats;\n            }\n            if (stats.Offtype == set_compressed)\n                stats.lastCountSize = countSize;\n            op += countSize;\n            assert(op <= oend);\n    }   }\n    /* build CTable for MatchLengths */\n    {   unsigned max = MaxML;\n        size_t const mostFrequent = HIST_countFast_wksp(\n            countWorkspace, &max, mlCodeTable, nbSeq, entropyWorkspace, entropyWkspSize);   /* can't fail */\n        DEBUGLOG(5, \"Building ML table (remaining space : %i)\", (int)(oend-op));\n        nextEntropy->matchlength_repeatMode = prevEntropy->matchlength_repeatMode;\n        stats.MLtype = ZSTD_selectEncodingType(&nextEntropy->matchlength_repeatMode,\n                                        countWorkspace, max, mostFrequent, nbSeq,\n                                        MLFSELog, prevEntropy->matchlengthCTable,\n                                        ML_defaultNorm, ML_defaultNormLog,\n                                        ZSTD_defaultAllowed, strategy);\n        assert(!(stats.MLtype < set_compressed && nextEntropy->matchlength_repeatMode != FSE_repeat_none)); /* We don't copy tables */\n        {   size_t const countSize = ZSTD_buildCTable(\n                op, (size_t)(oend - op),\n                CTable_MatchLength, MLFSELog, (SymbolEncodingType_e)stats.MLtype,\n                countWorkspace, max, mlCodeTable, nbSeq,\n                ML_defaultNorm, ML_defaultNormLog, MaxML,\n                prevEntropy->matchlengthCTable,\n                sizeof(prevEntropy->matchlengthCTable),\n                entropyWorkspace, entropyWkspSize);\n            if (ZSTD_isError(countSize)) {\n                DEBUGLOG(3, \"ZSTD_buildCTable for MatchLengths failed\");\n                stats.size = countSize;\n                return stats;\n            }\n            if (stats.MLtype == set_compressed)\n                stats.lastCountSize = countSize;\n            op += countSize;\n            assert(op <= oend);\n    }   }\n    stats.size = (size_t)(op-ostart);\n    return stats;\n}\n\n/* ZSTD_entropyCompressSeqStore_internal():\n * compresses both literals and sequences\n * Returns compressed size of block, or a zstd error.\n */\n#define SUSPECT_UNCOMPRESSIBLE_LITERAL_RATIO 20\nMEM_STATIC size_t\nZSTD_entropyCompressSeqStore_internal(\n                              void* dst, size_t dstCapacity,\n                        const void* literals, size_t litSize,\n                        const SeqStore_t* seqStorePtr,\n                        const ZSTD_entropyCTables_t* prevEntropy,\n                              ZSTD_entropyCTables_t* nextEntropy,\n                        const ZSTD_CCtx_params* cctxParams,\n                              void* entropyWorkspace, size_t entropyWkspSize,\n                        const int bmi2)\n{\n    ZSTD_strategy const strategy = cctxParams->cParams.strategy;\n    unsigned* count = (unsigned*)entropyWorkspace;\n    FSE_CTable* CTable_LitLength = nextEntropy->fse.litlengthCTable;\n    FSE_CTable* CTable_OffsetBits = nextEntropy->fse.offcodeCTable;\n    FSE_CTable* CTable_MatchLength = nextEntropy->fse.matchlengthCTable;\n    const SeqDef* const sequences = seqStorePtr->sequencesStart;\n    const size_t nbSeq = (size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart);\n    const BYTE* const ofCodeTable = seqStorePtr->ofCode;\n    const BYTE* const llCodeTable = seqStorePtr->llCode;\n    const BYTE* const mlCodeTable = seqStorePtr->mlCode;\n    BYTE* const ostart = (BYTE*)dst;\n    BYTE* const oend = ostart + dstCapacity;\n    BYTE* op = ostart;\n    size_t lastCountSize;\n    int longOffsets = 0;\n\n    entropyWorkspace = count + (MaxSeq + 1);\n    entropyWkspSize -= (MaxSeq + 1) * sizeof(*count);\n\n    DEBUGLOG(5, \"ZSTD_entropyCompressSeqStore_internal (nbSeq=%zu, dstCapacity=%zu)\", nbSeq, dstCapacity);\n    ZSTD_STATIC_ASSERT(HUF_WORKSPACE_SIZE >= (1<= HUF_WORKSPACE_SIZE);\n\n    /* Compress literals */\n    {   size_t const numSequences = (size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart);\n        /* Base suspicion of uncompressibility on ratio of literals to sequences */\n        int const suspectUncompressible = (numSequences == 0) || (litSize / numSequences >= SUSPECT_UNCOMPRESSIBLE_LITERAL_RATIO);\n\n        size_t const cSize = ZSTD_compressLiterals(\n                                    op, dstCapacity,\n                                    literals, litSize,\n                                    entropyWorkspace, entropyWkspSize,\n                                    &prevEntropy->huf, &nextEntropy->huf,\n                                    cctxParams->cParams.strategy,\n                                    ZSTD_literalsCompressionIsDisabled(cctxParams),\n                                    suspectUncompressible, bmi2);\n        FORWARD_IF_ERROR(cSize, \"ZSTD_compressLiterals failed\");\n        assert(cSize <= dstCapacity);\n        op += cSize;\n    }\n\n    /* Sequences Header */\n    RETURN_ERROR_IF((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/,\n                    dstSize_tooSmall, \"Can't fit seq hdr in output buf!\");\n    if (nbSeq < 128) {\n        *op++ = (BYTE)nbSeq;\n    } else if (nbSeq < LONGNBSEQ) {\n        op[0] = (BYTE)((nbSeq>>8) + 0x80);\n        op[1] = (BYTE)nbSeq;\n        op+=2;\n    } else {\n        op[0]=0xFF;\n        MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ));\n        op+=3;\n    }\n    assert(op <= oend);\n    if (nbSeq==0) {\n        /* Copy the old tables over as if we repeated them */\n        ZSTD_memcpy(&nextEntropy->fse, &prevEntropy->fse, sizeof(prevEntropy->fse));\n        return (size_t)(op - ostart);\n    }\n    {   BYTE* const seqHead = op++;\n        /* build stats for sequences */\n        const ZSTD_symbolEncodingTypeStats_t stats =\n                ZSTD_buildSequencesStatistics(seqStorePtr, nbSeq,\n                                             &prevEntropy->fse, &nextEntropy->fse,\n                                              op, oend,\n                                              strategy, count,\n                                              entropyWorkspace, entropyWkspSize);\n        FORWARD_IF_ERROR(stats.size, \"ZSTD_buildSequencesStatistics failed!\");\n        *seqHead = (BYTE)((stats.LLtype<<6) + (stats.Offtype<<4) + (stats.MLtype<<2));\n        lastCountSize = stats.lastCountSize;\n        op += stats.size;\n        longOffsets = stats.longOffsets;\n    }\n\n    {   size_t const bitstreamSize = ZSTD_encodeSequences(\n                                        op, (size_t)(oend - op),\n                                        CTable_MatchLength, mlCodeTable,\n                                        CTable_OffsetBits, ofCodeTable,\n                                        CTable_LitLength, llCodeTable,\n                                        sequences, nbSeq,\n                                        longOffsets, bmi2);\n        FORWARD_IF_ERROR(bitstreamSize, \"ZSTD_encodeSequences failed\");\n        op += bitstreamSize;\n        assert(op <= oend);\n        /* zstd versions <= 1.3.4 mistakenly report corruption when\n         * FSE_readNCount() receives a buffer < 4 bytes.\n         * Fixed by https://github.com/facebook/zstd/pull/1146.\n         * This can happen when the last set_compressed table present is 2\n         * bytes and the bitstream is only one byte.\n         * In this exceedingly rare case, we will simply emit an uncompressed\n         * block, since it isn't worth optimizing.\n         */\n        if (lastCountSize && (lastCountSize + bitstreamSize) < 4) {\n            /* lastCountSize >= 2 && bitstreamSize > 0 ==> lastCountSize == 3 */\n            assert(lastCountSize + bitstreamSize == 3);\n            DEBUGLOG(5, \"Avoiding bug in zstd decoder in versions <= 1.3.4 by \"\n                        \"emitting an uncompressed block.\");\n            return 0;\n        }\n    }\n\n    DEBUGLOG(5, \"compressed block size : %u\", (unsigned)(op - ostart));\n    return (size_t)(op - ostart);\n}\n\nstatic size_t\nZSTD_entropyCompressSeqStore_wExtLitBuffer(\n                          void* dst, size_t dstCapacity,\n                    const void* literals, size_t litSize,\n                          size_t blockSize,\n                    const SeqStore_t* seqStorePtr,\n                    const ZSTD_entropyCTables_t* prevEntropy,\n                          ZSTD_entropyCTables_t* nextEntropy,\n                    const ZSTD_CCtx_params* cctxParams,\n                          void* entropyWorkspace, size_t entropyWkspSize,\n                          int bmi2)\n{\n    size_t const cSize = ZSTD_entropyCompressSeqStore_internal(\n                            dst, dstCapacity,\n                            literals, litSize,\n                            seqStorePtr, prevEntropy, nextEntropy, cctxParams,\n                            entropyWorkspace, entropyWkspSize, bmi2);\n    if (cSize == 0) return 0;\n    /* When srcSize <= dstCapacity, there is enough space to write a raw uncompressed block.\n     * Since we ran out of space, block must be not compressible, so fall back to raw uncompressed block.\n     */\n    if ((cSize == ERROR(dstSize_tooSmall)) & (blockSize <= dstCapacity)) {\n        DEBUGLOG(4, \"not enough dstCapacity (%zu) for ZSTD_entropyCompressSeqStore_internal()=> do not compress block\", dstCapacity);\n        return 0;  /* block not compressed */\n    }\n    FORWARD_IF_ERROR(cSize, \"ZSTD_entropyCompressSeqStore_internal failed\");\n\n    /* Check compressibility */\n    {   size_t const maxCSize = blockSize - ZSTD_minGain(blockSize, cctxParams->cParams.strategy);\n        if (cSize >= maxCSize) return 0;  /* block not compressed */\n    }\n    DEBUGLOG(5, \"ZSTD_entropyCompressSeqStore() cSize: %zu\", cSize);\n    /* libzstd decoder before  > v1.5.4 is not compatible with compressed blocks of size ZSTD_BLOCKSIZE_MAX exactly.\n     * This restriction is indirectly already fulfilled by respecting ZSTD_minGain() condition above.\n     */\n    assert(cSize < ZSTD_BLOCKSIZE_MAX);\n    return cSize;\n}\n\nstatic size_t\nZSTD_entropyCompressSeqStore(\n                    const SeqStore_t* seqStorePtr,\n                    const ZSTD_entropyCTables_t* prevEntropy,\n                          ZSTD_entropyCTables_t* nextEntropy,\n                    const ZSTD_CCtx_params* cctxParams,\n                          void* dst, size_t dstCapacity,\n                          size_t srcSize,\n                          void* entropyWorkspace, size_t entropyWkspSize,\n                          int bmi2)\n{\n    return ZSTD_entropyCompressSeqStore_wExtLitBuffer(\n                dst, dstCapacity,\n                seqStorePtr->litStart, (size_t)(seqStorePtr->lit - seqStorePtr->litStart),\n                srcSize,\n                seqStorePtr,\n                prevEntropy, nextEntropy,\n                cctxParams,\n                entropyWorkspace, entropyWkspSize,\n                bmi2);\n}\n\n/* ZSTD_selectBlockCompressor() :\n * Not static, but internal use only (used by long distance matcher)\n * assumption : strat is a valid strategy */\nZSTD_BlockCompressor_f ZSTD_selectBlockCompressor(ZSTD_strategy strat, ZSTD_ParamSwitch_e useRowMatchFinder, ZSTD_dictMode_e dictMode)\n{\n    static const ZSTD_BlockCompressor_f blockCompressor[4][ZSTD_STRATEGY_MAX+1] = {\n        { ZSTD_compressBlock_fast  /* default for 0 */,\n          ZSTD_compressBlock_fast,\n          ZSTD_COMPRESSBLOCK_DOUBLEFAST,\n          ZSTD_COMPRESSBLOCK_GREEDY,\n          ZSTD_COMPRESSBLOCK_LAZY,\n          ZSTD_COMPRESSBLOCK_LAZY2,\n          ZSTD_COMPRESSBLOCK_BTLAZY2,\n          ZSTD_COMPRESSBLOCK_BTOPT,\n          ZSTD_COMPRESSBLOCK_BTULTRA,\n          ZSTD_COMPRESSBLOCK_BTULTRA2\n        },\n        { ZSTD_compressBlock_fast_extDict  /* default for 0 */,\n          ZSTD_compressBlock_fast_extDict,\n          ZSTD_COMPRESSBLOCK_DOUBLEFAST_EXTDICT,\n          ZSTD_COMPRESSBLOCK_GREEDY_EXTDICT,\n          ZSTD_COMPRESSBLOCK_LAZY_EXTDICT,\n          ZSTD_COMPRESSBLOCK_LAZY2_EXTDICT,\n          ZSTD_COMPRESSBLOCK_BTLAZY2_EXTDICT,\n          ZSTD_COMPRESSBLOCK_BTOPT_EXTDICT,\n          ZSTD_COMPRESSBLOCK_BTULTRA_EXTDICT,\n          ZSTD_COMPRESSBLOCK_BTULTRA_EXTDICT\n        },\n        { ZSTD_compressBlock_fast_dictMatchState  /* default for 0 */,\n          ZSTD_compressBlock_fast_dictMatchState,\n          ZSTD_COMPRESSBLOCK_DOUBLEFAST_DICTMATCHSTATE,\n          ZSTD_COMPRESSBLOCK_GREEDY_DICTMATCHSTATE,\n          ZSTD_COMPRESSBLOCK_LAZY_DICTMATCHSTATE,\n          ZSTD_COMPRESSBLOCK_LAZY2_DICTMATCHSTATE,\n          ZSTD_COMPRESSBLOCK_BTLAZY2_DICTMATCHSTATE,\n          ZSTD_COMPRESSBLOCK_BTOPT_DICTMATCHSTATE,\n          ZSTD_COMPRESSBLOCK_BTULTRA_DICTMATCHSTATE,\n          ZSTD_COMPRESSBLOCK_BTULTRA_DICTMATCHSTATE\n        },\n        { NULL  /* default for 0 */,\n          NULL,\n          NULL,\n          ZSTD_COMPRESSBLOCK_GREEDY_DEDICATEDDICTSEARCH,\n          ZSTD_COMPRESSBLOCK_LAZY_DEDICATEDDICTSEARCH,\n          ZSTD_COMPRESSBLOCK_LAZY2_DEDICATEDDICTSEARCH,\n          NULL,\n          NULL,\n          NULL,\n          NULL }\n    };\n    ZSTD_BlockCompressor_f selectedCompressor;\n    ZSTD_STATIC_ASSERT((unsigned)ZSTD_fast == 1);\n\n    assert(ZSTD_cParam_withinBounds(ZSTD_c_strategy, (int)strat));\n    DEBUGLOG(5, \"Selected block compressor: dictMode=%d strat=%d rowMatchfinder=%d\", (int)dictMode, (int)strat, (int)useRowMatchFinder);\n    if (ZSTD_rowMatchFinderUsed(strat, useRowMatchFinder)) {\n        static const ZSTD_BlockCompressor_f rowBasedBlockCompressors[4][3] = {\n            {\n                ZSTD_COMPRESSBLOCK_GREEDY_ROW,\n                ZSTD_COMPRESSBLOCK_LAZY_ROW,\n                ZSTD_COMPRESSBLOCK_LAZY2_ROW\n            },\n            {\n                ZSTD_COMPRESSBLOCK_GREEDY_EXTDICT_ROW,\n                ZSTD_COMPRESSBLOCK_LAZY_EXTDICT_ROW,\n                ZSTD_COMPRESSBLOCK_LAZY2_EXTDICT_ROW\n            },\n            {\n                ZSTD_COMPRESSBLOCK_GREEDY_DICTMATCHSTATE_ROW,\n                ZSTD_COMPRESSBLOCK_LAZY_DICTMATCHSTATE_ROW,\n                ZSTD_COMPRESSBLOCK_LAZY2_DICTMATCHSTATE_ROW\n            },\n            {\n                ZSTD_COMPRESSBLOCK_GREEDY_DEDICATEDDICTSEARCH_ROW,\n                ZSTD_COMPRESSBLOCK_LAZY_DEDICATEDDICTSEARCH_ROW,\n                ZSTD_COMPRESSBLOCK_LAZY2_DEDICATEDDICTSEARCH_ROW\n            }\n        };\n        DEBUGLOG(5, \"Selecting a row-based matchfinder\");\n        assert(useRowMatchFinder != ZSTD_ps_auto);\n        selectedCompressor = rowBasedBlockCompressors[(int)dictMode][(int)strat - (int)ZSTD_greedy];\n    } else {\n        selectedCompressor = blockCompressor[(int)dictMode][(int)strat];\n    }\n    assert(selectedCompressor != NULL);\n    return selectedCompressor;\n}\n\nstatic void ZSTD_storeLastLiterals(SeqStore_t* seqStorePtr,\n                                   const BYTE* anchor, size_t lastLLSize)\n{\n    ZSTD_memcpy(seqStorePtr->lit, anchor, lastLLSize);\n    seqStorePtr->lit += lastLLSize;\n}\n\nvoid ZSTD_resetSeqStore(SeqStore_t* ssPtr)\n{\n    ssPtr->lit = ssPtr->litStart;\n    ssPtr->sequences = ssPtr->sequencesStart;\n    ssPtr->longLengthType = ZSTD_llt_none;\n}\n\n/* ZSTD_postProcessSequenceProducerResult() :\n * Validates and post-processes sequences obtained through the external matchfinder API:\n *   - Checks whether nbExternalSeqs represents an error condition.\n *   - Appends a block delimiter to outSeqs if one is not already present.\n *     See zstd.h for context regarding block delimiters.\n * Returns the number of sequences after post-processing, or an error code. */\nstatic size_t ZSTD_postProcessSequenceProducerResult(\n    ZSTD_Sequence* outSeqs, size_t nbExternalSeqs, size_t outSeqsCapacity, size_t srcSize\n) {\n    RETURN_ERROR_IF(\n        nbExternalSeqs > outSeqsCapacity,\n        sequenceProducer_failed,\n        \"External sequence producer returned error code %lu\",\n        (unsigned long)nbExternalSeqs\n    );\n\n    RETURN_ERROR_IF(\n        nbExternalSeqs == 0 && srcSize > 0,\n        sequenceProducer_failed,\n        \"Got zero sequences from external sequence producer for a non-empty src buffer!\"\n    );\n\n    if (srcSize == 0) {\n        ZSTD_memset(&outSeqs[0], 0, sizeof(ZSTD_Sequence));\n        return 1;\n    }\n\n    {\n        ZSTD_Sequence const lastSeq = outSeqs[nbExternalSeqs - 1];\n\n        /* We can return early if lastSeq is already a block delimiter. */\n        if (lastSeq.offset == 0 && lastSeq.matchLength == 0) {\n            return nbExternalSeqs;\n        }\n\n        /* This error condition is only possible if the external matchfinder\n         * produced an invalid parse, by definition of ZSTD_sequenceBound(). */\n        RETURN_ERROR_IF(\n            nbExternalSeqs == outSeqsCapacity,\n            sequenceProducer_failed,\n            \"nbExternalSeqs == outSeqsCapacity but lastSeq is not a block delimiter!\"\n        );\n\n        /* lastSeq is not a block delimiter, so we need to append one. */\n        ZSTD_memset(&outSeqs[nbExternalSeqs], 0, sizeof(ZSTD_Sequence));\n        return nbExternalSeqs + 1;\n    }\n}\n\n/* ZSTD_fastSequenceLengthSum() :\n * Returns sum(litLen) + sum(matchLen) + lastLits for *seqBuf*.\n * Similar to another function in zstd_compress.c (determine_blockSize),\n * except it doesn't check for a block delimiter to end summation.\n * Removing the early exit allows the compiler to auto-vectorize (https://godbolt.org/z/cY1cajz9P).\n * This function can be deleted and replaced by determine_blockSize after we resolve issue #3456. */\nstatic size_t ZSTD_fastSequenceLengthSum(ZSTD_Sequence const* seqBuf, size_t seqBufSize) {\n    size_t matchLenSum, litLenSum, i;\n    matchLenSum = 0;\n    litLenSum = 0;\n    for (i = 0; i < seqBufSize; i++) {\n        litLenSum += seqBuf[i].litLength;\n        matchLenSum += seqBuf[i].matchLength;\n    }\n    return litLenSum + matchLenSum;\n}\n\n/**\n * Function to validate sequences produced by a block compressor.\n */\nstatic void ZSTD_validateSeqStore(const SeqStore_t* seqStore, const ZSTD_compressionParameters* cParams)\n{\n#if DEBUGLEVEL >= 1\n    const SeqDef* seq = seqStore->sequencesStart;\n    const SeqDef* const seqEnd = seqStore->sequences;\n    size_t const matchLenLowerBound = cParams->minMatch == 3 ? 3 : 4;\n    for (; seq < seqEnd; ++seq) {\n        const ZSTD_SequenceLength seqLength = ZSTD_getSequenceLength(seqStore, seq);\n        assert(seqLength.matchLength >= matchLenLowerBound);\n        (void)seqLength;\n        (void)matchLenLowerBound;\n    }\n#else\n    (void)seqStore;\n    (void)cParams;\n#endif\n}\n\nstatic size_t\nZSTD_transferSequences_wBlockDelim(ZSTD_CCtx* cctx,\n                                   ZSTD_SequencePosition* seqPos,\n                             const ZSTD_Sequence* const inSeqs, size_t inSeqsSize,\n                             const void* src, size_t blockSize,\n                                   ZSTD_ParamSwitch_e externalRepSearch);\n\ntypedef enum { ZSTDbss_compress, ZSTDbss_noCompress } ZSTD_BuildSeqStore_e;\n\nstatic size_t ZSTD_buildSeqStore(ZSTD_CCtx* zc, const void* src, size_t srcSize)\n{\n    ZSTD_MatchState_t* const ms = &zc->blockState.matchState;\n    DEBUGLOG(5, \"ZSTD_buildSeqStore (srcSize=%zu)\", srcSize);\n    assert(srcSize <= ZSTD_BLOCKSIZE_MAX);\n    /* Assert that we have correctly flushed the ctx params into the ms's copy */\n    ZSTD_assertEqualCParams(zc->appliedParams.cParams, ms->cParams);\n    /* TODO: See 3090. We reduced MIN_CBLOCK_SIZE from 3 to 2 so to compensate we are adding\n     * additional 1. We need to revisit and change this logic to be more consistent */\n    if (srcSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1+1) {\n        if (zc->appliedParams.cParams.strategy >= ZSTD_btopt) {\n            ZSTD_ldm_skipRawSeqStoreBytes(&zc->externSeqStore, srcSize);\n        } else {\n            ZSTD_ldm_skipSequences(&zc->externSeqStore, srcSize, zc->appliedParams.cParams.minMatch);\n        }\n        return ZSTDbss_noCompress; /* don't even attempt compression below a certain srcSize */\n    }\n    ZSTD_resetSeqStore(&(zc->seqStore));\n    /* required for optimal parser to read stats from dictionary */\n    ms->opt.symbolCosts = &zc->blockState.prevCBlock->entropy;\n    /* tell the optimal parser how we expect to compress literals */\n    ms->opt.literalCompressionMode = zc->appliedParams.literalCompressionMode;\n    /* a gap between an attached dict and the current window is not safe,\n     * they must remain adjacent,\n     * and when that stops being the case, the dict must be unset */\n    assert(ms->dictMatchState == NULL || ms->loadedDictEnd == ms->window.dictLimit);\n\n    /* limited update after a very long match */\n    {   const BYTE* const base = ms->window.base;\n        const BYTE* const istart = (const BYTE*)src;\n        const U32 curr = (U32)(istart-base);\n        if (sizeof(ptrdiff_t)==8) assert(istart - base < (ptrdiff_t)(U32)(-1));   /* ensure no overflow */\n        if (curr > ms->nextToUpdate + 384)\n            ms->nextToUpdate = curr - MIN(192, (U32)(curr - ms->nextToUpdate - 384));\n    }\n\n    /* select and store sequences */\n    {   ZSTD_dictMode_e const dictMode = ZSTD_matchState_dictMode(ms);\n        size_t lastLLSize;\n        {   int i;\n            for (i = 0; i < ZSTD_REP_NUM; ++i)\n                zc->blockState.nextCBlock->rep[i] = zc->blockState.prevCBlock->rep[i];\n        }\n        if (zc->externSeqStore.pos < zc->externSeqStore.size) {\n            assert(zc->appliedParams.ldmParams.enableLdm == ZSTD_ps_disable);\n\n            /* External matchfinder + LDM is technically possible, just not implemented yet.\n             * We need to revisit soon and implement it. */\n            RETURN_ERROR_IF(\n                ZSTD_hasExtSeqProd(&zc->appliedParams),\n                parameter_combination_unsupported,\n                \"Long-distance matching with external sequence producer enabled is not currently supported.\"\n            );\n\n            /* Updates ldmSeqStore.pos */\n            lastLLSize =\n                ZSTD_ldm_blockCompress(&zc->externSeqStore,\n                                       ms, &zc->seqStore,\n                                       zc->blockState.nextCBlock->rep,\n                                       zc->appliedParams.useRowMatchFinder,\n                                       src, srcSize);\n            assert(zc->externSeqStore.pos <= zc->externSeqStore.size);\n        } else if (zc->appliedParams.ldmParams.enableLdm == ZSTD_ps_enable) {\n            RawSeqStore_t ldmSeqStore = kNullRawSeqStore;\n\n            /* External matchfinder + LDM is technically possible, just not implemented yet.\n             * We need to revisit soon and implement it. */\n            RETURN_ERROR_IF(\n                ZSTD_hasExtSeqProd(&zc->appliedParams),\n                parameter_combination_unsupported,\n                \"Long-distance matching with external sequence producer enabled is not currently supported.\"\n            );\n\n            ldmSeqStore.seq = zc->ldmSequences;\n            ldmSeqStore.capacity = zc->maxNbLdmSequences;\n            /* Updates ldmSeqStore.size */\n            FORWARD_IF_ERROR(ZSTD_ldm_generateSequences(&zc->ldmState, &ldmSeqStore,\n                                               &zc->appliedParams.ldmParams,\n                                               src, srcSize), \"\");\n            /* Updates ldmSeqStore.pos */\n            lastLLSize =\n                ZSTD_ldm_blockCompress(&ldmSeqStore,\n                                       ms, &zc->seqStore,\n                                       zc->blockState.nextCBlock->rep,\n                                       zc->appliedParams.useRowMatchFinder,\n                                       src, srcSize);\n            assert(ldmSeqStore.pos == ldmSeqStore.size);\n        } else if (ZSTD_hasExtSeqProd(&zc->appliedParams)) {\n            assert(\n                zc->extSeqBufCapacity >= ZSTD_sequenceBound(srcSize)\n            );\n            assert(zc->appliedParams.extSeqProdFunc != NULL);\n\n            {   U32 const windowSize = (U32)1 << zc->appliedParams.cParams.windowLog;\n\n                size_t const nbExternalSeqs = (zc->appliedParams.extSeqProdFunc)(\n                    zc->appliedParams.extSeqProdState,\n                    zc->extSeqBuf,\n                    zc->extSeqBufCapacity,\n                    src, srcSize,\n                    NULL, 0,  /* dict and dictSize, currently not supported */\n                    zc->appliedParams.compressionLevel,\n                    windowSize\n                );\n\n                size_t const nbPostProcessedSeqs = ZSTD_postProcessSequenceProducerResult(\n                    zc->extSeqBuf,\n                    nbExternalSeqs,\n                    zc->extSeqBufCapacity,\n                    srcSize\n                );\n\n                /* Return early if there is no error, since we don't need to worry about last literals */\n                if (!ZSTD_isError(nbPostProcessedSeqs)) {\n                    ZSTD_SequencePosition seqPos = {0,0,0};\n                    size_t const seqLenSum = ZSTD_fastSequenceLengthSum(zc->extSeqBuf, nbPostProcessedSeqs);\n                    RETURN_ERROR_IF(seqLenSum > srcSize, externalSequences_invalid, \"External sequences imply too large a block!\");\n                    FORWARD_IF_ERROR(\n                        ZSTD_transferSequences_wBlockDelim(\n                            zc, &seqPos,\n                            zc->extSeqBuf, nbPostProcessedSeqs,\n                            src, srcSize,\n                            zc->appliedParams.searchForExternalRepcodes\n                        ),\n                        \"Failed to copy external sequences to seqStore!\"\n                    );\n                    ms->ldmSeqStore = NULL;\n                    DEBUGLOG(5, \"Copied %lu sequences from external sequence producer to internal seqStore.\", (unsigned long)nbExternalSeqs);\n                    return ZSTDbss_compress;\n                }\n\n                /* Propagate the error if fallback is disabled */\n                if (!zc->appliedParams.enableMatchFinderFallback) {\n                    return nbPostProcessedSeqs;\n                }\n\n                /* Fallback to software matchfinder */\n                {   ZSTD_BlockCompressor_f const blockCompressor =\n                        ZSTD_selectBlockCompressor(\n                            zc->appliedParams.cParams.strategy,\n                            zc->appliedParams.useRowMatchFinder,\n                            dictMode);\n                    ms->ldmSeqStore = NULL;\n                    DEBUGLOG(\n                        5,\n                        \"External sequence producer returned error code %lu. Falling back to internal parser.\",\n                        (unsigned long)nbExternalSeqs\n                    );\n                    lastLLSize = blockCompressor(ms, &zc->seqStore, zc->blockState.nextCBlock->rep, src, srcSize);\n            }   }\n        } else {   /* not long range mode and no external matchfinder */\n            ZSTD_BlockCompressor_f const blockCompressor = ZSTD_selectBlockCompressor(\n                    zc->appliedParams.cParams.strategy,\n                    zc->appliedParams.useRowMatchFinder,\n                    dictMode);\n            ms->ldmSeqStore = NULL;\n            lastLLSize = blockCompressor(ms, &zc->seqStore, zc->blockState.nextCBlock->rep, src, srcSize);\n        }\n        {   const BYTE* const lastLiterals = (const BYTE*)src + srcSize - lastLLSize;\n            ZSTD_storeLastLiterals(&zc->seqStore, lastLiterals, lastLLSize);\n    }   }\n    ZSTD_validateSeqStore(&zc->seqStore, &zc->appliedParams.cParams);\n    return ZSTDbss_compress;\n}\n\nstatic size_t ZSTD_copyBlockSequences(SeqCollector* seqCollector, const SeqStore_t* seqStore, const U32 prevRepcodes[ZSTD_REP_NUM])\n{\n    const SeqDef* inSeqs = seqStore->sequencesStart;\n    const size_t nbInSequences = (size_t)(seqStore->sequences - inSeqs);\n    const size_t nbInLiterals = (size_t)(seqStore->lit - seqStore->litStart);\n\n    ZSTD_Sequence* outSeqs = seqCollector->seqIndex == 0 ? seqCollector->seqStart : seqCollector->seqStart + seqCollector->seqIndex;\n    const size_t nbOutSequences = nbInSequences + 1;\n    size_t nbOutLiterals = 0;\n    Repcodes_t repcodes;\n    size_t i;\n\n    /* Bounds check that we have enough space for every input sequence\n     * and the block delimiter\n     */\n    assert(seqCollector->seqIndex <= seqCollector->maxSequences);\n    RETURN_ERROR_IF(\n        nbOutSequences > (size_t)(seqCollector->maxSequences - seqCollector->seqIndex),\n        dstSize_tooSmall,\n        \"Not enough space to copy sequences\");\n\n    ZSTD_memcpy(&repcodes, prevRepcodes, sizeof(repcodes));\n    for (i = 0; i < nbInSequences; ++i) {\n        U32 rawOffset;\n        outSeqs[i].litLength = inSeqs[i].litLength;\n        outSeqs[i].matchLength = inSeqs[i].mlBase + MINMATCH;\n        outSeqs[i].rep = 0;\n\n        /* Handle the possible single length >= 64K\n         * There can only be one because we add MINMATCH to every match length,\n         * and blocks are at most 128K.\n         */\n        if (i == seqStore->longLengthPos) {\n            if (seqStore->longLengthType == ZSTD_llt_literalLength) {\n                outSeqs[i].litLength += 0x10000;\n            } else if (seqStore->longLengthType == ZSTD_llt_matchLength) {\n                outSeqs[i].matchLength += 0x10000;\n            }\n        }\n\n        /* Determine the raw offset given the offBase, which may be a repcode. */\n        if (OFFBASE_IS_REPCODE(inSeqs[i].offBase)) {\n            const U32 repcode = OFFBASE_TO_REPCODE(inSeqs[i].offBase);\n            assert(repcode > 0);\n            outSeqs[i].rep = repcode;\n            if (outSeqs[i].litLength != 0) {\n                rawOffset = repcodes.rep[repcode - 1];\n            } else {\n                if (repcode == 3) {\n                    assert(repcodes.rep[0] > 1);\n                    rawOffset = repcodes.rep[0] - 1;\n                } else {\n                    rawOffset = repcodes.rep[repcode];\n                }\n            }\n        } else {\n            rawOffset = OFFBASE_TO_OFFSET(inSeqs[i].offBase);\n        }\n        outSeqs[i].offset = rawOffset;\n\n        /* Update repcode history for the sequence */\n        ZSTD_updateRep(repcodes.rep,\n                       inSeqs[i].offBase,\n                       inSeqs[i].litLength == 0);\n\n        nbOutLiterals += outSeqs[i].litLength;\n    }\n    /* Insert last literals (if any exist) in the block as a sequence with ml == off == 0.\n     * If there are no last literals, then we'll emit (of: 0, ml: 0, ll: 0), which is a marker\n     * for the block boundary, according to the API.\n     */\n    assert(nbInLiterals >= nbOutLiterals);\n    {\n        const size_t lastLLSize = nbInLiterals - nbOutLiterals;\n        outSeqs[nbInSequences].litLength = (U32)lastLLSize;\n        outSeqs[nbInSequences].matchLength = 0;\n        outSeqs[nbInSequences].offset = 0;\n        assert(nbOutSequences == nbInSequences + 1);\n    }\n    seqCollector->seqIndex += nbOutSequences;\n    assert(seqCollector->seqIndex <= seqCollector->maxSequences);\n\n    return 0;\n}\n\nsize_t ZSTD_sequenceBound(size_t srcSize) {\n    const size_t maxNbSeq = (srcSize / ZSTD_MINMATCH_MIN) + 1;\n    const size_t maxNbDelims = (srcSize / ZSTD_BLOCKSIZE_MAX_MIN) + 1;\n    return maxNbSeq + maxNbDelims;\n}\n\nsize_t ZSTD_generateSequences(ZSTD_CCtx* zc, ZSTD_Sequence* outSeqs,\n                              size_t outSeqsSize, const void* src, size_t srcSize)\n{\n    const size_t dstCapacity = ZSTD_compressBound(srcSize);\n    void* dst; /* Make C90 happy. */\n    SeqCollector seqCollector;\n    {\n        int targetCBlockSize;\n        FORWARD_IF_ERROR(ZSTD_CCtx_getParameter(zc, ZSTD_c_targetCBlockSize, &targetCBlockSize), \"\");\n        RETURN_ERROR_IF(targetCBlockSize != 0, parameter_unsupported, \"targetCBlockSize != 0\");\n    }\n    {\n        int nbWorkers;\n        FORWARD_IF_ERROR(ZSTD_CCtx_getParameter(zc, ZSTD_c_nbWorkers, &nbWorkers), \"\");\n        RETURN_ERROR_IF(nbWorkers != 0, parameter_unsupported, \"nbWorkers != 0\");\n    }\n\n    dst = ZSTD_customMalloc(dstCapacity, ZSTD_defaultCMem);\n    RETURN_ERROR_IF(dst == NULL, memory_allocation, \"NULL pointer!\");\n\n    seqCollector.collectSequences = 1;\n    seqCollector.seqStart = outSeqs;\n    seqCollector.seqIndex = 0;\n    seqCollector.maxSequences = outSeqsSize;\n    zc->seqCollector = seqCollector;\n\n    {\n        const size_t ret = ZSTD_compress2(zc, dst, dstCapacity, src, srcSize);\n        ZSTD_customFree(dst, ZSTD_defaultCMem);\n        FORWARD_IF_ERROR(ret, \"ZSTD_compress2 failed\");\n    }\n    assert(zc->seqCollector.seqIndex <= ZSTD_sequenceBound(srcSize));\n    return zc->seqCollector.seqIndex;\n}\n\nsize_t ZSTD_mergeBlockDelimiters(ZSTD_Sequence* sequences, size_t seqsSize) {\n    size_t in = 0;\n    size_t out = 0;\n    for (; in < seqsSize; ++in) {\n        if (sequences[in].offset == 0 && sequences[in].matchLength == 0) {\n            if (in != seqsSize - 1) {\n                sequences[in+1].litLength += sequences[in].litLength;\n            }\n        } else {\n            sequences[out] = sequences[in];\n            ++out;\n        }\n    }\n    return out;\n}\n\n/* Unrolled loop to read four size_ts of input at a time. Returns 1 if is RLE, 0 if not. */\nstatic int ZSTD_isRLE(const BYTE* src, size_t length) {\n    const BYTE* ip = src;\n    const BYTE value = ip[0];\n    const size_t valueST = (size_t)((U64)value * 0x0101010101010101ULL);\n    const size_t unrollSize = sizeof(size_t) * 4;\n    const size_t unrollMask = unrollSize - 1;\n    const size_t prefixLength = length & unrollMask;\n    size_t i;\n    if (length == 1) return 1;\n    /* Check if prefix is RLE first before using unrolled loop */\n    if (prefixLength && ZSTD_count(ip+1, ip, ip+prefixLength) != prefixLength-1) {\n        return 0;\n    }\n    for (i = prefixLength; i != length; i += unrollSize) {\n        size_t u;\n        for (u = 0; u < unrollSize; u += sizeof(size_t)) {\n            if (MEM_readST(ip + i + u) != valueST) {\n                return 0;\n    }   }   }\n    return 1;\n}\n\n/* Returns true if the given block may be RLE.\n * This is just a heuristic based on the compressibility.\n * It may return both false positives and false negatives.\n */\nstatic int ZSTD_maybeRLE(SeqStore_t const* seqStore)\n{\n    size_t const nbSeqs = (size_t)(seqStore->sequences - seqStore->sequencesStart);\n    size_t const nbLits = (size_t)(seqStore->lit - seqStore->litStart);\n\n    return nbSeqs < 4 && nbLits < 10;\n}\n\nstatic void\nZSTD_blockState_confirmRepcodesAndEntropyTables(ZSTD_blockState_t* const bs)\n{\n    ZSTD_compressedBlockState_t* const tmp = bs->prevCBlock;\n    bs->prevCBlock = bs->nextCBlock;\n    bs->nextCBlock = tmp;\n}\n\n/* Writes the block header */\nstatic void\nwriteBlockHeader(void* op, size_t cSize, size_t blockSize, U32 lastBlock)\n{\n    U32 const cBlockHeader = cSize == 1 ?\n                        lastBlock + (((U32)bt_rle)<<1) + (U32)(blockSize << 3) :\n                        lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);\n    MEM_writeLE24(op, cBlockHeader);\n    DEBUGLOG(5, \"writeBlockHeader: cSize: %zu blockSize: %zu lastBlock: %u\", cSize, blockSize, lastBlock);\n}\n\n/** ZSTD_buildBlockEntropyStats_literals() :\n *  Builds entropy for the literals.\n *  Stores literals block type (raw, rle, compressed, repeat) and\n *  huffman description table to hufMetadata.\n *  Requires ENTROPY_WORKSPACE_SIZE workspace\n * @return : size of huffman description table, or an error code\n */\nstatic size_t\nZSTD_buildBlockEntropyStats_literals(void* const src, size_t srcSize,\n                               const ZSTD_hufCTables_t* prevHuf,\n                                     ZSTD_hufCTables_t* nextHuf,\n                                     ZSTD_hufCTablesMetadata_t* hufMetadata,\n                               const int literalsCompressionIsDisabled,\n                                     void* workspace, size_t wkspSize,\n                                     int hufFlags)\n{\n    BYTE* const wkspStart = (BYTE*)workspace;\n    BYTE* const wkspEnd = wkspStart + wkspSize;\n    BYTE* const countWkspStart = wkspStart;\n    unsigned* const countWksp = (unsigned*)workspace;\n    const size_t countWkspSize = (HUF_SYMBOLVALUE_MAX + 1) * sizeof(unsigned);\n    BYTE* const nodeWksp = countWkspStart + countWkspSize;\n    const size_t nodeWkspSize = (size_t)(wkspEnd - nodeWksp);\n    unsigned maxSymbolValue = HUF_SYMBOLVALUE_MAX;\n    unsigned huffLog = LitHufLog;\n    HUF_repeat repeat = prevHuf->repeatMode;\n    DEBUGLOG(5, \"ZSTD_buildBlockEntropyStats_literals (srcSize=%zu)\", srcSize);\n\n    /* Prepare nextEntropy assuming reusing the existing table */\n    ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));\n\n    if (literalsCompressionIsDisabled) {\n        DEBUGLOG(5, \"set_basic - disabled\");\n        hufMetadata->hType = set_basic;\n        return 0;\n    }\n\n    /* small ? don't even attempt compression (speed opt) */\n#ifndef COMPRESS_LITERALS_SIZE_MIN\n# define COMPRESS_LITERALS_SIZE_MIN 63  /* heuristic */\n#endif\n    {   size_t const minLitSize = (prevHuf->repeatMode == HUF_repeat_valid) ? 6 : COMPRESS_LITERALS_SIZE_MIN;\n        if (srcSize <= minLitSize) {\n            DEBUGLOG(5, \"set_basic - too small\");\n            hufMetadata->hType = set_basic;\n            return 0;\n    }   }\n\n    /* Scan input and build symbol stats */\n    {   size_t const largest =\n            HIST_count_wksp (countWksp, &maxSymbolValue,\n                            (const BYTE*)src, srcSize,\n                            workspace, wkspSize);\n        FORWARD_IF_ERROR(largest, \"HIST_count_wksp failed\");\n        if (largest == srcSize) {\n            /* only one literal symbol */\n            DEBUGLOG(5, \"set_rle\");\n            hufMetadata->hType = set_rle;\n            return 0;\n        }\n        if (largest <= (srcSize >> 7)+4) {\n            /* heuristic: likely not compressible */\n            DEBUGLOG(5, \"set_basic - no gain\");\n            hufMetadata->hType = set_basic;\n            return 0;\n    }   }\n\n    /* Validate the previous Huffman table */\n    if (repeat == HUF_repeat_check\n      && !HUF_validateCTable((HUF_CElt const*)prevHuf->CTable, countWksp, maxSymbolValue)) {\n        repeat = HUF_repeat_none;\n    }\n\n    /* Build Huffman Tree */\n    ZSTD_memset(nextHuf->CTable, 0, sizeof(nextHuf->CTable));\n    huffLog = HUF_optimalTableLog(huffLog, srcSize, maxSymbolValue, nodeWksp, nodeWkspSize, nextHuf->CTable, countWksp, hufFlags);\n    assert(huffLog <= LitHufLog);\n    {   size_t const maxBits = HUF_buildCTable_wksp((HUF_CElt*)nextHuf->CTable, countWksp,\n                                                    maxSymbolValue, huffLog,\n                                                    nodeWksp, nodeWkspSize);\n        FORWARD_IF_ERROR(maxBits, \"HUF_buildCTable_wksp\");\n        huffLog = (U32)maxBits;\n    }\n    {   /* Build and write the CTable */\n        size_t const newCSize = HUF_estimateCompressedSize(\n                (HUF_CElt*)nextHuf->CTable, countWksp, maxSymbolValue);\n        size_t const hSize = HUF_writeCTable_wksp(\n                hufMetadata->hufDesBuffer, sizeof(hufMetadata->hufDesBuffer),\n                (HUF_CElt*)nextHuf->CTable, maxSymbolValue, huffLog,\n                nodeWksp, nodeWkspSize);\n        /* Check against repeating the previous CTable */\n        if (repeat != HUF_repeat_none) {\n            size_t const oldCSize = HUF_estimateCompressedSize(\n                    (HUF_CElt const*)prevHuf->CTable, countWksp, maxSymbolValue);\n            if (oldCSize < srcSize && (oldCSize <= hSize + newCSize || hSize + 12 >= srcSize)) {\n                DEBUGLOG(5, \"set_repeat - smaller\");\n                ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));\n                hufMetadata->hType = set_repeat;\n                return 0;\n        }   }\n        if (newCSize + hSize >= srcSize) {\n            DEBUGLOG(5, \"set_basic - no gains\");\n            ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));\n            hufMetadata->hType = set_basic;\n            return 0;\n        }\n        DEBUGLOG(5, \"set_compressed (hSize=%u)\", (U32)hSize);\n        hufMetadata->hType = set_compressed;\n        nextHuf->repeatMode = HUF_repeat_check;\n        return hSize;\n    }\n}\n\n\n/* ZSTD_buildDummySequencesStatistics():\n * Returns a ZSTD_symbolEncodingTypeStats_t with all encoding types as set_basic,\n * and updates nextEntropy to the appropriate repeatMode.\n */\nstatic ZSTD_symbolEncodingTypeStats_t\nZSTD_buildDummySequencesStatistics(ZSTD_fseCTables_t* nextEntropy)\n{\n    ZSTD_symbolEncodingTypeStats_t stats = {set_basic, set_basic, set_basic, 0, 0, 0};\n    nextEntropy->litlength_repeatMode = FSE_repeat_none;\n    nextEntropy->offcode_repeatMode = FSE_repeat_none;\n    nextEntropy->matchlength_repeatMode = FSE_repeat_none;\n    return stats;\n}\n\n/** ZSTD_buildBlockEntropyStats_sequences() :\n *  Builds entropy for the sequences.\n *  Stores symbol compression modes and fse table to fseMetadata.\n *  Requires ENTROPY_WORKSPACE_SIZE wksp.\n * @return : size of fse tables or error code */\nstatic size_t\nZSTD_buildBlockEntropyStats_sequences(\n                const SeqStore_t* seqStorePtr,\n                const ZSTD_fseCTables_t* prevEntropy,\n                      ZSTD_fseCTables_t* nextEntropy,\n                const ZSTD_CCtx_params* cctxParams,\n                      ZSTD_fseCTablesMetadata_t* fseMetadata,\n                      void* workspace, size_t wkspSize)\n{\n    ZSTD_strategy const strategy = cctxParams->cParams.strategy;\n    size_t const nbSeq = (size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart);\n    BYTE* const ostart = fseMetadata->fseTablesBuffer;\n    BYTE* const oend = ostart + sizeof(fseMetadata->fseTablesBuffer);\n    BYTE* op = ostart;\n    unsigned* countWorkspace = (unsigned*)workspace;\n    unsigned* entropyWorkspace = countWorkspace + (MaxSeq + 1);\n    size_t entropyWorkspaceSize = wkspSize - (MaxSeq + 1) * sizeof(*countWorkspace);\n    ZSTD_symbolEncodingTypeStats_t stats;\n\n    DEBUGLOG(5, \"ZSTD_buildBlockEntropyStats_sequences (nbSeq=%zu)\", nbSeq);\n    stats = nbSeq != 0 ? ZSTD_buildSequencesStatistics(seqStorePtr, nbSeq,\n                                          prevEntropy, nextEntropy, op, oend,\n                                          strategy, countWorkspace,\n                                          entropyWorkspace, entropyWorkspaceSize)\n                       : ZSTD_buildDummySequencesStatistics(nextEntropy);\n    FORWARD_IF_ERROR(stats.size, \"ZSTD_buildSequencesStatistics failed!\");\n    fseMetadata->llType = (SymbolEncodingType_e) stats.LLtype;\n    fseMetadata->ofType = (SymbolEncodingType_e) stats.Offtype;\n    fseMetadata->mlType = (SymbolEncodingType_e) stats.MLtype;\n    fseMetadata->lastCountSize = stats.lastCountSize;\n    return stats.size;\n}\n\n\n/** ZSTD_buildBlockEntropyStats() :\n *  Builds entropy for the block.\n *  Requires workspace size ENTROPY_WORKSPACE_SIZE\n * @return : 0 on success, or an error code\n *  Note : also employed in superblock\n */\nsize_t ZSTD_buildBlockEntropyStats(\n            const SeqStore_t* seqStorePtr,\n            const ZSTD_entropyCTables_t* prevEntropy,\n                  ZSTD_entropyCTables_t* nextEntropy,\n            const ZSTD_CCtx_params* cctxParams,\n                  ZSTD_entropyCTablesMetadata_t* entropyMetadata,\n                  void* workspace, size_t wkspSize)\n{\n    size_t const litSize = (size_t)(seqStorePtr->lit - seqStorePtr->litStart);\n    int const huf_useOptDepth = (cctxParams->cParams.strategy >= HUF_OPTIMAL_DEPTH_THRESHOLD);\n    int const hufFlags = huf_useOptDepth ? HUF_flags_optimalDepth : 0;\n\n    entropyMetadata->hufMetadata.hufDesSize =\n        ZSTD_buildBlockEntropyStats_literals(seqStorePtr->litStart, litSize,\n                                            &prevEntropy->huf, &nextEntropy->huf,\n                                            &entropyMetadata->hufMetadata,\n                                            ZSTD_literalsCompressionIsDisabled(cctxParams),\n                                            workspace, wkspSize, hufFlags);\n\n    FORWARD_IF_ERROR(entropyMetadata->hufMetadata.hufDesSize, \"ZSTD_buildBlockEntropyStats_literals failed\");\n    entropyMetadata->fseMetadata.fseTablesSize =\n        ZSTD_buildBlockEntropyStats_sequences(seqStorePtr,\n                                              &prevEntropy->fse, &nextEntropy->fse,\n                                              cctxParams,\n                                              &entropyMetadata->fseMetadata,\n                                              workspace, wkspSize);\n    FORWARD_IF_ERROR(entropyMetadata->fseMetadata.fseTablesSize, \"ZSTD_buildBlockEntropyStats_sequences failed\");\n    return 0;\n}\n\n/* Returns the size estimate for the literals section (header + content) of a block */\nstatic size_t\nZSTD_estimateBlockSize_literal(const BYTE* literals, size_t litSize,\n                               const ZSTD_hufCTables_t* huf,\n                               const ZSTD_hufCTablesMetadata_t* hufMetadata,\n                               void* workspace, size_t wkspSize,\n                               int writeEntropy)\n{\n    unsigned* const countWksp = (unsigned*)workspace;\n    unsigned maxSymbolValue = HUF_SYMBOLVALUE_MAX;\n    size_t literalSectionHeaderSize = 3 + (litSize >= 1 KB) + (litSize >= 16 KB);\n    U32 singleStream = litSize < 256;\n\n    if (hufMetadata->hType == set_basic) return litSize;\n    else if (hufMetadata->hType == set_rle) return 1;\n    else if (hufMetadata->hType == set_compressed || hufMetadata->hType == set_repeat) {\n        size_t const largest = HIST_count_wksp (countWksp, &maxSymbolValue, (const BYTE*)literals, litSize, workspace, wkspSize);\n        if (ZSTD_isError(largest)) return litSize;\n        {   size_t cLitSizeEstimate = HUF_estimateCompressedSize((const HUF_CElt*)huf->CTable, countWksp, maxSymbolValue);\n            if (writeEntropy) cLitSizeEstimate += hufMetadata->hufDesSize;\n            if (!singleStream) cLitSizeEstimate += 6; /* multi-stream huffman uses 6-byte jump table */\n            return cLitSizeEstimate + literalSectionHeaderSize;\n    }   }\n    assert(0); /* impossible */\n    return 0;\n}\n\n/* Returns the size estimate for the FSE-compressed symbols (of, ml, ll) of a block */\nstatic size_t\nZSTD_estimateBlockSize_symbolType(SymbolEncodingType_e type,\n                    const BYTE* codeTable, size_t nbSeq, unsigned maxCode,\n                    const FSE_CTable* fseCTable,\n                    const U8* additionalBits,\n                    short const* defaultNorm, U32 defaultNormLog, U32 defaultMax,\n                    void* workspace, size_t wkspSize)\n{\n    unsigned* const countWksp = (unsigned*)workspace;\n    const BYTE* ctp = codeTable;\n    const BYTE* const ctStart = ctp;\n    const BYTE* const ctEnd = ctStart + nbSeq;\n    size_t cSymbolTypeSizeEstimateInBits = 0;\n    unsigned max = maxCode;\n\n    HIST_countFast_wksp(countWksp, &max, codeTable, nbSeq, workspace, wkspSize);  /* can't fail */\n    if (type == set_basic) {\n        /* We selected this encoding type, so it must be valid. */\n        assert(max <= defaultMax);\n        (void)defaultMax;\n        cSymbolTypeSizeEstimateInBits = ZSTD_crossEntropyCost(defaultNorm, defaultNormLog, countWksp, max);\n    } else if (type == set_rle) {\n        cSymbolTypeSizeEstimateInBits = 0;\n    } else if (type == set_compressed || type == set_repeat) {\n        cSymbolTypeSizeEstimateInBits = ZSTD_fseBitCost(fseCTable, countWksp, max);\n    }\n    if (ZSTD_isError(cSymbolTypeSizeEstimateInBits)) {\n        return nbSeq * 10;\n    }\n    while (ctp < ctEnd) {\n        if (additionalBits) cSymbolTypeSizeEstimateInBits += additionalBits[*ctp];\n        else cSymbolTypeSizeEstimateInBits += *ctp; /* for offset, offset code is also the number of additional bits */\n        ctp++;\n    }\n    return cSymbolTypeSizeEstimateInBits >> 3;\n}\n\n/* Returns the size estimate for the sequences section (header + content) of a block */\nstatic size_t\nZSTD_estimateBlockSize_sequences(const BYTE* ofCodeTable,\n                                 const BYTE* llCodeTable,\n                                 const BYTE* mlCodeTable,\n                                 size_t nbSeq,\n                                 const ZSTD_fseCTables_t* fseTables,\n                                 const ZSTD_fseCTablesMetadata_t* fseMetadata,\n                                 void* workspace, size_t wkspSize,\n                                 int writeEntropy)\n{\n    size_t sequencesSectionHeaderSize = 1 /* seqHead */ + 1 /* min seqSize size */ + (nbSeq >= 128) + (nbSeq >= LONGNBSEQ);\n    size_t cSeqSizeEstimate = 0;\n    cSeqSizeEstimate += ZSTD_estimateBlockSize_symbolType(fseMetadata->ofType, ofCodeTable, nbSeq, MaxOff,\n                                    fseTables->offcodeCTable, NULL,\n                                    OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff,\n                                    workspace, wkspSize);\n    cSeqSizeEstimate += ZSTD_estimateBlockSize_symbolType(fseMetadata->llType, llCodeTable, nbSeq, MaxLL,\n                                    fseTables->litlengthCTable, LL_bits,\n                                    LL_defaultNorm, LL_defaultNormLog, MaxLL,\n                                    workspace, wkspSize);\n    cSeqSizeEstimate += ZSTD_estimateBlockSize_symbolType(fseMetadata->mlType, mlCodeTable, nbSeq, MaxML,\n                                    fseTables->matchlengthCTable, ML_bits,\n                                    ML_defaultNorm, ML_defaultNormLog, MaxML,\n                                    workspace, wkspSize);\n    if (writeEntropy) cSeqSizeEstimate += fseMetadata->fseTablesSize;\n    return cSeqSizeEstimate + sequencesSectionHeaderSize;\n}\n\n/* Returns the size estimate for a given stream of literals, of, ll, ml */\nstatic size_t\nZSTD_estimateBlockSize(const BYTE* literals, size_t litSize,\n                       const BYTE* ofCodeTable,\n                       const BYTE* llCodeTable,\n                       const BYTE* mlCodeTable,\n                       size_t nbSeq,\n                       const ZSTD_entropyCTables_t* entropy,\n                       const ZSTD_entropyCTablesMetadata_t* entropyMetadata,\n                       void* workspace, size_t wkspSize,\n                       int writeLitEntropy, int writeSeqEntropy)\n{\n    size_t const literalsSize = ZSTD_estimateBlockSize_literal(literals, litSize,\n                                    &entropy->huf, &entropyMetadata->hufMetadata,\n                                    workspace, wkspSize, writeLitEntropy);\n    size_t const seqSize = ZSTD_estimateBlockSize_sequences(ofCodeTable, llCodeTable, mlCodeTable,\n                                    nbSeq, &entropy->fse, &entropyMetadata->fseMetadata,\n                                    workspace, wkspSize, writeSeqEntropy);\n    return seqSize + literalsSize + ZSTD_blockHeaderSize;\n}\n\n/* Builds entropy statistics and uses them for blocksize estimation.\n *\n * @return: estimated compressed size of the seqStore, or a zstd error.\n */\nstatic size_t\nZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(SeqStore_t* seqStore, ZSTD_CCtx* zc)\n{\n    ZSTD_entropyCTablesMetadata_t* const entropyMetadata = &zc->blockSplitCtx.entropyMetadata;\n    DEBUGLOG(6, \"ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize()\");\n    FORWARD_IF_ERROR(ZSTD_buildBlockEntropyStats(seqStore,\n                    &zc->blockState.prevCBlock->entropy,\n                    &zc->blockState.nextCBlock->entropy,\n                    &zc->appliedParams,\n                    entropyMetadata,\n                    zc->tmpWorkspace, zc->tmpWkspSize), \"\");\n    return ZSTD_estimateBlockSize(\n                    seqStore->litStart, (size_t)(seqStore->lit - seqStore->litStart),\n                    seqStore->ofCode, seqStore->llCode, seqStore->mlCode,\n                    (size_t)(seqStore->sequences - seqStore->sequencesStart),\n                    &zc->blockState.nextCBlock->entropy,\n                    entropyMetadata,\n                    zc->tmpWorkspace, zc->tmpWkspSize,\n                    (int)(entropyMetadata->hufMetadata.hType == set_compressed), 1);\n}\n\n/* Returns literals bytes represented in a seqStore */\nstatic size_t ZSTD_countSeqStoreLiteralsBytes(const SeqStore_t* const seqStore)\n{\n    size_t literalsBytes = 0;\n    size_t const nbSeqs = (size_t)(seqStore->sequences - seqStore->sequencesStart);\n    size_t i;\n    for (i = 0; i < nbSeqs; ++i) {\n        SeqDef const seq = seqStore->sequencesStart[i];\n        literalsBytes += seq.litLength;\n        if (i == seqStore->longLengthPos && seqStore->longLengthType == ZSTD_llt_literalLength) {\n            literalsBytes += 0x10000;\n    }   }\n    return literalsBytes;\n}\n\n/* Returns match bytes represented in a seqStore */\nstatic size_t ZSTD_countSeqStoreMatchBytes(const SeqStore_t* const seqStore)\n{\n    size_t matchBytes = 0;\n    size_t const nbSeqs = (size_t)(seqStore->sequences - seqStore->sequencesStart);\n    size_t i;\n    for (i = 0; i < nbSeqs; ++i) {\n        SeqDef seq = seqStore->sequencesStart[i];\n        matchBytes += seq.mlBase + MINMATCH;\n        if (i == seqStore->longLengthPos && seqStore->longLengthType == ZSTD_llt_matchLength) {\n            matchBytes += 0x10000;\n    }   }\n    return matchBytes;\n}\n\n/* Derives the seqStore that is a chunk of the originalSeqStore from [startIdx, endIdx).\n * Stores the result in resultSeqStore.\n */\nstatic void ZSTD_deriveSeqStoreChunk(SeqStore_t* resultSeqStore,\n                               const SeqStore_t* originalSeqStore,\n                                     size_t startIdx, size_t endIdx)\n{\n    *resultSeqStore = *originalSeqStore;\n    if (startIdx > 0) {\n        resultSeqStore->sequences = originalSeqStore->sequencesStart + startIdx;\n        resultSeqStore->litStart += ZSTD_countSeqStoreLiteralsBytes(resultSeqStore);\n    }\n\n    /* Move longLengthPos into the correct position if necessary */\n    if (originalSeqStore->longLengthType != ZSTD_llt_none) {\n        if (originalSeqStore->longLengthPos < startIdx || originalSeqStore->longLengthPos > endIdx) {\n            resultSeqStore->longLengthType = ZSTD_llt_none;\n        } else {\n            resultSeqStore->longLengthPos -= (U32)startIdx;\n        }\n    }\n    resultSeqStore->sequencesStart = originalSeqStore->sequencesStart + startIdx;\n    resultSeqStore->sequences = originalSeqStore->sequencesStart + endIdx;\n    if (endIdx == (size_t)(originalSeqStore->sequences - originalSeqStore->sequencesStart)) {\n        /* This accounts for possible last literals if the derived chunk reaches the end of the block */\n        assert(resultSeqStore->lit == originalSeqStore->lit);\n    } else {\n        size_t const literalsBytes = ZSTD_countSeqStoreLiteralsBytes(resultSeqStore);\n        resultSeqStore->lit = resultSeqStore->litStart + literalsBytes;\n    }\n    resultSeqStore->llCode += startIdx;\n    resultSeqStore->mlCode += startIdx;\n    resultSeqStore->ofCode += startIdx;\n}\n\n/**\n * Returns the raw offset represented by the combination of offBase, ll0, and repcode history.\n * offBase must represent a repcode in the numeric representation of ZSTD_storeSeq().\n */\nstatic U32\nZSTD_resolveRepcodeToRawOffset(const U32 rep[ZSTD_REP_NUM], const U32 offBase, const U32 ll0)\n{\n    U32 const adjustedRepCode = OFFBASE_TO_REPCODE(offBase) - 1 + ll0;  /* [ 0 - 3 ] */\n    assert(OFFBASE_IS_REPCODE(offBase));\n    if (adjustedRepCode == ZSTD_REP_NUM) {\n        assert(ll0);\n        /* litlength == 0 and offCode == 2 implies selection of first repcode - 1\n         * This is only valid if it results in a valid offset value, aka > 0.\n         * Note : it may happen that `rep[0]==1` in exceptional circumstances.\n         * In which case this function will return 0, which is an invalid offset.\n         * It's not an issue though, since this value will be\n         * compared and discarded within ZSTD_seqStore_resolveOffCodes().\n         */\n        return rep[0] - 1;\n    }\n    return rep[adjustedRepCode];\n}\n\n/**\n * ZSTD_seqStore_resolveOffCodes() reconciles any possible divergences in offset history that may arise\n * due to emission of RLE/raw blocks that disturb the offset history,\n * and replaces any repcodes within the seqStore that may be invalid.\n *\n * dRepcodes are updated as would be on the decompression side.\n * cRepcodes are updated exactly in accordance with the seqStore.\n *\n * Note : this function assumes seq->offBase respects the following numbering scheme :\n *        0 : invalid\n *        1-3 : repcode 1-3\n *        4+ : real_offset+3\n */\nstatic void\nZSTD_seqStore_resolveOffCodes(Repcodes_t* const dRepcodes, Repcodes_t* const cRepcodes,\n                        const SeqStore_t* const seqStore, U32 const nbSeq)\n{\n    U32 idx = 0;\n    U32 const longLitLenIdx = seqStore->longLengthType == ZSTD_llt_literalLength ? seqStore->longLengthPos : nbSeq;\n    for (; idx < nbSeq; ++idx) {\n        SeqDef* const seq = seqStore->sequencesStart + idx;\n        U32 const ll0 = (seq->litLength == 0) && (idx != longLitLenIdx);\n        U32 const offBase = seq->offBase;\n        assert(offBase > 0);\n        if (OFFBASE_IS_REPCODE(offBase)) {\n            U32 const dRawOffset = ZSTD_resolveRepcodeToRawOffset(dRepcodes->rep, offBase, ll0);\n            U32 const cRawOffset = ZSTD_resolveRepcodeToRawOffset(cRepcodes->rep, offBase, ll0);\n            /* Adjust simulated decompression repcode history if we come across a mismatch. Replace\n             * the repcode with the offset it actually references, determined by the compression\n             * repcode history.\n             */\n            if (dRawOffset != cRawOffset) {\n                seq->offBase = OFFSET_TO_OFFBASE(cRawOffset);\n            }\n        }\n        /* Compression repcode history is always updated with values directly from the unmodified seqStore.\n         * Decompression repcode history may use modified seq->offset value taken from compression repcode history.\n         */\n        ZSTD_updateRep(dRepcodes->rep, seq->offBase, ll0);\n        ZSTD_updateRep(cRepcodes->rep, offBase, ll0);\n    }\n}\n\n/* ZSTD_compressSeqStore_singleBlock():\n * Compresses a seqStore into a block with a block header, into the buffer dst.\n *\n * Returns the total size of that block (including header) or a ZSTD error code.\n */\nstatic size_t\nZSTD_compressSeqStore_singleBlock(ZSTD_CCtx* zc,\n                            const SeqStore_t* const seqStore,\n                                  Repcodes_t* const dRep, Repcodes_t* const cRep,\n                                  void* dst, size_t dstCapacity,\n                            const void* src, size_t srcSize,\n                                  U32 lastBlock, U32 isPartition)\n{\n    const U32 rleMaxLength = 25;\n    BYTE* op = (BYTE*)dst;\n    const BYTE* ip = (const BYTE*)src;\n    size_t cSize;\n    size_t cSeqsSize;\n\n    /* In case of an RLE or raw block, the simulated decompression repcode history must be reset */\n    Repcodes_t const dRepOriginal = *dRep;\n    DEBUGLOG(5, \"ZSTD_compressSeqStore_singleBlock\");\n    if (isPartition)\n        ZSTD_seqStore_resolveOffCodes(dRep, cRep, seqStore, (U32)(seqStore->sequences - seqStore->sequencesStart));\n\n    RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize, dstSize_tooSmall, \"Block header doesn't fit\");\n    cSeqsSize = ZSTD_entropyCompressSeqStore(seqStore,\n                &zc->blockState.prevCBlock->entropy, &zc->blockState.nextCBlock->entropy,\n                &zc->appliedParams,\n                op + ZSTD_blockHeaderSize, dstCapacity - ZSTD_blockHeaderSize,\n                srcSize,\n                zc->tmpWorkspace, zc->tmpWkspSize /* statically allocated in resetCCtx */,\n                zc->bmi2);\n    FORWARD_IF_ERROR(cSeqsSize, \"ZSTD_entropyCompressSeqStore failed!\");\n\n    if (!zc->isFirstBlock &&\n        cSeqsSize < rleMaxLength &&\n        ZSTD_isRLE((BYTE const*)src, srcSize)) {\n        /* We don't want to emit our first block as a RLE even if it qualifies because\n        * doing so will cause the decoder (cli only) to throw a \"should consume all input error.\"\n        * This is only an issue for zstd <= v1.4.3\n        */\n        cSeqsSize = 1;\n    }\n\n    /* Sequence collection not supported when block splitting */\n    if (zc->seqCollector.collectSequences) {\n        FORWARD_IF_ERROR(ZSTD_copyBlockSequences(&zc->seqCollector, seqStore, dRepOriginal.rep), \"copyBlockSequences failed\");\n        ZSTD_blockState_confirmRepcodesAndEntropyTables(&zc->blockState);\n        return 0;\n    }\n\n    if (cSeqsSize == 0) {\n        cSize = ZSTD_noCompressBlock(op, dstCapacity, ip, srcSize, lastBlock);\n        FORWARD_IF_ERROR(cSize, \"Nocompress block failed\");\n        DEBUGLOG(5, \"Writing out nocompress block, size: %zu\", cSize);\n        *dRep = dRepOriginal; /* reset simulated decompression repcode history */\n    } else if (cSeqsSize == 1) {\n        cSize = ZSTD_rleCompressBlock(op, dstCapacity, *ip, srcSize, lastBlock);\n        FORWARD_IF_ERROR(cSize, \"RLE compress block failed\");\n        DEBUGLOG(5, \"Writing out RLE block, size: %zu\", cSize);\n        *dRep = dRepOriginal; /* reset simulated decompression repcode history */\n    } else {\n        ZSTD_blockState_confirmRepcodesAndEntropyTables(&zc->blockState);\n        writeBlockHeader(op, cSeqsSize, srcSize, lastBlock);\n        cSize = ZSTD_blockHeaderSize + cSeqsSize;\n        DEBUGLOG(5, \"Writing out compressed block, size: %zu\", cSize);\n    }\n\n    if (zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)\n        zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;\n\n    return cSize;\n}\n\n/* Struct to keep track of where we are in our recursive calls. */\ntypedef struct {\n    U32* splitLocations;    /* Array of split indices */\n    size_t idx;             /* The current index within splitLocations being worked on */\n} seqStoreSplits;\n\n#define MIN_SEQUENCES_BLOCK_SPLITTING 300\n\n/* Helper function to perform the recursive search for block splits.\n * Estimates the cost of seqStore prior to split, and estimates the cost of splitting the sequences in half.\n * If advantageous to split, then we recurse down the two sub-blocks.\n * If not, or if an error occurred in estimation, then we do not recurse.\n *\n * Note: The recursion depth is capped by a heuristic minimum number of sequences,\n * defined by MIN_SEQUENCES_BLOCK_SPLITTING.\n * In theory, this means the absolute largest recursion depth is 10 == log2(maxNbSeqInBlock/MIN_SEQUENCES_BLOCK_SPLITTING).\n * In practice, recursion depth usually doesn't go beyond 4.\n *\n * Furthermore, the number of splits is capped by ZSTD_MAX_NB_BLOCK_SPLITS.\n * At ZSTD_MAX_NB_BLOCK_SPLITS == 196 with the current existing blockSize\n * maximum of 128 KB, this value is actually impossible to reach.\n */\nstatic void\nZSTD_deriveBlockSplitsHelper(seqStoreSplits* splits, size_t startIdx, size_t endIdx,\n                             ZSTD_CCtx* zc, const SeqStore_t* origSeqStore)\n{\n    SeqStore_t* const fullSeqStoreChunk = &zc->blockSplitCtx.fullSeqStoreChunk;\n    SeqStore_t* const firstHalfSeqStore = &zc->blockSplitCtx.firstHalfSeqStore;\n    SeqStore_t* const secondHalfSeqStore = &zc->blockSplitCtx.secondHalfSeqStore;\n    size_t estimatedOriginalSize;\n    size_t estimatedFirstHalfSize;\n    size_t estimatedSecondHalfSize;\n    size_t midIdx = (startIdx + endIdx)/2;\n\n    DEBUGLOG(5, \"ZSTD_deriveBlockSplitsHelper: startIdx=%zu endIdx=%zu\", startIdx, endIdx);\n    assert(endIdx >= startIdx);\n    if (endIdx - startIdx < MIN_SEQUENCES_BLOCK_SPLITTING || splits->idx >= ZSTD_MAX_NB_BLOCK_SPLITS) {\n        DEBUGLOG(6, \"ZSTD_deriveBlockSplitsHelper: Too few sequences (%zu)\", endIdx - startIdx);\n        return;\n    }\n    ZSTD_deriveSeqStoreChunk(fullSeqStoreChunk, origSeqStore, startIdx, endIdx);\n    ZSTD_deriveSeqStoreChunk(firstHalfSeqStore, origSeqStore, startIdx, midIdx);\n    ZSTD_deriveSeqStoreChunk(secondHalfSeqStore, origSeqStore, midIdx, endIdx);\n    estimatedOriginalSize = ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(fullSeqStoreChunk, zc);\n    estimatedFirstHalfSize = ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(firstHalfSeqStore, zc);\n    estimatedSecondHalfSize = ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(secondHalfSeqStore, zc);\n    DEBUGLOG(5, \"Estimated original block size: %zu -- First half split: %zu -- Second half split: %zu\",\n             estimatedOriginalSize, estimatedFirstHalfSize, estimatedSecondHalfSize);\n    if (ZSTD_isError(estimatedOriginalSize) || ZSTD_isError(estimatedFirstHalfSize) || ZSTD_isError(estimatedSecondHalfSize)) {\n        return;\n    }\n    if (estimatedFirstHalfSize + estimatedSecondHalfSize < estimatedOriginalSize) {\n        DEBUGLOG(5, \"split decided at seqNb:%zu\", midIdx);\n        ZSTD_deriveBlockSplitsHelper(splits, startIdx, midIdx, zc, origSeqStore);\n        splits->splitLocations[splits->idx] = (U32)midIdx;\n        splits->idx++;\n        ZSTD_deriveBlockSplitsHelper(splits, midIdx, endIdx, zc, origSeqStore);\n    }\n}\n\n/* Base recursive function.\n * Populates a table with intra-block partition indices that can improve compression ratio.\n *\n * @return: number of splits made (which equals the size of the partition table - 1).\n */\nstatic size_t ZSTD_deriveBlockSplits(ZSTD_CCtx* zc, U32 partitions[], U32 nbSeq)\n{\n    seqStoreSplits splits;\n    splits.splitLocations = partitions;\n    splits.idx = 0;\n    if (nbSeq <= 4) {\n        DEBUGLOG(5, \"ZSTD_deriveBlockSplits: Too few sequences to split (%u <= 4)\", nbSeq);\n        /* Refuse to try and split anything with less than 4 sequences */\n        return 0;\n    }\n    ZSTD_deriveBlockSplitsHelper(&splits, 0, nbSeq, zc, &zc->seqStore);\n    splits.splitLocations[splits.idx] = nbSeq;\n    DEBUGLOG(5, \"ZSTD_deriveBlockSplits: final nb partitions: %zu\", splits.idx+1);\n    return splits.idx;\n}\n\n/* ZSTD_compressBlock_splitBlock():\n * Attempts to split a given block into multiple blocks to improve compression ratio.\n *\n * Returns combined size of all blocks (which includes headers), or a ZSTD error code.\n */\nstatic size_t\nZSTD_compressBlock_splitBlock_internal(ZSTD_CCtx* zc,\n                                    void* dst, size_t dstCapacity,\n                              const void* src, size_t blockSize,\n                                    U32 lastBlock, U32 nbSeq)\n{\n    size_t cSize = 0;\n    const BYTE* ip = (const BYTE*)src;\n    BYTE* op = (BYTE*)dst;\n    size_t i = 0;\n    size_t srcBytesTotal = 0;\n    U32* const partitions = zc->blockSplitCtx.partitions; /* size == ZSTD_MAX_NB_BLOCK_SPLITS */\n    SeqStore_t* const nextSeqStore = &zc->blockSplitCtx.nextSeqStore;\n    SeqStore_t* const currSeqStore = &zc->blockSplitCtx.currSeqStore;\n    size_t const numSplits = ZSTD_deriveBlockSplits(zc, partitions, nbSeq);\n\n    /* If a block is split and some partitions are emitted as RLE/uncompressed, then repcode history\n     * may become invalid. In order to reconcile potentially invalid repcodes, we keep track of two\n     * separate repcode histories that simulate repcode history on compression and decompression side,\n     * and use the histories to determine whether we must replace a particular repcode with its raw offset.\n     *\n     * 1) cRep gets updated for each partition, regardless of whether the block was emitted as uncompressed\n     *    or RLE. This allows us to retrieve the offset value that an invalid repcode references within\n     *    a nocompress/RLE block.\n     * 2) dRep gets updated only for compressed partitions, and when a repcode gets replaced, will use\n     *    the replacement offset value rather than the original repcode to update the repcode history.\n     *    dRep also will be the final repcode history sent to the next block.\n     *\n     * See ZSTD_seqStore_resolveOffCodes() for more details.\n     */\n    Repcodes_t dRep;\n    Repcodes_t cRep;\n    ZSTD_memcpy(dRep.rep, zc->blockState.prevCBlock->rep, sizeof(Repcodes_t));\n    ZSTD_memcpy(cRep.rep, zc->blockState.prevCBlock->rep, sizeof(Repcodes_t));\n    ZSTD_memset(nextSeqStore, 0, sizeof(SeqStore_t));\n\n    DEBUGLOG(5, \"ZSTD_compressBlock_splitBlock_internal (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u)\",\n                (unsigned)dstCapacity, (unsigned)zc->blockState.matchState.window.dictLimit,\n                (unsigned)zc->blockState.matchState.nextToUpdate);\n\n    if (numSplits == 0) {\n        size_t cSizeSingleBlock =\n            ZSTD_compressSeqStore_singleBlock(zc, &zc->seqStore,\n                                            &dRep, &cRep,\n                                            op, dstCapacity,\n                                            ip, blockSize,\n                                            lastBlock, 0 /* isPartition */);\n        FORWARD_IF_ERROR(cSizeSingleBlock, \"Compressing single block from splitBlock_internal() failed!\");\n        DEBUGLOG(5, \"ZSTD_compressBlock_splitBlock_internal: No splits\");\n        assert(zc->blockSizeMax <= ZSTD_BLOCKSIZE_MAX);\n        assert(cSizeSingleBlock <= zc->blockSizeMax + ZSTD_blockHeaderSize);\n        return cSizeSingleBlock;\n    }\n\n    ZSTD_deriveSeqStoreChunk(currSeqStore, &zc->seqStore, 0, partitions[0]);\n    for (i = 0; i <= numSplits; ++i) {\n        size_t cSizeChunk;\n        U32 const lastPartition = (i == numSplits);\n        U32 lastBlockEntireSrc = 0;\n\n        size_t srcBytes = ZSTD_countSeqStoreLiteralsBytes(currSeqStore) + ZSTD_countSeqStoreMatchBytes(currSeqStore);\n        srcBytesTotal += srcBytes;\n        if (lastPartition) {\n            /* This is the final partition, need to account for possible last literals */\n            srcBytes += blockSize - srcBytesTotal;\n            lastBlockEntireSrc = lastBlock;\n        } else {\n            ZSTD_deriveSeqStoreChunk(nextSeqStore, &zc->seqStore, partitions[i], partitions[i+1]);\n        }\n\n        cSizeChunk = ZSTD_compressSeqStore_singleBlock(zc, currSeqStore,\n                                                      &dRep, &cRep,\n                                                       op, dstCapacity,\n                                                       ip, srcBytes,\n                                                       lastBlockEntireSrc, 1 /* isPartition */);\n        DEBUGLOG(5, \"Estimated size: %zu vs %zu : actual size\",\n                    ZSTD_buildEntropyStatisticsAndEstimateSubBlockSize(currSeqStore, zc), cSizeChunk);\n        FORWARD_IF_ERROR(cSizeChunk, \"Compressing chunk failed!\");\n\n        ip += srcBytes;\n        op += cSizeChunk;\n        dstCapacity -= cSizeChunk;\n        cSize += cSizeChunk;\n        *currSeqStore = *nextSeqStore;\n        assert(cSizeChunk <= zc->blockSizeMax + ZSTD_blockHeaderSize);\n    }\n    /* cRep and dRep may have diverged during the compression.\n     * If so, we use the dRep repcodes for the next block.\n     */\n    ZSTD_memcpy(zc->blockState.prevCBlock->rep, dRep.rep, sizeof(Repcodes_t));\n    return cSize;\n}\n\nstatic size_t\nZSTD_compressBlock_splitBlock(ZSTD_CCtx* zc,\n                              void* dst, size_t dstCapacity,\n                              const void* src, size_t srcSize, U32 lastBlock)\n{\n    U32 nbSeq;\n    size_t cSize;\n    DEBUGLOG(5, \"ZSTD_compressBlock_splitBlock\");\n    assert(zc->appliedParams.postBlockSplitter == ZSTD_ps_enable);\n\n    {   const size_t bss = ZSTD_buildSeqStore(zc, src, srcSize);\n        FORWARD_IF_ERROR(bss, \"ZSTD_buildSeqStore failed\");\n        if (bss == ZSTDbss_noCompress) {\n            if (zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)\n                zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;\n            RETURN_ERROR_IF(zc->seqCollector.collectSequences, sequenceProducer_failed, \"Uncompressible block\");\n            cSize = ZSTD_noCompressBlock(dst, dstCapacity, src, srcSize, lastBlock);\n            FORWARD_IF_ERROR(cSize, \"ZSTD_noCompressBlock failed\");\n            DEBUGLOG(5, \"ZSTD_compressBlock_splitBlock: Nocompress block\");\n            return cSize;\n        }\n        nbSeq = (U32)(zc->seqStore.sequences - zc->seqStore.sequencesStart);\n    }\n\n    cSize = ZSTD_compressBlock_splitBlock_internal(zc, dst, dstCapacity, src, srcSize, lastBlock, nbSeq);\n    FORWARD_IF_ERROR(cSize, \"Splitting blocks failed!\");\n    return cSize;\n}\n\nstatic size_t\nZSTD_compressBlock_internal(ZSTD_CCtx* zc,\n                            void* dst, size_t dstCapacity,\n                            const void* src, size_t srcSize, U32 frame)\n{\n    /* This is an estimated upper bound for the length of an rle block.\n     * This isn't the actual upper bound.\n     * Finding the real threshold needs further investigation.\n     */\n    const U32 rleMaxLength = 25;\n    size_t cSize;\n    const BYTE* ip = (const BYTE*)src;\n    BYTE* op = (BYTE*)dst;\n    DEBUGLOG(5, \"ZSTD_compressBlock_internal (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u)\",\n                (unsigned)dstCapacity, (unsigned)zc->blockState.matchState.window.dictLimit,\n                (unsigned)zc->blockState.matchState.nextToUpdate);\n\n    {   const size_t bss = ZSTD_buildSeqStore(zc, src, srcSize);\n        FORWARD_IF_ERROR(bss, \"ZSTD_buildSeqStore failed\");\n        if (bss == ZSTDbss_noCompress) {\n            RETURN_ERROR_IF(zc->seqCollector.collectSequences, sequenceProducer_failed, \"Uncompressible block\");\n            cSize = 0;\n            goto out;\n        }\n    }\n\n    if (zc->seqCollector.collectSequences) {\n        FORWARD_IF_ERROR(ZSTD_copyBlockSequences(&zc->seqCollector, ZSTD_getSeqStore(zc), zc->blockState.prevCBlock->rep), \"copyBlockSequences failed\");\n        ZSTD_blockState_confirmRepcodesAndEntropyTables(&zc->blockState);\n        return 0;\n    }\n\n    /* encode sequences and literals */\n    cSize = ZSTD_entropyCompressSeqStore(&zc->seqStore,\n            &zc->blockState.prevCBlock->entropy, &zc->blockState.nextCBlock->entropy,\n            &zc->appliedParams,\n            dst, dstCapacity,\n            srcSize,\n            zc->tmpWorkspace, zc->tmpWkspSize /* statically allocated in resetCCtx */,\n            zc->bmi2);\n\n    if (frame &&\n        /* We don't want to emit our first block as a RLE even if it qualifies because\n         * doing so will cause the decoder (cli only) to throw a \"should consume all input error.\"\n         * This is only an issue for zstd <= v1.4.3\n         */\n        !zc->isFirstBlock &&\n        cSize < rleMaxLength &&\n        ZSTD_isRLE(ip, srcSize))\n    {\n        cSize = 1;\n        op[0] = ip[0];\n    }\n\nout:\n    if (!ZSTD_isError(cSize) && cSize > 1) {\n        ZSTD_blockState_confirmRepcodesAndEntropyTables(&zc->blockState);\n    }\n    /* We check that dictionaries have offset codes available for the first\n     * block. After the first block, the offcode table might not have large\n     * enough codes to represent the offsets in the data.\n     */\n    if (zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)\n        zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;\n\n    return cSize;\n}\n\nstatic size_t ZSTD_compressBlock_targetCBlockSize_body(ZSTD_CCtx* zc,\n                               void* dst, size_t dstCapacity,\n                               const void* src, size_t srcSize,\n                               const size_t bss, U32 lastBlock)\n{\n    DEBUGLOG(6, \"Attempting ZSTD_compressSuperBlock()\");\n    if (bss == ZSTDbss_compress) {\n        if (/* We don't want to emit our first block as a RLE even if it qualifies because\n            * doing so will cause the decoder (cli only) to throw a \"should consume all input error.\"\n            * This is only an issue for zstd <= v1.4.3\n            */\n            !zc->isFirstBlock &&\n            ZSTD_maybeRLE(&zc->seqStore) &&\n            ZSTD_isRLE((BYTE const*)src, srcSize))\n        {\n            return ZSTD_rleCompressBlock(dst, dstCapacity, *(BYTE const*)src, srcSize, lastBlock);\n        }\n        /* Attempt superblock compression.\n         *\n         * Note that compressed size of ZSTD_compressSuperBlock() is not bound by the\n         * standard ZSTD_compressBound(). This is a problem, because even if we have\n         * space now, taking an extra byte now could cause us to run out of space later\n         * and violate ZSTD_compressBound().\n         *\n         * Define blockBound(blockSize) = blockSize + ZSTD_blockHeaderSize.\n         *\n         * In order to respect ZSTD_compressBound() we must attempt to emit a raw\n         * uncompressed block in these cases:\n         *   * cSize == 0: Return code for an uncompressed block.\n         *   * cSize == dstSize_tooSmall: We may have expanded beyond blockBound(srcSize).\n         *     ZSTD_noCompressBlock() will return dstSize_tooSmall if we are really out of\n         *     output space.\n         *   * cSize >= blockBound(srcSize): We have expanded the block too much so\n         *     emit an uncompressed block.\n         */\n        {   size_t const cSize =\n                ZSTD_compressSuperBlock(zc, dst, dstCapacity, src, srcSize, lastBlock);\n            if (cSize != ERROR(dstSize_tooSmall)) {\n                size_t const maxCSize =\n                    srcSize - ZSTD_minGain(srcSize, zc->appliedParams.cParams.strategy);\n                FORWARD_IF_ERROR(cSize, \"ZSTD_compressSuperBlock failed\");\n                if (cSize != 0 && cSize < maxCSize + ZSTD_blockHeaderSize) {\n                    ZSTD_blockState_confirmRepcodesAndEntropyTables(&zc->blockState);\n                    return cSize;\n                }\n            }\n        }\n    } /* if (bss == ZSTDbss_compress)*/\n\n    DEBUGLOG(6, \"Resorting to ZSTD_noCompressBlock()\");\n    /* Superblock compression failed, attempt to emit a single no compress block.\n     * The decoder will be able to stream this block since it is uncompressed.\n     */\n    return ZSTD_noCompressBlock(dst, dstCapacity, src, srcSize, lastBlock);\n}\n\nstatic size_t ZSTD_compressBlock_targetCBlockSize(ZSTD_CCtx* zc,\n                               void* dst, size_t dstCapacity,\n                               const void* src, size_t srcSize,\n                               U32 lastBlock)\n{\n    size_t cSize = 0;\n    const size_t bss = ZSTD_buildSeqStore(zc, src, srcSize);\n    DEBUGLOG(5, \"ZSTD_compressBlock_targetCBlockSize (dstCapacity=%u, dictLimit=%u, nextToUpdate=%u, srcSize=%zu)\",\n                (unsigned)dstCapacity, (unsigned)zc->blockState.matchState.window.dictLimit, (unsigned)zc->blockState.matchState.nextToUpdate, srcSize);\n    FORWARD_IF_ERROR(bss, \"ZSTD_buildSeqStore failed\");\n\n    cSize = ZSTD_compressBlock_targetCBlockSize_body(zc, dst, dstCapacity, src, srcSize, bss, lastBlock);\n    FORWARD_IF_ERROR(cSize, \"ZSTD_compressBlock_targetCBlockSize_body failed\");\n\n    if (zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)\n        zc->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;\n\n    return cSize;\n}\n\nstatic void ZSTD_overflowCorrectIfNeeded(ZSTD_MatchState_t* ms,\n                                         ZSTD_cwksp* ws,\n                                         ZSTD_CCtx_params const* params,\n                                         void const* ip,\n                                         void const* iend)\n{\n    U32 const cycleLog = ZSTD_cycleLog(params->cParams.chainLog, params->cParams.strategy);\n    U32 const maxDist = (U32)1 << params->cParams.windowLog;\n    if (ZSTD_window_needOverflowCorrection(ms->window, cycleLog, maxDist, ms->loadedDictEnd, ip, iend)) {\n        U32 const correction = ZSTD_window_correctOverflow(&ms->window, cycleLog, maxDist, ip);\n        ZSTD_STATIC_ASSERT(ZSTD_CHAINLOG_MAX <= 30);\n        ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX_32 <= 30);\n        ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX <= 31);\n        ZSTD_cwksp_mark_tables_dirty(ws);\n        ZSTD_reduceIndex(ms, params, correction);\n        ZSTD_cwksp_mark_tables_clean(ws);\n        if (ms->nextToUpdate < correction) ms->nextToUpdate = 0;\n        else ms->nextToUpdate -= correction;\n        /* invalidate dictionaries on overflow correction */\n        ms->loadedDictEnd = 0;\n        ms->dictMatchState = NULL;\n    }\n}\n\n#include \"zstd_preSplit.h\"\n\nstatic size_t ZSTD_optimalBlockSize(ZSTD_CCtx* cctx, const void* src, size_t srcSize, size_t blockSizeMax, int splitLevel, ZSTD_strategy strat, S64 savings)\n{\n    /* split level based on compression strategy, from `fast` to `btultra2` */\n    static const int splitLevels[] = { 0, 0, 1, 2, 2, 3, 3, 4, 4, 4 };\n    /* note: conservatively only split full blocks (128 KB) currently.\n     * While it's possible to go lower, let's keep it simple for a first implementation.\n     * Besides, benefits of splitting are reduced when blocks are already small.\n     */\n    if (srcSize < 128 KB || blockSizeMax < 128 KB)\n        return MIN(srcSize, blockSizeMax);\n    /* do not split incompressible data though:\n     * require verified savings to allow pre-splitting.\n     * Note: as a consequence, the first full block is not split.\n     */\n    if (savings < 3) {\n        DEBUGLOG(6, \"don't attempt splitting: savings (%i) too low\", (int)savings);\n        return 128 KB;\n    }\n    /* apply @splitLevel, or use default value (which depends on @strat).\n     * note that splitting heuristic is still conditioned by @savings >= 3,\n     * so the first block will not reach this code path */\n    if (splitLevel == 1) return 128 KB;\n    if (splitLevel == 0) {\n        assert(ZSTD_fast <= strat && strat <= ZSTD_btultra2);\n        splitLevel = splitLevels[strat];\n    } else {\n        assert(2 <= splitLevel && splitLevel <= 6);\n        splitLevel -= 2;\n    }\n    return ZSTD_splitBlock(src, blockSizeMax, splitLevel, cctx->tmpWorkspace, cctx->tmpWkspSize);\n}\n\n/*! ZSTD_compress_frameChunk() :\n*   Compress a chunk of data into one or multiple blocks.\n*   All blocks will be terminated, all input will be consumed.\n*   Function will issue an error if there is not enough `dstCapacity` to hold the compressed content.\n*   Frame is supposed already started (header already produced)\n*  @return : compressed size, or an error code\n*/\nstatic size_t ZSTD_compress_frameChunk(ZSTD_CCtx* cctx,\n                                     void* dst, size_t dstCapacity,\n                               const void* src, size_t srcSize,\n                                     U32 lastFrameChunk)\n{\n    size_t blockSizeMax = cctx->blockSizeMax;\n    size_t remaining = srcSize;\n    const BYTE* ip = (const BYTE*)src;\n    BYTE* const ostart = (BYTE*)dst;\n    BYTE* op = ostart;\n    U32 const maxDist = (U32)1 << cctx->appliedParams.cParams.windowLog;\n    S64 savings = (S64)cctx->consumedSrcSize - (S64)cctx->producedCSize;\n\n    assert(cctx->appliedParams.cParams.windowLog <= ZSTD_WINDOWLOG_MAX);\n\n    DEBUGLOG(5, \"ZSTD_compress_frameChunk (srcSize=%u, blockSizeMax=%u)\", (unsigned)srcSize, (unsigned)blockSizeMax);\n    if (cctx->appliedParams.fParams.checksumFlag && srcSize)\n        XXH64_update(&cctx->xxhState, src, srcSize);\n\n    while (remaining) {\n        ZSTD_MatchState_t* const ms = &cctx->blockState.matchState;\n        size_t const blockSize = ZSTD_optimalBlockSize(cctx,\n                                ip, remaining,\n                                blockSizeMax,\n                                cctx->appliedParams.preBlockSplitter_level,\n                                cctx->appliedParams.cParams.strategy,\n                                savings);\n        U32 const lastBlock = lastFrameChunk & (blockSize == remaining);\n        assert(blockSize <= remaining);\n\n        /* TODO: See 3090. We reduced MIN_CBLOCK_SIZE from 3 to 2 so to compensate we are adding\n         * additional 1. We need to revisit and change this logic to be more consistent */\n        RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize + MIN_CBLOCK_SIZE + 1,\n                        dstSize_tooSmall,\n                        \"not enough space to store compressed block\");\n\n        ZSTD_overflowCorrectIfNeeded(\n            ms, &cctx->workspace, &cctx->appliedParams, ip, ip + blockSize);\n        ZSTD_checkDictValidity(&ms->window, ip + blockSize, maxDist, &ms->loadedDictEnd, &ms->dictMatchState);\n        ZSTD_window_enforceMaxDist(&ms->window, ip, maxDist, &ms->loadedDictEnd, &ms->dictMatchState);\n\n        /* Ensure hash/chain table insertion resumes no sooner than lowlimit */\n        if (ms->nextToUpdate < ms->window.lowLimit) ms->nextToUpdate = ms->window.lowLimit;\n\n        {   size_t cSize;\n            if (ZSTD_useTargetCBlockSize(&cctx->appliedParams)) {\n                cSize = ZSTD_compressBlock_targetCBlockSize(cctx, op, dstCapacity, ip, blockSize, lastBlock);\n                FORWARD_IF_ERROR(cSize, \"ZSTD_compressBlock_targetCBlockSize failed\");\n                assert(cSize > 0);\n                assert(cSize <= blockSize + ZSTD_blockHeaderSize);\n            } else if (ZSTD_blockSplitterEnabled(&cctx->appliedParams)) {\n                cSize = ZSTD_compressBlock_splitBlock(cctx, op, dstCapacity, ip, blockSize, lastBlock);\n                FORWARD_IF_ERROR(cSize, \"ZSTD_compressBlock_splitBlock failed\");\n                assert(cSize > 0 || cctx->seqCollector.collectSequences == 1);\n            } else {\n                cSize = ZSTD_compressBlock_internal(cctx,\n                                        op+ZSTD_blockHeaderSize, dstCapacity-ZSTD_blockHeaderSize,\n                                        ip, blockSize, 1 /* frame */);\n                FORWARD_IF_ERROR(cSize, \"ZSTD_compressBlock_internal failed\");\n\n                if (cSize == 0) {  /* block is not compressible */\n                    cSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock);\n                    FORWARD_IF_ERROR(cSize, \"ZSTD_noCompressBlock failed\");\n                } else {\n                    U32 const cBlockHeader = cSize == 1 ?\n                        lastBlock + (((U32)bt_rle)<<1) + (U32)(blockSize << 3) :\n                        lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);\n                    MEM_writeLE24(op, cBlockHeader);\n                    cSize += ZSTD_blockHeaderSize;\n                }\n            }  /* if (ZSTD_useTargetCBlockSize(&cctx->appliedParams))*/\n\n            /* @savings is employed to ensure that splitting doesn't worsen expansion of incompressible data.\n             * Without splitting, the maximum expansion is 3 bytes per full block.\n             * An adversarial input could attempt to fudge the split detector,\n             * and make it split incompressible data, resulting in more block headers.\n             * Note that, since ZSTD_COMPRESSBOUND() assumes a worst case scenario of 1KB per block,\n             * and the splitter never creates blocks that small (current lower limit is 8 KB),\n             * there is already no risk to expand beyond ZSTD_COMPRESSBOUND() limit.\n             * But if the goal is to not expand by more than 3-bytes per 128 KB full block,\n             * then yes, it becomes possible to make the block splitter oversplit incompressible data.\n             * Using @savings, we enforce an even more conservative condition,\n             * requiring the presence of enough savings (at least 3 bytes) to authorize splitting,\n             * otherwise only full blocks are used.\n             * But being conservative is fine,\n             * since splitting barely compressible blocks is not fruitful anyway */\n            savings += (S64)blockSize - (S64)cSize;\n\n            ip += blockSize;\n            assert(remaining >= blockSize);\n            remaining -= blockSize;\n            op += cSize;\n            assert(dstCapacity >= cSize);\n            dstCapacity -= cSize;\n            cctx->isFirstBlock = 0;\n            DEBUGLOG(5, \"ZSTD_compress_frameChunk: adding a block of size %u\",\n                        (unsigned)cSize);\n    }   }\n\n    if (lastFrameChunk && (op>ostart)) cctx->stage = ZSTDcs_ending;\n    return (size_t)(op-ostart);\n}\n\n\nstatic size_t ZSTD_writeFrameHeader(void* dst, size_t dstCapacity,\n                                    const ZSTD_CCtx_params* params,\n                                    U64 pledgedSrcSize, U32 dictID)\n{\n    BYTE* const op = (BYTE*)dst;\n    U32   const dictIDSizeCodeLength = (dictID>0) + (dictID>=256) + (dictID>=65536);   /* 0-3 */\n    U32   const dictIDSizeCode = params->fParams.noDictIDFlag ? 0 : dictIDSizeCodeLength;   /* 0-3 */\n    U32   const checksumFlag = params->fParams.checksumFlag>0;\n    U32   const windowSize = (U32)1 << params->cParams.windowLog;\n    U32   const singleSegment = params->fParams.contentSizeFlag && (windowSize >= pledgedSrcSize);\n    BYTE  const windowLogByte = (BYTE)((params->cParams.windowLog - ZSTD_WINDOWLOG_ABSOLUTEMIN) << 3);\n    U32   const fcsCode = params->fParams.contentSizeFlag ?\n                     (pledgedSrcSize>=256) + (pledgedSrcSize>=65536+256) + (pledgedSrcSize>=0xFFFFFFFFU) : 0;  /* 0-3 */\n    BYTE  const frameHeaderDescriptionByte = (BYTE)(dictIDSizeCode + (checksumFlag<<2) + (singleSegment<<5) + (fcsCode<<6) );\n    size_t pos=0;\n\n    assert(!(params->fParams.contentSizeFlag && pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN));\n    RETURN_ERROR_IF(dstCapacity < ZSTD_FRAMEHEADERSIZE_MAX, dstSize_tooSmall,\n                    \"dst buf is too small to fit worst-case frame header size.\");\n    DEBUGLOG(4, \"ZSTD_writeFrameHeader : dictIDFlag : %u ; dictID : %u ; dictIDSizeCode : %u\",\n                !params->fParams.noDictIDFlag, (unsigned)dictID, (unsigned)dictIDSizeCode);\n    if (params->format == ZSTD_f_zstd1) {\n        MEM_writeLE32(dst, ZSTD_MAGICNUMBER);\n        pos = 4;\n    }\n    op[pos++] = frameHeaderDescriptionByte;\n    if (!singleSegment) op[pos++] = windowLogByte;\n    switch(dictIDSizeCode)\n    {\n        default:\n            assert(0); /* impossible */\n            ZSTD_FALLTHROUGH;\n        case 0 : break;\n        case 1 : op[pos] = (BYTE)(dictID); pos++; break;\n        case 2 : MEM_writeLE16(op+pos, (U16)dictID); pos+=2; break;\n        case 3 : MEM_writeLE32(op+pos, dictID); pos+=4; break;\n    }\n    switch(fcsCode)\n    {\n        default:\n            assert(0); /* impossible */\n            ZSTD_FALLTHROUGH;\n        case 0 : if (singleSegment) op[pos++] = (BYTE)(pledgedSrcSize); break;\n        case 1 : MEM_writeLE16(op+pos, (U16)(pledgedSrcSize-256)); pos+=2; break;\n        case 2 : MEM_writeLE32(op+pos, (U32)(pledgedSrcSize)); pos+=4; break;\n        case 3 : MEM_writeLE64(op+pos, (U64)(pledgedSrcSize)); pos+=8; break;\n    }\n    return pos;\n}\n\n/* ZSTD_writeSkippableFrame_advanced() :\n * Writes out a skippable frame with the specified magic number variant (16 are supported),\n * from ZSTD_MAGIC_SKIPPABLE_START to ZSTD_MAGIC_SKIPPABLE_START+15, and the desired source data.\n *\n * Returns the total number of bytes written, or a ZSTD error code.\n */\nsize_t ZSTD_writeSkippableFrame(void* dst, size_t dstCapacity,\n                                const void* src, size_t srcSize, unsigned magicVariant) {\n    BYTE* op = (BYTE*)dst;\n    RETURN_ERROR_IF(dstCapacity < srcSize + ZSTD_SKIPPABLEHEADERSIZE /* Skippable frame overhead */,\n                    dstSize_tooSmall, \"Not enough room for skippable frame\");\n    RETURN_ERROR_IF(srcSize > (unsigned)0xFFFFFFFF, srcSize_wrong, \"Src size too large for skippable frame\");\n    RETURN_ERROR_IF(magicVariant > 15, parameter_outOfBound, \"Skippable frame magic number variant not supported\");\n\n    MEM_writeLE32(op, (U32)(ZSTD_MAGIC_SKIPPABLE_START + magicVariant));\n    MEM_writeLE32(op+4, (U32)srcSize);\n    ZSTD_memcpy(op+8, src, srcSize);\n    return srcSize + ZSTD_SKIPPABLEHEADERSIZE;\n}\n\n/* ZSTD_writeLastEmptyBlock() :\n * output an empty Block with end-of-frame mark to complete a frame\n * @return : size of data written into `dst` (== ZSTD_blockHeaderSize (defined in zstd_internal.h))\n *           or an error code if `dstCapacity` is too small (stage == ZSTDcs_init);\n    assert(nbSeq == 0 || cctx->appliedParams.ldmParams.enableLdm != ZSTD_ps_enable);\n    cctx->externSeqStore.seq = seq;\n    cctx->externSeqStore.size = nbSeq;\n    cctx->externSeqStore.capacity = nbSeq;\n    cctx->externSeqStore.pos = 0;\n    cctx->externSeqStore.posInSequence = 0;\n}\n\n\nstatic size_t ZSTD_compressContinue_internal (ZSTD_CCtx* cctx,\n                              void* dst, size_t dstCapacity,\n                        const void* src, size_t srcSize,\n                               U32 frame, U32 lastFrameChunk)\n{\n    ZSTD_MatchState_t* const ms = &cctx->blockState.matchState;\n    size_t fhSize = 0;\n\n    DEBUGLOG(5, \"ZSTD_compressContinue_internal, stage: %u, srcSize: %u\",\n                cctx->stage, (unsigned)srcSize);\n    RETURN_ERROR_IF(cctx->stage==ZSTDcs_created, stage_wrong,\n                    \"missing init (ZSTD_compressBegin)\");\n\n    if (frame && (cctx->stage==ZSTDcs_init)) {\n        fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, &cctx->appliedParams,\n                                       cctx->pledgedSrcSizePlusOne-1, cctx->dictID);\n        FORWARD_IF_ERROR(fhSize, \"ZSTD_writeFrameHeader failed\");\n        assert(fhSize <= dstCapacity);\n        dstCapacity -= fhSize;\n        dst = (char*)dst + fhSize;\n        cctx->stage = ZSTDcs_ongoing;\n    }\n\n    if (!srcSize) return fhSize;  /* do not generate an empty block if no input */\n\n    if (!ZSTD_window_update(&ms->window, src, srcSize, ms->forceNonContiguous)) {\n        ms->forceNonContiguous = 0;\n        ms->nextToUpdate = ms->window.dictLimit;\n    }\n    if (cctx->appliedParams.ldmParams.enableLdm == ZSTD_ps_enable) {\n        ZSTD_window_update(&cctx->ldmState.window, src, srcSize, /* forceNonContiguous */ 0);\n    }\n\n    if (!frame) {\n        /* overflow check and correction for block mode */\n        ZSTD_overflowCorrectIfNeeded(\n            ms, &cctx->workspace, &cctx->appliedParams,\n            src, (BYTE const*)src + srcSize);\n    }\n\n    DEBUGLOG(5, \"ZSTD_compressContinue_internal (blockSize=%u)\", (unsigned)cctx->blockSizeMax);\n    {   size_t const cSize = frame ?\n                             ZSTD_compress_frameChunk (cctx, dst, dstCapacity, src, srcSize, lastFrameChunk) :\n                             ZSTD_compressBlock_internal (cctx, dst, dstCapacity, src, srcSize, 0 /* frame */);\n        FORWARD_IF_ERROR(cSize, \"%s\", frame ? \"ZSTD_compress_frameChunk failed\" : \"ZSTD_compressBlock_internal failed\");\n        cctx->consumedSrcSize += srcSize;\n        cctx->producedCSize += (cSize + fhSize);\n        assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0));\n        if (cctx->pledgedSrcSizePlusOne != 0) {  /* control src size */\n            ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1);\n            RETURN_ERROR_IF(\n                cctx->consumedSrcSize+1 > cctx->pledgedSrcSizePlusOne,\n                srcSize_wrong,\n                \"error : pledgedSrcSize = %u, while realSrcSize >= %u\",\n                (unsigned)cctx->pledgedSrcSizePlusOne-1,\n                (unsigned)cctx->consumedSrcSize);\n        }\n        return cSize + fhSize;\n    }\n}\n\nsize_t ZSTD_compressContinue_public(ZSTD_CCtx* cctx,\n                                        void* dst, size_t dstCapacity,\n                                  const void* src, size_t srcSize)\n{\n    DEBUGLOG(5, \"ZSTD_compressContinue (srcSize=%u)\", (unsigned)srcSize);\n    return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1 /* frame mode */, 0 /* last chunk */);\n}\n\n/* NOTE: Must just wrap ZSTD_compressContinue_public() */\nsize_t ZSTD_compressContinue(ZSTD_CCtx* cctx,\n                             void* dst, size_t dstCapacity,\n                       const void* src, size_t srcSize)\n{\n    return ZSTD_compressContinue_public(cctx, dst, dstCapacity, src, srcSize);\n}\n\nstatic size_t ZSTD_getBlockSize_deprecated(const ZSTD_CCtx* cctx)\n{\n    ZSTD_compressionParameters const cParams = cctx->appliedParams.cParams;\n    assert(!ZSTD_checkCParams(cParams));\n    return MIN(cctx->appliedParams.maxBlockSize, (size_t)1 << cParams.windowLog);\n}\n\n/* NOTE: Must just wrap ZSTD_getBlockSize_deprecated() */\nsize_t ZSTD_getBlockSize(const ZSTD_CCtx* cctx)\n{\n    return ZSTD_getBlockSize_deprecated(cctx);\n}\n\n/* NOTE: Must just wrap ZSTD_compressBlock_deprecated() */\nsize_t ZSTD_compressBlock_deprecated(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)\n{\n    DEBUGLOG(5, \"ZSTD_compressBlock: srcSize = %u\", (unsigned)srcSize);\n    { size_t const blockSizeMax = ZSTD_getBlockSize_deprecated(cctx);\n      RETURN_ERROR_IF(srcSize > blockSizeMax, srcSize_wrong, \"input is larger than a block\"); }\n\n    return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 0 /* frame mode */, 0 /* last chunk */);\n}\n\n/* NOTE: Must just wrap ZSTD_compressBlock_deprecated() */\nsize_t ZSTD_compressBlock(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_deprecated(cctx, dst, dstCapacity, src, srcSize);\n}\n\n/*! ZSTD_loadDictionaryContent() :\n *  @return : 0, or an error code\n */\nstatic size_t\nZSTD_loadDictionaryContent(ZSTD_MatchState_t* ms,\n                        ldmState_t* ls,\n                        ZSTD_cwksp* ws,\n                        ZSTD_CCtx_params const* params,\n                        const void* src, size_t srcSize,\n                        ZSTD_dictTableLoadMethod_e dtlm,\n                        ZSTD_tableFillPurpose_e tfp)\n{\n    const BYTE* ip = (const BYTE*) src;\n    const BYTE* const iend = ip + srcSize;\n    int const loadLdmDict = params->ldmParams.enableLdm == ZSTD_ps_enable && ls != NULL;\n\n    /* Assert that the ms params match the params we're being given */\n    ZSTD_assertEqualCParams(params->cParams, ms->cParams);\n\n    {   /* Ensure large dictionaries can't cause index overflow */\n\n        /* Allow the dictionary to set indices up to exactly ZSTD_CURRENT_MAX.\n         * Dictionaries right at the edge will immediately trigger overflow\n         * correction, but I don't want to insert extra constraints here.\n         */\n        U32 maxDictSize = ZSTD_CURRENT_MAX - ZSTD_WINDOW_START_INDEX;\n\n        int const CDictTaggedIndices = ZSTD_CDictIndicesAreTagged(¶ms->cParams);\n        if (CDictTaggedIndices && tfp == ZSTD_tfp_forCDict) {\n            /* Some dictionary matchfinders in zstd use \"short cache\",\n             * which treats the lower ZSTD_SHORT_CACHE_TAG_BITS of each\n             * CDict hashtable entry as a tag rather than as part of an index.\n             * When short cache is used, we need to truncate the dictionary\n             * so that its indices don't overlap with the tag. */\n            U32 const shortCacheMaxDictSize = (1u << (32 - ZSTD_SHORT_CACHE_TAG_BITS)) - ZSTD_WINDOW_START_INDEX;\n            maxDictSize = MIN(maxDictSize, shortCacheMaxDictSize);\n            assert(!loadLdmDict);\n        }\n\n        /* If the dictionary is too large, only load the suffix of the dictionary. */\n        if (srcSize > maxDictSize) {\n            ip = iend - maxDictSize;\n            src = ip;\n            srcSize = maxDictSize;\n        }\n    }\n\n    if (srcSize > ZSTD_CHUNKSIZE_MAX) {\n        /* We must have cleared our windows when our source is this large. */\n        assert(ZSTD_window_isEmpty(ms->window));\n        if (loadLdmDict) assert(ZSTD_window_isEmpty(ls->window));\n    }\n    ZSTD_window_update(&ms->window, src, srcSize, /* forceNonContiguous */ 0);\n\n    DEBUGLOG(4, \"ZSTD_loadDictionaryContent: useRowMatchFinder=%d\", (int)params->useRowMatchFinder);\n\n    if (loadLdmDict) { /* Load the entire dict into LDM matchfinders. */\n        DEBUGLOG(4, \"ZSTD_loadDictionaryContent: Trigger loadLdmDict\");\n        ZSTD_window_update(&ls->window, src, srcSize, /* forceNonContiguous */ 0);\n        ls->loadedDictEnd = params->forceWindow ? 0 : (U32)(iend - ls->window.base);\n        ZSTD_ldm_fillHashTable(ls, ip, iend, ¶ms->ldmParams);\n        DEBUGLOG(4, \"ZSTD_loadDictionaryContent: ZSTD_ldm_fillHashTable completes\");\n    }\n\n    /* If the dict is larger than we can reasonably index in our tables, only load the suffix. */\n    {   U32 maxDictSize = 1U << MIN(MAX(params->cParams.hashLog + 3, params->cParams.chainLog + 1), 31);\n        if (srcSize > maxDictSize) {\n            ip = iend - maxDictSize;\n            src = ip;\n            srcSize = maxDictSize;\n        }\n    }\n\n    ms->nextToUpdate = (U32)(ip - ms->window.base);\n    ms->loadedDictEnd = params->forceWindow ? 0 : (U32)(iend - ms->window.base);\n    ms->forceNonContiguous = params->deterministicRefPrefix;\n\n    if (srcSize <= HASH_READ_SIZE) return 0;\n\n    ZSTD_overflowCorrectIfNeeded(ms, ws, params, ip, iend);\n\n    switch(params->cParams.strategy)\n    {\n    case ZSTD_fast:\n        ZSTD_fillHashTable(ms, iend, dtlm, tfp);\n        break;\n    case ZSTD_dfast:\n#ifndef ZSTD_EXCLUDE_DFAST_BLOCK_COMPRESSOR\n        ZSTD_fillDoubleHashTable(ms, iend, dtlm, tfp);\n#else\n        assert(0); /* shouldn't be called: cparams should've been adjusted. */\n#endif\n        break;\n\n    case ZSTD_greedy:\n    case ZSTD_lazy:\n    case ZSTD_lazy2:\n#if !defined(ZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR) \\\n || !defined(ZSTD_EXCLUDE_LAZY_BLOCK_COMPRESSOR) \\\n || !defined(ZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR)\n        assert(srcSize >= HASH_READ_SIZE);\n        if (ms->dedicatedDictSearch) {\n            assert(ms->chainTable != NULL);\n            ZSTD_dedicatedDictSearch_lazy_loadDictionary(ms, iend-HASH_READ_SIZE);\n        } else {\n            assert(params->useRowMatchFinder != ZSTD_ps_auto);\n            if (params->useRowMatchFinder == ZSTD_ps_enable) {\n                size_t const tagTableSize = ((size_t)1 << params->cParams.hashLog);\n                ZSTD_memset(ms->tagTable, 0, tagTableSize);\n                ZSTD_row_update(ms, iend-HASH_READ_SIZE);\n                DEBUGLOG(4, \"Using row-based hash table for lazy dict\");\n            } else {\n                ZSTD_insertAndFindFirstIndex(ms, iend-HASH_READ_SIZE);\n                DEBUGLOG(4, \"Using chain-based hash table for lazy dict\");\n            }\n        }\n#else\n        assert(0); /* shouldn't be called: cparams should've been adjusted. */\n#endif\n        break;\n\n    case ZSTD_btlazy2:   /* we want the dictionary table fully sorted */\n    case ZSTD_btopt:\n    case ZSTD_btultra:\n    case ZSTD_btultra2:\n#if !defined(ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR) \\\n || !defined(ZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR) \\\n || !defined(ZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR)\n        assert(srcSize >= HASH_READ_SIZE);\n        DEBUGLOG(4, \"Fill %u bytes into the Binary Tree\", (unsigned)srcSize);\n        ZSTD_updateTree(ms, iend-HASH_READ_SIZE, iend);\n#else\n        assert(0); /* shouldn't be called: cparams should've been adjusted. */\n#endif\n        break;\n\n    default:\n        assert(0);  /* not possible : not a valid strategy id */\n    }\n\n    ms->nextToUpdate = (U32)(iend - ms->window.base);\n    return 0;\n}\n\n\n/* Dictionaries that assign zero probability to symbols that show up causes problems\n * when FSE encoding. Mark dictionaries with zero probability symbols as FSE_repeat_check\n * and only dictionaries with 100% valid symbols can be assumed valid.\n */\nstatic FSE_repeat ZSTD_dictNCountRepeat(short* normalizedCounter, unsigned dictMaxSymbolValue, unsigned maxSymbolValue)\n{\n    U32 s;\n    if (dictMaxSymbolValue < maxSymbolValue) {\n        return FSE_repeat_check;\n    }\n    for (s = 0; s <= maxSymbolValue; ++s) {\n        if (normalizedCounter[s] == 0) {\n            return FSE_repeat_check;\n        }\n    }\n    return FSE_repeat_valid;\n}\n\nsize_t ZSTD_loadCEntropy(ZSTD_compressedBlockState_t* bs, void* workspace,\n                         const void* const dict, size_t dictSize)\n{\n    short offcodeNCount[MaxOff+1];\n    unsigned offcodeMaxValue = MaxOff;\n    const BYTE* dictPtr = (const BYTE*)dict;    /* skip magic num and dict ID */\n    const BYTE* const dictEnd = dictPtr + dictSize;\n    dictPtr += 8;\n    bs->entropy.huf.repeatMode = HUF_repeat_check;\n\n    {   unsigned maxSymbolValue = 255;\n        unsigned hasZeroWeights = 1;\n        size_t const hufHeaderSize = HUF_readCTable((HUF_CElt*)bs->entropy.huf.CTable, &maxSymbolValue, dictPtr,\n            (size_t)(dictEnd-dictPtr), &hasZeroWeights);\n\n        /* We only set the loaded table as valid if it contains all non-zero\n         * weights. Otherwise, we set it to check */\n        if (!hasZeroWeights && maxSymbolValue == 255)\n            bs->entropy.huf.repeatMode = HUF_repeat_valid;\n\n        RETURN_ERROR_IF(HUF_isError(hufHeaderSize), dictionary_corrupted, \"\");\n        dictPtr += hufHeaderSize;\n    }\n\n    {   unsigned offcodeLog;\n        size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, (size_t)(dictEnd-dictPtr));\n        RETURN_ERROR_IF(FSE_isError(offcodeHeaderSize), dictionary_corrupted, \"\");\n        RETURN_ERROR_IF(offcodeLog > OffFSELog, dictionary_corrupted, \"\");\n        /* fill all offset symbols to avoid garbage at end of table */\n        RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(\n                bs->entropy.fse.offcodeCTable,\n                offcodeNCount, MaxOff, offcodeLog,\n                workspace, HUF_WORKSPACE_SIZE)),\n            dictionary_corrupted, \"\");\n        /* Defer checking offcodeMaxValue because we need to know the size of the dictionary content */\n        dictPtr += offcodeHeaderSize;\n    }\n\n    {   short matchlengthNCount[MaxML+1];\n        unsigned matchlengthMaxValue = MaxML, matchlengthLog;\n        size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, (size_t)(dictEnd-dictPtr));\n        RETURN_ERROR_IF(FSE_isError(matchlengthHeaderSize), dictionary_corrupted, \"\");\n        RETURN_ERROR_IF(matchlengthLog > MLFSELog, dictionary_corrupted, \"\");\n        RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(\n                bs->entropy.fse.matchlengthCTable,\n                matchlengthNCount, matchlengthMaxValue, matchlengthLog,\n                workspace, HUF_WORKSPACE_SIZE)),\n            dictionary_corrupted, \"\");\n        bs->entropy.fse.matchlength_repeatMode = ZSTD_dictNCountRepeat(matchlengthNCount, matchlengthMaxValue, MaxML);\n        dictPtr += matchlengthHeaderSize;\n    }\n\n    {   short litlengthNCount[MaxLL+1];\n        unsigned litlengthMaxValue = MaxLL, litlengthLog;\n        size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, (size_t)(dictEnd-dictPtr));\n        RETURN_ERROR_IF(FSE_isError(litlengthHeaderSize), dictionary_corrupted, \"\");\n        RETURN_ERROR_IF(litlengthLog > LLFSELog, dictionary_corrupted, \"\");\n        RETURN_ERROR_IF(FSE_isError(FSE_buildCTable_wksp(\n                bs->entropy.fse.litlengthCTable,\n                litlengthNCount, litlengthMaxValue, litlengthLog,\n                workspace, HUF_WORKSPACE_SIZE)),\n            dictionary_corrupted, \"\");\n        bs->entropy.fse.litlength_repeatMode = ZSTD_dictNCountRepeat(litlengthNCount, litlengthMaxValue, MaxLL);\n        dictPtr += litlengthHeaderSize;\n    }\n\n    RETURN_ERROR_IF(dictPtr+12 > dictEnd, dictionary_corrupted, \"\");\n    bs->rep[0] = MEM_readLE32(dictPtr+0);\n    bs->rep[1] = MEM_readLE32(dictPtr+4);\n    bs->rep[2] = MEM_readLE32(dictPtr+8);\n    dictPtr += 12;\n\n    {   size_t const dictContentSize = (size_t)(dictEnd - dictPtr);\n        U32 offcodeMax = MaxOff;\n        if (dictContentSize <= ((U32)-1) - 128 KB) {\n            U32 const maxOffset = (U32)dictContentSize + 128 KB; /* The maximum offset that must be supported */\n            offcodeMax = ZSTD_highbit32(maxOffset); /* Calculate minimum offset code required to represent maxOffset */\n        }\n        /* All offset values <= dictContentSize + 128 KB must be representable for a valid table */\n        bs->entropy.fse.offcode_repeatMode = ZSTD_dictNCountRepeat(offcodeNCount, offcodeMaxValue, MIN(offcodeMax, MaxOff));\n\n        /* All repCodes must be <= dictContentSize and != 0 */\n        {   U32 u;\n            for (u=0; u<3; u++) {\n                RETURN_ERROR_IF(bs->rep[u] == 0, dictionary_corrupted, \"\");\n                RETURN_ERROR_IF(bs->rep[u] > dictContentSize, dictionary_corrupted, \"\");\n    }   }   }\n\n    return (size_t)(dictPtr - (const BYTE*)dict);\n}\n\n/* Dictionary format :\n * See :\n * https://github.com/facebook/zstd/blob/release/doc/zstd_compression_format.md#dictionary-format\n */\n/*! ZSTD_loadZstdDictionary() :\n * @return : dictID, or an error code\n *  assumptions : magic number supposed already checked\n *                dictSize supposed >= 8\n */\nstatic size_t ZSTD_loadZstdDictionary(ZSTD_compressedBlockState_t* bs,\n                                      ZSTD_MatchState_t* ms,\n                                      ZSTD_cwksp* ws,\n                                      ZSTD_CCtx_params const* params,\n                                      const void* dict, size_t dictSize,\n                                      ZSTD_dictTableLoadMethod_e dtlm,\n                                      ZSTD_tableFillPurpose_e tfp,\n                                      void* workspace)\n{\n    const BYTE* dictPtr = (const BYTE*)dict;\n    const BYTE* const dictEnd = dictPtr + dictSize;\n    size_t dictID;\n    size_t eSize;\n    ZSTD_STATIC_ASSERT(HUF_WORKSPACE_SIZE >= (1<= 8);\n    assert(MEM_readLE32(dictPtr) == ZSTD_MAGIC_DICTIONARY);\n\n    dictID = params->fParams.noDictIDFlag ? 0 :  MEM_readLE32(dictPtr + 4 /* skip magic number */ );\n    eSize = ZSTD_loadCEntropy(bs, workspace, dict, dictSize);\n    FORWARD_IF_ERROR(eSize, \"ZSTD_loadCEntropy failed\");\n    dictPtr += eSize;\n\n    {\n        size_t const dictContentSize = (size_t)(dictEnd - dictPtr);\n        FORWARD_IF_ERROR(ZSTD_loadDictionaryContent(\n            ms, NULL, ws, params, dictPtr, dictContentSize, dtlm, tfp), \"\");\n    }\n    return dictID;\n}\n\n/** ZSTD_compress_insertDictionary() :\n*   @return : dictID, or an error code */\nstatic size_t\nZSTD_compress_insertDictionary(ZSTD_compressedBlockState_t* bs,\n                               ZSTD_MatchState_t* ms,\n                               ldmState_t* ls,\n                               ZSTD_cwksp* ws,\n                         const ZSTD_CCtx_params* params,\n                         const void* dict, size_t dictSize,\n                               ZSTD_dictContentType_e dictContentType,\n                               ZSTD_dictTableLoadMethod_e dtlm,\n                               ZSTD_tableFillPurpose_e tfp,\n                               void* workspace)\n{\n    DEBUGLOG(4, \"ZSTD_compress_insertDictionary (dictSize=%u)\", (U32)dictSize);\n    if ((dict==NULL) || (dictSize<8)) {\n        RETURN_ERROR_IF(dictContentType == ZSTD_dct_fullDict, dictionary_wrong, \"\");\n        return 0;\n    }\n\n    ZSTD_reset_compressedBlockState(bs);\n\n    /* dict restricted modes */\n    if (dictContentType == ZSTD_dct_rawContent)\n        return ZSTD_loadDictionaryContent(ms, ls, ws, params, dict, dictSize, dtlm, tfp);\n\n    if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) {\n        if (dictContentType == ZSTD_dct_auto) {\n            DEBUGLOG(4, \"raw content dictionary detected\");\n            return ZSTD_loadDictionaryContent(\n                ms, ls, ws, params, dict, dictSize, dtlm, tfp);\n        }\n        RETURN_ERROR_IF(dictContentType == ZSTD_dct_fullDict, dictionary_wrong, \"\");\n        assert(0);   /* impossible */\n    }\n\n    /* dict as full zstd dictionary */\n    return ZSTD_loadZstdDictionary(\n        bs, ms, ws, params, dict, dictSize, dtlm, tfp, workspace);\n}\n\n#define ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF (128 KB)\n#define ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER (6ULL)\n\n/*! ZSTD_compressBegin_internal() :\n * Assumption : either @dict OR @cdict (or none) is non-NULL, never both\n * @return : 0, or an error code */\nstatic size_t ZSTD_compressBegin_internal(ZSTD_CCtx* cctx,\n                                    const void* dict, size_t dictSize,\n                                    ZSTD_dictContentType_e dictContentType,\n                                    ZSTD_dictTableLoadMethod_e dtlm,\n                                    const ZSTD_CDict* cdict,\n                                    const ZSTD_CCtx_params* params, U64 pledgedSrcSize,\n                                    ZSTD_buffered_policy_e zbuff)\n{\n    size_t const dictContentSize = cdict ? cdict->dictContentSize : dictSize;\n#if ZSTD_TRACE\n    cctx->traceCtx = (ZSTD_trace_compress_begin != NULL) ? ZSTD_trace_compress_begin(cctx) : 0;\n#endif\n    DEBUGLOG(4, \"ZSTD_compressBegin_internal: wlog=%u\", params->cParams.windowLog);\n    /* params are supposed to be fully validated at this point */\n    assert(!ZSTD_isError(ZSTD_checkCParams(params->cParams)));\n    assert(!((dict) && (cdict)));  /* either dict or cdict, not both */\n    if ( (cdict)\n      && (cdict->dictContentSize > 0)\n      && ( pledgedSrcSize < ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF\n        || pledgedSrcSize < cdict->dictContentSize * ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER\n        || pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN\n        || cdict->compressionLevel == 0)\n      && (params->attachDictPref != ZSTD_dictForceLoad) ) {\n        return ZSTD_resetCCtx_usingCDict(cctx, cdict, params, pledgedSrcSize, zbuff);\n    }\n\n    FORWARD_IF_ERROR( ZSTD_resetCCtx_internal(cctx, params, pledgedSrcSize,\n                                     dictContentSize,\n                                     ZSTDcrp_makeClean, zbuff) , \"\");\n    {   size_t const dictID = cdict ?\n                ZSTD_compress_insertDictionary(\n                        cctx->blockState.prevCBlock, &cctx->blockState.matchState,\n                        &cctx->ldmState, &cctx->workspace, &cctx->appliedParams, cdict->dictContent,\n                        cdict->dictContentSize, cdict->dictContentType, dtlm,\n                        ZSTD_tfp_forCCtx, cctx->tmpWorkspace)\n              : ZSTD_compress_insertDictionary(\n                        cctx->blockState.prevCBlock, &cctx->blockState.matchState,\n                        &cctx->ldmState, &cctx->workspace, &cctx->appliedParams, dict, dictSize,\n                        dictContentType, dtlm, ZSTD_tfp_forCCtx, cctx->tmpWorkspace);\n        FORWARD_IF_ERROR(dictID, \"ZSTD_compress_insertDictionary failed\");\n        assert(dictID <= UINT_MAX);\n        cctx->dictID = (U32)dictID;\n        cctx->dictContentSize = dictContentSize;\n    }\n    return 0;\n}\n\nsize_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,\n                                    const void* dict, size_t dictSize,\n                                    ZSTD_dictContentType_e dictContentType,\n                                    ZSTD_dictTableLoadMethod_e dtlm,\n                                    const ZSTD_CDict* cdict,\n                                    const ZSTD_CCtx_params* params,\n                                    unsigned long long pledgedSrcSize)\n{\n    DEBUGLOG(4, \"ZSTD_compressBegin_advanced_internal: wlog=%u\", params->cParams.windowLog);\n    /* compression parameters verification and optimization */\n    FORWARD_IF_ERROR( ZSTD_checkCParams(params->cParams) , \"\");\n    return ZSTD_compressBegin_internal(cctx,\n                                       dict, dictSize, dictContentType, dtlm,\n                                       cdict,\n                                       params, pledgedSrcSize,\n                                       ZSTDb_not_buffered);\n}\n\n/*! ZSTD_compressBegin_advanced() :\n*   @return : 0, or an error code */\nsize_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx,\n                             const void* dict, size_t dictSize,\n                                   ZSTD_parameters params, unsigned long long pledgedSrcSize)\n{\n    ZSTD_CCtx_params cctxParams;\n    ZSTD_CCtxParams_init_internal(&cctxParams, ¶ms, ZSTD_NO_CLEVEL);\n    return ZSTD_compressBegin_advanced_internal(cctx,\n                                            dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast,\n                                            NULL /*cdict*/,\n                                            &cctxParams, pledgedSrcSize);\n}\n\nstatic size_t\nZSTD_compressBegin_usingDict_deprecated(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel)\n{\n    ZSTD_CCtx_params cctxParams;\n    {   ZSTD_parameters const params = ZSTD_getParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_noAttachDict);\n        ZSTD_CCtxParams_init_internal(&cctxParams, ¶ms, (compressionLevel == 0) ? ZSTD_CLEVEL_DEFAULT : compressionLevel);\n    }\n    DEBUGLOG(4, \"ZSTD_compressBegin_usingDict (dictSize=%u)\", (unsigned)dictSize);\n    return ZSTD_compressBegin_internal(cctx, dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,\n                                       &cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, ZSTDb_not_buffered);\n}\n\nsize_t\nZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel)\n{\n    return ZSTD_compressBegin_usingDict_deprecated(cctx, dict, dictSize, compressionLevel);\n}\n\nsize_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel)\n{\n    return ZSTD_compressBegin_usingDict_deprecated(cctx, NULL, 0, compressionLevel);\n}\n\n\n/*! ZSTD_writeEpilogue() :\n*   Ends a frame.\n*   @return : nb of bytes written into dst (or an error code) */\nstatic size_t ZSTD_writeEpilogue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity)\n{\n    BYTE* const ostart = (BYTE*)dst;\n    BYTE* op = ostart;\n\n    DEBUGLOG(4, \"ZSTD_writeEpilogue\");\n    RETURN_ERROR_IF(cctx->stage == ZSTDcs_created, stage_wrong, \"init missing\");\n\n    /* special case : empty frame */\n    if (cctx->stage == ZSTDcs_init) {\n        size_t fhSize = ZSTD_writeFrameHeader(dst, dstCapacity, &cctx->appliedParams, 0, 0);\n        FORWARD_IF_ERROR(fhSize, \"ZSTD_writeFrameHeader failed\");\n        dstCapacity -= fhSize;\n        op += fhSize;\n        cctx->stage = ZSTDcs_ongoing;\n    }\n\n    if (cctx->stage != ZSTDcs_ending) {\n        /* write one last empty block, make it the \"last\" block */\n        U32 const cBlockHeader24 = 1 /* last block */ + (((U32)bt_raw)<<1) + 0;\n        ZSTD_STATIC_ASSERT(ZSTD_BLOCKHEADERSIZE == 3);\n        RETURN_ERROR_IF(dstCapacity<3, dstSize_tooSmall, \"no room for epilogue\");\n        MEM_writeLE24(op, cBlockHeader24);\n        op += ZSTD_blockHeaderSize;\n        dstCapacity -= ZSTD_blockHeaderSize;\n    }\n\n    if (cctx->appliedParams.fParams.checksumFlag) {\n        U32 const checksum = (U32) XXH64_digest(&cctx->xxhState);\n        RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall, \"no room for checksum\");\n        DEBUGLOG(4, \"ZSTD_writeEpilogue: write checksum : %08X\", (unsigned)checksum);\n        MEM_writeLE32(op, checksum);\n        op += 4;\n    }\n\n    cctx->stage = ZSTDcs_created;  /* return to \"created but no init\" status */\n    return (size_t)(op-ostart);\n}\n\nvoid ZSTD_CCtx_trace(ZSTD_CCtx* cctx, size_t extraCSize)\n{\n#if ZSTD_TRACE\n    if (cctx->traceCtx && ZSTD_trace_compress_end != NULL) {\n        int const streaming = cctx->inBuffSize > 0 || cctx->outBuffSize > 0 || cctx->appliedParams.nbWorkers > 0;\n        ZSTD_Trace trace;\n        ZSTD_memset(&trace, 0, sizeof(trace));\n        trace.version = ZSTD_VERSION_NUMBER;\n        trace.streaming = streaming;\n        trace.dictionaryID = cctx->dictID;\n        trace.dictionarySize = cctx->dictContentSize;\n        trace.uncompressedSize = cctx->consumedSrcSize;\n        trace.compressedSize = cctx->producedCSize + extraCSize;\n        trace.params = &cctx->appliedParams;\n        trace.cctx = cctx;\n        ZSTD_trace_compress_end(cctx->traceCtx, &trace);\n    }\n    cctx->traceCtx = 0;\n#else\n    (void)cctx;\n    (void)extraCSize;\n#endif\n}\n\nsize_t ZSTD_compressEnd_public(ZSTD_CCtx* cctx,\n                               void* dst, size_t dstCapacity,\n                         const void* src, size_t srcSize)\n{\n    size_t endResult;\n    size_t const cSize = ZSTD_compressContinue_internal(cctx,\n                                dst, dstCapacity, src, srcSize,\n                                1 /* frame mode */, 1 /* last chunk */);\n    FORWARD_IF_ERROR(cSize, \"ZSTD_compressContinue_internal failed\");\n    endResult = ZSTD_writeEpilogue(cctx, (char*)dst + cSize, dstCapacity-cSize);\n    FORWARD_IF_ERROR(endResult, \"ZSTD_writeEpilogue failed\");\n    assert(!(cctx->appliedParams.fParams.contentSizeFlag && cctx->pledgedSrcSizePlusOne == 0));\n    if (cctx->pledgedSrcSizePlusOne != 0) {  /* control src size */\n        ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_UNKNOWN == (unsigned long long)-1);\n        DEBUGLOG(4, \"end of frame : controlling src size\");\n        RETURN_ERROR_IF(\n            cctx->pledgedSrcSizePlusOne != cctx->consumedSrcSize+1,\n            srcSize_wrong,\n             \"error : pledgedSrcSize = %u, while realSrcSize = %u\",\n            (unsigned)cctx->pledgedSrcSizePlusOne-1,\n            (unsigned)cctx->consumedSrcSize);\n    }\n    ZSTD_CCtx_trace(cctx, endResult);\n    return cSize + endResult;\n}\n\n/* NOTE: Must just wrap ZSTD_compressEnd_public() */\nsize_t ZSTD_compressEnd(ZSTD_CCtx* cctx,\n                        void* dst, size_t dstCapacity,\n                  const void* src, size_t srcSize)\n{\n    return ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize);\n}\n\nsize_t ZSTD_compress_advanced (ZSTD_CCtx* cctx,\n                               void* dst, size_t dstCapacity,\n                         const void* src, size_t srcSize,\n                         const void* dict,size_t dictSize,\n                               ZSTD_parameters params)\n{\n    DEBUGLOG(4, \"ZSTD_compress_advanced\");\n    FORWARD_IF_ERROR(ZSTD_checkCParams(params.cParams), \"\");\n    ZSTD_CCtxParams_init_internal(&cctx->simpleApiParams, ¶ms, ZSTD_NO_CLEVEL);\n    return ZSTD_compress_advanced_internal(cctx,\n                                           dst, dstCapacity,\n                                           src, srcSize,\n                                           dict, dictSize,\n                                           &cctx->simpleApiParams);\n}\n\n/* Internal */\nsize_t ZSTD_compress_advanced_internal(\n        ZSTD_CCtx* cctx,\n        void* dst, size_t dstCapacity,\n        const void* src, size_t srcSize,\n        const void* dict,size_t dictSize,\n        const ZSTD_CCtx_params* params)\n{\n    DEBUGLOG(4, \"ZSTD_compress_advanced_internal (srcSize:%u)\", (unsigned)srcSize);\n    FORWARD_IF_ERROR( ZSTD_compressBegin_internal(cctx,\n                         dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,\n                         params, srcSize, ZSTDb_not_buffered) , \"\");\n    return ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize);\n}\n\nsize_t ZSTD_compress_usingDict(ZSTD_CCtx* cctx,\n                               void* dst, size_t dstCapacity,\n                         const void* src, size_t srcSize,\n                         const void* dict, size_t dictSize,\n                               int compressionLevel)\n{\n    {\n        ZSTD_parameters const params = ZSTD_getParams_internal(compressionLevel, srcSize, dict ? dictSize : 0, ZSTD_cpm_noAttachDict);\n        assert(params.fParams.contentSizeFlag == 1);\n        ZSTD_CCtxParams_init_internal(&cctx->simpleApiParams, ¶ms, (compressionLevel == 0) ? ZSTD_CLEVEL_DEFAULT: compressionLevel);\n    }\n    DEBUGLOG(4, \"ZSTD_compress_usingDict (srcSize=%u)\", (unsigned)srcSize);\n    return ZSTD_compress_advanced_internal(cctx, dst, dstCapacity, src, srcSize, dict, dictSize, &cctx->simpleApiParams);\n}\n\nsize_t ZSTD_compressCCtx(ZSTD_CCtx* cctx,\n                         void* dst, size_t dstCapacity,\n                   const void* src, size_t srcSize,\n                         int compressionLevel)\n{\n    DEBUGLOG(4, \"ZSTD_compressCCtx (srcSize=%u)\", (unsigned)srcSize);\n    assert(cctx != NULL);\n    return ZSTD_compress_usingDict(cctx, dst, dstCapacity, src, srcSize, NULL, 0, compressionLevel);\n}\n\nsize_t ZSTD_compress(void* dst, size_t dstCapacity,\n               const void* src, size_t srcSize,\n                     int compressionLevel)\n{\n    size_t result;\n#if ZSTD_COMPRESS_HEAPMODE\n    ZSTD_CCtx* cctx = ZSTD_createCCtx();\n    RETURN_ERROR_IF(!cctx, memory_allocation, \"ZSTD_createCCtx failed\");\n    result = ZSTD_compressCCtx(cctx, dst, dstCapacity, src, srcSize, compressionLevel);\n    ZSTD_freeCCtx(cctx);\n#else\n    ZSTD_CCtx ctxBody;\n    ZSTD_initCCtx(&ctxBody, ZSTD_defaultCMem);\n    result = ZSTD_compressCCtx(&ctxBody, dst, dstCapacity, src, srcSize, compressionLevel);\n    ZSTD_freeCCtxContent(&ctxBody);   /* can't free ctxBody itself, as it's on stack; free only heap content */\n#endif\n    return result;\n}\n\n\n/* =====  Dictionary API  ===== */\n\n/*! ZSTD_estimateCDictSize_advanced() :\n *  Estimate amount of memory that will be needed to create a dictionary with following arguments */\nsize_t ZSTD_estimateCDictSize_advanced(\n        size_t dictSize, ZSTD_compressionParameters cParams,\n        ZSTD_dictLoadMethod_e dictLoadMethod)\n{\n    DEBUGLOG(5, \"sizeof(ZSTD_CDict) : %u\", (unsigned)sizeof(ZSTD_CDict));\n    return ZSTD_cwksp_alloc_size(sizeof(ZSTD_CDict))\n         + ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE)\n         /* enableDedicatedDictSearch == 1 ensures that CDict estimation will not be too small\n          * in case we are using DDS with row-hash. */\n         + ZSTD_sizeof_matchState(&cParams, ZSTD_resolveRowMatchFinderMode(ZSTD_ps_auto, &cParams),\n                                  /* enableDedicatedDictSearch */ 1, /* forCCtx */ 0)\n         + (dictLoadMethod == ZSTD_dlm_byRef ? 0\n            : ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, sizeof(void *))));\n}\n\nsize_t ZSTD_estimateCDictSize(size_t dictSize, int compressionLevel)\n{\n    ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);\n    return ZSTD_estimateCDictSize_advanced(dictSize, cParams, ZSTD_dlm_byCopy);\n}\n\nsize_t ZSTD_sizeof_CDict(const ZSTD_CDict* cdict)\n{\n    if (cdict==NULL) return 0;   /* support sizeof on NULL */\n    DEBUGLOG(5, \"sizeof(*cdict) : %u\", (unsigned)sizeof(*cdict));\n    /* cdict may be in the workspace */\n    return (cdict->workspace.workspace == cdict ? 0 : sizeof(*cdict))\n        + ZSTD_cwksp_sizeof(&cdict->workspace);\n}\n\nstatic size_t ZSTD_initCDict_internal(\n                    ZSTD_CDict* cdict,\n              const void* dictBuffer, size_t dictSize,\n                    ZSTD_dictLoadMethod_e dictLoadMethod,\n                    ZSTD_dictContentType_e dictContentType,\n                    ZSTD_CCtx_params params)\n{\n    DEBUGLOG(3, \"ZSTD_initCDict_internal (dictContentType:%u)\", (unsigned)dictContentType);\n    assert(!ZSTD_checkCParams(params.cParams));\n    cdict->matchState.cParams = params.cParams;\n    cdict->matchState.dedicatedDictSearch = params.enableDedicatedDictSearch;\n    if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dictBuffer) || (!dictSize)) {\n        cdict->dictContent = dictBuffer;\n    } else {\n         void *internalBuffer = ZSTD_cwksp_reserve_object(&cdict->workspace, ZSTD_cwksp_align(dictSize, sizeof(void*)));\n        RETURN_ERROR_IF(!internalBuffer, memory_allocation, \"NULL pointer!\");\n        cdict->dictContent = internalBuffer;\n        ZSTD_memcpy(internalBuffer, dictBuffer, dictSize);\n    }\n    cdict->dictContentSize = dictSize;\n    cdict->dictContentType = dictContentType;\n\n    cdict->entropyWorkspace = (U32*)ZSTD_cwksp_reserve_object(&cdict->workspace, HUF_WORKSPACE_SIZE);\n\n\n    /* Reset the state to no dictionary */\n    ZSTD_reset_compressedBlockState(&cdict->cBlockState);\n    FORWARD_IF_ERROR(ZSTD_reset_matchState(\n        &cdict->matchState,\n        &cdict->workspace,\n        ¶ms.cParams,\n        params.useRowMatchFinder,\n        ZSTDcrp_makeClean,\n        ZSTDirp_reset,\n        ZSTD_resetTarget_CDict), \"\");\n    /* (Maybe) load the dictionary\n     * Skips loading the dictionary if it is < 8 bytes.\n     */\n    {   params.compressionLevel = ZSTD_CLEVEL_DEFAULT;\n        params.fParams.contentSizeFlag = 1;\n        {   size_t const dictID = ZSTD_compress_insertDictionary(\n                    &cdict->cBlockState, &cdict->matchState, NULL, &cdict->workspace,\n                    ¶ms, cdict->dictContent, cdict->dictContentSize,\n                    dictContentType, ZSTD_dtlm_full, ZSTD_tfp_forCDict, cdict->entropyWorkspace);\n            FORWARD_IF_ERROR(dictID, \"ZSTD_compress_insertDictionary failed\");\n            assert(dictID <= (size_t)(U32)-1);\n            cdict->dictID = (U32)dictID;\n        }\n    }\n\n    return 0;\n}\n\nstatic ZSTD_CDict*\nZSTD_createCDict_advanced_internal(size_t dictSize,\n                                ZSTD_dictLoadMethod_e dictLoadMethod,\n                                ZSTD_compressionParameters cParams,\n                                ZSTD_ParamSwitch_e useRowMatchFinder,\n                                int enableDedicatedDictSearch,\n                                ZSTD_customMem customMem)\n{\n    if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;\n    DEBUGLOG(3, \"ZSTD_createCDict_advanced_internal (dictSize=%u)\", (unsigned)dictSize);\n\n    {   size_t const workspaceSize =\n            ZSTD_cwksp_alloc_size(sizeof(ZSTD_CDict)) +\n            ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE) +\n            ZSTD_sizeof_matchState(&cParams, useRowMatchFinder, enableDedicatedDictSearch, /* forCCtx */ 0) +\n            (dictLoadMethod == ZSTD_dlm_byRef ? 0\n             : ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, sizeof(void*))));\n        void* const workspace = ZSTD_customMalloc(workspaceSize, customMem);\n        ZSTD_cwksp ws;\n        ZSTD_CDict* cdict;\n\n        if (!workspace) {\n            ZSTD_customFree(workspace, customMem);\n            return NULL;\n        }\n\n        ZSTD_cwksp_init(&ws, workspace, workspaceSize, ZSTD_cwksp_dynamic_alloc);\n\n        cdict = (ZSTD_CDict*)ZSTD_cwksp_reserve_object(&ws, sizeof(ZSTD_CDict));\n        assert(cdict != NULL);\n        ZSTD_cwksp_move(&cdict->workspace, &ws);\n        cdict->customMem = customMem;\n        cdict->compressionLevel = ZSTD_NO_CLEVEL; /* signals advanced API usage */\n        cdict->useRowMatchFinder = useRowMatchFinder;\n        return cdict;\n    }\n}\n\nZSTD_CDict* ZSTD_createCDict_advanced(const void* dictBuffer, size_t dictSize,\n                                      ZSTD_dictLoadMethod_e dictLoadMethod,\n                                      ZSTD_dictContentType_e dictContentType,\n                                      ZSTD_compressionParameters cParams,\n                                      ZSTD_customMem customMem)\n{\n    ZSTD_CCtx_params cctxParams;\n    ZSTD_memset(&cctxParams, 0, sizeof(cctxParams));\n    DEBUGLOG(3, \"ZSTD_createCDict_advanced, dictSize=%u, mode=%u\", (unsigned)dictSize, (unsigned)dictContentType);\n    ZSTD_CCtxParams_init(&cctxParams, 0);\n    cctxParams.cParams = cParams;\n    cctxParams.customMem = customMem;\n    return ZSTD_createCDict_advanced2(\n        dictBuffer, dictSize,\n        dictLoadMethod, dictContentType,\n        &cctxParams, customMem);\n}\n\nZSTD_CDict* ZSTD_createCDict_advanced2(\n        const void* dict, size_t dictSize,\n        ZSTD_dictLoadMethod_e dictLoadMethod,\n        ZSTD_dictContentType_e dictContentType,\n        const ZSTD_CCtx_params* originalCctxParams,\n        ZSTD_customMem customMem)\n{\n    ZSTD_CCtx_params cctxParams = *originalCctxParams;\n    ZSTD_compressionParameters cParams;\n    ZSTD_CDict* cdict;\n\n    DEBUGLOG(3, \"ZSTD_createCDict_advanced2, dictSize=%u, mode=%u\", (unsigned)dictSize, (unsigned)dictContentType);\n    if (!customMem.customAlloc ^ !customMem.customFree) return NULL;\n\n    if (cctxParams.enableDedicatedDictSearch) {\n        cParams = ZSTD_dedicatedDictSearch_getCParams(\n            cctxParams.compressionLevel, dictSize);\n        ZSTD_overrideCParams(&cParams, &cctxParams.cParams);\n    } else {\n        cParams = ZSTD_getCParamsFromCCtxParams(\n            &cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);\n    }\n\n    if (!ZSTD_dedicatedDictSearch_isSupported(&cParams)) {\n        /* Fall back to non-DDSS params */\n        cctxParams.enableDedicatedDictSearch = 0;\n        cParams = ZSTD_getCParamsFromCCtxParams(\n            &cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);\n    }\n\n    DEBUGLOG(3, \"ZSTD_createCDict_advanced2: DedicatedDictSearch=%u\", cctxParams.enableDedicatedDictSearch);\n    cctxParams.cParams = cParams;\n    cctxParams.useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(cctxParams.useRowMatchFinder, &cParams);\n\n    cdict = ZSTD_createCDict_advanced_internal(dictSize,\n                        dictLoadMethod, cctxParams.cParams,\n                        cctxParams.useRowMatchFinder, cctxParams.enableDedicatedDictSearch,\n                        customMem);\n\n    if (!cdict || ZSTD_isError( ZSTD_initCDict_internal(cdict,\n                                    dict, dictSize,\n                                    dictLoadMethod, dictContentType,\n                                    cctxParams) )) {\n        ZSTD_freeCDict(cdict);\n        return NULL;\n    }\n\n    return cdict;\n}\n\nZSTD_CDict* ZSTD_createCDict(const void* dict, size_t dictSize, int compressionLevel)\n{\n    ZSTD_compressionParameters cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);\n    ZSTD_CDict* const cdict = ZSTD_createCDict_advanced(dict, dictSize,\n                                                  ZSTD_dlm_byCopy, ZSTD_dct_auto,\n                                                  cParams, ZSTD_defaultCMem);\n    if (cdict)\n        cdict->compressionLevel = (compressionLevel == 0) ? ZSTD_CLEVEL_DEFAULT : compressionLevel;\n    return cdict;\n}\n\nZSTD_CDict* ZSTD_createCDict_byReference(const void* dict, size_t dictSize, int compressionLevel)\n{\n    ZSTD_compressionParameters cParams = ZSTD_getCParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_createCDict);\n    ZSTD_CDict* const cdict = ZSTD_createCDict_advanced(dict, dictSize,\n                                     ZSTD_dlm_byRef, ZSTD_dct_auto,\n                                     cParams, ZSTD_defaultCMem);\n    if (cdict)\n        cdict->compressionLevel = (compressionLevel == 0) ? ZSTD_CLEVEL_DEFAULT : compressionLevel;\n    return cdict;\n}\n\nsize_t ZSTD_freeCDict(ZSTD_CDict* cdict)\n{\n    if (cdict==NULL) return 0;   /* support free on NULL */\n    {   ZSTD_customMem const cMem = cdict->customMem;\n        int cdictInWorkspace = ZSTD_cwksp_owns_buffer(&cdict->workspace, cdict);\n        ZSTD_cwksp_free(&cdict->workspace, cMem);\n        if (!cdictInWorkspace) {\n            ZSTD_customFree(cdict, cMem);\n        }\n        return 0;\n    }\n}\n\n/*! ZSTD_initStaticCDict_advanced() :\n *  Generate a digested dictionary in provided memory area.\n *  workspace: The memory area to emplace the dictionary into.\n *             Provided pointer must 8-bytes aligned.\n *             It must outlive dictionary usage.\n *  workspaceSize: Use ZSTD_estimateCDictSize()\n *                 to determine how large workspace must be.\n *  cParams : use ZSTD_getCParams() to transform a compression level\n *            into its relevant cParams.\n * @return : pointer to ZSTD_CDict*, or NULL if error (size too small)\n *  Note : there is no corresponding \"free\" function.\n *         Since workspace was allocated externally, it must be freed externally.\n */\nconst ZSTD_CDict* ZSTD_initStaticCDict(\n                                 void* workspace, size_t workspaceSize,\n                           const void* dict, size_t dictSize,\n                                 ZSTD_dictLoadMethod_e dictLoadMethod,\n                                 ZSTD_dictContentType_e dictContentType,\n                                 ZSTD_compressionParameters cParams)\n{\n    ZSTD_ParamSwitch_e const useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(ZSTD_ps_auto, &cParams);\n    /* enableDedicatedDictSearch == 1 ensures matchstate is not too small in case this CDict will be used for DDS + row hash */\n    size_t const matchStateSize = ZSTD_sizeof_matchState(&cParams, useRowMatchFinder, /* enableDedicatedDictSearch */ 1, /* forCCtx */ 0);\n    size_t const neededSize = ZSTD_cwksp_alloc_size(sizeof(ZSTD_CDict))\n                            + (dictLoadMethod == ZSTD_dlm_byRef ? 0\n                               : ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(dictSize, sizeof(void*))))\n                            + ZSTD_cwksp_alloc_size(HUF_WORKSPACE_SIZE)\n                            + matchStateSize;\n    ZSTD_CDict* cdict;\n    ZSTD_CCtx_params params;\n\n    DEBUGLOG(4, \"ZSTD_initStaticCDict (dictSize==%u)\", (unsigned)dictSize);\n    if ((size_t)workspace & 7) return NULL;  /* 8-aligned */\n\n    {\n        ZSTD_cwksp ws;\n        ZSTD_cwksp_init(&ws, workspace, workspaceSize, ZSTD_cwksp_static_alloc);\n        cdict = (ZSTD_CDict*)ZSTD_cwksp_reserve_object(&ws, sizeof(ZSTD_CDict));\n        if (cdict == NULL) return NULL;\n        ZSTD_cwksp_move(&cdict->workspace, &ws);\n    }\n\n    if (workspaceSize < neededSize) return NULL;\n\n    ZSTD_CCtxParams_init(¶ms, 0);\n    params.cParams = cParams;\n    params.useRowMatchFinder = useRowMatchFinder;\n    cdict->useRowMatchFinder = useRowMatchFinder;\n    cdict->compressionLevel = ZSTD_NO_CLEVEL;\n\n    if (ZSTD_isError( ZSTD_initCDict_internal(cdict,\n                                              dict, dictSize,\n                                              dictLoadMethod, dictContentType,\n                                              params) ))\n        return NULL;\n\n    return cdict;\n}\n\nZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict)\n{\n    assert(cdict != NULL);\n    return cdict->matchState.cParams;\n}\n\n/*! ZSTD_getDictID_fromCDict() :\n *  Provides the dictID of the dictionary loaded into `cdict`.\n *  If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.\n *  Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */\nunsigned ZSTD_getDictID_fromCDict(const ZSTD_CDict* cdict)\n{\n    if (cdict==NULL) return 0;\n    return cdict->dictID;\n}\n\n/* ZSTD_compressBegin_usingCDict_internal() :\n * Implementation of various ZSTD_compressBegin_usingCDict* functions.\n */\nstatic size_t ZSTD_compressBegin_usingCDict_internal(\n    ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict,\n    ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize)\n{\n    ZSTD_CCtx_params cctxParams;\n    DEBUGLOG(4, \"ZSTD_compressBegin_usingCDict_internal\");\n    RETURN_ERROR_IF(cdict==NULL, dictionary_wrong, \"NULL pointer!\");\n    /* Initialize the cctxParams from the cdict */\n    {\n        ZSTD_parameters params;\n        params.fParams = fParams;\n        params.cParams = ( pledgedSrcSize < ZSTD_USE_CDICT_PARAMS_SRCSIZE_CUTOFF\n                        || pledgedSrcSize < cdict->dictContentSize * ZSTD_USE_CDICT_PARAMS_DICTSIZE_MULTIPLIER\n                        || pledgedSrcSize == ZSTD_CONTENTSIZE_UNKNOWN\n                        || cdict->compressionLevel == 0 ) ?\n                ZSTD_getCParamsFromCDict(cdict)\n              : ZSTD_getCParams(cdict->compressionLevel,\n                                pledgedSrcSize,\n                                cdict->dictContentSize);\n        ZSTD_CCtxParams_init_internal(&cctxParams, ¶ms, cdict->compressionLevel);\n    }\n    /* Increase window log to fit the entire dictionary and source if the\n     * source size is known. Limit the increase to 19, which is the\n     * window log for compression level 1 with the largest source size.\n     */\n    if (pledgedSrcSize != ZSTD_CONTENTSIZE_UNKNOWN) {\n        U32 const limitedSrcSize = (U32)MIN(pledgedSrcSize, 1U << 19);\n        U32 const limitedSrcLog = limitedSrcSize > 1 ? ZSTD_highbit32(limitedSrcSize - 1) + 1 : 1;\n        cctxParams.cParams.windowLog = MAX(cctxParams.cParams.windowLog, limitedSrcLog);\n    }\n    return ZSTD_compressBegin_internal(cctx,\n                                        NULL, 0, ZSTD_dct_auto, ZSTD_dtlm_fast,\n                                        cdict,\n                                        &cctxParams, pledgedSrcSize,\n                                        ZSTDb_not_buffered);\n}\n\n\n/* ZSTD_compressBegin_usingCDict_advanced() :\n * This function is DEPRECATED.\n * cdict must be != NULL */\nsize_t ZSTD_compressBegin_usingCDict_advanced(\n    ZSTD_CCtx* const cctx, const ZSTD_CDict* const cdict,\n    ZSTD_frameParameters const fParams, unsigned long long const pledgedSrcSize)\n{\n    return ZSTD_compressBegin_usingCDict_internal(cctx, cdict, fParams, pledgedSrcSize);\n}\n\n/* ZSTD_compressBegin_usingCDict() :\n * cdict must be != NULL */\nsize_t ZSTD_compressBegin_usingCDict_deprecated(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict)\n{\n    ZSTD_frameParameters const fParams = { 0 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ };\n    return ZSTD_compressBegin_usingCDict_internal(cctx, cdict, fParams, ZSTD_CONTENTSIZE_UNKNOWN);\n}\n\nsize_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict)\n{\n    return ZSTD_compressBegin_usingCDict_deprecated(cctx, cdict);\n}\n\n/*! ZSTD_compress_usingCDict_internal():\n * Implementation of various ZSTD_compress_usingCDict* functions.\n */\nstatic size_t ZSTD_compress_usingCDict_internal(ZSTD_CCtx* cctx,\n                                void* dst, size_t dstCapacity,\n                                const void* src, size_t srcSize,\n                                const ZSTD_CDict* cdict, ZSTD_frameParameters fParams)\n{\n    FORWARD_IF_ERROR(ZSTD_compressBegin_usingCDict_internal(cctx, cdict, fParams, srcSize), \"\"); /* will check if cdict != NULL */\n    return ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize);\n}\n\n/*! ZSTD_compress_usingCDict_advanced():\n * This function is DEPRECATED.\n */\nsize_t ZSTD_compress_usingCDict_advanced(ZSTD_CCtx* cctx,\n                                void* dst, size_t dstCapacity,\n                                const void* src, size_t srcSize,\n                                const ZSTD_CDict* cdict, ZSTD_frameParameters fParams)\n{\n    return ZSTD_compress_usingCDict_internal(cctx, dst, dstCapacity, src, srcSize, cdict, fParams);\n}\n\n/*! ZSTD_compress_usingCDict() :\n *  Compression using a digested Dictionary.\n *  Faster startup than ZSTD_compress_usingDict(), recommended when same dictionary is used multiple times.\n *  Note that compression parameters are decided at CDict creation time\n *  while frame parameters are hardcoded */\nsize_t ZSTD_compress_usingCDict(ZSTD_CCtx* cctx,\n                                void* dst, size_t dstCapacity,\n                                const void* src, size_t srcSize,\n                                const ZSTD_CDict* cdict)\n{\n    ZSTD_frameParameters const fParams = { 1 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ };\n    return ZSTD_compress_usingCDict_internal(cctx, dst, dstCapacity, src, srcSize, cdict, fParams);\n}\n\n\n\n/* ******************************************************************\n*  Streaming\n********************************************************************/\n\nZSTD_CStream* ZSTD_createCStream(void)\n{\n    DEBUGLOG(3, \"ZSTD_createCStream\");\n    return ZSTD_createCStream_advanced(ZSTD_defaultCMem);\n}\n\nZSTD_CStream* ZSTD_initStaticCStream(void *workspace, size_t workspaceSize)\n{\n    return ZSTD_initStaticCCtx(workspace, workspaceSize);\n}\n\nZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem)\n{   /* CStream and CCtx are now same object */\n    return ZSTD_createCCtx_advanced(customMem);\n}\n\nsize_t ZSTD_freeCStream(ZSTD_CStream* zcs)\n{\n    return ZSTD_freeCCtx(zcs);   /* same object */\n}\n\n\n\n/*======   Initialization   ======*/\n\nsize_t ZSTD_CStreamInSize(void)  { return ZSTD_BLOCKSIZE_MAX; }\n\nsize_t ZSTD_CStreamOutSize(void)\n{\n    return ZSTD_compressBound(ZSTD_BLOCKSIZE_MAX) + ZSTD_blockHeaderSize + 4 /* 32-bits hash */ ;\n}\n\nstatic ZSTD_CParamMode_e ZSTD_getCParamMode(ZSTD_CDict const* cdict, ZSTD_CCtx_params const* params, U64 pledgedSrcSize)\n{\n    if (cdict != NULL && ZSTD_shouldAttachDict(cdict, params, pledgedSrcSize))\n        return ZSTD_cpm_attachDict;\n    else\n        return ZSTD_cpm_noAttachDict;\n}\n\n/* ZSTD_resetCStream():\n * pledgedSrcSize == 0 means \"unknown\" */\nsize_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pss)\n{\n    /* temporary : 0 interpreted as \"unknown\" during transition period.\n     * Users willing to specify \"unknown\" **must** use ZSTD_CONTENTSIZE_UNKNOWN.\n     * 0 will be interpreted as \"empty\" in the future.\n     */\n    U64 const pledgedSrcSize = (pss==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;\n    DEBUGLOG(4, \"ZSTD_resetCStream: pledgedSrcSize = %u\", (unsigned)pledgedSrcSize);\n    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , \"\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , \"\");\n    return 0;\n}\n\n/*! ZSTD_initCStream_internal() :\n *  Note : for lib/compress only. Used by zstdmt_compress.c.\n *  Assumption 1 : params are valid\n *  Assumption 2 : either dict, or cdict, is defined, not both */\nsize_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,\n                    const void* dict, size_t dictSize, const ZSTD_CDict* cdict,\n                    const ZSTD_CCtx_params* params,\n                    unsigned long long pledgedSrcSize)\n{\n    DEBUGLOG(4, \"ZSTD_initCStream_internal\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , \"\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , \"\");\n    assert(!ZSTD_isError(ZSTD_checkCParams(params->cParams)));\n    zcs->requestedParams = *params;\n    assert(!((dict) && (cdict)));  /* either dict or cdict, not both */\n    if (dict) {\n        FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) , \"\");\n    } else {\n        /* Dictionary is cleared if !cdict */\n        FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) , \"\");\n    }\n    return 0;\n}\n\n/* ZSTD_initCStream_usingCDict_advanced() :\n * same as ZSTD_initCStream_usingCDict(), with control over frame parameters */\nsize_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,\n                                            const ZSTD_CDict* cdict,\n                                            ZSTD_frameParameters fParams,\n                                            unsigned long long pledgedSrcSize)\n{\n    DEBUGLOG(4, \"ZSTD_initCStream_usingCDict_advanced\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , \"\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , \"\");\n    zcs->requestedParams.fParams = fParams;\n    FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) , \"\");\n    return 0;\n}\n\n/* note : cdict must outlive compression session */\nsize_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict)\n{\n    DEBUGLOG(4, \"ZSTD_initCStream_usingCDict\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , \"\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, cdict) , \"\");\n    return 0;\n}\n\n\n/* ZSTD_initCStream_advanced() :\n * pledgedSrcSize must be exact.\n * if srcSize is not known at init time, use value ZSTD_CONTENTSIZE_UNKNOWN.\n * dict is loaded with default parameters ZSTD_dct_auto and ZSTD_dlm_byCopy. */\nsize_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,\n                                 const void* dict, size_t dictSize,\n                                 ZSTD_parameters params, unsigned long long pss)\n{\n    /* for compatibility with older programs relying on this behavior.\n     * Users should now specify ZSTD_CONTENTSIZE_UNKNOWN.\n     * This line will be removed in the future.\n     */\n    U64 const pledgedSrcSize = (pss==0 && params.fParams.contentSizeFlag==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;\n    DEBUGLOG(4, \"ZSTD_initCStream_advanced\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , \"\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , \"\");\n    FORWARD_IF_ERROR( ZSTD_checkCParams(params.cParams) , \"\");\n    ZSTD_CCtxParams_setZstdParams(&zcs->requestedParams, ¶ms);\n    FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) , \"\");\n    return 0;\n}\n\nsize_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel)\n{\n    DEBUGLOG(4, \"ZSTD_initCStream_usingDict\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , \"\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) , \"\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_loadDictionary(zcs, dict, dictSize) , \"\");\n    return 0;\n}\n\nsize_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pss)\n{\n    /* temporary : 0 interpreted as \"unknown\" during transition period.\n     * Users willing to specify \"unknown\" **must** use ZSTD_CONTENTSIZE_UNKNOWN.\n     * 0 will be interpreted as \"empty\" in the future.\n     */\n    U64 const pledgedSrcSize = (pss==0) ? ZSTD_CONTENTSIZE_UNKNOWN : pss;\n    DEBUGLOG(4, \"ZSTD_initCStream_srcSize\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , \"\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, NULL) , \"\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) , \"\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize) , \"\");\n    return 0;\n}\n\nsize_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel)\n{\n    DEBUGLOG(4, \"ZSTD_initCStream\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only) , \"\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_refCDict(zcs, NULL) , \"\");\n    FORWARD_IF_ERROR( ZSTD_CCtx_setParameter(zcs, ZSTD_c_compressionLevel, compressionLevel) , \"\");\n    return 0;\n}\n\n/*======   Compression   ======*/\n\nstatic size_t ZSTD_nextInputSizeHint(const ZSTD_CCtx* cctx)\n{\n    if (cctx->appliedParams.inBufferMode == ZSTD_bm_stable) {\n        return cctx->blockSizeMax - cctx->stableIn_notConsumed;\n    }\n    assert(cctx->appliedParams.inBufferMode == ZSTD_bm_buffered);\n    {   size_t hintInSize = cctx->inBuffTarget - cctx->inBuffPos;\n        if (hintInSize==0) hintInSize = cctx->blockSizeMax;\n        return hintInSize;\n    }\n}\n\n/** ZSTD_compressStream_generic():\n *  internal function for all *compressStream*() variants\n * @return : hint size for next input to complete ongoing block */\nstatic size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,\n                                          ZSTD_outBuffer* output,\n                                          ZSTD_inBuffer* input,\n                                          ZSTD_EndDirective const flushMode)\n{\n    const char* const istart = (assert(input != NULL), (const char*)input->src);\n    const char* const iend = (istart != NULL) ? istart + input->size : istart;\n    const char* ip = (istart != NULL) ? istart + input->pos : istart;\n    char* const ostart = (assert(output != NULL), (char*)output->dst);\n    char* const oend = (ostart != NULL) ? ostart + output->size : ostart;\n    char* op = (ostart != NULL) ? ostart + output->pos : ostart;\n    U32 someMoreWork = 1;\n\n    /* check expectations */\n    DEBUGLOG(5, \"ZSTD_compressStream_generic, flush=%i, srcSize = %zu\", (int)flushMode, input->size - input->pos);\n    assert(zcs != NULL);\n    if (zcs->appliedParams.inBufferMode == ZSTD_bm_stable) {\n        assert(input->pos >= zcs->stableIn_notConsumed);\n        input->pos -= zcs->stableIn_notConsumed;\n        if (ip) ip -= zcs->stableIn_notConsumed;\n        zcs->stableIn_notConsumed = 0;\n    }\n    if (zcs->appliedParams.inBufferMode == ZSTD_bm_buffered) {\n        assert(zcs->inBuff != NULL);\n        assert(zcs->inBuffSize > 0);\n    }\n    if (zcs->appliedParams.outBufferMode == ZSTD_bm_buffered) {\n        assert(zcs->outBuff !=  NULL);\n        assert(zcs->outBuffSize > 0);\n    }\n    if (input->src == NULL) assert(input->size == 0);\n    assert(input->pos <= input->size);\n    if (output->dst == NULL) assert(output->size == 0);\n    assert(output->pos <= output->size);\n    assert((U32)flushMode <= (U32)ZSTD_e_end);\n\n    while (someMoreWork) {\n        switch(zcs->streamStage)\n        {\n        case zcss_init:\n            RETURN_ERROR(init_missing, \"call ZSTD_initCStream() first!\");\n\n        case zcss_load:\n            if ( (flushMode == ZSTD_e_end)\n              && ( (size_t)(oend-op) >= ZSTD_compressBound((size_t)(iend-ip))     /* Enough output space */\n                || zcs->appliedParams.outBufferMode == ZSTD_bm_stable)  /* OR we are allowed to return dstSizeTooSmall */\n              && (zcs->inBuffPos == 0) ) {\n                /* shortcut to compression pass directly into output buffer */\n                size_t const cSize = ZSTD_compressEnd_public(zcs,\n                                                op, (size_t)(oend-op),\n                                                ip, (size_t)(iend-ip));\n                DEBUGLOG(4, \"ZSTD_compressEnd : cSize=%u\", (unsigned)cSize);\n                FORWARD_IF_ERROR(cSize, \"ZSTD_compressEnd failed\");\n                ip = iend;\n                op += cSize;\n                zcs->frameEnded = 1;\n                ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n                someMoreWork = 0; break;\n            }\n            /* complete loading into inBuffer in buffered mode */\n            if (zcs->appliedParams.inBufferMode == ZSTD_bm_buffered) {\n                size_t const toLoad = zcs->inBuffTarget - zcs->inBuffPos;\n                size_t const loaded = ZSTD_limitCopy(\n                                        zcs->inBuff + zcs->inBuffPos, toLoad,\n                                        ip, (size_t)(iend-ip));\n                zcs->inBuffPos += loaded;\n                if (ip) ip += loaded;\n                if ( (flushMode == ZSTD_e_continue)\n                  && (zcs->inBuffPos < zcs->inBuffTarget) ) {\n                    /* not enough input to fill full block : stop here */\n                    someMoreWork = 0; break;\n                }\n                if ( (flushMode == ZSTD_e_flush)\n                  && (zcs->inBuffPos == zcs->inToCompress) ) {\n                    /* empty */\n                    someMoreWork = 0; break;\n                }\n            } else {\n                assert(zcs->appliedParams.inBufferMode == ZSTD_bm_stable);\n                if ( (flushMode == ZSTD_e_continue)\n                  && ( (size_t)(iend - ip) < zcs->blockSizeMax) ) {\n                    /* can't compress a full block : stop here */\n                    zcs->stableIn_notConsumed = (size_t)(iend - ip);\n                    ip = iend;  /* pretend to have consumed input */\n                    someMoreWork = 0; break;\n                }\n                if ( (flushMode == ZSTD_e_flush)\n                  && (ip == iend) ) {\n                    /* empty */\n                    someMoreWork = 0; break;\n                }\n            }\n            /* compress current block (note : this stage cannot be stopped in the middle) */\n            DEBUGLOG(5, \"stream compression stage (flushMode==%u)\", flushMode);\n            {   int const inputBuffered = (zcs->appliedParams.inBufferMode == ZSTD_bm_buffered);\n                void* cDst;\n                size_t cSize;\n                size_t oSize = (size_t)(oend-op);\n                size_t const iSize = inputBuffered ? zcs->inBuffPos - zcs->inToCompress\n                                                   : MIN((size_t)(iend - ip), zcs->blockSizeMax);\n                if (oSize >= ZSTD_compressBound(iSize) || zcs->appliedParams.outBufferMode == ZSTD_bm_stable)\n                    cDst = op;   /* compress into output buffer, to skip flush stage */\n                else\n                    cDst = zcs->outBuff, oSize = zcs->outBuffSize;\n                if (inputBuffered) {\n                    unsigned const lastBlock = (flushMode == ZSTD_e_end) && (ip==iend);\n                    cSize = lastBlock ?\n                            ZSTD_compressEnd_public(zcs, cDst, oSize,\n                                        zcs->inBuff + zcs->inToCompress, iSize) :\n                            ZSTD_compressContinue_public(zcs, cDst, oSize,\n                                        zcs->inBuff + zcs->inToCompress, iSize);\n                    FORWARD_IF_ERROR(cSize, \"%s\", lastBlock ? \"ZSTD_compressEnd failed\" : \"ZSTD_compressContinue failed\");\n                    zcs->frameEnded = lastBlock;\n                    /* prepare next block */\n                    zcs->inBuffTarget = zcs->inBuffPos + zcs->blockSizeMax;\n                    if (zcs->inBuffTarget > zcs->inBuffSize)\n                        zcs->inBuffPos = 0, zcs->inBuffTarget = zcs->blockSizeMax;\n                    DEBUGLOG(5, \"inBuffTarget:%u / inBuffSize:%u\",\n                            (unsigned)zcs->inBuffTarget, (unsigned)zcs->inBuffSize);\n                    if (!lastBlock)\n                        assert(zcs->inBuffTarget <= zcs->inBuffSize);\n                    zcs->inToCompress = zcs->inBuffPos;\n                } else { /* !inputBuffered, hence ZSTD_bm_stable */\n                    unsigned const lastBlock = (flushMode == ZSTD_e_end) && (ip + iSize == iend);\n                    cSize = lastBlock ?\n                            ZSTD_compressEnd_public(zcs, cDst, oSize, ip, iSize) :\n                            ZSTD_compressContinue_public(zcs, cDst, oSize, ip, iSize);\n                    /* Consume the input prior to error checking to mirror buffered mode. */\n                    if (ip) ip += iSize;\n                    FORWARD_IF_ERROR(cSize, \"%s\", lastBlock ? \"ZSTD_compressEnd failed\" : \"ZSTD_compressContinue failed\");\n                    zcs->frameEnded = lastBlock;\n                    if (lastBlock) assert(ip == iend);\n                }\n                if (cDst == op) {  /* no need to flush */\n                    op += cSize;\n                    if (zcs->frameEnded) {\n                        DEBUGLOG(5, \"Frame completed directly in outBuffer\");\n                        someMoreWork = 0;\n                        ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n                    }\n                    break;\n                }\n                zcs->outBuffContentSize = cSize;\n                zcs->outBuffFlushedSize = 0;\n                zcs->streamStage = zcss_flush; /* pass-through to flush stage */\n            }\n\t    ZSTD_FALLTHROUGH;\n        case zcss_flush:\n            DEBUGLOG(5, \"flush stage\");\n            assert(zcs->appliedParams.outBufferMode == ZSTD_bm_buffered);\n            {   size_t const toFlush = zcs->outBuffContentSize - zcs->outBuffFlushedSize;\n                size_t const flushed = ZSTD_limitCopy(op, (size_t)(oend-op),\n                            zcs->outBuff + zcs->outBuffFlushedSize, toFlush);\n                DEBUGLOG(5, \"toFlush: %u into %u ==> flushed: %u\",\n                            (unsigned)toFlush, (unsigned)(oend-op), (unsigned)flushed);\n                if (flushed)\n                    op += flushed;\n                zcs->outBuffFlushedSize += flushed;\n                if (toFlush!=flushed) {\n                    /* flush not fully completed, presumably because dst is too small */\n                    assert(op==oend);\n                    someMoreWork = 0;\n                    break;\n                }\n                zcs->outBuffContentSize = zcs->outBuffFlushedSize = 0;\n                if (zcs->frameEnded) {\n                    DEBUGLOG(5, \"Frame completed on flush\");\n                    someMoreWork = 0;\n                    ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);\n                    break;\n                }\n                zcs->streamStage = zcss_load;\n                break;\n            }\n\n        default: /* impossible */\n            assert(0);\n        }\n    }\n\n    input->pos = (size_t)(ip - istart);\n    output->pos = (size_t)(op - ostart);\n    if (zcs->frameEnded) return 0;\n    return ZSTD_nextInputSizeHint(zcs);\n}\n\nstatic size_t ZSTD_nextInputSizeHint_MTorST(const ZSTD_CCtx* cctx)\n{\n#ifdef ZSTD_MULTITHREAD\n    if (cctx->appliedParams.nbWorkers >= 1) {\n        assert(cctx->mtctx != NULL);\n        return ZSTDMT_nextInputSizeHint(cctx->mtctx);\n    }\n#endif\n    return ZSTD_nextInputSizeHint(cctx);\n\n}\n\nsize_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input)\n{\n    FORWARD_IF_ERROR( ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue) , \"\");\n    return ZSTD_nextInputSizeHint_MTorST(zcs);\n}\n\n/* After a compression call set the expected input/output buffer.\n * This is validated at the start of the next compression call.\n */\nstatic void\nZSTD_setBufferExpectations(ZSTD_CCtx* cctx, const ZSTD_outBuffer* output, const ZSTD_inBuffer* input)\n{\n    DEBUGLOG(5, \"ZSTD_setBufferExpectations (for advanced stable in/out modes)\");\n    if (cctx->appliedParams.inBufferMode == ZSTD_bm_stable) {\n        cctx->expectedInBuffer = *input;\n    }\n    if (cctx->appliedParams.outBufferMode == ZSTD_bm_stable) {\n        cctx->expectedOutBufferSize = output->size - output->pos;\n    }\n}\n\n/* Validate that the input/output buffers match the expectations set by\n * ZSTD_setBufferExpectations.\n */\nstatic size_t ZSTD_checkBufferStability(ZSTD_CCtx const* cctx,\n                                        ZSTD_outBuffer const* output,\n                                        ZSTD_inBuffer const* input,\n                                        ZSTD_EndDirective endOp)\n{\n    if (cctx->appliedParams.inBufferMode == ZSTD_bm_stable) {\n        ZSTD_inBuffer const expect = cctx->expectedInBuffer;\n        if (expect.src != input->src || expect.pos != input->pos)\n            RETURN_ERROR(stabilityCondition_notRespected, \"ZSTD_c_stableInBuffer enabled but input differs!\");\n    }\n    (void)endOp;\n    if (cctx->appliedParams.outBufferMode == ZSTD_bm_stable) {\n        size_t const outBufferSize = output->size - output->pos;\n        if (cctx->expectedOutBufferSize != outBufferSize)\n            RETURN_ERROR(stabilityCondition_notRespected, \"ZSTD_c_stableOutBuffer enabled but output size differs!\");\n    }\n    return 0;\n}\n\n/*\n * If @endOp == ZSTD_e_end, @inSize becomes pledgedSrcSize.\n * Otherwise, it's ignored.\n * @return: 0 on success, or a ZSTD_error code otherwise.\n */\nstatic size_t ZSTD_CCtx_init_compressStream2(ZSTD_CCtx* cctx,\n                                             ZSTD_EndDirective endOp,\n                                             size_t inSize)\n{\n    ZSTD_CCtx_params params = cctx->requestedParams;\n    ZSTD_prefixDict const prefixDict = cctx->prefixDict;\n    FORWARD_IF_ERROR( ZSTD_initLocalDict(cctx) , \"\"); /* Init the local dict if present. */\n    ZSTD_memset(&cctx->prefixDict, 0, sizeof(cctx->prefixDict));   /* single usage */\n    assert(prefixDict.dict==NULL || cctx->cdict==NULL);    /* only one can be set */\n    if (cctx->cdict && !cctx->localDict.cdict) {\n        /* Let the cdict's compression level take priority over the requested params.\n         * But do not take the cdict's compression level if the \"cdict\" is actually a localDict\n         * generated from ZSTD_initLocalDict().\n         */\n        params.compressionLevel = cctx->cdict->compressionLevel;\n    }\n    DEBUGLOG(4, \"ZSTD_CCtx_init_compressStream2 : transparent init stage\");\n    if (endOp == ZSTD_e_end) cctx->pledgedSrcSizePlusOne = inSize + 1;  /* auto-determine pledgedSrcSize */\n\n    {   size_t const dictSize = prefixDict.dict\n                ? prefixDict.dictSize\n                : (cctx->cdict ? cctx->cdict->dictContentSize : 0);\n        ZSTD_CParamMode_e const mode = ZSTD_getCParamMode(cctx->cdict, ¶ms, cctx->pledgedSrcSizePlusOne - 1);\n        params.cParams = ZSTD_getCParamsFromCCtxParams(\n                ¶ms, cctx->pledgedSrcSizePlusOne-1,\n                dictSize, mode);\n    }\n\n    params.postBlockSplitter = ZSTD_resolveBlockSplitterMode(params.postBlockSplitter, ¶ms.cParams);\n    params.ldmParams.enableLdm = ZSTD_resolveEnableLdm(params.ldmParams.enableLdm, ¶ms.cParams);\n    params.useRowMatchFinder = ZSTD_resolveRowMatchFinderMode(params.useRowMatchFinder, ¶ms.cParams);\n    params.validateSequences = ZSTD_resolveExternalSequenceValidation(params.validateSequences);\n    params.maxBlockSize = ZSTD_resolveMaxBlockSize(params.maxBlockSize);\n    params.searchForExternalRepcodes = ZSTD_resolveExternalRepcodeSearch(params.searchForExternalRepcodes, params.compressionLevel);\n\n#ifdef ZSTD_MULTITHREAD\n    /* If external matchfinder is enabled, make sure to fail before checking job size (for consistency) */\n    RETURN_ERROR_IF(\n        ZSTD_hasExtSeqProd(¶ms) && params.nbWorkers >= 1,\n        parameter_combination_unsupported,\n        \"External sequence producer isn't supported with nbWorkers >= 1\"\n    );\n\n    if ((cctx->pledgedSrcSizePlusOne-1) <= ZSTDMT_JOBSIZE_MIN) {\n        params.nbWorkers = 0; /* do not invoke multi-threading when src size is too small */\n    }\n    if (params.nbWorkers > 0) {\n# if ZSTD_TRACE\n        cctx->traceCtx = (ZSTD_trace_compress_begin != NULL) ? ZSTD_trace_compress_begin(cctx) : 0;\n# endif\n        /* mt context creation */\n        if (cctx->mtctx == NULL) {\n            DEBUGLOG(4, \"ZSTD_compressStream2: creating new mtctx for nbWorkers=%u\",\n                        params.nbWorkers);\n            cctx->mtctx = ZSTDMT_createCCtx_advanced((U32)params.nbWorkers, cctx->customMem, cctx->pool);\n            RETURN_ERROR_IF(cctx->mtctx == NULL, memory_allocation, \"NULL pointer!\");\n        }\n        /* mt compression */\n        DEBUGLOG(4, \"call ZSTDMT_initCStream_internal as nbWorkers=%u\", params.nbWorkers);\n        FORWARD_IF_ERROR( ZSTDMT_initCStream_internal(\n                    cctx->mtctx,\n                    prefixDict.dict, prefixDict.dictSize, prefixDict.dictContentType,\n                    cctx->cdict, params, cctx->pledgedSrcSizePlusOne-1) , \"\");\n        cctx->dictID = cctx->cdict ? cctx->cdict->dictID : 0;\n        cctx->dictContentSize = cctx->cdict ? cctx->cdict->dictContentSize : prefixDict.dictSize;\n        cctx->consumedSrcSize = 0;\n        cctx->producedCSize = 0;\n        cctx->streamStage = zcss_load;\n        cctx->appliedParams = params;\n    } else\n#endif  /* ZSTD_MULTITHREAD */\n    {   U64 const pledgedSrcSize = cctx->pledgedSrcSizePlusOne - 1;\n        assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));\n        FORWARD_IF_ERROR( ZSTD_compressBegin_internal(cctx,\n                prefixDict.dict, prefixDict.dictSize, prefixDict.dictContentType, ZSTD_dtlm_fast,\n                cctx->cdict,\n                ¶ms, pledgedSrcSize,\n                ZSTDb_buffered) , \"\");\n        assert(cctx->appliedParams.nbWorkers == 0);\n        cctx->inToCompress = 0;\n        cctx->inBuffPos = 0;\n        if (cctx->appliedParams.inBufferMode == ZSTD_bm_buffered) {\n            /* for small input: avoid automatic flush on reaching end of block, since\n            * it would require to add a 3-bytes null block to end frame\n            */\n            cctx->inBuffTarget = cctx->blockSizeMax + (cctx->blockSizeMax == pledgedSrcSize);\n        } else {\n            cctx->inBuffTarget = 0;\n        }\n        cctx->outBuffContentSize = cctx->outBuffFlushedSize = 0;\n        cctx->streamStage = zcss_load;\n        cctx->frameEnded = 0;\n    }\n    return 0;\n}\n\n/* @return provides a minimum amount of data remaining to be flushed from internal buffers\n */\nsize_t ZSTD_compressStream2( ZSTD_CCtx* cctx,\n                             ZSTD_outBuffer* output,\n                             ZSTD_inBuffer* input,\n                             ZSTD_EndDirective endOp)\n{\n    DEBUGLOG(5, \"ZSTD_compressStream2, endOp=%u \", (unsigned)endOp);\n    /* check conditions */\n    RETURN_ERROR_IF(output->pos > output->size, dstSize_tooSmall, \"invalid output buffer\");\n    RETURN_ERROR_IF(input->pos  > input->size, srcSize_wrong, \"invalid input buffer\");\n    RETURN_ERROR_IF((U32)endOp > (U32)ZSTD_e_end, parameter_outOfBound, \"invalid endDirective\");\n    assert(cctx != NULL);\n\n    /* transparent initialization stage */\n    if (cctx->streamStage == zcss_init) {\n        size_t const inputSize = input->size - input->pos;  /* no obligation to start from pos==0 */\n        size_t const totalInputSize = inputSize + cctx->stableIn_notConsumed;\n        if ( (cctx->requestedParams.inBufferMode == ZSTD_bm_stable) /* input is presumed stable, across invocations */\n          && (endOp == ZSTD_e_continue)                             /* no flush requested, more input to come */\n          && (totalInputSize < ZSTD_BLOCKSIZE_MAX) ) {              /* not even reached one block yet */\n            if (cctx->stableIn_notConsumed) {  /* not the first time */\n                /* check stable source guarantees */\n                RETURN_ERROR_IF(input->src != cctx->expectedInBuffer.src, stabilityCondition_notRespected, \"stableInBuffer condition not respected: wrong src pointer\");\n                RETURN_ERROR_IF(input->pos != cctx->expectedInBuffer.size, stabilityCondition_notRespected, \"stableInBuffer condition not respected: externally modified pos\");\n            }\n            /* pretend input was consumed, to give a sense forward progress */\n            input->pos = input->size;\n            /* save stable inBuffer, for later control, and flush/end */\n            cctx->expectedInBuffer = *input;\n            /* but actually input wasn't consumed, so keep track of position from where compression shall resume */\n            cctx->stableIn_notConsumed += inputSize;\n            /* don't initialize yet, wait for the first block of flush() order, for better parameters adaptation */\n            return ZSTD_FRAMEHEADERSIZE_MIN(cctx->requestedParams.format);  /* at least some header to produce */\n        }\n        FORWARD_IF_ERROR(ZSTD_CCtx_init_compressStream2(cctx, endOp, totalInputSize), \"compressStream2 initialization failed\");\n        ZSTD_setBufferExpectations(cctx, output, input);   /* Set initial buffer expectations now that we've initialized */\n    }\n    /* end of transparent initialization stage */\n\n    FORWARD_IF_ERROR(ZSTD_checkBufferStability(cctx, output, input, endOp), \"invalid buffers\");\n    /* compression stage */\n#ifdef ZSTD_MULTITHREAD\n    if (cctx->appliedParams.nbWorkers > 0) {\n        size_t flushMin;\n        if (cctx->cParamsChanged) {\n            ZSTDMT_updateCParams_whileCompressing(cctx->mtctx, &cctx->requestedParams);\n            cctx->cParamsChanged = 0;\n        }\n        if (cctx->stableIn_notConsumed) {\n            assert(cctx->appliedParams.inBufferMode == ZSTD_bm_stable);\n            /* some early data was skipped - make it available for consumption */\n            assert(input->pos >= cctx->stableIn_notConsumed);\n            input->pos -= cctx->stableIn_notConsumed;\n            cctx->stableIn_notConsumed = 0;\n        }\n        for (;;) {\n            size_t const ipos = input->pos;\n            size_t const opos = output->pos;\n            flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp);\n            cctx->consumedSrcSize += (U64)(input->pos - ipos);\n            cctx->producedCSize += (U64)(output->pos - opos);\n            if ( ZSTD_isError(flushMin)\n              || (endOp == ZSTD_e_end && flushMin == 0) ) { /* compression completed */\n                if (flushMin == 0)\n                    ZSTD_CCtx_trace(cctx, 0);\n                ZSTD_CCtx_reset(cctx, ZSTD_reset_session_only);\n            }\n            FORWARD_IF_ERROR(flushMin, \"ZSTDMT_compressStream_generic failed\");\n\n            if (endOp == ZSTD_e_continue) {\n                /* We only require some progress with ZSTD_e_continue, not maximal progress.\n                 * We're done if we've consumed or produced any bytes, or either buffer is\n                 * full.\n                 */\n                if (input->pos != ipos || output->pos != opos || input->pos == input->size || output->pos == output->size)\n                    break;\n            } else {\n                assert(endOp == ZSTD_e_flush || endOp == ZSTD_e_end);\n                /* We require maximal progress. We're done when the flush is complete or the\n                 * output buffer is full.\n                 */\n                if (flushMin == 0 || output->pos == output->size)\n                    break;\n            }\n        }\n        DEBUGLOG(5, \"completed ZSTD_compressStream2 delegating to ZSTDMT_compressStream_generic\");\n        /* Either we don't require maximum forward progress, we've finished the\n         * flush, or we are out of output space.\n         */\n        assert(endOp == ZSTD_e_continue || flushMin == 0 || output->pos == output->size);\n        ZSTD_setBufferExpectations(cctx, output, input);\n        return flushMin;\n    }\n#endif /* ZSTD_MULTITHREAD */\n    FORWARD_IF_ERROR( ZSTD_compressStream_generic(cctx, output, input, endOp) , \"\");\n    DEBUGLOG(5, \"completed ZSTD_compressStream2\");\n    ZSTD_setBufferExpectations(cctx, output, input);\n    return cctx->outBuffContentSize - cctx->outBuffFlushedSize; /* remaining to flush */\n}\n\nsize_t ZSTD_compressStream2_simpleArgs (\n                            ZSTD_CCtx* cctx,\n                            void* dst, size_t dstCapacity, size_t* dstPos,\n                      const void* src, size_t srcSize, size_t* srcPos,\n                            ZSTD_EndDirective endOp)\n{\n    ZSTD_outBuffer output;\n    ZSTD_inBuffer  input;\n    output.dst = dst;\n    output.size = dstCapacity;\n    output.pos = *dstPos;\n    input.src = src;\n    input.size = srcSize;\n    input.pos = *srcPos;\n    /* ZSTD_compressStream2() will check validity of dstPos and srcPos */\n    {   size_t const cErr = ZSTD_compressStream2(cctx, &output, &input, endOp);\n        *dstPos = output.pos;\n        *srcPos = input.pos;\n        return cErr;\n    }\n}\n\nsize_t ZSTD_compress2(ZSTD_CCtx* cctx,\n                      void* dst, size_t dstCapacity,\n                      const void* src, size_t srcSize)\n{\n    ZSTD_bufferMode_e const originalInBufferMode = cctx->requestedParams.inBufferMode;\n    ZSTD_bufferMode_e const originalOutBufferMode = cctx->requestedParams.outBufferMode;\n    DEBUGLOG(4, \"ZSTD_compress2 (srcSize=%u)\", (unsigned)srcSize);\n    ZSTD_CCtx_reset(cctx, ZSTD_reset_session_only);\n    /* Enable stable input/output buffers. */\n    cctx->requestedParams.inBufferMode = ZSTD_bm_stable;\n    cctx->requestedParams.outBufferMode = ZSTD_bm_stable;\n    {   size_t oPos = 0;\n        size_t iPos = 0;\n        size_t const result = ZSTD_compressStream2_simpleArgs(cctx,\n                                        dst, dstCapacity, &oPos,\n                                        src, srcSize, &iPos,\n                                        ZSTD_e_end);\n        /* Reset to the original values. */\n        cctx->requestedParams.inBufferMode = originalInBufferMode;\n        cctx->requestedParams.outBufferMode = originalOutBufferMode;\n\n        FORWARD_IF_ERROR(result, \"ZSTD_compressStream2_simpleArgs failed\");\n        if (result != 0) {  /* compression not completed, due to lack of output space */\n            assert(oPos == dstCapacity);\n            RETURN_ERROR(dstSize_tooSmall, \"\");\n        }\n        assert(iPos == srcSize);   /* all input is expected consumed */\n        return oPos;\n    }\n}\n\n/* ZSTD_validateSequence() :\n * @offBase : must use the format required by ZSTD_storeSeq()\n * @returns a ZSTD error code if sequence is not valid\n */\nstatic size_t\nZSTD_validateSequence(U32 offBase, U32 matchLength, U32 minMatch,\n                      size_t posInSrc, U32 windowLog, size_t dictSize, int useSequenceProducer)\n{\n    U32 const windowSize = 1u << windowLog;\n    /* posInSrc represents the amount of data the decoder would decode up to this point.\n     * As long as the amount of data decoded is less than or equal to window size, offsets may be\n     * larger than the total length of output decoded in order to reference the dict, even larger than\n     * window size. After output surpasses windowSize, we're limited to windowSize offsets again.\n     */\n    size_t const offsetBound = posInSrc > windowSize ? (size_t)windowSize : posInSrc + (size_t)dictSize;\n    size_t const matchLenLowerBound = (minMatch == 3 || useSequenceProducer) ? 3 : 4;\n    RETURN_ERROR_IF(offBase > OFFSET_TO_OFFBASE(offsetBound), externalSequences_invalid, \"Offset too large!\");\n    /* Validate maxNbSeq is large enough for the given matchLength and minMatch */\n    RETURN_ERROR_IF(matchLength < matchLenLowerBound, externalSequences_invalid, \"Matchlength too small for the minMatch\");\n    return 0;\n}\n\n/* Returns an offset code, given a sequence's raw offset, the ongoing repcode array, and whether litLength == 0 */\nstatic U32 ZSTD_finalizeOffBase(U32 rawOffset, const U32 rep[ZSTD_REP_NUM], U32 ll0)\n{\n    U32 offBase = OFFSET_TO_OFFBASE(rawOffset);\n\n    if (!ll0 && rawOffset == rep[0]) {\n        offBase = REPCODE1_TO_OFFBASE;\n    } else if (rawOffset == rep[1]) {\n        offBase = REPCODE_TO_OFFBASE(2 - ll0);\n    } else if (rawOffset == rep[2]) {\n        offBase = REPCODE_TO_OFFBASE(3 - ll0);\n    } else if (ll0 && rawOffset == rep[0] - 1) {\n        offBase = REPCODE3_TO_OFFBASE;\n    }\n    return offBase;\n}\n\n/* This function scans through an array of ZSTD_Sequence,\n * storing the sequences it reads, until it reaches a block delimiter.\n * Note that the block delimiter includes the last literals of the block.\n * @blockSize must be == sum(sequence_lengths).\n * @returns @blockSize on success, and a ZSTD_error otherwise.\n */\nstatic size_t\nZSTD_transferSequences_wBlockDelim(ZSTD_CCtx* cctx,\n                                   ZSTD_SequencePosition* seqPos,\n                             const ZSTD_Sequence* const inSeqs, size_t inSeqsSize,\n                             const void* src, size_t blockSize,\n                                   ZSTD_ParamSwitch_e externalRepSearch)\n{\n    U32 idx = seqPos->idx;\n    U32 const startIdx = idx;\n    BYTE const* ip = (BYTE const*)(src);\n    const BYTE* const iend = ip + blockSize;\n    Repcodes_t updatedRepcodes;\n    U32 dictSize;\n\n    DEBUGLOG(5, \"ZSTD_transferSequences_wBlockDelim (blockSize = %zu)\", blockSize);\n\n    if (cctx->cdict) {\n        dictSize = (U32)cctx->cdict->dictContentSize;\n    } else if (cctx->prefixDict.dict) {\n        dictSize = (U32)cctx->prefixDict.dictSize;\n    } else {\n        dictSize = 0;\n    }\n    ZSTD_memcpy(updatedRepcodes.rep, cctx->blockState.prevCBlock->rep, sizeof(Repcodes_t));\n    for (; idx < inSeqsSize && (inSeqs[idx].matchLength != 0 || inSeqs[idx].offset != 0); ++idx) {\n        U32 const litLength = inSeqs[idx].litLength;\n        U32 const matchLength = inSeqs[idx].matchLength;\n        U32 offBase;\n\n        if (externalRepSearch == ZSTD_ps_disable) {\n            offBase = OFFSET_TO_OFFBASE(inSeqs[idx].offset);\n        } else {\n            U32 const ll0 = (litLength == 0);\n            offBase = ZSTD_finalizeOffBase(inSeqs[idx].offset, updatedRepcodes.rep, ll0);\n            ZSTD_updateRep(updatedRepcodes.rep, offBase, ll0);\n        }\n\n        DEBUGLOG(6, \"Storing sequence: (of: %u, ml: %u, ll: %u)\", offBase, matchLength, litLength);\n        if (cctx->appliedParams.validateSequences) {\n            seqPos->posInSrc += litLength + matchLength;\n            FORWARD_IF_ERROR(ZSTD_validateSequence(offBase, matchLength, cctx->appliedParams.cParams.minMatch,\n                                                seqPos->posInSrc,\n                                                cctx->appliedParams.cParams.windowLog, dictSize,\n                                                ZSTD_hasExtSeqProd(&cctx->appliedParams)),\n                                                \"Sequence validation failed\");\n        }\n        RETURN_ERROR_IF(idx - seqPos->idx >= cctx->seqStore.maxNbSeq, externalSequences_invalid,\n                        \"Not enough memory allocated. Try adjusting ZSTD_c_minMatch.\");\n        ZSTD_storeSeq(&cctx->seqStore, litLength, ip, iend, offBase, matchLength);\n        ip += matchLength + litLength;\n    }\n    RETURN_ERROR_IF(idx == inSeqsSize, externalSequences_invalid, \"Block delimiter not found.\");\n\n    /* If we skipped repcode search while parsing, we need to update repcodes now */\n    assert(externalRepSearch != ZSTD_ps_auto);\n    assert(idx >= startIdx);\n    if (externalRepSearch == ZSTD_ps_disable && idx != startIdx) {\n        U32* const rep = updatedRepcodes.rep;\n        U32 lastSeqIdx = idx - 1; /* index of last non-block-delimiter sequence */\n\n        if (lastSeqIdx >= startIdx + 2) {\n            rep[2] = inSeqs[lastSeqIdx - 2].offset;\n            rep[1] = inSeqs[lastSeqIdx - 1].offset;\n            rep[0] = inSeqs[lastSeqIdx].offset;\n        } else if (lastSeqIdx == startIdx + 1) {\n            rep[2] = rep[0];\n            rep[1] = inSeqs[lastSeqIdx - 1].offset;\n            rep[0] = inSeqs[lastSeqIdx].offset;\n        } else {\n            assert(lastSeqIdx == startIdx);\n            rep[2] = rep[1];\n            rep[1] = rep[0];\n            rep[0] = inSeqs[lastSeqIdx].offset;\n        }\n    }\n\n    ZSTD_memcpy(cctx->blockState.nextCBlock->rep, updatedRepcodes.rep, sizeof(Repcodes_t));\n\n    if (inSeqs[idx].litLength) {\n        DEBUGLOG(6, \"Storing last literals of size: %u\", inSeqs[idx].litLength);\n        ZSTD_storeLastLiterals(&cctx->seqStore, ip, inSeqs[idx].litLength);\n        ip += inSeqs[idx].litLength;\n        seqPos->posInSrc += inSeqs[idx].litLength;\n    }\n    RETURN_ERROR_IF(ip != iend, externalSequences_invalid, \"Blocksize doesn't agree with block delimiter!\");\n    seqPos->idx = idx+1;\n    return blockSize;\n}\n\n/*\n * This function attempts to scan through @blockSize bytes in @src\n * represented by the sequences in @inSeqs,\n * storing any (partial) sequences.\n *\n * Occasionally, we may want to reduce the actual number of bytes consumed from @src\n * to avoid splitting a match, notably if it would produce a match smaller than MINMATCH.\n *\n * @returns the number of bytes consumed from @src, necessarily <= @blockSize.\n * Otherwise, it may return a ZSTD error if something went wrong.\n */\nstatic size_t\nZSTD_transferSequences_noDelim(ZSTD_CCtx* cctx,\n                               ZSTD_SequencePosition* seqPos,\n                         const ZSTD_Sequence* const inSeqs, size_t inSeqsSize,\n                         const void* src, size_t blockSize,\n                               ZSTD_ParamSwitch_e externalRepSearch)\n{\n    U32 idx = seqPos->idx;\n    U32 startPosInSequence = seqPos->posInSequence;\n    U32 endPosInSequence = seqPos->posInSequence + (U32)blockSize;\n    size_t dictSize;\n    const BYTE* const istart = (const BYTE*)(src);\n    const BYTE* ip = istart;\n    const BYTE* iend = istart + blockSize;  /* May be adjusted if we decide to process fewer than blockSize bytes */\n    Repcodes_t updatedRepcodes;\n    U32 bytesAdjustment = 0;\n    U32 finalMatchSplit = 0;\n\n    /* TODO(embg) support fast parsing mode in noBlockDelim mode */\n    (void)externalRepSearch;\n\n    if (cctx->cdict) {\n        dictSize = cctx->cdict->dictContentSize;\n    } else if (cctx->prefixDict.dict) {\n        dictSize = cctx->prefixDict.dictSize;\n    } else {\n        dictSize = 0;\n    }\n    DEBUGLOG(5, \"ZSTD_transferSequences_noDelim: idx: %u PIS: %u blockSize: %zu\", idx, startPosInSequence, blockSize);\n    DEBUGLOG(5, \"Start seq: idx: %u (of: %u ml: %u ll: %u)\", idx, inSeqs[idx].offset, inSeqs[idx].matchLength, inSeqs[idx].litLength);\n    ZSTD_memcpy(updatedRepcodes.rep, cctx->blockState.prevCBlock->rep, sizeof(Repcodes_t));\n    while (endPosInSequence && idx < inSeqsSize && !finalMatchSplit) {\n        const ZSTD_Sequence currSeq = inSeqs[idx];\n        U32 litLength = currSeq.litLength;\n        U32 matchLength = currSeq.matchLength;\n        U32 const rawOffset = currSeq.offset;\n        U32 offBase;\n\n        /* Modify the sequence depending on where endPosInSequence lies */\n        if (endPosInSequence >= currSeq.litLength + currSeq.matchLength) {\n            if (startPosInSequence >= litLength) {\n                startPosInSequence -= litLength;\n                litLength = 0;\n                matchLength -= startPosInSequence;\n            } else {\n                litLength -= startPosInSequence;\n            }\n            /* Move to the next sequence */\n            endPosInSequence -= currSeq.litLength + currSeq.matchLength;\n            startPosInSequence = 0;\n        } else {\n            /* This is the final (partial) sequence we're adding from inSeqs, and endPosInSequence\n               does not reach the end of the match. So, we have to split the sequence */\n            DEBUGLOG(6, \"Require a split: diff: %u, idx: %u PIS: %u\",\n                     currSeq.litLength + currSeq.matchLength - endPosInSequence, idx, endPosInSequence);\n            if (endPosInSequence > litLength) {\n                U32 firstHalfMatchLength;\n                litLength = startPosInSequence >= litLength ? 0 : litLength - startPosInSequence;\n                firstHalfMatchLength = endPosInSequence - startPosInSequence - litLength;\n                if (matchLength > blockSize && firstHalfMatchLength >= cctx->appliedParams.cParams.minMatch) {\n                    /* Only ever split the match if it is larger than the block size */\n                    U32 secondHalfMatchLength = currSeq.matchLength + currSeq.litLength - endPosInSequence;\n                    if (secondHalfMatchLength < cctx->appliedParams.cParams.minMatch) {\n                        /* Move the endPosInSequence backward so that it creates match of minMatch length */\n                        endPosInSequence -= cctx->appliedParams.cParams.minMatch - secondHalfMatchLength;\n                        bytesAdjustment = cctx->appliedParams.cParams.minMatch - secondHalfMatchLength;\n                        firstHalfMatchLength -= bytesAdjustment;\n                    }\n                    matchLength = firstHalfMatchLength;\n                    /* Flag that we split the last match - after storing the sequence, exit the loop,\n                       but keep the value of endPosInSequence */\n                    finalMatchSplit = 1;\n                } else {\n                    /* Move the position in sequence backwards so that we don't split match, and break to store\n                     * the last literals. We use the original currSeq.litLength as a marker for where endPosInSequence\n                     * should go. We prefer to do this whenever it is not necessary to split the match, or if doing so\n                     * would cause the first half of the match to be too small\n                     */\n                    bytesAdjustment = endPosInSequence - currSeq.litLength;\n                    endPosInSequence = currSeq.litLength;\n                    break;\n                }\n            } else {\n                /* This sequence ends inside the literals, break to store the last literals */\n                break;\n            }\n        }\n        /* Check if this offset can be represented with a repcode */\n        {   U32 const ll0 = (litLength == 0);\n            offBase = ZSTD_finalizeOffBase(rawOffset, updatedRepcodes.rep, ll0);\n            ZSTD_updateRep(updatedRepcodes.rep, offBase, ll0);\n        }\n\n        if (cctx->appliedParams.validateSequences) {\n            seqPos->posInSrc += litLength + matchLength;\n            FORWARD_IF_ERROR(ZSTD_validateSequence(offBase, matchLength, cctx->appliedParams.cParams.minMatch, seqPos->posInSrc,\n                                                   cctx->appliedParams.cParams.windowLog, dictSize, ZSTD_hasExtSeqProd(&cctx->appliedParams)),\n                                                   \"Sequence validation failed\");\n        }\n        DEBUGLOG(6, \"Storing sequence: (of: %u, ml: %u, ll: %u)\", offBase, matchLength, litLength);\n        RETURN_ERROR_IF(idx - seqPos->idx >= cctx->seqStore.maxNbSeq, externalSequences_invalid,\n                        \"Not enough memory allocated. Try adjusting ZSTD_c_minMatch.\");\n        ZSTD_storeSeq(&cctx->seqStore, litLength, ip, iend, offBase, matchLength);\n        ip += matchLength + litLength;\n        if (!finalMatchSplit)\n            idx++; /* Next Sequence */\n    }\n    DEBUGLOG(5, \"Ending seq: idx: %u (of: %u ml: %u ll: %u)\", idx, inSeqs[idx].offset, inSeqs[idx].matchLength, inSeqs[idx].litLength);\n    assert(idx == inSeqsSize || endPosInSequence <= inSeqs[idx].litLength + inSeqs[idx].matchLength);\n    seqPos->idx = idx;\n    seqPos->posInSequence = endPosInSequence;\n    ZSTD_memcpy(cctx->blockState.nextCBlock->rep, updatedRepcodes.rep, sizeof(Repcodes_t));\n\n    iend -= bytesAdjustment;\n    if (ip != iend) {\n        /* Store any last literals */\n        U32 const lastLLSize = (U32)(iend - ip);\n        assert(ip <= iend);\n        DEBUGLOG(6, \"Storing last literals of size: %u\", lastLLSize);\n        ZSTD_storeLastLiterals(&cctx->seqStore, ip, lastLLSize);\n        seqPos->posInSrc += lastLLSize;\n    }\n\n    return (size_t)(iend-istart);\n}\n\n/* @seqPos represents a position within @inSeqs,\n * it is read and updated by this function,\n * once the goal to produce a block of size @blockSize is reached.\n * @return: nb of bytes consumed from @src, necessarily <= @blockSize.\n */\ntypedef size_t (*ZSTD_SequenceCopier_f)(ZSTD_CCtx* cctx,\n                                        ZSTD_SequencePosition* seqPos,\n                                  const ZSTD_Sequence* const inSeqs, size_t inSeqsSize,\n                                  const void* src, size_t blockSize,\n                                        ZSTD_ParamSwitch_e externalRepSearch);\n\nstatic ZSTD_SequenceCopier_f ZSTD_selectSequenceCopier(ZSTD_SequenceFormat_e mode)\n{\n    assert(ZSTD_cParam_withinBounds(ZSTD_c_blockDelimiters, (int)mode));\n    if (mode == ZSTD_sf_explicitBlockDelimiters) {\n        return ZSTD_transferSequences_wBlockDelim;\n    }\n    assert(mode == ZSTD_sf_noBlockDelimiters);\n    return ZSTD_transferSequences_noDelim;\n}\n\n/* Discover the size of next block by searching for the delimiter.\n * Note that a block delimiter **must** exist in this mode,\n * otherwise it's an input error.\n * The block size retrieved will be later compared to ensure it remains within bounds */\nstatic size_t\nblockSize_explicitDelimiter(const ZSTD_Sequence* inSeqs, size_t inSeqsSize, ZSTD_SequencePosition seqPos)\n{\n    int end = 0;\n    size_t blockSize = 0;\n    size_t spos = seqPos.idx;\n    DEBUGLOG(6, \"blockSize_explicitDelimiter : seq %zu / %zu\", spos, inSeqsSize);\n    assert(spos <= inSeqsSize);\n    while (spos < inSeqsSize) {\n        end = (inSeqs[spos].offset == 0);\n        blockSize += inSeqs[spos].litLength + inSeqs[spos].matchLength;\n        if (end) {\n            if (inSeqs[spos].matchLength != 0)\n                RETURN_ERROR(externalSequences_invalid, \"delimiter format error : both matchlength and offset must be == 0\");\n            break;\n        }\n        spos++;\n    }\n    if (!end)\n        RETURN_ERROR(externalSequences_invalid, \"Reached end of sequences without finding a block delimiter\");\n    return blockSize;\n}\n\nstatic size_t determine_blockSize(ZSTD_SequenceFormat_e mode,\n                           size_t blockSize, size_t remaining,\n                     const ZSTD_Sequence* inSeqs, size_t inSeqsSize,\n                           ZSTD_SequencePosition seqPos)\n{\n    DEBUGLOG(6, \"determine_blockSize : remainingSize = %zu\", remaining);\n    if (mode == ZSTD_sf_noBlockDelimiters) {\n        /* Note: more a \"target\" block size */\n        return MIN(remaining, blockSize);\n    }\n    assert(mode == ZSTD_sf_explicitBlockDelimiters);\n    {   size_t const explicitBlockSize = blockSize_explicitDelimiter(inSeqs, inSeqsSize, seqPos);\n        FORWARD_IF_ERROR(explicitBlockSize, \"Error while determining block size with explicit delimiters\");\n        if (explicitBlockSize > blockSize)\n            RETURN_ERROR(externalSequences_invalid, \"sequences incorrectly define a too large block\");\n        if (explicitBlockSize > remaining)\n            RETURN_ERROR(externalSequences_invalid, \"sequences define a frame longer than source\");\n        return explicitBlockSize;\n    }\n}\n\n/* Compress all provided sequences, block-by-block.\n *\n * Returns the cumulative size of all compressed blocks (including their headers),\n * otherwise a ZSTD error.\n */\nstatic size_t\nZSTD_compressSequences_internal(ZSTD_CCtx* cctx,\n                                void* dst, size_t dstCapacity,\n                          const ZSTD_Sequence* inSeqs, size_t inSeqsSize,\n                          const void* src, size_t srcSize)\n{\n    size_t cSize = 0;\n    size_t remaining = srcSize;\n    ZSTD_SequencePosition seqPos = {0, 0, 0};\n\n    const BYTE* ip = (BYTE const*)src;\n    BYTE* op = (BYTE*)dst;\n    ZSTD_SequenceCopier_f const sequenceCopier = ZSTD_selectSequenceCopier(cctx->appliedParams.blockDelimiters);\n\n    DEBUGLOG(4, \"ZSTD_compressSequences_internal srcSize: %zu, inSeqsSize: %zu\", srcSize, inSeqsSize);\n    /* Special case: empty frame */\n    if (remaining == 0) {\n        U32 const cBlockHeader24 = 1 /* last block */ + (((U32)bt_raw)<<1);\n        RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall, \"No room for empty frame block header\");\n        MEM_writeLE32(op, cBlockHeader24);\n        op += ZSTD_blockHeaderSize;\n        dstCapacity -= ZSTD_blockHeaderSize;\n        cSize += ZSTD_blockHeaderSize;\n    }\n\n    while (remaining) {\n        size_t compressedSeqsSize;\n        size_t cBlockSize;\n        size_t blockSize = determine_blockSize(cctx->appliedParams.blockDelimiters,\n                                        cctx->blockSizeMax, remaining,\n                                        inSeqs, inSeqsSize, seqPos);\n        U32 const lastBlock = (blockSize == remaining);\n        FORWARD_IF_ERROR(blockSize, \"Error while trying to determine block size\");\n        assert(blockSize <= remaining);\n        ZSTD_resetSeqStore(&cctx->seqStore);\n\n        blockSize = sequenceCopier(cctx,\n                                   &seqPos, inSeqs, inSeqsSize,\n                                   ip, blockSize,\n                                   cctx->appliedParams.searchForExternalRepcodes);\n        FORWARD_IF_ERROR(blockSize, \"Bad sequence copy\");\n\n        /* If blocks are too small, emit as a nocompress block */\n        /* TODO: See 3090. We reduced MIN_CBLOCK_SIZE from 3 to 2 so to compensate we are adding\n         * additional 1. We need to revisit and change this logic to be more consistent */\n        if (blockSize < MIN_CBLOCK_SIZE+ZSTD_blockHeaderSize+1+1) {\n            cBlockSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock);\n            FORWARD_IF_ERROR(cBlockSize, \"Nocompress block failed\");\n            DEBUGLOG(5, \"Block too small (%zu): data remains uncompressed: cSize=%zu\", blockSize, cBlockSize);\n            cSize += cBlockSize;\n            ip += blockSize;\n            op += cBlockSize;\n            remaining -= blockSize;\n            dstCapacity -= cBlockSize;\n            continue;\n        }\n\n        RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize, dstSize_tooSmall, \"not enough dstCapacity to write a new compressed block\");\n        compressedSeqsSize = ZSTD_entropyCompressSeqStore(&cctx->seqStore,\n                                &cctx->blockState.prevCBlock->entropy, &cctx->blockState.nextCBlock->entropy,\n                                &cctx->appliedParams,\n                                op + ZSTD_blockHeaderSize /* Leave space for block header */, dstCapacity - ZSTD_blockHeaderSize,\n                                blockSize,\n                                cctx->tmpWorkspace, cctx->tmpWkspSize /* statically allocated in resetCCtx */,\n                                cctx->bmi2);\n        FORWARD_IF_ERROR(compressedSeqsSize, \"Compressing sequences of block failed\");\n        DEBUGLOG(5, \"Compressed sequences size: %zu\", compressedSeqsSize);\n\n        if (!cctx->isFirstBlock &&\n            ZSTD_maybeRLE(&cctx->seqStore) &&\n            ZSTD_isRLE(ip, blockSize)) {\n            /* Note: don't emit the first block as RLE even if it qualifies because\n             * doing so will cause the decoder (cli <= v1.4.3 only) to throw an (invalid) error\n             * \"should consume all input error.\"\n             */\n            compressedSeqsSize = 1;\n        }\n\n        if (compressedSeqsSize == 0) {\n            /* ZSTD_noCompressBlock writes the block header as well */\n            cBlockSize = ZSTD_noCompressBlock(op, dstCapacity, ip, blockSize, lastBlock);\n            FORWARD_IF_ERROR(cBlockSize, \"ZSTD_noCompressBlock failed\");\n            DEBUGLOG(5, \"Writing out nocompress block, size: %zu\", cBlockSize);\n        } else if (compressedSeqsSize == 1) {\n            cBlockSize = ZSTD_rleCompressBlock(op, dstCapacity, *ip, blockSize, lastBlock);\n            FORWARD_IF_ERROR(cBlockSize, \"ZSTD_rleCompressBlock failed\");\n            DEBUGLOG(5, \"Writing out RLE block, size: %zu\", cBlockSize);\n        } else {\n            U32 cBlockHeader;\n            /* Error checking and repcodes update */\n            ZSTD_blockState_confirmRepcodesAndEntropyTables(&cctx->blockState);\n            if (cctx->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)\n                cctx->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;\n\n            /* Write block header into beginning of block*/\n            cBlockHeader = lastBlock + (((U32)bt_compressed)<<1) + (U32)(compressedSeqsSize << 3);\n            MEM_writeLE24(op, cBlockHeader);\n            cBlockSize = ZSTD_blockHeaderSize + compressedSeqsSize;\n            DEBUGLOG(5, \"Writing out compressed block, size: %zu\", cBlockSize);\n        }\n\n        cSize += cBlockSize;\n\n        if (lastBlock) {\n            break;\n        } else {\n            ip += blockSize;\n            op += cBlockSize;\n            remaining -= blockSize;\n            dstCapacity -= cBlockSize;\n            cctx->isFirstBlock = 0;\n        }\n        DEBUGLOG(5, \"cSize running total: %zu (remaining dstCapacity=%zu)\", cSize, dstCapacity);\n    }\n\n    DEBUGLOG(4, \"cSize final total: %zu\", cSize);\n    return cSize;\n}\n\nsize_t ZSTD_compressSequences(ZSTD_CCtx* cctx,\n                              void* dst, size_t dstCapacity,\n                              const ZSTD_Sequence* inSeqs, size_t inSeqsSize,\n                              const void* src, size_t srcSize)\n{\n    BYTE* op = (BYTE*)dst;\n    size_t cSize = 0;\n\n    /* Transparent initialization stage, same as compressStream2() */\n    DEBUGLOG(4, \"ZSTD_compressSequences (nbSeqs=%zu,dstCapacity=%zu)\", inSeqsSize, dstCapacity);\n    assert(cctx != NULL);\n    FORWARD_IF_ERROR(ZSTD_CCtx_init_compressStream2(cctx, ZSTD_e_end, srcSize), \"CCtx initialization failed\");\n\n    /* Begin writing output, starting with frame header */\n    {   size_t const frameHeaderSize = ZSTD_writeFrameHeader(op, dstCapacity,\n                    &cctx->appliedParams, srcSize, cctx->dictID);\n        op += frameHeaderSize;\n        assert(frameHeaderSize <= dstCapacity);\n        dstCapacity -= frameHeaderSize;\n        cSize += frameHeaderSize;\n    }\n    if (cctx->appliedParams.fParams.checksumFlag && srcSize) {\n        XXH64_update(&cctx->xxhState, src, srcSize);\n    }\n\n    /* Now generate compressed blocks */\n    {   size_t const cBlocksSize = ZSTD_compressSequences_internal(cctx,\n                                                           op, dstCapacity,\n                                                           inSeqs, inSeqsSize,\n                                                           src, srcSize);\n        FORWARD_IF_ERROR(cBlocksSize, \"Compressing blocks failed!\");\n        cSize += cBlocksSize;\n        assert(cBlocksSize <= dstCapacity);\n        dstCapacity -= cBlocksSize;\n    }\n\n    /* Complete with frame checksum, if needed */\n    if (cctx->appliedParams.fParams.checksumFlag) {\n        U32 const checksum = (U32) XXH64_digest(&cctx->xxhState);\n        RETURN_ERROR_IF(dstCapacity<4, dstSize_tooSmall, \"no room for checksum\");\n        DEBUGLOG(4, \"Write checksum : %08X\", (unsigned)checksum);\n        MEM_writeLE32((char*)dst + cSize, checksum);\n        cSize += 4;\n    }\n\n    DEBUGLOG(4, \"Final compressed size: %zu\", cSize);\n    return cSize;\n}\n\n\n#if defined(ZSTD_ARCH_X86_AVX2)\n\n#include   /* AVX2 intrinsics */\n\n/*\n * Convert 2 sequences per iteration, using AVX2 intrinsics:\n *   - offset -> offBase = offset + 2\n *   - litLength -> (U16) litLength\n *   - matchLength -> (U16)(matchLength - 3)\n *   - rep is ignored\n * Store only 8 bytes per SeqDef (offBase[4], litLength[2], mlBase[2]).\n *\n * At the end, instead of extracting two __m128i,\n * we use _mm256_permute4x64_epi64(..., 0xE8) to move lane2 into lane1,\n * then store the lower 16 bytes in one go.\n *\n * @returns 0 on succes, with no long length detected\n * @returns > 0 if there is one long length (> 65535),\n * indicating the position, and type.\n */\nsize_t convertSequences_noRepcodes(\n    SeqDef* dstSeqs,\n    const ZSTD_Sequence* inSeqs,\n    size_t nbSequences)\n{\n    /*\n     * addition:\n     *   For each 128-bit half: (offset+2, litLength+0, matchLength-3, rep+0)\n     */\n    const __m256i addition = _mm256_setr_epi32(\n        ZSTD_REP_NUM, 0, -MINMATCH, 0,    /* for sequence i */\n        ZSTD_REP_NUM, 0, -MINMATCH, 0     /* for sequence i+1 */\n    );\n\n    /* limit: check if there is a long length */\n    const __m256i limit = _mm256_set1_epi32(65535);\n\n    /*\n     * shuffle mask for byte-level rearrangement in each 128-bit half:\n     *\n     * Input layout (after addition) per 128-bit half:\n     *   [ offset+2 (4 bytes) | litLength (4 bytes) | matchLength (4 bytes) | rep (4 bytes) ]\n     * We only need:\n     *   offBase (4 bytes) = offset+2\n     *   litLength (2 bytes) = low 2 bytes of litLength\n     *   mlBase (2 bytes) = low 2 bytes of (matchLength)\n     * => Bytes [0..3, 4..5, 8..9], zero the rest.\n     */\n    const __m256i mask = _mm256_setr_epi8(\n        /* For the lower 128 bits => sequence i */\n         0, 1, 2, 3,       /* offset+2 */\n         4, 5,             /* litLength (16 bits) */\n         8, 9,             /* matchLength (16 bits) */\n         (BYTE)0x80, (BYTE)0x80, (BYTE)0x80, (BYTE)0x80,\n         (BYTE)0x80, (BYTE)0x80, (BYTE)0x80, (BYTE)0x80,\n\n        /* For the upper 128 bits => sequence i+1 */\n        16,17,18,19,       /* offset+2 */\n        20,21,             /* litLength */\n        24,25,             /* matchLength */\n        (BYTE)0x80, (BYTE)0x80, (BYTE)0x80, (BYTE)0x80,\n        (BYTE)0x80, (BYTE)0x80, (BYTE)0x80, (BYTE)0x80\n    );\n\n    /*\n     * Next, we'll use _mm256_permute4x64_epi64(vshf, 0xE8).\n     * Explanation of 0xE8 = 11101000b => [lane0, lane2, lane2, lane3].\n     * So the lower 128 bits become [lane0, lane2] => combining seq0 and seq1.\n     */\n#define PERM_LANE_0X_E8 0xE8  /* [0,2,2,3] in lane indices */\n\n    size_t longLen = 0, i = 0;\n\n    /* AVX permutation depends on the specific definition of target structures */\n    ZSTD_STATIC_ASSERT(sizeof(ZSTD_Sequence) == 16);\n    ZSTD_STATIC_ASSERT(offsetof(ZSTD_Sequence, offset) == 0);\n    ZSTD_STATIC_ASSERT(offsetof(ZSTD_Sequence, litLength) == 4);\n    ZSTD_STATIC_ASSERT(offsetof(ZSTD_Sequence, matchLength) == 8);\n    ZSTD_STATIC_ASSERT(sizeof(SeqDef) == 8);\n    ZSTD_STATIC_ASSERT(offsetof(SeqDef, offBase) == 0);\n    ZSTD_STATIC_ASSERT(offsetof(SeqDef, litLength) == 4);\n    ZSTD_STATIC_ASSERT(offsetof(SeqDef, mlBase) == 6);\n\n    /* Process 2 sequences per loop iteration */\n    for (; i + 1 < nbSequences; i += 2) {\n        /* Load 2 ZSTD_Sequence (32 bytes) */\n        __m256i vin  = _mm256_loadu_si256((const __m256i*)(const void*)&inSeqs[i]);\n\n        /* Add {2, 0, -3, 0} in each 128-bit half */\n        __m256i vadd = _mm256_add_epi32(vin, addition);\n\n        /* Check for long length */\n        __m256i ll_cmp  = _mm256_cmpgt_epi32(vadd, limit);  /* 0xFFFFFFFF for element > 65535 */\n        int ll_res  = _mm256_movemask_epi8(ll_cmp);\n\n        /* Shuffle bytes so each half gives us the 8 bytes we need */\n        __m256i vshf = _mm256_shuffle_epi8(vadd, mask);\n        /*\n         * Now:\n         *   Lane0 = seq0's 8 bytes\n         *   Lane1 = 0\n         *   Lane2 = seq1's 8 bytes\n         *   Lane3 = 0\n         */\n\n        /* Permute 64-bit lanes => move Lane2 down into Lane1. */\n        __m256i vperm = _mm256_permute4x64_epi64(vshf, PERM_LANE_0X_E8);\n        /*\n         * Now the lower 16 bytes (Lane0+Lane1) = [seq0, seq1].\n         * The upper 16 bytes are [Lane2, Lane3] = [seq1, 0], but we won't use them.\n         */\n\n        /* Store only the lower 16 bytes => 2 SeqDef (8 bytes each) */\n        _mm_storeu_si128((__m128i *)(void*)&dstSeqs[i], _mm256_castsi256_si128(vperm));\n        /*\n         * This writes out 16 bytes total:\n         *   - offset 0..7  => seq0 (offBase, litLength, mlBase)\n         *   - offset 8..15 => seq1 (offBase, litLength, mlBase)\n         */\n\n        /* check (unlikely) long lengths > 65535\n         * indices for lengths correspond to bits [4..7], [8..11], [20..23], [24..27]\n         * => combined mask = 0x0FF00FF0\n         */\n        if (UNLIKELY((ll_res & 0x0FF00FF0) != 0)) {\n            /* long length detected: let's figure out which one*/\n            if (inSeqs[i].matchLength > 65535+MINMATCH) {\n                assert(longLen == 0);\n                longLen = i + 1;\n            }\n            if (inSeqs[i].litLength > 65535) {\n                assert(longLen == 0);\n                longLen = i + nbSequences + 1;\n            }\n            if (inSeqs[i+1].matchLength > 65535+MINMATCH) {\n                assert(longLen == 0);\n                longLen = i + 1 + 1;\n            }\n            if (inSeqs[i+1].litLength > 65535) {\n                assert(longLen == 0);\n                longLen = i + 1 + nbSequences + 1;\n            }\n        }\n    }\n\n    /* Handle leftover if @nbSequences is odd */\n    if (i < nbSequences) {\n        /* process last sequence */\n        assert(i == nbSequences - 1);\n        dstSeqs[i].offBase = OFFSET_TO_OFFBASE(inSeqs[i].offset);\n        dstSeqs[i].litLength = (U16)inSeqs[i].litLength;\n        dstSeqs[i].mlBase = (U16)(inSeqs[i].matchLength - MINMATCH);\n        /* check (unlikely) long lengths > 65535 */\n        if (UNLIKELY(inSeqs[i].matchLength > 65535+MINMATCH)) {\n            assert(longLen == 0);\n            longLen = i + 1;\n        }\n        if (UNLIKELY(inSeqs[i].litLength > 65535)) {\n            assert(longLen == 0);\n            longLen = i + nbSequences + 1;\n        }\n    }\n\n    return longLen;\n}\n\n#elif defined (ZSTD_ARCH_RISCV_RVV)\n#include \n/*\n * Convert `vl` sequences per iteration, using RVV intrinsics:\n *   - offset -> offBase = offset + 2\n *   - litLength -> (U16) litLength\n *   - matchLength -> (U16)(matchLength - 3)\n *   - rep is ignored\n * Store only 8 bytes per SeqDef (offBase[4], litLength[2], mlBase[2]).\n *\n * @returns 0 on succes, with no long length detected\n * @returns > 0 if there is one long length (> 65535),\n * indicating the position, and type.\n */\nsize_t convertSequences_noRepcodes(SeqDef* dstSeqs, const ZSTD_Sequence* inSeqs, size_t nbSequences) {\n    size_t longLen = 0;\n    size_t vl = 0;\n    typedef uint32_t __attribute__((may_alias)) aliased_u32;\n    /* RVV depends on the specific definition of target structures */\n    ZSTD_STATIC_ASSERT(sizeof(ZSTD_Sequence) == 16);\n    ZSTD_STATIC_ASSERT(offsetof(ZSTD_Sequence, offset) == 0);\n    ZSTD_STATIC_ASSERT(offsetof(ZSTD_Sequence, litLength) == 4);\n    ZSTD_STATIC_ASSERT(offsetof(ZSTD_Sequence, matchLength) == 8);\n    ZSTD_STATIC_ASSERT(sizeof(SeqDef) == 8);\n    ZSTD_STATIC_ASSERT(offsetof(SeqDef, offBase) == 0);\n    ZSTD_STATIC_ASSERT(offsetof(SeqDef, litLength) == 4);\n    ZSTD_STATIC_ASSERT(offsetof(SeqDef, mlBase) == 6);\n    \n    for (size_t i = 0; i < nbSequences; i += vl) {\n\n        vl = __riscv_vsetvl_e32m2(nbSequences-i);       \n        {\n            // Loading structure member variables\n            vuint32m2x4_t v_tuple = __riscv_vlseg4e32_v_u32m2x4(\n                (const aliased_u32*)((const void*)&inSeqs[i]), \n                vl\n            );\n            vuint32m2_t v_offset = __riscv_vget_v_u32m2x4_u32m2(v_tuple, 0);\n            vuint32m2_t v_lit = __riscv_vget_v_u32m2x4_u32m2(v_tuple, 1);\n            vuint32m2_t v_match = __riscv_vget_v_u32m2x4_u32m2(v_tuple, 2);\n            // offset + ZSTD_REP_NUM\n            vuint32m2_t v_offBase = __riscv_vadd_vx_u32m2(v_offset, ZSTD_REP_NUM, vl); \n            // Check for integer overflow\n            // Cast to a 16-bit variable\n            vbool16_t lit_overflow = __riscv_vmsgtu_vx_u32m2_b16(v_lit, 65535, vl);\n            vuint16m1_t v_lit_clamped = __riscv_vncvt_x_x_w_u16m1(v_lit, vl);\n\n            vbool16_t ml_overflow = __riscv_vmsgtu_vx_u32m2_b16(v_match, 65535+MINMATCH, vl);\n            vuint16m1_t v_ml_clamped = __riscv_vncvt_x_x_w_u16m1(__riscv_vsub_vx_u32m2(v_match, MINMATCH, vl), vl);\n\n            // Pack two 16-bit fields into a 32-bit value (little-endian)\n            // The lower 16 bits contain litLength, and the upper 16 bits contain mlBase\n            vuint32m2_t v_lit_ml_combined = __riscv_vsll_vx_u32m2(\n                __riscv_vwcvtu_x_x_v_u32m2(v_ml_clamped, vl), // Convert matchLength to 32-bit\n                16, \n                vl\n            );\n            v_lit_ml_combined = __riscv_vor_vv_u32m2(\n                v_lit_ml_combined,\n                __riscv_vwcvtu_x_x_v_u32m2(v_lit_clamped, vl),\n                vl\n            );\n            {\n                // Create a vector of SeqDef structures\n                // Store the offBase, litLength, and mlBase in a vector of SeqDef\n                vuint32m2x2_t store_data = __riscv_vcreate_v_u32m2x2(\n                    v_offBase,          \n                    v_lit_ml_combined   \n                );\n                __riscv_vsseg2e32_v_u32m2x2(\n                    (aliased_u32*)((void*)&dstSeqs[i]), \n                    store_data,             \n                    vl                      \n                );\n            }\n            {\n                // Find the first index where an overflow occurs\n                int first_ml = __riscv_vfirst_m_b16(ml_overflow, vl);\n                int first_lit = __riscv_vfirst_m_b16(lit_overflow, vl);\n\n                if (UNLIKELY(first_ml != -1)) {\n                    assert(longLen == 0);\n                    longLen = i + first_ml + 1;\n                }\n                if (UNLIKELY(first_lit != -1)) {\n                    assert(longLen == 0);\n                    longLen = i + first_lit + 1 + nbSequences;\n                }\n            }\n        }\n    }\n    return longLen;\n}\n\n/* the vector implementation could also be ported to SSSE3,\n * but since this implementation is targeting modern systems (>= Sapphire Rapid),\n * it's not useful to develop and maintain code for older pre-AVX2 platforms */\n\n#elif defined(ZSTD_ARCH_ARM_SVE2)\n\n/*\n * Checks if any active element in a signed 8-bit integer vector is greater\n * than zero.\n *\n * @param g Governing predicate selecting active lanes.\n * @param a Input vector of signed 8-bit integers.\n *\n * @return True if any active element in `a` is > 0, false otherwise.\n */\nFORCE_INLINE_TEMPLATE int cmpgtz_any_s8(svbool_t g, svint8_t a)\n{\n    svbool_t ptest = svcmpgt_n_s8(g, a, 0);\n    return svptest_any(ptest, ptest);\n}\n\nsize_t convertSequences_noRepcodes(\n    SeqDef* dstSeqs,\n    const ZSTD_Sequence* inSeqs,\n    size_t nbSequences)\n{\n    /* Process the input with `8 * VL / element` lanes. */\n    const size_t lanes = 8 * svcntb() / sizeof(ZSTD_Sequence);\n    size_t longLen = 0;\n    size_t n = 0;\n\n    /* SVE permutation depends on the specific definition of target structures. */\n    ZSTD_STATIC_ASSERT(sizeof(ZSTD_Sequence) == 16);\n    ZSTD_STATIC_ASSERT(offsetof(ZSTD_Sequence, offset) == 0);\n    ZSTD_STATIC_ASSERT(offsetof(ZSTD_Sequence, litLength) == 4);\n    ZSTD_STATIC_ASSERT(offsetof(ZSTD_Sequence, matchLength) == 8);\n    ZSTD_STATIC_ASSERT(sizeof(SeqDef) == 8);\n    ZSTD_STATIC_ASSERT(offsetof(SeqDef, offBase) == 0);\n    ZSTD_STATIC_ASSERT(offsetof(SeqDef, litLength) == 4);\n    ZSTD_STATIC_ASSERT(offsetof(SeqDef, mlBase) == 6);\n\n    if (nbSequences >= lanes) {\n        const svbool_t ptrue = svptrue_b8();\n        /* 16-bit of {ZSTD_REP_NUM, 0, -MINMATCH, 0} extended to 32-bit lanes. */\n        const svuint32_t vaddition = svreinterpret_u32(\n            svunpklo_s32(svreinterpret_s16(svdup_n_u64(ZSTD_REP_NUM | (((U64)(U16)-MINMATCH) << 32)))));\n        /* For permutation of 16-bit units: 0, 1, 2, 4, 8, 9, 10, 12, ... */\n        const svuint16_t vmask = svreinterpret_u16(\n            svindex_u64(0x0004000200010000, 0x0008000800080008));\n        /* Upper bytes of `litLength` and `matchLength` will be packed into the\n         * middle of overflow check vector. */\n        const svbool_t pmid = svcmpne_n_u8(\n            ptrue, svreinterpret_u8(svdup_n_u64(0x0000FFFFFFFF0000)), 0);\n\n        do {\n            /* Load `lanes` number of `ZSTD_Sequence` into 8 vectors. */\n            const svuint32_t vin0 = svld1_vnum_u32(ptrue, &inSeqs[n].offset, 0);\n            const svuint32_t vin1 = svld1_vnum_u32(ptrue, &inSeqs[n].offset, 1);\n            const svuint32_t vin2 = svld1_vnum_u32(ptrue, &inSeqs[n].offset, 2);\n            const svuint32_t vin3 = svld1_vnum_u32(ptrue, &inSeqs[n].offset, 3);\n            const svuint32_t vin4 = svld1_vnum_u32(ptrue, &inSeqs[n].offset, 4);\n            const svuint32_t vin5 = svld1_vnum_u32(ptrue, &inSeqs[n].offset, 5);\n            const svuint32_t vin6 = svld1_vnum_u32(ptrue, &inSeqs[n].offset, 6);\n            const svuint32_t vin7 = svld1_vnum_u32(ptrue, &inSeqs[n].offset, 7);\n\n            /* Add {ZSTD_REP_NUM, 0, -MINMATCH, 0} to each structures. */\n            const svuint16x2_t vadd01 = svcreate2_u16(\n                svreinterpret_u16(svadd_u32_x(ptrue, vin0, vaddition)),\n                svreinterpret_u16(svadd_u32_x(ptrue, vin1, vaddition)));\n            const svuint16x2_t vadd23 = svcreate2_u16(\n                svreinterpret_u16(svadd_u32_x(ptrue, vin2, vaddition)),\n                svreinterpret_u16(svadd_u32_x(ptrue, vin3, vaddition)));\n            const svuint16x2_t vadd45 = svcreate2_u16(\n                svreinterpret_u16(svadd_u32_x(ptrue, vin4, vaddition)),\n                svreinterpret_u16(svadd_u32_x(ptrue, vin5, vaddition)));\n            const svuint16x2_t vadd67 = svcreate2_u16(\n                svreinterpret_u16(svadd_u32_x(ptrue, vin6, vaddition)),\n                svreinterpret_u16(svadd_u32_x(ptrue, vin7, vaddition)));\n\n            /* Shuffle and pack bytes so each vector contains SeqDef structures. */\n            const svuint16_t vout01 = svtbl2_u16(vadd01, vmask);\n            const svuint16_t vout23 = svtbl2_u16(vadd23, vmask);\n            const svuint16_t vout45 = svtbl2_u16(vadd45, vmask);\n            const svuint16_t vout67 = svtbl2_u16(vadd67, vmask);\n\n            /* Pack the upper 16-bits of 32-bit lanes for overflow check. */\n            const svuint16_t voverflow01 = svuzp2_u16(svget2_u16(vadd01, 0),\n                                                      svget2_u16(vadd01, 1));\n            const svuint16_t voverflow23 = svuzp2_u16(svget2_u16(vadd23, 0),\n                                                      svget2_u16(vadd23, 1));\n            const svuint16_t voverflow45 = svuzp2_u16(svget2_u16(vadd45, 0),\n                                                      svget2_u16(vadd45, 1));\n            const svuint16_t voverflow67 = svuzp2_u16(svget2_u16(vadd67, 0),\n                                                      svget2_u16(vadd67, 1));\n\n            /* We don't need the whole 16 bits of the overflow part. Only 1 bit\n             * is needed, so we pack tightly and merge multiple vectors to be\n             * able to use a single comparison to handle the overflow case.\n             * However, we also need to handle the possible negative values of\n             * matchLength parts, so we use signed comparison later. */\n            const svint8_t voverflow =\n                svmax_s8_x(pmid,\n                           svtrn1_s8(svreinterpret_s8(voverflow01),\n                                     svreinterpret_s8(voverflow23)),\n                           svtrn1_s8(svreinterpret_s8(voverflow45),\n                                     svreinterpret_s8(voverflow67)));\n\n            /* Store `lanes` number of `SeqDef` structures from 4 vectors. */\n            svst1_vnum_u32(ptrue, &dstSeqs[n].offBase, 0, svreinterpret_u32(vout01));\n            svst1_vnum_u32(ptrue, &dstSeqs[n].offBase, 1, svreinterpret_u32(vout23));\n            svst1_vnum_u32(ptrue, &dstSeqs[n].offBase, 2, svreinterpret_u32(vout45));\n            svst1_vnum_u32(ptrue, &dstSeqs[n].offBase, 3, svreinterpret_u32(vout67));\n\n            /* Check if any enabled lanes of the overflow vector is larger than\n             * zero, only one such may happen. */\n            if (UNLIKELY(cmpgtz_any_s8(pmid, voverflow))) {\n                /* Scalar search for long match is needed because we merged\n                 * multiple overflow bytes with `max`. */\n                size_t i;\n                for (i = n; i < n + lanes; i++) {\n                    if (inSeqs[i].matchLength > 65535 + MINMATCH) {\n                        assert(longLen == 0);\n                        longLen = i + 1;\n                    }\n                    if (inSeqs[i].litLength > 65535) {\n                        assert(longLen == 0);\n                        longLen = i + nbSequences + 1;\n                    }\n                }\n            }\n\n            n += lanes;\n        } while(n <= nbSequences - lanes);\n    }\n\n    /* Handle remaining elements. */\n    for (; n < nbSequences; n++) {\n        dstSeqs[n].offBase = OFFSET_TO_OFFBASE(inSeqs[n].offset);\n        dstSeqs[n].litLength = (U16)inSeqs[n].litLength;\n        dstSeqs[n].mlBase = (U16)(inSeqs[n].matchLength - MINMATCH);\n        /* Check for long length > 65535. */\n        if (UNLIKELY(inSeqs[n].matchLength > 65535 + MINMATCH)) {\n            assert(longLen == 0);\n            longLen = n + 1;\n        }\n        if (UNLIKELY(inSeqs[n].litLength > 65535)) {\n            assert(longLen == 0);\n            longLen = n + nbSequences + 1;\n        }\n    }\n    return longLen;\n}\n\n#elif defined(ZSTD_ARCH_ARM_NEON) && (defined(__aarch64__) || defined(_M_ARM64))\n\nsize_t convertSequences_noRepcodes(\n    SeqDef* dstSeqs,\n    const ZSTD_Sequence* inSeqs,\n    size_t nbSequences)\n{\n    size_t longLen = 0;\n    size_t n = 0;\n\n    /* Neon permutation depends on the specific definition of target structures. */\n    ZSTD_STATIC_ASSERT(sizeof(ZSTD_Sequence) == 16);\n    ZSTD_STATIC_ASSERT(offsetof(ZSTD_Sequence, offset) == 0);\n    ZSTD_STATIC_ASSERT(offsetof(ZSTD_Sequence, litLength) == 4);\n    ZSTD_STATIC_ASSERT(offsetof(ZSTD_Sequence, matchLength) == 8);\n    ZSTD_STATIC_ASSERT(sizeof(SeqDef) == 8);\n    ZSTD_STATIC_ASSERT(offsetof(SeqDef, offBase) == 0);\n    ZSTD_STATIC_ASSERT(offsetof(SeqDef, litLength) == 4);\n    ZSTD_STATIC_ASSERT(offsetof(SeqDef, mlBase) == 6);\n\n    if (nbSequences > 3) {\n        static const ZSTD_ALIGNED(16) U32 constAddition[4] = {\n            ZSTD_REP_NUM, 0, -MINMATCH, 0\n        };\n        static const ZSTD_ALIGNED(16) U8 constMask[16] = {\n            0, 1, 2, 3, 4, 5, 8, 9, 16, 17, 18, 19, 20, 21, 24, 25\n        };\n        static const ZSTD_ALIGNED(16) U16 constCounter[8] = {\n            1, 1, 1, 1, 2, 2, 2, 2\n        };\n\n        const uint32x4_t vaddition = vld1q_u32(constAddition);\n        const uint8x16_t vmask = vld1q_u8(constMask);\n        uint16x8_t vcounter = vld1q_u16(constCounter);\n        uint16x8_t vindex01 = vdupq_n_u16(0);\n        uint16x8_t vindex23 = vdupq_n_u16(0);\n\n        do {\n            /* Load 4 ZSTD_Sequence (64 bytes). */\n            const uint32x4_t vin0 = vld1q_u32(&inSeqs[n + 0].offset);\n            const uint32x4_t vin1 = vld1q_u32(&inSeqs[n + 1].offset);\n            const uint32x4_t vin2 = vld1q_u32(&inSeqs[n + 2].offset);\n            const uint32x4_t vin3 = vld1q_u32(&inSeqs[n + 3].offset);\n\n            /* Add {ZSTD_REP_NUM, 0, -MINMATCH, 0} to each vector. */\n            const uint8x16x2_t vadd01 = { {\n                vreinterpretq_u8_u32(vaddq_u32(vin0, vaddition)),\n                vreinterpretq_u8_u32(vaddq_u32(vin1, vaddition)),\n            } };\n            const uint8x16x2_t vadd23 = { {\n                vreinterpretq_u8_u32(vaddq_u32(vin2, vaddition)),\n                vreinterpretq_u8_u32(vaddq_u32(vin3, vaddition)),\n            } };\n\n            /* Shuffle and pack bytes so each vector contains 2 SeqDef structures. */\n            const uint8x16_t vout01 = vqtbl2q_u8(vadd01, vmask);\n            const uint8x16_t vout23 = vqtbl2q_u8(vadd23, vmask);\n\n            /* Pack the upper 16-bits of 32-bit lanes for overflow check. */\n            uint16x8_t voverflow01 = vuzp2q_u16(vreinterpretq_u16_u8(vadd01.val[0]),\n                                                vreinterpretq_u16_u8(vadd01.val[1]));\n            uint16x8_t voverflow23 = vuzp2q_u16(vreinterpretq_u16_u8(vadd23.val[0]),\n                                                vreinterpretq_u16_u8(vadd23.val[1]));\n\n            /* Store 4 SeqDef structures. */\n            vst1q_u32(&dstSeqs[n + 0].offBase, vreinterpretq_u32_u8(vout01));\n            vst1q_u32(&dstSeqs[n + 2].offBase, vreinterpretq_u32_u8(vout23));\n\n            /* Create masks in case of overflow. */\n            voverflow01 = vcgtzq_s16(vreinterpretq_s16_u16(voverflow01));\n            voverflow23 = vcgtzq_s16(vreinterpretq_s16_u16(voverflow23));\n\n            /* Update overflow indices. */\n            vindex01 = vbslq_u16(voverflow01, vcounter, vindex01);\n            vindex23 = vbslq_u16(voverflow23, vcounter, vindex23);\n\n            /* Update counter for overflow check. */\n            vcounter = vaddq_u16(vcounter, vdupq_n_u16(4));\n\n            n += 4;\n        } while(n < nbSequences - 3);\n\n        /* Fixup indices in the second vector, we saved an additional counter\n           in the loop to update the second overflow index, we need to add 2\n           here when the indices are not 0. */\n        {   uint16x8_t nonzero = vtstq_u16(vindex23, vindex23);\n            vindex23 = vsubq_u16(vindex23, nonzero);\n            vindex23 = vsubq_u16(vindex23, nonzero);\n        }\n\n        /* Merge indices in the vectors, maximums are needed. */\n        vindex01 = vmaxq_u16(vindex01, vindex23);\n        vindex01 = vmaxq_u16(vindex01, vextq_u16(vindex01, vindex01, 4));\n\n        /* Compute `longLen`, maximums of matchLength and litLength\n           with a preference on litLength. */\n        {   U64 maxLitMatchIndices = vgetq_lane_u64(vreinterpretq_u64_u16(vindex01), 0);\n            size_t maxLitIndex = (maxLitMatchIndices >> 16) & 0xFFFF;\n            size_t maxMatchIndex = (maxLitMatchIndices >> 32) & 0xFFFF;\n            longLen = maxLitIndex > maxMatchIndex ? maxLitIndex + nbSequences\n                                                  : maxMatchIndex;\n        }\n    }\n\n    /* Handle remaining elements. */\n    for (; n < nbSequences; n++) {\n        dstSeqs[n].offBase = OFFSET_TO_OFFBASE(inSeqs[n].offset);\n        dstSeqs[n].litLength = (U16)inSeqs[n].litLength;\n        dstSeqs[n].mlBase = (U16)(inSeqs[n].matchLength - MINMATCH);\n        /* Check for long length > 65535. */\n        if (UNLIKELY(inSeqs[n].matchLength > 65535 + MINMATCH)) {\n            assert(longLen == 0);\n            longLen = n + 1;\n        }\n        if (UNLIKELY(inSeqs[n].litLength > 65535)) {\n            assert(longLen == 0);\n            longLen = n + nbSequences + 1;\n        }\n    }\n    return longLen;\n}\n\n#else /* No vectorization. */\n\nsize_t convertSequences_noRepcodes(\n    SeqDef* dstSeqs,\n    const ZSTD_Sequence* inSeqs,\n    size_t nbSequences)\n{\n    size_t longLen = 0;\n    size_t n;\n    for (n=0; n 65535. */\n        if (UNLIKELY(inSeqs[n].matchLength > 65535+MINMATCH)) {\n            assert(longLen == 0);\n            longLen = n + 1;\n        }\n        if (UNLIKELY(inSeqs[n].litLength > 65535)) {\n            assert(longLen == 0);\n            longLen = n + nbSequences + 1;\n        }\n    }\n    return longLen;\n}\n\n#endif\n\n/*\n * Precondition: Sequences must end on an explicit Block Delimiter\n * @return: 0 on success, or an error code.\n * Note: Sequence validation functionality has been disabled (removed).\n * This is helpful to generate a lean main pipeline, improving performance.\n * It may be re-inserted later.\n */\nsize_t ZSTD_convertBlockSequences(ZSTD_CCtx* cctx,\n                const ZSTD_Sequence* const inSeqs, size_t nbSequences,\n                int repcodeResolution)\n{\n    Repcodes_t updatedRepcodes;\n    size_t seqNb = 0;\n\n    DEBUGLOG(5, \"ZSTD_convertBlockSequences (nbSequences = %zu)\", nbSequences);\n\n    RETURN_ERROR_IF(nbSequences >= cctx->seqStore.maxNbSeq, externalSequences_invalid,\n                    \"Not enough memory allocated. Try adjusting ZSTD_c_minMatch.\");\n\n    ZSTD_memcpy(updatedRepcodes.rep, cctx->blockState.prevCBlock->rep, sizeof(Repcodes_t));\n\n    /* check end condition */\n    assert(nbSequences >= 1);\n    assert(inSeqs[nbSequences-1].matchLength == 0);\n    assert(inSeqs[nbSequences-1].offset == 0);\n\n    /* Convert Sequences from public format to internal format */\n    if (!repcodeResolution) {\n        size_t const longl = convertSequences_noRepcodes(cctx->seqStore.sequencesStart, inSeqs, nbSequences-1);\n        cctx->seqStore.sequences = cctx->seqStore.sequencesStart + nbSequences-1;\n        if (longl) {\n            DEBUGLOG(5, \"long length\");\n            assert(cctx->seqStore.longLengthType == ZSTD_llt_none);\n            if (longl <= nbSequences-1) {\n                DEBUGLOG(5, \"long match length detected at pos %zu\", longl-1);\n                cctx->seqStore.longLengthType = ZSTD_llt_matchLength;\n                cctx->seqStore.longLengthPos = (U32)(longl-1);\n            } else {\n                DEBUGLOG(5, \"long literals length detected at pos %zu\", longl-nbSequences);\n                assert(longl <= 2* (nbSequences-1));\n                cctx->seqStore.longLengthType = ZSTD_llt_literalLength;\n                cctx->seqStore.longLengthPos = (U32)(longl-(nbSequences-1)-1);\n            }\n        }\n    } else {\n        for (seqNb = 0; seqNb < nbSequences - 1 ; seqNb++) {\n            U32 const litLength = inSeqs[seqNb].litLength;\n            U32 const matchLength = inSeqs[seqNb].matchLength;\n            U32 const ll0 = (litLength == 0);\n            U32 const offBase = ZSTD_finalizeOffBase(inSeqs[seqNb].offset, updatedRepcodes.rep, ll0);\n\n            DEBUGLOG(6, \"Storing sequence: (of: %u, ml: %u, ll: %u)\", offBase, matchLength, litLength);\n            ZSTD_storeSeqOnly(&cctx->seqStore, litLength, offBase, matchLength);\n            ZSTD_updateRep(updatedRepcodes.rep, offBase, ll0);\n        }\n    }\n\n    /* If we skipped repcode search while parsing, we need to update repcodes now */\n    if (!repcodeResolution && nbSequences > 1) {\n        U32* const rep = updatedRepcodes.rep;\n\n        if (nbSequences >= 4) {\n            U32 lastSeqIdx = (U32)nbSequences - 2; /* index of last full sequence */\n            rep[2] = inSeqs[lastSeqIdx - 2].offset;\n            rep[1] = inSeqs[lastSeqIdx - 1].offset;\n            rep[0] = inSeqs[lastSeqIdx].offset;\n        } else if (nbSequences == 3) {\n            rep[2] = rep[0];\n            rep[1] = inSeqs[0].offset;\n            rep[0] = inSeqs[1].offset;\n        } else {\n            assert(nbSequences == 2);\n            rep[2] = rep[1];\n            rep[1] = rep[0];\n            rep[0] = inSeqs[0].offset;\n        }\n    }\n\n    ZSTD_memcpy(cctx->blockState.nextCBlock->rep, updatedRepcodes.rep, sizeof(Repcodes_t));\n\n    return 0;\n}\n\n#if defined(ZSTD_ARCH_X86_AVX2)\n\nBlockSummary ZSTD_get1BlockSummary(const ZSTD_Sequence* seqs, size_t nbSeqs)\n{\n    size_t i;\n    __m256i const zeroVec = _mm256_setzero_si256();\n    __m256i sumVec = zeroVec;  /* accumulates match+lit in 32-bit lanes */\n    ZSTD_ALIGNED(32) U32 tmp[8];      /* temporary buffer for reduction */\n    size_t mSum = 0, lSum = 0;\n    ZSTD_STATIC_ASSERT(sizeof(ZSTD_Sequence) == 16);\n\n    /* Process 2 structs (32 bytes) at a time */\n    for (i = 0; i + 2 <= nbSeqs; i += 2) {\n        /* Load two consecutive ZSTD_Sequence (8×4 = 32 bytes) */\n        __m256i data     = _mm256_loadu_si256((const __m256i*)(const void*)&seqs[i]);\n        /* check end of block signal */\n        __m256i cmp      = _mm256_cmpeq_epi32(data, zeroVec);\n        int cmp_res      = _mm256_movemask_epi8(cmp);\n        /* indices for match lengths correspond to bits [8..11], [24..27]\n         * => combined mask = 0x0F000F00 */\n        ZSTD_STATIC_ASSERT(offsetof(ZSTD_Sequence, matchLength) == 8);\n        if (cmp_res & 0x0F000F00) break;\n        /* Accumulate in sumVec */\n        sumVec           = _mm256_add_epi32(sumVec, data);\n    }\n\n    /* Horizontal reduction */\n    _mm256_store_si256((__m256i*)tmp, sumVec);\n    lSum = tmp[1] + tmp[5];\n    mSum = tmp[2] + tmp[6];\n\n    /* Handle the leftover */\n    for (; i < nbSeqs; i++) {\n        lSum += seqs[i].litLength;\n        mSum += seqs[i].matchLength;\n        if (seqs[i].matchLength == 0) break; /* end of block */\n    }\n\n    if (i==nbSeqs) {\n        /* reaching end of sequences: end of block signal was not present */\n        BlockSummary bs;\n        bs.nbSequences = ERROR(externalSequences_invalid);\n        return bs;\n    }\n    {   BlockSummary bs;\n        bs.nbSequences = i+1;\n        bs.blockSize = lSum + mSum;\n        bs.litSize = lSum;\n        return bs;\n    }\n}\n\n#elif defined (ZSTD_ARCH_RISCV_RVV)\n\nBlockSummary ZSTD_get1BlockSummary(const ZSTD_Sequence* seqs, size_t nbSeqs)\n{\n    size_t totalMatchSize = 0;\n    size_t litSize = 0;\n    size_t i = 0;\n    int found_terminator = 0; \n    size_t vl_max = __riscv_vsetvlmax_e32m1();\n    typedef uint32_t __attribute__((may_alias)) aliased_u32;\n    vuint32m1_t v_lit_sum = __riscv_vmv_v_x_u32m1(0, vl_max);\n    vuint32m1_t v_match_sum = __riscv_vmv_v_x_u32m1(0, vl_max);\n\n    for (; i  < nbSeqs; ) {\n        size_t vl = __riscv_vsetvl_e32m2(nbSeqs - i); \n\n        vuint32m2x4_t v_tuple = __riscv_vlseg4e32_v_u32m2x4(\n            (const aliased_u32*)((const void*)&seqs[i]), \n            vl\n        );\n        vuint32m2_t v_lit = __riscv_vget_v_u32m2x4_u32m2(v_tuple, 1);\n        vuint32m2_t v_match = __riscv_vget_v_u32m2x4_u32m2(v_tuple, 2);\n\n        // Check if any element has a matchLength of 0\n        vbool16_t mask = __riscv_vmseq_vx_u32m2_b16(v_match, 0, vl);\n        int first_zero = __riscv_vfirst_m_b16(mask, vl);\n\n        if (first_zero >= 0) {\n            // Find the first zero byte and set the effective length to that index + 1 to \n            // recompute the cumulative vector length of literals and matches\n            vl = first_zero + 1;\n            \n            // recompute the cumulative vector length of literals and matches\n            v_lit_sum = __riscv_vredsum_vs_u32m2_u32m1(__riscv_vslidedown_vx_u32m2(v_lit, 0, vl), v_lit_sum, vl);\n            v_match_sum = __riscv_vredsum_vs_u32m2_u32m1(__riscv_vslidedown_vx_u32m2(v_match, 0, vl), v_match_sum, vl);\n\n            i += vl;\n            found_terminator = 1; \n            assert(seqs[i - 1].offset == 0);\n            break;\n        } else {\n\n            v_lit_sum = __riscv_vredsum_vs_u32m2_u32m1(v_lit, v_lit_sum, vl);\n            v_match_sum = __riscv_vredsum_vs_u32m2_u32m1(v_match, v_match_sum, vl);\n            i += vl;\n        }\n    }\n    litSize = __riscv_vmv_x_s_u32m1_u32(v_lit_sum);\n    totalMatchSize = __riscv_vmv_x_s_u32m1_u32(v_match_sum);\n\n    if (!found_terminator && i==nbSeqs) {\n        BlockSummary bs;\n        bs.nbSequences = ERROR(externalSequences_invalid);\n        return bs;\n    }\n    {   BlockSummary bs;\n        bs.nbSequences = i;\n        bs.blockSize = litSize + totalMatchSize;\n        bs.litSize = litSize;\n        return bs;\n    }\n}\n\n#else\n\n/*\n * The function assumes `litMatchLength` is a packed 64-bit value where the\n * lower 32 bits represent the match length. The check varies based on the\n * system's endianness:\n * - On little-endian systems, it verifies if the entire 64-bit value is at most\n * 0xFFFFFFFF, indicating the match length (lower 32 bits) is zero.\n * - On big-endian systems, it directly checks if the lower 32 bits are zero.\n *\n * @returns 1 if the match length is zero, 0 otherwise.\n */\nFORCE_INLINE_TEMPLATE int matchLengthHalfIsZero(U64 litMatchLength)\n{\n    if (MEM_isLittleEndian()) {\n        return litMatchLength <= 0xFFFFFFFFULL;\n    } else {\n        return (U32)litMatchLength == 0;\n    }\n}\n\nBlockSummary ZSTD_get1BlockSummary(const ZSTD_Sequence* seqs, size_t nbSeqs)\n{\n    /* Use multiple accumulators for efficient use of wide out-of-order machines. */\n    U64 litMatchSize0 = 0;\n    U64 litMatchSize1 = 0;\n    U64 litMatchSize2 = 0;\n    U64 litMatchSize3 = 0;\n    size_t n = 0;\n\n    ZSTD_STATIC_ASSERT(offsetof(ZSTD_Sequence, litLength) + 4 == offsetof(ZSTD_Sequence, matchLength));\n    ZSTD_STATIC_ASSERT(offsetof(ZSTD_Sequence, matchLength) + 4 == offsetof(ZSTD_Sequence, rep));\n    assert(seqs);\n\n    if (nbSeqs > 3) {\n        /* Process the input in 4 independent streams to reach high throughput. */\n        do {\n            /* Load `litLength` and `matchLength` as a packed `U64`. It is safe\n             * to use 64-bit unsigned arithmetic here because the sum of `litLength`\n             * and `matchLength` cannot exceed the block size, so the 32-bit\n             * subparts will never overflow. */\n            U64 litMatchLength = MEM_read64(&seqs[n].litLength);\n            litMatchSize0 += litMatchLength;\n            if (matchLengthHalfIsZero(litMatchLength)) {\n                assert(seqs[n].offset == 0);\n                goto _out;\n            }\n\n            litMatchLength = MEM_read64(&seqs[n + 1].litLength);\n            litMatchSize1 += litMatchLength;\n            if (matchLengthHalfIsZero(litMatchLength)) {\n                n += 1;\n                assert(seqs[n].offset == 0);\n                goto _out;\n            }\n\n            litMatchLength = MEM_read64(&seqs[n + 2].litLength);\n            litMatchSize2 += litMatchLength;\n            if (matchLengthHalfIsZero(litMatchLength)) {\n                n += 2;\n                assert(seqs[n].offset == 0);\n                goto _out;\n            }\n\n            litMatchLength = MEM_read64(&seqs[n + 3].litLength);\n            litMatchSize3 += litMatchLength;\n            if (matchLengthHalfIsZero(litMatchLength)) {\n                n += 3;\n                assert(seqs[n].offset == 0);\n                goto _out;\n            }\n\n            n += 4;\n        } while(n < nbSeqs - 3);\n    }\n\n    for (; n < nbSeqs; n++) {\n        U64 litMatchLength = MEM_read64(&seqs[n].litLength);\n        litMatchSize0 += litMatchLength;\n        if (matchLengthHalfIsZero(litMatchLength)) {\n            assert(seqs[n].offset == 0);\n            goto _out;\n        }\n    }\n    /* At this point n == nbSeqs, so no end terminator. */\n    {   BlockSummary bs;\n        bs.nbSequences = ERROR(externalSequences_invalid);\n        return bs;\n    }\n_out:\n    litMatchSize0 += litMatchSize1 + litMatchSize2 + litMatchSize3;\n    {   BlockSummary bs;\n        bs.nbSequences = n + 1;\n        if (MEM_isLittleEndian()) {\n            bs.litSize = (U32)litMatchSize0;\n            bs.blockSize = bs.litSize + (litMatchSize0 >> 32);\n        } else {\n            bs.litSize = litMatchSize0 >> 32;\n            bs.blockSize = bs.litSize + (U32)litMatchSize0;\n        }\n        return bs;\n    }\n}\n#endif\n\n\nstatic size_t\nZSTD_compressSequencesAndLiterals_internal(ZSTD_CCtx* cctx,\n                                void* dst, size_t dstCapacity,\n                          const ZSTD_Sequence* inSeqs, size_t nbSequences,\n                          const void* literals, size_t litSize, size_t srcSize)\n{\n    size_t remaining = srcSize;\n    size_t cSize = 0;\n    BYTE* op = (BYTE*)dst;\n    int const repcodeResolution = (cctx->appliedParams.searchForExternalRepcodes == ZSTD_ps_enable);\n    assert(cctx->appliedParams.searchForExternalRepcodes != ZSTD_ps_auto);\n\n    DEBUGLOG(4, \"ZSTD_compressSequencesAndLiterals_internal: nbSeqs=%zu, litSize=%zu\", nbSequences, litSize);\n    RETURN_ERROR_IF(nbSequences == 0, externalSequences_invalid, \"Requires at least 1 end-of-block\");\n\n    /* Special case: empty frame */\n    if ((nbSequences == 1) && (inSeqs[0].litLength == 0)) {\n        U32 const cBlockHeader24 = 1 /* last block */ + (((U32)bt_raw)<<1);\n        RETURN_ERROR_IF(dstCapacity<3, dstSize_tooSmall, \"No room for empty frame block header\");\n        MEM_writeLE24(op, cBlockHeader24);\n        op += ZSTD_blockHeaderSize;\n        dstCapacity -= ZSTD_blockHeaderSize;\n        cSize += ZSTD_blockHeaderSize;\n    }\n\n    while (nbSequences) {\n        size_t compressedSeqsSize, cBlockSize, conversionStatus;\n        BlockSummary const block = ZSTD_get1BlockSummary(inSeqs, nbSequences);\n        U32 const lastBlock = (block.nbSequences == nbSequences);\n        FORWARD_IF_ERROR(block.nbSequences, \"Error while trying to determine nb of sequences for a block\");\n        assert(block.nbSequences <= nbSequences);\n        RETURN_ERROR_IF(block.litSize > litSize, externalSequences_invalid, \"discrepancy: Sequences require more literals than present in buffer\");\n        ZSTD_resetSeqStore(&cctx->seqStore);\n\n        conversionStatus = ZSTD_convertBlockSequences(cctx,\n                            inSeqs, block.nbSequences,\n                            repcodeResolution);\n        FORWARD_IF_ERROR(conversionStatus, \"Bad sequence conversion\");\n        inSeqs += block.nbSequences;\n        nbSequences -= block.nbSequences;\n        remaining -= block.blockSize;\n\n        /* Note: when blockSize is very small, other variant send it uncompressed.\n         * Here, we still send the sequences, because we don't have the original source to send it uncompressed.\n         * One could imagine in theory reproducing the source from the sequences,\n         * but that's complex and costly memory intensive, and goes against the objectives of this variant. */\n\n        RETURN_ERROR_IF(dstCapacity < ZSTD_blockHeaderSize, dstSize_tooSmall, \"not enough dstCapacity to write a new compressed block\");\n\n        compressedSeqsSize = ZSTD_entropyCompressSeqStore_internal(\n                                op + ZSTD_blockHeaderSize /* Leave space for block header */, dstCapacity - ZSTD_blockHeaderSize,\n                                literals, block.litSize,\n                                &cctx->seqStore,\n                                &cctx->blockState.prevCBlock->entropy, &cctx->blockState.nextCBlock->entropy,\n                                &cctx->appliedParams,\n                                cctx->tmpWorkspace, cctx->tmpWkspSize /* statically allocated in resetCCtx */,\n                                cctx->bmi2);\n        FORWARD_IF_ERROR(compressedSeqsSize, \"Compressing sequences of block failed\");\n        /* note: the spec forbids for any compressed block to be larger than maximum block size */\n        if (compressedSeqsSize > cctx->blockSizeMax) compressedSeqsSize = 0;\n        DEBUGLOG(5, \"Compressed sequences size: %zu\", compressedSeqsSize);\n        litSize -= block.litSize;\n        literals = (const char*)literals + block.litSize;\n\n        /* Note: difficult to check source for RLE block when only Literals are provided,\n         * but it could be considered from analyzing the sequence directly */\n\n        if (compressedSeqsSize == 0) {\n            /* Sending uncompressed blocks is out of reach, because the source is not provided.\n             * In theory, one could use the sequences to regenerate the source, like a decompressor,\n             * but it's complex, and memory hungry, killing the purpose of this variant.\n             * Current outcome: generate an error code.\n             */\n            RETURN_ERROR(cannotProduce_uncompressedBlock, \"ZSTD_compressSequencesAndLiterals cannot generate an uncompressed block\");\n        } else {\n            U32 cBlockHeader;\n            assert(compressedSeqsSize > 1); /* no RLE */\n            /* Error checking and repcodes update */\n            ZSTD_blockState_confirmRepcodesAndEntropyTables(&cctx->blockState);\n            if (cctx->blockState.prevCBlock->entropy.fse.offcode_repeatMode == FSE_repeat_valid)\n                cctx->blockState.prevCBlock->entropy.fse.offcode_repeatMode = FSE_repeat_check;\n\n            /* Write block header into beginning of block*/\n            cBlockHeader = lastBlock + (((U32)bt_compressed)<<1) + (U32)(compressedSeqsSize << 3);\n            MEM_writeLE24(op, cBlockHeader);\n            cBlockSize = ZSTD_blockHeaderSize + compressedSeqsSize;\n            DEBUGLOG(5, \"Writing out compressed block, size: %zu\", cBlockSize);\n        }\n\n        cSize += cBlockSize;\n        op += cBlockSize;\n        dstCapacity -= cBlockSize;\n        cctx->isFirstBlock = 0;\n        DEBUGLOG(5, \"cSize running total: %zu (remaining dstCapacity=%zu)\", cSize, dstCapacity);\n\n        if (lastBlock) {\n            assert(nbSequences == 0);\n            break;\n        }\n    }\n\n    RETURN_ERROR_IF(litSize != 0, externalSequences_invalid, \"literals must be entirely and exactly consumed\");\n    RETURN_ERROR_IF(remaining != 0, externalSequences_invalid, \"Sequences must represent a total of exactly srcSize=%zu\", srcSize);\n    DEBUGLOG(4, \"cSize final total: %zu\", cSize);\n    return cSize;\n}\n\nsize_t\nZSTD_compressSequencesAndLiterals(ZSTD_CCtx* cctx,\n                    void* dst, size_t dstCapacity,\n                    const ZSTD_Sequence* inSeqs, size_t inSeqsSize,\n                    const void* literals, size_t litSize, size_t litCapacity,\n                    size_t decompressedSize)\n{\n    BYTE* op = (BYTE*)dst;\n    size_t cSize = 0;\n\n    /* Transparent initialization stage, same as compressStream2() */\n    DEBUGLOG(4, \"ZSTD_compressSequencesAndLiterals (dstCapacity=%zu)\", dstCapacity);\n    assert(cctx != NULL);\n    if (litCapacity < litSize) {\n        RETURN_ERROR(workSpace_tooSmall, \"literals buffer is not large enough: must be at least 8 bytes larger than litSize (risk of read out-of-bound)\");\n    }\n    FORWARD_IF_ERROR(ZSTD_CCtx_init_compressStream2(cctx, ZSTD_e_end, decompressedSize), \"CCtx initialization failed\");\n\n    if (cctx->appliedParams.blockDelimiters == ZSTD_sf_noBlockDelimiters) {\n        RETURN_ERROR(frameParameter_unsupported, \"This mode is only compatible with explicit delimiters\");\n    }\n    if (cctx->appliedParams.validateSequences) {\n        RETURN_ERROR(parameter_unsupported, \"This mode is not compatible with Sequence validation\");\n    }\n    if (cctx->appliedParams.fParams.checksumFlag) {\n        RETURN_ERROR(frameParameter_unsupported, \"this mode is not compatible with frame checksum\");\n    }\n\n    /* Begin writing output, starting with frame header */\n    {   size_t const frameHeaderSize = ZSTD_writeFrameHeader(op, dstCapacity,\n                    &cctx->appliedParams, decompressedSize, cctx->dictID);\n        op += frameHeaderSize;\n        assert(frameHeaderSize <= dstCapacity);\n        dstCapacity -= frameHeaderSize;\n        cSize += frameHeaderSize;\n    }\n\n    /* Now generate compressed blocks */\n    {   size_t const cBlocksSize = ZSTD_compressSequencesAndLiterals_internal(cctx,\n                                            op, dstCapacity,\n                                            inSeqs, inSeqsSize,\n                                            literals, litSize, decompressedSize);\n        FORWARD_IF_ERROR(cBlocksSize, \"Compressing blocks failed!\");\n        cSize += cBlocksSize;\n        assert(cBlocksSize <= dstCapacity);\n        dstCapacity -= cBlocksSize;\n    }\n\n    DEBUGLOG(4, \"Final compressed size: %zu\", cSize);\n    return cSize;\n}\n\n/*======   Finalize   ======*/\n\nstatic ZSTD_inBuffer inBuffer_forEndFlush(const ZSTD_CStream* zcs)\n{\n    const ZSTD_inBuffer nullInput = { NULL, 0, 0 };\n    const int stableInput = (zcs->appliedParams.inBufferMode == ZSTD_bm_stable);\n    return stableInput ? zcs->expectedInBuffer : nullInput;\n}\n\n/*! ZSTD_flushStream() :\n * @return : amount of data remaining to flush */\nsize_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)\n{\n    ZSTD_inBuffer input = inBuffer_forEndFlush(zcs);\n    input.size = input.pos; /* do not ingest more input during flush */\n    return ZSTD_compressStream2(zcs, output, &input, ZSTD_e_flush);\n}\n\nsize_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)\n{\n    ZSTD_inBuffer input = inBuffer_forEndFlush(zcs);\n    size_t const remainingToFlush = ZSTD_compressStream2(zcs, output, &input, ZSTD_e_end);\n    FORWARD_IF_ERROR(remainingToFlush , \"ZSTD_compressStream2(,,ZSTD_e_end) failed\");\n    if (zcs->appliedParams.nbWorkers > 0) return remainingToFlush;   /* minimal estimation */\n    /* single thread mode : attempt to calculate remaining to flush more precisely */\n    {   size_t const lastBlockSize = zcs->frameEnded ? 0 : ZSTD_BLOCKHEADERSIZE;\n        size_t const checksumSize = (size_t)(zcs->frameEnded ? 0 : zcs->appliedParams.fParams.checksumFlag * 4);\n        size_t const toFlush = remainingToFlush + lastBlockSize + checksumSize;\n        DEBUGLOG(4, \"ZSTD_endStream : remaining to flush : %u\", (unsigned)toFlush);\n        return toFlush;\n    }\n}\n\n\n/*-=====  Pre-defined compression levels  =====-*/\n#include \"clevels.h\"\n\nint ZSTD_maxCLevel(void) { return ZSTD_MAX_CLEVEL; }\nint ZSTD_minCLevel(void) { return (int)-ZSTD_TARGETLENGTH_MAX; }\nint ZSTD_defaultCLevel(void) { return ZSTD_CLEVEL_DEFAULT; }\n\nstatic ZSTD_compressionParameters ZSTD_dedicatedDictSearch_getCParams(int const compressionLevel, size_t const dictSize)\n{\n    ZSTD_compressionParameters cParams = ZSTD_getCParams_internal(compressionLevel, 0, dictSize, ZSTD_cpm_createCDict);\n    switch (cParams.strategy) {\n        case ZSTD_fast:\n        case ZSTD_dfast:\n            break;\n        case ZSTD_greedy:\n        case ZSTD_lazy:\n        case ZSTD_lazy2:\n            cParams.hashLog += ZSTD_LAZY_DDSS_BUCKET_LOG;\n            break;\n        case ZSTD_btlazy2:\n        case ZSTD_btopt:\n        case ZSTD_btultra:\n        case ZSTD_btultra2:\n            break;\n    }\n    return cParams;\n}\n\nstatic int ZSTD_dedicatedDictSearch_isSupported(\n        ZSTD_compressionParameters const* cParams)\n{\n    return (cParams->strategy >= ZSTD_greedy)\n        && (cParams->strategy <= ZSTD_lazy2)\n        && (cParams->hashLog > cParams->chainLog)\n        && (cParams->chainLog <= 24);\n}\n\n/**\n * Reverses the adjustment applied to cparams when enabling dedicated dict\n * search. This is used to recover the params set to be used in the working\n * context. (Otherwise, those tables would also grow.)\n */\nstatic void ZSTD_dedicatedDictSearch_revertCParams(\n        ZSTD_compressionParameters* cParams) {\n    switch (cParams->strategy) {\n        case ZSTD_fast:\n        case ZSTD_dfast:\n            break;\n        case ZSTD_greedy:\n        case ZSTD_lazy:\n        case ZSTD_lazy2:\n            cParams->hashLog -= ZSTD_LAZY_DDSS_BUCKET_LOG;\n            if (cParams->hashLog < ZSTD_HASHLOG_MIN) {\n                cParams->hashLog = ZSTD_HASHLOG_MIN;\n            }\n            break;\n        case ZSTD_btlazy2:\n        case ZSTD_btopt:\n        case ZSTD_btultra:\n        case ZSTD_btultra2:\n            break;\n    }\n}\n\nstatic U64 ZSTD_getCParamRowSize(U64 srcSizeHint, size_t dictSize, ZSTD_CParamMode_e mode)\n{\n    switch (mode) {\n    case ZSTD_cpm_unknown:\n    case ZSTD_cpm_noAttachDict:\n    case ZSTD_cpm_createCDict:\n        break;\n    case ZSTD_cpm_attachDict:\n        dictSize = 0;\n        break;\n    default:\n        assert(0);\n        break;\n    }\n    {   int const unknown = srcSizeHint == ZSTD_CONTENTSIZE_UNKNOWN;\n        size_t const addedSize = unknown && dictSize > 0 ? 500 : 0;\n        return unknown && dictSize == 0 ? ZSTD_CONTENTSIZE_UNKNOWN : srcSizeHint+dictSize+addedSize;\n    }\n}\n\n/*! ZSTD_getCParams_internal() :\n * @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize.\n *  Note: srcSizeHint 0 means 0, use ZSTD_CONTENTSIZE_UNKNOWN for unknown.\n *        Use dictSize == 0 for unknown or unused.\n *  Note: `mode` controls how we treat the `dictSize`. See docs for `ZSTD_CParamMode_e`. */\nstatic ZSTD_compressionParameters ZSTD_getCParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_CParamMode_e mode)\n{\n    U64 const rSize = ZSTD_getCParamRowSize(srcSizeHint, dictSize, mode);\n    U32 const tableID = (rSize <= 256 KB) + (rSize <= 128 KB) + (rSize <= 16 KB);\n    int row;\n    DEBUGLOG(5, \"ZSTD_getCParams_internal (cLevel=%i)\", compressionLevel);\n\n    /* row */\n    if (compressionLevel == 0) row = ZSTD_CLEVEL_DEFAULT;   /* 0 == default */\n    else if (compressionLevel < 0) row = 0;   /* entry 0 is baseline for fast mode */\n    else if (compressionLevel > ZSTD_MAX_CLEVEL) row = ZSTD_MAX_CLEVEL;\n    else row = compressionLevel;\n\n    {   ZSTD_compressionParameters cp = ZSTD_defaultCParameters[tableID][row];\n        DEBUGLOG(5, \"ZSTD_getCParams_internal selected tableID: %u row: %u strat: %u\", tableID, row, (U32)cp.strategy);\n        /* acceleration factor */\n        if (compressionLevel < 0) {\n            int const clampedCompressionLevel = MAX(ZSTD_minCLevel(), compressionLevel);\n            cp.targetLength = (unsigned)(-clampedCompressionLevel);\n        }\n        /* refine parameters based on srcSize & dictSize */\n        return ZSTD_adjustCParams_internal(cp, srcSizeHint, dictSize, mode, ZSTD_ps_auto);\n    }\n}\n\n/*! ZSTD_getCParams() :\n * @return ZSTD_compressionParameters structure for a selected compression level, srcSize and dictSize.\n *  Size values are optional, provide 0 if not known or unused */\nZSTD_compressionParameters ZSTD_getCParams(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize)\n{\n    if (srcSizeHint == 0) srcSizeHint = ZSTD_CONTENTSIZE_UNKNOWN;\n    return ZSTD_getCParams_internal(compressionLevel, srcSizeHint, dictSize, ZSTD_cpm_unknown);\n}\n\n/*! ZSTD_getParams() :\n *  same idea as ZSTD_getCParams()\n * @return a `ZSTD_parameters` structure (instead of `ZSTD_compressionParameters`).\n *  Fields of `ZSTD_frameParameters` are set to default values */\nstatic ZSTD_parameters\nZSTD_getParams_internal(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize, ZSTD_CParamMode_e mode)\n{\n    ZSTD_parameters params;\n    ZSTD_compressionParameters const cParams = ZSTD_getCParams_internal(compressionLevel, srcSizeHint, dictSize, mode);\n    DEBUGLOG(5, \"ZSTD_getParams (cLevel=%i)\", compressionLevel);\n    ZSTD_memset(¶ms, 0, sizeof(params));\n    params.cParams = cParams;\n    params.fParams.contentSizeFlag = 1;\n    return params;\n}\n\n/*! ZSTD_getParams() :\n *  same idea as ZSTD_getCParams()\n * @return a `ZSTD_parameters` structure (instead of `ZSTD_compressionParameters`).\n *  Fields of `ZSTD_frameParameters` are set to default values */\nZSTD_parameters ZSTD_getParams(int compressionLevel, unsigned long long srcSizeHint, size_t dictSize)\n{\n    if (srcSizeHint == 0) srcSizeHint = ZSTD_CONTENTSIZE_UNKNOWN;\n    return ZSTD_getParams_internal(compressionLevel, srcSizeHint, dictSize, ZSTD_cpm_unknown);\n}\n\nvoid ZSTD_registerSequenceProducer(\n    ZSTD_CCtx* zc,\n    void* extSeqProdState,\n    ZSTD_sequenceProducer_F extSeqProdFunc)\n{\n    assert(zc != NULL);\n    ZSTD_CCtxParams_registerSequenceProducer(\n        &zc->requestedParams, extSeqProdState, extSeqProdFunc\n    );\n}\n\nvoid ZSTD_CCtxParams_registerSequenceProducer(\n  ZSTD_CCtx_params* params,\n  void* extSeqProdState,\n  ZSTD_sequenceProducer_F extSeqProdFunc)\n{\n    assert(params != NULL);\n    if (extSeqProdFunc != NULL) {\n        params->extSeqProdFunc = extSeqProdFunc;\n        params->extSeqProdState = extSeqProdState;\n    } else {\n        params->extSeqProdFunc = NULL;\n        params->extSeqProdState = NULL;\n    }\n}\n"
  },
  {
    "path": "lib/compress/zstd_compress_internal.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/* This header contains definitions\n * that shall **only** be used by modules within lib/compress.\n */\n\n#ifndef ZSTD_COMPRESS_H\n#define ZSTD_COMPRESS_H\n\n/*-*************************************\n*  Dependencies\n***************************************/\n#include \"../common/zstd_internal.h\"\n#include \"zstd_cwksp.h\"\n#ifdef ZSTD_MULTITHREAD\n#  include \"zstdmt_compress.h\"\n#endif\n#include \"../common/bits.h\" /* ZSTD_highbit32, ZSTD_NbCommonBytes */\n#include \"zstd_preSplit.h\" /* ZSTD_SLIPBLOCK_WORKSPACESIZE */\n\n/*-*************************************\n*  Constants\n***************************************/\n#define kSearchStrength      8\n#define HASH_READ_SIZE       8\n#define ZSTD_DUBT_UNSORTED_MARK 1   /* For btlazy2 strategy, index ZSTD_DUBT_UNSORTED_MARK==1 means \"unsorted\".\n                                       It could be confused for a real successor at index \"1\", if sorted as larger than its predecessor.\n                                       It's not a big deal though : candidate will just be sorted again.\n                                       Additionally, candidate position 1 will be lost.\n                                       But candidate 1 cannot hide a large tree of candidates, so it's a minimal loss.\n                                       The benefit is that ZSTD_DUBT_UNSORTED_MARK cannot be mishandled after table reuse with a different strategy.\n                                       This constant is required by ZSTD_compressBlock_btlazy2() and ZSTD_reduceTable_internal() */\n\n\n/*-*************************************\n*  Context memory management\n***************************************/\ntypedef enum { ZSTDcs_created=0, ZSTDcs_init, ZSTDcs_ongoing, ZSTDcs_ending } ZSTD_compressionStage_e;\ntypedef enum { zcss_init=0, zcss_load, zcss_flush } ZSTD_cStreamStage;\n\ntypedef struct ZSTD_prefixDict_s {\n    const void* dict;\n    size_t dictSize;\n    ZSTD_dictContentType_e dictContentType;\n} ZSTD_prefixDict;\n\ntypedef struct {\n    void* dictBuffer;\n    void const* dict;\n    size_t dictSize;\n    ZSTD_dictContentType_e dictContentType;\n    ZSTD_CDict* cdict;\n} ZSTD_localDict;\n\ntypedef struct {\n    HUF_CElt CTable[HUF_CTABLE_SIZE_ST(255)];\n    HUF_repeat repeatMode;\n} ZSTD_hufCTables_t;\n\ntypedef struct {\n    FSE_CTable offcodeCTable[FSE_CTABLE_SIZE_U32(OffFSELog, MaxOff)];\n    FSE_CTable matchlengthCTable[FSE_CTABLE_SIZE_U32(MLFSELog, MaxML)];\n    FSE_CTable litlengthCTable[FSE_CTABLE_SIZE_U32(LLFSELog, MaxLL)];\n    FSE_repeat offcode_repeatMode;\n    FSE_repeat matchlength_repeatMode;\n    FSE_repeat litlength_repeatMode;\n} ZSTD_fseCTables_t;\n\ntypedef struct {\n    ZSTD_hufCTables_t huf;\n    ZSTD_fseCTables_t fse;\n} ZSTD_entropyCTables_t;\n\n/***********************************************\n*  Sequences *\n***********************************************/\ntypedef struct SeqDef_s {\n    U32 offBase;   /* offBase == Offset + ZSTD_REP_NUM, or repcode 1,2,3 */\n    U16 litLength;\n    U16 mlBase;    /* mlBase == matchLength - MINMATCH */\n} SeqDef;\n\n/* Controls whether seqStore has a single \"long\" litLength or matchLength. See SeqStore_t. */\ntypedef enum {\n    ZSTD_llt_none = 0,             /* no longLengthType */\n    ZSTD_llt_literalLength = 1,    /* represents a long literal */\n    ZSTD_llt_matchLength = 2       /* represents a long match */\n} ZSTD_longLengthType_e;\n\ntypedef struct {\n    SeqDef* sequencesStart;\n    SeqDef* sequences;      /* ptr to end of sequences */\n    BYTE*  litStart;\n    BYTE*  lit;             /* ptr to end of literals */\n    BYTE*  llCode;\n    BYTE*  mlCode;\n    BYTE*  ofCode;\n    size_t maxNbSeq;\n    size_t maxNbLit;\n\n    /* longLengthPos and longLengthType to allow us to represent either a single litLength or matchLength\n     * in the seqStore that has a value larger than U16 (if it exists). To do so, we increment\n     * the existing value of the litLength or matchLength by 0x10000.\n     */\n    ZSTD_longLengthType_e longLengthType;\n    U32                   longLengthPos;  /* Index of the sequence to apply long length modification to */\n} SeqStore_t;\n\ntypedef struct {\n    U32 litLength;\n    U32 matchLength;\n} ZSTD_SequenceLength;\n\n/**\n * Returns the ZSTD_SequenceLength for the given sequences. It handles the decoding of long sequences\n * indicated by longLengthPos and longLengthType, and adds MINMATCH back to matchLength.\n */\nMEM_STATIC ZSTD_SequenceLength ZSTD_getSequenceLength(SeqStore_t const* seqStore, SeqDef const* seq)\n{\n    ZSTD_SequenceLength seqLen;\n    seqLen.litLength = seq->litLength;\n    seqLen.matchLength = seq->mlBase + MINMATCH;\n    if (seqStore->longLengthPos == (U32)(seq - seqStore->sequencesStart)) {\n        if (seqStore->longLengthType == ZSTD_llt_literalLength) {\n            seqLen.litLength += 0x10000;\n        }\n        if (seqStore->longLengthType == ZSTD_llt_matchLength) {\n            seqLen.matchLength += 0x10000;\n        }\n    }\n    return seqLen;\n}\n\nconst SeqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx);   /* compress & dictBuilder */\nint ZSTD_seqToCodes(const SeqStore_t* seqStorePtr);   /* compress, dictBuilder, decodeCorpus (shouldn't get its definition from here) */\n\n\n/***********************************************\n*  Entropy buffer statistics structs and funcs *\n***********************************************/\n/** ZSTD_hufCTablesMetadata_t :\n *  Stores Literals Block Type for a super-block in hType, and\n *  huffman tree description in hufDesBuffer.\n *  hufDesSize refers to the size of huffman tree description in bytes.\n *  This metadata is populated in ZSTD_buildBlockEntropyStats_literals() */\ntypedef struct {\n    SymbolEncodingType_e hType;\n    BYTE hufDesBuffer[ZSTD_MAX_HUF_HEADER_SIZE];\n    size_t hufDesSize;\n} ZSTD_hufCTablesMetadata_t;\n\n/** ZSTD_fseCTablesMetadata_t :\n *  Stores symbol compression modes for a super-block in {ll, ol, ml}Type, and\n *  fse tables in fseTablesBuffer.\n *  fseTablesSize refers to the size of fse tables in bytes.\n *  This metadata is populated in ZSTD_buildBlockEntropyStats_sequences() */\ntypedef struct {\n    SymbolEncodingType_e llType;\n    SymbolEncodingType_e ofType;\n    SymbolEncodingType_e mlType;\n    BYTE fseTablesBuffer[ZSTD_MAX_FSE_HEADERS_SIZE];\n    size_t fseTablesSize;\n    size_t lastCountSize; /* This is to account for bug in 1.3.4. More detail in ZSTD_entropyCompressSeqStore_internal() */\n} ZSTD_fseCTablesMetadata_t;\n\ntypedef struct {\n    ZSTD_hufCTablesMetadata_t hufMetadata;\n    ZSTD_fseCTablesMetadata_t fseMetadata;\n} ZSTD_entropyCTablesMetadata_t;\n\n/** ZSTD_buildBlockEntropyStats() :\n *  Builds entropy for the block.\n *  @return : 0 on success or error code */\nsize_t ZSTD_buildBlockEntropyStats(\n                    const SeqStore_t* seqStorePtr,\n                    const ZSTD_entropyCTables_t* prevEntropy,\n                          ZSTD_entropyCTables_t* nextEntropy,\n                    const ZSTD_CCtx_params* cctxParams,\n                          ZSTD_entropyCTablesMetadata_t* entropyMetadata,\n                          void* workspace, size_t wkspSize);\n\n/*********************************\n*  Compression internals structs *\n*********************************/\n\ntypedef struct {\n    U32 off;            /* Offset sumtype code for the match, using ZSTD_storeSeq() format */\n    U32 len;            /* Raw length of match */\n} ZSTD_match_t;\n\ntypedef struct {\n    U32 offset;         /* Offset of sequence */\n    U32 litLength;      /* Length of literals prior to match */\n    U32 matchLength;    /* Raw length of match */\n} rawSeq;\n\ntypedef struct {\n  rawSeq* seq;          /* The start of the sequences */\n  size_t pos;           /* The index in seq where reading stopped. pos <= size. */\n  size_t posInSequence; /* The position within the sequence at seq[pos] where reading\n                           stopped. posInSequence <= seq[pos].litLength + seq[pos].matchLength */\n  size_t size;          /* The number of sequences. <= capacity. */\n  size_t capacity;      /* The capacity starting from `seq` pointer */\n} RawSeqStore_t;\n\nUNUSED_ATTR static const RawSeqStore_t kNullRawSeqStore = {NULL, 0, 0, 0, 0};\n\ntypedef struct {\n    int price;  /* price from beginning of segment to this position */\n    U32 off;    /* offset of previous match */\n    U32 mlen;   /* length of previous match */\n    U32 litlen; /* nb of literals since previous match */\n    U32 rep[ZSTD_REP_NUM];  /* offset history after previous match */\n} ZSTD_optimal_t;\n\ntypedef enum { zop_dynamic=0, zop_predef } ZSTD_OptPrice_e;\n\n#define ZSTD_OPT_SIZE (ZSTD_OPT_NUM+3)\ntypedef struct {\n    /* All tables are allocated inside cctx->workspace by ZSTD_resetCCtx_internal() */\n    unsigned* litFreq;           /* table of literals statistics, of size 256 */\n    unsigned* litLengthFreq;     /* table of litLength statistics, of size (MaxLL+1) */\n    unsigned* matchLengthFreq;   /* table of matchLength statistics, of size (MaxML+1) */\n    unsigned* offCodeFreq;       /* table of offCode statistics, of size (MaxOff+1) */\n    ZSTD_match_t* matchTable;    /* list of found matches, of size ZSTD_OPT_SIZE */\n    ZSTD_optimal_t* priceTable;  /* All positions tracked by optimal parser, of size ZSTD_OPT_SIZE */\n\n    U32  litSum;                 /* nb of literals */\n    U32  litLengthSum;           /* nb of litLength codes */\n    U32  matchLengthSum;         /* nb of matchLength codes */\n    U32  offCodeSum;             /* nb of offset codes */\n    U32  litSumBasePrice;        /* to compare to log2(litfreq) */\n    U32  litLengthSumBasePrice;  /* to compare to log2(llfreq)  */\n    U32  matchLengthSumBasePrice;/* to compare to log2(mlfreq)  */\n    U32  offCodeSumBasePrice;    /* to compare to log2(offreq)  */\n    ZSTD_OptPrice_e priceType;   /* prices can be determined dynamically, or follow a pre-defined cost structure */\n    const ZSTD_entropyCTables_t* symbolCosts;  /* pre-calculated dictionary statistics */\n    ZSTD_ParamSwitch_e literalCompressionMode;\n} optState_t;\n\ntypedef struct {\n  ZSTD_entropyCTables_t entropy;\n  U32 rep[ZSTD_REP_NUM];\n} ZSTD_compressedBlockState_t;\n\ntypedef struct {\n    BYTE const* nextSrc;       /* next block here to continue on current prefix */\n    BYTE const* base;          /* All regular indexes relative to this position */\n    BYTE const* dictBase;      /* extDict indexes relative to this position */\n    U32 dictLimit;             /* below that point, need extDict */\n    U32 lowLimit;              /* below that point, no more valid data */\n    U32 nbOverflowCorrections; /* Number of times overflow correction has run since\n                                * ZSTD_window_init(). Useful for debugging coredumps\n                                * and for ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY.\n                                */\n} ZSTD_window_t;\n\n#define ZSTD_WINDOW_START_INDEX 2\n\ntypedef struct ZSTD_MatchState_t ZSTD_MatchState_t;\n\n#define ZSTD_ROW_HASH_CACHE_SIZE 8       /* Size of prefetching hash cache for row-based matchfinder */\n\nstruct ZSTD_MatchState_t {\n    ZSTD_window_t window;   /* State for window round buffer management */\n    U32 loadedDictEnd;      /* index of end of dictionary, within context's referential.\n                             * When loadedDictEnd != 0, a dictionary is in use, and still valid.\n                             * This relies on a mechanism to set loadedDictEnd=0 when dictionary is no longer within distance.\n                             * Such mechanism is provided within ZSTD_window_enforceMaxDist() and ZSTD_checkDictValidity().\n                             * When dict referential is copied into active context (i.e. not attached),\n                             * loadedDictEnd == dictSize, since referential starts from zero.\n                             */\n    U32 nextToUpdate;       /* index from which to continue table update */\n    U32 hashLog3;           /* dispatch table for matches of len==3 : larger == faster, more memory */\n\n    U32 rowHashLog;                          /* For row-based matchfinder: Hashlog based on nb of rows in the hashTable.*/\n    BYTE* tagTable;                          /* For row-based matchFinder: A row-based table containing the hashes and head index. */\n    U32 hashCache[ZSTD_ROW_HASH_CACHE_SIZE]; /* For row-based matchFinder: a cache of hashes to improve speed */\n    U64 hashSalt;                            /* For row-based matchFinder: salts the hash for reuse of tag table */\n    U32 hashSaltEntropy;                     /* For row-based matchFinder: collects entropy for salt generation */\n\n    U32* hashTable;\n    U32* hashTable3;\n    U32* chainTable;\n\n    int forceNonContiguous; /* Non-zero if we should force non-contiguous load for the next window update. */\n\n    int dedicatedDictSearch;  /* Indicates whether this matchState is using the\n                               * dedicated dictionary search structure.\n                               */\n    optState_t opt;         /* optimal parser state */\n    const ZSTD_MatchState_t* dictMatchState;\n    ZSTD_compressionParameters cParams;\n    const RawSeqStore_t* ldmSeqStore;\n\n    /* Controls prefetching in some dictMatchState matchfinders.\n     * This behavior is controlled from the cctx ms.\n     * This parameter has no effect in the cdict ms. */\n    int prefetchCDictTables;\n\n    /* When == 0, lazy match finders insert every position.\n     * When != 0, lazy match finders only insert positions they search.\n     * This allows them to skip much faster over incompressible data,\n     * at a small cost to compression ratio.\n     */\n    int lazySkipping;\n};\n\ntypedef struct {\n    ZSTD_compressedBlockState_t* prevCBlock;\n    ZSTD_compressedBlockState_t* nextCBlock;\n    ZSTD_MatchState_t matchState;\n} ZSTD_blockState_t;\n\ntypedef struct {\n    U32 offset;\n    U32 checksum;\n} ldmEntry_t;\n\ntypedef struct {\n    BYTE const* split;\n    U32 hash;\n    U32 checksum;\n    ldmEntry_t* bucket;\n} ldmMatchCandidate_t;\n\n#define LDM_BATCH_SIZE 64\n\ntypedef struct {\n    ZSTD_window_t window;   /* State for the window round buffer management */\n    ldmEntry_t* hashTable;\n    U32 loadedDictEnd;\n    BYTE* bucketOffsets;    /* Next position in bucket to insert entry */\n    size_t splitIndices[LDM_BATCH_SIZE];\n    ldmMatchCandidate_t matchCandidates[LDM_BATCH_SIZE];\n} ldmState_t;\n\ntypedef struct {\n    ZSTD_ParamSwitch_e enableLdm; /* ZSTD_ps_enable to enable LDM. ZSTD_ps_auto by default */\n    U32 hashLog;            /* Log size of hashTable */\n    U32 bucketSizeLog;      /* Log bucket size for collision resolution, at most 8 */\n    U32 minMatchLength;     /* Minimum match length */\n    U32 hashRateLog;       /* Log number of entries to skip */\n    U32 windowLog;          /* Window log for the LDM */\n} ldmParams_t;\n\ntypedef struct {\n    int collectSequences;\n    ZSTD_Sequence* seqStart;\n    size_t seqIndex;\n    size_t maxSequences;\n} SeqCollector;\n\nstruct ZSTD_CCtx_params_s {\n    ZSTD_format_e format;\n    ZSTD_compressionParameters cParams;\n    ZSTD_frameParameters fParams;\n\n    int compressionLevel;\n    int forceWindow;           /* force back-references to respect limit of\n                                * 1< 63) ? ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength];\n}\n\n/* ZSTD_MLcode() :\n * note : mlBase = matchLength - MINMATCH;\n *        because it's the format it's stored in seqStore->sequences */\nMEM_STATIC U32 ZSTD_MLcode(U32 mlBase)\n{\n    static const BYTE ML_Code[128] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,\n                                      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,\n                                      32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37,\n                                      38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 39, 39, 39,\n                                      40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,\n                                      41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,\n                                      42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,\n                                      42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 };\n    static const U32 ML_deltaCode = 36;\n    return (mlBase > 127) ? ZSTD_highbit32(mlBase) + ML_deltaCode : ML_Code[mlBase];\n}\n\n/* ZSTD_cParam_withinBounds:\n * @return 1 if value is within cParam bounds,\n * 0 otherwise */\nMEM_STATIC int ZSTD_cParam_withinBounds(ZSTD_cParameter cParam, int value)\n{\n    ZSTD_bounds const bounds = ZSTD_cParam_getBounds(cParam);\n    if (ZSTD_isError(bounds.error)) return 0;\n    if (value < bounds.lowerBound) return 0;\n    if (value > bounds.upperBound) return 0;\n    return 1;\n}\n\n/* ZSTD_selectAddr:\n * @return index >= lowLimit ? candidate : backup,\n * tries to force branchless codegen. */\nMEM_STATIC const BYTE*\nZSTD_selectAddr(U32 index, U32 lowLimit, const BYTE* candidate, const BYTE* backup)\n{\n#if defined(__GNUC__) && defined(__x86_64__)\n    __asm__ (\n        \"cmp %1, %2\\n\"\n        \"cmova %3, %0\\n\"\n        : \"+r\"(candidate)\n        : \"r\"(index), \"r\"(lowLimit), \"r\"(backup)\n        );\n    return candidate;\n#else\n    return index >= lowLimit ? candidate : backup;\n#endif\n}\n\n/* ZSTD_noCompressBlock() :\n * Writes uncompressed block to dst buffer from given src.\n * Returns the size of the block */\nMEM_STATIC size_t\nZSTD_noCompressBlock(void* dst, size_t dstCapacity, const void* src, size_t srcSize, U32 lastBlock)\n{\n    U32 const cBlockHeader24 = lastBlock + (((U32)bt_raw)<<1) + (U32)(srcSize << 3);\n    DEBUGLOG(5, \"ZSTD_noCompressBlock (srcSize=%zu, dstCapacity=%zu)\", srcSize, dstCapacity);\n    RETURN_ERROR_IF(srcSize + ZSTD_blockHeaderSize > dstCapacity,\n                    dstSize_tooSmall, \"dst buf too small for uncompressed block\");\n    MEM_writeLE24(dst, cBlockHeader24);\n    ZSTD_memcpy((BYTE*)dst + ZSTD_blockHeaderSize, src, srcSize);\n    return ZSTD_blockHeaderSize + srcSize;\n}\n\nMEM_STATIC size_t\nZSTD_rleCompressBlock(void* dst, size_t dstCapacity, BYTE src, size_t srcSize, U32 lastBlock)\n{\n    BYTE* const op = (BYTE*)dst;\n    U32 const cBlockHeader = lastBlock + (((U32)bt_rle)<<1) + (U32)(srcSize << 3);\n    RETURN_ERROR_IF(dstCapacity < 4, dstSize_tooSmall, \"\");\n    MEM_writeLE24(op, cBlockHeader);\n    op[3] = src;\n    return 4;\n}\n\n\n/* ZSTD_minGain() :\n * minimum compression required\n * to generate a compress block or a compressed literals section.\n * note : use same formula for both situations */\nMEM_STATIC size_t ZSTD_minGain(size_t srcSize, ZSTD_strategy strat)\n{\n    U32 const minlog = (strat>=ZSTD_btultra) ? (U32)(strat) - 1 : 6;\n    ZSTD_STATIC_ASSERT(ZSTD_btultra == 8);\n    assert(ZSTD_cParam_withinBounds(ZSTD_c_strategy, (int)strat));\n    return (srcSize >> minlog) + 2;\n}\n\nMEM_STATIC int ZSTD_literalsCompressionIsDisabled(const ZSTD_CCtx_params* cctxParams)\n{\n    switch (cctxParams->literalCompressionMode) {\n    case ZSTD_ps_enable:\n        return 0;\n    case ZSTD_ps_disable:\n        return 1;\n    default:\n        assert(0 /* impossible: pre-validated */);\n        ZSTD_FALLTHROUGH;\n    case ZSTD_ps_auto:\n        return (cctxParams->cParams.strategy == ZSTD_fast) && (cctxParams->cParams.targetLength > 0);\n    }\n}\n\n/*! ZSTD_safecopyLiterals() :\n *  memcpy() function that won't read beyond more than WILDCOPY_OVERLENGTH bytes past ilimit_w.\n *  Only called when the sequence ends past ilimit_w, so it only needs to be optimized for single\n *  large copies.\n */\nstatic void\nZSTD_safecopyLiterals(BYTE* op, BYTE const* ip, BYTE const* const iend, BYTE const* ilimit_w)\n{\n    assert(iend > ilimit_w);\n    if (ip <= ilimit_w) {\n        ZSTD_wildcopy(op, ip, (size_t)(ilimit_w - ip), ZSTD_no_overlap);\n        op += ilimit_w - ip;\n        ip = ilimit_w;\n    }\n    while (ip < iend) *op++ = *ip++;\n}\n\n\n#define REPCODE1_TO_OFFBASE REPCODE_TO_OFFBASE(1)\n#define REPCODE2_TO_OFFBASE REPCODE_TO_OFFBASE(2)\n#define REPCODE3_TO_OFFBASE REPCODE_TO_OFFBASE(3)\n#define REPCODE_TO_OFFBASE(r) (assert((r)>=1), assert((r)<=ZSTD_REP_NUM), (r)) /* accepts IDs 1,2,3 */\n#define OFFSET_TO_OFFBASE(o)  (assert((o)>0), o + ZSTD_REP_NUM)\n#define OFFBASE_IS_OFFSET(o)  ((o) > ZSTD_REP_NUM)\n#define OFFBASE_IS_REPCODE(o) ( 1 <= (o) && (o) <= ZSTD_REP_NUM)\n#define OFFBASE_TO_OFFSET(o)  (assert(OFFBASE_IS_OFFSET(o)), (o) - ZSTD_REP_NUM)\n#define OFFBASE_TO_REPCODE(o) (assert(OFFBASE_IS_REPCODE(o)), (o))  /* returns ID 1,2,3 */\n\n/*! ZSTD_storeSeqOnly() :\n *  Store a sequence (litlen, litPtr, offBase and matchLength) into SeqStore_t.\n *  Literals themselves are not copied, but @litPtr is updated.\n *  @offBase : Users should employ macros REPCODE_TO_OFFBASE() and OFFSET_TO_OFFBASE().\n *  @matchLength : must be >= MINMATCH\n*/\nHINT_INLINE UNUSED_ATTR void\nZSTD_storeSeqOnly(SeqStore_t* seqStorePtr,\n              size_t litLength,\n              U32 offBase,\n              size_t matchLength)\n{\n    assert((size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart) < seqStorePtr->maxNbSeq);\n\n    /* literal Length */\n    assert(litLength <= ZSTD_BLOCKSIZE_MAX);\n    if (UNLIKELY(litLength>0xFFFF)) {\n        assert(seqStorePtr->longLengthType == ZSTD_llt_none); /* there can only be a single long length */\n        seqStorePtr->longLengthType = ZSTD_llt_literalLength;\n        seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);\n    }\n    seqStorePtr->sequences[0].litLength = (U16)litLength;\n\n    /* match offset */\n    seqStorePtr->sequences[0].offBase = offBase;\n\n    /* match Length */\n    assert(matchLength <= ZSTD_BLOCKSIZE_MAX);\n    assert(matchLength >= MINMATCH);\n    {   size_t const mlBase = matchLength - MINMATCH;\n        if (UNLIKELY(mlBase>0xFFFF)) {\n            assert(seqStorePtr->longLengthType == ZSTD_llt_none); /* there can only be a single long length */\n            seqStorePtr->longLengthType = ZSTD_llt_matchLength;\n            seqStorePtr->longLengthPos = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);\n        }\n        seqStorePtr->sequences[0].mlBase = (U16)mlBase;\n    }\n\n    seqStorePtr->sequences++;\n}\n\n/*! ZSTD_storeSeq() :\n *  Store a sequence (litlen, litPtr, offBase and matchLength) into SeqStore_t.\n *  @offBase : Users should employ macros REPCODE_TO_OFFBASE() and OFFSET_TO_OFFBASE().\n *  @matchLength : must be >= MINMATCH\n *  Allowed to over-read literals up to litLimit.\n*/\nHINT_INLINE UNUSED_ATTR void\nZSTD_storeSeq(SeqStore_t* seqStorePtr,\n              size_t litLength, const BYTE* literals, const BYTE* litLimit,\n              U32 offBase,\n              size_t matchLength)\n{\n    BYTE const* const litLimit_w = litLimit - WILDCOPY_OVERLENGTH;\n    BYTE const* const litEnd = literals + litLength;\n#if defined(DEBUGLEVEL) && (DEBUGLEVEL >= 6)\n    static const BYTE* g_start = NULL;\n    if (g_start==NULL) g_start = (const BYTE*)literals;  /* note : index only works for compression within a single segment */\n    {   U32 const pos = (U32)((const BYTE*)literals - g_start);\n        DEBUGLOG(6, \"Cpos%7u :%3u literals, match%4u bytes at offBase%7u\",\n               pos, (U32)litLength, (U32)matchLength, (U32)offBase);\n    }\n#endif\n    assert((size_t)(seqStorePtr->sequences - seqStorePtr->sequencesStart) < seqStorePtr->maxNbSeq);\n    /* copy Literals */\n    assert(seqStorePtr->maxNbLit <= 128 KB);\n    assert(seqStorePtr->lit + litLength <= seqStorePtr->litStart + seqStorePtr->maxNbLit);\n    assert(literals + litLength <= litLimit);\n    if (litEnd <= litLimit_w) {\n        /* Common case we can use wildcopy.\n         * First copy 16 bytes, because literals are likely short.\n         */\n        ZSTD_STATIC_ASSERT(WILDCOPY_OVERLENGTH >= 16);\n        ZSTD_copy16(seqStorePtr->lit, literals);\n        if (litLength > 16) {\n            ZSTD_wildcopy(seqStorePtr->lit+16, literals+16, litLength-16, ZSTD_no_overlap);\n        }\n    } else {\n        ZSTD_safecopyLiterals(seqStorePtr->lit, literals, litEnd, litLimit_w);\n    }\n    seqStorePtr->lit += litLength;\n\n    ZSTD_storeSeqOnly(seqStorePtr, litLength, offBase, matchLength);\n}\n\n/* ZSTD_updateRep() :\n * updates in-place @rep (array of repeat offsets)\n * @offBase : sum-type, using numeric representation of ZSTD_storeSeq()\n */\nMEM_STATIC void\nZSTD_updateRep(U32 rep[ZSTD_REP_NUM], U32 const offBase, U32 const ll0)\n{\n    if (OFFBASE_IS_OFFSET(offBase)) {  /* full offset */\n        rep[2] = rep[1];\n        rep[1] = rep[0];\n        rep[0] = OFFBASE_TO_OFFSET(offBase);\n    } else {   /* repcode */\n        U32 const repCode = OFFBASE_TO_REPCODE(offBase) - 1 + ll0;\n        if (repCode > 0) {  /* note : if repCode==0, no change */\n            U32 const currentOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];\n            rep[2] = (repCode >= 2) ? rep[1] : rep[2];\n            rep[1] = rep[0];\n            rep[0] = currentOffset;\n        } else {   /* repCode == 0 */\n            /* nothing to do */\n        }\n    }\n}\n\ntypedef struct repcodes_s {\n    U32 rep[3];\n} Repcodes_t;\n\nMEM_STATIC Repcodes_t\nZSTD_newRep(U32 const rep[ZSTD_REP_NUM], U32 const offBase, U32 const ll0)\n{\n    Repcodes_t newReps;\n    ZSTD_memcpy(&newReps, rep, sizeof(newReps));\n    ZSTD_updateRep(newReps.rep, offBase, ll0);\n    return newReps;\n}\n\n\n/*-*************************************\n*  Match length counter\n***************************************/\nMEM_STATIC size_t ZSTD_count(const BYTE* pIn, const BYTE* pMatch, const BYTE* const pInLimit)\n{\n    const BYTE* const pStart = pIn;\n    const BYTE* const pInLoopLimit = pInLimit - (sizeof(size_t)-1);\n\n    if (pIn < pInLoopLimit) {\n        { size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);\n          if (diff) return ZSTD_NbCommonBytes(diff); }\n        pIn+=sizeof(size_t); pMatch+=sizeof(size_t);\n        while (pIn < pInLoopLimit) {\n            size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);\n            if (!diff) { pIn+=sizeof(size_t); pMatch+=sizeof(size_t); continue; }\n            pIn += ZSTD_NbCommonBytes(diff);\n            return (size_t)(pIn - pStart);\n    }   }\n    if (MEM_64bits() && (pIn<(pInLimit-3)) && (MEM_read32(pMatch) == MEM_read32(pIn))) { pIn+=4; pMatch+=4; }\n    if ((pIn<(pInLimit-1)) && (MEM_read16(pMatch) == MEM_read16(pIn))) { pIn+=2; pMatch+=2; }\n    if ((pIn> (32-h) ; }\nMEM_STATIC size_t ZSTD_hash3Ptr(const void* ptr, U32 h) { return ZSTD_hash3(MEM_readLE32(ptr), h, 0); } /* only in zstd_opt.h */\nMEM_STATIC size_t ZSTD_hash3PtrS(const void* ptr, U32 h, U32 s) { return ZSTD_hash3(MEM_readLE32(ptr), h, s); }\n\nstatic const U32 prime4bytes = 2654435761U;\nstatic U32    ZSTD_hash4(U32 u, U32 h, U32 s) { assert(h <= 32); return ((u * prime4bytes) ^ s) >> (32-h) ; }\nstatic size_t ZSTD_hash4Ptr(const void* ptr, U32 h) { return ZSTD_hash4(MEM_readLE32(ptr), h, 0); }\nstatic size_t ZSTD_hash4PtrS(const void* ptr, U32 h, U32 s) { return ZSTD_hash4(MEM_readLE32(ptr), h, s); }\n\nstatic const U64 prime5bytes = 889523592379ULL;\nstatic size_t ZSTD_hash5(U64 u, U32 h, U64 s) { assert(h <= 64); return (size_t)((((u  << (64-40)) * prime5bytes) ^ s) >> (64-h)) ; }\nstatic size_t ZSTD_hash5Ptr(const void* p, U32 h) { return ZSTD_hash5(MEM_readLE64(p), h, 0); }\nstatic size_t ZSTD_hash5PtrS(const void* p, U32 h, U64 s) { return ZSTD_hash5(MEM_readLE64(p), h, s); }\n\nstatic const U64 prime6bytes = 227718039650203ULL;\nstatic size_t ZSTD_hash6(U64 u, U32 h, U64 s) { assert(h <= 64); return (size_t)((((u  << (64-48)) * prime6bytes) ^ s) >> (64-h)) ; }\nstatic size_t ZSTD_hash6Ptr(const void* p, U32 h) { return ZSTD_hash6(MEM_readLE64(p), h, 0); }\nstatic size_t ZSTD_hash6PtrS(const void* p, U32 h, U64 s) { return ZSTD_hash6(MEM_readLE64(p), h, s); }\n\nstatic const U64 prime7bytes = 58295818150454627ULL;\nstatic size_t ZSTD_hash7(U64 u, U32 h, U64 s) { assert(h <= 64); return (size_t)((((u  << (64-56)) * prime7bytes) ^ s) >> (64-h)) ; }\nstatic size_t ZSTD_hash7Ptr(const void* p, U32 h) { return ZSTD_hash7(MEM_readLE64(p), h, 0); }\nstatic size_t ZSTD_hash7PtrS(const void* p, U32 h, U64 s) { return ZSTD_hash7(MEM_readLE64(p), h, s); }\n\nstatic const U64 prime8bytes = 0xCF1BBCDCB7A56463ULL;\nstatic size_t ZSTD_hash8(U64 u, U32 h, U64 s) { assert(h <= 64); return (size_t)((((u) * prime8bytes)  ^ s) >> (64-h)) ; }\nstatic size_t ZSTD_hash8Ptr(const void* p, U32 h) { return ZSTD_hash8(MEM_readLE64(p), h, 0); }\nstatic size_t ZSTD_hash8PtrS(const void* p, U32 h, U64 s) { return ZSTD_hash8(MEM_readLE64(p), h, s); }\n\n\nMEM_STATIC FORCE_INLINE_ATTR\nsize_t ZSTD_hashPtr(const void* p, U32 hBits, U32 mls)\n{\n    /* Although some of these hashes do support hBits up to 64, some do not.\n     * To be on the safe side, always avoid hBits > 32. */\n    assert(hBits <= 32);\n\n    switch(mls)\n    {\n    default:\n    case 4: return ZSTD_hash4Ptr(p, hBits);\n    case 5: return ZSTD_hash5Ptr(p, hBits);\n    case 6: return ZSTD_hash6Ptr(p, hBits);\n    case 7: return ZSTD_hash7Ptr(p, hBits);\n    case 8: return ZSTD_hash8Ptr(p, hBits);\n    }\n}\n\nMEM_STATIC FORCE_INLINE_ATTR\nsize_t ZSTD_hashPtrSalted(const void* p, U32 hBits, U32 mls, const U64 hashSalt) {\n    /* Although some of these hashes do support hBits up to 64, some do not.\n     * To be on the safe side, always avoid hBits > 32. */\n    assert(hBits <= 32);\n\n    switch(mls)\n    {\n        default:\n        case 4: return ZSTD_hash4PtrS(p, hBits, (U32)hashSalt);\n        case 5: return ZSTD_hash5PtrS(p, hBits, hashSalt);\n        case 6: return ZSTD_hash6PtrS(p, hBits, hashSalt);\n        case 7: return ZSTD_hash7PtrS(p, hBits, hashSalt);\n        case 8: return ZSTD_hash8PtrS(p, hBits, hashSalt);\n    }\n}\n\n\n/** ZSTD_ipow() :\n * Return base^exponent.\n */\nstatic U64 ZSTD_ipow(U64 base, U64 exponent)\n{\n    U64 power = 1;\n    while (exponent) {\n      if (exponent & 1) power *= base;\n      exponent >>= 1;\n      base *= base;\n    }\n    return power;\n}\n\n#define ZSTD_ROLL_HASH_CHAR_OFFSET 10\n\n/** ZSTD_rollingHash_append() :\n * Add the buffer to the hash value.\n */\nstatic U64 ZSTD_rollingHash_append(U64 hash, void const* buf, size_t size)\n{\n    BYTE const* istart = (BYTE const*)buf;\n    size_t pos;\n    for (pos = 0; pos < size; ++pos) {\n        hash *= prime8bytes;\n        hash += istart[pos] + ZSTD_ROLL_HASH_CHAR_OFFSET;\n    }\n    return hash;\n}\n\n/** ZSTD_rollingHash_compute() :\n * Compute the rolling hash value of the buffer.\n */\nMEM_STATIC U64 ZSTD_rollingHash_compute(void const* buf, size_t size)\n{\n    return ZSTD_rollingHash_append(0, buf, size);\n}\n\n/** ZSTD_rollingHash_primePower() :\n * Compute the primePower to be passed to ZSTD_rollingHash_rotate() for a hash\n * over a window of length bytes.\n */\nMEM_STATIC U64 ZSTD_rollingHash_primePower(U32 length)\n{\n    return ZSTD_ipow(prime8bytes, length - 1);\n}\n\n/** ZSTD_rollingHash_rotate() :\n * Rotate the rolling hash by one byte.\n */\nMEM_STATIC U64 ZSTD_rollingHash_rotate(U64 hash, BYTE toRemove, BYTE toAdd, U64 primePower)\n{\n    hash -= (toRemove + ZSTD_ROLL_HASH_CHAR_OFFSET) * primePower;\n    hash *= prime8bytes;\n    hash += toAdd + ZSTD_ROLL_HASH_CHAR_OFFSET;\n    return hash;\n}\n\n/*-*************************************\n*  Round buffer management\n***************************************/\n/* Max @current value allowed:\n * In 32-bit mode: we want to avoid crossing the 2 GB limit,\n *                 reducing risks of side effects in case of signed operations on indexes.\n * In 64-bit mode: we want to ensure that adding the maximum job size (512 MB)\n *                 doesn't overflow U32 index capacity (4 GB) */\n#define ZSTD_CURRENT_MAX (MEM_64bits() ? 3500U MB : 2000U MB)\n/* Maximum chunk size before overflow correction needs to be called again */\n#define ZSTD_CHUNKSIZE_MAX                                                     \\\n    ( ((U32)-1)                  /* Maximum ending current index */            \\\n    - ZSTD_CURRENT_MAX)          /* Maximum beginning lowLimit */\n\n/**\n * ZSTD_window_clear():\n * Clears the window containing the history by simply setting it to empty.\n */\nMEM_STATIC void ZSTD_window_clear(ZSTD_window_t* window)\n{\n    size_t const endT = (size_t)(window->nextSrc - window->base);\n    U32 const end = (U32)endT;\n\n    window->lowLimit = end;\n    window->dictLimit = end;\n}\n\nMEM_STATIC U32 ZSTD_window_isEmpty(ZSTD_window_t const window)\n{\n    return window.dictLimit == ZSTD_WINDOW_START_INDEX &&\n           window.lowLimit == ZSTD_WINDOW_START_INDEX &&\n           (window.nextSrc - window.base) == ZSTD_WINDOW_START_INDEX;\n}\n\n/**\n * ZSTD_window_hasExtDict():\n * Returns non-zero if the window has a non-empty extDict.\n */\nMEM_STATIC U32 ZSTD_window_hasExtDict(ZSTD_window_t const window)\n{\n    return window.lowLimit < window.dictLimit;\n}\n\n/**\n * ZSTD_matchState_dictMode():\n * Inspects the provided matchState and figures out what dictMode should be\n * passed to the compressor.\n */\nMEM_STATIC ZSTD_dictMode_e ZSTD_matchState_dictMode(const ZSTD_MatchState_t *ms)\n{\n    return ZSTD_window_hasExtDict(ms->window) ?\n        ZSTD_extDict :\n        ms->dictMatchState != NULL ?\n            (ms->dictMatchState->dedicatedDictSearch ? ZSTD_dedicatedDictSearch : ZSTD_dictMatchState) :\n            ZSTD_noDict;\n}\n\n/* Defining this macro to non-zero tells zstd to run the overflow correction\n * code much more frequently. This is very inefficient, and should only be\n * used for tests and fuzzers.\n */\n#ifndef ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY\n#  ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION\n#    define ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY 1\n#  else\n#    define ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY 0\n#  endif\n#endif\n\n/**\n * ZSTD_window_canOverflowCorrect():\n * Returns non-zero if the indices are large enough for overflow correction\n * to work correctly without impacting compression ratio.\n */\nMEM_STATIC U32 ZSTD_window_canOverflowCorrect(ZSTD_window_t const window,\n                                              U32 cycleLog,\n                                              U32 maxDist,\n                                              U32 loadedDictEnd,\n                                              void const* src)\n{\n    U32 const cycleSize = 1u << cycleLog;\n    U32 const curr = (U32)((BYTE const*)src - window.base);\n    U32 const minIndexToOverflowCorrect = cycleSize\n                                        + MAX(maxDist, cycleSize)\n                                        + ZSTD_WINDOW_START_INDEX;\n\n    /* Adjust the min index to backoff the overflow correction frequency,\n     * so we don't waste too much CPU in overflow correction. If this\n     * computation overflows we don't really care, we just need to make\n     * sure it is at least minIndexToOverflowCorrect.\n     */\n    U32 const adjustment = window.nbOverflowCorrections + 1;\n    U32 const adjustedIndex = MAX(minIndexToOverflowCorrect * adjustment,\n                                  minIndexToOverflowCorrect);\n    U32 const indexLargeEnough = curr > adjustedIndex;\n\n    /* Only overflow correct early if the dictionary is invalidated already,\n     * so we don't hurt compression ratio.\n     */\n    U32 const dictionaryInvalidated = curr > maxDist + loadedDictEnd;\n\n    return indexLargeEnough && dictionaryInvalidated;\n}\n\n/**\n * ZSTD_window_needOverflowCorrection():\n * Returns non-zero if the indices are getting too large and need overflow\n * protection.\n */\nMEM_STATIC U32 ZSTD_window_needOverflowCorrection(ZSTD_window_t const window,\n                                                  U32 cycleLog,\n                                                  U32 maxDist,\n                                                  U32 loadedDictEnd,\n                                                  void const* src,\n                                                  void const* srcEnd)\n{\n    U32 const curr = (U32)((BYTE const*)srcEnd - window.base);\n    if (ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY) {\n        if (ZSTD_window_canOverflowCorrect(window, cycleLog, maxDist, loadedDictEnd, src)) {\n            return 1;\n        }\n    }\n    return curr > ZSTD_CURRENT_MAX;\n}\n\n/**\n * ZSTD_window_correctOverflow():\n * Reduces the indices to protect from index overflow.\n * Returns the correction made to the indices, which must be applied to every\n * stored index.\n *\n * The least significant cycleLog bits of the indices must remain the same,\n * which may be 0. Every index up to maxDist in the past must be valid.\n */\nMEM_STATIC\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nU32 ZSTD_window_correctOverflow(ZSTD_window_t* window, U32 cycleLog,\n                                           U32 maxDist, void const* src)\n{\n    /* preemptive overflow correction:\n     * 1. correction is large enough:\n     *    lowLimit > (3<<29) ==> current > 3<<29 + 1< (3<<29 + 1< (3<<29) - (1< (3<<29) - (1<<30)             (NOTE: chainLog <= 30)\n     *    > 1<<29\n     *\n     * 2. (ip+ZSTD_CHUNKSIZE_MAX - cctx->base) doesn't overflow:\n     *    After correction, current is less than (1<base < 1<<32.\n     * 3. (cctx->lowLimit + 1< 3<<29 + 1<base);\n    U32 const currentCycle = curr & cycleMask;\n    /* Ensure newCurrent - maxDist >= ZSTD_WINDOW_START_INDEX. */\n    U32 const currentCycleCorrection = currentCycle < ZSTD_WINDOW_START_INDEX\n                                     ? MAX(cycleSize, ZSTD_WINDOW_START_INDEX)\n                                     : 0;\n    U32 const newCurrent = currentCycle\n                         + currentCycleCorrection\n                         + MAX(maxDist, cycleSize);\n    U32 const correction = curr - newCurrent;\n    /* maxDist must be a power of two so that:\n     *   (newCurrent & cycleMask) == (curr & cycleMask)\n     * This is required to not corrupt the chains / binary tree.\n     */\n    assert((maxDist & (maxDist - 1)) == 0);\n    assert((curr & cycleMask) == (newCurrent & cycleMask));\n    assert(curr > newCurrent);\n    if (!ZSTD_WINDOW_OVERFLOW_CORRECT_FREQUENTLY) {\n        /* Loose bound, should be around 1<<29 (see above) */\n        assert(correction > 1<<28);\n    }\n\n    window->base += correction;\n    window->dictBase += correction;\n    if (window->lowLimit < correction + ZSTD_WINDOW_START_INDEX) {\n        window->lowLimit = ZSTD_WINDOW_START_INDEX;\n    } else {\n        window->lowLimit -= correction;\n    }\n    if (window->dictLimit < correction + ZSTD_WINDOW_START_INDEX) {\n        window->dictLimit = ZSTD_WINDOW_START_INDEX;\n    } else {\n        window->dictLimit -= correction;\n    }\n\n    /* Ensure we can still reference the full window. */\n    assert(newCurrent >= maxDist);\n    assert(newCurrent - maxDist >= ZSTD_WINDOW_START_INDEX);\n    /* Ensure that lowLimit and dictLimit didn't underflow. */\n    assert(window->lowLimit <= newCurrent);\n    assert(window->dictLimit <= newCurrent);\n\n    ++window->nbOverflowCorrections;\n\n    DEBUGLOG(4, \"Correction of 0x%x bytes to lowLimit=0x%x\", correction,\n             window->lowLimit);\n    return correction;\n}\n\n/**\n * ZSTD_window_enforceMaxDist():\n * Updates lowLimit so that:\n *    (srcEnd - base) - lowLimit == maxDist + loadedDictEnd\n *\n * It ensures index is valid as long as index >= lowLimit.\n * This must be called before a block compression call.\n *\n * loadedDictEnd is only defined if a dictionary is in use for current compression.\n * As the name implies, loadedDictEnd represents the index at end of dictionary.\n * The value lies within context's referential, it can be directly compared to blockEndIdx.\n *\n * If loadedDictEndPtr is NULL, no dictionary is in use, and we use loadedDictEnd == 0.\n * If loadedDictEndPtr is not NULL, we set it to zero after updating lowLimit.\n * This is because dictionaries are allowed to be referenced fully\n * as long as the last byte of the dictionary is in the window.\n * Once input has progressed beyond window size, dictionary cannot be referenced anymore.\n *\n * In normal dict mode, the dictionary lies between lowLimit and dictLimit.\n * In dictMatchState mode, lowLimit and dictLimit are the same,\n * and the dictionary is below them.\n * forceWindow and dictMatchState are therefore incompatible.\n */\nMEM_STATIC void\nZSTD_window_enforceMaxDist(ZSTD_window_t* window,\n                     const void* blockEnd,\n                           U32   maxDist,\n                           U32*  loadedDictEndPtr,\n                     const ZSTD_MatchState_t** dictMatchStatePtr)\n{\n    U32 const blockEndIdx = (U32)((BYTE const*)blockEnd - window->base);\n    U32 const loadedDictEnd = (loadedDictEndPtr != NULL) ? *loadedDictEndPtr : 0;\n    DEBUGLOG(5, \"ZSTD_window_enforceMaxDist: blockEndIdx=%u, maxDist=%u, loadedDictEnd=%u\",\n                (unsigned)blockEndIdx, (unsigned)maxDist, (unsigned)loadedDictEnd);\n\n    /* - When there is no dictionary : loadedDictEnd == 0.\n         In which case, the test (blockEndIdx > maxDist) is merely to avoid\n         overflowing next operation `newLowLimit = blockEndIdx - maxDist`.\n       - When there is a standard dictionary :\n         Index referential is copied from the dictionary,\n         which means it starts from 0.\n         In which case, loadedDictEnd == dictSize,\n         and it makes sense to compare `blockEndIdx > maxDist + dictSize`\n         since `blockEndIdx` also starts from zero.\n       - When there is an attached dictionary :\n         loadedDictEnd is expressed within the referential of the context,\n         so it can be directly compared against blockEndIdx.\n    */\n    if (blockEndIdx > maxDist + loadedDictEnd) {\n        U32 const newLowLimit = blockEndIdx - maxDist;\n        if (window->lowLimit < newLowLimit) window->lowLimit = newLowLimit;\n        if (window->dictLimit < window->lowLimit) {\n            DEBUGLOG(5, \"Update dictLimit to match lowLimit, from %u to %u\",\n                        (unsigned)window->dictLimit, (unsigned)window->lowLimit);\n            window->dictLimit = window->lowLimit;\n        }\n        /* On reaching window size, dictionaries are invalidated */\n        if (loadedDictEndPtr) *loadedDictEndPtr = 0;\n        if (dictMatchStatePtr) *dictMatchStatePtr = NULL;\n    }\n}\n\n/* Similar to ZSTD_window_enforceMaxDist(),\n * but only invalidates dictionary\n * when input progresses beyond window size.\n * assumption : loadedDictEndPtr and dictMatchStatePtr are valid (non NULL)\n *              loadedDictEnd uses same referential as window->base\n *              maxDist is the window size */\nMEM_STATIC void\nZSTD_checkDictValidity(const ZSTD_window_t* window,\n                       const void* blockEnd,\n                             U32   maxDist,\n                             U32*  loadedDictEndPtr,\n                       const ZSTD_MatchState_t** dictMatchStatePtr)\n{\n    assert(loadedDictEndPtr != NULL);\n    assert(dictMatchStatePtr != NULL);\n    {   U32 const blockEndIdx = (U32)((BYTE const*)blockEnd - window->base);\n        U32 const loadedDictEnd = *loadedDictEndPtr;\n        DEBUGLOG(5, \"ZSTD_checkDictValidity: blockEndIdx=%u, maxDist=%u, loadedDictEnd=%u\",\n                    (unsigned)blockEndIdx, (unsigned)maxDist, (unsigned)loadedDictEnd);\n        assert(blockEndIdx >= loadedDictEnd);\n\n        if (blockEndIdx > loadedDictEnd + maxDist || loadedDictEnd != window->dictLimit) {\n            /* On reaching window size, dictionaries are invalidated.\n             * For simplification, if window size is reached anywhere within next block,\n             * the dictionary is invalidated for the full block.\n             *\n             * We also have to invalidate the dictionary if ZSTD_window_update() has detected\n             * non-contiguous segments, which means that loadedDictEnd != window->dictLimit.\n             * loadedDictEnd may be 0, if forceWindow is true, but in that case we never use\n             * dictMatchState, so setting it to NULL is not a problem.\n             */\n            DEBUGLOG(6, \"invalidating dictionary for current block (distance > windowSize)\");\n            *loadedDictEndPtr = 0;\n            *dictMatchStatePtr = NULL;\n        } else {\n            if (*loadedDictEndPtr != 0) {\n                DEBUGLOG(6, \"dictionary considered valid for current block\");\n    }   }   }\n}\n\nMEM_STATIC void ZSTD_window_init(ZSTD_window_t* window) {\n    ZSTD_memset(window, 0, sizeof(*window));\n    window->base = (BYTE const*)\" \";\n    window->dictBase = (BYTE const*)\" \";\n    ZSTD_STATIC_ASSERT(ZSTD_DUBT_UNSORTED_MARK < ZSTD_WINDOW_START_INDEX); /* Start above ZSTD_DUBT_UNSORTED_MARK */\n    window->dictLimit = ZSTD_WINDOW_START_INDEX;    /* start from >0, so that 1st position is valid */\n    window->lowLimit = ZSTD_WINDOW_START_INDEX;     /* it ensures first and later CCtx usages compress the same */\n    window->nextSrc = window->base + ZSTD_WINDOW_START_INDEX;   /* see issue #1241 */\n    window->nbOverflowCorrections = 0;\n}\n\n/**\n * ZSTD_window_update():\n * Updates the window by appending [src, src + srcSize) to the window.\n * If it is not contiguous, the current prefix becomes the extDict, and we\n * forget about the extDict. Handles overlap of the prefix and extDict.\n * Returns non-zero if the segment is contiguous.\n */\nMEM_STATIC\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nU32 ZSTD_window_update(ZSTD_window_t* window,\n                 const void* src, size_t srcSize,\n                       int forceNonContiguous)\n{\n    BYTE const* const ip = (BYTE const*)src;\n    U32 contiguous = 1;\n    DEBUGLOG(5, \"ZSTD_window_update\");\n    if (srcSize == 0)\n        return contiguous;\n    assert(window->base != NULL);\n    assert(window->dictBase != NULL);\n    /* Check if blocks follow each other */\n    if (src != window->nextSrc || forceNonContiguous) {\n        /* not contiguous */\n        size_t const distanceFromBase = (size_t)(window->nextSrc - window->base);\n        DEBUGLOG(5, \"Non contiguous blocks, new segment starts at %u\", window->dictLimit);\n        window->lowLimit = window->dictLimit;\n        assert(distanceFromBase == (size_t)(U32)distanceFromBase);  /* should never overflow */\n        window->dictLimit = (U32)distanceFromBase;\n        window->dictBase = window->base;\n        window->base = ip - distanceFromBase;\n        /* ms->nextToUpdate = window->dictLimit; */\n        if (window->dictLimit - window->lowLimit < HASH_READ_SIZE) window->lowLimit = window->dictLimit;   /* too small extDict */\n        contiguous = 0;\n    }\n    window->nextSrc = ip + srcSize;\n    /* if input and dictionary overlap : reduce dictionary (area presumed modified by input) */\n    if ( (ip+srcSize > window->dictBase + window->lowLimit)\n       & (ip < window->dictBase + window->dictLimit)) {\n        size_t const highInputIdx = (size_t)((ip + srcSize) - window->dictBase);\n        U32 const lowLimitMax = (highInputIdx > (size_t)window->dictLimit) ? window->dictLimit : (U32)highInputIdx;\n        assert(highInputIdx < UINT_MAX);\n        window->lowLimit = lowLimitMax;\n        DEBUGLOG(5, \"Overlapping extDict and input : new lowLimit = %u\", window->lowLimit);\n    }\n    return contiguous;\n}\n\n/**\n * Returns the lowest allowed match index. It may either be in the ext-dict or the prefix.\n */\nMEM_STATIC U32 ZSTD_getLowestMatchIndex(const ZSTD_MatchState_t* ms, U32 curr, unsigned windowLog)\n{\n    U32 const maxDistance = 1U << windowLog;\n    U32 const lowestValid = ms->window.lowLimit;\n    U32 const withinWindow = (curr - lowestValid > maxDistance) ? curr - maxDistance : lowestValid;\n    U32 const isDictionary = (ms->loadedDictEnd != 0);\n    /* When using a dictionary the entire dictionary is valid if a single byte of the dictionary\n     * is within the window. We invalidate the dictionary (and set loadedDictEnd to 0) when it isn't\n     * valid for the entire block. So this check is sufficient to find the lowest valid match index.\n     */\n    U32 const matchLowest = isDictionary ? lowestValid : withinWindow;\n    return matchLowest;\n}\n\n/**\n * Returns the lowest allowed match index in the prefix.\n */\nMEM_STATIC U32 ZSTD_getLowestPrefixIndex(const ZSTD_MatchState_t* ms, U32 curr, unsigned windowLog)\n{\n    U32    const maxDistance = 1U << windowLog;\n    U32    const lowestValid = ms->window.dictLimit;\n    U32    const withinWindow = (curr - lowestValid > maxDistance) ? curr - maxDistance : lowestValid;\n    U32    const isDictionary = (ms->loadedDictEnd != 0);\n    /* When computing the lowest prefix index we need to take the dictionary into account to handle\n     * the edge case where the dictionary and the source are contiguous in memory.\n     */\n    U32    const matchLowest = isDictionary ? lowestValid : withinWindow;\n    return matchLowest;\n}\n\n/* index_safety_check:\n * intentional underflow : ensure repIndex isn't overlapping dict + prefix\n * @return 1 if values are not overlapping,\n * 0 otherwise */\nMEM_STATIC int ZSTD_index_overlap_check(const U32 prefixLowestIndex, const U32 repIndex) {\n    return ((U32)((prefixLowestIndex-1)  - repIndex) >= 3);\n}\n\n\n/* debug functions */\n#if (DEBUGLEVEL>=2)\n\nMEM_STATIC double ZSTD_fWeight(U32 rawStat)\n{\n    U32 const fp_accuracy = 8;\n    U32 const fp_multiplier = (1 << fp_accuracy);\n    U32 const newStat = rawStat + 1;\n    U32 const hb = ZSTD_highbit32(newStat);\n    U32 const BWeight = hb * fp_multiplier;\n    U32 const FWeight = (newStat << fp_accuracy) >> hb;\n    U32 const weight = BWeight + FWeight;\n    assert(hb + fp_accuracy < 31);\n    return (double)weight / fp_multiplier;\n}\n\n/* display a table content,\n * listing each element, its frequency, and its predicted bit cost */\nMEM_STATIC void ZSTD_debugTable(const U32* table, U32 max)\n{\n    unsigned u, sum;\n    for (u=0, sum=0; u<=max; u++) sum += table[u];\n    DEBUGLOG(2, \"total nb elts: %u\", sum);\n    for (u=0; u<=max; u++) {\n        DEBUGLOG(2, \"%2u: %5u  (%.2f)\",\n                u, table[u], ZSTD_fWeight(sum) - ZSTD_fWeight(table[u]) );\n    }\n}\n\n#endif\n\n/* Short Cache */\n\n/* Normally, zstd matchfinders follow this flow:\n *     1. Compute hash at ip\n *     2. Load index from hashTable[hash]\n *     3. Check if *ip == *(base + index)\n * In dictionary compression, loading *(base + index) is often an L2 or even L3 miss.\n *\n * Short cache is an optimization which allows us to avoid step 3 most of the time\n * when the data doesn't actually match. With short cache, the flow becomes:\n *     1. Compute (hash, currentTag) at ip. currentTag is an 8-bit independent hash at ip.\n *     2. Load (index, matchTag) from hashTable[hash]. See ZSTD_writeTaggedIndex to understand how this works.\n *     3. Only if currentTag == matchTag, check *ip == *(base + index). Otherwise, continue.\n *\n * Currently, short cache is only implemented in CDict hashtables. Thus, its use is limited to\n * dictMatchState matchfinders.\n */\n#define ZSTD_SHORT_CACHE_TAG_BITS 8\n#define ZSTD_SHORT_CACHE_TAG_MASK ((1u << ZSTD_SHORT_CACHE_TAG_BITS) - 1)\n\n/* Helper function for ZSTD_fillHashTable and ZSTD_fillDoubleHashTable.\n * Unpacks hashAndTag into (hash, tag), then packs (index, tag) into hashTable[hash]. */\nMEM_STATIC void ZSTD_writeTaggedIndex(U32* const hashTable, size_t hashAndTag, U32 index) {\n    size_t const hash = hashAndTag >> ZSTD_SHORT_CACHE_TAG_BITS;\n    U32 const tag = (U32)(hashAndTag & ZSTD_SHORT_CACHE_TAG_MASK);\n    assert(index >> (32 - ZSTD_SHORT_CACHE_TAG_BITS) == 0);\n    hashTable[hash] = (index << ZSTD_SHORT_CACHE_TAG_BITS) | tag;\n}\n\n/* Helper function for short cache matchfinders.\n * Unpacks tag1 and tag2 from lower bits of packedTag1 and packedTag2, then checks if the tags match. */\nMEM_STATIC int ZSTD_comparePackedTags(size_t packedTag1, size_t packedTag2) {\n    U32 const tag1 = packedTag1 & ZSTD_SHORT_CACHE_TAG_MASK;\n    U32 const tag2 = packedTag2 & ZSTD_SHORT_CACHE_TAG_MASK;\n    return tag1 == tag2;\n}\n\n/* ===============================================================\n * Shared internal declarations\n * These prototypes may be called from sources not in lib/compress\n * =============================================================== */\n\n/* ZSTD_loadCEntropy() :\n * dict : must point at beginning of a valid zstd dictionary.\n * return : size of dictionary header (size of magic number + dict ID + entropy tables)\n * assumptions : magic number supposed already checked\n *               and dictSize >= 8 */\nsize_t ZSTD_loadCEntropy(ZSTD_compressedBlockState_t* bs, void* workspace,\n                         const void* const dict, size_t dictSize);\n\nvoid ZSTD_reset_compressedBlockState(ZSTD_compressedBlockState_t* bs);\n\ntypedef struct {\n    U32 idx;            /* Index in array of ZSTD_Sequence */\n    U32 posInSequence;  /* Position within sequence at idx */\n    size_t posInSrc;    /* Number of bytes given by sequences provided so far */\n} ZSTD_SequencePosition;\n\n/* for benchmark */\nsize_t ZSTD_convertBlockSequences(ZSTD_CCtx* cctx,\n                        const ZSTD_Sequence* const inSeqs, size_t nbSequences,\n                        int repcodeResolution);\n\ntypedef struct {\n    size_t nbSequences;\n    size_t blockSize;\n    size_t litSize;\n} BlockSummary;\n\nBlockSummary ZSTD_get1BlockSummary(const ZSTD_Sequence* seqs, size_t nbSeqs);\n\n/* ==============================================================\n * Private declarations\n * These prototypes shall only be called from within lib/compress\n * ============================================================== */\n\n/* ZSTD_getCParamsFromCCtxParams() :\n * cParams are built depending on compressionLevel, src size hints,\n * LDM and manually set compression parameters.\n * Note: srcSizeHint == 0 means 0!\n */\nZSTD_compressionParameters ZSTD_getCParamsFromCCtxParams(\n        const ZSTD_CCtx_params* CCtxParams, U64 srcSizeHint, size_t dictSize, ZSTD_CParamMode_e mode);\n\n/*! ZSTD_initCStream_internal() :\n *  Private use only. Init streaming operation.\n *  expects params to be valid.\n *  must receive dict, or cdict, or none, but not both.\n *  @return : 0, or an error code */\nsize_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,\n                     const void* dict, size_t dictSize,\n                     const ZSTD_CDict* cdict,\n                     const ZSTD_CCtx_params* params, unsigned long long pledgedSrcSize);\n\nvoid ZSTD_resetSeqStore(SeqStore_t* ssPtr);\n\n/*! ZSTD_getCParamsFromCDict() :\n *  as the name implies */\nZSTD_compressionParameters ZSTD_getCParamsFromCDict(const ZSTD_CDict* cdict);\n\n/* ZSTD_compressBegin_advanced_internal() :\n * Private use only. To be called from zstdmt_compress.c. */\nsize_t ZSTD_compressBegin_advanced_internal(ZSTD_CCtx* cctx,\n                                    const void* dict, size_t dictSize,\n                                    ZSTD_dictContentType_e dictContentType,\n                                    ZSTD_dictTableLoadMethod_e dtlm,\n                                    const ZSTD_CDict* cdict,\n                                    const ZSTD_CCtx_params* params,\n                                    unsigned long long pledgedSrcSize);\n\n/* ZSTD_compress_advanced_internal() :\n * Private use only. To be called from zstdmt_compress.c. */\nsize_t ZSTD_compress_advanced_internal(ZSTD_CCtx* cctx,\n                                       void* dst, size_t dstCapacity,\n                                 const void* src, size_t srcSize,\n                                 const void* dict,size_t dictSize,\n                                 const ZSTD_CCtx_params* params);\n\n\n/* ZSTD_writeLastEmptyBlock() :\n * output an empty Block with end-of-frame mark to complete a frame\n * @return : size of data written into `dst` (== ZSTD_blockHeaderSize (defined in zstd_internal.h))\n *           or an error code if `dstCapacity` is too small ( 1 */\nU32 ZSTD_cycleLog(U32 hashLog, ZSTD_strategy strat);\n\n/** ZSTD_CCtx_trace() :\n *  Trace the end of a compression call.\n */\nvoid ZSTD_CCtx_trace(ZSTD_CCtx* cctx, size_t extraCSize);\n\n/* Returns 1 if an external sequence producer is registered, otherwise returns 0. */\nMEM_STATIC int ZSTD_hasExtSeqProd(const ZSTD_CCtx_params* params) {\n    return params->extSeqProdFunc != NULL;\n}\n\n/* ===============================================================\n * Deprecated definitions that are still used internally to avoid\n * deprecation warnings. These functions are exactly equivalent to\n * their public variants, but avoid the deprecation warnings.\n * =============================================================== */\n\nsize_t ZSTD_compressBegin_usingCDict_deprecated(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict);\n\nsize_t ZSTD_compressContinue_public(ZSTD_CCtx* cctx,\n                                    void* dst, size_t dstCapacity,\n                              const void* src, size_t srcSize);\n\nsize_t ZSTD_compressEnd_public(ZSTD_CCtx* cctx,\n                               void* dst, size_t dstCapacity,\n                         const void* src, size_t srcSize);\n\nsize_t ZSTD_compressBlock_deprecated(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);\n\n\n#endif /* ZSTD_COMPRESS_H */\n"
  },
  {
    "path": "lib/compress/zstd_compress_literals.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n /*-*************************************\n *  Dependencies\n ***************************************/\n#include \"zstd_compress_literals.h\"\n\n\n/* **************************************************************\n*  Debug Traces\n****************************************************************/\n#if DEBUGLEVEL >= 2\n\nstatic size_t showHexa(const void* src, size_t srcSize)\n{\n    const BYTE* const ip = (const BYTE*)src;\n    size_t u;\n    for (u=0; u31) + (srcSize>4095);\n\n    DEBUGLOG(5, \"ZSTD_noCompressLiterals: srcSize=%zu, dstCapacity=%zu\", srcSize, dstCapacity);\n\n    RETURN_ERROR_IF(srcSize + flSize > dstCapacity, dstSize_tooSmall, \"\");\n\n    switch(flSize)\n    {\n        case 1: /* 2 - 1 - 5 */\n            ostart[0] = (BYTE)((U32)set_basic + (srcSize<<3));\n            break;\n        case 2: /* 2 - 2 - 12 */\n            MEM_writeLE16(ostart, (U16)((U32)set_basic + (1<<2) + (srcSize<<4)));\n            break;\n        case 3: /* 2 - 2 - 20 */\n            MEM_writeLE32(ostart, (U32)((U32)set_basic + (3<<2) + (srcSize<<4)));\n            break;\n        default:   /* not necessary : flSize is {1,2,3} */\n            assert(0);\n    }\n\n    ZSTD_memcpy(ostart + flSize, src, srcSize);\n    DEBUGLOG(5, \"Raw (uncompressed) literals: %u -> %u\", (U32)srcSize, (U32)(srcSize + flSize));\n    return srcSize + flSize;\n}\n\nstatic int allBytesIdentical(const void* src, size_t srcSize)\n{\n    assert(srcSize >= 1);\n    assert(src != NULL);\n    {   const BYTE b = ((const BYTE*)src)[0];\n        size_t p;\n        for (p=1; p31) + (srcSize>4095);\n\n    assert(dstCapacity >= 4); (void)dstCapacity;\n    assert(allBytesIdentical(src, srcSize));\n\n    switch(flSize)\n    {\n        case 1: /* 2 - 1 - 5 */\n            ostart[0] = (BYTE)((U32)set_rle + (srcSize<<3));\n            break;\n        case 2: /* 2 - 2 - 12 */\n            MEM_writeLE16(ostart, (U16)((U32)set_rle + (1<<2) + (srcSize<<4)));\n            break;\n        case 3: /* 2 - 2 - 20 */\n            MEM_writeLE32(ostart, (U32)((U32)set_rle + (3<<2) + (srcSize<<4)));\n            break;\n        default:   /* not necessary : flSize is {1,2,3} */\n            assert(0);\n    }\n\n    ostart[flSize] = *(const BYTE*)src;\n    DEBUGLOG(5, \"RLE : Repeated Literal (%02X: %u times) -> %u bytes encoded\", ((const BYTE*)src)[0], (U32)srcSize, (U32)flSize + 1);\n    return flSize+1;\n}\n\n/* ZSTD_minLiteralsToCompress() :\n * returns minimal amount of literals\n * for literal compression to even be attempted.\n * Minimum is made tighter as compression strategy increases.\n */\nstatic size_t\nZSTD_minLiteralsToCompress(ZSTD_strategy strategy, HUF_repeat huf_repeat)\n{\n    assert((int)strategy >= 0);\n    assert((int)strategy <= 9);\n    /* btultra2 : min 8 bytes;\n     * then 2x larger for each successive compression strategy\n     * max threshold 64 bytes */\n    {   int const shift = MIN(9-(int)strategy, 3);\n        size_t const mintc = (huf_repeat == HUF_repeat_valid) ? 6 : (size_t)8 << shift;\n        DEBUGLOG(7, \"minLiteralsToCompress = %zu\", mintc);\n        return mintc;\n    }\n}\n\nsize_t ZSTD_compressLiterals (\n                  void* dst, size_t dstCapacity,\n            const void* src, size_t srcSize,\n                  void* entropyWorkspace, size_t entropyWorkspaceSize,\n            const ZSTD_hufCTables_t* prevHuf,\n                  ZSTD_hufCTables_t* nextHuf,\n                  ZSTD_strategy strategy,\n                  int disableLiteralCompression,\n                  int suspectUncompressible,\n                  int bmi2)\n{\n    size_t const lhSize = 3 + (srcSize >= 1 KB) + (srcSize >= 16 KB);\n    BYTE*  const ostart = (BYTE*)dst;\n    U32 singleStream = srcSize < 256;\n    SymbolEncodingType_e hType = set_compressed;\n    size_t cLitSize;\n\n    DEBUGLOG(5,\"ZSTD_compressLiterals (disableLiteralCompression=%i, srcSize=%u, dstCapacity=%zu)\",\n                disableLiteralCompression, (U32)srcSize, dstCapacity);\n\n    DEBUGLOG(6, \"Completed literals listing (%zu bytes)\", showHexa(src, srcSize));\n\n    /* Prepare nextEntropy assuming reusing the existing table */\n    ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));\n\n    if (disableLiteralCompression)\n        return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);\n\n    /* if too small, don't even attempt compression (speed opt) */\n    if (srcSize < ZSTD_minLiteralsToCompress(strategy, prevHuf->repeatMode))\n        return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);\n\n    RETURN_ERROR_IF(dstCapacity < lhSize+1, dstSize_tooSmall, \"not enough space for compression\");\n    {   HUF_repeat repeat = prevHuf->repeatMode;\n        int const flags = 0\n            | (bmi2 ? HUF_flags_bmi2 : 0)\n            | (strategy < ZSTD_lazy && srcSize <= 1024 ? HUF_flags_preferRepeat : 0)\n            | (strategy >= HUF_OPTIMAL_DEPTH_THRESHOLD ? HUF_flags_optimalDepth : 0)\n            | (suspectUncompressible ? HUF_flags_suspectUncompressible : 0);\n\n        typedef size_t (*huf_compress_f)(void*, size_t, const void*, size_t, unsigned, unsigned, void*, size_t, HUF_CElt*, HUF_repeat*, int);\n        huf_compress_f huf_compress;\n        if (repeat == HUF_repeat_valid && lhSize == 3) singleStream = 1;\n        huf_compress = singleStream ? HUF_compress1X_repeat : HUF_compress4X_repeat;\n        cLitSize = huf_compress(ostart+lhSize, dstCapacity-lhSize,\n                                src, srcSize,\n                                HUF_SYMBOLVALUE_MAX, LitHufLog,\n                                entropyWorkspace, entropyWorkspaceSize,\n                                (HUF_CElt*)nextHuf->CTable,\n                                &repeat, flags);\n        DEBUGLOG(5, \"%zu literals compressed into %zu bytes (before header)\", srcSize, cLitSize);\n        if (repeat != HUF_repeat_none) {\n            /* reused the existing table */\n            DEBUGLOG(5, \"reusing statistics from previous huffman block\");\n            hType = set_repeat;\n        }\n    }\n\n    {   size_t const minGain = ZSTD_minGain(srcSize, strategy);\n        if ((cLitSize==0) || (cLitSize >= srcSize - minGain) || ERR_isError(cLitSize)) {\n            ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));\n            return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);\n    }   }\n    if (cLitSize==1) {\n        /* A return value of 1 signals that the alphabet consists of a single symbol.\n         * However, in some rare circumstances, it could be the compressed size (a single byte).\n         * For that outcome to have a chance to happen, it's necessary that `srcSize < 8`.\n         * (it's also necessary to not generate statistics).\n         * Therefore, in such a case, actively check that all bytes are identical. */\n        if ((srcSize >= 8) || allBytesIdentical(src, srcSize)) {\n            ZSTD_memcpy(nextHuf, prevHuf, sizeof(*prevHuf));\n            return ZSTD_compressRleLiteralsBlock(dst, dstCapacity, src, srcSize);\n    }   }\n\n    if (hType == set_compressed) {\n        /* using a newly constructed table */\n        nextHuf->repeatMode = HUF_repeat_check;\n    }\n\n    /* Build header */\n    switch(lhSize)\n    {\n    case 3: /* 2 - 2 - 10 - 10 */\n        if (!singleStream) assert(srcSize >= MIN_LITERALS_FOR_4_STREAMS);\n        {   U32 const lhc = hType + ((U32)(!singleStream) << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<14);\n            MEM_writeLE24(ostart, lhc);\n            break;\n        }\n    case 4: /* 2 - 2 - 14 - 14 */\n        assert(srcSize >= MIN_LITERALS_FOR_4_STREAMS);\n        {   U32 const lhc = hType + (2 << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<18);\n            MEM_writeLE32(ostart, lhc);\n            break;\n        }\n    case 5: /* 2 - 2 - 18 - 18 */\n        assert(srcSize >= MIN_LITERALS_FOR_4_STREAMS);\n        {   U32 const lhc = hType + (3 << 2) + ((U32)srcSize<<4) + ((U32)cLitSize<<22);\n            MEM_writeLE32(ostart, lhc);\n            ostart[4] = (BYTE)(cLitSize >> 10);\n            break;\n        }\n    default:  /* not possible : lhSize is {3,4,5} */\n        assert(0);\n    }\n    DEBUGLOG(5, \"Compressed literals: %u -> %u\", (U32)srcSize, (U32)(lhSize+cLitSize));\n    return lhSize+cLitSize;\n}\n"
  },
  {
    "path": "lib/compress/zstd_compress_literals.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_COMPRESS_LITERALS_H\n#define ZSTD_COMPRESS_LITERALS_H\n\n#include \"zstd_compress_internal.h\" /* ZSTD_hufCTables_t, ZSTD_minGain() */\n\n\nsize_t ZSTD_noCompressLiterals (void* dst, size_t dstCapacity, const void* src, size_t srcSize);\n\n/* ZSTD_compressRleLiteralsBlock() :\n * Conditions :\n * - All bytes in @src are identical\n * - dstCapacity >= 4 */\nsize_t ZSTD_compressRleLiteralsBlock (void* dst, size_t dstCapacity, const void* src, size_t srcSize);\n\n/* ZSTD_compressLiterals():\n * @entropyWorkspace: must be aligned on 4-bytes boundaries\n * @entropyWorkspaceSize : must be >= HUF_WORKSPACE_SIZE\n * @suspectUncompressible: sampling checks, to potentially skip huffman coding\n */\nsize_t ZSTD_compressLiterals (void* dst, size_t dstCapacity,\n                        const void* src, size_t srcSize,\n                              void* entropyWorkspace, size_t entropyWorkspaceSize,\n                        const ZSTD_hufCTables_t* prevHuf,\n                              ZSTD_hufCTables_t* nextHuf,\n                              ZSTD_strategy strategy, int disableLiteralCompression,\n                              int suspectUncompressible,\n                              int bmi2);\n\n#endif /* ZSTD_COMPRESS_LITERALS_H */\n"
  },
  {
    "path": "lib/compress/zstd_compress_sequences.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n /*-*************************************\n *  Dependencies\n ***************************************/\n#include \"zstd_compress_sequences.h\"\n\n/**\n * -log2(x / 256) lookup table for x in [0, 256).\n * If x == 0: Return 0\n * Else: Return floor(-log2(x / 256) * 256)\n */\nstatic unsigned const kInverseProbabilityLog256[256] = {\n    0,    2048, 1792, 1642, 1536, 1453, 1386, 1329, 1280, 1236, 1197, 1162,\n    1130, 1100, 1073, 1047, 1024, 1001, 980,  960,  941,  923,  906,  889,\n    874,  859,  844,  830,  817,  804,  791,  779,  768,  756,  745,  734,\n    724,  714,  704,  694,  685,  676,  667,  658,  650,  642,  633,  626,\n    618,  610,  603,  595,  588,  581,  574,  567,  561,  554,  548,  542,\n    535,  529,  523,  517,  512,  506,  500,  495,  489,  484,  478,  473,\n    468,  463,  458,  453,  448,  443,  438,  434,  429,  424,  420,  415,\n    411,  407,  402,  398,  394,  390,  386,  382,  377,  373,  370,  366,\n    362,  358,  354,  350,  347,  343,  339,  336,  332,  329,  325,  322,\n    318,  315,  311,  308,  305,  302,  298,  295,  292,  289,  286,  282,\n    279,  276,  273,  270,  267,  264,  261,  258,  256,  253,  250,  247,\n    244,  241,  239,  236,  233,  230,  228,  225,  222,  220,  217,  215,\n    212,  209,  207,  204,  202,  199,  197,  194,  192,  190,  187,  185,\n    182,  180,  178,  175,  173,  171,  168,  166,  164,  162,  159,  157,\n    155,  153,  151,  149,  146,  144,  142,  140,  138,  136,  134,  132,\n    130,  128,  126,  123,  121,  119,  117,  115,  114,  112,  110,  108,\n    106,  104,  102,  100,  98,   96,   94,   93,   91,   89,   87,   85,\n    83,   82,   80,   78,   76,   74,   73,   71,   69,   67,   66,   64,\n    62,   61,   59,   57,   55,   54,   52,   50,   49,   47,   46,   44,\n    42,   41,   39,   37,   36,   34,   33,   31,   30,   28,   26,   25,\n    23,   22,   20,   19,   17,   16,   14,   13,   11,   10,   8,    7,\n    5,    4,    2,    1,\n};\n\nstatic unsigned ZSTD_getFSEMaxSymbolValue(FSE_CTable const* ctable) {\n  void const* ptr = ctable;\n  U16 const* u16ptr = (U16 const*)ptr;\n  U32 const maxSymbolValue = MEM_read16(u16ptr + 1);\n  return maxSymbolValue;\n}\n\n/**\n * Returns true if we should use ncount=-1 else we should\n * use ncount=1 for low probability symbols instead.\n */\nstatic unsigned ZSTD_useLowProbCount(size_t const nbSeq)\n{\n    /* Heuristic: This should cover most blocks <= 16K and\n     * start to fade out after 16K to about 32K depending on\n     * compressibility.\n     */\n    return nbSeq >= 2048;\n}\n\n/**\n * Returns the cost in bytes of encoding the normalized count header.\n * Returns an error if any of the helper functions return an error.\n */\nstatic size_t ZSTD_NCountCost(unsigned const* count, unsigned const max,\n                              size_t const nbSeq, unsigned const FSELog)\n{\n    BYTE wksp[FSE_NCOUNTBOUND];\n    S16 norm[MaxSeq + 1];\n    const U32 tableLog = FSE_optimalTableLog(FSELog, nbSeq, max);\n    FORWARD_IF_ERROR(FSE_normalizeCount(norm, tableLog, count, nbSeq, max, ZSTD_useLowProbCount(nbSeq)), \"\");\n    return FSE_writeNCount(wksp, sizeof(wksp), norm, max, tableLog);\n}\n\n/**\n * Returns the cost in bits of encoding the distribution described by count\n * using the entropy bound.\n */\nstatic size_t ZSTD_entropyCost(unsigned const* count, unsigned const max, size_t const total)\n{\n    unsigned cost = 0;\n    unsigned s;\n\n    assert(total > 0);\n    for (s = 0; s <= max; ++s) {\n        unsigned norm = (unsigned)((256 * count[s]) / total);\n        if (count[s] != 0 && norm == 0)\n            norm = 1;\n        assert(count[s] < total);\n        cost += count[s] * kInverseProbabilityLog256[norm];\n    }\n    return cost >> 8;\n}\n\n/**\n * Returns the cost in bits of encoding the distribution in count using ctable.\n * Returns an error if ctable cannot represent all the symbols in count.\n */\nsize_t ZSTD_fseBitCost(\n    FSE_CTable const* ctable,\n    unsigned const* count,\n    unsigned const max)\n{\n    unsigned const kAccuracyLog = 8;\n    size_t cost = 0;\n    unsigned s;\n    FSE_CState_t cstate;\n    FSE_initCState(&cstate, ctable);\n    if (ZSTD_getFSEMaxSymbolValue(ctable) < max) {\n        DEBUGLOG(5, \"Repeat FSE_CTable has maxSymbolValue %u < %u\",\n                    ZSTD_getFSEMaxSymbolValue(ctable), max);\n        return ERROR(GENERIC);\n    }\n    for (s = 0; s <= max; ++s) {\n        unsigned const tableLog = cstate.stateLog;\n        unsigned const badCost = (tableLog + 1) << kAccuracyLog;\n        unsigned const bitCost = FSE_bitCost(cstate.symbolTT, tableLog, s, kAccuracyLog);\n        if (count[s] == 0)\n            continue;\n        if (bitCost >= badCost) {\n            DEBUGLOG(5, \"Repeat FSE_CTable has Prob[%u] == 0\", s);\n            return ERROR(GENERIC);\n        }\n        cost += (size_t)count[s] * bitCost;\n    }\n    return cost >> kAccuracyLog;\n}\n\n/**\n * Returns the cost in bits of encoding the distribution in count using the\n * table described by norm. The max symbol support by norm is assumed >= max.\n * norm must be valid for every symbol with non-zero probability in count.\n */\nsize_t ZSTD_crossEntropyCost(short const* norm, unsigned accuracyLog,\n                             unsigned const* count, unsigned const max)\n{\n    unsigned const shift = 8 - accuracyLog;\n    size_t cost = 0;\n    unsigned s;\n    assert(accuracyLog <= 8);\n    for (s = 0; s <= max; ++s) {\n        unsigned const normAcc = (norm[s] != -1) ? (unsigned)norm[s] : 1;\n        unsigned const norm256 = normAcc << shift;\n        assert(norm256 > 0);\n        assert(norm256 < 256);\n        cost += count[s] * kInverseProbabilityLog256[norm256];\n    }\n    return cost >> 8;\n}\n\nSymbolEncodingType_e\nZSTD_selectEncodingType(\n        FSE_repeat* repeatMode, unsigned const* count, unsigned const max,\n        size_t const mostFrequent, size_t nbSeq, unsigned const FSELog,\n        FSE_CTable const* prevCTable,\n        short const* defaultNorm, U32 defaultNormLog,\n        ZSTD_DefaultPolicy_e const isDefaultAllowed,\n        ZSTD_strategy const strategy)\n{\n    ZSTD_STATIC_ASSERT(ZSTD_defaultDisallowed == 0 && ZSTD_defaultAllowed != 0);\n    if (mostFrequent == nbSeq) {\n        *repeatMode = FSE_repeat_none;\n        if (isDefaultAllowed && nbSeq <= 2) {\n            /* Prefer set_basic over set_rle when there are 2 or fewer symbols,\n             * since RLE uses 1 byte, but set_basic uses 5-6 bits per symbol.\n             * If basic encoding isn't possible, always choose RLE.\n             */\n            DEBUGLOG(5, \"Selected set_basic\");\n            return set_basic;\n        }\n        DEBUGLOG(5, \"Selected set_rle\");\n        return set_rle;\n    }\n    if (strategy < ZSTD_lazy) {\n        if (isDefaultAllowed) {\n            size_t const staticFse_nbSeq_max = 1000;\n            size_t const mult = 10 - strategy;\n            size_t const baseLog = 3;\n            size_t const dynamicFse_nbSeq_min = (((size_t)1 << defaultNormLog) * mult) >> baseLog;  /* 28-36 for offset, 56-72 for lengths */\n            assert(defaultNormLog >= 5 && defaultNormLog <= 6);  /* xx_DEFAULTNORMLOG */\n            assert(mult <= 9 && mult >= 7);\n            if ( (*repeatMode == FSE_repeat_valid)\n              && (nbSeq < staticFse_nbSeq_max) ) {\n                DEBUGLOG(5, \"Selected set_repeat\");\n                return set_repeat;\n            }\n            if ( (nbSeq < dynamicFse_nbSeq_min)\n              || (mostFrequent < (nbSeq >> (defaultNormLog-1))) ) {\n                DEBUGLOG(5, \"Selected set_basic\");\n                /* The format allows default tables to be repeated, but it isn't useful.\n                 * When using simple heuristics to select encoding type, we don't want\n                 * to confuse these tables with dictionaries. When running more careful\n                 * analysis, we don't need to waste time checking both repeating tables\n                 * and default tables.\n                 */\n                *repeatMode = FSE_repeat_none;\n                return set_basic;\n            }\n        }\n    } else {\n        size_t const basicCost = isDefaultAllowed ? ZSTD_crossEntropyCost(defaultNorm, defaultNormLog, count, max) : ERROR(GENERIC);\n        size_t const repeatCost = *repeatMode != FSE_repeat_none ? ZSTD_fseBitCost(prevCTable, count, max) : ERROR(GENERIC);\n        size_t const NCountCost = ZSTD_NCountCost(count, max, nbSeq, FSELog);\n        size_t const compressedCost = (NCountCost << 3) + ZSTD_entropyCost(count, max, nbSeq);\n\n        if (isDefaultAllowed) {\n            assert(!ZSTD_isError(basicCost));\n            assert(!(*repeatMode == FSE_repeat_valid && ZSTD_isError(repeatCost)));\n        }\n        assert(!ZSTD_isError(NCountCost));\n        assert(compressedCost < ERROR(maxCode));\n        DEBUGLOG(5, \"Estimated bit costs: basic=%u\\trepeat=%u\\tcompressed=%u\",\n                    (unsigned)basicCost, (unsigned)repeatCost, (unsigned)compressedCost);\n        if (basicCost <= repeatCost && basicCost <= compressedCost) {\n            DEBUGLOG(5, \"Selected set_basic\");\n            assert(isDefaultAllowed);\n            *repeatMode = FSE_repeat_none;\n            return set_basic;\n        }\n        if (repeatCost <= compressedCost) {\n            DEBUGLOG(5, \"Selected set_repeat\");\n            assert(!ZSTD_isError(repeatCost));\n            return set_repeat;\n        }\n        assert(compressedCost < basicCost && compressedCost < repeatCost);\n    }\n    DEBUGLOG(5, \"Selected set_compressed\");\n    *repeatMode = FSE_repeat_check;\n    return set_compressed;\n}\n\ntypedef struct {\n    S16 norm[MaxSeq + 1];\n    U32 wksp[FSE_BUILD_CTABLE_WORKSPACE_SIZE_U32(MaxSeq, MaxFSELog)];\n} ZSTD_BuildCTableWksp;\n\nsize_t\nZSTD_buildCTable(void* dst, size_t dstCapacity,\n                FSE_CTable* nextCTable, U32 FSELog, SymbolEncodingType_e type,\n                unsigned* count, U32 max,\n                const BYTE* codeTable, size_t nbSeq,\n                const S16* defaultNorm, U32 defaultNormLog, U32 defaultMax,\n                const FSE_CTable* prevCTable, size_t prevCTableSize,\n                void* entropyWorkspace, size_t entropyWorkspaceSize)\n{\n    BYTE* op = (BYTE*)dst;\n    const BYTE* const oend = op + dstCapacity;\n    DEBUGLOG(6, \"ZSTD_buildCTable (dstCapacity=%u)\", (unsigned)dstCapacity);\n\n    switch (type) {\n    case set_rle:\n        FORWARD_IF_ERROR(FSE_buildCTable_rle(nextCTable, (BYTE)max), \"\");\n        RETURN_ERROR_IF(dstCapacity==0, dstSize_tooSmall, \"not enough space\");\n        *op = codeTable[0];\n        return 1;\n    case set_repeat:\n        ZSTD_memcpy(nextCTable, prevCTable, prevCTableSize);\n        return 0;\n    case set_basic:\n        FORWARD_IF_ERROR(FSE_buildCTable_wksp(nextCTable, defaultNorm, defaultMax, defaultNormLog, entropyWorkspace, entropyWorkspaceSize), \"\");  /* note : could be pre-calculated */\n        return 0;\n    case set_compressed: {\n        ZSTD_BuildCTableWksp* wksp = (ZSTD_BuildCTableWksp*)entropyWorkspace;\n        size_t nbSeq_1 = nbSeq;\n        const U32 tableLog = FSE_optimalTableLog(FSELog, nbSeq, max);\n        if (count[codeTable[nbSeq-1]] > 1) {\n            count[codeTable[nbSeq-1]]--;\n            nbSeq_1--;\n        }\n        assert(nbSeq_1 > 1);\n        assert(entropyWorkspaceSize >= sizeof(ZSTD_BuildCTableWksp));\n        (void)entropyWorkspaceSize;\n        FORWARD_IF_ERROR(FSE_normalizeCount(wksp->norm, tableLog, count, nbSeq_1, max, ZSTD_useLowProbCount(nbSeq_1)), \"FSE_normalizeCount failed\");\n        assert(oend >= op);\n        {   size_t const NCountSize = FSE_writeNCount(op, (size_t)(oend - op), wksp->norm, max, tableLog);   /* overflow protected */\n            FORWARD_IF_ERROR(NCountSize, \"FSE_writeNCount failed\");\n            FORWARD_IF_ERROR(FSE_buildCTable_wksp(nextCTable, wksp->norm, max, tableLog, wksp->wksp, sizeof(wksp->wksp)), \"FSE_buildCTable_wksp failed\");\n            return NCountSize;\n        }\n    }\n    default: assert(0); RETURN_ERROR(GENERIC, \"impossible to reach\");\n    }\n}\n\nFORCE_INLINE_TEMPLATE size_t\nZSTD_encodeSequences_body(\n            void* dst, size_t dstCapacity,\n            FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,\n            FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,\n            FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,\n            SeqDef const* sequences, size_t nbSeq, int longOffsets)\n{\n    BIT_CStream_t blockStream;\n    FSE_CState_t  stateMatchLength;\n    FSE_CState_t  stateOffsetBits;\n    FSE_CState_t  stateLitLength;\n\n    RETURN_ERROR_IF(\n        ERR_isError(BIT_initCStream(&blockStream, dst, dstCapacity)),\n        dstSize_tooSmall, \"not enough space remaining\");\n    DEBUGLOG(6, \"available space for bitstream : %i  (dstCapacity=%u)\",\n                (int)(blockStream.endPtr - blockStream.startPtr),\n                (unsigned)dstCapacity);\n\n    /* first symbols */\n    FSE_initCState2(&stateMatchLength, CTable_MatchLength, mlCodeTable[nbSeq-1]);\n    FSE_initCState2(&stateOffsetBits,  CTable_OffsetBits,  ofCodeTable[nbSeq-1]);\n    FSE_initCState2(&stateLitLength,   CTable_LitLength,   llCodeTable[nbSeq-1]);\n    BIT_addBits(&blockStream, sequences[nbSeq-1].litLength, LL_bits[llCodeTable[nbSeq-1]]);\n    if (MEM_32bits()) BIT_flushBits(&blockStream);\n    BIT_addBits(&blockStream, sequences[nbSeq-1].mlBase, ML_bits[mlCodeTable[nbSeq-1]]);\n    if (MEM_32bits()) BIT_flushBits(&blockStream);\n    if (longOffsets) {\n        U32 const ofBits = ofCodeTable[nbSeq-1];\n        unsigned const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);\n        if (extraBits) {\n            BIT_addBits(&blockStream, sequences[nbSeq-1].offBase, extraBits);\n            BIT_flushBits(&blockStream);\n        }\n        BIT_addBits(&blockStream, sequences[nbSeq-1].offBase >> extraBits,\n                    ofBits - extraBits);\n    } else {\n        BIT_addBits(&blockStream, sequences[nbSeq-1].offBase, ofCodeTable[nbSeq-1]);\n    }\n    BIT_flushBits(&blockStream);\n\n    {   size_t n;\n        for (n=nbSeq-2 ; n= 64-7-(LLFSELog+MLFSELog+OffFSELog)))\n                BIT_flushBits(&blockStream);                                /* (7)*/\n            BIT_addBits(&blockStream, sequences[n].litLength, llBits);\n            if (MEM_32bits() && ((llBits+mlBits)>24)) BIT_flushBits(&blockStream);\n            BIT_addBits(&blockStream, sequences[n].mlBase, mlBits);\n            if (MEM_32bits() || (ofBits+mlBits+llBits > 56)) BIT_flushBits(&blockStream);\n            if (longOffsets) {\n                unsigned const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);\n                if (extraBits) {\n                    BIT_addBits(&blockStream, sequences[n].offBase, extraBits);\n                    BIT_flushBits(&blockStream);                            /* (7)*/\n                }\n                BIT_addBits(&blockStream, sequences[n].offBase >> extraBits,\n                            ofBits - extraBits);                            /* 31 */\n            } else {\n                BIT_addBits(&blockStream, sequences[n].offBase, ofBits);     /* 31 */\n            }\n            BIT_flushBits(&blockStream);                                    /* (7)*/\n            DEBUGLOG(7, \"remaining space : %i\", (int)(blockStream.endPtr - blockStream.ptr));\n    }   }\n\n    DEBUGLOG(6, \"ZSTD_encodeSequences: flushing ML state with %u bits\", stateMatchLength.stateLog);\n    FSE_flushCState(&blockStream, &stateMatchLength);\n    DEBUGLOG(6, \"ZSTD_encodeSequences: flushing Off state with %u bits\", stateOffsetBits.stateLog);\n    FSE_flushCState(&blockStream, &stateOffsetBits);\n    DEBUGLOG(6, \"ZSTD_encodeSequences: flushing LL state with %u bits\", stateLitLength.stateLog);\n    FSE_flushCState(&blockStream, &stateLitLength);\n\n    {   size_t const streamSize = BIT_closeCStream(&blockStream);\n        RETURN_ERROR_IF(streamSize==0, dstSize_tooSmall, \"not enough space\");\n        return streamSize;\n    }\n}\n\nstatic size_t\nZSTD_encodeSequences_default(\n            void* dst, size_t dstCapacity,\n            FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,\n            FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,\n            FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,\n            SeqDef const* sequences, size_t nbSeq, int longOffsets)\n{\n    return ZSTD_encodeSequences_body(dst, dstCapacity,\n                                    CTable_MatchLength, mlCodeTable,\n                                    CTable_OffsetBits, ofCodeTable,\n                                    CTable_LitLength, llCodeTable,\n                                    sequences, nbSeq, longOffsets);\n}\n\n\n#if DYNAMIC_BMI2\n\nstatic BMI2_TARGET_ATTRIBUTE size_t\nZSTD_encodeSequences_bmi2(\n            void* dst, size_t dstCapacity,\n            FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,\n            FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,\n            FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,\n            SeqDef const* sequences, size_t nbSeq, int longOffsets)\n{\n    return ZSTD_encodeSequences_body(dst, dstCapacity,\n                                    CTable_MatchLength, mlCodeTable,\n                                    CTable_OffsetBits, ofCodeTable,\n                                    CTable_LitLength, llCodeTable,\n                                    sequences, nbSeq, longOffsets);\n}\n\n#endif\n\nsize_t ZSTD_encodeSequences(\n            void* dst, size_t dstCapacity,\n            FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,\n            FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,\n            FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,\n            SeqDef const* sequences, size_t nbSeq, int longOffsets, int bmi2)\n{\n    DEBUGLOG(5, \"ZSTD_encodeSequences: dstCapacity = %u\", (unsigned)dstCapacity);\n#if DYNAMIC_BMI2\n    if (bmi2) {\n        return ZSTD_encodeSequences_bmi2(dst, dstCapacity,\n                                         CTable_MatchLength, mlCodeTable,\n                                         CTable_OffsetBits, ofCodeTable,\n                                         CTable_LitLength, llCodeTable,\n                                         sequences, nbSeq, longOffsets);\n    }\n#endif\n    (void)bmi2;\n    return ZSTD_encodeSequences_default(dst, dstCapacity,\n                                        CTable_MatchLength, mlCodeTable,\n                                        CTable_OffsetBits, ofCodeTable,\n                                        CTable_LitLength, llCodeTable,\n                                        sequences, nbSeq, longOffsets);\n}\n"
  },
  {
    "path": "lib/compress/zstd_compress_sequences.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_COMPRESS_SEQUENCES_H\n#define ZSTD_COMPRESS_SEQUENCES_H\n\n#include \"zstd_compress_internal.h\" /* SeqDef */\n#include \"../common/fse.h\" /* FSE_repeat, FSE_CTable */\n#include \"../common/zstd_internal.h\" /* SymbolEncodingType_e, ZSTD_strategy */\n\ntypedef enum {\n    ZSTD_defaultDisallowed = 0,\n    ZSTD_defaultAllowed = 1\n} ZSTD_DefaultPolicy_e;\n\nSymbolEncodingType_e\nZSTD_selectEncodingType(\n        FSE_repeat* repeatMode, unsigned const* count, unsigned const max,\n        size_t const mostFrequent, size_t nbSeq, unsigned const FSELog,\n        FSE_CTable const* prevCTable,\n        short const* defaultNorm, U32 defaultNormLog,\n        ZSTD_DefaultPolicy_e const isDefaultAllowed,\n        ZSTD_strategy const strategy);\n\nsize_t\nZSTD_buildCTable(void* dst, size_t dstCapacity,\n                FSE_CTable* nextCTable, U32 FSELog, SymbolEncodingType_e type,\n                unsigned* count, U32 max,\n                const BYTE* codeTable, size_t nbSeq,\n                const S16* defaultNorm, U32 defaultNormLog, U32 defaultMax,\n                const FSE_CTable* prevCTable, size_t prevCTableSize,\n                void* entropyWorkspace, size_t entropyWorkspaceSize);\n\nsize_t ZSTD_encodeSequences(\n            void* dst, size_t dstCapacity,\n            FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,\n            FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,\n            FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,\n            SeqDef const* sequences, size_t nbSeq, int longOffsets, int bmi2);\n\nsize_t ZSTD_fseBitCost(\n    FSE_CTable const* ctable,\n    unsigned const* count,\n    unsigned const max);\n\nsize_t ZSTD_crossEntropyCost(short const* norm, unsigned accuracyLog,\n                             unsigned const* count, unsigned const max);\n#endif /* ZSTD_COMPRESS_SEQUENCES_H */\n"
  },
  {
    "path": "lib/compress/zstd_compress_superblock.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n /*-*************************************\n *  Dependencies\n ***************************************/\n#include \"zstd_compress_superblock.h\"\n\n#include \"../common/zstd_internal.h\"  /* ZSTD_getSequenceLength */\n#include \"hist.h\"                     /* HIST_countFast_wksp */\n#include \"zstd_compress_internal.h\"   /* ZSTD_[huf|fse|entropy]CTablesMetadata_t */\n#include \"zstd_compress_sequences.h\"\n#include \"zstd_compress_literals.h\"\n\n/** ZSTD_compressSubBlock_literal() :\n *  Compresses literals section for a sub-block.\n *  When we have to write the Huffman table we will sometimes choose a header\n *  size larger than necessary. This is because we have to pick the header size\n *  before we know the table size + compressed size, so we have a bound on the\n *  table size. If we guessed incorrectly, we fall back to uncompressed literals.\n *\n *  We write the header when writeEntropy=1 and set entropyWritten=1 when we succeeded\n *  in writing the header, otherwise it is set to 0.\n *\n *  hufMetadata->hType has literals block type info.\n *      If it is set_basic, all sub-blocks literals section will be Raw_Literals_Block.\n *      If it is set_rle, all sub-blocks literals section will be RLE_Literals_Block.\n *      If it is set_compressed, first sub-block's literals section will be Compressed_Literals_Block\n *      If it is set_compressed, first sub-block's literals section will be Treeless_Literals_Block\n *      and the following sub-blocks' literals sections will be Treeless_Literals_Block.\n *  @return : compressed size of literals section of a sub-block\n *            Or 0 if unable to compress.\n *            Or error code */\nstatic size_t\nZSTD_compressSubBlock_literal(const HUF_CElt* hufTable,\n                              const ZSTD_hufCTablesMetadata_t* hufMetadata,\n                              const BYTE* literals, size_t litSize,\n                              void* dst, size_t dstSize,\n                              const int bmi2, int writeEntropy, int* entropyWritten)\n{\n    size_t const header = writeEntropy ? 200 : 0;\n    size_t const lhSize = 3 + (litSize >= (1 KB - header)) + (litSize >= (16 KB - header));\n    BYTE* const ostart = (BYTE*)dst;\n    BYTE* const oend = ostart + dstSize;\n    BYTE* op = ostart + lhSize;\n    U32 const singleStream = lhSize == 3;\n    SymbolEncodingType_e hType = writeEntropy ? hufMetadata->hType : set_repeat;\n    size_t cLitSize = 0;\n\n    DEBUGLOG(5, \"ZSTD_compressSubBlock_literal (litSize=%zu, lhSize=%zu, writeEntropy=%d)\", litSize, lhSize, writeEntropy);\n\n    *entropyWritten = 0;\n    if (litSize == 0 || hufMetadata->hType == set_basic) {\n      DEBUGLOG(5, \"ZSTD_compressSubBlock_literal using raw literal\");\n      return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize);\n    } else if (hufMetadata->hType == set_rle) {\n      DEBUGLOG(5, \"ZSTD_compressSubBlock_literal using rle literal\");\n      return ZSTD_compressRleLiteralsBlock(dst, dstSize, literals, litSize);\n    }\n\n    assert(litSize > 0);\n    assert(hufMetadata->hType == set_compressed || hufMetadata->hType == set_repeat);\n\n    if (writeEntropy && hufMetadata->hType == set_compressed) {\n        ZSTD_memcpy(op, hufMetadata->hufDesBuffer, hufMetadata->hufDesSize);\n        op += hufMetadata->hufDesSize;\n        cLitSize += hufMetadata->hufDesSize;\n        DEBUGLOG(5, \"ZSTD_compressSubBlock_literal (hSize=%zu)\", hufMetadata->hufDesSize);\n    }\n\n    {   int const flags = bmi2 ? HUF_flags_bmi2 : 0;\n        const size_t cSize = singleStream ? HUF_compress1X_usingCTable(op, (size_t)(oend-op), literals, litSize, hufTable, flags)\n                                          : HUF_compress4X_usingCTable(op, (size_t)(oend-op), literals, litSize, hufTable, flags);\n        op += cSize;\n        cLitSize += cSize;\n        if (cSize == 0 || ERR_isError(cSize)) {\n            DEBUGLOG(5, \"Failed to write entropy tables %s\", ZSTD_getErrorName(cSize));\n            return 0;\n        }\n        /* If we expand and we aren't writing a header then emit uncompressed */\n        if (!writeEntropy && cLitSize >= litSize) {\n            DEBUGLOG(5, \"ZSTD_compressSubBlock_literal using raw literal because uncompressible\");\n            return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize);\n        }\n        /* If we are writing headers then allow expansion that doesn't change our header size. */\n        if (lhSize < (size_t)(3 + (cLitSize >= 1 KB) + (cLitSize >= 16 KB))) {\n            assert(cLitSize > litSize);\n            DEBUGLOG(5, \"Literals expanded beyond allowed header size\");\n            return ZSTD_noCompressLiterals(dst, dstSize, literals, litSize);\n        }\n        DEBUGLOG(5, \"ZSTD_compressSubBlock_literal (cSize=%zu)\", cSize);\n    }\n\n    /* Build header */\n    switch(lhSize)\n    {\n    case 3: /* 2 - 2 - 10 - 10 */\n        {   U32 const lhc = hType + ((U32)(!singleStream) << 2) + ((U32)litSize<<4) + ((U32)cLitSize<<14);\n            MEM_writeLE24(ostart, lhc);\n            break;\n        }\n    case 4: /* 2 - 2 - 14 - 14 */\n        {   U32 const lhc = hType + (2 << 2) + ((U32)litSize<<4) + ((U32)cLitSize<<18);\n            MEM_writeLE32(ostart, lhc);\n            break;\n        }\n    case 5: /* 2 - 2 - 18 - 18 */\n        {   U32 const lhc = hType + (3 << 2) + ((U32)litSize<<4) + ((U32)cLitSize<<22);\n            MEM_writeLE32(ostart, lhc);\n            ostart[4] = (BYTE)(cLitSize >> 10);\n            break;\n        }\n    default:  /* not possible : lhSize is {3,4,5} */\n        assert(0);\n    }\n    *entropyWritten = 1;\n    DEBUGLOG(5, \"Compressed literals: %u -> %u\", (U32)litSize, (U32)(op-ostart));\n    return (size_t)(op-ostart);\n}\n\nstatic size_t\nZSTD_seqDecompressedSize(SeqStore_t const* seqStore,\n                   const SeqDef* sequences, size_t nbSeqs,\n                         size_t litSize, int lastSubBlock)\n{\n    size_t matchLengthSum = 0;\n    size_t litLengthSum = 0;\n    size_t n;\n    for (n=0; nllType, fseMetadata->ofType, and fseMetadata->mlType have\n *  symbol compression modes for the super-block.\n *  The first successfully compressed block will have these in its header.\n *  We set entropyWritten=1 when we succeed in compressing the sequences.\n *  The following sub-blocks will always have repeat mode.\n *  @return : compressed size of sequences section of a sub-block\n *            Or 0 if it is unable to compress\n *            Or error code. */\nstatic size_t\nZSTD_compressSubBlock_sequences(const ZSTD_fseCTables_t* fseTables,\n                                const ZSTD_fseCTablesMetadata_t* fseMetadata,\n                                const SeqDef* sequences, size_t nbSeq,\n                                const BYTE* llCode, const BYTE* mlCode, const BYTE* ofCode,\n                                const ZSTD_CCtx_params* cctxParams,\n                                void* dst, size_t dstCapacity,\n                                const int bmi2, int writeEntropy, int* entropyWritten)\n{\n    const int longOffsets = cctxParams->cParams.windowLog > STREAM_ACCUMULATOR_MIN;\n    BYTE* const ostart = (BYTE*)dst;\n    BYTE* const oend = ostart + dstCapacity;\n    BYTE* op = ostart;\n    BYTE* seqHead;\n\n    DEBUGLOG(5, \"ZSTD_compressSubBlock_sequences (nbSeq=%zu, writeEntropy=%d, longOffsets=%d)\", nbSeq, writeEntropy, longOffsets);\n\n    *entropyWritten = 0;\n    /* Sequences Header */\n    RETURN_ERROR_IF((oend-op) < 3 /*max nbSeq Size*/ + 1 /*seqHead*/,\n                    dstSize_tooSmall, \"\");\n    if (nbSeq < 128)\n        *op++ = (BYTE)nbSeq;\n    else if (nbSeq < LONGNBSEQ)\n        op[0] = (BYTE)((nbSeq>>8) + 0x80), op[1] = (BYTE)nbSeq, op+=2;\n    else\n        op[0]=0xFF, MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ)), op+=3;\n    if (nbSeq==0) {\n        return (size_t)(op - ostart);\n    }\n\n    /* seqHead : flags for FSE encoding type */\n    seqHead = op++;\n\n    DEBUGLOG(5, \"ZSTD_compressSubBlock_sequences (seqHeadSize=%u)\", (unsigned)(op-ostart));\n\n    if (writeEntropy) {\n        const U32 LLtype = fseMetadata->llType;\n        const U32 Offtype = fseMetadata->ofType;\n        const U32 MLtype = fseMetadata->mlType;\n        DEBUGLOG(5, \"ZSTD_compressSubBlock_sequences (fseTablesSize=%zu)\", fseMetadata->fseTablesSize);\n        *seqHead = (BYTE)((LLtype<<6) + (Offtype<<4) + (MLtype<<2));\n        ZSTD_memcpy(op, fseMetadata->fseTablesBuffer, fseMetadata->fseTablesSize);\n        op += fseMetadata->fseTablesSize;\n    } else {\n        const U32 repeat = set_repeat;\n        *seqHead = (BYTE)((repeat<<6) + (repeat<<4) + (repeat<<2));\n    }\n\n    {   size_t const bitstreamSize = ZSTD_encodeSequences(\n                                        op, (size_t)(oend - op),\n                                        fseTables->matchlengthCTable, mlCode,\n                                        fseTables->offcodeCTable, ofCode,\n                                        fseTables->litlengthCTable, llCode,\n                                        sequences, nbSeq,\n                                        longOffsets, bmi2);\n        FORWARD_IF_ERROR(bitstreamSize, \"ZSTD_encodeSequences failed\");\n        op += bitstreamSize;\n        /* zstd versions <= 1.3.4 mistakenly report corruption when\n         * FSE_readNCount() receives a buffer < 4 bytes.\n         * Fixed by https://github.com/facebook/zstd/pull/1146.\n         * This can happen when the last set_compressed table present is 2\n         * bytes and the bitstream is only one byte.\n         * In this exceedingly rare case, we will simply emit an uncompressed\n         * block, since it isn't worth optimizing.\n         */\n#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION\n        if (writeEntropy && fseMetadata->lastCountSize && fseMetadata->lastCountSize + bitstreamSize < 4) {\n            /* NCountSize >= 2 && bitstreamSize > 0 ==> lastCountSize == 3 */\n            assert(fseMetadata->lastCountSize + bitstreamSize == 3);\n            DEBUGLOG(5, \"Avoiding bug in zstd decoder in versions <= 1.3.4 by \"\n                        \"emitting an uncompressed block.\");\n            return 0;\n        }\n#endif\n        DEBUGLOG(5, \"ZSTD_compressSubBlock_sequences (bitstreamSize=%zu)\", bitstreamSize);\n    }\n\n    /* zstd versions <= 1.4.0 mistakenly report error when\n     * sequences section body size is less than 3 bytes.\n     * Fixed by https://github.com/facebook/zstd/pull/1664.\n     * This can happen when the previous sequences section block is compressed\n     * with rle mode and the current block's sequences section is compressed\n     * with repeat mode where sequences section body size can be 1 byte.\n     */\n#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION\n    if (op-seqHead < 4) {\n        DEBUGLOG(5, \"Avoiding bug in zstd decoder in versions <= 1.4.0 by emitting \"\n                    \"an uncompressed block when sequences are < 4 bytes\");\n        return 0;\n    }\n#endif\n\n    *entropyWritten = 1;\n    return (size_t)(op - ostart);\n}\n\n/** ZSTD_compressSubBlock() :\n *  Compresses a single sub-block.\n *  @return : compressed size of the sub-block\n *            Or 0 if it failed to compress. */\nstatic size_t ZSTD_compressSubBlock(const ZSTD_entropyCTables_t* entropy,\n                                    const ZSTD_entropyCTablesMetadata_t* entropyMetadata,\n                                    const SeqDef* sequences, size_t nbSeq,\n                                    const BYTE* literals, size_t litSize,\n                                    const BYTE* llCode, const BYTE* mlCode, const BYTE* ofCode,\n                                    const ZSTD_CCtx_params* cctxParams,\n                                    void* dst, size_t dstCapacity,\n                                    const int bmi2,\n                                    int writeLitEntropy, int writeSeqEntropy,\n                                    int* litEntropyWritten, int* seqEntropyWritten,\n                                    U32 lastBlock)\n{\n    BYTE* const ostart = (BYTE*)dst;\n    BYTE* const oend = ostart + dstCapacity;\n    BYTE* op = ostart + ZSTD_blockHeaderSize;\n    DEBUGLOG(5, \"ZSTD_compressSubBlock (litSize=%zu, nbSeq=%zu, writeLitEntropy=%d, writeSeqEntropy=%d, lastBlock=%d)\",\n                litSize, nbSeq, writeLitEntropy, writeSeqEntropy, lastBlock);\n    {   size_t cLitSize = ZSTD_compressSubBlock_literal((const HUF_CElt*)entropy->huf.CTable,\n                                                        &entropyMetadata->hufMetadata, literals, litSize,\n                                                        op, (size_t)(oend-op),\n                                                        bmi2, writeLitEntropy, litEntropyWritten);\n        FORWARD_IF_ERROR(cLitSize, \"ZSTD_compressSubBlock_literal failed\");\n        if (cLitSize == 0) return 0;\n        op += cLitSize;\n    }\n    {   size_t cSeqSize = ZSTD_compressSubBlock_sequences(&entropy->fse,\n                                                  &entropyMetadata->fseMetadata,\n                                                  sequences, nbSeq,\n                                                  llCode, mlCode, ofCode,\n                                                  cctxParams,\n                                                  op, (size_t)(oend-op),\n                                                  bmi2, writeSeqEntropy, seqEntropyWritten);\n        FORWARD_IF_ERROR(cSeqSize, \"ZSTD_compressSubBlock_sequences failed\");\n        if (cSeqSize == 0) return 0;\n        op += cSeqSize;\n    }\n    /* Write block header */\n    {   size_t cSize = (size_t)(op-ostart) - ZSTD_blockHeaderSize;\n        U32 const cBlockHeader24 = lastBlock + (((U32)bt_compressed)<<1) + (U32)(cSize << 3);\n        MEM_writeLE24(ostart, cBlockHeader24);\n    }\n    return (size_t)(op-ostart);\n}\n\nstatic size_t ZSTD_estimateSubBlockSize_literal(const BYTE* literals, size_t litSize,\n                                                const ZSTD_hufCTables_t* huf,\n                                                const ZSTD_hufCTablesMetadata_t* hufMetadata,\n                                                void* workspace, size_t wkspSize,\n                                                int writeEntropy)\n{\n    unsigned* const countWksp = (unsigned*)workspace;\n    unsigned maxSymbolValue = 255;\n    size_t literalSectionHeaderSize = 3; /* Use hard coded size of 3 bytes */\n\n    if (hufMetadata->hType == set_basic) return litSize;\n    else if (hufMetadata->hType == set_rle) return 1;\n    else if (hufMetadata->hType == set_compressed || hufMetadata->hType == set_repeat) {\n        size_t const largest = HIST_count_wksp (countWksp, &maxSymbolValue, (const BYTE*)literals, litSize, workspace, wkspSize);\n        if (ZSTD_isError(largest)) return litSize;\n        {   size_t cLitSizeEstimate = HUF_estimateCompressedSize((const HUF_CElt*)huf->CTable, countWksp, maxSymbolValue);\n            if (writeEntropy) cLitSizeEstimate += hufMetadata->hufDesSize;\n            return cLitSizeEstimate + literalSectionHeaderSize;\n    }   }\n    assert(0); /* impossible */\n    return 0;\n}\n\nstatic size_t ZSTD_estimateSubBlockSize_symbolType(SymbolEncodingType_e type,\n                        const BYTE* codeTable, unsigned maxCode,\n                        size_t nbSeq, const FSE_CTable* fseCTable,\n                        const U8* additionalBits,\n                        short const* defaultNorm, U32 defaultNormLog, U32 defaultMax,\n                        void* workspace, size_t wkspSize)\n{\n    unsigned* const countWksp = (unsigned*)workspace;\n    const BYTE* ctp = codeTable;\n    const BYTE* const ctStart = ctp;\n    const BYTE* const ctEnd = ctStart + nbSeq;\n    size_t cSymbolTypeSizeEstimateInBits = 0;\n    unsigned max = maxCode;\n\n    HIST_countFast_wksp(countWksp, &max, codeTable, nbSeq, workspace, wkspSize);  /* can't fail */\n    if (type == set_basic) {\n        /* We selected this encoding type, so it must be valid. */\n        assert(max <= defaultMax);\n        cSymbolTypeSizeEstimateInBits = max <= defaultMax\n                ? ZSTD_crossEntropyCost(defaultNorm, defaultNormLog, countWksp, max)\n                : ERROR(GENERIC);\n    } else if (type == set_rle) {\n        cSymbolTypeSizeEstimateInBits = 0;\n    } else if (type == set_compressed || type == set_repeat) {\n        cSymbolTypeSizeEstimateInBits = ZSTD_fseBitCost(fseCTable, countWksp, max);\n    }\n    if (ZSTD_isError(cSymbolTypeSizeEstimateInBits)) return nbSeq * 10;\n    while (ctp < ctEnd) {\n        if (additionalBits) cSymbolTypeSizeEstimateInBits += additionalBits[*ctp];\n        else cSymbolTypeSizeEstimateInBits += *ctp; /* for offset, offset code is also the number of additional bits */\n        ctp++;\n    }\n    return cSymbolTypeSizeEstimateInBits / 8;\n}\n\nstatic size_t ZSTD_estimateSubBlockSize_sequences(const BYTE* ofCodeTable,\n                                                  const BYTE* llCodeTable,\n                                                  const BYTE* mlCodeTable,\n                                                  size_t nbSeq,\n                                                  const ZSTD_fseCTables_t* fseTables,\n                                                  const ZSTD_fseCTablesMetadata_t* fseMetadata,\n                                                  void* workspace, size_t wkspSize,\n                                                  int writeEntropy)\n{\n    size_t const sequencesSectionHeaderSize = 3; /* Use hard coded size of 3 bytes */\n    size_t cSeqSizeEstimate = 0;\n    if (nbSeq == 0) return sequencesSectionHeaderSize;\n    cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType(fseMetadata->ofType, ofCodeTable, MaxOff,\n                                         nbSeq, fseTables->offcodeCTable, NULL,\n                                         OF_defaultNorm, OF_defaultNormLog, DefaultMaxOff,\n                                         workspace, wkspSize);\n    cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType(fseMetadata->llType, llCodeTable, MaxLL,\n                                         nbSeq, fseTables->litlengthCTable, LL_bits,\n                                         LL_defaultNorm, LL_defaultNormLog, MaxLL,\n                                         workspace, wkspSize);\n    cSeqSizeEstimate += ZSTD_estimateSubBlockSize_symbolType(fseMetadata->mlType, mlCodeTable, MaxML,\n                                         nbSeq, fseTables->matchlengthCTable, ML_bits,\n                                         ML_defaultNorm, ML_defaultNormLog, MaxML,\n                                         workspace, wkspSize);\n    if (writeEntropy) cSeqSizeEstimate += fseMetadata->fseTablesSize;\n    return cSeqSizeEstimate + sequencesSectionHeaderSize;\n}\n\ntypedef struct {\n    size_t estLitSize;\n    size_t estBlockSize;\n} EstimatedBlockSize;\nstatic EstimatedBlockSize ZSTD_estimateSubBlockSize(const BYTE* literals, size_t litSize,\n                                        const BYTE* ofCodeTable,\n                                        const BYTE* llCodeTable,\n                                        const BYTE* mlCodeTable,\n                                        size_t nbSeq,\n                                        const ZSTD_entropyCTables_t* entropy,\n                                        const ZSTD_entropyCTablesMetadata_t* entropyMetadata,\n                                        void* workspace, size_t wkspSize,\n                                        int writeLitEntropy, int writeSeqEntropy)\n{\n    EstimatedBlockSize ebs;\n    ebs.estLitSize = ZSTD_estimateSubBlockSize_literal(literals, litSize,\n                                                        &entropy->huf, &entropyMetadata->hufMetadata,\n                                                        workspace, wkspSize, writeLitEntropy);\n    ebs.estBlockSize = ZSTD_estimateSubBlockSize_sequences(ofCodeTable, llCodeTable, mlCodeTable,\n                                                         nbSeq, &entropy->fse, &entropyMetadata->fseMetadata,\n                                                         workspace, wkspSize, writeSeqEntropy);\n    ebs.estBlockSize += ebs.estLitSize + ZSTD_blockHeaderSize;\n    return ebs;\n}\n\nstatic int ZSTD_needSequenceEntropyTables(ZSTD_fseCTablesMetadata_t const* fseMetadata)\n{\n    if (fseMetadata->llType == set_compressed || fseMetadata->llType == set_rle)\n        return 1;\n    if (fseMetadata->mlType == set_compressed || fseMetadata->mlType == set_rle)\n        return 1;\n    if (fseMetadata->ofType == set_compressed || fseMetadata->ofType == set_rle)\n        return 1;\n    return 0;\n}\n\nstatic size_t countLiterals(SeqStore_t const* seqStore, const SeqDef* sp, size_t seqCount)\n{\n    size_t n, total = 0;\n    assert(sp != NULL);\n    for (n=0; n %zu bytes\", seqCount, (const void*)sp, total);\n    return total;\n}\n\n#define BYTESCALE 256\n\nstatic size_t sizeBlockSequences(const SeqDef* sp, size_t nbSeqs,\n                size_t targetBudget, size_t avgLitCost, size_t avgSeqCost,\n                int firstSubBlock)\n{\n    size_t n, budget = 0, inSize=0;\n    /* entropy headers */\n    size_t const headerSize = (size_t)firstSubBlock * 120 * BYTESCALE; /* generous estimate */\n    assert(firstSubBlock==0 || firstSubBlock==1);\n    budget += headerSize;\n\n    /* first sequence => at least one sequence*/\n    budget += sp[0].litLength * avgLitCost + avgSeqCost;\n    if (budget > targetBudget) return 1;\n    inSize = sp[0].litLength + (sp[0].mlBase+MINMATCH);\n\n    /* loop over sequences */\n    for (n=1; n targetBudget)\n            /* though continue to expand until the sub-block is deemed compressible */\n          && (budget < inSize * BYTESCALE) )\n            break;\n    }\n\n    return n;\n}\n\n/** ZSTD_compressSubBlock_multi() :\n *  Breaks super-block into multiple sub-blocks and compresses them.\n *  Entropy will be written into the first block.\n *  The following blocks use repeat_mode to compress.\n *  Sub-blocks are all compressed, except the last one when beneficial.\n *  @return : compressed size of the super block (which features multiple ZSTD blocks)\n *            or 0 if it failed to compress. */\nstatic size_t ZSTD_compressSubBlock_multi(const SeqStore_t* seqStorePtr,\n                            const ZSTD_compressedBlockState_t* prevCBlock,\n                            ZSTD_compressedBlockState_t* nextCBlock,\n                            const ZSTD_entropyCTablesMetadata_t* entropyMetadata,\n                            const ZSTD_CCtx_params* cctxParams,\n                                  void* dst, size_t dstCapacity,\n                            const void* src, size_t srcSize,\n                            const int bmi2, U32 lastBlock,\n                            void* workspace, size_t wkspSize)\n{\n    const SeqDef* const sstart = seqStorePtr->sequencesStart;\n    const SeqDef* const send = seqStorePtr->sequences;\n    const SeqDef* sp = sstart; /* tracks progresses within seqStorePtr->sequences */\n    size_t const nbSeqs = (size_t)(send - sstart);\n    const BYTE* const lstart = seqStorePtr->litStart;\n    const BYTE* const lend = seqStorePtr->lit;\n    const BYTE* lp = lstart;\n    size_t const nbLiterals = (size_t)(lend - lstart);\n    BYTE const* ip = (BYTE const*)src;\n    BYTE const* const iend = ip + srcSize;\n    BYTE* const ostart = (BYTE*)dst;\n    BYTE* const oend = ostart + dstCapacity;\n    BYTE* op = ostart;\n    const BYTE* llCodePtr = seqStorePtr->llCode;\n    const BYTE* mlCodePtr = seqStorePtr->mlCode;\n    const BYTE* ofCodePtr = seqStorePtr->ofCode;\n    size_t const minTarget = ZSTD_TARGETCBLOCKSIZE_MIN; /* enforce minimum size, to reduce undesirable side effects */\n    size_t const targetCBlockSize = MAX(minTarget, cctxParams->targetCBlockSize);\n    int writeLitEntropy = (entropyMetadata->hufMetadata.hType == set_compressed);\n    int writeSeqEntropy = 1;\n\n    DEBUGLOG(5, \"ZSTD_compressSubBlock_multi (srcSize=%u, litSize=%u, nbSeq=%u)\",\n               (unsigned)srcSize, (unsigned)(lend-lstart), (unsigned)(send-sstart));\n\n        /* let's start by a general estimation for the full block */\n    if (nbSeqs > 0) {\n        EstimatedBlockSize const ebs =\n                ZSTD_estimateSubBlockSize(lp, nbLiterals,\n                                        ofCodePtr, llCodePtr, mlCodePtr, nbSeqs,\n                                        &nextCBlock->entropy, entropyMetadata,\n                                        workspace, wkspSize,\n                                        writeLitEntropy, writeSeqEntropy);\n        /* quick estimation */\n        size_t const avgLitCost = nbLiterals ? (ebs.estLitSize * BYTESCALE) / nbLiterals : BYTESCALE;\n        size_t const avgSeqCost = ((ebs.estBlockSize - ebs.estLitSize) * BYTESCALE) / nbSeqs;\n        const size_t nbSubBlocks = MAX((ebs.estBlockSize + (targetCBlockSize/2)) / targetCBlockSize, 1);\n        size_t n, avgBlockBudget, blockBudgetSupp=0;\n        avgBlockBudget = (ebs.estBlockSize * BYTESCALE) / nbSubBlocks;\n        DEBUGLOG(5, \"estimated fullblock size=%u bytes ; avgLitCost=%.2f ; avgSeqCost=%.2f ; targetCBlockSize=%u, nbSubBlocks=%u ; avgBlockBudget=%.0f bytes\",\n                    (unsigned)ebs.estBlockSize, (double)avgLitCost/BYTESCALE, (double)avgSeqCost/BYTESCALE,\n                    (unsigned)targetCBlockSize, (unsigned)nbSubBlocks, (double)avgBlockBudget/BYTESCALE);\n        /* simplification: if estimates states that the full superblock doesn't compress, just bail out immediately\n         * this will result in the production of a single uncompressed block covering @srcSize.*/\n        if (ebs.estBlockSize > srcSize) return 0;\n\n        /* compress and write sub-blocks */\n        assert(nbSubBlocks>0);\n        for (n=0; n < nbSubBlocks-1; n++) {\n            /* determine nb of sequences for current sub-block + nbLiterals from next sequence */\n            size_t const seqCount = sizeBlockSequences(sp, (size_t)(send-sp),\n                                        avgBlockBudget + blockBudgetSupp, avgLitCost, avgSeqCost, n==0);\n            /* if reached last sequence : break to last sub-block (simplification) */\n            assert(seqCount <= (size_t)(send-sp));\n            if (sp + seqCount == send) break;\n            assert(seqCount > 0);\n            /* compress sub-block */\n            {   int litEntropyWritten = 0;\n                int seqEntropyWritten = 0;\n                size_t litSize = countLiterals(seqStorePtr, sp, seqCount);\n                const size_t decompressedSize =\n                        ZSTD_seqDecompressedSize(seqStorePtr, sp, seqCount, litSize, 0);\n                size_t const cSize = ZSTD_compressSubBlock(&nextCBlock->entropy, entropyMetadata,\n                                                sp, seqCount,\n                                                lp, litSize,\n                                                llCodePtr, mlCodePtr, ofCodePtr,\n                                                cctxParams,\n                                                op, (size_t)(oend-op),\n                                                bmi2, writeLitEntropy, writeSeqEntropy,\n                                                &litEntropyWritten, &seqEntropyWritten,\n                                                0);\n                FORWARD_IF_ERROR(cSize, \"ZSTD_compressSubBlock failed\");\n\n                /* check compressibility, update state components */\n                if (cSize > 0 && cSize < decompressedSize) {\n                    DEBUGLOG(5, \"Committed sub-block compressing %u bytes => %u bytes\",\n                                (unsigned)decompressedSize, (unsigned)cSize);\n                    assert(ip + decompressedSize <= iend);\n                    ip += decompressedSize;\n                    lp += litSize;\n                    op += cSize;\n                    llCodePtr += seqCount;\n                    mlCodePtr += seqCount;\n                    ofCodePtr += seqCount;\n                    /* Entropy only needs to be written once */\n                    if (litEntropyWritten) {\n                        writeLitEntropy = 0;\n                    }\n                    if (seqEntropyWritten) {\n                        writeSeqEntropy = 0;\n                    }\n                    sp += seqCount;\n                    blockBudgetSupp = 0;\n            }   }\n            /* otherwise : do not compress yet, coalesce current sub-block with following one */\n        }\n    } /* if (nbSeqs > 0) */\n\n    /* write last block */\n    DEBUGLOG(5, \"Generate last sub-block: %u sequences remaining\", (unsigned)(send - sp));\n    {   int litEntropyWritten = 0;\n        int seqEntropyWritten = 0;\n        size_t litSize = (size_t)(lend - lp);\n        size_t seqCount = (size_t)(send - sp);\n        const size_t decompressedSize =\n                ZSTD_seqDecompressedSize(seqStorePtr, sp, seqCount, litSize, 1);\n        size_t const cSize = ZSTD_compressSubBlock(&nextCBlock->entropy, entropyMetadata,\n                                            sp, seqCount,\n                                            lp, litSize,\n                                            llCodePtr, mlCodePtr, ofCodePtr,\n                                            cctxParams,\n                                            op, (size_t)(oend-op),\n                                            bmi2, writeLitEntropy, writeSeqEntropy,\n                                            &litEntropyWritten, &seqEntropyWritten,\n                                            lastBlock);\n        FORWARD_IF_ERROR(cSize, \"ZSTD_compressSubBlock failed\");\n\n        /* update pointers, the nb of literals borrowed from next sequence must be preserved */\n        if (cSize > 0 && cSize < decompressedSize) {\n            DEBUGLOG(5, \"Last sub-block compressed %u bytes => %u bytes\",\n                        (unsigned)decompressedSize, (unsigned)cSize);\n            assert(ip + decompressedSize <= iend);\n            ip += decompressedSize;\n            lp += litSize;\n            op += cSize;\n            llCodePtr += seqCount;\n            mlCodePtr += seqCount;\n            ofCodePtr += seqCount;\n            /* Entropy only needs to be written once */\n            if (litEntropyWritten) {\n                writeLitEntropy = 0;\n            }\n            if (seqEntropyWritten) {\n                writeSeqEntropy = 0;\n            }\n            sp += seqCount;\n        }\n    }\n\n\n    if (writeLitEntropy) {\n        DEBUGLOG(5, \"Literal entropy tables were never written\");\n        ZSTD_memcpy(&nextCBlock->entropy.huf, &prevCBlock->entropy.huf, sizeof(prevCBlock->entropy.huf));\n    }\n    if (writeSeqEntropy && ZSTD_needSequenceEntropyTables(&entropyMetadata->fseMetadata)) {\n        /* If we haven't written our entropy tables, then we've violated our contract and\n         * must emit an uncompressed block.\n         */\n        DEBUGLOG(5, \"Sequence entropy tables were never written => cancel, emit an uncompressed block\");\n        return 0;\n    }\n\n    if (ip < iend) {\n        /* some data left : last part of the block sent uncompressed */\n        size_t const rSize = (size_t)((iend - ip));\n        size_t const cSize = ZSTD_noCompressBlock(op, (size_t)(oend - op), ip, rSize, lastBlock);\n        DEBUGLOG(5, \"Generate last uncompressed sub-block of %u bytes\", (unsigned)(rSize));\n        FORWARD_IF_ERROR(cSize, \"ZSTD_noCompressBlock failed\");\n        assert(cSize != 0);\n        op += cSize;\n        /* We have to regenerate the repcodes because we've skipped some sequences */\n        if (sp < send) {\n            const SeqDef* seq;\n            Repcodes_t rep;\n            ZSTD_memcpy(&rep, prevCBlock->rep, sizeof(rep));\n            for (seq = sstart; seq < sp; ++seq) {\n                ZSTD_updateRep(rep.rep, seq->offBase, ZSTD_getSequenceLength(seqStorePtr, seq).litLength == 0);\n            }\n            ZSTD_memcpy(nextCBlock->rep, &rep, sizeof(rep));\n        }\n    }\n\n    DEBUGLOG(5, \"ZSTD_compressSubBlock_multi compressed all subBlocks: total compressed size = %u\",\n                (unsigned)(op-ostart));\n    return (size_t)(op-ostart);\n}\n\nsize_t ZSTD_compressSuperBlock(ZSTD_CCtx* zc,\n                               void* dst, size_t dstCapacity,\n                               const void* src, size_t srcSize,\n                               unsigned lastBlock)\n{\n    ZSTD_entropyCTablesMetadata_t entropyMetadata;\n\n    FORWARD_IF_ERROR(ZSTD_buildBlockEntropyStats(&zc->seqStore,\n          &zc->blockState.prevCBlock->entropy,\n          &zc->blockState.nextCBlock->entropy,\n          &zc->appliedParams,\n          &entropyMetadata,\n          zc->tmpWorkspace, zc->tmpWkspSize /* statically allocated in resetCCtx */), \"\");\n\n    return ZSTD_compressSubBlock_multi(&zc->seqStore,\n            zc->blockState.prevCBlock,\n            zc->blockState.nextCBlock,\n            &entropyMetadata,\n            &zc->appliedParams,\n            dst, dstCapacity,\n            src, srcSize,\n            zc->bmi2, lastBlock,\n            zc->tmpWorkspace, zc->tmpWkspSize /* statically allocated in resetCCtx */);\n}\n"
  },
  {
    "path": "lib/compress/zstd_compress_superblock.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_COMPRESS_ADVANCED_H\n#define ZSTD_COMPRESS_ADVANCED_H\n\n/*-*************************************\n*  Dependencies\n***************************************/\n\n#include \"../zstd.h\" /* ZSTD_CCtx */\n\n/*-*************************************\n*  Target Compressed Block Size\n***************************************/\n\n/* ZSTD_compressSuperBlock() :\n * Used to compress a super block when targetCBlockSize is being used.\n * The given block will be compressed into multiple sub blocks that are around targetCBlockSize. */\nsize_t ZSTD_compressSuperBlock(ZSTD_CCtx* zc,\n                               void* dst, size_t dstCapacity,\n                               void const* src, size_t srcSize,\n                               unsigned lastBlock);\n\n#endif /* ZSTD_COMPRESS_ADVANCED_H */\n"
  },
  {
    "path": "lib/compress/zstd_cwksp.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_CWKSP_H\n#define ZSTD_CWKSP_H\n\n/*-*************************************\n*  Dependencies\n***************************************/\n#include \"../common/allocations.h\"  /* ZSTD_customMalloc, ZSTD_customFree */\n#include \"../common/zstd_internal.h\"\n#include \"../common/portability_macros.h\"\n#include \"../common/compiler.h\" /* ZS2_isPower2 */\n\n/*-*************************************\n*  Constants\n***************************************/\n\n/* Since the workspace is effectively its own little malloc implementation /\n * arena, when we run under ASAN, we should similarly insert redzones between\n * each internal element of the workspace, so ASAN will catch overruns that\n * reach outside an object but that stay inside the workspace.\n *\n * This defines the size of that redzone.\n */\n#ifndef ZSTD_CWKSP_ASAN_REDZONE_SIZE\n#define ZSTD_CWKSP_ASAN_REDZONE_SIZE 128\n#endif\n\n\n/* Set our tables and aligneds to align by 64 bytes */\n#define ZSTD_CWKSP_ALIGNMENT_BYTES 64\n\n/*-*************************************\n*  Structures\n***************************************/\ntypedef enum {\n    ZSTD_cwksp_alloc_objects,\n    ZSTD_cwksp_alloc_aligned_init_once,\n    ZSTD_cwksp_alloc_aligned,\n    ZSTD_cwksp_alloc_buffers\n} ZSTD_cwksp_alloc_phase_e;\n\n/**\n * Used to describe whether the workspace is statically allocated (and will not\n * necessarily ever be freed), or if it's dynamically allocated and we can\n * expect a well-formed caller to free this.\n */\ntypedef enum {\n    ZSTD_cwksp_dynamic_alloc,\n    ZSTD_cwksp_static_alloc\n} ZSTD_cwksp_static_alloc_e;\n\n/**\n * Zstd fits all its internal datastructures into a single continuous buffer,\n * so that it only needs to perform a single OS allocation (or so that a buffer\n * can be provided to it and it can perform no allocations at all). This buffer\n * is called the workspace.\n *\n * Several optimizations complicate that process of allocating memory ranges\n * from this workspace for each internal datastructure:\n *\n * - These different internal datastructures have different setup requirements:\n *\n *   - The static objects need to be cleared once and can then be trivially\n *     reused for each compression.\n *\n *   - Various buffers don't need to be initialized at all--they are always\n *     written into before they're read.\n *\n *   - The matchstate tables have a unique requirement that they don't need\n *     their memory to be totally cleared, but they do need the memory to have\n *     some bound, i.e., a guarantee that all values in the memory they've been\n *     allocated is less than some maximum value (which is the starting value\n *     for the indices that they will then use for compression). When this\n *     guarantee is provided to them, they can use the memory without any setup\n *     work. When it can't, they have to clear the area.\n *\n * - These buffers also have different alignment requirements.\n *\n * - We would like to reuse the objects in the workspace for multiple\n *   compressions without having to perform any expensive reallocation or\n *   reinitialization work.\n *\n * - We would like to be able to efficiently reuse the workspace across\n *   multiple compressions **even when the compression parameters change** and\n *   we need to resize some of the objects (where possible).\n *\n * To attempt to manage this buffer, given these constraints, the ZSTD_cwksp\n * abstraction was created. It works as follows:\n *\n * Workspace Layout:\n *\n * [                        ... workspace ...                           ]\n * [objects][tables ->] free space [<- buffers][<- aligned][<- init once]\n *\n * The various objects that live in the workspace are divided into the\n * following categories, and are allocated separately:\n *\n * - Static objects: this is optionally the enclosing ZSTD_CCtx or ZSTD_CDict,\n *   so that literally everything fits in a single buffer. Note: if present,\n *   this must be the first object in the workspace, since ZSTD_customFree{CCtx,\n *   CDict}() rely on a pointer comparison to see whether one or two frees are\n *   required.\n *\n * - Fixed size objects: these are fixed-size, fixed-count objects that are\n *   nonetheless \"dynamically\" allocated in the workspace so that we can\n *   control how they're initialized separately from the broader ZSTD_CCtx.\n *   Examples:\n *   - Entropy Workspace\n *   - 2 x ZSTD_compressedBlockState_t\n *   - CDict dictionary contents\n *\n * - Tables: these are any of several different datastructures (hash tables,\n *   chain tables, binary trees) that all respect a common format: they are\n *   uint32_t arrays, all of whose values are between 0 and (nextSrc - base).\n *   Their sizes depend on the cparams. These tables are 64-byte aligned.\n *\n * - Init once: these buffers require to be initialized at least once before\n *   use. They should be used when we want to skip memory initialization\n *   while not triggering memory checkers (like Valgrind) when reading from\n *   from this memory without writing to it first.\n *   These buffers should be used carefully as they might contain data\n *   from previous compressions.\n *   Buffers are aligned to 64 bytes.\n *\n * - Aligned: these buffers don't require any initialization before they're\n *   used. The user of the buffer should make sure they write into a buffer\n *   location before reading from it.\n *   Buffers are aligned to 64 bytes.\n *\n * - Buffers: these buffers are used for various purposes that don't require\n *   any alignment or initialization before they're used. This means they can\n *   be moved around at no cost for a new compression.\n *\n * Allocating Memory:\n *\n * The various types of objects must be allocated in order, so they can be\n * correctly packed into the workspace buffer. That order is:\n *\n * 1. Objects\n * 2. Init once / Tables\n * 3. Aligned / Tables\n * 4. Buffers / Tables\n *\n * Attempts to reserve objects of different types out of order will fail.\n */\ntypedef struct {\n    void* workspace;\n    void* workspaceEnd;\n\n    void* objectEnd;\n    void* tableEnd;\n    void* tableValidEnd;\n    void* allocStart;\n    void* initOnceStart;\n\n    BYTE allocFailed;\n    int workspaceOversizedDuration;\n    ZSTD_cwksp_alloc_phase_e phase;\n    ZSTD_cwksp_static_alloc_e isStatic;\n} ZSTD_cwksp;\n\n/*-*************************************\n*  Functions\n***************************************/\n\nMEM_STATIC size_t ZSTD_cwksp_available_space(ZSTD_cwksp* ws);\nMEM_STATIC void*  ZSTD_cwksp_initialAllocStart(ZSTD_cwksp* ws);\n\nMEM_STATIC void ZSTD_cwksp_assert_internal_consistency(ZSTD_cwksp* ws) {\n    (void)ws;\n    assert(ws->workspace <= ws->objectEnd);\n    assert(ws->objectEnd <= ws->tableEnd);\n    assert(ws->objectEnd <= ws->tableValidEnd);\n    assert(ws->tableEnd <= ws->allocStart);\n    assert(ws->tableValidEnd <= ws->allocStart);\n    assert(ws->allocStart <= ws->workspaceEnd);\n    assert(ws->initOnceStart <= ZSTD_cwksp_initialAllocStart(ws));\n    assert(ws->workspace <= ws->initOnceStart);\n#if ZSTD_MEMORY_SANITIZER\n    {\n        intptr_t const offset = __msan_test_shadow(ws->initOnceStart,\n            (U8*)ZSTD_cwksp_initialAllocStart(ws) - (U8*)ws->initOnceStart);\n        (void)offset;\n#if defined(ZSTD_MSAN_PRINT)\n        if(offset!=-1) {\n            __msan_print_shadow((U8*)ws->initOnceStart + offset - 8, 32);\n        }\n#endif\n        assert(offset==-1);\n    };\n#endif\n}\n\n/**\n * Align must be a power of 2.\n */\nMEM_STATIC size_t ZSTD_cwksp_align(size_t size, size_t align) {\n    size_t const mask = align - 1;\n    assert(ZSTD_isPower2(align));\n    return (size + mask) & ~mask;\n}\n\n/**\n * Use this to determine how much space in the workspace we will consume to\n * allocate this object. (Normally it should be exactly the size of the object,\n * but under special conditions, like ASAN, where we pad each object, it might\n * be larger.)\n *\n * Since tables aren't currently redzoned, you don't need to call through this\n * to figure out how much space you need for the matchState tables. Everything\n * else is though.\n *\n * Do not use for sizing aligned buffers. Instead, use ZSTD_cwksp_aligned64_alloc_size().\n */\nMEM_STATIC size_t ZSTD_cwksp_alloc_size(size_t size) {\n    if (size == 0)\n        return 0;\n#if ZSTD_ADDRESS_SANITIZER && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)\n    return size + 2 * ZSTD_CWKSP_ASAN_REDZONE_SIZE;\n#else\n    return size;\n#endif\n}\n\nMEM_STATIC size_t ZSTD_cwksp_aligned_alloc_size(size_t size, size_t alignment) {\n    return ZSTD_cwksp_alloc_size(ZSTD_cwksp_align(size, alignment));\n}\n\n/**\n * Returns an adjusted alloc size that is the nearest larger multiple of 64 bytes.\n * Used to determine the number of bytes required for a given \"aligned\".\n */\nMEM_STATIC size_t ZSTD_cwksp_aligned64_alloc_size(size_t size) {\n    return ZSTD_cwksp_aligned_alloc_size(size, ZSTD_CWKSP_ALIGNMENT_BYTES);\n}\n\n/**\n * Returns the amount of additional space the cwksp must allocate\n * for internal purposes (currently only alignment).\n */\nMEM_STATIC size_t ZSTD_cwksp_slack_space_required(void) {\n    /* For alignment, the wksp will always allocate an additional 2*ZSTD_CWKSP_ALIGNMENT_BYTES\n     * bytes to align the beginning of tables section and end of buffers;\n     */\n    size_t const slackSpace = ZSTD_CWKSP_ALIGNMENT_BYTES * 2;\n    return slackSpace;\n}\n\n\n/**\n * Return the number of additional bytes required to align a pointer to the given number of bytes.\n * alignBytes must be a power of two.\n */\nMEM_STATIC size_t ZSTD_cwksp_bytes_to_align_ptr(void* ptr, const size_t alignBytes) {\n    size_t const alignBytesMask = alignBytes - 1;\n    size_t const bytes = (alignBytes - ((size_t)ptr & (alignBytesMask))) & alignBytesMask;\n    assert(ZSTD_isPower2(alignBytes));\n    assert(bytes < alignBytes);\n    return bytes;\n}\n\n/**\n * Returns the initial value for allocStart which is used to determine the position from\n * which we can allocate from the end of the workspace.\n */\nMEM_STATIC void*  ZSTD_cwksp_initialAllocStart(ZSTD_cwksp* ws)\n{\n    char* endPtr = (char*)ws->workspaceEnd;\n    assert(ZSTD_isPower2(ZSTD_CWKSP_ALIGNMENT_BYTES));\n    endPtr = endPtr - ((size_t)endPtr % ZSTD_CWKSP_ALIGNMENT_BYTES);\n    return (void*)endPtr;\n}\n\n/**\n * Internal function. Do not use directly.\n * Reserves the given number of bytes within the aligned/buffer segment of the wksp,\n * which counts from the end of the wksp (as opposed to the object/table segment).\n *\n * Returns a pointer to the beginning of that space.\n */\nMEM_STATIC void*\nZSTD_cwksp_reserve_internal_buffer_space(ZSTD_cwksp* ws, size_t const bytes)\n{\n    void* const alloc = (BYTE*)ws->allocStart - bytes;\n    void* const bottom = ws->tableEnd;\n    DEBUGLOG(5, \"cwksp: reserving [0x%p]:%zd bytes; %zd bytes remaining\",\n        alloc, bytes, ZSTD_cwksp_available_space(ws) - bytes);\n    ZSTD_cwksp_assert_internal_consistency(ws);\n    assert(alloc >= bottom);\n    if (alloc < bottom) {\n        DEBUGLOG(4, \"cwksp: alloc failed!\");\n        ws->allocFailed = 1;\n        return NULL;\n    }\n    /* the area is reserved from the end of wksp.\n     * If it overlaps with tableValidEnd, it voids guarantees on values' range */\n    if (alloc < ws->tableValidEnd) {\n        ws->tableValidEnd = alloc;\n    }\n    ws->allocStart = alloc;\n    return alloc;\n}\n\n/**\n * Moves the cwksp to the next phase, and does any necessary allocations.\n * cwksp initialization must necessarily go through each phase in order.\n * Returns a 0 on success, or zstd error\n */\nMEM_STATIC size_t\nZSTD_cwksp_internal_advance_phase(ZSTD_cwksp* ws, ZSTD_cwksp_alloc_phase_e phase)\n{\n    assert(phase >= ws->phase);\n    if (phase > ws->phase) {\n        /* Going from allocating objects to allocating initOnce / tables */\n        if (ws->phase < ZSTD_cwksp_alloc_aligned_init_once &&\n            phase >= ZSTD_cwksp_alloc_aligned_init_once) {\n            ws->tableValidEnd = ws->objectEnd;\n            ws->initOnceStart = ZSTD_cwksp_initialAllocStart(ws);\n\n            {   /* Align the start of the tables to 64 bytes. Use [0, 63] bytes */\n                void *const alloc = ws->objectEnd;\n                size_t const bytesToAlign = ZSTD_cwksp_bytes_to_align_ptr(alloc, ZSTD_CWKSP_ALIGNMENT_BYTES);\n                void *const objectEnd = (BYTE *) alloc + bytesToAlign;\n                DEBUGLOG(5, \"reserving table alignment addtl space: %zu\", bytesToAlign);\n                RETURN_ERROR_IF(objectEnd > ws->workspaceEnd, memory_allocation,\n                                \"table phase - alignment initial allocation failed!\");\n                ws->objectEnd = objectEnd;\n                ws->tableEnd = objectEnd;  /* table area starts being empty */\n                if (ws->tableValidEnd < ws->tableEnd) {\n                    ws->tableValidEnd = ws->tableEnd;\n                }\n            }\n        }\n        ws->phase = phase;\n        ZSTD_cwksp_assert_internal_consistency(ws);\n    }\n    return 0;\n}\n\n/**\n * Returns whether this object/buffer/etc was allocated in this workspace.\n */\nMEM_STATIC int ZSTD_cwksp_owns_buffer(const ZSTD_cwksp* ws, const void* ptr)\n{\n    return (ptr != NULL) && (ws->workspace <= ptr) && (ptr < ws->workspaceEnd);\n}\n\n/**\n * Internal function. Do not use directly.\n */\nMEM_STATIC void*\nZSTD_cwksp_reserve_internal(ZSTD_cwksp* ws, size_t bytes, ZSTD_cwksp_alloc_phase_e phase)\n{\n    void* alloc;\n    if (ZSTD_isError(ZSTD_cwksp_internal_advance_phase(ws, phase)) || bytes == 0) {\n        return NULL;\n    }\n\n#if ZSTD_ADDRESS_SANITIZER && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)\n    /* over-reserve space */\n    bytes += 2 * ZSTD_CWKSP_ASAN_REDZONE_SIZE;\n#endif\n\n    alloc = ZSTD_cwksp_reserve_internal_buffer_space(ws, bytes);\n\n#if ZSTD_ADDRESS_SANITIZER && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)\n    /* Move alloc so there's ZSTD_CWKSP_ASAN_REDZONE_SIZE unused space on\n     * either size. */\n    if (alloc) {\n        alloc = (BYTE *)alloc + ZSTD_CWKSP_ASAN_REDZONE_SIZE;\n        if (ws->isStatic == ZSTD_cwksp_dynamic_alloc) {\n            /* We need to keep the redzone poisoned while unpoisoning the bytes that\n             * are actually allocated. */\n            __asan_unpoison_memory_region(alloc, bytes - 2 * ZSTD_CWKSP_ASAN_REDZONE_SIZE);\n        }\n    }\n#endif\n\n    return alloc;\n}\n\n/**\n * Reserves and returns unaligned memory.\n */\nMEM_STATIC BYTE* ZSTD_cwksp_reserve_buffer(ZSTD_cwksp* ws, size_t bytes)\n{\n    return (BYTE*)ZSTD_cwksp_reserve_internal(ws, bytes, ZSTD_cwksp_alloc_buffers);\n}\n\n/**\n * Reserves and returns memory sized on and aligned on ZSTD_CWKSP_ALIGNMENT_BYTES (64 bytes).\n * This memory has been initialized at least once in the past.\n * This doesn't mean it has been initialized this time, and it might contain data from previous\n * operations.\n * The main usage is for algorithms that might need read access into uninitialized memory.\n * The algorithm must maintain safety under these conditions and must make sure it doesn't\n * leak any of the past data (directly or in side channels).\n */\nMEM_STATIC void* ZSTD_cwksp_reserve_aligned_init_once(ZSTD_cwksp* ws, size_t bytes)\n{\n    size_t const alignedBytes = ZSTD_cwksp_align(bytes, ZSTD_CWKSP_ALIGNMENT_BYTES);\n    void* ptr = ZSTD_cwksp_reserve_internal(ws, alignedBytes, ZSTD_cwksp_alloc_aligned_init_once);\n    assert(((size_t)ptr & (ZSTD_CWKSP_ALIGNMENT_BYTES-1)) == 0);\n    if(ptr && ptr < ws->initOnceStart) {\n        /* We assume the memory following the current allocation is either:\n         * 1. Not usable as initOnce memory (end of workspace)\n         * 2. Another initOnce buffer that has been allocated before (and so was previously memset)\n         * 3. An ASAN redzone, in which case we don't want to write on it\n         * For these reasons it should be fine to not explicitly zero every byte up to ws->initOnceStart.\n         * Note that we assume here that MSAN and ASAN cannot run in the same time. */\n        ZSTD_memset(ptr, 0, MIN((size_t)((U8*)ws->initOnceStart - (U8*)ptr), alignedBytes));\n        ws->initOnceStart = ptr;\n    }\n#if ZSTD_MEMORY_SANITIZER\n    assert(__msan_test_shadow(ptr, bytes) == -1);\n#endif\n    return ptr;\n}\n\n/**\n * Reserves and returns memory sized on and aligned on ZSTD_CWKSP_ALIGNMENT_BYTES (64 bytes).\n */\nMEM_STATIC void* ZSTD_cwksp_reserve_aligned64(ZSTD_cwksp* ws, size_t bytes)\n{\n    void* const ptr = ZSTD_cwksp_reserve_internal(ws,\n                        ZSTD_cwksp_align(bytes, ZSTD_CWKSP_ALIGNMENT_BYTES),\n                        ZSTD_cwksp_alloc_aligned);\n    assert(((size_t)ptr & (ZSTD_CWKSP_ALIGNMENT_BYTES-1)) == 0);\n    return ptr;\n}\n\n/**\n * Aligned on 64 bytes. These buffers have the special property that\n * their values remain constrained, allowing us to reuse them without\n * memset()-ing them.\n */\nMEM_STATIC void* ZSTD_cwksp_reserve_table(ZSTD_cwksp* ws, size_t bytes)\n{\n    const ZSTD_cwksp_alloc_phase_e phase = ZSTD_cwksp_alloc_aligned_init_once;\n    void* alloc;\n    void* end;\n    void* top;\n\n    /* We can only start allocating tables after we are done reserving space for objects at the\n     * start of the workspace */\n    if(ws->phase < phase) {\n        if (ZSTD_isError(ZSTD_cwksp_internal_advance_phase(ws, phase))) {\n            return NULL;\n        }\n    }\n    alloc = ws->tableEnd;\n    end = (BYTE *)alloc + bytes;\n    top = ws->allocStart;\n\n    DEBUGLOG(5, \"cwksp: reserving %p table %zd bytes, %zd bytes remaining\",\n        alloc, bytes, ZSTD_cwksp_available_space(ws) - bytes);\n    assert((bytes & (sizeof(U32)-1)) == 0);\n    ZSTD_cwksp_assert_internal_consistency(ws);\n    assert(end <= top);\n    if (end > top) {\n        DEBUGLOG(4, \"cwksp: table alloc failed!\");\n        ws->allocFailed = 1;\n        return NULL;\n    }\n    ws->tableEnd = end;\n\n#if ZSTD_ADDRESS_SANITIZER && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)\n    if (ws->isStatic == ZSTD_cwksp_dynamic_alloc) {\n        __asan_unpoison_memory_region(alloc, bytes);\n    }\n#endif\n\n    assert((bytes & (ZSTD_CWKSP_ALIGNMENT_BYTES-1)) == 0);\n    assert(((size_t)alloc & (ZSTD_CWKSP_ALIGNMENT_BYTES-1)) == 0);\n    return alloc;\n}\n\n/**\n * Aligned on sizeof(void*).\n * Note : should happen only once, at workspace first initialization\n */\nMEM_STATIC void* ZSTD_cwksp_reserve_object(ZSTD_cwksp* ws, size_t bytes)\n{\n    size_t const roundedBytes = ZSTD_cwksp_align(bytes, sizeof(void*));\n    void* alloc = ws->objectEnd;\n    void* end = (BYTE*)alloc + roundedBytes;\n\n#if ZSTD_ADDRESS_SANITIZER && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)\n    /* over-reserve space */\n    end = (BYTE *)end + 2 * ZSTD_CWKSP_ASAN_REDZONE_SIZE;\n#endif\n\n    DEBUGLOG(4,\n        \"cwksp: reserving %p object %zd bytes (rounded to %zd), %zd bytes remaining\",\n        alloc, bytes, roundedBytes, ZSTD_cwksp_available_space(ws) - roundedBytes);\n    assert((size_t)alloc % ZSTD_ALIGNOF(void*) == 0);\n    assert(bytes % ZSTD_ALIGNOF(void*) == 0);\n    ZSTD_cwksp_assert_internal_consistency(ws);\n    /* we must be in the first phase, no advance is possible */\n    if (ws->phase != ZSTD_cwksp_alloc_objects || end > ws->workspaceEnd) {\n        DEBUGLOG(3, \"cwksp: object alloc failed!\");\n        ws->allocFailed = 1;\n        return NULL;\n    }\n    ws->objectEnd = end;\n    ws->tableEnd = end;\n    ws->tableValidEnd = end;\n\n#if ZSTD_ADDRESS_SANITIZER && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)\n    /* Move alloc so there's ZSTD_CWKSP_ASAN_REDZONE_SIZE unused space on\n     * either size. */\n    alloc = (BYTE*)alloc + ZSTD_CWKSP_ASAN_REDZONE_SIZE;\n    if (ws->isStatic == ZSTD_cwksp_dynamic_alloc) {\n        __asan_unpoison_memory_region(alloc, bytes);\n    }\n#endif\n\n    return alloc;\n}\n/**\n * with alignment control\n * Note : should happen only once, at workspace first initialization\n */\nMEM_STATIC void* ZSTD_cwksp_reserve_object_aligned(ZSTD_cwksp* ws, size_t byteSize, size_t alignment)\n{\n    size_t const mask = alignment - 1;\n    size_t const surplus = (alignment > sizeof(void*)) ? alignment - sizeof(void*) : 0;\n    void* const start = ZSTD_cwksp_reserve_object(ws, byteSize + surplus);\n    if (start == NULL) return NULL;\n    if (surplus == 0) return start;\n    assert(ZSTD_isPower2(alignment));\n    return (void*)(((size_t)start + surplus) & ~mask);\n}\n\nMEM_STATIC void ZSTD_cwksp_mark_tables_dirty(ZSTD_cwksp* ws)\n{\n    DEBUGLOG(4, \"cwksp: ZSTD_cwksp_mark_tables_dirty\");\n\n#if ZSTD_MEMORY_SANITIZER && !defined (ZSTD_MSAN_DONT_POISON_WORKSPACE)\n    /* To validate that the table reuse logic is sound, and that we don't\n     * access table space that we haven't cleaned, we re-\"poison\" the table\n     * space every time we mark it dirty.\n     * Since tableValidEnd space and initOnce space may overlap we don't poison\n     * the initOnce portion as it break its promise. This means that this poisoning\n     * check isn't always applied fully. */\n    {\n        size_t size = (BYTE*)ws->tableValidEnd - (BYTE*)ws->objectEnd;\n        assert(__msan_test_shadow(ws->objectEnd, size) == -1);\n        if((BYTE*)ws->tableValidEnd < (BYTE*)ws->initOnceStart) {\n            __msan_poison(ws->objectEnd, size);\n        } else {\n            assert(ws->initOnceStart >= ws->objectEnd);\n            __msan_poison(ws->objectEnd, (BYTE*)ws->initOnceStart - (BYTE*)ws->objectEnd);\n        }\n    }\n#endif\n\n    assert(ws->tableValidEnd >= ws->objectEnd);\n    assert(ws->tableValidEnd <= ws->allocStart);\n    ws->tableValidEnd = ws->objectEnd;\n    ZSTD_cwksp_assert_internal_consistency(ws);\n}\n\nMEM_STATIC void ZSTD_cwksp_mark_tables_clean(ZSTD_cwksp* ws) {\n    DEBUGLOG(4, \"cwksp: ZSTD_cwksp_mark_tables_clean\");\n    assert(ws->tableValidEnd >= ws->objectEnd);\n    assert(ws->tableValidEnd <= ws->allocStart);\n    if (ws->tableValidEnd < ws->tableEnd) {\n        ws->tableValidEnd = ws->tableEnd;\n    }\n    ZSTD_cwksp_assert_internal_consistency(ws);\n}\n\n/**\n * Zero the part of the allocated tables not already marked clean.\n */\nMEM_STATIC void ZSTD_cwksp_clean_tables(ZSTD_cwksp* ws) {\n    DEBUGLOG(4, \"cwksp: ZSTD_cwksp_clean_tables\");\n    assert(ws->tableValidEnd >= ws->objectEnd);\n    assert(ws->tableValidEnd <= ws->allocStart);\n    if (ws->tableValidEnd < ws->tableEnd) {\n        ZSTD_memset(ws->tableValidEnd, 0, (size_t)((BYTE*)ws->tableEnd - (BYTE*)ws->tableValidEnd));\n    }\n    ZSTD_cwksp_mark_tables_clean(ws);\n}\n\n/**\n * Invalidates table allocations.\n * All other allocations remain valid.\n */\nMEM_STATIC void ZSTD_cwksp_clear_tables(ZSTD_cwksp* ws)\n{\n    DEBUGLOG(4, \"cwksp: clearing tables!\");\n\n#if ZSTD_ADDRESS_SANITIZER && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)\n    /* We don't do this when the workspace is statically allocated, because\n     * when that is the case, we have no capability to hook into the end of the\n     * workspace's lifecycle to unpoison the memory.\n     */\n    if (ws->isStatic == ZSTD_cwksp_dynamic_alloc) {\n        size_t size = (BYTE*)ws->tableValidEnd - (BYTE*)ws->objectEnd;\n        __asan_poison_memory_region(ws->objectEnd, size);\n    }\n#endif\n\n    ws->tableEnd = ws->objectEnd;\n    ZSTD_cwksp_assert_internal_consistency(ws);\n}\n\n/**\n * Invalidates all buffer, aligned, and table allocations.\n * Object allocations remain valid.\n */\nMEM_STATIC void ZSTD_cwksp_clear(ZSTD_cwksp* ws) {\n    DEBUGLOG(4, \"cwksp: clearing!\");\n\n#if ZSTD_MEMORY_SANITIZER && !defined (ZSTD_MSAN_DONT_POISON_WORKSPACE)\n    /* To validate that the context reuse logic is sound, and that we don't\n     * access stuff that this compression hasn't initialized, we re-\"poison\"\n     * the workspace except for the areas in which we expect memory reuse\n     * without initialization (objects, valid tables area and init once\n     * memory). */\n    {\n        if((BYTE*)ws->tableValidEnd < (BYTE*)ws->initOnceStart) {\n            size_t size = (BYTE*)ws->initOnceStart - (BYTE*)ws->tableValidEnd;\n            __msan_poison(ws->tableValidEnd, size);\n        }\n    }\n#endif\n\n#if ZSTD_ADDRESS_SANITIZER && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)\n    /* We don't do this when the workspace is statically allocated, because\n     * when that is the case, we have no capability to hook into the end of the\n     * workspace's lifecycle to unpoison the memory.\n     */\n    if (ws->isStatic == ZSTD_cwksp_dynamic_alloc) {\n        size_t size = (BYTE*)ws->workspaceEnd - (BYTE*)ws->objectEnd;\n        __asan_poison_memory_region(ws->objectEnd, size);\n    }\n#endif\n\n    ws->tableEnd = ws->objectEnd;\n    ws->allocStart = ZSTD_cwksp_initialAllocStart(ws);\n    ws->allocFailed = 0;\n    if (ws->phase > ZSTD_cwksp_alloc_aligned_init_once) {\n        ws->phase = ZSTD_cwksp_alloc_aligned_init_once;\n    }\n    ZSTD_cwksp_assert_internal_consistency(ws);\n}\n\nMEM_STATIC size_t ZSTD_cwksp_sizeof(const ZSTD_cwksp* ws) {\n    return (size_t)((BYTE*)ws->workspaceEnd - (BYTE*)ws->workspace);\n}\n\nMEM_STATIC size_t ZSTD_cwksp_used(const ZSTD_cwksp* ws) {\n    return (size_t)((BYTE*)ws->tableEnd - (BYTE*)ws->workspace)\n         + (size_t)((BYTE*)ws->workspaceEnd - (BYTE*)ws->allocStart);\n}\n\n/**\n * The provided workspace takes ownership of the buffer [start, start+size).\n * Any existing values in the workspace are ignored (the previously managed\n * buffer, if present, must be separately freed).\n */\nMEM_STATIC void ZSTD_cwksp_init(ZSTD_cwksp* ws, void* start, size_t size, ZSTD_cwksp_static_alloc_e isStatic) {\n    DEBUGLOG(4, \"cwksp: init'ing workspace with %zd bytes\", size);\n    assert(((size_t)start & (sizeof(void*)-1)) == 0); /* ensure correct alignment */\n    ws->workspace = start;\n    ws->workspaceEnd = (BYTE*)start + size;\n    ws->objectEnd = ws->workspace;\n    ws->tableValidEnd = ws->objectEnd;\n    ws->initOnceStart = ZSTD_cwksp_initialAllocStart(ws);\n    ws->phase = ZSTD_cwksp_alloc_objects;\n    ws->isStatic = isStatic;\n    ZSTD_cwksp_clear(ws);\n    ws->workspaceOversizedDuration = 0;\n    ZSTD_cwksp_assert_internal_consistency(ws);\n}\n\nMEM_STATIC size_t ZSTD_cwksp_create(ZSTD_cwksp* ws, size_t size, ZSTD_customMem customMem) {\n    void* workspace = ZSTD_customMalloc(size, customMem);\n    DEBUGLOG(4, \"cwksp: creating new workspace with %zd bytes\", size);\n    RETURN_ERROR_IF(workspace == NULL, memory_allocation, \"NULL pointer!\");\n    ZSTD_cwksp_init(ws, workspace, size, ZSTD_cwksp_dynamic_alloc);\n    return 0;\n}\n\nMEM_STATIC void ZSTD_cwksp_free(ZSTD_cwksp* ws, ZSTD_customMem customMem) {\n    void *ptr = ws->workspace;\n    DEBUGLOG(4, \"cwksp: freeing workspace\");\n#if ZSTD_MEMORY_SANITIZER && !defined(ZSTD_MSAN_DONT_POISON_WORKSPACE)\n    if (ptr != NULL && customMem.customFree != NULL) {\n        __msan_unpoison(ptr, ZSTD_cwksp_sizeof(ws));\n    }\n#endif\n    ZSTD_memset(ws, 0, sizeof(ZSTD_cwksp));\n    ZSTD_customFree(ptr, customMem);\n}\n\n/**\n * Moves the management of a workspace from one cwksp to another. The src cwksp\n * is left in an invalid state (src must be re-init()'ed before it's used again).\n */\nMEM_STATIC void ZSTD_cwksp_move(ZSTD_cwksp* dst, ZSTD_cwksp* src) {\n    *dst = *src;\n    ZSTD_memset(src, 0, sizeof(ZSTD_cwksp));\n}\n\nMEM_STATIC int ZSTD_cwksp_reserve_failed(const ZSTD_cwksp* ws) {\n    return ws->allocFailed;\n}\n\n/*-*************************************\n*  Functions Checking Free Space\n***************************************/\n\n/* ZSTD_alignmentSpaceWithinBounds() :\n * Returns if the estimated space needed for a wksp is within an acceptable limit of the\n * actual amount of space used.\n */\nMEM_STATIC int ZSTD_cwksp_estimated_space_within_bounds(const ZSTD_cwksp *const ws, size_t const estimatedSpace) {\n    /* We have an alignment space between objects and tables between tables and buffers, so we can have up to twice\n     * the alignment bytes difference between estimation and actual usage */\n    return (estimatedSpace - ZSTD_cwksp_slack_space_required()) <= ZSTD_cwksp_used(ws) &&\n           ZSTD_cwksp_used(ws) <= estimatedSpace;\n}\n\n\nMEM_STATIC size_t ZSTD_cwksp_available_space(ZSTD_cwksp* ws) {\n    return (size_t)((BYTE*)ws->allocStart - (BYTE*)ws->tableEnd);\n}\n\nMEM_STATIC int ZSTD_cwksp_check_available(ZSTD_cwksp* ws, size_t additionalNeededSpace) {\n    return ZSTD_cwksp_available_space(ws) >= additionalNeededSpace;\n}\n\nMEM_STATIC int ZSTD_cwksp_check_too_large(ZSTD_cwksp* ws, size_t additionalNeededSpace) {\n    return ZSTD_cwksp_check_available(\n        ws, additionalNeededSpace * ZSTD_WORKSPACETOOLARGE_FACTOR);\n}\n\nMEM_STATIC int ZSTD_cwksp_check_wasteful(ZSTD_cwksp* ws, size_t additionalNeededSpace) {\n    return ZSTD_cwksp_check_too_large(ws, additionalNeededSpace)\n        && ws->workspaceOversizedDuration > ZSTD_WORKSPACETOOLARGE_MAXDURATION;\n}\n\nMEM_STATIC void ZSTD_cwksp_bump_oversized_duration(\n        ZSTD_cwksp* ws, size_t additionalNeededSpace) {\n    if (ZSTD_cwksp_check_too_large(ws, additionalNeededSpace)) {\n        ws->workspaceOversizedDuration++;\n    } else {\n        ws->workspaceOversizedDuration = 0;\n    }\n}\n\n#endif /* ZSTD_CWKSP_H */\n"
  },
  {
    "path": "lib/compress/zstd_double_fast.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#include \"zstd_compress_internal.h\"\n#include \"zstd_double_fast.h\"\n\n#ifndef ZSTD_EXCLUDE_DFAST_BLOCK_COMPRESSOR\n\nstatic\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nvoid ZSTD_fillDoubleHashTableForCDict(ZSTD_MatchState_t* ms,\n                              void const* end, ZSTD_dictTableLoadMethod_e dtlm)\n{\n    const ZSTD_compressionParameters* const cParams = &ms->cParams;\n    U32* const hashLarge = ms->hashTable;\n    U32  const hBitsL = cParams->hashLog + ZSTD_SHORT_CACHE_TAG_BITS;\n    U32  const mls = cParams->minMatch;\n    U32* const hashSmall = ms->chainTable;\n    U32  const hBitsS = cParams->chainLog + ZSTD_SHORT_CACHE_TAG_BITS;\n    const BYTE* const base = ms->window.base;\n    const BYTE* ip = base + ms->nextToUpdate;\n    const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE;\n    const U32 fastHashFillStep = 3;\n\n    /* Always insert every fastHashFillStep position into the hash tables.\n     * Insert the other positions into the large hash table if their entry\n     * is empty.\n     */\n    for (; ip + fastHashFillStep - 1 <= iend; ip += fastHashFillStep) {\n        U32 const curr = (U32)(ip - base);\n        U32 i;\n        for (i = 0; i < fastHashFillStep; ++i) {\n            size_t const smHashAndTag = ZSTD_hashPtr(ip + i, hBitsS, mls);\n            size_t const lgHashAndTag = ZSTD_hashPtr(ip + i, hBitsL, 8);\n            if (i == 0) {\n                ZSTD_writeTaggedIndex(hashSmall, smHashAndTag, curr + i);\n            }\n            if (i == 0 || hashLarge[lgHashAndTag >> ZSTD_SHORT_CACHE_TAG_BITS] == 0) {\n                ZSTD_writeTaggedIndex(hashLarge, lgHashAndTag, curr + i);\n            }\n            /* Only load extra positions for ZSTD_dtlm_full */\n            if (dtlm == ZSTD_dtlm_fast)\n                break;\n    }   }\n}\n\nstatic\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nvoid ZSTD_fillDoubleHashTableForCCtx(ZSTD_MatchState_t* ms,\n                              void const* end, ZSTD_dictTableLoadMethod_e dtlm)\n{\n    const ZSTD_compressionParameters* const cParams = &ms->cParams;\n    U32* const hashLarge = ms->hashTable;\n    U32  const hBitsL = cParams->hashLog;\n    U32  const mls = cParams->minMatch;\n    U32* const hashSmall = ms->chainTable;\n    U32  const hBitsS = cParams->chainLog;\n    const BYTE* const base = ms->window.base;\n    const BYTE* ip = base + ms->nextToUpdate;\n    const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE;\n    const U32 fastHashFillStep = 3;\n\n    /* Always insert every fastHashFillStep position into the hash tables.\n     * Insert the other positions into the large hash table if their entry\n     * is empty.\n     */\n    for (; ip + fastHashFillStep - 1 <= iend; ip += fastHashFillStep) {\n        U32 const curr = (U32)(ip - base);\n        U32 i;\n        for (i = 0; i < fastHashFillStep; ++i) {\n            size_t const smHash = ZSTD_hashPtr(ip + i, hBitsS, mls);\n            size_t const lgHash = ZSTD_hashPtr(ip + i, hBitsL, 8);\n            if (i == 0)\n                hashSmall[smHash] = curr + i;\n            if (i == 0 || hashLarge[lgHash] == 0)\n                hashLarge[lgHash] = curr + i;\n            /* Only load extra positions for ZSTD_dtlm_full */\n            if (dtlm == ZSTD_dtlm_fast)\n                break;\n        }   }\n}\n\nvoid ZSTD_fillDoubleHashTable(ZSTD_MatchState_t* ms,\n                        const void* const end,\n                        ZSTD_dictTableLoadMethod_e dtlm,\n                        ZSTD_tableFillPurpose_e tfp)\n{\n    if (tfp == ZSTD_tfp_forCDict) {\n        ZSTD_fillDoubleHashTableForCDict(ms, end, dtlm);\n    } else {\n        ZSTD_fillDoubleHashTableForCCtx(ms, end, dtlm);\n    }\n}\n\n\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_compressBlock_doubleFast_noDict_generic(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize, U32 const mls /* template */)\n{\n    ZSTD_compressionParameters const* cParams = &ms->cParams;\n    U32* const hashLong = ms->hashTable;\n    const U32 hBitsL = cParams->hashLog;\n    U32* const hashSmall = ms->chainTable;\n    const U32 hBitsS = cParams->chainLog;\n    const BYTE* const base = ms->window.base;\n    const BYTE* const istart = (const BYTE*)src;\n    const BYTE* anchor = istart;\n    const U32 endIndex = (U32)((size_t)(istart - base) + srcSize);\n    /* presumes that, if there is a dictionary, it must be using Attach mode */\n    const U32 prefixLowestIndex = ZSTD_getLowestPrefixIndex(ms, endIndex, cParams->windowLog);\n    const BYTE* const prefixLowest = base + prefixLowestIndex;\n    const BYTE* const iend = istart + srcSize;\n    const BYTE* const ilimit = iend - HASH_READ_SIZE;\n    U32 offset_1=rep[0], offset_2=rep[1];\n    U32 offsetSaved1 = 0, offsetSaved2 = 0;\n\n    size_t mLength;\n    U32 offset;\n    U32 curr;\n\n    /* how many positions to search before increasing step size */\n    const size_t kStepIncr = 1 << kSearchStrength;\n    /* the position at which to increment the step size if no match is found */\n    const BYTE* nextStep;\n    size_t step; /* the current step size */\n\n    size_t hl0; /* the long hash at ip */\n    size_t hl1; /* the long hash at ip1 */\n\n    U32 idxl0; /* the long match index for ip */\n    U32 idxl1; /* the long match index for ip1 */\n\n    const BYTE* matchl0; /* the long match for ip */\n    const BYTE* matchs0; /* the short match for ip */\n    const BYTE* matchl1; /* the long match for ip1 */\n    const BYTE* matchs0_safe; /* matchs0 or safe address */\n\n    const BYTE* ip = istart; /* the current position */\n    const BYTE* ip1; /* the next position */\n    /* Array of ~random data, should have low probability of matching data\n     * we load from here instead of from tables, if matchl0/matchl1 are\n     * invalid indices. Used to avoid unpredictable branches. */\n    const BYTE dummy[] = {0x12,0x34,0x56,0x78,0x9a,0xbc,0xde,0xf0,0xe2,0xb4};\n\n    DEBUGLOG(5, \"ZSTD_compressBlock_doubleFast_noDict_generic\");\n\n    /* init */\n    ip += ((ip - prefixLowest) == 0);\n    {\n        U32 const current = (U32)(ip - base);\n        U32 const windowLow = ZSTD_getLowestPrefixIndex(ms, current, cParams->windowLog);\n        U32 const maxRep = current - windowLow;\n        if (offset_2 > maxRep) offsetSaved2 = offset_2, offset_2 = 0;\n        if (offset_1 > maxRep) offsetSaved1 = offset_1, offset_1 = 0;\n    }\n\n    /* Outer Loop: one iteration per match found and stored */\n    while (1) {\n        step = 1;\n        nextStep = ip + kStepIncr;\n        ip1 = ip + step;\n\n        if (ip1 > ilimit) {\n            goto _cleanup;\n        }\n\n        hl0 = ZSTD_hashPtr(ip, hBitsL, 8);\n        idxl0 = hashLong[hl0];\n        matchl0 = base + idxl0;\n\n        /* Inner Loop: one iteration per search / position */\n        do {\n            const size_t hs0 = ZSTD_hashPtr(ip, hBitsS, mls);\n            const U32 idxs0 = hashSmall[hs0];\n            curr = (U32)(ip-base);\n            matchs0 = base + idxs0;\n\n            hashLong[hl0] = hashSmall[hs0] = curr;   /* update hash tables */\n\n            /* check noDict repcode */\n            if ((offset_1 > 0) & (MEM_read32(ip+1-offset_1) == MEM_read32(ip+1))) {\n                mLength = ZSTD_count(ip+1+4, ip+1+4-offset_1, iend) + 4;\n                ip++;\n                ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, REPCODE1_TO_OFFBASE, mLength);\n                goto _match_stored;\n            }\n\n            hl1 = ZSTD_hashPtr(ip1, hBitsL, 8);\n\n            /* idxl0 > prefixLowestIndex is a (somewhat) unpredictable branch.\n             * However expression below complies into conditional move. Since\n             * match is unlikely and we only *branch* on idxl0 > prefixLowestIndex\n             * if there is a match, all branches become predictable. */\n            {   const BYTE*  const matchl0_safe = ZSTD_selectAddr(idxl0, prefixLowestIndex, matchl0, &dummy[0]);\n\n                /* check prefix long match */\n                if (MEM_read64(matchl0_safe) == MEM_read64(ip) && matchl0_safe == matchl0) {\n                    mLength = ZSTD_count(ip+8, matchl0+8, iend) + 8;\n                    offset = (U32)(ip-matchl0);\n                    while (((ip>anchor) & (matchl0>prefixLowest)) && (ip[-1] == matchl0[-1])) { ip--; matchl0--; mLength++; } /* catch up */\n                    goto _match_found;\n            }   }\n\n            idxl1 = hashLong[hl1];\n            matchl1 = base + idxl1;\n\n            /* Same optimization as matchl0 above */\n            matchs0_safe = ZSTD_selectAddr(idxs0, prefixLowestIndex, matchs0, &dummy[0]);\n\n            /* check prefix short match */\n            if(MEM_read32(matchs0_safe) == MEM_read32(ip) && matchs0_safe == matchs0) {\n                  goto _search_next_long;\n            }\n\n            if (ip1 >= nextStep) {\n                PREFETCH_L1(ip1 + 64);\n                PREFETCH_L1(ip1 + 128);\n                step++;\n                nextStep += kStepIncr;\n            }\n            ip = ip1;\n            ip1 += step;\n\n            hl0 = hl1;\n            idxl0 = idxl1;\n            matchl0 = matchl1;\n    #if defined(__aarch64__)\n            PREFETCH_L1(ip+256);\n    #endif\n        } while (ip1 <= ilimit);\n\n_cleanup:\n        /* If offset_1 started invalid (offsetSaved1 != 0) and became valid (offset_1 != 0),\n         * rotate saved offsets. See comment in ZSTD_compressBlock_fast_noDict for more context. */\n        offsetSaved2 = ((offsetSaved1 != 0) && (offset_1 != 0)) ? offsetSaved1 : offsetSaved2;\n\n        /* save reps for next block */\n        rep[0] = offset_1 ? offset_1 : offsetSaved1;\n        rep[1] = offset_2 ? offset_2 : offsetSaved2;\n\n        /* Return the last literals size */\n        return (size_t)(iend - anchor);\n\n_search_next_long:\n\n        /* short match found: let's check for a longer one */\n        mLength = ZSTD_count(ip+4, matchs0+4, iend) + 4;\n        offset = (U32)(ip - matchs0);\n\n        /* check long match at +1 position */\n        if ((idxl1 > prefixLowestIndex) && (MEM_read64(matchl1) == MEM_read64(ip1))) {\n            size_t const l1len = ZSTD_count(ip1+8, matchl1+8, iend) + 8;\n            if (l1len > mLength) {\n                /* use the long match instead */\n                ip = ip1;\n                mLength = l1len;\n                offset = (U32)(ip-matchl1);\n                matchs0 = matchl1;\n            }\n        }\n\n        while (((ip>anchor) & (matchs0>prefixLowest)) && (ip[-1] == matchs0[-1])) { ip--; matchs0--; mLength++; } /* complete backward */\n\n        /* fall-through */\n\n_match_found: /* requires ip, offset, mLength */\n        offset_2 = offset_1;\n        offset_1 = offset;\n\n        if (step < 4) {\n            /* It is unsafe to write this value back to the hashtable when ip1 is\n             * greater than or equal to the new ip we will have after we're done\n             * processing this match. Rather than perform that test directly\n             * (ip1 >= ip + mLength), which costs speed in practice, we do a simpler\n             * more predictable test. The minmatch even if we take a short match is\n             * 4 bytes, so as long as step, the distance between ip and ip1\n             * (initially) is less than 4, we know ip1 < new ip. */\n            hashLong[hl1] = (U32)(ip1 - base);\n        }\n\n        ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, OFFSET_TO_OFFBASE(offset), mLength);\n\n_match_stored:\n        /* match found */\n        ip += mLength;\n        anchor = ip;\n\n        if (ip <= ilimit) {\n            /* Complementary insertion */\n            /* done after iLimit test, as candidates could be > iend-8 */\n            {   U32 const indexToInsert = curr+2;\n                hashLong[ZSTD_hashPtr(base+indexToInsert, hBitsL, 8)] = indexToInsert;\n                hashLong[ZSTD_hashPtr(ip-2, hBitsL, 8)] = (U32)(ip-2-base);\n                hashSmall[ZSTD_hashPtr(base+indexToInsert, hBitsS, mls)] = indexToInsert;\n                hashSmall[ZSTD_hashPtr(ip-1, hBitsS, mls)] = (U32)(ip-1-base);\n            }\n\n            /* check immediate repcode */\n            while ( (ip <= ilimit)\n                 && ( (offset_2>0)\n                    & (MEM_read32(ip) == MEM_read32(ip - offset_2)) )) {\n                /* store sequence */\n                size_t const rLength = ZSTD_count(ip+4, ip+4-offset_2, iend) + 4;\n                U32 const tmpOff = offset_2; offset_2 = offset_1; offset_1 = tmpOff;  /* swap offset_2 <=> offset_1 */\n                hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = (U32)(ip-base);\n                hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = (U32)(ip-base);\n                ZSTD_storeSeq(seqStore, 0, anchor, iend, REPCODE1_TO_OFFBASE, rLength);\n                ip += rLength;\n                anchor = ip;\n                continue;   /* faster when present ... (?) */\n            }\n        }\n    }\n}\n\n\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_compressBlock_doubleFast_dictMatchState_generic(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize,\n        U32 const mls /* template */)\n{\n    ZSTD_compressionParameters const* cParams = &ms->cParams;\n    U32* const hashLong = ms->hashTable;\n    const U32 hBitsL = cParams->hashLog;\n    U32* const hashSmall = ms->chainTable;\n    const U32 hBitsS = cParams->chainLog;\n    const BYTE* const base = ms->window.base;\n    const BYTE* const istart = (const BYTE*)src;\n    const BYTE* ip = istart;\n    const BYTE* anchor = istart;\n    const U32 endIndex = (U32)((size_t)(istart - base) + srcSize);\n    /* presumes that, if there is a dictionary, it must be using Attach mode */\n    const U32 prefixLowestIndex = ZSTD_getLowestPrefixIndex(ms, endIndex, cParams->windowLog);\n    const BYTE* const prefixLowest = base + prefixLowestIndex;\n    const BYTE* const iend = istart + srcSize;\n    const BYTE* const ilimit = iend - HASH_READ_SIZE;\n    U32 offset_1=rep[0], offset_2=rep[1];\n\n    const ZSTD_MatchState_t* const dms = ms->dictMatchState;\n    const ZSTD_compressionParameters* const dictCParams = &dms->cParams;\n    const U32* const dictHashLong  = dms->hashTable;\n    const U32* const dictHashSmall = dms->chainTable;\n    const U32 dictStartIndex       = dms->window.dictLimit;\n    const BYTE* const dictBase     = dms->window.base;\n    const BYTE* const dictStart    = dictBase + dictStartIndex;\n    const BYTE* const dictEnd      = dms->window.nextSrc;\n    const U32 dictIndexDelta       = prefixLowestIndex - (U32)(dictEnd - dictBase);\n    const U32 dictHBitsL           = dictCParams->hashLog + ZSTD_SHORT_CACHE_TAG_BITS;\n    const U32 dictHBitsS           = dictCParams->chainLog + ZSTD_SHORT_CACHE_TAG_BITS;\n    const U32 dictAndPrefixLength  = (U32)((ip - prefixLowest) + (dictEnd - dictStart));\n\n    DEBUGLOG(5, \"ZSTD_compressBlock_doubleFast_dictMatchState_generic\");\n\n    /* if a dictionary is attached, it must be within window range */\n    assert(ms->window.dictLimit + (1U << cParams->windowLog) >= endIndex);\n\n    if (ms->prefetchCDictTables) {\n        size_t const hashTableBytes = (((size_t)1) << dictCParams->hashLog) * sizeof(U32);\n        size_t const chainTableBytes = (((size_t)1) << dictCParams->chainLog) * sizeof(U32);\n        PREFETCH_AREA(dictHashLong, hashTableBytes);\n        PREFETCH_AREA(dictHashSmall, chainTableBytes);\n    }\n\n    /* init */\n    ip += (dictAndPrefixLength == 0);\n\n    /* dictMatchState repCode checks don't currently handle repCode == 0\n     * disabling. */\n    assert(offset_1 <= dictAndPrefixLength);\n    assert(offset_2 <= dictAndPrefixLength);\n\n    /* Main Search Loop */\n    while (ip < ilimit) {   /* < instead of <=, because repcode check at (ip+1) */\n        size_t mLength;\n        U32 offset;\n        size_t const h2 = ZSTD_hashPtr(ip, hBitsL, 8);\n        size_t const h = ZSTD_hashPtr(ip, hBitsS, mls);\n        size_t const dictHashAndTagL = ZSTD_hashPtr(ip, dictHBitsL, 8);\n        size_t const dictHashAndTagS = ZSTD_hashPtr(ip, dictHBitsS, mls);\n        U32 const dictMatchIndexAndTagL = dictHashLong[dictHashAndTagL >> ZSTD_SHORT_CACHE_TAG_BITS];\n        U32 const dictMatchIndexAndTagS = dictHashSmall[dictHashAndTagS >> ZSTD_SHORT_CACHE_TAG_BITS];\n        int const dictTagsMatchL = ZSTD_comparePackedTags(dictMatchIndexAndTagL, dictHashAndTagL);\n        int const dictTagsMatchS = ZSTD_comparePackedTags(dictMatchIndexAndTagS, dictHashAndTagS);\n        U32 const curr = (U32)(ip-base);\n        U32 const matchIndexL = hashLong[h2];\n        U32 matchIndexS = hashSmall[h];\n        const BYTE* matchLong = base + matchIndexL;\n        const BYTE* match = base + matchIndexS;\n        const U32 repIndex = curr + 1 - offset_1;\n        const BYTE* repMatch = (repIndex < prefixLowestIndex) ?\n                               dictBase + (repIndex - dictIndexDelta) :\n                               base + repIndex;\n        hashLong[h2] = hashSmall[h] = curr;   /* update hash tables */\n\n        /* check repcode */\n        if ((ZSTD_index_overlap_check(prefixLowestIndex, repIndex))\n            && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {\n            const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;\n            mLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;\n            ip++;\n            ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, REPCODE1_TO_OFFBASE, mLength);\n            goto _match_stored;\n        }\n\n        if ((matchIndexL >= prefixLowestIndex) && (MEM_read64(matchLong) == MEM_read64(ip))) {\n            /* check prefix long match */\n            mLength = ZSTD_count(ip+8, matchLong+8, iend) + 8;\n            offset = (U32)(ip-matchLong);\n            while (((ip>anchor) & (matchLong>prefixLowest)) && (ip[-1] == matchLong[-1])) { ip--; matchLong--; mLength++; } /* catch up */\n            goto _match_found;\n        } else if (dictTagsMatchL) {\n            /* check dictMatchState long match */\n            U32 const dictMatchIndexL = dictMatchIndexAndTagL >> ZSTD_SHORT_CACHE_TAG_BITS;\n            const BYTE* dictMatchL = dictBase + dictMatchIndexL;\n            assert(dictMatchL < dictEnd);\n\n            if (dictMatchL > dictStart && MEM_read64(dictMatchL) == MEM_read64(ip)) {\n                mLength = ZSTD_count_2segments(ip+8, dictMatchL+8, iend, dictEnd, prefixLowest) + 8;\n                offset = (U32)(curr - dictMatchIndexL - dictIndexDelta);\n                while (((ip>anchor) & (dictMatchL>dictStart)) && (ip[-1] == dictMatchL[-1])) { ip--; dictMatchL--; mLength++; } /* catch up */\n                goto _match_found;\n        }   }\n\n        if (matchIndexS > prefixLowestIndex) {\n            /* short match  candidate */\n            if (MEM_read32(match) == MEM_read32(ip)) {\n                goto _search_next_long;\n            }\n        } else if (dictTagsMatchS) {\n            /* check dictMatchState short match */\n            U32 const dictMatchIndexS = dictMatchIndexAndTagS >> ZSTD_SHORT_CACHE_TAG_BITS;\n            match = dictBase + dictMatchIndexS;\n            matchIndexS = dictMatchIndexS + dictIndexDelta;\n\n            if (match > dictStart && MEM_read32(match) == MEM_read32(ip)) {\n                goto _search_next_long;\n        }   }\n\n        ip += ((ip-anchor) >> kSearchStrength) + 1;\n#if defined(__aarch64__)\n        PREFETCH_L1(ip+256);\n#endif\n        continue;\n\n_search_next_long:\n        {   size_t const hl3 = ZSTD_hashPtr(ip+1, hBitsL, 8);\n            size_t const dictHashAndTagL3 = ZSTD_hashPtr(ip+1, dictHBitsL, 8);\n            U32 const matchIndexL3 = hashLong[hl3];\n            U32 const dictMatchIndexAndTagL3 = dictHashLong[dictHashAndTagL3 >> ZSTD_SHORT_CACHE_TAG_BITS];\n            int const dictTagsMatchL3 = ZSTD_comparePackedTags(dictMatchIndexAndTagL3, dictHashAndTagL3);\n            const BYTE* matchL3 = base + matchIndexL3;\n            hashLong[hl3] = curr + 1;\n\n            /* check prefix long +1 match */\n            if ((matchIndexL3 >= prefixLowestIndex) && (MEM_read64(matchL3) == MEM_read64(ip+1))) {\n                mLength = ZSTD_count(ip+9, matchL3+8, iend) + 8;\n                ip++;\n                offset = (U32)(ip-matchL3);\n                while (((ip>anchor) & (matchL3>prefixLowest)) && (ip[-1] == matchL3[-1])) { ip--; matchL3--; mLength++; } /* catch up */\n                goto _match_found;\n            } else if (dictTagsMatchL3) {\n                /* check dict long +1 match */\n                U32 const dictMatchIndexL3 = dictMatchIndexAndTagL3 >> ZSTD_SHORT_CACHE_TAG_BITS;\n                const BYTE* dictMatchL3 = dictBase + dictMatchIndexL3;\n                assert(dictMatchL3 < dictEnd);\n                if (dictMatchL3 > dictStart && MEM_read64(dictMatchL3) == MEM_read64(ip+1)) {\n                    mLength = ZSTD_count_2segments(ip+1+8, dictMatchL3+8, iend, dictEnd, prefixLowest) + 8;\n                    ip++;\n                    offset = (U32)(curr + 1 - dictMatchIndexL3 - dictIndexDelta);\n                    while (((ip>anchor) & (dictMatchL3>dictStart)) && (ip[-1] == dictMatchL3[-1])) { ip--; dictMatchL3--; mLength++; } /* catch up */\n                    goto _match_found;\n        }   }   }\n\n        /* if no long +1 match, explore the short match we found */\n        if (matchIndexS < prefixLowestIndex) {\n            mLength = ZSTD_count_2segments(ip+4, match+4, iend, dictEnd, prefixLowest) + 4;\n            offset = (U32)(curr - matchIndexS);\n            while (((ip>anchor) & (match>dictStart)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */\n        } else {\n            mLength = ZSTD_count(ip+4, match+4, iend) + 4;\n            offset = (U32)(ip - match);\n            while (((ip>anchor) & (match>prefixLowest)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; } /* catch up */\n        }\n\n_match_found:\n        offset_2 = offset_1;\n        offset_1 = offset;\n\n        ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, OFFSET_TO_OFFBASE(offset), mLength);\n\n_match_stored:\n        /* match found */\n        ip += mLength;\n        anchor = ip;\n\n        if (ip <= ilimit) {\n            /* Complementary insertion */\n            /* done after iLimit test, as candidates could be > iend-8 */\n            {   U32 const indexToInsert = curr+2;\n                hashLong[ZSTD_hashPtr(base+indexToInsert, hBitsL, 8)] = indexToInsert;\n                hashLong[ZSTD_hashPtr(ip-2, hBitsL, 8)] = (U32)(ip-2-base);\n                hashSmall[ZSTD_hashPtr(base+indexToInsert, hBitsS, mls)] = indexToInsert;\n                hashSmall[ZSTD_hashPtr(ip-1, hBitsS, mls)] = (U32)(ip-1-base);\n            }\n\n            /* check immediate repcode */\n            while (ip <= ilimit) {\n                U32 const current2 = (U32)(ip-base);\n                U32 const repIndex2 = current2 - offset_2;\n                const BYTE* repMatch2 = repIndex2 < prefixLowestIndex ?\n                        dictBase + repIndex2 - dictIndexDelta :\n                        base + repIndex2;\n                if ( (ZSTD_index_overlap_check(prefixLowestIndex, repIndex2))\n                   && (MEM_read32(repMatch2) == MEM_read32(ip)) ) {\n                    const BYTE* const repEnd2 = repIndex2 < prefixLowestIndex ? dictEnd : iend;\n                    size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, prefixLowest) + 4;\n                    U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset;   /* swap offset_2 <=> offset_1 */\n                    ZSTD_storeSeq(seqStore, 0, anchor, iend, REPCODE1_TO_OFFBASE, repLength2);\n                    hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = current2;\n                    hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = current2;\n                    ip += repLength2;\n                    anchor = ip;\n                    continue;\n                }\n                break;\n            }\n        }\n    }   /* while (ip < ilimit) */\n\n    /* save reps for next block */\n    rep[0] = offset_1;\n    rep[1] = offset_2;\n\n    /* Return the last literals size */\n    return (size_t)(iend - anchor);\n}\n\n#define ZSTD_GEN_DFAST_FN(dictMode, mls)                                                                 \\\n    static size_t ZSTD_compressBlock_doubleFast_##dictMode##_##mls(                                      \\\n            ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],                          \\\n            void const* src, size_t srcSize)                                                             \\\n    {                                                                                                    \\\n        return ZSTD_compressBlock_doubleFast_##dictMode##_generic(ms, seqStore, rep, src, srcSize, mls); \\\n    }\n\nZSTD_GEN_DFAST_FN(noDict, 4)\nZSTD_GEN_DFAST_FN(noDict, 5)\nZSTD_GEN_DFAST_FN(noDict, 6)\nZSTD_GEN_DFAST_FN(noDict, 7)\n\nZSTD_GEN_DFAST_FN(dictMatchState, 4)\nZSTD_GEN_DFAST_FN(dictMatchState, 5)\nZSTD_GEN_DFAST_FN(dictMatchState, 6)\nZSTD_GEN_DFAST_FN(dictMatchState, 7)\n\n\nsize_t ZSTD_compressBlock_doubleFast(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    const U32 mls = ms->cParams.minMatch;\n    switch(mls)\n    {\n    default: /* includes case 3 */\n    case 4 :\n        return ZSTD_compressBlock_doubleFast_noDict_4(ms, seqStore, rep, src, srcSize);\n    case 5 :\n        return ZSTD_compressBlock_doubleFast_noDict_5(ms, seqStore, rep, src, srcSize);\n    case 6 :\n        return ZSTD_compressBlock_doubleFast_noDict_6(ms, seqStore, rep, src, srcSize);\n    case 7 :\n        return ZSTD_compressBlock_doubleFast_noDict_7(ms, seqStore, rep, src, srcSize);\n    }\n}\n\n\nsize_t ZSTD_compressBlock_doubleFast_dictMatchState(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    const U32 mls = ms->cParams.minMatch;\n    switch(mls)\n    {\n    default: /* includes case 3 */\n    case 4 :\n        return ZSTD_compressBlock_doubleFast_dictMatchState_4(ms, seqStore, rep, src, srcSize);\n    case 5 :\n        return ZSTD_compressBlock_doubleFast_dictMatchState_5(ms, seqStore, rep, src, srcSize);\n    case 6 :\n        return ZSTD_compressBlock_doubleFast_dictMatchState_6(ms, seqStore, rep, src, srcSize);\n    case 7 :\n        return ZSTD_compressBlock_doubleFast_dictMatchState_7(ms, seqStore, rep, src, srcSize);\n    }\n}\n\n\nstatic\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_compressBlock_doubleFast_extDict_generic(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize,\n        U32 const mls /* template */)\n{\n    ZSTD_compressionParameters const* cParams = &ms->cParams;\n    U32* const hashLong = ms->hashTable;\n    U32  const hBitsL = cParams->hashLog;\n    U32* const hashSmall = ms->chainTable;\n    U32  const hBitsS = cParams->chainLog;\n    const BYTE* const istart = (const BYTE*)src;\n    const BYTE* ip = istart;\n    const BYTE* anchor = istart;\n    const BYTE* const iend = istart + srcSize;\n    const BYTE* const ilimit = iend - 8;\n    const BYTE* const base = ms->window.base;\n    const U32   endIndex = (U32)((size_t)(istart - base) + srcSize);\n    const U32   lowLimit = ZSTD_getLowestMatchIndex(ms, endIndex, cParams->windowLog);\n    const U32   dictStartIndex = lowLimit;\n    const U32   dictLimit = ms->window.dictLimit;\n    const U32   prefixStartIndex = (dictLimit > lowLimit) ? dictLimit : lowLimit;\n    const BYTE* const prefixStart = base + prefixStartIndex;\n    const BYTE* const dictBase = ms->window.dictBase;\n    const BYTE* const dictStart = dictBase + dictStartIndex;\n    const BYTE* const dictEnd = dictBase + prefixStartIndex;\n    U32 offset_1=rep[0], offset_2=rep[1];\n\n    DEBUGLOG(5, \"ZSTD_compressBlock_doubleFast_extDict_generic (srcSize=%zu)\", srcSize);\n\n    /* if extDict is invalidated due to maxDistance, switch to \"regular\" variant */\n    if (prefixStartIndex == dictStartIndex)\n        return ZSTD_compressBlock_doubleFast(ms, seqStore, rep, src, srcSize);\n\n    /* Search Loop */\n    while (ip < ilimit) {  /* < instead of <=, because (ip+1) */\n        const size_t hSmall = ZSTD_hashPtr(ip, hBitsS, mls);\n        const U32 matchIndex = hashSmall[hSmall];\n        const BYTE* const matchBase = matchIndex < prefixStartIndex ? dictBase : base;\n        const BYTE* match = matchBase + matchIndex;\n\n        const size_t hLong = ZSTD_hashPtr(ip, hBitsL, 8);\n        const U32 matchLongIndex = hashLong[hLong];\n        const BYTE* const matchLongBase = matchLongIndex < prefixStartIndex ? dictBase : base;\n        const BYTE* matchLong = matchLongBase + matchLongIndex;\n\n        const U32 curr = (U32)(ip-base);\n        const U32 repIndex = curr + 1 - offset_1;   /* offset_1 expected <= curr +1 */\n        const BYTE* const repBase = repIndex < prefixStartIndex ? dictBase : base;\n        const BYTE* const repMatch = repBase + repIndex;\n        size_t mLength;\n        hashSmall[hSmall] = hashLong[hLong] = curr;   /* update hash table */\n\n        if (((ZSTD_index_overlap_check(prefixStartIndex, repIndex))\n            & (offset_1 <= curr+1 - dictStartIndex)) /* note: we are searching at curr+1 */\n          && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {\n            const BYTE* repMatchEnd = repIndex < prefixStartIndex ? dictEnd : iend;\n            mLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixStart) + 4;\n            ip++;\n            ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, REPCODE1_TO_OFFBASE, mLength);\n        } else {\n            if ((matchLongIndex > dictStartIndex) && (MEM_read64(matchLong) == MEM_read64(ip))) {\n                const BYTE* const matchEnd = matchLongIndex < prefixStartIndex ? dictEnd : iend;\n                const BYTE* const lowMatchPtr = matchLongIndex < prefixStartIndex ? dictStart : prefixStart;\n                U32 offset;\n                mLength = ZSTD_count_2segments(ip+8, matchLong+8, iend, matchEnd, prefixStart) + 8;\n                offset = curr - matchLongIndex;\n                while (((ip>anchor) & (matchLong>lowMatchPtr)) && (ip[-1] == matchLong[-1])) { ip--; matchLong--; mLength++; }   /* catch up */\n                offset_2 = offset_1;\n                offset_1 = offset;\n                ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, OFFSET_TO_OFFBASE(offset), mLength);\n\n            } else if ((matchIndex > dictStartIndex) && (MEM_read32(match) == MEM_read32(ip))) {\n                size_t const h3 = ZSTD_hashPtr(ip+1, hBitsL, 8);\n                U32 const matchIndex3 = hashLong[h3];\n                const BYTE* const match3Base = matchIndex3 < prefixStartIndex ? dictBase : base;\n                const BYTE* match3 = match3Base + matchIndex3;\n                U32 offset;\n                hashLong[h3] = curr + 1;\n                if ( (matchIndex3 > dictStartIndex) && (MEM_read64(match3) == MEM_read64(ip+1)) ) {\n                    const BYTE* const matchEnd = matchIndex3 < prefixStartIndex ? dictEnd : iend;\n                    const BYTE* const lowMatchPtr = matchIndex3 < prefixStartIndex ? dictStart : prefixStart;\n                    mLength = ZSTD_count_2segments(ip+9, match3+8, iend, matchEnd, prefixStart) + 8;\n                    ip++;\n                    offset = curr+1 - matchIndex3;\n                    while (((ip>anchor) & (match3>lowMatchPtr)) && (ip[-1] == match3[-1])) { ip--; match3--; mLength++; } /* catch up */\n                } else {\n                    const BYTE* const matchEnd = matchIndex < prefixStartIndex ? dictEnd : iend;\n                    const BYTE* const lowMatchPtr = matchIndex < prefixStartIndex ? dictStart : prefixStart;\n                    mLength = ZSTD_count_2segments(ip+4, match+4, iend, matchEnd, prefixStart) + 4;\n                    offset = curr - matchIndex;\n                    while (((ip>anchor) & (match>lowMatchPtr)) && (ip[-1] == match[-1])) { ip--; match--; mLength++; }   /* catch up */\n                }\n                offset_2 = offset_1;\n                offset_1 = offset;\n                ZSTD_storeSeq(seqStore, (size_t)(ip-anchor), anchor, iend, OFFSET_TO_OFFBASE(offset), mLength);\n\n            } else {\n                ip += ((ip-anchor) >> kSearchStrength) + 1;\n                continue;\n        }   }\n\n        /* move to next sequence start */\n        ip += mLength;\n        anchor = ip;\n\n        if (ip <= ilimit) {\n            /* Complementary insertion */\n            /* done after iLimit test, as candidates could be > iend-8 */\n            {   U32 const indexToInsert = curr+2;\n                hashLong[ZSTD_hashPtr(base+indexToInsert, hBitsL, 8)] = indexToInsert;\n                hashLong[ZSTD_hashPtr(ip-2, hBitsL, 8)] = (U32)(ip-2-base);\n                hashSmall[ZSTD_hashPtr(base+indexToInsert, hBitsS, mls)] = indexToInsert;\n                hashSmall[ZSTD_hashPtr(ip-1, hBitsS, mls)] = (U32)(ip-1-base);\n            }\n\n            /* check immediate repcode */\n            while (ip <= ilimit) {\n                U32 const current2 = (U32)(ip-base);\n                U32 const repIndex2 = current2 - offset_2;\n                const BYTE* repMatch2 = repIndex2 < prefixStartIndex ? dictBase + repIndex2 : base + repIndex2;\n                if ( ((ZSTD_index_overlap_check(prefixStartIndex, repIndex2))\n                    & (offset_2 <= current2 - dictStartIndex))\n                  && (MEM_read32(repMatch2) == MEM_read32(ip)) ) {\n                    const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend;\n                    size_t const repLength2 = ZSTD_count_2segments(ip+4, repMatch2+4, iend, repEnd2, prefixStart) + 4;\n                    U32 const tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset;   /* swap offset_2 <=> offset_1 */\n                    ZSTD_storeSeq(seqStore, 0, anchor, iend, REPCODE1_TO_OFFBASE, repLength2);\n                    hashSmall[ZSTD_hashPtr(ip, hBitsS, mls)] = current2;\n                    hashLong[ZSTD_hashPtr(ip, hBitsL, 8)] = current2;\n                    ip += repLength2;\n                    anchor = ip;\n                    continue;\n                }\n                break;\n    }   }   }\n\n    /* save reps for next block */\n    rep[0] = offset_1;\n    rep[1] = offset_2;\n\n    /* Return the last literals size */\n    return (size_t)(iend - anchor);\n}\n\nZSTD_GEN_DFAST_FN(extDict, 4)\nZSTD_GEN_DFAST_FN(extDict, 5)\nZSTD_GEN_DFAST_FN(extDict, 6)\nZSTD_GEN_DFAST_FN(extDict, 7)\n\nsize_t ZSTD_compressBlock_doubleFast_extDict(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    U32 const mls = ms->cParams.minMatch;\n    switch(mls)\n    {\n    default: /* includes case 3 */\n    case 4 :\n        return ZSTD_compressBlock_doubleFast_extDict_4(ms, seqStore, rep, src, srcSize);\n    case 5 :\n        return ZSTD_compressBlock_doubleFast_extDict_5(ms, seqStore, rep, src, srcSize);\n    case 6 :\n        return ZSTD_compressBlock_doubleFast_extDict_6(ms, seqStore, rep, src, srcSize);\n    case 7 :\n        return ZSTD_compressBlock_doubleFast_extDict_7(ms, seqStore, rep, src, srcSize);\n    }\n}\n\n#endif /* ZSTD_EXCLUDE_DFAST_BLOCK_COMPRESSOR */\n"
  },
  {
    "path": "lib/compress/zstd_double_fast.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_DOUBLE_FAST_H\n#define ZSTD_DOUBLE_FAST_H\n\n#include \"../common/mem.h\"      /* U32 */\n#include \"zstd_compress_internal.h\"     /* ZSTD_CCtx, size_t */\n\n#ifndef ZSTD_EXCLUDE_DFAST_BLOCK_COMPRESSOR\n\nvoid ZSTD_fillDoubleHashTable(ZSTD_MatchState_t* ms,\n                              void const* end, ZSTD_dictTableLoadMethod_e dtlm,\n                              ZSTD_tableFillPurpose_e tfp);\n\nsize_t ZSTD_compressBlock_doubleFast(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_doubleFast_dictMatchState(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_doubleFast_extDict(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\n\n#define ZSTD_COMPRESSBLOCK_DOUBLEFAST ZSTD_compressBlock_doubleFast\n#define ZSTD_COMPRESSBLOCK_DOUBLEFAST_DICTMATCHSTATE ZSTD_compressBlock_doubleFast_dictMatchState\n#define ZSTD_COMPRESSBLOCK_DOUBLEFAST_EXTDICT ZSTD_compressBlock_doubleFast_extDict\n#else\n#define ZSTD_COMPRESSBLOCK_DOUBLEFAST NULL\n#define ZSTD_COMPRESSBLOCK_DOUBLEFAST_DICTMATCHSTATE NULL\n#define ZSTD_COMPRESSBLOCK_DOUBLEFAST_EXTDICT NULL\n#endif /* ZSTD_EXCLUDE_DFAST_BLOCK_COMPRESSOR */\n\n#endif /* ZSTD_DOUBLE_FAST_H */\n"
  },
  {
    "path": "lib/compress/zstd_fast.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#include \"zstd_compress_internal.h\"  /* ZSTD_hashPtr, ZSTD_count, ZSTD_storeSeq */\n#include \"zstd_fast.h\"\n\nstatic\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nvoid ZSTD_fillHashTableForCDict(ZSTD_MatchState_t* ms,\n                        const void* const end,\n                        ZSTD_dictTableLoadMethod_e dtlm)\n{\n    const ZSTD_compressionParameters* const cParams = &ms->cParams;\n    U32* const hashTable = ms->hashTable;\n    U32  const hBits = cParams->hashLog + ZSTD_SHORT_CACHE_TAG_BITS;\n    U32  const mls = cParams->minMatch;\n    const BYTE* const base = ms->window.base;\n    const BYTE* ip = base + ms->nextToUpdate;\n    const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE;\n    const U32 fastHashFillStep = 3;\n\n    /* Currently, we always use ZSTD_dtlm_full for filling CDict tables.\n     * Feel free to remove this assert if there's a good reason! */\n    assert(dtlm == ZSTD_dtlm_full);\n\n    /* Always insert every fastHashFillStep position into the hash table.\n     * Insert the other positions if their hash entry is empty.\n     */\n    for ( ; ip + fastHashFillStep < iend + 2; ip += fastHashFillStep) {\n        U32 const curr = (U32)(ip - base);\n        {   size_t const hashAndTag = ZSTD_hashPtr(ip, hBits, mls);\n            ZSTD_writeTaggedIndex(hashTable, hashAndTag, curr);   }\n\n        if (dtlm == ZSTD_dtlm_fast) continue;\n        /* Only load extra positions for ZSTD_dtlm_full */\n        {   U32 p;\n            for (p = 1; p < fastHashFillStep; ++p) {\n                size_t const hashAndTag = ZSTD_hashPtr(ip + p, hBits, mls);\n                if (hashTable[hashAndTag >> ZSTD_SHORT_CACHE_TAG_BITS] == 0) {  /* not yet filled */\n                    ZSTD_writeTaggedIndex(hashTable, hashAndTag, curr + p);\n    }   }   }   }\n}\n\nstatic\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nvoid ZSTD_fillHashTableForCCtx(ZSTD_MatchState_t* ms,\n                        const void* const end,\n                        ZSTD_dictTableLoadMethod_e dtlm)\n{\n    const ZSTD_compressionParameters* const cParams = &ms->cParams;\n    U32* const hashTable = ms->hashTable;\n    U32  const hBits = cParams->hashLog;\n    U32  const mls = cParams->minMatch;\n    const BYTE* const base = ms->window.base;\n    const BYTE* ip = base + ms->nextToUpdate;\n    const BYTE* const iend = ((const BYTE*)end) - HASH_READ_SIZE;\n    const U32 fastHashFillStep = 3;\n\n    /* Currently, we always use ZSTD_dtlm_fast for filling CCtx tables.\n     * Feel free to remove this assert if there's a good reason! */\n    assert(dtlm == ZSTD_dtlm_fast);\n\n    /* Always insert every fastHashFillStep position into the hash table.\n     * Insert the other positions if their hash entry is empty.\n     */\n    for ( ; ip + fastHashFillStep < iend + 2; ip += fastHashFillStep) {\n        U32 const curr = (U32)(ip - base);\n        size_t const hash0 = ZSTD_hashPtr(ip, hBits, mls);\n        hashTable[hash0] = curr;\n        if (dtlm == ZSTD_dtlm_fast) continue;\n        /* Only load extra positions for ZSTD_dtlm_full */\n        {   U32 p;\n            for (p = 1; p < fastHashFillStep; ++p) {\n                size_t const hash = ZSTD_hashPtr(ip + p, hBits, mls);\n                if (hashTable[hash] == 0) {  /* not yet filled */\n                    hashTable[hash] = curr + p;\n    }   }   }   }\n}\n\nvoid ZSTD_fillHashTable(ZSTD_MatchState_t* ms,\n                        const void* const end,\n                        ZSTD_dictTableLoadMethod_e dtlm,\n                        ZSTD_tableFillPurpose_e tfp)\n{\n    if (tfp == ZSTD_tfp_forCDict) {\n        ZSTD_fillHashTableForCDict(ms, end, dtlm);\n    } else {\n        ZSTD_fillHashTableForCCtx(ms, end, dtlm);\n    }\n}\n\n\ntypedef int (*ZSTD_match4Found) (const BYTE* currentPtr, const BYTE* matchAddress, U32 matchIdx, U32 idxLowLimit);\n\nstatic int\nZSTD_match4Found_cmov(const BYTE* currentPtr, const BYTE* matchAddress, U32 matchIdx, U32 idxLowLimit)\n{\n    /* Array of ~random data, should have low probability of matching data.\n     * Load from here if the index is invalid.\n     * Used to avoid unpredictable branches. */\n    static const BYTE dummy[] = {0x12,0x34,0x56,0x78};\n\n    /* currentIdx >= lowLimit is a (somewhat) unpredictable branch.\n     * However expression below compiles into conditional move.\n     */\n    const BYTE* mvalAddr = ZSTD_selectAddr(matchIdx, idxLowLimit, matchAddress, dummy);\n    /* Note: this used to be written as : return test1 && test2;\n     * Unfortunately, once inlined, these tests become branches,\n     * in which case it becomes critical that they are executed in the right order (test1 then test2).\n     * So we have to write these tests in a specific manner to ensure their ordering.\n     */\n    if (MEM_read32(currentPtr) != MEM_read32(mvalAddr)) return 0;\n    /* force ordering of these tests, which matters once the function is inlined, as they become branches */\n#if defined(__GNUC__)\n    __asm__(\"\");\n#endif\n    return matchIdx >= idxLowLimit;\n}\n\nstatic int\nZSTD_match4Found_branch(const BYTE* currentPtr, const BYTE* matchAddress, U32 matchIdx, U32 idxLowLimit)\n{\n    /* using a branch instead of a cmov,\n     * because it's faster in scenarios where matchIdx >= idxLowLimit is generally true,\n     * aka almost all candidates are within range */\n    U32 mval;\n    if (matchIdx >= idxLowLimit) {\n        mval = MEM_read32(matchAddress);\n    } else {\n        mval = MEM_read32(currentPtr) ^ 1; /* guaranteed to not match. */\n    }\n\n    return (MEM_read32(currentPtr) == mval);\n}\n\n\n/**\n * If you squint hard enough (and ignore repcodes), the search operation at any\n * given position is broken into 4 stages:\n *\n * 1. Hash   (map position to hash value via input read)\n * 2. Lookup (map hash val to index via hashtable read)\n * 3. Load   (map index to value at that position via input read)\n * 4. Compare\n *\n * Each of these steps involves a memory read at an address which is computed\n * from the previous step. This means these steps must be sequenced and their\n * latencies are cumulative.\n *\n * Rather than do 1->2->3->4 sequentially for a single position before moving\n * onto the next, this implementation interleaves these operations across the\n * next few positions:\n *\n * R = Repcode Read & Compare\n * H = Hash\n * T = Table Lookup\n * M = Match Read & Compare\n *\n * Pos | Time -->\n * ----+-------------------\n * N   | ... M\n * N+1 | ...   TM\n * N+2 |    R H   T M\n * N+3 |         H    TM\n * N+4 |           R H   T M\n * N+5 |                H   ...\n * N+6 |                  R ...\n *\n * This is very much analogous to the pipelining of execution in a CPU. And just\n * like a CPU, we have to dump the pipeline when we find a match (i.e., take a\n * branch).\n *\n * When this happens, we throw away our current state, and do the following prep\n * to re-enter the loop:\n *\n * Pos | Time -->\n * ----+-------------------\n * N   | H T\n * N+1 |  H\n *\n * This is also the work we do at the beginning to enter the loop initially.\n */\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_compressBlock_fast_noDict_generic(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize,\n        U32 const mls, int useCmov)\n{\n    const ZSTD_compressionParameters* const cParams = &ms->cParams;\n    U32* const hashTable = ms->hashTable;\n    U32 const hlog = cParams->hashLog;\n    size_t const stepSize = cParams->targetLength + !(cParams->targetLength) + 1; /* min 2 */\n    const BYTE* const base = ms->window.base;\n    const BYTE* const istart = (const BYTE*)src;\n    const U32   endIndex = (U32)((size_t)(istart - base) + srcSize);\n    const U32   prefixStartIndex = ZSTD_getLowestPrefixIndex(ms, endIndex, cParams->windowLog);\n    const BYTE* const prefixStart = base + prefixStartIndex;\n    const BYTE* const iend = istart + srcSize;\n    const BYTE* const ilimit = iend - HASH_READ_SIZE;\n\n    const BYTE* anchor = istart;\n    const BYTE* ip0 = istart;\n    const BYTE* ip1;\n    const BYTE* ip2;\n    const BYTE* ip3;\n    U32 current0;\n\n    U32 rep_offset1 = rep[0];\n    U32 rep_offset2 = rep[1];\n    U32 offsetSaved1 = 0, offsetSaved2 = 0;\n\n    size_t hash0; /* hash for ip0 */\n    size_t hash1; /* hash for ip1 */\n    U32 matchIdx; /* match idx for ip0 */\n\n    U32 offcode;\n    const BYTE* match0;\n    size_t mLength;\n\n    /* ip0 and ip1 are always adjacent. The targetLength skipping and\n     * uncompressibility acceleration is applied to every other position,\n     * matching the behavior of #1562. step therefore represents the gap\n     * between pairs of positions, from ip0 to ip2 or ip1 to ip3. */\n    size_t step;\n    const BYTE* nextStep;\n    const size_t kStepIncr = (1 << (kSearchStrength - 1));\n    const ZSTD_match4Found matchFound = useCmov ? ZSTD_match4Found_cmov : ZSTD_match4Found_branch;\n\n    DEBUGLOG(5, \"ZSTD_compressBlock_fast_generic\");\n    ip0 += (ip0 == prefixStart);\n    {   U32 const curr = (U32)(ip0 - base);\n        U32 const windowLow = ZSTD_getLowestPrefixIndex(ms, curr, cParams->windowLog);\n        U32 const maxRep = curr - windowLow;\n        if (rep_offset2 > maxRep) offsetSaved2 = rep_offset2, rep_offset2 = 0;\n        if (rep_offset1 > maxRep) offsetSaved1 = rep_offset1, rep_offset1 = 0;\n    }\n\n    /* start each op */\n_start: /* Requires: ip0 */\n\n    step = stepSize;\n    nextStep = ip0 + kStepIncr;\n\n    /* calculate positions, ip0 - anchor == 0, so we skip step calc */\n    ip1 = ip0 + 1;\n    ip2 = ip0 + step;\n    ip3 = ip2 + 1;\n\n    if (ip3 >= ilimit) {\n        goto _cleanup;\n    }\n\n    hash0 = ZSTD_hashPtr(ip0, hlog, mls);\n    hash1 = ZSTD_hashPtr(ip1, hlog, mls);\n\n    matchIdx = hashTable[hash0];\n\n    do {\n        /* load repcode match for ip[2]*/\n        const U32 rval = MEM_read32(ip2 - rep_offset1);\n\n        /* write back hash table entry */\n        current0 = (U32)(ip0 - base);\n        hashTable[hash0] = current0;\n\n        /* check repcode at ip[2] */\n        if ((MEM_read32(ip2) == rval) & (rep_offset1 > 0)) {\n            ip0 = ip2;\n            match0 = ip0 - rep_offset1;\n            mLength = ip0[-1] == match0[-1];\n            ip0 -= mLength;\n            match0 -= mLength;\n            offcode = REPCODE1_TO_OFFBASE;\n            mLength += 4;\n\n            /* Write next hash table entry: it's already calculated.\n             * This write is known to be safe because ip1 is before the\n             * repcode (ip2). */\n            hashTable[hash1] = (U32)(ip1 - base);\n\n            goto _match;\n        }\n\n         if (matchFound(ip0, base + matchIdx, matchIdx, prefixStartIndex)) {\n            /* Write next hash table entry (it's already calculated).\n            * This write is known to be safe because the ip1 == ip0 + 1,\n            * so searching will resume after ip1 */\n            hashTable[hash1] = (U32)(ip1 - base);\n\n            goto _offset;\n        }\n\n        /* lookup ip[1] */\n        matchIdx = hashTable[hash1];\n\n        /* hash ip[2] */\n        hash0 = hash1;\n        hash1 = ZSTD_hashPtr(ip2, hlog, mls);\n\n        /* advance to next positions */\n        ip0 = ip1;\n        ip1 = ip2;\n        ip2 = ip3;\n\n        /* write back hash table entry */\n        current0 = (U32)(ip0 - base);\n        hashTable[hash0] = current0;\n\n         if (matchFound(ip0, base + matchIdx, matchIdx, prefixStartIndex)) {\n            /* Write next hash table entry, since it's already calculated */\n            if (step <= 4) {\n                /* Avoid writing an index if it's >= position where search will resume.\n                * The minimum possible match has length 4, so search can resume at ip0 + 4.\n                */\n                hashTable[hash1] = (U32)(ip1 - base);\n            }\n            goto _offset;\n        }\n\n        /* lookup ip[1] */\n        matchIdx = hashTable[hash1];\n\n        /* hash ip[2] */\n        hash0 = hash1;\n        hash1 = ZSTD_hashPtr(ip2, hlog, mls);\n\n        /* advance to next positions */\n        ip0 = ip1;\n        ip1 = ip2;\n        ip2 = ip0 + step;\n        ip3 = ip1 + step;\n\n        /* calculate step */\n        if (ip2 >= nextStep) {\n            step++;\n            PREFETCH_L1(ip1 + 64);\n            PREFETCH_L1(ip1 + 128);\n            nextStep += kStepIncr;\n        }\n    } while (ip3 < ilimit);\n\n_cleanup:\n    /* Note that there are probably still a couple positions one could search.\n     * However, it seems to be a meaningful performance hit to try to search\n     * them. So let's not. */\n\n    /* When the repcodes are outside of the prefix, we set them to zero before the loop.\n     * When the offsets are still zero, we need to restore them after the block to have a correct\n     * repcode history. If only one offset was invalid, it is easy. The tricky case is when both\n     * offsets were invalid. We need to figure out which offset to refill with.\n     *     - If both offsets are zero they are in the same order.\n     *     - If both offsets are non-zero, we won't restore the offsets from `offsetSaved[12]`.\n     *     - If only one is zero, we need to decide which offset to restore.\n     *         - If rep_offset1 is non-zero, then rep_offset2 must be offsetSaved1.\n     *         - It is impossible for rep_offset2 to be non-zero.\n     *\n     * So if rep_offset1 started invalid (offsetSaved1 != 0) and became valid (rep_offset1 != 0), then\n     * set rep[0] = rep_offset1 and rep[1] = offsetSaved1.\n     */\n    offsetSaved2 = ((offsetSaved1 != 0) && (rep_offset1 != 0)) ? offsetSaved1 : offsetSaved2;\n\n    /* save reps for next block */\n    rep[0] = rep_offset1 ? rep_offset1 : offsetSaved1;\n    rep[1] = rep_offset2 ? rep_offset2 : offsetSaved2;\n\n    /* Return the last literals size */\n    return (size_t)(iend - anchor);\n\n_offset: /* Requires: ip0, idx */\n\n    /* Compute the offset code. */\n    match0 = base + matchIdx;\n    rep_offset2 = rep_offset1;\n    rep_offset1 = (U32)(ip0-match0);\n    offcode = OFFSET_TO_OFFBASE(rep_offset1);\n    mLength = 4;\n\n    /* Count the backwards match length. */\n    while (((ip0>anchor) & (match0>prefixStart)) && (ip0[-1] == match0[-1])) {\n        ip0--;\n        match0--;\n        mLength++;\n    }\n\n_match: /* Requires: ip0, match0, offcode */\n\n    /* Count the forward length. */\n    mLength += ZSTD_count(ip0 + mLength, match0 + mLength, iend);\n\n    ZSTD_storeSeq(seqStore, (size_t)(ip0 - anchor), anchor, iend, offcode, mLength);\n\n    ip0 += mLength;\n    anchor = ip0;\n\n    /* Fill table and check for immediate repcode. */\n    if (ip0 <= ilimit) {\n        /* Fill Table */\n        assert(base+current0+2 > istart);  /* check base overflow */\n        hashTable[ZSTD_hashPtr(base+current0+2, hlog, mls)] = current0+2;  /* here because current+2 could be > iend-8 */\n        hashTable[ZSTD_hashPtr(ip0-2, hlog, mls)] = (U32)(ip0-2-base);\n\n        if (rep_offset2 > 0) { /* rep_offset2==0 means rep_offset2 is invalidated */\n            while ( (ip0 <= ilimit) && (MEM_read32(ip0) == MEM_read32(ip0 - rep_offset2)) ) {\n                /* store sequence */\n                size_t const rLength = ZSTD_count(ip0+4, ip0+4-rep_offset2, iend) + 4;\n                { U32 const tmpOff = rep_offset2; rep_offset2 = rep_offset1; rep_offset1 = tmpOff; } /* swap rep_offset2 <=> rep_offset1 */\n                hashTable[ZSTD_hashPtr(ip0, hlog, mls)] = (U32)(ip0-base);\n                ip0 += rLength;\n                ZSTD_storeSeq(seqStore, 0 /*litLen*/, anchor, iend, REPCODE1_TO_OFFBASE, rLength);\n                anchor = ip0;\n                continue;   /* faster when present (confirmed on gcc-8) ... (?) */\n    }   }   }\n\n    goto _start;\n}\n\n#define ZSTD_GEN_FAST_FN(dictMode, mml, cmov)                                                       \\\n    static size_t ZSTD_compressBlock_fast_##dictMode##_##mml##_##cmov(                              \\\n            ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],                    \\\n            void const* src, size_t srcSize)                                                       \\\n    {                                                                                              \\\n        return ZSTD_compressBlock_fast_##dictMode##_generic(ms, seqStore, rep, src, srcSize, mml, cmov); \\\n    }\n\nZSTD_GEN_FAST_FN(noDict, 4, 1)\nZSTD_GEN_FAST_FN(noDict, 5, 1)\nZSTD_GEN_FAST_FN(noDict, 6, 1)\nZSTD_GEN_FAST_FN(noDict, 7, 1)\n\nZSTD_GEN_FAST_FN(noDict, 4, 0)\nZSTD_GEN_FAST_FN(noDict, 5, 0)\nZSTD_GEN_FAST_FN(noDict, 6, 0)\nZSTD_GEN_FAST_FN(noDict, 7, 0)\n\nsize_t ZSTD_compressBlock_fast(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    U32 const mml = ms->cParams.minMatch;\n    /* use cmov when \"candidate in range\" branch is likely unpredictable */\n    int const useCmov = ms->cParams.windowLog < 19;\n    assert(ms->dictMatchState == NULL);\n    if (useCmov) {\n        switch(mml)\n        {\n        default: /* includes case 3 */\n        case 4 :\n            return ZSTD_compressBlock_fast_noDict_4_1(ms, seqStore, rep, src, srcSize);\n        case 5 :\n            return ZSTD_compressBlock_fast_noDict_5_1(ms, seqStore, rep, src, srcSize);\n        case 6 :\n            return ZSTD_compressBlock_fast_noDict_6_1(ms, seqStore, rep, src, srcSize);\n        case 7 :\n            return ZSTD_compressBlock_fast_noDict_7_1(ms, seqStore, rep, src, srcSize);\n        }\n    } else {\n        /* use a branch instead */\n        switch(mml)\n        {\n        default: /* includes case 3 */\n        case 4 :\n            return ZSTD_compressBlock_fast_noDict_4_0(ms, seqStore, rep, src, srcSize);\n        case 5 :\n            return ZSTD_compressBlock_fast_noDict_5_0(ms, seqStore, rep, src, srcSize);\n        case 6 :\n            return ZSTD_compressBlock_fast_noDict_6_0(ms, seqStore, rep, src, srcSize);\n        case 7 :\n            return ZSTD_compressBlock_fast_noDict_7_0(ms, seqStore, rep, src, srcSize);\n        }\n    }\n}\n\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_compressBlock_fast_dictMatchState_generic(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize, U32 const mls, U32 const hasStep)\n{\n    const ZSTD_compressionParameters* const cParams = &ms->cParams;\n    U32* const hashTable = ms->hashTable;\n    U32 const hlog = cParams->hashLog;\n    /* support stepSize of 0 */\n    U32 const stepSize = cParams->targetLength + !(cParams->targetLength);\n    const BYTE* const base = ms->window.base;\n    const BYTE* const istart = (const BYTE*)src;\n    const BYTE* ip0 = istart;\n    const BYTE* ip1 = ip0 + stepSize; /* we assert below that stepSize >= 1 */\n    const BYTE* anchor = istart;\n    const U32   prefixStartIndex = ms->window.dictLimit;\n    const BYTE* const prefixStart = base + prefixStartIndex;\n    const BYTE* const iend = istart + srcSize;\n    const BYTE* const ilimit = iend - HASH_READ_SIZE;\n    U32 offset_1=rep[0], offset_2=rep[1];\n\n    const ZSTD_MatchState_t* const dms = ms->dictMatchState;\n    const ZSTD_compressionParameters* const dictCParams = &dms->cParams ;\n    const U32* const dictHashTable = dms->hashTable;\n    const U32 dictStartIndex       = dms->window.dictLimit;\n    const BYTE* const dictBase     = dms->window.base;\n    const BYTE* const dictStart    = dictBase + dictStartIndex;\n    const BYTE* const dictEnd      = dms->window.nextSrc;\n    const U32 dictIndexDelta       = prefixStartIndex - (U32)(dictEnd - dictBase);\n    const U32 dictAndPrefixLength  = (U32)(istart - prefixStart + dictEnd - dictStart);\n    const U32 dictHBits            = dictCParams->hashLog + ZSTD_SHORT_CACHE_TAG_BITS;\n\n    /* if a dictionary is still attached, it necessarily means that\n     * it is within window size. So we just check it. */\n    const U32 maxDistance = 1U << cParams->windowLog;\n    const U32 endIndex = (U32)((size_t)(istart - base) + srcSize);\n    assert(endIndex - prefixStartIndex <= maxDistance);\n    (void)maxDistance; (void)endIndex;   /* these variables are not used when assert() is disabled */\n\n    (void)hasStep; /* not currently specialized on whether it's accelerated */\n\n    /* ensure there will be no underflow\n     * when translating a dict index into a local index */\n    assert(prefixStartIndex >= (U32)(dictEnd - dictBase));\n\n    if (ms->prefetchCDictTables) {\n        size_t const hashTableBytes = (((size_t)1) << dictCParams->hashLog) * sizeof(U32);\n        PREFETCH_AREA(dictHashTable, hashTableBytes);\n    }\n\n    /* init */\n    DEBUGLOG(5, \"ZSTD_compressBlock_fast_dictMatchState_generic\");\n    ip0 += (dictAndPrefixLength == 0);\n    /* dictMatchState repCode checks don't currently handle repCode == 0\n     * disabling. */\n    assert(offset_1 <= dictAndPrefixLength);\n    assert(offset_2 <= dictAndPrefixLength);\n\n    /* Outer search loop */\n    assert(stepSize >= 1);\n    while (ip1 <= ilimit) {   /* repcode check at (ip0 + 1) is safe because ip0 < ip1 */\n        size_t mLength;\n        size_t hash0 = ZSTD_hashPtr(ip0, hlog, mls);\n\n        size_t const dictHashAndTag0 = ZSTD_hashPtr(ip0, dictHBits, mls);\n        U32 dictMatchIndexAndTag = dictHashTable[dictHashAndTag0 >> ZSTD_SHORT_CACHE_TAG_BITS];\n        int dictTagsMatch = ZSTD_comparePackedTags(dictMatchIndexAndTag, dictHashAndTag0);\n\n        U32 matchIndex = hashTable[hash0];\n        U32 curr = (U32)(ip0 - base);\n        size_t step = stepSize;\n        const size_t kStepIncr = 1 << kSearchStrength;\n        const BYTE* nextStep = ip0 + kStepIncr;\n\n        /* Inner search loop */\n        while (1) {\n            const BYTE* match = base + matchIndex;\n            const U32 repIndex = curr + 1 - offset_1;\n            const BYTE* repMatch = (repIndex < prefixStartIndex) ?\n                                   dictBase + (repIndex - dictIndexDelta) :\n                                   base + repIndex;\n            const size_t hash1 = ZSTD_hashPtr(ip1, hlog, mls);\n            size_t const dictHashAndTag1 = ZSTD_hashPtr(ip1, dictHBits, mls);\n            hashTable[hash0] = curr;   /* update hash table */\n\n            if ((ZSTD_index_overlap_check(prefixStartIndex, repIndex))\n                && (MEM_read32(repMatch) == MEM_read32(ip0 + 1))) {\n                const BYTE* const repMatchEnd = repIndex < prefixStartIndex ? dictEnd : iend;\n                mLength = ZSTD_count_2segments(ip0 + 1 + 4, repMatch + 4, iend, repMatchEnd, prefixStart) + 4;\n                ip0++;\n                ZSTD_storeSeq(seqStore, (size_t) (ip0 - anchor), anchor, iend, REPCODE1_TO_OFFBASE, mLength);\n                break;\n            }\n\n            if (dictTagsMatch) {\n                /* Found a possible dict match */\n                const U32 dictMatchIndex = dictMatchIndexAndTag >> ZSTD_SHORT_CACHE_TAG_BITS;\n                const BYTE* dictMatch = dictBase + dictMatchIndex;\n                if (dictMatchIndex > dictStartIndex &&\n                    MEM_read32(dictMatch) == MEM_read32(ip0)) {\n                    /* To replicate extDict parse behavior, we only use dict matches when the normal matchIndex is invalid */\n                    if (matchIndex <= prefixStartIndex) {\n                        U32 const offset = (U32) (curr - dictMatchIndex - dictIndexDelta);\n                        mLength = ZSTD_count_2segments(ip0 + 4, dictMatch + 4, iend, dictEnd, prefixStart) + 4;\n                        while (((ip0 > anchor) & (dictMatch > dictStart))\n                            && (ip0[-1] == dictMatch[-1])) {\n                            ip0--;\n                            dictMatch--;\n                            mLength++;\n                        } /* catch up */\n                        offset_2 = offset_1;\n                        offset_1 = offset;\n                        ZSTD_storeSeq(seqStore, (size_t) (ip0 - anchor), anchor, iend, OFFSET_TO_OFFBASE(offset), mLength);\n                        break;\n                    }\n                }\n            }\n\n            if (ZSTD_match4Found_cmov(ip0, match, matchIndex, prefixStartIndex)) {\n                /* found a regular match of size >= 4 */\n                U32 const offset = (U32) (ip0 - match);\n                mLength = ZSTD_count(ip0 + 4, match + 4, iend) + 4;\n                while (((ip0 > anchor) & (match > prefixStart))\n                       && (ip0[-1] == match[-1])) {\n                    ip0--;\n                    match--;\n                    mLength++;\n                } /* catch up */\n                offset_2 = offset_1;\n                offset_1 = offset;\n                ZSTD_storeSeq(seqStore, (size_t) (ip0 - anchor), anchor, iend, OFFSET_TO_OFFBASE(offset), mLength);\n                break;\n            }\n\n            /* Prepare for next iteration */\n            dictMatchIndexAndTag = dictHashTable[dictHashAndTag1 >> ZSTD_SHORT_CACHE_TAG_BITS];\n            dictTagsMatch = ZSTD_comparePackedTags(dictMatchIndexAndTag, dictHashAndTag1);\n            matchIndex = hashTable[hash1];\n\n            if (ip1 >= nextStep) {\n                step++;\n                nextStep += kStepIncr;\n            }\n            ip0 = ip1;\n            ip1 = ip1 + step;\n            if (ip1 > ilimit) goto _cleanup;\n\n            curr = (U32)(ip0 - base);\n            hash0 = hash1;\n        }   /* end inner search loop */\n\n        /* match found */\n        assert(mLength);\n        ip0 += mLength;\n        anchor = ip0;\n\n        if (ip0 <= ilimit) {\n            /* Fill Table */\n            assert(base+curr+2 > istart);  /* check base overflow */\n            hashTable[ZSTD_hashPtr(base+curr+2, hlog, mls)] = curr+2;  /* here because curr+2 could be > iend-8 */\n            hashTable[ZSTD_hashPtr(ip0-2, hlog, mls)] = (U32)(ip0-2-base);\n\n            /* check immediate repcode */\n            while (ip0 <= ilimit) {\n                U32 const current2 = (U32)(ip0-base);\n                U32 const repIndex2 = current2 - offset_2;\n                const BYTE* repMatch2 = repIndex2 < prefixStartIndex ?\n                        dictBase - dictIndexDelta + repIndex2 :\n                        base + repIndex2;\n                if ( (ZSTD_index_overlap_check(prefixStartIndex, repIndex2))\n                   && (MEM_read32(repMatch2) == MEM_read32(ip0))) {\n                    const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend;\n                    size_t const repLength2 = ZSTD_count_2segments(ip0+4, repMatch2+4, iend, repEnd2, prefixStart) + 4;\n                    U32 tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset;   /* swap offset_2 <=> offset_1 */\n                    ZSTD_storeSeq(seqStore, 0, anchor, iend, REPCODE1_TO_OFFBASE, repLength2);\n                    hashTable[ZSTD_hashPtr(ip0, hlog, mls)] = current2;\n                    ip0 += repLength2;\n                    anchor = ip0;\n                    continue;\n                }\n                break;\n            }\n        }\n\n        /* Prepare for next iteration */\n        assert(ip0 == anchor);\n        ip1 = ip0 + stepSize;\n    }\n\n_cleanup:\n    /* save reps for next block */\n    rep[0] = offset_1;\n    rep[1] = offset_2;\n\n    /* Return the last literals size */\n    return (size_t)(iend - anchor);\n}\n\n\nZSTD_GEN_FAST_FN(dictMatchState, 4, 0)\nZSTD_GEN_FAST_FN(dictMatchState, 5, 0)\nZSTD_GEN_FAST_FN(dictMatchState, 6, 0)\nZSTD_GEN_FAST_FN(dictMatchState, 7, 0)\n\nsize_t ZSTD_compressBlock_fast_dictMatchState(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    U32 const mls = ms->cParams.minMatch;\n    assert(ms->dictMatchState != NULL);\n    switch(mls)\n    {\n    default: /* includes case 3 */\n    case 4 :\n        return ZSTD_compressBlock_fast_dictMatchState_4_0(ms, seqStore, rep, src, srcSize);\n    case 5 :\n        return ZSTD_compressBlock_fast_dictMatchState_5_0(ms, seqStore, rep, src, srcSize);\n    case 6 :\n        return ZSTD_compressBlock_fast_dictMatchState_6_0(ms, seqStore, rep, src, srcSize);\n    case 7 :\n        return ZSTD_compressBlock_fast_dictMatchState_7_0(ms, seqStore, rep, src, srcSize);\n    }\n}\n\n\nstatic\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_compressBlock_fast_extDict_generic(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize, U32 const mls, U32 const hasStep)\n{\n    const ZSTD_compressionParameters* const cParams = &ms->cParams;\n    U32* const hashTable = ms->hashTable;\n    U32 const hlog = cParams->hashLog;\n    /* support stepSize of 0 */\n    size_t const stepSize = cParams->targetLength + !(cParams->targetLength) + 1;\n    const BYTE* const base = ms->window.base;\n    const BYTE* const dictBase = ms->window.dictBase;\n    const BYTE* const istart = (const BYTE*)src;\n    const BYTE* anchor = istart;\n    const U32   endIndex = (U32)((size_t)(istart - base) + srcSize);\n    const U32   lowLimit = ZSTD_getLowestMatchIndex(ms, endIndex, cParams->windowLog);\n    const U32   dictStartIndex = lowLimit;\n    const BYTE* const dictStart = dictBase + dictStartIndex;\n    const U32   dictLimit = ms->window.dictLimit;\n    const U32   prefixStartIndex = dictLimit < lowLimit ? lowLimit : dictLimit;\n    const BYTE* const prefixStart = base + prefixStartIndex;\n    const BYTE* const dictEnd = dictBase + prefixStartIndex;\n    const BYTE* const iend = istart + srcSize;\n    const BYTE* const ilimit = iend - 8;\n    U32 offset_1=rep[0], offset_2=rep[1];\n    U32 offsetSaved1 = 0, offsetSaved2 = 0;\n\n    const BYTE* ip0 = istart;\n    const BYTE* ip1;\n    const BYTE* ip2;\n    const BYTE* ip3;\n    U32 current0;\n\n\n    size_t hash0; /* hash for ip0 */\n    size_t hash1; /* hash for ip1 */\n    U32 idx; /* match idx for ip0 */\n    const BYTE* idxBase; /* base pointer for idx */\n\n    U32 offcode;\n    const BYTE* match0;\n    size_t mLength;\n    const BYTE* matchEnd = 0; /* initialize to avoid warning, assert != 0 later */\n\n    size_t step;\n    const BYTE* nextStep;\n    const size_t kStepIncr = (1 << (kSearchStrength - 1));\n\n    (void)hasStep; /* not currently specialized on whether it's accelerated */\n\n    DEBUGLOG(5, \"ZSTD_compressBlock_fast_extDict_generic (offset_1=%u)\", offset_1);\n\n    /* switch to \"regular\" variant if extDict is invalidated due to maxDistance */\n    if (prefixStartIndex == dictStartIndex)\n        return ZSTD_compressBlock_fast(ms, seqStore, rep, src, srcSize);\n\n    {   U32 const curr = (U32)(ip0 - base);\n        U32 const maxRep = curr - dictStartIndex;\n        if (offset_2 >= maxRep) offsetSaved2 = offset_2, offset_2 = 0;\n        if (offset_1 >= maxRep) offsetSaved1 = offset_1, offset_1 = 0;\n    }\n\n    /* start each op */\n_start: /* Requires: ip0 */\n\n    step = stepSize;\n    nextStep = ip0 + kStepIncr;\n\n    /* calculate positions, ip0 - anchor == 0, so we skip step calc */\n    ip1 = ip0 + 1;\n    ip2 = ip0 + step;\n    ip3 = ip2 + 1;\n\n    if (ip3 >= ilimit) {\n        goto _cleanup;\n    }\n\n    hash0 = ZSTD_hashPtr(ip0, hlog, mls);\n    hash1 = ZSTD_hashPtr(ip1, hlog, mls);\n\n    idx = hashTable[hash0];\n    idxBase = idx < prefixStartIndex ? dictBase : base;\n\n    do {\n        {   /* load repcode match for ip[2] */\n            U32 const current2 = (U32)(ip2 - base);\n            U32 const repIndex = current2 - offset_1;\n            const BYTE* const repBase = repIndex < prefixStartIndex ? dictBase : base;\n            U32 rval;\n            if ( ((U32)(prefixStartIndex - repIndex) >= 4) /* intentional underflow */\n                 & (offset_1 > 0) ) {\n                rval = MEM_read32(repBase + repIndex);\n            } else {\n                rval = MEM_read32(ip2) ^ 1; /* guaranteed to not match. */\n            }\n\n            /* write back hash table entry */\n            current0 = (U32)(ip0 - base);\n            hashTable[hash0] = current0;\n\n            /* check repcode at ip[2] */\n            if (MEM_read32(ip2) == rval) {\n                ip0 = ip2;\n                match0 = repBase + repIndex;\n                matchEnd = repIndex < prefixStartIndex ? dictEnd : iend;\n                assert((match0 != prefixStart) & (match0 != dictStart));\n                mLength = ip0[-1] == match0[-1];\n                ip0 -= mLength;\n                match0 -= mLength;\n                offcode = REPCODE1_TO_OFFBASE;\n                mLength += 4;\n                goto _match;\n        }   }\n\n        {   /* load match for ip[0] */\n            U32 const mval = idx >= dictStartIndex ?\n                    MEM_read32(idxBase + idx) :\n                    MEM_read32(ip0) ^ 1; /* guaranteed not to match */\n\n            /* check match at ip[0] */\n            if (MEM_read32(ip0) == mval) {\n                /* found a match! */\n                goto _offset;\n        }   }\n\n        /* lookup ip[1] */\n        idx = hashTable[hash1];\n        idxBase = idx < prefixStartIndex ? dictBase : base;\n\n        /* hash ip[2] */\n        hash0 = hash1;\n        hash1 = ZSTD_hashPtr(ip2, hlog, mls);\n\n        /* advance to next positions */\n        ip0 = ip1;\n        ip1 = ip2;\n        ip2 = ip3;\n\n        /* write back hash table entry */\n        current0 = (U32)(ip0 - base);\n        hashTable[hash0] = current0;\n\n        {   /* load match for ip[0] */\n            U32 const mval = idx >= dictStartIndex ?\n                    MEM_read32(idxBase + idx) :\n                    MEM_read32(ip0) ^ 1; /* guaranteed not to match */\n\n            /* check match at ip[0] */\n            if (MEM_read32(ip0) == mval) {\n                /* found a match! */\n                goto _offset;\n        }   }\n\n        /* lookup ip[1] */\n        idx = hashTable[hash1];\n        idxBase = idx < prefixStartIndex ? dictBase : base;\n\n        /* hash ip[2] */\n        hash0 = hash1;\n        hash1 = ZSTD_hashPtr(ip2, hlog, mls);\n\n        /* advance to next positions */\n        ip0 = ip1;\n        ip1 = ip2;\n        ip2 = ip0 + step;\n        ip3 = ip1 + step;\n\n        /* calculate step */\n        if (ip2 >= nextStep) {\n            step++;\n            PREFETCH_L1(ip1 + 64);\n            PREFETCH_L1(ip1 + 128);\n            nextStep += kStepIncr;\n        }\n    } while (ip3 < ilimit);\n\n_cleanup:\n    /* Note that there are probably still a couple positions we could search.\n     * However, it seems to be a meaningful performance hit to try to search\n     * them. So let's not. */\n\n    /* If offset_1 started invalid (offsetSaved1 != 0) and became valid (offset_1 != 0),\n     * rotate saved offsets. See comment in ZSTD_compressBlock_fast_noDict for more context. */\n    offsetSaved2 = ((offsetSaved1 != 0) && (offset_1 != 0)) ? offsetSaved1 : offsetSaved2;\n\n    /* save reps for next block */\n    rep[0] = offset_1 ? offset_1 : offsetSaved1;\n    rep[1] = offset_2 ? offset_2 : offsetSaved2;\n\n    /* Return the last literals size */\n    return (size_t)(iend - anchor);\n\n_offset: /* Requires: ip0, idx, idxBase */\n\n    /* Compute the offset code. */\n    {   U32 const offset = current0 - idx;\n        const BYTE* const lowMatchPtr = idx < prefixStartIndex ? dictStart : prefixStart;\n        matchEnd = idx < prefixStartIndex ? dictEnd : iend;\n        match0 = idxBase + idx;\n        offset_2 = offset_1;\n        offset_1 = offset;\n        offcode = OFFSET_TO_OFFBASE(offset);\n        mLength = 4;\n\n        /* Count the backwards match length. */\n        while (((ip0>anchor) & (match0>lowMatchPtr)) && (ip0[-1] == match0[-1])) {\n            ip0--;\n            match0--;\n            mLength++;\n    }   }\n\n_match: /* Requires: ip0, match0, offcode, matchEnd */\n\n    /* Count the forward length. */\n    assert(matchEnd != 0);\n    mLength += ZSTD_count_2segments(ip0 + mLength, match0 + mLength, iend, matchEnd, prefixStart);\n\n    ZSTD_storeSeq(seqStore, (size_t)(ip0 - anchor), anchor, iend, offcode, mLength);\n\n    ip0 += mLength;\n    anchor = ip0;\n\n    /* write next hash table entry */\n    if (ip1 < ip0) {\n        hashTable[hash1] = (U32)(ip1 - base);\n    }\n\n    /* Fill table and check for immediate repcode. */\n    if (ip0 <= ilimit) {\n        /* Fill Table */\n        assert(base+current0+2 > istart);  /* check base overflow */\n        hashTable[ZSTD_hashPtr(base+current0+2, hlog, mls)] = current0+2;  /* here because current+2 could be > iend-8 */\n        hashTable[ZSTD_hashPtr(ip0-2, hlog, mls)] = (U32)(ip0-2-base);\n\n        while (ip0 <= ilimit) {\n            U32 const repIndex2 = (U32)(ip0-base) - offset_2;\n            const BYTE* const repMatch2 = repIndex2 < prefixStartIndex ? dictBase + repIndex2 : base + repIndex2;\n            if ( ((ZSTD_index_overlap_check(prefixStartIndex, repIndex2)) & (offset_2 > 0))\n                 && (MEM_read32(repMatch2) == MEM_read32(ip0)) ) {\n                const BYTE* const repEnd2 = repIndex2 < prefixStartIndex ? dictEnd : iend;\n                size_t const repLength2 = ZSTD_count_2segments(ip0+4, repMatch2+4, iend, repEnd2, prefixStart) + 4;\n                { U32 const tmpOffset = offset_2; offset_2 = offset_1; offset_1 = tmpOffset; }  /* swap offset_2 <=> offset_1 */\n                ZSTD_storeSeq(seqStore, 0 /*litlen*/, anchor, iend, REPCODE1_TO_OFFBASE, repLength2);\n                hashTable[ZSTD_hashPtr(ip0, hlog, mls)] = (U32)(ip0-base);\n                ip0 += repLength2;\n                anchor = ip0;\n                continue;\n            }\n            break;\n    }   }\n\n    goto _start;\n}\n\nZSTD_GEN_FAST_FN(extDict, 4, 0)\nZSTD_GEN_FAST_FN(extDict, 5, 0)\nZSTD_GEN_FAST_FN(extDict, 6, 0)\nZSTD_GEN_FAST_FN(extDict, 7, 0)\n\nsize_t ZSTD_compressBlock_fast_extDict(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    U32 const mls = ms->cParams.minMatch;\n    assert(ms->dictMatchState == NULL);\n    switch(mls)\n    {\n    default: /* includes case 3 */\n    case 4 :\n        return ZSTD_compressBlock_fast_extDict_4_0(ms, seqStore, rep, src, srcSize);\n    case 5 :\n        return ZSTD_compressBlock_fast_extDict_5_0(ms, seqStore, rep, src, srcSize);\n    case 6 :\n        return ZSTD_compressBlock_fast_extDict_6_0(ms, seqStore, rep, src, srcSize);\n    case 7 :\n        return ZSTD_compressBlock_fast_extDict_7_0(ms, seqStore, rep, src, srcSize);\n    }\n}\n"
  },
  {
    "path": "lib/compress/zstd_fast.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_FAST_H\n#define ZSTD_FAST_H\n\n#include \"../common/mem.h\"      /* U32 */\n#include \"zstd_compress_internal.h\"\n\nvoid ZSTD_fillHashTable(ZSTD_MatchState_t* ms,\n                        void const* end, ZSTD_dictTableLoadMethod_e dtlm,\n                        ZSTD_tableFillPurpose_e tfp);\nsize_t ZSTD_compressBlock_fast(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_fast_dictMatchState(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_fast_extDict(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\n\n#endif /* ZSTD_FAST_H */\n"
  },
  {
    "path": "lib/compress/zstd_lazy.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#include \"zstd_compress_internal.h\"\n#include \"zstd_lazy.h\"\n#include \"../common/bits.h\" /* ZSTD_countTrailingZeros64 */\n\n#if !defined(ZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR) \\\n || !defined(ZSTD_EXCLUDE_LAZY_BLOCK_COMPRESSOR) \\\n || !defined(ZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR) \\\n || !defined(ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR)\n\n#define kLazySkippingStep 8\n\n\n/*-*************************************\n*  Binary Tree search\n***************************************/\n\nstatic\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nvoid ZSTD_updateDUBT(ZSTD_MatchState_t* ms,\n                const BYTE* ip, const BYTE* iend,\n                U32 mls)\n{\n    const ZSTD_compressionParameters* const cParams = &ms->cParams;\n    U32* const hashTable = ms->hashTable;\n    U32  const hashLog = cParams->hashLog;\n\n    U32* const bt = ms->chainTable;\n    U32  const btLog  = cParams->chainLog - 1;\n    U32  const btMask = (1 << btLog) - 1;\n\n    const BYTE* const base = ms->window.base;\n    U32 const target = (U32)(ip - base);\n    U32 idx = ms->nextToUpdate;\n\n    if (idx != target)\n        DEBUGLOG(7, \"ZSTD_updateDUBT, from %u to %u (dictLimit:%u)\",\n                    idx, target, ms->window.dictLimit);\n    assert(ip + 8 <= iend);   /* condition for ZSTD_hashPtr */\n    (void)iend;\n\n    assert(idx >= ms->window.dictLimit);   /* condition for valid base+idx */\n    for ( ; idx < target ; idx++) {\n        size_t const h  = ZSTD_hashPtr(base + idx, hashLog, mls);   /* assumption : ip + 8 <= iend */\n        U32    const matchIndex = hashTable[h];\n\n        U32*   const nextCandidatePtr = bt + 2*(idx&btMask);\n        U32*   const sortMarkPtr  = nextCandidatePtr + 1;\n\n        DEBUGLOG(8, \"ZSTD_updateDUBT: insert %u\", idx);\n        hashTable[h] = idx;   /* Update Hash Table */\n        *nextCandidatePtr = matchIndex;   /* update BT like a chain */\n        *sortMarkPtr = ZSTD_DUBT_UNSORTED_MARK;\n    }\n    ms->nextToUpdate = target;\n}\n\n\n/** ZSTD_insertDUBT1() :\n *  sort one already inserted but unsorted position\n *  assumption : curr >= btlow == (curr - btmask)\n *  doesn't fail */\nstatic\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nvoid ZSTD_insertDUBT1(const ZSTD_MatchState_t* ms,\n                 U32 curr, const BYTE* inputEnd,\n                 U32 nbCompares, U32 btLow,\n                 const ZSTD_dictMode_e dictMode)\n{\n    const ZSTD_compressionParameters* const cParams = &ms->cParams;\n    U32* const bt = ms->chainTable;\n    U32  const btLog  = cParams->chainLog - 1;\n    U32  const btMask = (1 << btLog) - 1;\n    size_t commonLengthSmaller=0, commonLengthLarger=0;\n    const BYTE* const base = ms->window.base;\n    const BYTE* const dictBase = ms->window.dictBase;\n    const U32 dictLimit = ms->window.dictLimit;\n    const BYTE* const ip = (curr>=dictLimit) ? base + curr : dictBase + curr;\n    const BYTE* const iend = (curr>=dictLimit) ? inputEnd : dictBase + dictLimit;\n    const BYTE* const dictEnd = dictBase + dictLimit;\n    const BYTE* const prefixStart = base + dictLimit;\n    const BYTE* match;\n    U32* smallerPtr = bt + 2*(curr&btMask);\n    U32* largerPtr  = smallerPtr + 1;\n    U32 matchIndex = *smallerPtr;   /* this candidate is unsorted : next sorted candidate is reached through *smallerPtr, while *largerPtr contains previous unsorted candidate (which is already saved and can be overwritten) */\n    U32 dummy32;   /* to be nullified at the end */\n    U32 const windowValid = ms->window.lowLimit;\n    U32 const maxDistance = 1U << cParams->windowLog;\n    U32 const windowLow = (curr - windowValid > maxDistance) ? curr - maxDistance : windowValid;\n\n\n    DEBUGLOG(8, \"ZSTD_insertDUBT1(%u) (dictLimit=%u, lowLimit=%u)\",\n                curr, dictLimit, windowLow);\n    assert(curr >= btLow);\n    assert(ip < iend);   /* condition for ZSTD_count */\n\n    for (; nbCompares && (matchIndex > windowLow); --nbCompares) {\n        U32* const nextPtr = bt + 2*(matchIndex & btMask);\n        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */\n        assert(matchIndex < curr);\n        /* note : all candidates are now supposed sorted,\n         * but it's still possible to have nextPtr[1] == ZSTD_DUBT_UNSORTED_MARK\n         * when a real index has the same value as ZSTD_DUBT_UNSORTED_MARK */\n\n        if ( (dictMode != ZSTD_extDict)\n          || (matchIndex+matchLength >= dictLimit)  /* both in current segment*/\n          || (curr < dictLimit) /* both in extDict */) {\n            const BYTE* const mBase = ( (dictMode != ZSTD_extDict)\n                                     || (matchIndex+matchLength >= dictLimit)) ?\n                                        base : dictBase;\n            assert( (matchIndex+matchLength >= dictLimit)   /* might be wrong if extDict is incorrectly set to 0 */\n                 || (curr < dictLimit) );\n            match = mBase + matchIndex;\n            matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);\n        } else {\n            match = dictBase + matchIndex;\n            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);\n            if (matchIndex+matchLength >= dictLimit)\n                match = base + matchIndex;   /* preparation for next read of match[matchLength] */\n        }\n\n        DEBUGLOG(8, \"ZSTD_insertDUBT1: comparing %u with %u : found %u common bytes \",\n                    curr, matchIndex, (U32)matchLength);\n\n        if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */\n            break;   /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */\n        }\n\n        if (match[matchLength] < ip[matchLength]) {  /* necessarily within buffer */\n            /* match is smaller than current */\n            *smallerPtr = matchIndex;             /* update smaller idx */\n            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */\n            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop searching */\n            DEBUGLOG(8, \"ZSTD_insertDUBT1: %u (>btLow=%u) is smaller : next => %u\",\n                        matchIndex, btLow, nextPtr[1]);\n            smallerPtr = nextPtr+1;               /* new \"candidate\" => larger than match, which was smaller than target */\n            matchIndex = nextPtr[1];              /* new matchIndex, larger than previous and closer to current */\n        } else {\n            /* match is larger than current */\n            *largerPtr = matchIndex;\n            commonLengthLarger = matchLength;\n            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop searching */\n            DEBUGLOG(8, \"ZSTD_insertDUBT1: %u (>btLow=%u) is larger => %u\",\n                        matchIndex, btLow, nextPtr[0]);\n            largerPtr = nextPtr;\n            matchIndex = nextPtr[0];\n    }   }\n\n    *smallerPtr = *largerPtr = 0;\n}\n\n\nstatic\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_DUBT_findBetterDictMatch (\n        const ZSTD_MatchState_t* ms,\n        const BYTE* const ip, const BYTE* const iend,\n        size_t* offsetPtr,\n        size_t bestLength,\n        U32 nbCompares,\n        U32 const mls,\n        const ZSTD_dictMode_e dictMode)\n{\n    const ZSTD_MatchState_t * const dms = ms->dictMatchState;\n    const ZSTD_compressionParameters* const dmsCParams = &dms->cParams;\n    const U32 * const dictHashTable = dms->hashTable;\n    U32         const hashLog = dmsCParams->hashLog;\n    size_t      const h  = ZSTD_hashPtr(ip, hashLog, mls);\n    U32               dictMatchIndex = dictHashTable[h];\n\n    const BYTE* const base = ms->window.base;\n    const BYTE* const prefixStart = base + ms->window.dictLimit;\n    U32         const curr = (U32)(ip-base);\n    const BYTE* const dictBase = dms->window.base;\n    const BYTE* const dictEnd = dms->window.nextSrc;\n    U32         const dictHighLimit = (U32)(dms->window.nextSrc - dms->window.base);\n    U32         const dictLowLimit = dms->window.lowLimit;\n    U32         const dictIndexDelta = ms->window.lowLimit - dictHighLimit;\n\n    U32*        const dictBt = dms->chainTable;\n    U32         const btLog  = dmsCParams->chainLog - 1;\n    U32         const btMask = (1 << btLog) - 1;\n    U32         const btLow = (btMask >= dictHighLimit - dictLowLimit) ? dictLowLimit : dictHighLimit - btMask;\n\n    size_t commonLengthSmaller=0, commonLengthLarger=0;\n\n    (void)dictMode;\n    assert(dictMode == ZSTD_dictMatchState);\n\n    for (; nbCompares && (dictMatchIndex > dictLowLimit); --nbCompares) {\n        U32* const nextPtr = dictBt + 2*(dictMatchIndex & btMask);\n        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */\n        const BYTE* match = dictBase + dictMatchIndex;\n        matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);\n        if (dictMatchIndex+matchLength >= dictHighLimit)\n            match = base + dictMatchIndex + dictIndexDelta;   /* to prepare for next usage of match[matchLength] */\n\n        if (matchLength > bestLength) {\n            U32 matchIndex = dictMatchIndex + dictIndexDelta;\n            if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(curr-matchIndex+1) - ZSTD_highbit32((U32)offsetPtr[0]+1)) ) {\n                DEBUGLOG(9, \"ZSTD_DUBT_findBetterDictMatch(%u) : found better match length %u -> %u and offsetCode %u -> %u (dictMatchIndex %u, matchIndex %u)\",\n                    curr, (U32)bestLength, (U32)matchLength, (U32)*offsetPtr, OFFSET_TO_OFFBASE(curr - matchIndex), dictMatchIndex, matchIndex);\n                bestLength = matchLength, *offsetPtr = OFFSET_TO_OFFBASE(curr - matchIndex);\n            }\n            if (ip+matchLength == iend) {   /* reached end of input : ip[matchLength] is not valid, no way to know if it's larger or smaller than match */\n                break;   /* drop, to guarantee consistency (miss a little bit of compression) */\n            }\n        }\n\n        if (match[matchLength] < ip[matchLength]) {\n            if (dictMatchIndex <= btLow) { break; }   /* beyond tree size, stop the search */\n            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */\n            dictMatchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */\n        } else {\n            /* match is larger than current */\n            if (dictMatchIndex <= btLow) { break; }   /* beyond tree size, stop the search */\n            commonLengthLarger = matchLength;\n            dictMatchIndex = nextPtr[0];\n        }\n    }\n\n    if (bestLength >= MINMATCH) {\n        U32 const mIndex = curr - (U32)OFFBASE_TO_OFFSET(*offsetPtr); (void)mIndex;\n        DEBUGLOG(8, \"ZSTD_DUBT_findBetterDictMatch(%u) : found match of length %u and offsetCode %u (pos %u)\",\n                    curr, (U32)bestLength, (U32)*offsetPtr, mIndex);\n    }\n    return bestLength;\n\n}\n\n\nstatic\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_DUBT_findBestMatch(ZSTD_MatchState_t* ms,\n                        const BYTE* const ip, const BYTE* const iend,\n                        size_t* offBasePtr,\n                        U32 const mls,\n                        const ZSTD_dictMode_e dictMode)\n{\n    const ZSTD_compressionParameters* const cParams = &ms->cParams;\n    U32*   const hashTable = ms->hashTable;\n    U32    const hashLog = cParams->hashLog;\n    size_t const h  = ZSTD_hashPtr(ip, hashLog, mls);\n    U32          matchIndex  = hashTable[h];\n\n    const BYTE* const base = ms->window.base;\n    U32    const curr = (U32)(ip-base);\n    U32    const windowLow = ZSTD_getLowestMatchIndex(ms, curr, cParams->windowLog);\n\n    U32*   const bt = ms->chainTable;\n    U32    const btLog  = cParams->chainLog - 1;\n    U32    const btMask = (1 << btLog) - 1;\n    U32    const btLow = (btMask >= curr) ? 0 : curr - btMask;\n    U32    const unsortLimit = MAX(btLow, windowLow);\n\n    U32*         nextCandidate = bt + 2*(matchIndex&btMask);\n    U32*         unsortedMark = bt + 2*(matchIndex&btMask) + 1;\n    U32          nbCompares = 1U << cParams->searchLog;\n    U32          nbCandidates = nbCompares;\n    U32          previousCandidate = 0;\n\n    DEBUGLOG(7, \"ZSTD_DUBT_findBestMatch (%u) \", curr);\n    assert(ip <= iend-8);   /* required for h calculation */\n    assert(dictMode != ZSTD_dedicatedDictSearch);\n\n    /* reach end of unsorted candidates list */\n    while ( (matchIndex > unsortLimit)\n         && (*unsortedMark == ZSTD_DUBT_UNSORTED_MARK)\n         && (nbCandidates > 1) ) {\n        DEBUGLOG(8, \"ZSTD_DUBT_findBestMatch: candidate %u is unsorted\",\n                    matchIndex);\n        *unsortedMark = previousCandidate;  /* the unsortedMark becomes a reversed chain, to move up back to original position */\n        previousCandidate = matchIndex;\n        matchIndex = *nextCandidate;\n        nextCandidate = bt + 2*(matchIndex&btMask);\n        unsortedMark = bt + 2*(matchIndex&btMask) + 1;\n        nbCandidates --;\n    }\n\n    /* nullify last candidate if it's still unsorted\n     * simplification, detrimental to compression ratio, beneficial for speed */\n    if ( (matchIndex > unsortLimit)\n      && (*unsortedMark==ZSTD_DUBT_UNSORTED_MARK) ) {\n        DEBUGLOG(7, \"ZSTD_DUBT_findBestMatch: nullify last unsorted candidate %u\",\n                    matchIndex);\n        *nextCandidate = *unsortedMark = 0;\n    }\n\n    /* batch sort stacked candidates */\n    matchIndex = previousCandidate;\n    while (matchIndex) {  /* will end on matchIndex == 0 */\n        U32* const nextCandidateIdxPtr = bt + 2*(matchIndex&btMask) + 1;\n        U32 const nextCandidateIdx = *nextCandidateIdxPtr;\n        ZSTD_insertDUBT1(ms, matchIndex, iend,\n                         nbCandidates, unsortLimit, dictMode);\n        matchIndex = nextCandidateIdx;\n        nbCandidates++;\n    }\n\n    /* find longest match */\n    {   size_t commonLengthSmaller = 0, commonLengthLarger = 0;\n        const BYTE* const dictBase = ms->window.dictBase;\n        const U32 dictLimit = ms->window.dictLimit;\n        const BYTE* const dictEnd = dictBase + dictLimit;\n        const BYTE* const prefixStart = base + dictLimit;\n        U32* smallerPtr = bt + 2*(curr&btMask);\n        U32* largerPtr  = bt + 2*(curr&btMask) + 1;\n        U32 matchEndIdx = curr + 8 + 1;\n        U32 dummy32;   /* to be nullified at the end */\n        size_t bestLength = 0;\n\n        matchIndex  = hashTable[h];\n        hashTable[h] = curr;   /* Update Hash Table */\n\n        for (; nbCompares && (matchIndex > windowLow); --nbCompares) {\n            U32* const nextPtr = bt + 2*(matchIndex & btMask);\n            size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */\n            const BYTE* match;\n\n            if ((dictMode != ZSTD_extDict) || (matchIndex+matchLength >= dictLimit)) {\n                match = base + matchIndex;\n                matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);\n            } else {\n                match = dictBase + matchIndex;\n                matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);\n                if (matchIndex+matchLength >= dictLimit)\n                    match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */\n            }\n\n            if (matchLength > bestLength) {\n                if (matchLength > matchEndIdx - matchIndex)\n                    matchEndIdx = matchIndex + (U32)matchLength;\n                if ( (4*(int)(matchLength-bestLength)) > (int)(ZSTD_highbit32(curr - matchIndex + 1) - ZSTD_highbit32((U32)*offBasePtr)) )\n                    bestLength = matchLength, *offBasePtr = OFFSET_TO_OFFBASE(curr - matchIndex);\n                if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */\n                    if (dictMode == ZSTD_dictMatchState) {\n                        nbCompares = 0; /* in addition to avoiding checking any\n                                         * further in this loop, make sure we\n                                         * skip checking in the dictionary. */\n                    }\n                    break;   /* drop, to guarantee consistency (miss a little bit of compression) */\n                }\n            }\n\n            if (match[matchLength] < ip[matchLength]) {\n                /* match is smaller than current */\n                *smallerPtr = matchIndex;             /* update smaller idx */\n                commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */\n                if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */\n                smallerPtr = nextPtr+1;               /* new \"smaller\" => larger of match */\n                matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */\n            } else {\n                /* match is larger than current */\n                *largerPtr = matchIndex;\n                commonLengthLarger = matchLength;\n                if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */\n                largerPtr = nextPtr;\n                matchIndex = nextPtr[0];\n        }   }\n\n        *smallerPtr = *largerPtr = 0;\n\n        assert(nbCompares <= (1U << ZSTD_SEARCHLOG_MAX)); /* Check we haven't underflowed. */\n        if (dictMode == ZSTD_dictMatchState && nbCompares) {\n            bestLength = ZSTD_DUBT_findBetterDictMatch(\n                    ms, ip, iend,\n                    offBasePtr, bestLength, nbCompares,\n                    mls, dictMode);\n        }\n\n        assert(matchEndIdx > curr+8); /* ensure nextToUpdate is increased */\n        ms->nextToUpdate = matchEndIdx - 8;   /* skip repetitive patterns */\n        if (bestLength >= MINMATCH) {\n            U32 const mIndex = curr - (U32)OFFBASE_TO_OFFSET(*offBasePtr); (void)mIndex;\n            DEBUGLOG(8, \"ZSTD_DUBT_findBestMatch(%u) : found match of length %u and offsetCode %u (pos %u)\",\n                        curr, (U32)bestLength, (U32)*offBasePtr, mIndex);\n        }\n        return bestLength;\n    }\n}\n\n\n/** ZSTD_BtFindBestMatch() : Tree updater, providing best match */\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_BtFindBestMatch( ZSTD_MatchState_t* ms,\n                const BYTE* const ip, const BYTE* const iLimit,\n                      size_t* offBasePtr,\n                const U32 mls /* template */,\n                const ZSTD_dictMode_e dictMode)\n{\n    DEBUGLOG(7, \"ZSTD_BtFindBestMatch\");\n    if (ip < ms->window.base + ms->nextToUpdate) return 0;   /* skipped area */\n    ZSTD_updateDUBT(ms, ip, iLimit, mls);\n    return ZSTD_DUBT_findBestMatch(ms, ip, iLimit, offBasePtr, mls, dictMode);\n}\n\n/***********************************\n* Dedicated dict search\n***********************************/\n\nvoid ZSTD_dedicatedDictSearch_lazy_loadDictionary(ZSTD_MatchState_t* ms, const BYTE* const ip)\n{\n    const BYTE* const base = ms->window.base;\n    U32 const target = (U32)(ip - base);\n    U32* const hashTable = ms->hashTable;\n    U32* const chainTable = ms->chainTable;\n    U32 const chainSize = 1 << ms->cParams.chainLog;\n    U32 idx = ms->nextToUpdate;\n    U32 const minChain = chainSize < target - idx ? target - chainSize : idx;\n    U32 const bucketSize = 1 << ZSTD_LAZY_DDSS_BUCKET_LOG;\n    U32 const cacheSize = bucketSize - 1;\n    U32 const chainAttempts = (1 << ms->cParams.searchLog) - cacheSize;\n    U32 const chainLimit = chainAttempts > 255 ? 255 : chainAttempts;\n\n    /* We know the hashtable is oversized by a factor of `bucketSize`.\n     * We are going to temporarily pretend `bucketSize == 1`, keeping only a\n     * single entry. We will use the rest of the space to construct a temporary\n     * chaintable.\n     */\n    U32 const hashLog = ms->cParams.hashLog - ZSTD_LAZY_DDSS_BUCKET_LOG;\n    U32* const tmpHashTable = hashTable;\n    U32* const tmpChainTable = hashTable + ((size_t)1 << hashLog);\n    U32 const tmpChainSize = (U32)((1 << ZSTD_LAZY_DDSS_BUCKET_LOG) - 1) << hashLog;\n    U32 const tmpMinChain = tmpChainSize < target ? target - tmpChainSize : idx;\n    U32 hashIdx;\n\n    assert(ms->cParams.chainLog <= 24);\n    assert(ms->cParams.hashLog > ms->cParams.chainLog);\n    assert(idx != 0);\n    assert(tmpMinChain <= minChain);\n\n    /* fill conventional hash table and conventional chain table */\n    for ( ; idx < target; idx++) {\n        U32 const h = (U32)ZSTD_hashPtr(base + idx, hashLog, ms->cParams.minMatch);\n        if (idx >= tmpMinChain) {\n            tmpChainTable[idx - tmpMinChain] = hashTable[h];\n        }\n        tmpHashTable[h] = idx;\n    }\n\n    /* sort chains into ddss chain table */\n    {\n        U32 chainPos = 0;\n        for (hashIdx = 0; hashIdx < (1U << hashLog); hashIdx++) {\n            U32 count;\n            U32 countBeyondMinChain = 0;\n            U32 i = tmpHashTable[hashIdx];\n            for (count = 0; i >= tmpMinChain && count < cacheSize; count++) {\n                /* skip through the chain to the first position that won't be\n                 * in the hash cache bucket */\n                if (i < minChain) {\n                    countBeyondMinChain++;\n                }\n                i = tmpChainTable[i - tmpMinChain];\n            }\n            if (count == cacheSize) {\n                for (count = 0; count < chainLimit;) {\n                    if (i < minChain) {\n                        if (!i || ++countBeyondMinChain > cacheSize) {\n                            /* only allow pulling `cacheSize` number of entries\n                             * into the cache or chainTable beyond `minChain`,\n                             * to replace the entries pulled out of the\n                             * chainTable into the cache. This lets us reach\n                             * back further without increasing the total number\n                             * of entries in the chainTable, guaranteeing the\n                             * DDSS chain table will fit into the space\n                             * allocated for the regular one. */\n                            break;\n                        }\n                    }\n                    chainTable[chainPos++] = i;\n                    count++;\n                    if (i < tmpMinChain) {\n                        break;\n                    }\n                    i = tmpChainTable[i - tmpMinChain];\n                }\n            } else {\n                count = 0;\n            }\n            if (count) {\n                tmpHashTable[hashIdx] = ((chainPos - count) << 8) + count;\n            } else {\n                tmpHashTable[hashIdx] = 0;\n            }\n        }\n        assert(chainPos <= chainSize); /* I believe this is guaranteed... */\n    }\n\n    /* move chain pointers into the last entry of each hash bucket */\n    for (hashIdx = (1 << hashLog); hashIdx; ) {\n        U32 const bucketIdx = --hashIdx << ZSTD_LAZY_DDSS_BUCKET_LOG;\n        U32 const chainPackedPointer = tmpHashTable[hashIdx];\n        U32 i;\n        for (i = 0; i < cacheSize; i++) {\n            hashTable[bucketIdx + i] = 0;\n        }\n        hashTable[bucketIdx + bucketSize - 1] = chainPackedPointer;\n    }\n\n    /* fill the buckets of the hash table */\n    for (idx = ms->nextToUpdate; idx < target; idx++) {\n        U32 const h = (U32)ZSTD_hashPtr(base + idx, hashLog, ms->cParams.minMatch)\n                   << ZSTD_LAZY_DDSS_BUCKET_LOG;\n        U32 i;\n        /* Shift hash cache down 1. */\n        for (i = cacheSize - 1; i; i--)\n            hashTable[h + i] = hashTable[h + i - 1];\n        hashTable[h] = idx;\n    }\n\n    ms->nextToUpdate = target;\n}\n\n/* Returns the longest match length found in the dedicated dict search structure.\n * If none are longer than the argument ml, then ml will be returned.\n */\nFORCE_INLINE_TEMPLATE\nsize_t ZSTD_dedicatedDictSearch_lazy_search(size_t* offsetPtr, size_t ml, U32 nbAttempts,\n                                            const ZSTD_MatchState_t* const dms,\n                                            const BYTE* const ip, const BYTE* const iLimit,\n                                            const BYTE* const prefixStart, const U32 curr,\n                                            const U32 dictLimit, const size_t ddsIdx) {\n    const U32 ddsLowestIndex  = dms->window.dictLimit;\n    const BYTE* const ddsBase = dms->window.base;\n    const BYTE* const ddsEnd  = dms->window.nextSrc;\n    const U32 ddsSize         = (U32)(ddsEnd - ddsBase);\n    const U32 ddsIndexDelta   = dictLimit - ddsSize;\n    const U32 bucketSize      = (1 << ZSTD_LAZY_DDSS_BUCKET_LOG);\n    const U32 bucketLimit     = nbAttempts < bucketSize - 1 ? nbAttempts : bucketSize - 1;\n    U32 ddsAttempt;\n    U32 matchIndex;\n\n    for (ddsAttempt = 0; ddsAttempt < bucketSize - 1; ddsAttempt++) {\n        PREFETCH_L1(ddsBase + dms->hashTable[ddsIdx + ddsAttempt]);\n    }\n\n    {\n        U32 const chainPackedPointer = dms->hashTable[ddsIdx + bucketSize - 1];\n        U32 const chainIndex = chainPackedPointer >> 8;\n\n        PREFETCH_L1(&dms->chainTable[chainIndex]);\n    }\n\n    for (ddsAttempt = 0; ddsAttempt < bucketLimit; ddsAttempt++) {\n        size_t currentMl=0;\n        const BYTE* match;\n        matchIndex = dms->hashTable[ddsIdx + ddsAttempt];\n        match = ddsBase + matchIndex;\n\n        if (!matchIndex) {\n            return ml;\n        }\n\n        /* guaranteed by table construction */\n        (void)ddsLowestIndex;\n        assert(matchIndex >= ddsLowestIndex);\n        assert(match+4 <= ddsEnd);\n        if (MEM_read32(match) == MEM_read32(ip)) {\n            /* assumption : matchIndex <= dictLimit-4 (by table construction) */\n            currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, ddsEnd, prefixStart) + 4;\n        }\n\n        /* save best solution */\n        if (currentMl > ml) {\n            ml = currentMl;\n            *offsetPtr = OFFSET_TO_OFFBASE(curr - (matchIndex + ddsIndexDelta));\n            if (ip+currentMl == iLimit) {\n                /* best possible, avoids read overflow on next attempt */\n                return ml;\n            }\n        }\n    }\n\n    {\n        U32 const chainPackedPointer = dms->hashTable[ddsIdx + bucketSize - 1];\n        U32 chainIndex = chainPackedPointer >> 8;\n        U32 const chainLength = chainPackedPointer & 0xFF;\n        U32 const chainAttempts = nbAttempts - ddsAttempt;\n        U32 const chainLimit = chainAttempts > chainLength ? chainLength : chainAttempts;\n        U32 chainAttempt;\n\n        for (chainAttempt = 0 ; chainAttempt < chainLimit; chainAttempt++) {\n            PREFETCH_L1(ddsBase + dms->chainTable[chainIndex + chainAttempt]);\n        }\n\n        for (chainAttempt = 0 ; chainAttempt < chainLimit; chainAttempt++, chainIndex++) {\n            size_t currentMl=0;\n            const BYTE* match;\n            matchIndex = dms->chainTable[chainIndex];\n            match = ddsBase + matchIndex;\n\n            /* guaranteed by table construction */\n            assert(matchIndex >= ddsLowestIndex);\n            assert(match+4 <= ddsEnd);\n            if (MEM_read32(match) == MEM_read32(ip)) {\n                /* assumption : matchIndex <= dictLimit-4 (by table construction) */\n                currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, ddsEnd, prefixStart) + 4;\n            }\n\n            /* save best solution */\n            if (currentMl > ml) {\n                ml = currentMl;\n                *offsetPtr = OFFSET_TO_OFFBASE(curr - (matchIndex + ddsIndexDelta));\n                if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */\n            }\n        }\n    }\n    return ml;\n}\n\n\n/* *********************************\n*  Hash Chain\n***********************************/\n#define NEXT_IN_CHAIN(d, mask)   chainTable[(d) & (mask)]\n\n/* Update chains up to ip (excluded)\n   Assumption : always within prefix (i.e. not within extDict) */\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nU32 ZSTD_insertAndFindFirstIndex_internal(\n                        ZSTD_MatchState_t* ms,\n                        const ZSTD_compressionParameters* const cParams,\n                        const BYTE* ip, U32 const mls, U32 const lazySkipping)\n{\n    U32* const hashTable  = ms->hashTable;\n    const U32 hashLog = cParams->hashLog;\n    U32* const chainTable = ms->chainTable;\n    const U32 chainMask = (1 << cParams->chainLog) - 1;\n    const BYTE* const base = ms->window.base;\n    const U32 target = (U32)(ip - base);\n    U32 idx = ms->nextToUpdate;\n\n    while(idx < target) { /* catch up */\n        size_t const h = ZSTD_hashPtr(base+idx, hashLog, mls);\n        NEXT_IN_CHAIN(idx, chainMask) = hashTable[h];\n        hashTable[h] = idx;\n        idx++;\n        /* Stop inserting every position when in the lazy skipping mode. */\n        if (lazySkipping)\n            break;\n    }\n\n    ms->nextToUpdate = target;\n    return hashTable[ZSTD_hashPtr(ip, hashLog, mls)];\n}\n\nU32 ZSTD_insertAndFindFirstIndex(ZSTD_MatchState_t* ms, const BYTE* ip) {\n    const ZSTD_compressionParameters* const cParams = &ms->cParams;\n    return ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, ms->cParams.minMatch, /* lazySkipping*/ 0);\n}\n\n/* inlining is important to hardwire a hot branch (template emulation) */\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_HcFindBestMatch(\n                        ZSTD_MatchState_t* ms,\n                        const BYTE* const ip, const BYTE* const iLimit,\n                        size_t* offsetPtr,\n                        const U32 mls, const ZSTD_dictMode_e dictMode)\n{\n    const ZSTD_compressionParameters* const cParams = &ms->cParams;\n    U32* const chainTable = ms->chainTable;\n    const U32 chainSize = (1 << cParams->chainLog);\n    const U32 chainMask = chainSize-1;\n    const BYTE* const base = ms->window.base;\n    const BYTE* const dictBase = ms->window.dictBase;\n    const U32 dictLimit = ms->window.dictLimit;\n    const BYTE* const prefixStart = base + dictLimit;\n    const BYTE* const dictEnd = dictBase + dictLimit;\n    const U32 curr = (U32)(ip-base);\n    const U32 maxDistance = 1U << cParams->windowLog;\n    const U32 lowestValid = ms->window.lowLimit;\n    const U32 withinMaxDistance = (curr - lowestValid > maxDistance) ? curr - maxDistance : lowestValid;\n    const U32 isDictionary = (ms->loadedDictEnd != 0);\n    const U32 lowLimit = isDictionary ? lowestValid : withinMaxDistance;\n    const U32 minChain = curr > chainSize ? curr - chainSize : 0;\n    U32 nbAttempts = 1U << cParams->searchLog;\n    size_t ml=4-1;\n\n    const ZSTD_MatchState_t* const dms = ms->dictMatchState;\n    const U32 ddsHashLog = dictMode == ZSTD_dedicatedDictSearch\n                         ? dms->cParams.hashLog - ZSTD_LAZY_DDSS_BUCKET_LOG : 0;\n    const size_t ddsIdx = dictMode == ZSTD_dedicatedDictSearch\n                        ? ZSTD_hashPtr(ip, ddsHashLog, mls) << ZSTD_LAZY_DDSS_BUCKET_LOG : 0;\n\n    U32 matchIndex;\n\n    if (dictMode == ZSTD_dedicatedDictSearch) {\n        const U32* entry = &dms->hashTable[ddsIdx];\n        PREFETCH_L1(entry);\n    }\n\n    /* HC4 match finder */\n    matchIndex = ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, mls, ms->lazySkipping);\n\n    for ( ; (matchIndex>=lowLimit) & (nbAttempts>0) ; nbAttempts--) {\n        size_t currentMl=0;\n        if ((dictMode != ZSTD_extDict) || matchIndex >= dictLimit) {\n            const BYTE* const match = base + matchIndex;\n            assert(matchIndex >= dictLimit);   /* ensures this is true if dictMode != ZSTD_extDict */\n            /* read 4B starting from (match + ml + 1 - sizeof(U32)) */\n            if (MEM_read32(match + ml - 3) == MEM_read32(ip + ml - 3))   /* potentially better */\n                currentMl = ZSTD_count(ip, match, iLimit);\n        } else {\n            const BYTE* const match = dictBase + matchIndex;\n            assert(match+4 <= dictEnd);\n            if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */\n                currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dictEnd, prefixStart) + 4;\n        }\n\n        /* save best solution */\n        if (currentMl > ml) {\n            ml = currentMl;\n            *offsetPtr = OFFSET_TO_OFFBASE(curr - matchIndex);\n            if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */\n        }\n\n        if (matchIndex <= minChain) break;\n        matchIndex = NEXT_IN_CHAIN(matchIndex, chainMask);\n    }\n\n    assert(nbAttempts <= (1U << ZSTD_SEARCHLOG_MAX)); /* Check we haven't underflowed. */\n    if (dictMode == ZSTD_dedicatedDictSearch) {\n        ml = ZSTD_dedicatedDictSearch_lazy_search(offsetPtr, ml, nbAttempts, dms,\n                                                  ip, iLimit, prefixStart, curr, dictLimit, ddsIdx);\n    } else if (dictMode == ZSTD_dictMatchState) {\n        const U32* const dmsChainTable = dms->chainTable;\n        const U32 dmsChainSize         = (1 << dms->cParams.chainLog);\n        const U32 dmsChainMask         = dmsChainSize - 1;\n        const U32 dmsLowestIndex       = dms->window.dictLimit;\n        const BYTE* const dmsBase      = dms->window.base;\n        const BYTE* const dmsEnd       = dms->window.nextSrc;\n        const U32 dmsSize              = (U32)(dmsEnd - dmsBase);\n        const U32 dmsIndexDelta        = dictLimit - dmsSize;\n        const U32 dmsMinChain = dmsSize > dmsChainSize ? dmsSize - dmsChainSize : 0;\n\n        matchIndex = dms->hashTable[ZSTD_hashPtr(ip, dms->cParams.hashLog, mls)];\n\n        for ( ; (matchIndex>=dmsLowestIndex) & (nbAttempts>0) ; nbAttempts--) {\n            size_t currentMl=0;\n            const BYTE* const match = dmsBase + matchIndex;\n            assert(match+4 <= dmsEnd);\n            if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */\n                currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dmsEnd, prefixStart) + 4;\n\n            /* save best solution */\n            if (currentMl > ml) {\n                ml = currentMl;\n                assert(curr > matchIndex + dmsIndexDelta);\n                *offsetPtr = OFFSET_TO_OFFBASE(curr - (matchIndex + dmsIndexDelta));\n                if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */\n            }\n\n            if (matchIndex <= dmsMinChain) break;\n\n            matchIndex = dmsChainTable[matchIndex & dmsChainMask];\n        }\n    }\n\n    return ml;\n}\n\n/* *********************************\n* (SIMD) Row-based matchfinder\n***********************************/\n/* Constants for row-based hash */\n#define ZSTD_ROW_HASH_TAG_MASK ((1u << ZSTD_ROW_HASH_TAG_BITS) - 1)\n#define ZSTD_ROW_HASH_MAX_ENTRIES 64    /* absolute maximum number of entries per row, for all configurations */\n\n#define ZSTD_ROW_HASH_CACHE_MASK (ZSTD_ROW_HASH_CACHE_SIZE - 1)\n\ntypedef U64 ZSTD_VecMask;   /* Clarifies when we are interacting with a U64 representing a mask of matches */\n\n/* ZSTD_VecMask_next():\n * Starting from the LSB, returns the idx of the next non-zero bit.\n * Basically counting the nb of trailing zeroes.\n */\nMEM_STATIC U32 ZSTD_VecMask_next(ZSTD_VecMask val) {\n    return ZSTD_countTrailingZeros64(val);\n}\n\n/* ZSTD_row_nextIndex():\n * Returns the next index to insert at within a tagTable row, and updates the \"head\"\n * value to reflect the update. Essentially cycles backwards from [1, {entries per row})\n */\nFORCE_INLINE_TEMPLATE U32 ZSTD_row_nextIndex(BYTE* const tagRow, U32 const rowMask) {\n    U32 next = (*tagRow-1) & rowMask;\n    next += (next == 0) ? rowMask : 0; /* skip first position */\n    *tagRow = (BYTE)next;\n    return next;\n}\n\n/* ZSTD_isAligned():\n * Checks that a pointer is aligned to \"align\" bytes which must be a power of 2.\n */\nMEM_STATIC int ZSTD_isAligned(void const* ptr, size_t align) {\n    assert((align & (align - 1)) == 0);\n    return (((size_t)ptr) & (align - 1)) == 0;\n}\n\n/* ZSTD_row_prefetch():\n * Performs prefetching for the hashTable and tagTable at a given row.\n */\nFORCE_INLINE_TEMPLATE void ZSTD_row_prefetch(U32 const* hashTable, BYTE const* tagTable, U32 const relRow, U32 const rowLog) {\n    PREFETCH_L1(hashTable + relRow);\n    if (rowLog >= 5) {\n        PREFETCH_L1(hashTable + relRow + 16);\n        /* Note: prefetching more of the hash table does not appear to be beneficial for 128-entry rows */\n    }\n    PREFETCH_L1(tagTable + relRow);\n    if (rowLog == 6) {\n        PREFETCH_L1(tagTable + relRow + 32);\n    }\n    assert(rowLog == 4 || rowLog == 5 || rowLog == 6);\n    assert(ZSTD_isAligned(hashTable + relRow, 64));                 /* prefetched hash row always 64-byte aligned */\n    assert(ZSTD_isAligned(tagTable + relRow, (size_t)1 << rowLog)); /* prefetched tagRow sits on correct multiple of bytes (32,64,128) */\n}\n\n/* ZSTD_row_fillHashCache():\n * Fill up the hash cache starting at idx, prefetching up to ZSTD_ROW_HASH_CACHE_SIZE entries,\n * but not beyond iLimit.\n */\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nvoid ZSTD_row_fillHashCache(ZSTD_MatchState_t* ms, const BYTE* base,\n                                   U32 const rowLog, U32 const mls,\n                                   U32 idx, const BYTE* const iLimit)\n{\n    U32 const* const hashTable = ms->hashTable;\n    BYTE const* const tagTable = ms->tagTable;\n    U32 const hashLog = ms->rowHashLog;\n    U32 const maxElemsToPrefetch = (base + idx) > iLimit ? 0 : (U32)(iLimit - (base + idx) + 1);\n    U32 const lim = idx + MIN(ZSTD_ROW_HASH_CACHE_SIZE, maxElemsToPrefetch);\n\n    for (; idx < lim; ++idx) {\n        U32 const hash = (U32)ZSTD_hashPtrSalted(base + idx, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls, ms->hashSalt);\n        U32 const row = (hash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;\n        ZSTD_row_prefetch(hashTable, tagTable, row, rowLog);\n        ms->hashCache[idx & ZSTD_ROW_HASH_CACHE_MASK] = hash;\n    }\n\n    DEBUGLOG(6, \"ZSTD_row_fillHashCache(): [%u %u %u %u %u %u %u %u]\", ms->hashCache[0], ms->hashCache[1],\n                                                     ms->hashCache[2], ms->hashCache[3], ms->hashCache[4],\n                                                     ms->hashCache[5], ms->hashCache[6], ms->hashCache[7]);\n}\n\n/* ZSTD_row_nextCachedHash():\n * Returns the hash of base + idx, and replaces the hash in the hash cache with the byte at\n * base + idx + ZSTD_ROW_HASH_CACHE_SIZE. Also prefetches the appropriate rows from hashTable and tagTable.\n */\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nU32 ZSTD_row_nextCachedHash(U32* cache, U32 const* hashTable,\n                                                  BYTE const* tagTable, BYTE const* base,\n                                                  U32 idx, U32 const hashLog,\n                                                  U32 const rowLog, U32 const mls,\n                                                  U64 const hashSalt)\n{\n    U32 const newHash = (U32)ZSTD_hashPtrSalted(base+idx+ZSTD_ROW_HASH_CACHE_SIZE, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls, hashSalt);\n    U32 const row = (newHash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;\n    ZSTD_row_prefetch(hashTable, tagTable, row, rowLog);\n    {   U32 const hash = cache[idx & ZSTD_ROW_HASH_CACHE_MASK];\n        cache[idx & ZSTD_ROW_HASH_CACHE_MASK] = newHash;\n        return hash;\n    }\n}\n\n/* ZSTD_row_update_internalImpl():\n * Updates the hash table with positions starting from updateStartIdx until updateEndIdx.\n */\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nvoid ZSTD_row_update_internalImpl(ZSTD_MatchState_t* ms,\n                                  U32 updateStartIdx, U32 const updateEndIdx,\n                                  U32 const mls, U32 const rowLog,\n                                  U32 const rowMask, U32 const useCache)\n{\n    U32* const hashTable = ms->hashTable;\n    BYTE* const tagTable = ms->tagTable;\n    U32 const hashLog = ms->rowHashLog;\n    const BYTE* const base = ms->window.base;\n\n    DEBUGLOG(6, \"ZSTD_row_update_internalImpl(): updateStartIdx=%u, updateEndIdx=%u\", updateStartIdx, updateEndIdx);\n    for (; updateStartIdx < updateEndIdx; ++updateStartIdx) {\n        U32 const hash = useCache ? ZSTD_row_nextCachedHash(ms->hashCache, hashTable, tagTable, base, updateStartIdx, hashLog, rowLog, mls, ms->hashSalt)\n                                  : (U32)ZSTD_hashPtrSalted(base + updateStartIdx, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls, ms->hashSalt);\n        U32 const relRow = (hash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;\n        U32* const row = hashTable + relRow;\n        BYTE* tagRow = tagTable + relRow;\n        U32 const pos = ZSTD_row_nextIndex(tagRow, rowMask);\n\n        assert(hash == ZSTD_hashPtrSalted(base + updateStartIdx, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls, ms->hashSalt));\n        tagRow[pos] = hash & ZSTD_ROW_HASH_TAG_MASK;\n        row[pos] = updateStartIdx;\n    }\n}\n\n/* ZSTD_row_update_internal():\n * Inserts the byte at ip into the appropriate position in the hash table, and updates ms->nextToUpdate.\n * Skips sections of long matches as is necessary.\n */\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nvoid ZSTD_row_update_internal(ZSTD_MatchState_t* ms, const BYTE* ip,\n                              U32 const mls, U32 const rowLog,\n                              U32 const rowMask, U32 const useCache)\n{\n    U32 idx = ms->nextToUpdate;\n    const BYTE* const base = ms->window.base;\n    const U32 target = (U32)(ip - base);\n    const U32 kSkipThreshold = 384;\n    const U32 kMaxMatchStartPositionsToUpdate = 96;\n    const U32 kMaxMatchEndPositionsToUpdate = 32;\n\n    if (useCache) {\n        /* Only skip positions when using hash cache, i.e.\n         * if we are loading a dict, don't skip anything.\n         * If we decide to skip, then we only update a set number\n         * of positions at the beginning and end of the match.\n         */\n        if (UNLIKELY(target - idx > kSkipThreshold)) {\n            U32 const bound = idx + kMaxMatchStartPositionsToUpdate;\n            ZSTD_row_update_internalImpl(ms, idx, bound, mls, rowLog, rowMask, useCache);\n            idx = target - kMaxMatchEndPositionsToUpdate;\n            ZSTD_row_fillHashCache(ms, base, rowLog, mls, idx, ip+1);\n        }\n    }\n    assert(target >= idx);\n    ZSTD_row_update_internalImpl(ms, idx, target, mls, rowLog, rowMask, useCache);\n    ms->nextToUpdate = target;\n}\n\n/* ZSTD_row_update():\n * External wrapper for ZSTD_row_update_internal(). Used for filling the hashtable during dictionary\n * processing.\n */\nvoid ZSTD_row_update(ZSTD_MatchState_t* const ms, const BYTE* ip) {\n    const U32 rowLog = BOUNDED(4, ms->cParams.searchLog, 6);\n    const U32 rowMask = (1u << rowLog) - 1;\n    const U32 mls = MIN(ms->cParams.minMatch, 6 /* mls caps out at 6 */);\n\n    DEBUGLOG(5, \"ZSTD_row_update(), rowLog=%u\", rowLog);\n    ZSTD_row_update_internal(ms, ip, mls, rowLog, rowMask, 0 /* don't use cache */);\n}\n\n/* Returns the mask width of bits group of which will be set to 1. Given not all\n * architectures have easy movemask instruction, this helps to iterate over\n * groups of bits easier and faster.\n */\nFORCE_INLINE_TEMPLATE U32\nZSTD_row_matchMaskGroupWidth(const U32 rowEntries)\n{\n    assert((rowEntries == 16) || (rowEntries == 32) || rowEntries == 64);\n    assert(rowEntries <= ZSTD_ROW_HASH_MAX_ENTRIES);\n    (void)rowEntries;\n#if defined(ZSTD_ARCH_ARM_NEON)\n    /* NEON path only works for little endian */\n    if (!MEM_isLittleEndian()) {\n        return 1;\n    }\n    if (rowEntries == 16) {\n        return 4;\n    }\n    if (rowEntries == 32) {\n        return 2;\n    }\n    if (rowEntries == 64) {\n        return 1;\n    }\n#endif\n    return 1;\n}\n\n#if defined(ZSTD_ARCH_X86_SSE2)\nFORCE_INLINE_TEMPLATE ZSTD_VecMask\nZSTD_row_getSSEMask(int nbChunks, const BYTE* const src, const BYTE tag, const U32 head)\n{\n    const __m128i comparisonMask = _mm_set1_epi8((char)tag);\n    int matches[4] = {0};\n    int i;\n    assert(nbChunks == 1 || nbChunks == 2 || nbChunks == 4);\n    for (i=0; i> chunkSize;\n            do {\n                size_t chunk = MEM_readST(&src[i]);\n                chunk ^= splatChar;\n                chunk = (((chunk | x80) - x01) | chunk) & x80;\n                matches <<= chunkSize;\n                matches |= (chunk * extractMagic) >> shiftAmount;\n                i -= chunkSize;\n            } while (i >= 0);\n        } else { /* big endian: reverse bits during extraction */\n            const size_t msb = xFF ^ (xFF >> 1);\n            const size_t extractMagic = (msb / 0x1FF) | msb;\n            do {\n                size_t chunk = MEM_readST(&src[i]);\n                chunk ^= splatChar;\n                chunk = (((chunk | x80) - x01) | chunk) & x80;\n                matches <<= chunkSize;\n                matches |= ((chunk >> 7) * extractMagic) >> shiftAmount;\n                i -= chunkSize;\n            } while (i >= 0);\n        }\n        matches = ~matches;\n        if (rowEntries == 16) {\n            return ZSTD_rotateRight_U16((U16)matches, headGrouped);\n        } else if (rowEntries == 32) {\n            return ZSTD_rotateRight_U32((U32)matches, headGrouped);\n        } else {\n            return ZSTD_rotateRight_U64((U64)matches, headGrouped);\n        }\n    }\n#endif\n}\n\n/* The high-level approach of the SIMD row based match finder is as follows:\n * - Figure out where to insert the new entry:\n *      - Generate a hash for current input position and split it into a one byte of tag and `rowHashLog` bits of index.\n *           - The hash is salted by a value that changes on every context reset, so when the same table is used\n *             we will avoid collisions that would otherwise slow us down by introducing phantom matches.\n *      - The hashTable is effectively split into groups or \"rows\" of 15 or 31 entries of U32, and the index determines\n *        which row to insert into.\n *      - Determine the correct position within the row to insert the entry into. Each row of 15 or 31 can\n *        be considered as a circular buffer with a \"head\" index that resides in the tagTable (overall 16 or 32 bytes\n *        per row).\n * - Use SIMD to efficiently compare the tags in the tagTable to the 1-byte tag calculated for the position and\n *   generate a bitfield that we can cycle through to check the collisions in the hash table.\n * - Pick the longest match.\n * - Insert the tag into the equivalent row and position in the tagTable.\n */\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_RowFindBestMatch(\n                        ZSTD_MatchState_t* ms,\n                        const BYTE* const ip, const BYTE* const iLimit,\n                        size_t* offsetPtr,\n                        const U32 mls, const ZSTD_dictMode_e dictMode,\n                        const U32 rowLog)\n{\n    U32* const hashTable = ms->hashTable;\n    BYTE* const tagTable = ms->tagTable;\n    U32* const hashCache = ms->hashCache;\n    const U32 hashLog = ms->rowHashLog;\n    const ZSTD_compressionParameters* const cParams = &ms->cParams;\n    const BYTE* const base = ms->window.base;\n    const BYTE* const dictBase = ms->window.dictBase;\n    const U32 dictLimit = ms->window.dictLimit;\n    const BYTE* const prefixStart = base + dictLimit;\n    const BYTE* const dictEnd = dictBase + dictLimit;\n    const U32 curr = (U32)(ip-base);\n    const U32 maxDistance = 1U << cParams->windowLog;\n    const U32 lowestValid = ms->window.lowLimit;\n    const U32 withinMaxDistance = (curr - lowestValid > maxDistance) ? curr - maxDistance : lowestValid;\n    const U32 isDictionary = (ms->loadedDictEnd != 0);\n    const U32 lowLimit = isDictionary ? lowestValid : withinMaxDistance;\n    const U32 rowEntries = (1U << rowLog);\n    const U32 rowMask = rowEntries - 1;\n    const U32 cappedSearchLog = MIN(cParams->searchLog, rowLog); /* nb of searches is capped at nb entries per row */\n    const U32 groupWidth = ZSTD_row_matchMaskGroupWidth(rowEntries);\n    const U64 hashSalt = ms->hashSalt;\n    U32 nbAttempts = 1U << cappedSearchLog;\n    size_t ml=4-1;\n    U32 hash;\n\n    /* DMS/DDS variables that may be referenced laster */\n    const ZSTD_MatchState_t* const dms = ms->dictMatchState;\n\n    /* Initialize the following variables to satisfy static analyzer */\n    size_t ddsIdx = 0;\n    U32 ddsExtraAttempts = 0; /* cctx hash tables are limited in searches, but allow extra searches into DDS */\n    U32 dmsTag = 0;\n    U32* dmsRow = NULL;\n    BYTE* dmsTagRow = NULL;\n\n    if (dictMode == ZSTD_dedicatedDictSearch) {\n        const U32 ddsHashLog = dms->cParams.hashLog - ZSTD_LAZY_DDSS_BUCKET_LOG;\n        {   /* Prefetch DDS hashtable entry */\n            ddsIdx = ZSTD_hashPtr(ip, ddsHashLog, mls) << ZSTD_LAZY_DDSS_BUCKET_LOG;\n            PREFETCH_L1(&dms->hashTable[ddsIdx]);\n        }\n        ddsExtraAttempts = cParams->searchLog > rowLog ? 1U << (cParams->searchLog - rowLog) : 0;\n    }\n\n    if (dictMode == ZSTD_dictMatchState) {\n        /* Prefetch DMS rows */\n        U32* const dmsHashTable = dms->hashTable;\n        BYTE* const dmsTagTable = dms->tagTable;\n        U32 const dmsHash = (U32)ZSTD_hashPtr(ip, dms->rowHashLog + ZSTD_ROW_HASH_TAG_BITS, mls);\n        U32 const dmsRelRow = (dmsHash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;\n        dmsTag = dmsHash & ZSTD_ROW_HASH_TAG_MASK;\n        dmsTagRow = (BYTE*)(dmsTagTable + dmsRelRow);\n        dmsRow = dmsHashTable + dmsRelRow;\n        ZSTD_row_prefetch(dmsHashTable, dmsTagTable, dmsRelRow, rowLog);\n    }\n\n    /* Update the hashTable and tagTable up to (but not including) ip */\n    if (!ms->lazySkipping) {\n        ZSTD_row_update_internal(ms, ip, mls, rowLog, rowMask, 1 /* useCache */);\n        hash = ZSTD_row_nextCachedHash(hashCache, hashTable, tagTable, base, curr, hashLog, rowLog, mls, hashSalt);\n    } else {\n        /* Stop inserting every position when in the lazy skipping mode.\n         * The hash cache is also not kept up to date in this mode.\n         */\n        hash = (U32)ZSTD_hashPtrSalted(ip, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls, hashSalt);\n        ms->nextToUpdate = curr;\n    }\n    ms->hashSaltEntropy += hash; /* collect salt entropy */\n\n    {   /* Get the hash for ip, compute the appropriate row */\n        U32 const relRow = (hash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;\n        U32 const tag = hash & ZSTD_ROW_HASH_TAG_MASK;\n        U32* const row = hashTable + relRow;\n        BYTE* tagRow = (BYTE*)(tagTable + relRow);\n        U32 const headGrouped = (*tagRow & rowMask) * groupWidth;\n        U32 matchBuffer[ZSTD_ROW_HASH_MAX_ENTRIES];\n        size_t numMatches = 0;\n        size_t currMatch = 0;\n        ZSTD_VecMask matches = ZSTD_row_getMatchMask(tagRow, (BYTE)tag, headGrouped, rowEntries);\n\n        /* Cycle through the matches and prefetch */\n        for (; (matches > 0) && (nbAttempts > 0); matches &= (matches - 1)) {\n            U32 const matchPos = ((headGrouped + ZSTD_VecMask_next(matches)) / groupWidth) & rowMask;\n            U32 const matchIndex = row[matchPos];\n            if(matchPos == 0) continue;\n            assert(numMatches < rowEntries);\n            if (matchIndex < lowLimit)\n                break;\n            if ((dictMode != ZSTD_extDict) || matchIndex >= dictLimit) {\n                PREFETCH_L1(base + matchIndex);\n            } else {\n                PREFETCH_L1(dictBase + matchIndex);\n            }\n            matchBuffer[numMatches++] = matchIndex;\n            --nbAttempts;\n        }\n\n        /* Speed opt: insert current byte into hashtable too. This allows us to avoid one iteration of the loop\n           in ZSTD_row_update_internal() at the next search. */\n        {\n            U32 const pos = ZSTD_row_nextIndex(tagRow, rowMask);\n            tagRow[pos] = (BYTE)tag;\n            row[pos] = ms->nextToUpdate++;\n        }\n\n        /* Return the longest match */\n        for (; currMatch < numMatches; ++currMatch) {\n            U32 const matchIndex = matchBuffer[currMatch];\n            size_t currentMl=0;\n            assert(matchIndex < curr);\n            assert(matchIndex >= lowLimit);\n\n            if ((dictMode != ZSTD_extDict) || matchIndex >= dictLimit) {\n                const BYTE* const match = base + matchIndex;\n                assert(matchIndex >= dictLimit);   /* ensures this is true if dictMode != ZSTD_extDict */\n                /* read 4B starting from (match + ml + 1 - sizeof(U32)) */\n                if (MEM_read32(match + ml - 3) == MEM_read32(ip + ml - 3))   /* potentially better */\n                    currentMl = ZSTD_count(ip, match, iLimit);\n            } else {\n                const BYTE* const match = dictBase + matchIndex;\n                assert(match+4 <= dictEnd);\n                if (MEM_read32(match) == MEM_read32(ip))   /* assumption : matchIndex <= dictLimit-4 (by table construction) */\n                    currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dictEnd, prefixStart) + 4;\n            }\n\n            /* Save best solution */\n            if (currentMl > ml) {\n                ml = currentMl;\n                *offsetPtr = OFFSET_TO_OFFBASE(curr - matchIndex);\n                if (ip+currentMl == iLimit) break; /* best possible, avoids read overflow on next attempt */\n            }\n        }\n    }\n\n    assert(nbAttempts <= (1U << ZSTD_SEARCHLOG_MAX)); /* Check we haven't underflowed. */\n    if (dictMode == ZSTD_dedicatedDictSearch) {\n        ml = ZSTD_dedicatedDictSearch_lazy_search(offsetPtr, ml, nbAttempts + ddsExtraAttempts, dms,\n                                                  ip, iLimit, prefixStart, curr, dictLimit, ddsIdx);\n    } else if (dictMode == ZSTD_dictMatchState) {\n        /* TODO: Measure and potentially add prefetching to DMS */\n        const U32 dmsLowestIndex       = dms->window.dictLimit;\n        const BYTE* const dmsBase      = dms->window.base;\n        const BYTE* const dmsEnd       = dms->window.nextSrc;\n        const U32 dmsSize              = (U32)(dmsEnd - dmsBase);\n        const U32 dmsIndexDelta        = dictLimit - dmsSize;\n\n        {   U32 const headGrouped = (*dmsTagRow & rowMask) * groupWidth;\n            U32 matchBuffer[ZSTD_ROW_HASH_MAX_ENTRIES];\n            size_t numMatches = 0;\n            size_t currMatch = 0;\n            ZSTD_VecMask matches = ZSTD_row_getMatchMask(dmsTagRow, (BYTE)dmsTag, headGrouped, rowEntries);\n\n            for (; (matches > 0) && (nbAttempts > 0); matches &= (matches - 1)) {\n                U32 const matchPos = ((headGrouped + ZSTD_VecMask_next(matches)) / groupWidth) & rowMask;\n                U32 const matchIndex = dmsRow[matchPos];\n                if(matchPos == 0) continue;\n                if (matchIndex < dmsLowestIndex)\n                    break;\n                PREFETCH_L1(dmsBase + matchIndex);\n                matchBuffer[numMatches++] = matchIndex;\n                --nbAttempts;\n            }\n\n            /* Return the longest match */\n            for (; currMatch < numMatches; ++currMatch) {\n                U32 const matchIndex = matchBuffer[currMatch];\n                size_t currentMl=0;\n                assert(matchIndex >= dmsLowestIndex);\n                assert(matchIndex < curr);\n\n                {   const BYTE* const match = dmsBase + matchIndex;\n                    assert(match+4 <= dmsEnd);\n                    if (MEM_read32(match) == MEM_read32(ip))\n                        currentMl = ZSTD_count_2segments(ip+4, match+4, iLimit, dmsEnd, prefixStart) + 4;\n                }\n\n                if (currentMl > ml) {\n                    ml = currentMl;\n                    assert(curr > matchIndex + dmsIndexDelta);\n                    *offsetPtr = OFFSET_TO_OFFBASE(curr - (matchIndex + dmsIndexDelta));\n                    if (ip+currentMl == iLimit) break;\n                }\n            }\n        }\n    }\n    return ml;\n}\n\n\n/**\n * Generate search functions templated on (dictMode, mls, rowLog).\n * These functions are outlined for code size & compilation time.\n * ZSTD_searchMax() dispatches to the correct implementation function.\n *\n * TODO: The start of the search function involves loading and calculating a\n * bunch of constants from the ZSTD_MatchState_t. These computations could be\n * done in an initialization function, and saved somewhere in the match state.\n * Then we could pass a pointer to the saved state instead of the match state,\n * and avoid duplicate computations.\n *\n * TODO: Move the match re-winding into searchMax. This improves compression\n * ratio, and unlocks further simplifications with the next TODO.\n *\n * TODO: Try moving the repcode search into searchMax. After the re-winding\n * and repcode search are in searchMax, there is no more logic in the match\n * finder loop that requires knowledge about the dictMode. So we should be\n * able to avoid force inlining it, and we can join the extDict loop with\n * the single segment loop. It should go in searchMax instead of its own\n * function to avoid having multiple virtual function calls per search.\n */\n\n#define ZSTD_BT_SEARCH_FN(dictMode, mls) ZSTD_BtFindBestMatch_##dictMode##_##mls\n#define ZSTD_HC_SEARCH_FN(dictMode, mls) ZSTD_HcFindBestMatch_##dictMode##_##mls\n#define ZSTD_ROW_SEARCH_FN(dictMode, mls, rowLog) ZSTD_RowFindBestMatch_##dictMode##_##mls##_##rowLog\n\n#define ZSTD_SEARCH_FN_ATTRS FORCE_NOINLINE\n\n#define GEN_ZSTD_BT_SEARCH_FN(dictMode, mls)                                           \\\n    ZSTD_SEARCH_FN_ATTRS size_t ZSTD_BT_SEARCH_FN(dictMode, mls)(                      \\\n            ZSTD_MatchState_t* ms,                                                     \\\n            const BYTE* ip, const BYTE* const iLimit,                                  \\\n            size_t* offBasePtr)                                                        \\\n    {                                                                                  \\\n        assert(MAX(4, MIN(6, ms->cParams.minMatch)) == mls);                           \\\n        return ZSTD_BtFindBestMatch(ms, ip, iLimit, offBasePtr, mls, ZSTD_##dictMode); \\\n    }                                                                                  \\\n\n#define GEN_ZSTD_HC_SEARCH_FN(dictMode, mls)                                          \\\n    ZSTD_SEARCH_FN_ATTRS size_t ZSTD_HC_SEARCH_FN(dictMode, mls)(                     \\\n            ZSTD_MatchState_t* ms,                                                    \\\n            const BYTE* ip, const BYTE* const iLimit,                                 \\\n            size_t* offsetPtr)                                                        \\\n    {                                                                                 \\\n        assert(MAX(4, MIN(6, ms->cParams.minMatch)) == mls);                          \\\n        return ZSTD_HcFindBestMatch(ms, ip, iLimit, offsetPtr, mls, ZSTD_##dictMode); \\\n    }                                                                                 \\\n\n#define GEN_ZSTD_ROW_SEARCH_FN(dictMode, mls, rowLog)                                          \\\n    ZSTD_SEARCH_FN_ATTRS size_t ZSTD_ROW_SEARCH_FN(dictMode, mls, rowLog)(                     \\\n            ZSTD_MatchState_t* ms,                                                             \\\n            const BYTE* ip, const BYTE* const iLimit,                                          \\\n            size_t* offsetPtr)                                                                 \\\n    {                                                                                          \\\n        assert(MAX(4, MIN(6, ms->cParams.minMatch)) == mls);                                   \\\n        assert(MAX(4, MIN(6, ms->cParams.searchLog)) == rowLog);                               \\\n        return ZSTD_RowFindBestMatch(ms, ip, iLimit, offsetPtr, mls, ZSTD_##dictMode, rowLog); \\\n    }                                                                                          \\\n\n#define ZSTD_FOR_EACH_ROWLOG(X, dictMode, mls) \\\n    X(dictMode, mls, 4)                        \\\n    X(dictMode, mls, 5)                        \\\n    X(dictMode, mls, 6)\n\n#define ZSTD_FOR_EACH_MLS_ROWLOG(X, dictMode) \\\n    ZSTD_FOR_EACH_ROWLOG(X, dictMode, 4)      \\\n    ZSTD_FOR_EACH_ROWLOG(X, dictMode, 5)      \\\n    ZSTD_FOR_EACH_ROWLOG(X, dictMode, 6)\n\n#define ZSTD_FOR_EACH_MLS(X, dictMode) \\\n    X(dictMode, 4)                     \\\n    X(dictMode, 5)                     \\\n    X(dictMode, 6)\n\n#define ZSTD_FOR_EACH_DICT_MODE(X, ...) \\\n    X(__VA_ARGS__, noDict)              \\\n    X(__VA_ARGS__, extDict)             \\\n    X(__VA_ARGS__, dictMatchState)      \\\n    X(__VA_ARGS__, dedicatedDictSearch)\n\n/* Generate row search fns for each combination of (dictMode, mls, rowLog) */\nZSTD_FOR_EACH_DICT_MODE(ZSTD_FOR_EACH_MLS_ROWLOG, GEN_ZSTD_ROW_SEARCH_FN)\n/* Generate binary Tree search fns for each combination of (dictMode, mls) */\nZSTD_FOR_EACH_DICT_MODE(ZSTD_FOR_EACH_MLS, GEN_ZSTD_BT_SEARCH_FN)\n/* Generate hash chain search fns for each combination of (dictMode, mls) */\nZSTD_FOR_EACH_DICT_MODE(ZSTD_FOR_EACH_MLS, GEN_ZSTD_HC_SEARCH_FN)\n\ntypedef enum { search_hashChain=0, search_binaryTree=1, search_rowHash=2 } searchMethod_e;\n\n#define GEN_ZSTD_CALL_BT_SEARCH_FN(dictMode, mls)                         \\\n    case mls:                                                             \\\n        return ZSTD_BT_SEARCH_FN(dictMode, mls)(ms, ip, iend, offsetPtr);\n#define GEN_ZSTD_CALL_HC_SEARCH_FN(dictMode, mls)                         \\\n    case mls:                                                             \\\n        return ZSTD_HC_SEARCH_FN(dictMode, mls)(ms, ip, iend, offsetPtr);\n#define GEN_ZSTD_CALL_ROW_SEARCH_FN(dictMode, mls, rowLog)                         \\\n    case rowLog:                                                                   \\\n        return ZSTD_ROW_SEARCH_FN(dictMode, mls, rowLog)(ms, ip, iend, offsetPtr);\n\n#define ZSTD_SWITCH_MLS(X, dictMode)   \\\n    switch (mls) {                     \\\n        ZSTD_FOR_EACH_MLS(X, dictMode) \\\n    }\n\n#define ZSTD_SWITCH_ROWLOG(dictMode, mls)                                    \\\n    case mls:                                                                \\\n        switch (rowLog) {                                                    \\\n            ZSTD_FOR_EACH_ROWLOG(GEN_ZSTD_CALL_ROW_SEARCH_FN, dictMode, mls) \\\n        }                                                                    \\\n        ZSTD_UNREACHABLE;                                                    \\\n        break;\n\n#define ZSTD_SWITCH_SEARCH_METHOD(dictMode)                       \\\n    switch (searchMethod) {                                       \\\n        case search_hashChain:                                    \\\n            ZSTD_SWITCH_MLS(GEN_ZSTD_CALL_HC_SEARCH_FN, dictMode) \\\n            break;                                                \\\n        case search_binaryTree:                                   \\\n            ZSTD_SWITCH_MLS(GEN_ZSTD_CALL_BT_SEARCH_FN, dictMode) \\\n            break;                                                \\\n        case search_rowHash:                                      \\\n            ZSTD_SWITCH_MLS(ZSTD_SWITCH_ROWLOG, dictMode)         \\\n            break;                                                \\\n    }                                                             \\\n    ZSTD_UNREACHABLE;\n\n/**\n * Searches for the longest match at @p ip.\n * Dispatches to the correct implementation function based on the\n * (searchMethod, dictMode, mls, rowLog). We use switch statements\n * here instead of using an indirect function call through a function\n * pointer because after Spectre and Meltdown mitigations, indirect\n * function calls can be very costly, especially in the kernel.\n *\n * NOTE: dictMode and searchMethod should be templated, so those switch\n * statements should be optimized out. Only the mls & rowLog switches\n * should be left.\n *\n * @param ms The match state.\n * @param ip The position to search at.\n * @param iend The end of the input data.\n * @param[out] offsetPtr Stores the match offset into this pointer.\n * @param mls The minimum search length, in the range [4, 6].\n * @param rowLog The row log (if applicable), in the range [4, 6].\n * @param searchMethod The search method to use (templated).\n * @param dictMode The dictMode (templated).\n *\n * @returns The length of the longest match found, or < mls if no match is found.\n * If a match is found its offset is stored in @p offsetPtr.\n */\nFORCE_INLINE_TEMPLATE size_t ZSTD_searchMax(\n    ZSTD_MatchState_t* ms,\n    const BYTE* ip,\n    const BYTE* iend,\n    size_t* offsetPtr,\n    U32 const mls,\n    U32 const rowLog,\n    searchMethod_e const searchMethod,\n    ZSTD_dictMode_e const dictMode)\n{\n    if (dictMode == ZSTD_noDict) {\n        ZSTD_SWITCH_SEARCH_METHOD(noDict)\n    } else if (dictMode == ZSTD_extDict) {\n        ZSTD_SWITCH_SEARCH_METHOD(extDict)\n    } else if (dictMode == ZSTD_dictMatchState) {\n        ZSTD_SWITCH_SEARCH_METHOD(dictMatchState)\n    } else if (dictMode == ZSTD_dedicatedDictSearch) {\n        ZSTD_SWITCH_SEARCH_METHOD(dedicatedDictSearch)\n    }\n    ZSTD_UNREACHABLE;\n    return 0;\n}\n\n/* *******************************\n*  Common parser - lazy strategy\n*********************************/\n\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_compressBlock_lazy_generic(\n                        ZSTD_MatchState_t* ms, SeqStore_t* seqStore,\n                        U32 rep[ZSTD_REP_NUM],\n                        const void* src, size_t srcSize,\n                        const searchMethod_e searchMethod, const U32 depth,\n                        ZSTD_dictMode_e const dictMode)\n{\n    const BYTE* const istart = (const BYTE*)src;\n    const BYTE* ip = istart;\n    const BYTE* anchor = istart;\n    const BYTE* const iend = istart + srcSize;\n    const BYTE* const ilimit = (searchMethod == search_rowHash) ? iend - 8 - ZSTD_ROW_HASH_CACHE_SIZE : iend - 8;\n    const BYTE* const base = ms->window.base;\n    const U32 prefixLowestIndex = ms->window.dictLimit;\n    const BYTE* const prefixLowest = base + prefixLowestIndex;\n    const U32 mls = BOUNDED(4, ms->cParams.minMatch, 6);\n    const U32 rowLog = BOUNDED(4, ms->cParams.searchLog, 6);\n\n    U32 offset_1 = rep[0], offset_2 = rep[1];\n    U32 offsetSaved1 = 0, offsetSaved2 = 0;\n\n    const int isDMS = dictMode == ZSTD_dictMatchState;\n    const int isDDS = dictMode == ZSTD_dedicatedDictSearch;\n    const int isDxS = isDMS || isDDS;\n    const ZSTD_MatchState_t* const dms = ms->dictMatchState;\n    const U32 dictLowestIndex      = isDxS ? dms->window.dictLimit : 0;\n    const BYTE* const dictBase     = isDxS ? dms->window.base : NULL;\n    const BYTE* const dictLowest   = isDxS ? dictBase + dictLowestIndex : NULL;\n    const BYTE* const dictEnd      = isDxS ? dms->window.nextSrc : NULL;\n    const U32 dictIndexDelta       = isDxS ?\n                                     prefixLowestIndex - (U32)(dictEnd - dictBase) :\n                                     0;\n    const U32 dictAndPrefixLength = (U32)((ip - prefixLowest) + (dictEnd - dictLowest));\n\n    DEBUGLOG(5, \"ZSTD_compressBlock_lazy_generic (dictMode=%u) (searchFunc=%u)\", (U32)dictMode, (U32)searchMethod);\n    ip += (dictAndPrefixLength == 0);\n    if (dictMode == ZSTD_noDict) {\n        U32 const curr = (U32)(ip - base);\n        U32 const windowLow = ZSTD_getLowestPrefixIndex(ms, curr, ms->cParams.windowLog);\n        U32 const maxRep = curr - windowLow;\n        if (offset_2 > maxRep) offsetSaved2 = offset_2, offset_2 = 0;\n        if (offset_1 > maxRep) offsetSaved1 = offset_1, offset_1 = 0;\n    }\n    if (isDxS) {\n        /* dictMatchState repCode checks don't currently handle repCode == 0\n         * disabling. */\n        assert(offset_1 <= dictAndPrefixLength);\n        assert(offset_2 <= dictAndPrefixLength);\n    }\n\n    /* Reset the lazy skipping state */\n    ms->lazySkipping = 0;\n\n    if (searchMethod == search_rowHash) {\n        ZSTD_row_fillHashCache(ms, base, rowLog, mls, ms->nextToUpdate, ilimit);\n    }\n\n    /* Match Loop */\n#if defined(__GNUC__) && defined(__x86_64__)\n    /* I've measured random a 5% speed loss on levels 5 & 6 (greedy) when the\n     * code alignment is perturbed. To fix the instability align the loop on 32-bytes.\n     */\n    __asm__(\".p2align 5\");\n#endif\n    while (ip < ilimit) {\n        size_t matchLength=0;\n        size_t offBase = REPCODE1_TO_OFFBASE;\n        const BYTE* start=ip+1;\n        DEBUGLOG(7, \"search baseline (depth 0)\");\n\n        /* check repCode */\n        if (isDxS) {\n            const U32 repIndex = (U32)(ip - base) + 1 - offset_1;\n            const BYTE* repMatch = ((dictMode == ZSTD_dictMatchState || dictMode == ZSTD_dedicatedDictSearch)\n                                && repIndex < prefixLowestIndex) ?\n                                   dictBase + (repIndex - dictIndexDelta) :\n                                   base + repIndex;\n            if ((ZSTD_index_overlap_check(prefixLowestIndex, repIndex))\n                && (MEM_read32(repMatch) == MEM_read32(ip+1)) ) {\n                const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;\n                matchLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;\n                if (depth==0) goto _storeSequence;\n            }\n        }\n        if ( dictMode == ZSTD_noDict\n          && ((offset_1 > 0) & (MEM_read32(ip+1-offset_1) == MEM_read32(ip+1)))) {\n            matchLength = ZSTD_count(ip+1+4, ip+1+4-offset_1, iend) + 4;\n            if (depth==0) goto _storeSequence;\n        }\n\n        /* first search (depth 0) */\n        {   size_t offbaseFound = 999999999;\n            size_t const ml2 = ZSTD_searchMax(ms, ip, iend, &offbaseFound, mls, rowLog, searchMethod, dictMode);\n            if (ml2 > matchLength)\n                matchLength = ml2, start = ip, offBase = offbaseFound;\n        }\n\n        if (matchLength < 4) {\n            size_t const step = ((size_t)(ip-anchor) >> kSearchStrength) + 1;   /* jump faster over incompressible sections */;\n            ip += step;\n            /* Enter the lazy skipping mode once we are skipping more than 8 bytes at a time.\n             * In this mode we stop inserting every position into our tables, and only insert\n             * positions that we search, which is one in step positions.\n             * The exact cutoff is flexible, I've just chosen a number that is reasonably high,\n             * so we minimize the compression ratio loss in \"normal\" scenarios. This mode gets\n             * triggered once we've gone 2KB without finding any matches.\n             */\n            ms->lazySkipping = step > kLazySkippingStep;\n            continue;\n        }\n\n        /* let's try to find a better solution */\n        if (depth>=1)\n        while (ip0) & (MEM_read32(ip) == MEM_read32(ip - offset_1)))) {\n                size_t const mlRep = ZSTD_count(ip+4, ip+4-offset_1, iend) + 4;\n                int const gain2 = (int)(mlRep * 3);\n                int const gain1 = (int)(matchLength*3 - ZSTD_highbit32((U32)offBase) + 1);\n                if ((mlRep >= 4) && (gain2 > gain1))\n                    matchLength = mlRep, offBase = REPCODE1_TO_OFFBASE, start = ip;\n            }\n            if (isDxS) {\n                const U32 repIndex = (U32)(ip - base) - offset_1;\n                const BYTE* repMatch = repIndex < prefixLowestIndex ?\n                               dictBase + (repIndex - dictIndexDelta) :\n                               base + repIndex;\n                if ((ZSTD_index_overlap_check(prefixLowestIndex, repIndex))\n                    && (MEM_read32(repMatch) == MEM_read32(ip)) ) {\n                    const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;\n                    size_t const mlRep = ZSTD_count_2segments(ip+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;\n                    int const gain2 = (int)(mlRep * 3);\n                    int const gain1 = (int)(matchLength*3 - ZSTD_highbit32((U32)offBase) + 1);\n                    if ((mlRep >= 4) && (gain2 > gain1))\n                        matchLength = mlRep, offBase = REPCODE1_TO_OFFBASE, start = ip;\n                }\n            }\n            {   size_t ofbCandidate=999999999;\n                size_t const ml2 = ZSTD_searchMax(ms, ip, iend, &ofbCandidate, mls, rowLog, searchMethod, dictMode);\n                int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)ofbCandidate));   /* raw approx */\n                int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offBase) + 4);\n                if ((ml2 >= 4) && (gain2 > gain1)) {\n                    matchLength = ml2, offBase = ofbCandidate, start = ip;\n                    continue;   /* search a better one */\n            }   }\n\n            /* let's find an even better one */\n            if ((depth==2) && (ip0) & (MEM_read32(ip) == MEM_read32(ip - offset_1)))) {\n                    size_t const mlRep = ZSTD_count(ip+4, ip+4-offset_1, iend) + 4;\n                    int const gain2 = (int)(mlRep * 4);\n                    int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offBase) + 1);\n                    if ((mlRep >= 4) && (gain2 > gain1))\n                        matchLength = mlRep, offBase = REPCODE1_TO_OFFBASE, start = ip;\n                }\n                if (isDxS) {\n                    const U32 repIndex = (U32)(ip - base) - offset_1;\n                    const BYTE* repMatch = repIndex < prefixLowestIndex ?\n                                   dictBase + (repIndex - dictIndexDelta) :\n                                   base + repIndex;\n                    if ((ZSTD_index_overlap_check(prefixLowestIndex, repIndex))\n                        && (MEM_read32(repMatch) == MEM_read32(ip)) ) {\n                        const BYTE* repMatchEnd = repIndex < prefixLowestIndex ? dictEnd : iend;\n                        size_t const mlRep = ZSTD_count_2segments(ip+4, repMatch+4, iend, repMatchEnd, prefixLowest) + 4;\n                        int const gain2 = (int)(mlRep * 4);\n                        int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offBase) + 1);\n                        if ((mlRep >= 4) && (gain2 > gain1))\n                            matchLength = mlRep, offBase = REPCODE1_TO_OFFBASE, start = ip;\n                    }\n                }\n                {   size_t ofbCandidate=999999999;\n                    size_t const ml2 = ZSTD_searchMax(ms, ip, iend, &ofbCandidate, mls, rowLog, searchMethod, dictMode);\n                    int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)ofbCandidate));   /* raw approx */\n                    int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offBase) + 7);\n                    if ((ml2 >= 4) && (gain2 > gain1)) {\n                        matchLength = ml2, offBase = ofbCandidate, start = ip;\n                        continue;\n            }   }   }\n            break;  /* nothing found : store previous solution */\n        }\n\n        /* NOTE:\n         * Pay attention that `start[-value]` can lead to strange undefined behavior\n         * notably if `value` is unsigned, resulting in a large positive `-value`.\n         */\n        /* catch up */\n        if (OFFBASE_IS_OFFSET(offBase)) {\n            if (dictMode == ZSTD_noDict) {\n                while ( ((start > anchor) & (start - OFFBASE_TO_OFFSET(offBase) > prefixLowest))\n                     && (start[-1] == (start-OFFBASE_TO_OFFSET(offBase))[-1]) )  /* only search for offset within prefix */\n                    { start--; matchLength++; }\n            }\n            if (isDxS) {\n                U32 const matchIndex = (U32)((size_t)(start-base) - OFFBASE_TO_OFFSET(offBase));\n                const BYTE* match = (matchIndex < prefixLowestIndex) ? dictBase + matchIndex - dictIndexDelta : base + matchIndex;\n                const BYTE* const mStart = (matchIndex < prefixLowestIndex) ? dictLowest : prefixLowest;\n                while ((start>anchor) && (match>mStart) && (start[-1] == match[-1])) { start--; match--; matchLength++; }  /* catch up */\n            }\n            offset_2 = offset_1; offset_1 = (U32)OFFBASE_TO_OFFSET(offBase);\n        }\n        /* store sequence */\n_storeSequence:\n        {   size_t const litLength = (size_t)(start - anchor);\n            ZSTD_storeSeq(seqStore, litLength, anchor, iend, (U32)offBase, matchLength);\n            anchor = ip = start + matchLength;\n        }\n        if (ms->lazySkipping) {\n            /* We've found a match, disable lazy skipping mode, and refill the hash cache. */\n            if (searchMethod == search_rowHash) {\n                ZSTD_row_fillHashCache(ms, base, rowLog, mls, ms->nextToUpdate, ilimit);\n            }\n            ms->lazySkipping = 0;\n        }\n\n        /* check immediate repcode */\n        if (isDxS) {\n            while (ip <= ilimit) {\n                U32 const current2 = (U32)(ip-base);\n                U32 const repIndex = current2 - offset_2;\n                const BYTE* repMatch = repIndex < prefixLowestIndex ?\n                        dictBase - dictIndexDelta + repIndex :\n                        base + repIndex;\n                if ( (ZSTD_index_overlap_check(prefixLowestIndex, repIndex))\n                   && (MEM_read32(repMatch) == MEM_read32(ip)) ) {\n                    const BYTE* const repEnd2 = repIndex < prefixLowestIndex ? dictEnd : iend;\n                    matchLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd2, prefixLowest) + 4;\n                    offBase = offset_2; offset_2 = offset_1; offset_1 = (U32)offBase;   /* swap offset_2 <=> offset_1 */\n                    ZSTD_storeSeq(seqStore, 0, anchor, iend, REPCODE1_TO_OFFBASE, matchLength);\n                    ip += matchLength;\n                    anchor = ip;\n                    continue;\n                }\n                break;\n            }\n        }\n\n        if (dictMode == ZSTD_noDict) {\n            while ( ((ip <= ilimit) & (offset_2>0))\n                 && (MEM_read32(ip) == MEM_read32(ip - offset_2)) ) {\n                /* store sequence */\n                matchLength = ZSTD_count(ip+4, ip+4-offset_2, iend) + 4;\n                offBase = offset_2; offset_2 = offset_1; offset_1 = (U32)offBase; /* swap repcodes */\n                ZSTD_storeSeq(seqStore, 0, anchor, iend, REPCODE1_TO_OFFBASE, matchLength);\n                ip += matchLength;\n                anchor = ip;\n                continue;   /* faster when present ... (?) */\n    }   }   }\n\n    /* If offset_1 started invalid (offsetSaved1 != 0) and became valid (offset_1 != 0),\n     * rotate saved offsets. See comment in ZSTD_compressBlock_fast_noDict for more context. */\n    offsetSaved2 = ((offsetSaved1 != 0) && (offset_1 != 0)) ? offsetSaved1 : offsetSaved2;\n\n    /* save reps for next block */\n    rep[0] = offset_1 ? offset_1 : offsetSaved1;\n    rep[1] = offset_2 ? offset_2 : offsetSaved2;\n\n    /* Return the last literals size */\n    return (size_t)(iend - anchor);\n}\n#endif /* build exclusions */\n\n\n#ifndef ZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR\nsize_t ZSTD_compressBlock_greedy(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0, ZSTD_noDict);\n}\n\nsize_t ZSTD_compressBlock_greedy_dictMatchState(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0, ZSTD_dictMatchState);\n}\n\nsize_t ZSTD_compressBlock_greedy_dedicatedDictSearch(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0, ZSTD_dedicatedDictSearch);\n}\n\nsize_t ZSTD_compressBlock_greedy_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 0, ZSTD_noDict);\n}\n\nsize_t ZSTD_compressBlock_greedy_dictMatchState_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 0, ZSTD_dictMatchState);\n}\n\nsize_t ZSTD_compressBlock_greedy_dedicatedDictSearch_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 0, ZSTD_dedicatedDictSearch);\n}\n#endif\n\n#ifndef ZSTD_EXCLUDE_LAZY_BLOCK_COMPRESSOR\nsize_t ZSTD_compressBlock_lazy(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1, ZSTD_noDict);\n}\n\nsize_t ZSTD_compressBlock_lazy_dictMatchState(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1, ZSTD_dictMatchState);\n}\n\nsize_t ZSTD_compressBlock_lazy_dedicatedDictSearch(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1, ZSTD_dedicatedDictSearch);\n}\n\nsize_t ZSTD_compressBlock_lazy_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 1, ZSTD_noDict);\n}\n\nsize_t ZSTD_compressBlock_lazy_dictMatchState_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 1, ZSTD_dictMatchState);\n}\n\nsize_t ZSTD_compressBlock_lazy_dedicatedDictSearch_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 1, ZSTD_dedicatedDictSearch);\n}\n#endif\n\n#ifndef ZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR\nsize_t ZSTD_compressBlock_lazy2(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2, ZSTD_noDict);\n}\n\nsize_t ZSTD_compressBlock_lazy2_dictMatchState(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2, ZSTD_dictMatchState);\n}\n\nsize_t ZSTD_compressBlock_lazy2_dedicatedDictSearch(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2, ZSTD_dedicatedDictSearch);\n}\n\nsize_t ZSTD_compressBlock_lazy2_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 2, ZSTD_noDict);\n}\n\nsize_t ZSTD_compressBlock_lazy2_dictMatchState_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 2, ZSTD_dictMatchState);\n}\n\nsize_t ZSTD_compressBlock_lazy2_dedicatedDictSearch_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 2, ZSTD_dedicatedDictSearch);\n}\n#endif\n\n#ifndef ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR\nsize_t ZSTD_compressBlock_btlazy2(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_binaryTree, 2, ZSTD_noDict);\n}\n\nsize_t ZSTD_compressBlock_btlazy2_dictMatchState(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_generic(ms, seqStore, rep, src, srcSize, search_binaryTree, 2, ZSTD_dictMatchState);\n}\n#endif\n\n#if !defined(ZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR) \\\n || !defined(ZSTD_EXCLUDE_LAZY_BLOCK_COMPRESSOR) \\\n || !defined(ZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR) \\\n || !defined(ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR)\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_compressBlock_lazy_extDict_generic(\n                        ZSTD_MatchState_t* ms, SeqStore_t* seqStore,\n                        U32 rep[ZSTD_REP_NUM],\n                        const void* src, size_t srcSize,\n                        const searchMethod_e searchMethod, const U32 depth)\n{\n    const BYTE* const istart = (const BYTE*)src;\n    const BYTE* ip = istart;\n    const BYTE* anchor = istart;\n    const BYTE* const iend = istart + srcSize;\n    const BYTE* const ilimit = searchMethod == search_rowHash ? iend - 8 - ZSTD_ROW_HASH_CACHE_SIZE : iend - 8;\n    const BYTE* const base = ms->window.base;\n    const U32 dictLimit = ms->window.dictLimit;\n    const BYTE* const prefixStart = base + dictLimit;\n    const BYTE* const dictBase = ms->window.dictBase;\n    const BYTE* const dictEnd  = dictBase + dictLimit;\n    const BYTE* const dictStart  = dictBase + ms->window.lowLimit;\n    const U32 windowLog = ms->cParams.windowLog;\n    const U32 mls = BOUNDED(4, ms->cParams.minMatch, 6);\n    const U32 rowLog = BOUNDED(4, ms->cParams.searchLog, 6);\n\n    U32 offset_1 = rep[0], offset_2 = rep[1];\n\n    DEBUGLOG(5, \"ZSTD_compressBlock_lazy_extDict_generic (searchFunc=%u)\", (U32)searchMethod);\n\n    /* Reset the lazy skipping state */\n    ms->lazySkipping = 0;\n\n    /* init */\n    ip += (ip == prefixStart);\n    if (searchMethod == search_rowHash) {\n        ZSTD_row_fillHashCache(ms, base, rowLog, mls, ms->nextToUpdate, ilimit);\n    }\n\n    /* Match Loop */\n#if defined(__GNUC__) && defined(__x86_64__)\n    /* I've measured random a 5% speed loss on levels 5 & 6 (greedy) when the\n     * code alignment is perturbed. To fix the instability align the loop on 32-bytes.\n     */\n    __asm__(\".p2align 5\");\n#endif\n    while (ip < ilimit) {\n        size_t matchLength=0;\n        size_t offBase = REPCODE1_TO_OFFBASE;\n        const BYTE* start=ip+1;\n        U32 curr = (U32)(ip-base);\n\n        /* check repCode */\n        {   const U32 windowLow = ZSTD_getLowestMatchIndex(ms, curr+1, windowLog);\n            const U32 repIndex = (U32)(curr+1 - offset_1);\n            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;\n            const BYTE* const repMatch = repBase + repIndex;\n            if ( (ZSTD_index_overlap_check(dictLimit, repIndex))\n               & (offset_1 <= curr+1 - windowLow) ) /* note: we are searching at curr+1 */\n            if (MEM_read32(ip+1) == MEM_read32(repMatch)) {\n                /* repcode detected we should take it */\n                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;\n                matchLength = ZSTD_count_2segments(ip+1+4, repMatch+4, iend, repEnd, prefixStart) + 4;\n                if (depth==0) goto _storeSequence;\n        }   }\n\n        /* first search (depth 0) */\n        {   size_t ofbCandidate = 999999999;\n            size_t const ml2 = ZSTD_searchMax(ms, ip, iend, &ofbCandidate, mls, rowLog, searchMethod, ZSTD_extDict);\n            if (ml2 > matchLength)\n                matchLength = ml2, start = ip, offBase = ofbCandidate;\n        }\n\n        if (matchLength < 4) {\n            size_t const step = ((size_t)(ip-anchor) >> kSearchStrength);\n            ip += step + 1;   /* jump faster over incompressible sections */\n            /* Enter the lazy skipping mode once we are skipping more than 8 bytes at a time.\n             * In this mode we stop inserting every position into our tables, and only insert\n             * positions that we search, which is one in step positions.\n             * The exact cutoff is flexible, I've just chosen a number that is reasonably high,\n             * so we minimize the compression ratio loss in \"normal\" scenarios. This mode gets\n             * triggered once we've gone 2KB without finding any matches.\n             */\n            ms->lazySkipping = step > kLazySkippingStep;\n            continue;\n        }\n\n        /* let's try to find a better solution */\n        if (depth>=1)\n        while (ip repIndex >= windowLow` */\n                if (MEM_read32(ip) == MEM_read32(repMatch)) {\n                    /* repcode detected */\n                    const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;\n                    size_t const repLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;\n                    int const gain2 = (int)(repLength * 3);\n                    int const gain1 = (int)(matchLength*3 - ZSTD_highbit32((U32)offBase) + 1);\n                    if ((repLength >= 4) && (gain2 > gain1))\n                        matchLength = repLength, offBase = REPCODE1_TO_OFFBASE, start = ip;\n            }   }\n\n            /* search match, depth 1 */\n            {   size_t ofbCandidate = 999999999;\n                size_t const ml2 = ZSTD_searchMax(ms, ip, iend, &ofbCandidate, mls, rowLog, searchMethod, ZSTD_extDict);\n                int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)ofbCandidate));   /* raw approx */\n                int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offBase) + 4);\n                if ((ml2 >= 4) && (gain2 > gain1)) {\n                    matchLength = ml2, offBase = ofbCandidate, start = ip;\n                    continue;   /* search a better one */\n            }   }\n\n            /* let's find an even better one */\n            if ((depth==2) && (ip repIndex >= windowLow` */\n                    if (MEM_read32(ip) == MEM_read32(repMatch)) {\n                        /* repcode detected */\n                        const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;\n                        size_t const repLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;\n                        int const gain2 = (int)(repLength * 4);\n                        int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offBase) + 1);\n                        if ((repLength >= 4) && (gain2 > gain1))\n                            matchLength = repLength, offBase = REPCODE1_TO_OFFBASE, start = ip;\n                }   }\n\n                /* search match, depth 2 */\n                {   size_t ofbCandidate = 999999999;\n                    size_t const ml2 = ZSTD_searchMax(ms, ip, iend, &ofbCandidate, mls, rowLog, searchMethod, ZSTD_extDict);\n                    int const gain2 = (int)(ml2*4 - ZSTD_highbit32((U32)ofbCandidate));   /* raw approx */\n                    int const gain1 = (int)(matchLength*4 - ZSTD_highbit32((U32)offBase) + 7);\n                    if ((ml2 >= 4) && (gain2 > gain1)) {\n                        matchLength = ml2, offBase = ofbCandidate, start = ip;\n                        continue;\n            }   }   }\n            break;  /* nothing found : store previous solution */\n        }\n\n        /* catch up */\n        if (OFFBASE_IS_OFFSET(offBase)) {\n            U32 const matchIndex = (U32)((size_t)(start-base) - OFFBASE_TO_OFFSET(offBase));\n            const BYTE* match = (matchIndex < dictLimit) ? dictBase + matchIndex : base + matchIndex;\n            const BYTE* const mStart = (matchIndex < dictLimit) ? dictStart : prefixStart;\n            while ((start>anchor) && (match>mStart) && (start[-1] == match[-1])) { start--; match--; matchLength++; }  /* catch up */\n            offset_2 = offset_1; offset_1 = (U32)OFFBASE_TO_OFFSET(offBase);\n        }\n\n        /* store sequence */\n_storeSequence:\n        {   size_t const litLength = (size_t)(start - anchor);\n            ZSTD_storeSeq(seqStore, litLength, anchor, iend, (U32)offBase, matchLength);\n            anchor = ip = start + matchLength;\n        }\n        if (ms->lazySkipping) {\n            /* We've found a match, disable lazy skipping mode, and refill the hash cache. */\n            if (searchMethod == search_rowHash) {\n                ZSTD_row_fillHashCache(ms, base, rowLog, mls, ms->nextToUpdate, ilimit);\n            }\n            ms->lazySkipping = 0;\n        }\n\n        /* check immediate repcode */\n        while (ip <= ilimit) {\n            const U32 repCurrent = (U32)(ip-base);\n            const U32 windowLow = ZSTD_getLowestMatchIndex(ms, repCurrent, windowLog);\n            const U32 repIndex = repCurrent - offset_2;\n            const BYTE* const repBase = repIndex < dictLimit ? dictBase : base;\n            const BYTE* const repMatch = repBase + repIndex;\n            if ( (ZSTD_index_overlap_check(dictLimit, repIndex))\n               & (offset_2 <= repCurrent - windowLow) ) /* equivalent to `curr > repIndex >= windowLow` */\n            if (MEM_read32(ip) == MEM_read32(repMatch)) {\n                /* repcode detected we should take it */\n                const BYTE* const repEnd = repIndex < dictLimit ? dictEnd : iend;\n                matchLength = ZSTD_count_2segments(ip+4, repMatch+4, iend, repEnd, prefixStart) + 4;\n                offBase = offset_2; offset_2 = offset_1; offset_1 = (U32)offBase;   /* swap offset history */\n                ZSTD_storeSeq(seqStore, 0, anchor, iend, REPCODE1_TO_OFFBASE, matchLength);\n                ip += matchLength;\n                anchor = ip;\n                continue;   /* faster when present ... (?) */\n            }\n            break;\n    }   }\n\n    /* Save reps for next block */\n    rep[0] = offset_1;\n    rep[1] = offset_2;\n\n    /* Return the last literals size */\n    return (size_t)(iend - anchor);\n}\n#endif /* build exclusions */\n\n#ifndef ZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR\nsize_t ZSTD_compressBlock_greedy_extDict(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 0);\n}\n\nsize_t ZSTD_compressBlock_greedy_extDict_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 0);\n}\n#endif\n\n#ifndef ZSTD_EXCLUDE_LAZY_BLOCK_COMPRESSOR\nsize_t ZSTD_compressBlock_lazy_extDict(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n\n{\n    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 1);\n}\n\nsize_t ZSTD_compressBlock_lazy_extDict_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n\n{\n    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 1);\n}\n#endif\n\n#ifndef ZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR\nsize_t ZSTD_compressBlock_lazy2_extDict(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n\n{\n    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_hashChain, 2);\n}\n\nsize_t ZSTD_compressBlock_lazy2_extDict_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_rowHash, 2);\n}\n#endif\n\n#ifndef ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR\nsize_t ZSTD_compressBlock_btlazy2_extDict(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize)\n\n{\n    return ZSTD_compressBlock_lazy_extDict_generic(ms, seqStore, rep, src, srcSize, search_binaryTree, 2);\n}\n#endif\n"
  },
  {
    "path": "lib/compress/zstd_lazy.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_LAZY_H\n#define ZSTD_LAZY_H\n\n#include \"zstd_compress_internal.h\"\n\n/**\n * Dedicated Dictionary Search Structure bucket log. In the\n * ZSTD_dedicatedDictSearch mode, the hashTable has\n * 2 ** ZSTD_LAZY_DDSS_BUCKET_LOG entries in each bucket, rather than just\n * one.\n */\n#define ZSTD_LAZY_DDSS_BUCKET_LOG 2\n\n#define ZSTD_ROW_HASH_TAG_BITS 8        /* nb bits to use for the tag */\n\n#if !defined(ZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR) \\\n || !defined(ZSTD_EXCLUDE_LAZY_BLOCK_COMPRESSOR) \\\n || !defined(ZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR) \\\n || !defined(ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR)\nU32 ZSTD_insertAndFindFirstIndex(ZSTD_MatchState_t* ms, const BYTE* ip);\nvoid ZSTD_row_update(ZSTD_MatchState_t* const ms, const BYTE* ip);\n\nvoid ZSTD_dedicatedDictSearch_lazy_loadDictionary(ZSTD_MatchState_t* ms, const BYTE* const ip);\n\nvoid ZSTD_preserveUnsortedMark (U32* const table, U32 const size, U32 const reducerValue);  /*! used in ZSTD_reduceIndex(). preemptively increase value of ZSTD_DUBT_UNSORTED_MARK */\n#endif\n\n#ifndef ZSTD_EXCLUDE_GREEDY_BLOCK_COMPRESSOR\nsize_t ZSTD_compressBlock_greedy(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_greedy_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_greedy_dictMatchState(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_greedy_dictMatchState_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_greedy_dedicatedDictSearch(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_greedy_dedicatedDictSearch_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_greedy_extDict(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_greedy_extDict_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\n\n#define ZSTD_COMPRESSBLOCK_GREEDY ZSTD_compressBlock_greedy\n#define ZSTD_COMPRESSBLOCK_GREEDY_ROW ZSTD_compressBlock_greedy_row\n#define ZSTD_COMPRESSBLOCK_GREEDY_DICTMATCHSTATE ZSTD_compressBlock_greedy_dictMatchState\n#define ZSTD_COMPRESSBLOCK_GREEDY_DICTMATCHSTATE_ROW ZSTD_compressBlock_greedy_dictMatchState_row\n#define ZSTD_COMPRESSBLOCK_GREEDY_DEDICATEDDICTSEARCH ZSTD_compressBlock_greedy_dedicatedDictSearch\n#define ZSTD_COMPRESSBLOCK_GREEDY_DEDICATEDDICTSEARCH_ROW ZSTD_compressBlock_greedy_dedicatedDictSearch_row\n#define ZSTD_COMPRESSBLOCK_GREEDY_EXTDICT ZSTD_compressBlock_greedy_extDict\n#define ZSTD_COMPRESSBLOCK_GREEDY_EXTDICT_ROW ZSTD_compressBlock_greedy_extDict_row\n#else\n#define ZSTD_COMPRESSBLOCK_GREEDY NULL\n#define ZSTD_COMPRESSBLOCK_GREEDY_ROW NULL\n#define ZSTD_COMPRESSBLOCK_GREEDY_DICTMATCHSTATE NULL\n#define ZSTD_COMPRESSBLOCK_GREEDY_DICTMATCHSTATE_ROW NULL\n#define ZSTD_COMPRESSBLOCK_GREEDY_DEDICATEDDICTSEARCH NULL\n#define ZSTD_COMPRESSBLOCK_GREEDY_DEDICATEDDICTSEARCH_ROW NULL\n#define ZSTD_COMPRESSBLOCK_GREEDY_EXTDICT NULL\n#define ZSTD_COMPRESSBLOCK_GREEDY_EXTDICT_ROW NULL\n#endif\n\n#ifndef ZSTD_EXCLUDE_LAZY_BLOCK_COMPRESSOR\nsize_t ZSTD_compressBlock_lazy(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_lazy_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_lazy_dictMatchState(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_lazy_dictMatchState_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_lazy_dedicatedDictSearch(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_lazy_dedicatedDictSearch_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_lazy_extDict(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_lazy_extDict_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\n\n#define ZSTD_COMPRESSBLOCK_LAZY ZSTD_compressBlock_lazy\n#define ZSTD_COMPRESSBLOCK_LAZY_ROW ZSTD_compressBlock_lazy_row\n#define ZSTD_COMPRESSBLOCK_LAZY_DICTMATCHSTATE ZSTD_compressBlock_lazy_dictMatchState\n#define ZSTD_COMPRESSBLOCK_LAZY_DICTMATCHSTATE_ROW ZSTD_compressBlock_lazy_dictMatchState_row\n#define ZSTD_COMPRESSBLOCK_LAZY_DEDICATEDDICTSEARCH ZSTD_compressBlock_lazy_dedicatedDictSearch\n#define ZSTD_COMPRESSBLOCK_LAZY_DEDICATEDDICTSEARCH_ROW ZSTD_compressBlock_lazy_dedicatedDictSearch_row\n#define ZSTD_COMPRESSBLOCK_LAZY_EXTDICT ZSTD_compressBlock_lazy_extDict\n#define ZSTD_COMPRESSBLOCK_LAZY_EXTDICT_ROW ZSTD_compressBlock_lazy_extDict_row\n#else\n#define ZSTD_COMPRESSBLOCK_LAZY NULL\n#define ZSTD_COMPRESSBLOCK_LAZY_ROW NULL\n#define ZSTD_COMPRESSBLOCK_LAZY_DICTMATCHSTATE NULL\n#define ZSTD_COMPRESSBLOCK_LAZY_DICTMATCHSTATE_ROW NULL\n#define ZSTD_COMPRESSBLOCK_LAZY_DEDICATEDDICTSEARCH NULL\n#define ZSTD_COMPRESSBLOCK_LAZY_DEDICATEDDICTSEARCH_ROW NULL\n#define ZSTD_COMPRESSBLOCK_LAZY_EXTDICT NULL\n#define ZSTD_COMPRESSBLOCK_LAZY_EXTDICT_ROW NULL\n#endif\n\n#ifndef ZSTD_EXCLUDE_LAZY2_BLOCK_COMPRESSOR\nsize_t ZSTD_compressBlock_lazy2(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_lazy2_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_lazy2_dictMatchState(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_lazy2_dictMatchState_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_lazy2_dedicatedDictSearch(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_lazy2_dedicatedDictSearch_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_lazy2_extDict(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_lazy2_extDict_row(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\n\n#define ZSTD_COMPRESSBLOCK_LAZY2 ZSTD_compressBlock_lazy2\n#define ZSTD_COMPRESSBLOCK_LAZY2_ROW ZSTD_compressBlock_lazy2_row\n#define ZSTD_COMPRESSBLOCK_LAZY2_DICTMATCHSTATE ZSTD_compressBlock_lazy2_dictMatchState\n#define ZSTD_COMPRESSBLOCK_LAZY2_DICTMATCHSTATE_ROW ZSTD_compressBlock_lazy2_dictMatchState_row\n#define ZSTD_COMPRESSBLOCK_LAZY2_DEDICATEDDICTSEARCH ZSTD_compressBlock_lazy2_dedicatedDictSearch\n#define ZSTD_COMPRESSBLOCK_LAZY2_DEDICATEDDICTSEARCH_ROW ZSTD_compressBlock_lazy2_dedicatedDictSearch_row\n#define ZSTD_COMPRESSBLOCK_LAZY2_EXTDICT ZSTD_compressBlock_lazy2_extDict\n#define ZSTD_COMPRESSBLOCK_LAZY2_EXTDICT_ROW ZSTD_compressBlock_lazy2_extDict_row\n#else\n#define ZSTD_COMPRESSBLOCK_LAZY2 NULL\n#define ZSTD_COMPRESSBLOCK_LAZY2_ROW NULL\n#define ZSTD_COMPRESSBLOCK_LAZY2_DICTMATCHSTATE NULL\n#define ZSTD_COMPRESSBLOCK_LAZY2_DICTMATCHSTATE_ROW NULL\n#define ZSTD_COMPRESSBLOCK_LAZY2_DEDICATEDDICTSEARCH NULL\n#define ZSTD_COMPRESSBLOCK_LAZY2_DEDICATEDDICTSEARCH_ROW NULL\n#define ZSTD_COMPRESSBLOCK_LAZY2_EXTDICT NULL\n#define ZSTD_COMPRESSBLOCK_LAZY2_EXTDICT_ROW NULL\n#endif\n\n#ifndef ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR\nsize_t ZSTD_compressBlock_btlazy2(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_btlazy2_dictMatchState(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_btlazy2_extDict(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\n\n#define ZSTD_COMPRESSBLOCK_BTLAZY2 ZSTD_compressBlock_btlazy2\n#define ZSTD_COMPRESSBLOCK_BTLAZY2_DICTMATCHSTATE ZSTD_compressBlock_btlazy2_dictMatchState\n#define ZSTD_COMPRESSBLOCK_BTLAZY2_EXTDICT ZSTD_compressBlock_btlazy2_extDict\n#else\n#define ZSTD_COMPRESSBLOCK_BTLAZY2 NULL\n#define ZSTD_COMPRESSBLOCK_BTLAZY2_DICTMATCHSTATE NULL\n#define ZSTD_COMPRESSBLOCK_BTLAZY2_EXTDICT NULL\n#endif\n\n#endif /* ZSTD_LAZY_H */\n"
  },
  {
    "path": "lib/compress/zstd_ldm.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#include \"zstd_ldm.h\"\n\n#include \"../common/debug.h\"\n#include \"../common/xxhash.h\"\n#include \"zstd_fast.h\"          /* ZSTD_fillHashTable() */\n#include \"zstd_double_fast.h\"   /* ZSTD_fillDoubleHashTable() */\n#include \"zstd_ldm_geartab.h\"\n\n#define LDM_BUCKET_SIZE_LOG 4\n#define LDM_MIN_MATCH_LENGTH 64\n#define LDM_HASH_RLOG 7\n\ntypedef struct {\n    U64 rolling;\n    U64 stopMask;\n} ldmRollingHashState_t;\n\n/** ZSTD_ldm_gear_init():\n *\n * Initializes the rolling hash state such that it will honor the\n * settings in params. */\nstatic void ZSTD_ldm_gear_init(ldmRollingHashState_t* state, ldmParams_t const* params)\n{\n    unsigned maxBitsInMask = MIN(params->minMatchLength, 64);\n    unsigned hashRateLog = params->hashRateLog;\n\n    state->rolling = ~(U32)0;\n\n    /* The choice of the splitting criterion is subject to two conditions:\n     *   1. it has to trigger on average every 2^(hashRateLog) bytes;\n     *   2. ideally, it has to depend on a window of minMatchLength bytes.\n     *\n     * In the gear hash algorithm, bit n depends on the last n bytes;\n     * so in order to obtain a good quality splitting criterion it is\n     * preferable to use bits with high weight.\n     *\n     * To match condition 1 we use a mask with hashRateLog bits set\n     * and, because of the previous remark, we make sure these bits\n     * have the highest possible weight while still respecting\n     * condition 2.\n     */\n    if (hashRateLog > 0 && hashRateLog <= maxBitsInMask) {\n        state->stopMask = (((U64)1 << hashRateLog) - 1) << (maxBitsInMask - hashRateLog);\n    } else {\n        /* In this degenerate case we simply honor the hash rate. */\n        state->stopMask = ((U64)1 << hashRateLog) - 1;\n    }\n}\n\n/** ZSTD_ldm_gear_reset()\n * Feeds [data, data + minMatchLength) into the hash without registering any\n * splits. This effectively resets the hash state. This is used when skipping\n * over data, either at the beginning of a block, or skipping sections.\n */\nstatic void ZSTD_ldm_gear_reset(ldmRollingHashState_t* state,\n                                BYTE const* data, size_t minMatchLength)\n{\n    U64 hash = state->rolling;\n    size_t n = 0;\n\n#define GEAR_ITER_ONCE() do {                                  \\\n        hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff]; \\\n        n += 1;                                                \\\n    } while (0)\n    while (n + 3 < minMatchLength) {\n        GEAR_ITER_ONCE();\n        GEAR_ITER_ONCE();\n        GEAR_ITER_ONCE();\n        GEAR_ITER_ONCE();\n    }\n    while (n < minMatchLength) {\n        GEAR_ITER_ONCE();\n    }\n#undef GEAR_ITER_ONCE\n}\n\n/** ZSTD_ldm_gear_feed():\n *\n * Registers in the splits array all the split points found in the first\n * size bytes following the data pointer. This function terminates when\n * either all the data has been processed or LDM_BATCH_SIZE splits are\n * present in the splits array.\n *\n * Precondition: The splits array must not be full.\n * Returns: The number of bytes processed. */\nstatic size_t ZSTD_ldm_gear_feed(ldmRollingHashState_t* state,\n                                 BYTE const* data, size_t size,\n                                 size_t* splits, unsigned* numSplits)\n{\n    size_t n;\n    U64 hash, mask;\n\n    hash = state->rolling;\n    mask = state->stopMask;\n    n = 0;\n\n#define GEAR_ITER_ONCE() do { \\\n        hash = (hash << 1) + ZSTD_ldm_gearTab[data[n] & 0xff]; \\\n        n += 1; \\\n        if (UNLIKELY((hash & mask) == 0)) { \\\n            splits[*numSplits] = n; \\\n            *numSplits += 1; \\\n            if (*numSplits == LDM_BATCH_SIZE) \\\n                goto done; \\\n        } \\\n    } while (0)\n\n    while (n + 3 < size) {\n        GEAR_ITER_ONCE();\n        GEAR_ITER_ONCE();\n        GEAR_ITER_ONCE();\n        GEAR_ITER_ONCE();\n    }\n    while (n < size) {\n        GEAR_ITER_ONCE();\n    }\n\n#undef GEAR_ITER_ONCE\n\ndone:\n    state->rolling = hash;\n    return n;\n}\n\nvoid ZSTD_ldm_adjustParameters(ldmParams_t* params,\n                        const ZSTD_compressionParameters* cParams)\n{\n    params->windowLog = cParams->windowLog;\n    ZSTD_STATIC_ASSERT(LDM_BUCKET_SIZE_LOG <= ZSTD_LDM_BUCKETSIZELOG_MAX);\n    DEBUGLOG(4, \"ZSTD_ldm_adjustParameters\");\n    if (params->hashRateLog == 0) {\n        if (params->hashLog > 0) {\n            /* if params->hashLog is set, derive hashRateLog from it */\n            assert(params->hashLog <= ZSTD_HASHLOG_MAX);\n            if (params->windowLog > params->hashLog) {\n                params->hashRateLog = params->windowLog - params->hashLog;\n            }\n        } else {\n            assert(1 <= (int)cParams->strategy && (int)cParams->strategy <= 9);\n            /* mapping from [fast, rate7] to [btultra2, rate4] */\n            params->hashRateLog = 7 - (cParams->strategy/3);\n        }\n    }\n    if (params->hashLog == 0) {\n        if (params->windowLog <= params->hashRateLog) {\n            params->hashLog = ZSTD_HASHLOG_MIN;\n        } else {\n            params->hashLog = BOUNDED(ZSTD_HASHLOG_MIN, params->windowLog - params->hashRateLog, ZSTD_HASHLOG_MAX);\n        }\n    }\n    if (params->minMatchLength == 0) {\n        params->minMatchLength = LDM_MIN_MATCH_LENGTH;\n        if (cParams->strategy >= ZSTD_btultra)\n            params->minMatchLength /= 2;\n    }\n    if (params->bucketSizeLog==0) {\n        assert(1 <= (int)cParams->strategy && (int)cParams->strategy <= 9);\n        params->bucketSizeLog = BOUNDED(LDM_BUCKET_SIZE_LOG, (U32)cParams->strategy, ZSTD_LDM_BUCKETSIZELOG_MAX);\n    }\n    params->bucketSizeLog = MIN(params->bucketSizeLog, params->hashLog);\n}\n\nsize_t ZSTD_ldm_getTableSize(ldmParams_t params)\n{\n    size_t const ldmHSize = ((size_t)1) << params.hashLog;\n    size_t const ldmBucketSizeLog = MIN(params.bucketSizeLog, params.hashLog);\n    size_t const ldmBucketSize = ((size_t)1) << (params.hashLog - ldmBucketSizeLog);\n    size_t const totalSize = ZSTD_cwksp_alloc_size(ldmBucketSize)\n                           + ZSTD_cwksp_alloc_size(ldmHSize * sizeof(ldmEntry_t));\n    return params.enableLdm == ZSTD_ps_enable ? totalSize : 0;\n}\n\nsize_t ZSTD_ldm_getMaxNbSeq(ldmParams_t params, size_t maxChunkSize)\n{\n    return params.enableLdm == ZSTD_ps_enable ? (maxChunkSize / params.minMatchLength) : 0;\n}\n\n/** ZSTD_ldm_getBucket() :\n *  Returns a pointer to the start of the bucket associated with hash. */\nstatic ldmEntry_t* ZSTD_ldm_getBucket(\n        const ldmState_t* ldmState, size_t hash, U32 const bucketSizeLog)\n{\n    return ldmState->hashTable + (hash << bucketSizeLog);\n}\n\n/** ZSTD_ldm_insertEntry() :\n *  Insert the entry with corresponding hash into the hash table */\nstatic void ZSTD_ldm_insertEntry(ldmState_t* ldmState,\n                                 size_t const hash, const ldmEntry_t entry,\n                                 U32 const bucketSizeLog)\n{\n    BYTE* const pOffset = ldmState->bucketOffsets + hash;\n    unsigned const offset = *pOffset;\n\n    *(ZSTD_ldm_getBucket(ldmState, hash, bucketSizeLog) + offset) = entry;\n    *pOffset = (BYTE)((offset + 1) & ((1u << bucketSizeLog) - 1));\n\n}\n\n/** ZSTD_ldm_countBackwardsMatch() :\n *  Returns the number of bytes that match backwards before pIn and pMatch.\n *\n *  We count only bytes where pMatch >= pBase and pIn >= pAnchor. */\nstatic size_t ZSTD_ldm_countBackwardsMatch(\n            const BYTE* pIn, const BYTE* pAnchor,\n            const BYTE* pMatch, const BYTE* pMatchBase)\n{\n    size_t matchLength = 0;\n    while (pIn > pAnchor && pMatch > pMatchBase && pIn[-1] == pMatch[-1]) {\n        pIn--;\n        pMatch--;\n        matchLength++;\n    }\n    return matchLength;\n}\n\n/** ZSTD_ldm_countBackwardsMatch_2segments() :\n *  Returns the number of bytes that match backwards from pMatch,\n *  even with the backwards match spanning 2 different segments.\n *\n *  On reaching `pMatchBase`, start counting from mEnd */\nstatic size_t ZSTD_ldm_countBackwardsMatch_2segments(\n                    const BYTE* pIn, const BYTE* pAnchor,\n                    const BYTE* pMatch, const BYTE* pMatchBase,\n                    const BYTE* pExtDictStart, const BYTE* pExtDictEnd)\n{\n    size_t matchLength = ZSTD_ldm_countBackwardsMatch(pIn, pAnchor, pMatch, pMatchBase);\n    if (pMatch - matchLength != pMatchBase || pMatchBase == pExtDictStart) {\n        /* If backwards match is entirely in the extDict or prefix, immediately return */\n        return matchLength;\n    }\n    DEBUGLOG(7, \"ZSTD_ldm_countBackwardsMatch_2segments: found 2-parts backwards match (length in prefix==%zu)\", matchLength);\n    matchLength += ZSTD_ldm_countBackwardsMatch(pIn - matchLength, pAnchor, pExtDictEnd, pExtDictStart);\n    DEBUGLOG(7, \"final backwards match length = %zu\", matchLength);\n    return matchLength;\n}\n\n/** ZSTD_ldm_fillFastTables() :\n *\n *  Fills the relevant tables for the ZSTD_fast and ZSTD_dfast strategies.\n *  This is similar to ZSTD_loadDictionaryContent.\n *\n *  The tables for the other strategies are filled within their\n *  block compressors. */\nstatic size_t ZSTD_ldm_fillFastTables(ZSTD_MatchState_t* ms,\n                                      void const* end)\n{\n    const BYTE* const iend = (const BYTE*)end;\n\n    switch(ms->cParams.strategy)\n    {\n    case ZSTD_fast:\n        ZSTD_fillHashTable(ms, iend, ZSTD_dtlm_fast, ZSTD_tfp_forCCtx);\n        break;\n\n    case ZSTD_dfast:\n#ifndef ZSTD_EXCLUDE_DFAST_BLOCK_COMPRESSOR\n        ZSTD_fillDoubleHashTable(ms, iend, ZSTD_dtlm_fast, ZSTD_tfp_forCCtx);\n#else\n        assert(0); /* shouldn't be called: cparams should've been adjusted. */\n#endif\n        break;\n\n    case ZSTD_greedy:\n    case ZSTD_lazy:\n    case ZSTD_lazy2:\n    case ZSTD_btlazy2:\n    case ZSTD_btopt:\n    case ZSTD_btultra:\n    case ZSTD_btultra2:\n        break;\n    default:\n        assert(0);  /* not possible : not a valid strategy id */\n    }\n\n    return 0;\n}\n\nvoid ZSTD_ldm_fillHashTable(\n            ldmState_t* ldmState, const BYTE* ip,\n            const BYTE* iend, ldmParams_t const* params)\n{\n    U32 const minMatchLength = params->minMatchLength;\n    U32 const bucketSizeLog = params->bucketSizeLog;\n    U32 const hBits = params->hashLog - bucketSizeLog;\n    BYTE const* const base = ldmState->window.base;\n    BYTE const* const istart = ip;\n    ldmRollingHashState_t hashState;\n    size_t* const splits = ldmState->splitIndices;\n    unsigned numSplits;\n\n    DEBUGLOG(5, \"ZSTD_ldm_fillHashTable\");\n\n    ZSTD_ldm_gear_init(&hashState, params);\n    while (ip < iend) {\n        size_t hashed;\n        unsigned n;\n\n        numSplits = 0;\n        hashed = ZSTD_ldm_gear_feed(&hashState, ip, (size_t)(iend - ip), splits, &numSplits);\n\n        for (n = 0; n < numSplits; n++) {\n            if (ip + splits[n] >= istart + minMatchLength) {\n                BYTE const* const split = ip + splits[n] - minMatchLength;\n                U64 const xxhash = XXH64(split, minMatchLength, 0);\n                U32 const hash = (U32)(xxhash & (((U32)1 << hBits) - 1));\n                ldmEntry_t entry;\n\n                entry.offset = (U32)(split - base);\n                entry.checksum = (U32)(xxhash >> 32);\n                ZSTD_ldm_insertEntry(ldmState, hash, entry, params->bucketSizeLog);\n            }\n        }\n\n        ip += hashed;\n    }\n}\n\n\n/** ZSTD_ldm_limitTableUpdate() :\n *\n *  Sets cctx->nextToUpdate to a position corresponding closer to anchor\n *  if it is far way\n *  (after a long match, only update tables a limited amount). */\nstatic void ZSTD_ldm_limitTableUpdate(ZSTD_MatchState_t* ms, const BYTE* anchor)\n{\n    U32 const curr = (U32)(anchor - ms->window.base);\n    if (curr > ms->nextToUpdate + 1024) {\n        ms->nextToUpdate =\n            curr - MIN(512, curr - ms->nextToUpdate - 1024);\n    }\n}\n\nstatic\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_ldm_generateSequences_internal(\n        ldmState_t* ldmState, RawSeqStore_t* rawSeqStore,\n        ldmParams_t const* params, void const* src, size_t srcSize)\n{\n    /* LDM parameters */\n    int const extDict = ZSTD_window_hasExtDict(ldmState->window);\n    U32 const minMatchLength = params->minMatchLength;\n    U32 const entsPerBucket = 1U << params->bucketSizeLog;\n    U32 const hBits = params->hashLog - params->bucketSizeLog;\n    /* Prefix and extDict parameters */\n    U32 const dictLimit = ldmState->window.dictLimit;\n    U32 const lowestIndex = extDict ? ldmState->window.lowLimit : dictLimit;\n    BYTE const* const base = ldmState->window.base;\n    BYTE const* const dictBase = extDict ? ldmState->window.dictBase : NULL;\n    BYTE const* const dictStart = extDict ? dictBase + lowestIndex : NULL;\n    BYTE const* const dictEnd = extDict ? dictBase + dictLimit : NULL;\n    BYTE const* const lowPrefixPtr = base + dictLimit;\n    /* Input bounds */\n    BYTE const* const istart = (BYTE const*)src;\n    BYTE const* const iend = istart + srcSize;\n    BYTE const* const ilimit = iend - HASH_READ_SIZE;\n    /* Input positions */\n    BYTE const* anchor = istart;\n    BYTE const* ip = istart;\n    /* Rolling hash state */\n    ldmRollingHashState_t hashState;\n    /* Arrays for staged-processing */\n    size_t* const splits = ldmState->splitIndices;\n    ldmMatchCandidate_t* const candidates = ldmState->matchCandidates;\n    unsigned numSplits;\n\n    if (srcSize < minMatchLength)\n        return iend - anchor;\n\n    /* Initialize the rolling hash state with the first minMatchLength bytes */\n    ZSTD_ldm_gear_init(&hashState, params);\n    ZSTD_ldm_gear_reset(&hashState, ip, minMatchLength);\n    ip += minMatchLength;\n\n    while (ip < ilimit) {\n        size_t hashed;\n        unsigned n;\n\n        numSplits = 0;\n        hashed = ZSTD_ldm_gear_feed(&hashState, ip, ilimit - ip,\n                                    splits, &numSplits);\n\n        for (n = 0; n < numSplits; n++) {\n            BYTE const* const split = ip + splits[n] - minMatchLength;\n            U64 const xxhash = XXH64(split, minMatchLength, 0);\n            U32 const hash = (U32)(xxhash & (((U32)1 << hBits) - 1));\n\n            candidates[n].split = split;\n            candidates[n].hash = hash;\n            candidates[n].checksum = (U32)(xxhash >> 32);\n            candidates[n].bucket = ZSTD_ldm_getBucket(ldmState, hash, params->bucketSizeLog);\n            PREFETCH_L1(candidates[n].bucket);\n        }\n\n        for (n = 0; n < numSplits; n++) {\n            size_t forwardMatchLength = 0, backwardMatchLength = 0,\n                   bestMatchLength = 0, mLength;\n            U32 offset;\n            BYTE const* const split = candidates[n].split;\n            U32 const checksum = candidates[n].checksum;\n            U32 const hash = candidates[n].hash;\n            ldmEntry_t* const bucket = candidates[n].bucket;\n            ldmEntry_t const* cur;\n            ldmEntry_t const* bestEntry = NULL;\n            ldmEntry_t newEntry;\n\n            newEntry.offset = (U32)(split - base);\n            newEntry.checksum = checksum;\n\n            /* If a split point would generate a sequence overlapping with\n             * the previous one, we merely register it in the hash table and\n             * move on */\n            if (split < anchor) {\n                ZSTD_ldm_insertEntry(ldmState, hash, newEntry, params->bucketSizeLog);\n                continue;\n            }\n\n            for (cur = bucket; cur < bucket + entsPerBucket; cur++) {\n                size_t curForwardMatchLength, curBackwardMatchLength,\n                       curTotalMatchLength;\n                if (cur->checksum != checksum || cur->offset <= lowestIndex) {\n                    continue;\n                }\n                if (extDict) {\n                    BYTE const* const curMatchBase =\n                        cur->offset < dictLimit ? dictBase : base;\n                    BYTE const* const pMatch = curMatchBase + cur->offset;\n                    BYTE const* const matchEnd =\n                        cur->offset < dictLimit ? dictEnd : iend;\n                    BYTE const* const lowMatchPtr =\n                        cur->offset < dictLimit ? dictStart : lowPrefixPtr;\n                    curForwardMatchLength =\n                        ZSTD_count_2segments(split, pMatch, iend, matchEnd, lowPrefixPtr);\n                    if (curForwardMatchLength < minMatchLength) {\n                        continue;\n                    }\n                    curBackwardMatchLength = ZSTD_ldm_countBackwardsMatch_2segments(\n                            split, anchor, pMatch, lowMatchPtr, dictStart, dictEnd);\n                } else { /* !extDict */\n                    BYTE const* const pMatch = base + cur->offset;\n                    curForwardMatchLength = ZSTD_count(split, pMatch, iend);\n                    if (curForwardMatchLength < minMatchLength) {\n                        continue;\n                    }\n                    curBackwardMatchLength =\n                        ZSTD_ldm_countBackwardsMatch(split, anchor, pMatch, lowPrefixPtr);\n                }\n                curTotalMatchLength = curForwardMatchLength + curBackwardMatchLength;\n\n                if (curTotalMatchLength > bestMatchLength) {\n                    bestMatchLength = curTotalMatchLength;\n                    forwardMatchLength = curForwardMatchLength;\n                    backwardMatchLength = curBackwardMatchLength;\n                    bestEntry = cur;\n                }\n            }\n\n            /* No match found -- insert an entry into the hash table\n             * and process the next candidate match */\n            if (bestEntry == NULL) {\n                ZSTD_ldm_insertEntry(ldmState, hash, newEntry, params->bucketSizeLog);\n                continue;\n            }\n\n            /* Match found */\n            offset = (U32)(split - base) - bestEntry->offset;\n            mLength = forwardMatchLength + backwardMatchLength;\n            {\n                rawSeq* const seq = rawSeqStore->seq + rawSeqStore->size;\n\n                /* Out of sequence storage */\n                if (rawSeqStore->size == rawSeqStore->capacity)\n                    return ERROR(dstSize_tooSmall);\n                seq->litLength = (U32)(split - backwardMatchLength - anchor);\n                seq->matchLength = (U32)mLength;\n                seq->offset = offset;\n                rawSeqStore->size++;\n            }\n\n            /* Insert the current entry into the hash table --- it must be\n             * done after the previous block to avoid clobbering bestEntry */\n            ZSTD_ldm_insertEntry(ldmState, hash, newEntry, params->bucketSizeLog);\n\n            anchor = split + forwardMatchLength;\n\n            /* If we find a match that ends after the data that we've hashed\n             * then we have a repeating, overlapping, pattern. E.g. all zeros.\n             * If one repetition of the pattern matches our `stopMask` then all\n             * repetitions will. We don't need to insert them all into out table,\n             * only the first one. So skip over overlapping matches.\n             * This is a major speed boost (20x) for compressing a single byte\n             * repeated, when that byte ends up in the table.\n             */\n            if (anchor > ip + hashed) {\n                ZSTD_ldm_gear_reset(&hashState, anchor - minMatchLength, minMatchLength);\n                /* Continue the outer loop at anchor (ip + hashed == anchor). */\n                ip = anchor - hashed;\n                break;\n            }\n        }\n\n        ip += hashed;\n    }\n\n    return iend - anchor;\n}\n\n/*! ZSTD_ldm_reduceTable() :\n *  reduce table indexes by `reducerValue` */\nstatic void ZSTD_ldm_reduceTable(ldmEntry_t* const table, U32 const size,\n                                 U32 const reducerValue)\n{\n    U32 u;\n    for (u = 0; u < size; u++) {\n        if (table[u].offset < reducerValue) table[u].offset = 0;\n        else table[u].offset -= reducerValue;\n    }\n}\n\nsize_t ZSTD_ldm_generateSequences(\n        ldmState_t* ldmState, RawSeqStore_t* sequences,\n        ldmParams_t const* params, void const* src, size_t srcSize)\n{\n    U32 const maxDist = 1U << params->windowLog;\n    BYTE const* const istart = (BYTE const*)src;\n    BYTE const* const iend = istart + srcSize;\n    size_t const kMaxChunkSize = 1 << 20;\n    size_t const nbChunks = (srcSize / kMaxChunkSize) + ((srcSize % kMaxChunkSize) != 0);\n    size_t chunk;\n    size_t leftoverSize = 0;\n\n    assert(ZSTD_CHUNKSIZE_MAX >= kMaxChunkSize);\n    /* Check that ZSTD_window_update() has been called for this chunk prior\n     * to passing it to this function.\n     */\n    assert(ldmState->window.nextSrc >= (BYTE const*)src + srcSize);\n    /* The input could be very large (in zstdmt), so it must be broken up into\n     * chunks to enforce the maximum distance and handle overflow correction.\n     */\n    assert(sequences->pos <= sequences->size);\n    assert(sequences->size <= sequences->capacity);\n    for (chunk = 0; chunk < nbChunks && sequences->size < sequences->capacity; ++chunk) {\n        BYTE const* const chunkStart = istart + chunk * kMaxChunkSize;\n        size_t const remaining = (size_t)(iend - chunkStart);\n        BYTE const *const chunkEnd =\n            (remaining < kMaxChunkSize) ? iend : chunkStart + kMaxChunkSize;\n        size_t const chunkSize = chunkEnd - chunkStart;\n        size_t newLeftoverSize;\n        size_t const prevSize = sequences->size;\n\n        assert(chunkStart < iend);\n        /* 1. Perform overflow correction if necessary. */\n        if (ZSTD_window_needOverflowCorrection(ldmState->window, 0, maxDist, ldmState->loadedDictEnd, chunkStart, chunkEnd)) {\n            U32 const ldmHSize = 1U << params->hashLog;\n            U32 const correction = ZSTD_window_correctOverflow(\n                &ldmState->window, /* cycleLog */ 0, maxDist, chunkStart);\n            ZSTD_ldm_reduceTable(ldmState->hashTable, ldmHSize, correction);\n            /* invalidate dictionaries on overflow correction */\n            ldmState->loadedDictEnd = 0;\n        }\n        /* 2. We enforce the maximum offset allowed.\n         *\n         * kMaxChunkSize should be small enough that we don't lose too much of\n         * the window through early invalidation.\n         * TODO: * Test the chunk size.\n         *       * Try invalidation after the sequence generation and test the\n         *         offset against maxDist directly.\n         *\n         * NOTE: Because of dictionaries + sequence splitting we MUST make sure\n         * that any offset used is valid at the END of the sequence, since it may\n         * be split into two sequences. This condition holds when using\n         * ZSTD_window_enforceMaxDist(), but if we move to checking offsets\n         * against maxDist directly, we'll have to carefully handle that case.\n         */\n        ZSTD_window_enforceMaxDist(&ldmState->window, chunkEnd, maxDist, &ldmState->loadedDictEnd, NULL);\n        /* 3. Generate the sequences for the chunk, and get newLeftoverSize. */\n        newLeftoverSize = ZSTD_ldm_generateSequences_internal(\n            ldmState, sequences, params, chunkStart, chunkSize);\n        if (ZSTD_isError(newLeftoverSize))\n            return newLeftoverSize;\n        /* 4. We add the leftover literals from previous iterations to the first\n         *    newly generated sequence, or add the `newLeftoverSize` if none are\n         *    generated.\n         */\n        /* Prepend the leftover literals from the last call */\n        if (prevSize < sequences->size) {\n            sequences->seq[prevSize].litLength += (U32)leftoverSize;\n            leftoverSize = newLeftoverSize;\n        } else {\n            assert(newLeftoverSize == chunkSize);\n            leftoverSize += chunkSize;\n        }\n    }\n    return 0;\n}\n\nvoid\nZSTD_ldm_skipSequences(RawSeqStore_t* rawSeqStore, size_t srcSize, U32 const minMatch)\n{\n    while (srcSize > 0 && rawSeqStore->pos < rawSeqStore->size) {\n        rawSeq* seq = rawSeqStore->seq + rawSeqStore->pos;\n        if (srcSize <= seq->litLength) {\n            /* Skip past srcSize literals */\n            seq->litLength -= (U32)srcSize;\n            return;\n        }\n        srcSize -= seq->litLength;\n        seq->litLength = 0;\n        if (srcSize < seq->matchLength) {\n            /* Skip past the first srcSize of the match */\n            seq->matchLength -= (U32)srcSize;\n            if (seq->matchLength < minMatch) {\n                /* The match is too short, omit it */\n                if (rawSeqStore->pos + 1 < rawSeqStore->size) {\n                    seq[1].litLength += seq[0].matchLength;\n                }\n                rawSeqStore->pos++;\n            }\n            return;\n        }\n        srcSize -= seq->matchLength;\n        seq->matchLength = 0;\n        rawSeqStore->pos++;\n    }\n}\n\n/**\n * If the sequence length is longer than remaining then the sequence is split\n * between this block and the next.\n *\n * Returns the current sequence to handle, or if the rest of the block should\n * be literals, it returns a sequence with offset == 0.\n */\nstatic rawSeq maybeSplitSequence(RawSeqStore_t* rawSeqStore,\n                                 U32 const remaining, U32 const minMatch)\n{\n    rawSeq sequence = rawSeqStore->seq[rawSeqStore->pos];\n    assert(sequence.offset > 0);\n    /* Likely: No partial sequence */\n    if (remaining >= sequence.litLength + sequence.matchLength) {\n        rawSeqStore->pos++;\n        return sequence;\n    }\n    /* Cut the sequence short (offset == 0 ==> rest is literals). */\n    if (remaining <= sequence.litLength) {\n        sequence.offset = 0;\n    } else if (remaining < sequence.litLength + sequence.matchLength) {\n        sequence.matchLength = remaining - sequence.litLength;\n        if (sequence.matchLength < minMatch) {\n            sequence.offset = 0;\n        }\n    }\n    /* Skip past `remaining` bytes for the future sequences. */\n    ZSTD_ldm_skipSequences(rawSeqStore, remaining, minMatch);\n    return sequence;\n}\n\nvoid ZSTD_ldm_skipRawSeqStoreBytes(RawSeqStore_t* rawSeqStore, size_t nbBytes) {\n    U32 currPos = (U32)(rawSeqStore->posInSequence + nbBytes);\n    while (currPos && rawSeqStore->pos < rawSeqStore->size) {\n        rawSeq currSeq = rawSeqStore->seq[rawSeqStore->pos];\n        if (currPos >= currSeq.litLength + currSeq.matchLength) {\n            currPos -= currSeq.litLength + currSeq.matchLength;\n            rawSeqStore->pos++;\n        } else {\n            rawSeqStore->posInSequence = currPos;\n            break;\n        }\n    }\n    if (currPos == 0 || rawSeqStore->pos == rawSeqStore->size) {\n        rawSeqStore->posInSequence = 0;\n    }\n}\n\nsize_t ZSTD_ldm_blockCompress(RawSeqStore_t* rawSeqStore,\n    ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n    ZSTD_ParamSwitch_e useRowMatchFinder,\n    void const* src, size_t srcSize)\n{\n    const ZSTD_compressionParameters* const cParams = &ms->cParams;\n    unsigned const minMatch = cParams->minMatch;\n    ZSTD_BlockCompressor_f const blockCompressor =\n        ZSTD_selectBlockCompressor(cParams->strategy, useRowMatchFinder, ZSTD_matchState_dictMode(ms));\n    /* Input bounds */\n    BYTE const* const istart = (BYTE const*)src;\n    BYTE const* const iend = istart + srcSize;\n    /* Input positions */\n    BYTE const* ip = istart;\n\n    DEBUGLOG(5, \"ZSTD_ldm_blockCompress: srcSize=%zu\", srcSize);\n    /* If using opt parser, use LDMs only as candidates rather than always accepting them */\n    if (cParams->strategy >= ZSTD_btopt) {\n        size_t lastLLSize;\n        ms->ldmSeqStore = rawSeqStore;\n        lastLLSize = blockCompressor(ms, seqStore, rep, src, srcSize);\n        ZSTD_ldm_skipRawSeqStoreBytes(rawSeqStore, srcSize);\n        return lastLLSize;\n    }\n\n    assert(rawSeqStore->pos <= rawSeqStore->size);\n    assert(rawSeqStore->size <= rawSeqStore->capacity);\n    /* Loop through each sequence and apply the block compressor to the literals */\n    while (rawSeqStore->pos < rawSeqStore->size && ip < iend) {\n        /* maybeSplitSequence updates rawSeqStore->pos */\n        rawSeq const sequence = maybeSplitSequence(rawSeqStore,\n                                                   (U32)(iend - ip), minMatch);\n        /* End signal */\n        if (sequence.offset == 0)\n            break;\n\n        assert(ip + sequence.litLength + sequence.matchLength <= iend);\n\n        /* Fill tables for block compressor */\n        ZSTD_ldm_limitTableUpdate(ms, ip);\n        ZSTD_ldm_fillFastTables(ms, ip);\n        /* Run the block compressor */\n        DEBUGLOG(5, \"pos %u : calling block compressor on segment of size %u\", (unsigned)(ip-istart), sequence.litLength);\n        {\n            int i;\n            size_t const newLitLength =\n                blockCompressor(ms, seqStore, rep, ip, sequence.litLength);\n            ip += sequence.litLength;\n            /* Update the repcodes */\n            for (i = ZSTD_REP_NUM - 1; i > 0; i--)\n                rep[i] = rep[i-1];\n            rep[0] = sequence.offset;\n            /* Store the sequence */\n            ZSTD_storeSeq(seqStore, newLitLength, ip - newLitLength, iend,\n                          OFFSET_TO_OFFBASE(sequence.offset),\n                          sequence.matchLength);\n            ip += sequence.matchLength;\n        }\n    }\n    /* Fill the tables for the block compressor */\n    ZSTD_ldm_limitTableUpdate(ms, ip);\n    ZSTD_ldm_fillFastTables(ms, ip);\n    /* Compress the last literals */\n    return blockCompressor(ms, seqStore, rep, ip, iend - ip);\n}\n"
  },
  {
    "path": "lib/compress/zstd_ldm.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_LDM_H\n#define ZSTD_LDM_H\n\n#include \"zstd_compress_internal.h\"   /* ldmParams_t, U32 */\n#include \"../zstd.h\"   /* ZSTD_CCtx, size_t */\n\n/*-*************************************\n*  Long distance matching\n***************************************/\n\n#define ZSTD_LDM_DEFAULT_WINDOW_LOG ZSTD_WINDOWLOG_LIMIT_DEFAULT\n\nvoid ZSTD_ldm_fillHashTable(\n            ldmState_t* state, const BYTE* ip,\n            const BYTE* iend, ldmParams_t const* params);\n\n/**\n * ZSTD_ldm_generateSequences():\n *\n * Generates the sequences using the long distance match finder.\n * Generates long range matching sequences in `sequences`, which parse a prefix\n * of the source. `sequences` must be large enough to store every sequence,\n * which can be checked with `ZSTD_ldm_getMaxNbSeq()`.\n * @returns 0 or an error code.\n *\n * NOTE: The user must have called ZSTD_window_update() for all of the input\n * they have, even if they pass it to ZSTD_ldm_generateSequences() in chunks.\n * NOTE: This function returns an error if it runs out of space to store\n *       sequences.\n */\nsize_t ZSTD_ldm_generateSequences(\n            ldmState_t* ldms, RawSeqStore_t* sequences,\n            ldmParams_t const* params, void const* src, size_t srcSize);\n\n/**\n * ZSTD_ldm_blockCompress():\n *\n * Compresses a block using the predefined sequences, along with a secondary\n * block compressor. The literals section of every sequence is passed to the\n * secondary block compressor, and those sequences are interspersed with the\n * predefined sequences. Returns the length of the last literals.\n * Updates `rawSeqStore.pos` to indicate how many sequences have been consumed.\n * `rawSeqStore.seq` may also be updated to split the last sequence between two\n * blocks.\n * @return The length of the last literals.\n *\n * NOTE: The source must be at most the maximum block size, but the predefined\n * sequences can be any size, and may be longer than the block. In the case that\n * they are longer than the block, the last sequences may need to be split into\n * two. We handle that case correctly, and update `rawSeqStore` appropriately.\n * NOTE: This function does not return any errors.\n */\nsize_t ZSTD_ldm_blockCompress(RawSeqStore_t* rawSeqStore,\n            ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n            ZSTD_ParamSwitch_e useRowMatchFinder,\n            void const* src, size_t srcSize);\n\n/**\n * ZSTD_ldm_skipSequences():\n *\n * Skip past `srcSize` bytes worth of sequences in `rawSeqStore`.\n * Avoids emitting matches less than `minMatch` bytes.\n * Must be called for data that is not passed to ZSTD_ldm_blockCompress().\n */\nvoid ZSTD_ldm_skipSequences(RawSeqStore_t* rawSeqStore, size_t srcSize,\n    U32 const minMatch);\n\n/* ZSTD_ldm_skipRawSeqStoreBytes():\n * Moves forward in rawSeqStore by nbBytes, updating fields 'pos' and 'posInSequence'.\n * Not to be used in conjunction with ZSTD_ldm_skipSequences().\n * Must be called for data with is not passed to ZSTD_ldm_blockCompress().\n */\nvoid ZSTD_ldm_skipRawSeqStoreBytes(RawSeqStore_t* rawSeqStore, size_t nbBytes);\n\n/** ZSTD_ldm_getTableSize() :\n *  Estimate the space needed for long distance matching tables or 0 if LDM is\n *  disabled.\n */\nsize_t ZSTD_ldm_getTableSize(ldmParams_t params);\n\n/** ZSTD_ldm_getSeqSpace() :\n *  Return an upper bound on the number of sequences that can be produced by\n *  the long distance matcher, or 0 if LDM is disabled.\n */\nsize_t ZSTD_ldm_getMaxNbSeq(ldmParams_t params, size_t maxChunkSize);\n\n/** ZSTD_ldm_adjustParameters() :\n *  If the params->hashRateLog is not set, set it to its default value based on\n *  windowLog and params->hashLog.\n *\n *  Ensures that params->bucketSizeLog is <= params->hashLog (setting it to\n *  params->hashLog if it is not).\n *\n *  Ensures that the minMatchLength >= targetLength during optimal parsing.\n */\nvoid ZSTD_ldm_adjustParameters(ldmParams_t* params,\n                               ZSTD_compressionParameters const* cParams);\n\n#endif /* ZSTD_FAST_H */\n"
  },
  {
    "path": "lib/compress/zstd_ldm_geartab.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_LDM_GEARTAB_H\n#define ZSTD_LDM_GEARTAB_H\n\n#include \"../common/compiler.h\" /* UNUSED_ATTR */\n#include \"../common/mem.h\"      /* U64 */\n\nstatic UNUSED_ATTR const U64 ZSTD_ldm_gearTab[256] = {\n    0xf5b8f72c5f77775c, 0x84935f266b7ac412, 0xb647ada9ca730ccc,\n    0xb065bb4b114fb1de, 0x34584e7e8c3a9fd0, 0x4e97e17c6ae26b05,\n    0x3a03d743bc99a604, 0xcecd042422c4044f, 0x76de76c58524259e,\n    0x9c8528f65badeaca, 0x86563706e2097529, 0x2902475fa375d889,\n    0xafb32a9739a5ebe6, 0xce2714da3883e639, 0x21eaf821722e69e,\n    0x37b628620b628,    0x49a8d455d88caf5,  0x8556d711e6958140,\n    0x4f7ae74fc605c1f,  0x829f0c3468bd3a20, 0x4ffdc885c625179e,\n    0x8473de048a3daf1b, 0x51008822b05646b2, 0x69d75d12b2d1cc5f,\n    0x8c9d4a19159154bc, 0xc3cc10f4abbd4003, 0xd06ddc1cecb97391,\n    0xbe48e6e7ed80302e, 0x3481db31cee03547, 0xacc3f67cdaa1d210,\n    0x65cb771d8c7f96cc, 0x8eb27177055723dd, 0xc789950d44cd94be,\n    0x934feadc3700b12b, 0x5e485f11edbdf182, 0x1e2e2a46fd64767a,\n    0x2969ca71d82efa7c, 0x9d46e9935ebbba2e, 0xe056b67e05e6822b,\n    0x94d73f55739d03a0, 0xcd7010bdb69b5a03, 0x455ef9fcd79b82f4,\n    0x869cb54a8749c161, 0x38d1a4fa6185d225, 0xb475166f94bbe9bb,\n    0xa4143548720959f1, 0x7aed4780ba6b26ba, 0xd0ce264439e02312,\n    0x84366d746078d508, 0xa8ce973c72ed17be, 0x21c323a29a430b01,\n    0x9962d617e3af80ee, 0xab0ce91d9c8cf75b, 0x530e8ee6d19a4dbc,\n    0x2ef68c0cf53f5d72, 0xc03a681640a85506, 0x496e4e9f9c310967,\n    0x78580472b59b14a0, 0x273824c23b388577, 0x66bf923ad45cb553,\n    0x47ae1a5a2492ba86, 0x35e304569e229659, 0x4765182a46870b6f,\n    0x6cbab625e9099412, 0xddac9a2e598522c1, 0x7172086e666624f2,\n    0xdf5003ca503b7837, 0x88c0c1db78563d09, 0x58d51865acfc289d,\n    0x177671aec65224f1, 0xfb79d8a241e967d7, 0x2be1e101cad9a49a,\n    0x6625682f6e29186b, 0x399553457ac06e50, 0x35dffb4c23abb74,\n    0x429db2591f54aade, 0xc52802a8037d1009, 0x6acb27381f0b25f3,\n    0xf45e2551ee4f823b, 0x8b0ea2d99580c2f7, 0x3bed519cbcb4e1e1,\n    0xff452823dbb010a,  0x9d42ed614f3dd267, 0x5b9313c06257c57b,\n    0xa114b8008b5e1442, 0xc1fe311c11c13d4b, 0x66e8763ea34c5568,\n    0x8b982af1c262f05d, 0xee8876faaa75fbb7, 0x8a62a4d0d172bb2a,\n    0xc13d94a3b7449a97, 0x6dbbba9dc15d037c, 0xc786101f1d92e0f1,\n    0xd78681a907a0b79b, 0xf61aaf2962c9abb9, 0x2cfd16fcd3cb7ad9,\n    0x868c5b6744624d21, 0x25e650899c74ddd7, 0xba042af4a7c37463,\n    0x4eb1a539465a3eca, 0xbe09dbf03b05d5ca, 0x774e5a362b5472ba,\n    0x47a1221229d183cd, 0x504b0ca18ef5a2df, 0xdffbdfbde2456eb9,\n    0x46cd2b2fbee34634, 0xf2aef8fe819d98c3, 0x357f5276d4599d61,\n    0x24a5483879c453e3, 0x88026889192b4b9,  0x28da96671782dbec,\n    0x4ef37c40588e9aaa, 0x8837b90651bc9fb3, 0xc164f741d3f0e5d6,\n    0xbc135a0a704b70ba, 0x69cd868f7622ada,  0xbc37ba89e0b9c0ab,\n    0x47c14a01323552f6, 0x4f00794bacee98bb, 0x7107de7d637a69d5,\n    0x88af793bb6f2255e, 0xf3c6466b8799b598, 0xc288c616aa7f3b59,\n    0x81ca63cf42fca3fd, 0x88d85ace36a2674b, 0xd056bd3792389e7,\n    0xe55c396c4e9dd32d, 0xbefb504571e6c0a6, 0x96ab32115e91e8cc,\n    0xbf8acb18de8f38d1, 0x66dae58801672606, 0x833b6017872317fb,\n    0xb87c16f2d1c92864, 0xdb766a74e58b669c, 0x89659f85c61417be,\n    0xc8daad856011ea0c, 0x76a4b565b6fe7eae, 0xa469d085f6237312,\n    0xaaf0365683a3e96c, 0x4dbb746f8424f7b8, 0x638755af4e4acc1,\n    0x3d7807f5bde64486, 0x17be6d8f5bbb7639, 0x903f0cd44dc35dc,\n    0x67b672eafdf1196c, 0xa676ff93ed4c82f1, 0x521d1004c5053d9d,\n    0x37ba9ad09ccc9202, 0x84e54d297aacfb51, 0xa0b4b776a143445,\n    0x820d471e20b348e,  0x1874383cb83d46dc, 0x97edeec7a1efe11c,\n    0xb330e50b1bdc42aa, 0x1dd91955ce70e032, 0xa514cdb88f2939d5,\n    0x2791233fd90db9d3, 0x7b670a4cc50f7a9b, 0x77c07d2a05c6dfa5,\n    0xe3778b6646d0a6fa, 0xb39c8eda47b56749, 0x933ed448addbef28,\n    0xaf846af6ab7d0bf4, 0xe5af208eb666e49,  0x5e6622f73534cd6a,\n    0x297daeca42ef5b6e, 0x862daef3d35539a6, 0xe68722498f8e1ea9,\n    0x981c53093dc0d572, 0xfa09b0bfbf86fbf5, 0x30b1e96166219f15,\n    0x70e7d466bdc4fb83, 0x5a66736e35f2a8e9, 0xcddb59d2b7c1baef,\n    0xd6c7d247d26d8996, 0xea4e39eac8de1ba3, 0x539c8bb19fa3aff2,\n    0x9f90e4c5fd508d8,  0xa34e5956fbaf3385, 0x2e2f8e151d3ef375,\n    0x173691e9b83faec1, 0xb85a8d56bf016379, 0x8382381267408ae3,\n    0xb90f901bbdc0096d, 0x7c6ad32933bcec65, 0x76bb5e2f2c8ad595,\n    0x390f851a6cf46d28, 0xc3e6064da1c2da72, 0xc52a0c101cfa5389,\n    0xd78eaf84a3fbc530, 0x3781b9e2288b997e, 0x73c2f6dea83d05c4,\n    0x4228e364c5b5ed7,  0x9d7a3edf0da43911, 0x8edcfeda24686756,\n    0x5e7667a7b7a9b3a1, 0x4c4f389fa143791d, 0xb08bc1023da7cddc,\n    0x7ab4be3ae529b1cc, 0x754e6132dbe74ff9, 0x71635442a839df45,\n    0x2f6fb1643fbe52de, 0x961e0a42cf7a8177, 0xf3b45d83d89ef2ea,\n    0xee3de4cf4a6e3e9b, 0xcd6848542c3295e7, 0xe4cee1664c78662f,\n    0x9947548b474c68c4, 0x25d73777a5ed8b0b, 0xc915b1d636b7fc,\n    0x21c2ba75d9b0d2da, 0x5f6b5dcf608a64a1, 0xdcf333255ff9570c,\n    0x633b922418ced4ee, 0xc136dde0b004b34a, 0x58cc83b05d4b2f5a,\n    0x5eb424dda28e42d2, 0x62df47369739cd98, 0xb4e0b42485e4ce17,\n    0x16e1f0c1f9a8d1e7, 0x8ec3916707560ebf, 0x62ba6e2df2cc9db3,\n    0xcbf9f4ff77d83a16, 0x78d9d7d07d2bbcc4, 0xef554ce1e02c41f4,\n    0x8d7581127eccf94d, 0xa9b53336cb3c8a05, 0x38c42c0bf45c4f91,\n    0x640893cdf4488863, 0x80ec34bc575ea568, 0x39f324f5b48eaa40,\n    0xe9d9ed1f8eff527f, 0x9224fc058cc5a214, 0xbaba00b04cfe7741,\n    0x309a9f120fcf52af, 0xa558f3ec65626212, 0x424bec8b7adabe2f,\n    0x41622513a6aea433, 0xb88da2d5324ca798, 0xd287733b245528a4,\n    0x9a44697e6d68aec3, 0x7b1093be2f49bb28, 0x50bbec632e3d8aad,\n    0x6cd90723e1ea8283, 0x897b9e7431b02bf3, 0x219efdcb338a7047,\n    0x3b0311f0a27c0656, 0xdb17bf91c0db96e7, 0x8cd4fd6b4e85a5b2,\n    0xfab071054ba6409d, 0x40d6fe831fa9dfd9, 0xaf358debad7d791e,\n    0xeb8d0e25a65e3e58, 0xbbcbd3df14e08580, 0xcf751f27ecdab2b,\n    0x2b4da14f2613d8f4\n};\n\n#endif /* ZSTD_LDM_GEARTAB_H */\n"
  },
  {
    "path": "lib/compress/zstd_opt.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#include \"zstd_compress_internal.h\"\n#include \"hist.h\"\n#include \"zstd_opt.h\"\n\n#if !defined(ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR) \\\n || !defined(ZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR) \\\n || !defined(ZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR)\n\n#define ZSTD_LITFREQ_ADD    2   /* scaling factor for litFreq, so that frequencies adapt faster to new stats */\n#define ZSTD_MAX_PRICE     (1<<30)\n\n#define ZSTD_PREDEF_THRESHOLD 8   /* if srcSize < ZSTD_PREDEF_THRESHOLD, symbols' cost is assumed static, directly determined by pre-defined distributions */\n\n\n/*-*************************************\n*  Price functions for optimal parser\n***************************************/\n\n#if 0    /* approximation at bit level (for tests) */\n#  define BITCOST_ACCURACY 0\n#  define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY)\n#  define WEIGHT(stat, opt) ((void)(opt), ZSTD_bitWeight(stat))\n#elif 0  /* fractional bit accuracy (for tests) */\n#  define BITCOST_ACCURACY 8\n#  define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY)\n#  define WEIGHT(stat,opt) ((void)(opt), ZSTD_fracWeight(stat))\n#else    /* opt==approx, ultra==accurate */\n#  define BITCOST_ACCURACY 8\n#  define BITCOST_MULTIPLIER (1 << BITCOST_ACCURACY)\n#  define WEIGHT(stat,opt) ((opt) ? ZSTD_fracWeight(stat) : ZSTD_bitWeight(stat))\n#endif\n\n/* ZSTD_bitWeight() :\n * provide estimated \"cost\" of a stat in full bits only */\nMEM_STATIC U32 ZSTD_bitWeight(U32 stat)\n{\n    return (ZSTD_highbit32(stat+1) * BITCOST_MULTIPLIER);\n}\n\n/* ZSTD_fracWeight() :\n * provide fractional-bit \"cost\" of a stat,\n * using linear interpolation approximation */\nMEM_STATIC U32 ZSTD_fracWeight(U32 rawStat)\n{\n    U32 const stat = rawStat + 1;\n    U32 const hb = ZSTD_highbit32(stat);\n    U32 const BWeight = hb * BITCOST_MULTIPLIER;\n    /* Fweight was meant for \"Fractional weight\"\n     * but it's effectively a value between 1 and 2\n     * using fixed point arithmetic */\n    U32 const FWeight = (stat << BITCOST_ACCURACY) >> hb;\n    U32 const weight = BWeight + FWeight;\n    assert(hb + BITCOST_ACCURACY < 31);\n    return weight;\n}\n\n#if (DEBUGLEVEL>=2)\n/* debugging function,\n * @return price in bytes as fractional value\n * for debug messages only */\nMEM_STATIC double ZSTD_fCost(int price)\n{\n    return (double)price / (BITCOST_MULTIPLIER*8);\n}\n#endif\n\nstatic int ZSTD_compressedLiterals(optState_t const* const optPtr)\n{\n    return optPtr->literalCompressionMode != ZSTD_ps_disable;\n}\n\nstatic void ZSTD_setBasePrices(optState_t* optPtr, int optLevel)\n{\n    if (ZSTD_compressedLiterals(optPtr))\n        optPtr->litSumBasePrice = WEIGHT(optPtr->litSum, optLevel);\n    optPtr->litLengthSumBasePrice = WEIGHT(optPtr->litLengthSum, optLevel);\n    optPtr->matchLengthSumBasePrice = WEIGHT(optPtr->matchLengthSum, optLevel);\n    optPtr->offCodeSumBasePrice = WEIGHT(optPtr->offCodeSum, optLevel);\n}\n\n\nstatic U32 sum_u32(const unsigned table[], size_t nbElts)\n{\n    size_t n;\n    U32 total = 0;\n    for (n=0; n0);\n        unsigned const newStat = base + (table[s] >> shift);\n        sum += newStat;\n        table[s] = newStat;\n    }\n    return sum;\n}\n\n/* ZSTD_scaleStats() :\n * reduce all elt frequencies in table if sum too large\n * return the resulting sum of elements */\nstatic U32 ZSTD_scaleStats(unsigned* table, U32 lastEltIndex, U32 logTarget)\n{\n    U32 const prevsum = sum_u32(table, lastEltIndex+1);\n    U32 const factor = prevsum >> logTarget;\n    DEBUGLOG(5, \"ZSTD_scaleStats (nbElts=%u, target=%u)\", (unsigned)lastEltIndex+1, (unsigned)logTarget);\n    assert(logTarget < 30);\n    if (factor <= 1) return prevsum;\n    return ZSTD_downscaleStats(table, lastEltIndex, ZSTD_highbit32(factor), base_1guaranteed);\n}\n\n/* ZSTD_rescaleFreqs() :\n * if first block (detected by optPtr->litLengthSum == 0) : init statistics\n *    take hints from dictionary if there is one\n *    and init from zero if there is none,\n *    using src for literals stats, and baseline stats for sequence symbols\n * otherwise downscale existing stats, to be used as seed for next block.\n */\nstatic void\nZSTD_rescaleFreqs(optState_t* const optPtr,\n            const BYTE* const src, size_t const srcSize,\n                  int const optLevel)\n{\n    int const compressedLiterals = ZSTD_compressedLiterals(optPtr);\n    DEBUGLOG(5, \"ZSTD_rescaleFreqs (srcSize=%u)\", (unsigned)srcSize);\n    optPtr->priceType = zop_dynamic;\n\n    if (optPtr->litLengthSum == 0) {  /* no literals stats collected -> first block assumed -> init */\n\n        /* heuristic: use pre-defined stats for too small inputs */\n        if (srcSize <= ZSTD_PREDEF_THRESHOLD) {\n            DEBUGLOG(5, \"srcSize <= %i : use predefined stats\", ZSTD_PREDEF_THRESHOLD);\n            optPtr->priceType = zop_predef;\n        }\n\n        assert(optPtr->symbolCosts != NULL);\n        if (optPtr->symbolCosts->huf.repeatMode == HUF_repeat_valid) {\n\n            /* huffman stats covering the full value set : table presumed generated by dictionary */\n            optPtr->priceType = zop_dynamic;\n\n            if (compressedLiterals) {\n                /* generate literals statistics from huffman table */\n                unsigned lit;\n                assert(optPtr->litFreq != NULL);\n                optPtr->litSum = 0;\n                for (lit=0; lit<=MaxLit; lit++) {\n                    U32 const scaleLog = 11;   /* scale to 2K */\n                    U32 const bitCost = HUF_getNbBitsFromCTable(optPtr->symbolCosts->huf.CTable, lit);\n                    assert(bitCost <= scaleLog);\n                    optPtr->litFreq[lit] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/;\n                    optPtr->litSum += optPtr->litFreq[lit];\n            }   }\n\n            {   unsigned ll;\n                FSE_CState_t llstate;\n                FSE_initCState(&llstate, optPtr->symbolCosts->fse.litlengthCTable);\n                optPtr->litLengthSum = 0;\n                for (ll=0; ll<=MaxLL; ll++) {\n                    U32 const scaleLog = 10;   /* scale to 1K */\n                    U32 const bitCost = FSE_getMaxNbBits(llstate.symbolTT, ll);\n                    assert(bitCost < scaleLog);\n                    optPtr->litLengthFreq[ll] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/;\n                    optPtr->litLengthSum += optPtr->litLengthFreq[ll];\n            }   }\n\n            {   unsigned ml;\n                FSE_CState_t mlstate;\n                FSE_initCState(&mlstate, optPtr->symbolCosts->fse.matchlengthCTable);\n                optPtr->matchLengthSum = 0;\n                for (ml=0; ml<=MaxML; ml++) {\n                    U32 const scaleLog = 10;\n                    U32 const bitCost = FSE_getMaxNbBits(mlstate.symbolTT, ml);\n                    assert(bitCost < scaleLog);\n                    optPtr->matchLengthFreq[ml] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/;\n                    optPtr->matchLengthSum += optPtr->matchLengthFreq[ml];\n            }   }\n\n            {   unsigned of;\n                FSE_CState_t ofstate;\n                FSE_initCState(&ofstate, optPtr->symbolCosts->fse.offcodeCTable);\n                optPtr->offCodeSum = 0;\n                for (of=0; of<=MaxOff; of++) {\n                    U32 const scaleLog = 10;\n                    U32 const bitCost = FSE_getMaxNbBits(ofstate.symbolTT, of);\n                    assert(bitCost < scaleLog);\n                    optPtr->offCodeFreq[of] = bitCost ? 1 << (scaleLog-bitCost) : 1 /*minimum to calculate cost*/;\n                    optPtr->offCodeSum += optPtr->offCodeFreq[of];\n            }   }\n\n        } else {  /* first block, no dictionary */\n\n            assert(optPtr->litFreq != NULL);\n            if (compressedLiterals) {\n                /* base initial cost of literals on direct frequency within src */\n                unsigned lit = MaxLit;\n                HIST_count_simple(optPtr->litFreq, &lit, src, srcSize);   /* use raw first block to init statistics */\n                optPtr->litSum = ZSTD_downscaleStats(optPtr->litFreq, MaxLit, 8, base_0possible);\n            }\n\n            {   unsigned const baseLLfreqs[MaxLL+1] = {\n                    4, 2, 1, 1, 1, 1, 1, 1,\n                    1, 1, 1, 1, 1, 1, 1, 1,\n                    1, 1, 1, 1, 1, 1, 1, 1,\n                    1, 1, 1, 1, 1, 1, 1, 1,\n                    1, 1, 1, 1\n                };\n                ZSTD_memcpy(optPtr->litLengthFreq, baseLLfreqs, sizeof(baseLLfreqs));\n                optPtr->litLengthSum = sum_u32(baseLLfreqs, MaxLL+1);\n            }\n\n            {   unsigned ml;\n                for (ml=0; ml<=MaxML; ml++)\n                    optPtr->matchLengthFreq[ml] = 1;\n            }\n            optPtr->matchLengthSum = MaxML+1;\n\n            {   unsigned const baseOFCfreqs[MaxOff+1] = {\n                    6, 2, 1, 1, 2, 3, 4, 4,\n                    4, 3, 2, 1, 1, 1, 1, 1,\n                    1, 1, 1, 1, 1, 1, 1, 1,\n                    1, 1, 1, 1, 1, 1, 1, 1\n                };\n                ZSTD_memcpy(optPtr->offCodeFreq, baseOFCfreqs, sizeof(baseOFCfreqs));\n                optPtr->offCodeSum = sum_u32(baseOFCfreqs, MaxOff+1);\n            }\n\n        }\n\n    } else {   /* new block : scale down accumulated statistics */\n\n        if (compressedLiterals)\n            optPtr->litSum = ZSTD_scaleStats(optPtr->litFreq, MaxLit, 12);\n        optPtr->litLengthSum = ZSTD_scaleStats(optPtr->litLengthFreq, MaxLL, 11);\n        optPtr->matchLengthSum = ZSTD_scaleStats(optPtr->matchLengthFreq, MaxML, 11);\n        optPtr->offCodeSum = ZSTD_scaleStats(optPtr->offCodeFreq, MaxOff, 11);\n    }\n\n    ZSTD_setBasePrices(optPtr, optLevel);\n}\n\n/* ZSTD_rawLiteralsCost() :\n * price of literals (only) in specified segment (which length can be 0).\n * does not include price of literalLength symbol */\nstatic U32 ZSTD_rawLiteralsCost(const BYTE* const literals, U32 const litLength,\n                                const optState_t* const optPtr,\n                                int optLevel)\n{\n    DEBUGLOG(8, \"ZSTD_rawLiteralsCost (%u literals)\", litLength);\n    if (litLength == 0) return 0;\n\n    if (!ZSTD_compressedLiterals(optPtr))\n        return (litLength << 3) * BITCOST_MULTIPLIER;  /* Uncompressed - 8 bytes per literal. */\n\n    if (optPtr->priceType == zop_predef)\n        return (litLength*6) * BITCOST_MULTIPLIER;  /* 6 bit per literal - no statistic used */\n\n    /* dynamic statistics */\n    {   U32 price = optPtr->litSumBasePrice * litLength;\n        U32 const litPriceMax = optPtr->litSumBasePrice - BITCOST_MULTIPLIER;\n        U32 u;\n        assert(optPtr->litSumBasePrice >= BITCOST_MULTIPLIER);\n        for (u=0; u < litLength; u++) {\n            U32 litPrice = WEIGHT(optPtr->litFreq[literals[u]], optLevel);\n            if (UNLIKELY(litPrice > litPriceMax)) litPrice = litPriceMax;\n            price -= litPrice;\n        }\n        return price;\n    }\n}\n\n/* ZSTD_litLengthPrice() :\n * cost of literalLength symbol */\nstatic U32 ZSTD_litLengthPrice(U32 const litLength, const optState_t* const optPtr, int optLevel)\n{\n    assert(litLength <= ZSTD_BLOCKSIZE_MAX);\n    if (optPtr->priceType == zop_predef)\n        return WEIGHT(litLength, optLevel);\n\n    /* ZSTD_LLcode() can't compute litLength price for sizes >= ZSTD_BLOCKSIZE_MAX\n     * because it isn't representable in the zstd format.\n     * So instead just pretend it would cost 1 bit more than ZSTD_BLOCKSIZE_MAX - 1.\n     * In such a case, the block would be all literals.\n     */\n    if (litLength == ZSTD_BLOCKSIZE_MAX)\n        return BITCOST_MULTIPLIER + ZSTD_litLengthPrice(ZSTD_BLOCKSIZE_MAX - 1, optPtr, optLevel);\n\n    /* dynamic statistics */\n    {   U32 const llCode = ZSTD_LLcode(litLength);\n        return (LL_bits[llCode] * BITCOST_MULTIPLIER)\n             + optPtr->litLengthSumBasePrice\n             - WEIGHT(optPtr->litLengthFreq[llCode], optLevel);\n    }\n}\n\n/* ZSTD_getMatchPrice() :\n * Provides the cost of the match part (offset + matchLength) of a sequence.\n * Must be combined with ZSTD_fullLiteralsCost() to get the full cost of a sequence.\n * @offBase : sumtype, representing an offset or a repcode, and using numeric representation of ZSTD_storeSeq()\n * @optLevel: when <2, favors small offset for decompression speed (improved cache efficiency)\n */\nFORCE_INLINE_TEMPLATE U32\nZSTD_getMatchPrice(U32 const offBase,\n                   U32 const matchLength,\n             const optState_t* const optPtr,\n                   int const optLevel)\n{\n    U32 price;\n    U32 const offCode = ZSTD_highbit32(offBase);\n    U32 const mlBase = matchLength - MINMATCH;\n    assert(matchLength >= MINMATCH);\n\n    if (optPtr->priceType == zop_predef)  /* fixed scheme, does not use statistics */\n        return WEIGHT(mlBase, optLevel)\n             + ((16 + offCode) * BITCOST_MULTIPLIER); /* emulated offset cost */\n\n    /* dynamic statistics */\n    price = (offCode * BITCOST_MULTIPLIER) + (optPtr->offCodeSumBasePrice - WEIGHT(optPtr->offCodeFreq[offCode], optLevel));\n    if ((optLevel<2) /*static*/ && offCode >= 20)\n        price += (offCode-19)*2 * BITCOST_MULTIPLIER; /* handicap for long distance offsets, favor decompression speed */\n\n    /* match Length */\n    {   U32 const mlCode = ZSTD_MLcode(mlBase);\n        price += (ML_bits[mlCode] * BITCOST_MULTIPLIER) + (optPtr->matchLengthSumBasePrice - WEIGHT(optPtr->matchLengthFreq[mlCode], optLevel));\n    }\n\n    price += BITCOST_MULTIPLIER / 5;   /* heuristic : make matches a bit more costly to favor less sequences -> faster decompression speed */\n\n    DEBUGLOG(8, \"ZSTD_getMatchPrice(ml:%u) = %u\", matchLength, price);\n    return price;\n}\n\n/* ZSTD_updateStats() :\n * assumption : literals + litLength <= iend */\nstatic void ZSTD_updateStats(optState_t* const optPtr,\n                             U32 litLength, const BYTE* literals,\n                             U32 offBase, U32 matchLength)\n{\n    /* literals */\n    if (ZSTD_compressedLiterals(optPtr)) {\n        U32 u;\n        for (u=0; u < litLength; u++)\n            optPtr->litFreq[literals[u]] += ZSTD_LITFREQ_ADD;\n        optPtr->litSum += litLength*ZSTD_LITFREQ_ADD;\n    }\n\n    /* literal Length */\n    {   U32 const llCode = ZSTD_LLcode(litLength);\n        optPtr->litLengthFreq[llCode]++;\n        optPtr->litLengthSum++;\n    }\n\n    /* offset code : follows storeSeq() numeric representation */\n    {   U32 const offCode = ZSTD_highbit32(offBase);\n        assert(offCode <= MaxOff);\n        optPtr->offCodeFreq[offCode]++;\n        optPtr->offCodeSum++;\n    }\n\n    /* match Length */\n    {   U32 const mlBase = matchLength - MINMATCH;\n        U32 const mlCode = ZSTD_MLcode(mlBase);\n        optPtr->matchLengthFreq[mlCode]++;\n        optPtr->matchLengthSum++;\n    }\n}\n\n\n/* ZSTD_readMINMATCH() :\n * function safe only for comparisons\n * assumption : memPtr must be at least 4 bytes before end of buffer */\nMEM_STATIC U32 ZSTD_readMINMATCH(const void* memPtr, U32 length)\n{\n    switch (length)\n    {\n    default :\n    case 4 : return MEM_read32(memPtr);\n    case 3 : if (MEM_isLittleEndian())\n                return MEM_read32(memPtr)<<8;\n             else\n                return MEM_read32(memPtr)>>8;\n    }\n}\n\n\n/* Update hashTable3 up to ip (excluded)\n   Assumption : always within prefix (i.e. not within extDict) */\nstatic\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nU32 ZSTD_insertAndFindFirstIndexHash3 (const ZSTD_MatchState_t* ms,\n                                       U32* nextToUpdate3,\n                                       const BYTE* const ip)\n{\n    U32* const hashTable3 = ms->hashTable3;\n    U32 const hashLog3 = ms->hashLog3;\n    const BYTE* const base = ms->window.base;\n    U32 idx = *nextToUpdate3;\n    U32 const target = (U32)(ip - base);\n    size_t const hash3 = ZSTD_hash3Ptr(ip, hashLog3);\n    assert(hashLog3 > 0);\n\n    while(idx < target) {\n        hashTable3[ZSTD_hash3Ptr(base+idx, hashLog3)] = idx;\n        idx++;\n    }\n\n    *nextToUpdate3 = target;\n    return hashTable3[hash3];\n}\n\n\n/*-*************************************\n*  Binary Tree search\n***************************************/\n/** ZSTD_insertBt1() : add one or multiple positions to tree.\n * @param ip assumed <= iend-8 .\n * @param target The target of ZSTD_updateTree_internal() - we are filling to this position\n * @return : nb of positions added */\nstatic\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nU32 ZSTD_insertBt1(\n                const ZSTD_MatchState_t* ms,\n                const BYTE* const ip, const BYTE* const iend,\n                U32 const target,\n                U32 const mls, const int extDict)\n{\n    const ZSTD_compressionParameters* const cParams = &ms->cParams;\n    U32*   const hashTable = ms->hashTable;\n    U32    const hashLog = cParams->hashLog;\n    size_t const h  = ZSTD_hashPtr(ip, hashLog, mls);\n    U32*   const bt = ms->chainTable;\n    U32    const btLog  = cParams->chainLog - 1;\n    U32    const btMask = (1 << btLog) - 1;\n    U32 matchIndex = hashTable[h];\n    size_t commonLengthSmaller=0, commonLengthLarger=0;\n    const BYTE* const base = ms->window.base;\n    const BYTE* const dictBase = ms->window.dictBase;\n    const U32 dictLimit = ms->window.dictLimit;\n    const BYTE* const dictEnd = dictBase + dictLimit;\n    const BYTE* const prefixStart = base + dictLimit;\n    const BYTE* match;\n    const U32 curr = (U32)(ip-base);\n    const U32 btLow = btMask >= curr ? 0 : curr - btMask;\n    U32* smallerPtr = bt + 2*(curr&btMask);\n    U32* largerPtr  = smallerPtr + 1;\n    U32 dummy32;   /* to be nullified at the end */\n    /* windowLow is based on target because\n     * we only need positions that will be in the window at the end of the tree update.\n     */\n    U32 const windowLow = ZSTD_getLowestMatchIndex(ms, target, cParams->windowLog);\n    U32 matchEndIdx = curr+8+1;\n    size_t bestLength = 8;\n    U32 nbCompares = 1U << cParams->searchLog;\n#ifdef ZSTD_C_PREDICT\n    U32 predictedSmall = *(bt + 2*((curr-1)&btMask) + 0);\n    U32 predictedLarge = *(bt + 2*((curr-1)&btMask) + 1);\n    predictedSmall += (predictedSmall>0);\n    predictedLarge += (predictedLarge>0);\n#endif /* ZSTD_C_PREDICT */\n\n    DEBUGLOG(8, \"ZSTD_insertBt1 (%u)\", curr);\n\n    assert(curr <= target);\n    assert(ip <= iend-8);   /* required for h calculation */\n    hashTable[h] = curr;   /* Update Hash Table */\n\n    assert(windowLow > 0);\n    for (; nbCompares && (matchIndex >= windowLow); --nbCompares) {\n        U32* const nextPtr = bt + 2*(matchIndex & btMask);\n        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */\n        assert(matchIndex < curr);\n\n#ifdef ZSTD_C_PREDICT   /* note : can create issues when hlog small <= 11 */\n        const U32* predictPtr = bt + 2*((matchIndex-1) & btMask);   /* written this way, as bt is a roll buffer */\n        if (matchIndex == predictedSmall) {\n            /* no need to check length, result known */\n            *smallerPtr = matchIndex;\n            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */\n            smallerPtr = nextPtr+1;               /* new \"smaller\" => larger of match */\n            matchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */\n            predictedSmall = predictPtr[1] + (predictPtr[1]>0);\n            continue;\n        }\n        if (matchIndex == predictedLarge) {\n            *largerPtr = matchIndex;\n            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */\n            largerPtr = nextPtr;\n            matchIndex = nextPtr[0];\n            predictedLarge = predictPtr[0] + (predictPtr[0]>0);\n            continue;\n        }\n#endif\n\n        if (!extDict || (matchIndex+matchLength >= dictLimit)) {\n            assert(matchIndex+matchLength >= dictLimit);   /* might be wrong if actually extDict */\n            match = base + matchIndex;\n            matchLength += ZSTD_count(ip+matchLength, match+matchLength, iend);\n        } else {\n            match = dictBase + matchIndex;\n            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iend, dictEnd, prefixStart);\n            if (matchIndex+matchLength >= dictLimit)\n                match = base + matchIndex;   /* to prepare for next usage of match[matchLength] */\n        }\n\n        if (matchLength > bestLength) {\n            bestLength = matchLength;\n            if (matchLength > matchEndIdx - matchIndex)\n                matchEndIdx = matchIndex + (U32)matchLength;\n        }\n\n        if (ip+matchLength == iend) {   /* equal : no way to know if inf or sup */\n            break;   /* drop , to guarantee consistency ; miss a bit of compression, but other solutions can corrupt tree */\n        }\n\n        if (match[matchLength] < ip[matchLength]) {  /* necessarily within buffer */\n            /* match is smaller than current */\n            *smallerPtr = matchIndex;             /* update smaller idx */\n            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */\n            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop searching */\n            smallerPtr = nextPtr+1;               /* new \"candidate\" => larger than match, which was smaller than target */\n            matchIndex = nextPtr[1];              /* new matchIndex, larger than previous and closer to current */\n        } else {\n            /* match is larger than current */\n            *largerPtr = matchIndex;\n            commonLengthLarger = matchLength;\n            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop searching */\n            largerPtr = nextPtr;\n            matchIndex = nextPtr[0];\n    }   }\n\n    *smallerPtr = *largerPtr = 0;\n    {   U32 positions = 0;\n        if (bestLength > 384) positions = MIN(192, (U32)(bestLength - 384));   /* speed optimization */\n        assert(matchEndIdx > curr + 8);\n        return MAX(positions, matchEndIdx - (curr + 8));\n    }\n}\n\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nvoid ZSTD_updateTree_internal(\n                ZSTD_MatchState_t* ms,\n                const BYTE* const ip, const BYTE* const iend,\n                const U32 mls, const ZSTD_dictMode_e dictMode)\n{\n    const BYTE* const base = ms->window.base;\n    U32 const target = (U32)(ip - base);\n    U32 idx = ms->nextToUpdate;\n    DEBUGLOG(7, \"ZSTD_updateTree_internal, from %u to %u  (dictMode:%u)\",\n                idx, target, dictMode);\n\n    while(idx < target) {\n        U32 const forward = ZSTD_insertBt1(ms, base+idx, iend, target, mls, dictMode == ZSTD_extDict);\n        assert(idx < (U32)(idx + forward));\n        idx += forward;\n    }\n    assert((size_t)(ip - base) <= (size_t)(U32)(-1));\n    assert((size_t)(iend - base) <= (size_t)(U32)(-1));\n    ms->nextToUpdate = target;\n}\n\nvoid ZSTD_updateTree(ZSTD_MatchState_t* ms, const BYTE* ip, const BYTE* iend) {\n    ZSTD_updateTree_internal(ms, ip, iend, ms->cParams.minMatch, ZSTD_noDict);\n}\n\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nU32\nZSTD_insertBtAndGetAllMatches (\n                ZSTD_match_t* matches,  /* store result (found matches) in this table (presumed large enough) */\n                ZSTD_MatchState_t* ms,\n                U32* nextToUpdate3,\n                const BYTE* const ip, const BYTE* const iLimit,\n                const ZSTD_dictMode_e dictMode,\n                const U32 rep[ZSTD_REP_NUM],\n                const U32 ll0,  /* tells if associated literal length is 0 or not. This value must be 0 or 1 */\n                const U32 lengthToBeat,\n                const U32 mls /* template */)\n{\n    const ZSTD_compressionParameters* const cParams = &ms->cParams;\n    U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1);\n    const BYTE* const base = ms->window.base;\n    U32 const curr = (U32)(ip-base);\n    U32 const hashLog = cParams->hashLog;\n    U32 const minMatch = (mls==3) ? 3 : 4;\n    U32* const hashTable = ms->hashTable;\n    size_t const h  = ZSTD_hashPtr(ip, hashLog, mls);\n    U32 matchIndex  = hashTable[h];\n    U32* const bt   = ms->chainTable;\n    U32 const btLog = cParams->chainLog - 1;\n    U32 const btMask= (1U << btLog) - 1;\n    size_t commonLengthSmaller=0, commonLengthLarger=0;\n    const BYTE* const dictBase = ms->window.dictBase;\n    U32 const dictLimit = ms->window.dictLimit;\n    const BYTE* const dictEnd = dictBase + dictLimit;\n    const BYTE* const prefixStart = base + dictLimit;\n    U32 const btLow = (btMask >= curr) ? 0 : curr - btMask;\n    U32 const windowLow = ZSTD_getLowestMatchIndex(ms, curr, cParams->windowLog);\n    U32 const matchLow = windowLow ? windowLow : 1;\n    U32* smallerPtr = bt + 2*(curr&btMask);\n    U32* largerPtr  = bt + 2*(curr&btMask) + 1;\n    U32 matchEndIdx = curr+8+1;   /* farthest referenced position of any match => detects repetitive patterns */\n    U32 dummy32;   /* to be nullified at the end */\n    U32 mnum = 0;\n    U32 nbCompares = 1U << cParams->searchLog;\n\n    const ZSTD_MatchState_t* dms    = dictMode == ZSTD_dictMatchState ? ms->dictMatchState : NULL;\n    const ZSTD_compressionParameters* const dmsCParams =\n                                      dictMode == ZSTD_dictMatchState ? &dms->cParams : NULL;\n    const BYTE* const dmsBase       = dictMode == ZSTD_dictMatchState ? dms->window.base : NULL;\n    const BYTE* const dmsEnd        = dictMode == ZSTD_dictMatchState ? dms->window.nextSrc : NULL;\n    U32         const dmsHighLimit  = dictMode == ZSTD_dictMatchState ? (U32)(dmsEnd - dmsBase) : 0;\n    U32         const dmsLowLimit   = dictMode == ZSTD_dictMatchState ? dms->window.lowLimit : 0;\n    U32         const dmsIndexDelta = dictMode == ZSTD_dictMatchState ? windowLow - dmsHighLimit : 0;\n    U32         const dmsHashLog    = dictMode == ZSTD_dictMatchState ? dmsCParams->hashLog : hashLog;\n    U32         const dmsBtLog      = dictMode == ZSTD_dictMatchState ? dmsCParams->chainLog - 1 : btLog;\n    U32         const dmsBtMask     = dictMode == ZSTD_dictMatchState ? (1U << dmsBtLog) - 1 : 0;\n    U32         const dmsBtLow      = dictMode == ZSTD_dictMatchState && dmsBtMask < dmsHighLimit - dmsLowLimit ? dmsHighLimit - dmsBtMask : dmsLowLimit;\n\n    size_t bestLength = lengthToBeat-1;\n    DEBUGLOG(8, \"ZSTD_insertBtAndGetAllMatches: current=%u\", curr);\n\n    /* check repCode */\n    assert(ll0 <= 1);   /* necessarily 1 or 0 */\n    {   U32 const lastR = ZSTD_REP_NUM + ll0;\n        U32 repCode;\n        for (repCode = ll0; repCode < lastR; repCode++) {\n            U32 const repOffset = (repCode==ZSTD_REP_NUM) ? (rep[0] - 1) : rep[repCode];\n            U32 const repIndex = curr - repOffset;\n            U32 repLen = 0;\n            assert(curr >= dictLimit);\n            if (repOffset-1 /* intentional overflow, discards 0 and -1 */ < curr-dictLimit) {  /* equivalent to `curr > repIndex >= dictLimit` */\n                /* We must validate the repcode offset because when we're using a dictionary the\n                 * valid offset range shrinks when the dictionary goes out of bounds.\n                 */\n                if ((repIndex >= windowLow) & (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(ip - repOffset, minMatch))) {\n                    repLen = (U32)ZSTD_count(ip+minMatch, ip+minMatch-repOffset, iLimit) + minMatch;\n                }\n            } else {  /* repIndex < dictLimit || repIndex >= curr */\n                const BYTE* const repMatch = dictMode == ZSTD_dictMatchState ?\n                                             dmsBase + repIndex - dmsIndexDelta :\n                                             dictBase + repIndex;\n                assert(curr >= windowLow);\n                if ( dictMode == ZSTD_extDict\n                  && ( ((repOffset-1) /*intentional overflow*/ < curr - windowLow)  /* equivalent to `curr > repIndex >= windowLow` */\n                     & (ZSTD_index_overlap_check(dictLimit, repIndex)) )\n                  && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) {\n                    repLen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iLimit, dictEnd, prefixStart) + minMatch;\n                }\n                if (dictMode == ZSTD_dictMatchState\n                  && ( ((repOffset-1) /*intentional overflow*/ < curr - (dmsLowLimit + dmsIndexDelta))  /* equivalent to `curr > repIndex >= dmsLowLimit` */\n                     & (ZSTD_index_overlap_check(dictLimit, repIndex)) )\n                  && (ZSTD_readMINMATCH(ip, minMatch) == ZSTD_readMINMATCH(repMatch, minMatch)) ) {\n                    repLen = (U32)ZSTD_count_2segments(ip+minMatch, repMatch+minMatch, iLimit, dmsEnd, prefixStart) + minMatch;\n            }   }\n            /* save longer solution */\n            if (repLen > bestLength) {\n                DEBUGLOG(8, \"found repCode %u (ll0:%u, offset:%u) of length %u\",\n                            repCode, ll0, repOffset, repLen);\n                bestLength = repLen;\n                matches[mnum].off = REPCODE_TO_OFFBASE(repCode - ll0 + 1);  /* expect value between 1 and 3 */\n                matches[mnum].len = (U32)repLen;\n                mnum++;\n                if ( (repLen > sufficient_len)\n                   | (ip+repLen == iLimit) ) {  /* best possible */\n                    return mnum;\n    }   }   }   }\n\n    /* HC3 match finder */\n    if ((mls == 3) /*static*/ && (bestLength < mls)) {\n        U32 const matchIndex3 = ZSTD_insertAndFindFirstIndexHash3(ms, nextToUpdate3, ip);\n        if ((matchIndex3 >= matchLow)\n          & (curr - matchIndex3 < (1<<18)) /*heuristic : longer distance likely too expensive*/ ) {\n            size_t mlen;\n            if ((dictMode == ZSTD_noDict) /*static*/ || (dictMode == ZSTD_dictMatchState) /*static*/ || (matchIndex3 >= dictLimit)) {\n                const BYTE* const match = base + matchIndex3;\n                mlen = ZSTD_count(ip, match, iLimit);\n            } else {\n                const BYTE* const match = dictBase + matchIndex3;\n                mlen = ZSTD_count_2segments(ip, match, iLimit, dictEnd, prefixStart);\n            }\n\n            /* save best solution */\n            if (mlen >= mls /* == 3 > bestLength */) {\n                DEBUGLOG(8, \"found small match with hlog3, of length %u\",\n                            (U32)mlen);\n                bestLength = mlen;\n                assert(curr > matchIndex3);\n                assert(mnum==0);  /* no prior solution */\n                matches[0].off = OFFSET_TO_OFFBASE(curr - matchIndex3);\n                matches[0].len = (U32)mlen;\n                mnum = 1;\n                if ( (mlen > sufficient_len) |\n                     (ip+mlen == iLimit) ) {  /* best possible length */\n                    ms->nextToUpdate = curr+1;  /* skip insertion */\n                    return 1;\n        }   }   }\n        /* no dictMatchState lookup: dicts don't have a populated HC3 table */\n    }  /* if (mls == 3) */\n\n    hashTable[h] = curr;   /* Update Hash Table */\n\n    for (; nbCompares && (matchIndex >= matchLow); --nbCompares) {\n        U32* const nextPtr = bt + 2*(matchIndex & btMask);\n        const BYTE* match;\n        size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */\n        assert(curr > matchIndex);\n\n        if ((dictMode == ZSTD_noDict) || (dictMode == ZSTD_dictMatchState) || (matchIndex+matchLength >= dictLimit)) {\n            assert(matchIndex+matchLength >= dictLimit);  /* ensure the condition is correct when !extDict */\n            match = base + matchIndex;\n            if (matchIndex >= dictLimit) assert(memcmp(match, ip, matchLength) == 0);  /* ensure early section of match is equal as expected */\n            matchLength += ZSTD_count(ip+matchLength, match+matchLength, iLimit);\n        } else {\n            match = dictBase + matchIndex;\n            assert(memcmp(match, ip, matchLength) == 0);  /* ensure early section of match is equal as expected */\n            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dictEnd, prefixStart);\n            if (matchIndex+matchLength >= dictLimit)\n                match = base + matchIndex;   /* prepare for match[matchLength] read */\n        }\n\n        if (matchLength > bestLength) {\n            DEBUGLOG(8, \"found match of length %u at distance %u (offBase=%u)\",\n                    (U32)matchLength, curr - matchIndex, OFFSET_TO_OFFBASE(curr - matchIndex));\n            assert(matchEndIdx > matchIndex);\n            if (matchLength > matchEndIdx - matchIndex)\n                matchEndIdx = matchIndex + (U32)matchLength;\n            bestLength = matchLength;\n            matches[mnum].off = OFFSET_TO_OFFBASE(curr - matchIndex);\n            matches[mnum].len = (U32)matchLength;\n            mnum++;\n            if ( (matchLength > ZSTD_OPT_NUM)\n               | (ip+matchLength == iLimit) /* equal : no way to know if inf or sup */) {\n                if (dictMode == ZSTD_dictMatchState) nbCompares = 0; /* break should also skip searching dms */\n                break; /* drop, to preserve bt consistency (miss a little bit of compression) */\n        }   }\n\n        if (match[matchLength] < ip[matchLength]) {\n            /* match smaller than current */\n            *smallerPtr = matchIndex;             /* update smaller idx */\n            commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */\n            if (matchIndex <= btLow) { smallerPtr=&dummy32; break; }   /* beyond tree size, stop the search */\n            smallerPtr = nextPtr+1;               /* new candidate => larger than match, which was smaller than current */\n            matchIndex = nextPtr[1];              /* new matchIndex, larger than previous, closer to current */\n        } else {\n            *largerPtr = matchIndex;\n            commonLengthLarger = matchLength;\n            if (matchIndex <= btLow) { largerPtr=&dummy32; break; }   /* beyond tree size, stop the search */\n            largerPtr = nextPtr;\n            matchIndex = nextPtr[0];\n    }   }\n\n    *smallerPtr = *largerPtr = 0;\n\n    assert(nbCompares <= (1U << ZSTD_SEARCHLOG_MAX)); /* Check we haven't underflowed. */\n    if (dictMode == ZSTD_dictMatchState && nbCompares) {\n        size_t const dmsH = ZSTD_hashPtr(ip, dmsHashLog, mls);\n        U32 dictMatchIndex = dms->hashTable[dmsH];\n        const U32* const dmsBt = dms->chainTable;\n        commonLengthSmaller = commonLengthLarger = 0;\n        for (; nbCompares && (dictMatchIndex > dmsLowLimit); --nbCompares) {\n            const U32* const nextPtr = dmsBt + 2*(dictMatchIndex & dmsBtMask);\n            size_t matchLength = MIN(commonLengthSmaller, commonLengthLarger);   /* guaranteed minimum nb of common bytes */\n            const BYTE* match = dmsBase + dictMatchIndex;\n            matchLength += ZSTD_count_2segments(ip+matchLength, match+matchLength, iLimit, dmsEnd, prefixStart);\n            if (dictMatchIndex+matchLength >= dmsHighLimit)\n                match = base + dictMatchIndex + dmsIndexDelta;   /* to prepare for next usage of match[matchLength] */\n\n            if (matchLength > bestLength) {\n                matchIndex = dictMatchIndex + dmsIndexDelta;\n                DEBUGLOG(8, \"found dms match of length %u at distance %u (offBase=%u)\",\n                        (U32)matchLength, curr - matchIndex, OFFSET_TO_OFFBASE(curr - matchIndex));\n                if (matchLength > matchEndIdx - matchIndex)\n                    matchEndIdx = matchIndex + (U32)matchLength;\n                bestLength = matchLength;\n                matches[mnum].off = OFFSET_TO_OFFBASE(curr - matchIndex);\n                matches[mnum].len = (U32)matchLength;\n                mnum++;\n                if ( (matchLength > ZSTD_OPT_NUM)\n                   | (ip+matchLength == iLimit) /* equal : no way to know if inf or sup */) {\n                    break;   /* drop, to guarantee consistency (miss a little bit of compression) */\n            }   }\n\n            if (dictMatchIndex <= dmsBtLow) { break; }   /* beyond tree size, stop the search */\n            if (match[matchLength] < ip[matchLength]) {\n                commonLengthSmaller = matchLength;    /* all smaller will now have at least this guaranteed common length */\n                dictMatchIndex = nextPtr[1];              /* new matchIndex larger than previous (closer to current) */\n            } else {\n                /* match is larger than current */\n                commonLengthLarger = matchLength;\n                dictMatchIndex = nextPtr[0];\n    }   }   }  /* if (dictMode == ZSTD_dictMatchState) */\n\n    assert(matchEndIdx > curr+8);\n    ms->nextToUpdate = matchEndIdx - 8;  /* skip repetitive patterns */\n    return mnum;\n}\n\ntypedef U32 (*ZSTD_getAllMatchesFn)(\n    ZSTD_match_t*,\n    ZSTD_MatchState_t*,\n    U32*,\n    const BYTE*,\n    const BYTE*,\n    const U32 rep[ZSTD_REP_NUM],\n    U32 const ll0,\n    U32 const lengthToBeat);\n\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nU32 ZSTD_btGetAllMatches_internal(\n        ZSTD_match_t* matches,\n        ZSTD_MatchState_t* ms,\n        U32* nextToUpdate3,\n        const BYTE* ip,\n        const BYTE* const iHighLimit,\n        const U32 rep[ZSTD_REP_NUM],\n        U32 const ll0,\n        U32 const lengthToBeat,\n        const ZSTD_dictMode_e dictMode,\n        const U32 mls)\n{\n    assert(BOUNDED(3, ms->cParams.minMatch, 6) == mls);\n    DEBUGLOG(8, \"ZSTD_BtGetAllMatches(dictMode=%d, mls=%u)\", (int)dictMode, mls);\n    if (ip < ms->window.base + ms->nextToUpdate)\n        return 0;   /* skipped area */\n    ZSTD_updateTree_internal(ms, ip, iHighLimit, mls, dictMode);\n    return ZSTD_insertBtAndGetAllMatches(matches, ms, nextToUpdate3, ip, iHighLimit, dictMode, rep, ll0, lengthToBeat, mls);\n}\n\n#define ZSTD_BT_GET_ALL_MATCHES_FN(dictMode, mls) ZSTD_btGetAllMatches_##dictMode##_##mls\n\n#define GEN_ZSTD_BT_GET_ALL_MATCHES_(dictMode, mls)            \\\n    static U32 ZSTD_BT_GET_ALL_MATCHES_FN(dictMode, mls)(      \\\n            ZSTD_match_t* matches,                             \\\n            ZSTD_MatchState_t* ms,                             \\\n            U32* nextToUpdate3,                                \\\n            const BYTE* ip,                                    \\\n            const BYTE* const iHighLimit,                      \\\n            const U32 rep[ZSTD_REP_NUM],                       \\\n            U32 const ll0,                                     \\\n            U32 const lengthToBeat)                            \\\n    {                                                          \\\n        return ZSTD_btGetAllMatches_internal(                  \\\n                matches, ms, nextToUpdate3, ip, iHighLimit,    \\\n                rep, ll0, lengthToBeat, ZSTD_##dictMode, mls); \\\n    }\n\n#define GEN_ZSTD_BT_GET_ALL_MATCHES(dictMode)  \\\n    GEN_ZSTD_BT_GET_ALL_MATCHES_(dictMode, 3)  \\\n    GEN_ZSTD_BT_GET_ALL_MATCHES_(dictMode, 4)  \\\n    GEN_ZSTD_BT_GET_ALL_MATCHES_(dictMode, 5)  \\\n    GEN_ZSTD_BT_GET_ALL_MATCHES_(dictMode, 6)\n\nGEN_ZSTD_BT_GET_ALL_MATCHES(noDict)\nGEN_ZSTD_BT_GET_ALL_MATCHES(extDict)\nGEN_ZSTD_BT_GET_ALL_MATCHES(dictMatchState)\n\n#define ZSTD_BT_GET_ALL_MATCHES_ARRAY(dictMode)  \\\n    {                                            \\\n        ZSTD_BT_GET_ALL_MATCHES_FN(dictMode, 3), \\\n        ZSTD_BT_GET_ALL_MATCHES_FN(dictMode, 4), \\\n        ZSTD_BT_GET_ALL_MATCHES_FN(dictMode, 5), \\\n        ZSTD_BT_GET_ALL_MATCHES_FN(dictMode, 6)  \\\n    }\n\nstatic ZSTD_getAllMatchesFn\nZSTD_selectBtGetAllMatches(ZSTD_MatchState_t const* ms, ZSTD_dictMode_e const dictMode)\n{\n    ZSTD_getAllMatchesFn const getAllMatchesFns[3][4] = {\n        ZSTD_BT_GET_ALL_MATCHES_ARRAY(noDict),\n        ZSTD_BT_GET_ALL_MATCHES_ARRAY(extDict),\n        ZSTD_BT_GET_ALL_MATCHES_ARRAY(dictMatchState)\n    };\n    U32 const mls = BOUNDED(3, ms->cParams.minMatch, 6);\n    assert((U32)dictMode < 3);\n    assert(mls - 3 < 4);\n    return getAllMatchesFns[(int)dictMode][mls - 3];\n}\n\n/*************************\n*  LDM helper functions  *\n*************************/\n\n/* Struct containing info needed to make decision about ldm inclusion */\ntypedef struct {\n    RawSeqStore_t seqStore;   /* External match candidates store for this block */\n    U32 startPosInBlock;      /* Start position of the current match candidate */\n    U32 endPosInBlock;        /* End position of the current match candidate */\n    U32 offset;               /* Offset of the match candidate */\n} ZSTD_optLdm_t;\n\n/* ZSTD_optLdm_skipRawSeqStoreBytes():\n * Moves forward in @rawSeqStore by @nbBytes,\n * which will update the fields 'pos' and 'posInSequence'.\n */\nstatic void ZSTD_optLdm_skipRawSeqStoreBytes(RawSeqStore_t* rawSeqStore, size_t nbBytes)\n{\n    U32 currPos = (U32)(rawSeqStore->posInSequence + nbBytes);\n    while (currPos && rawSeqStore->pos < rawSeqStore->size) {\n        rawSeq currSeq = rawSeqStore->seq[rawSeqStore->pos];\n        if (currPos >= currSeq.litLength + currSeq.matchLength) {\n            currPos -= currSeq.litLength + currSeq.matchLength;\n            rawSeqStore->pos++;\n        } else {\n            rawSeqStore->posInSequence = currPos;\n            break;\n        }\n    }\n    if (currPos == 0 || rawSeqStore->pos == rawSeqStore->size) {\n        rawSeqStore->posInSequence = 0;\n    }\n}\n\n/* ZSTD_opt_getNextMatchAndUpdateSeqStore():\n * Calculates the beginning and end of the next match in the current block.\n * Updates 'pos' and 'posInSequence' of the ldmSeqStore.\n */\nstatic void\nZSTD_opt_getNextMatchAndUpdateSeqStore(ZSTD_optLdm_t* optLdm, U32 currPosInBlock,\n                                       U32 blockBytesRemaining)\n{\n    rawSeq currSeq;\n    U32 currBlockEndPos;\n    U32 literalsBytesRemaining;\n    U32 matchBytesRemaining;\n\n    /* Setting match end position to MAX to ensure we never use an LDM during this block */\n    if (optLdm->seqStore.size == 0 || optLdm->seqStore.pos >= optLdm->seqStore.size) {\n        optLdm->startPosInBlock = UINT_MAX;\n        optLdm->endPosInBlock = UINT_MAX;\n        return;\n    }\n    /* Calculate appropriate bytes left in matchLength and litLength\n     * after adjusting based on ldmSeqStore->posInSequence */\n    currSeq = optLdm->seqStore.seq[optLdm->seqStore.pos];\n    assert(optLdm->seqStore.posInSequence <= currSeq.litLength + currSeq.matchLength);\n    currBlockEndPos = currPosInBlock + blockBytesRemaining;\n    literalsBytesRemaining = (optLdm->seqStore.posInSequence < currSeq.litLength) ?\n            currSeq.litLength - (U32)optLdm->seqStore.posInSequence :\n            0;\n    matchBytesRemaining = (literalsBytesRemaining == 0) ?\n            currSeq.matchLength - ((U32)optLdm->seqStore.posInSequence - currSeq.litLength) :\n            currSeq.matchLength;\n\n    /* If there are more literal bytes than bytes remaining in block, no ldm is possible */\n    if (literalsBytesRemaining >= blockBytesRemaining) {\n        optLdm->startPosInBlock = UINT_MAX;\n        optLdm->endPosInBlock = UINT_MAX;\n        ZSTD_optLdm_skipRawSeqStoreBytes(&optLdm->seqStore, blockBytesRemaining);\n        return;\n    }\n\n    /* Matches may be < minMatch by this process. In that case, we will reject them\n       when we are deciding whether or not to add the ldm */\n    optLdm->startPosInBlock = currPosInBlock + literalsBytesRemaining;\n    optLdm->endPosInBlock = optLdm->startPosInBlock + matchBytesRemaining;\n    optLdm->offset = currSeq.offset;\n\n    if (optLdm->endPosInBlock > currBlockEndPos) {\n        /* Match ends after the block ends, we can't use the whole match */\n        optLdm->endPosInBlock = currBlockEndPos;\n        ZSTD_optLdm_skipRawSeqStoreBytes(&optLdm->seqStore, currBlockEndPos - currPosInBlock);\n    } else {\n        /* Consume nb of bytes equal to size of sequence left */\n        ZSTD_optLdm_skipRawSeqStoreBytes(&optLdm->seqStore, literalsBytesRemaining + matchBytesRemaining);\n    }\n}\n\n/* ZSTD_optLdm_maybeAddMatch():\n * Adds a match if it's long enough,\n * based on it's 'matchStartPosInBlock' and 'matchEndPosInBlock',\n * into 'matches'. Maintains the correct ordering of 'matches'.\n */\nstatic void ZSTD_optLdm_maybeAddMatch(ZSTD_match_t* matches, U32* nbMatches,\n                                      const ZSTD_optLdm_t* optLdm, U32 currPosInBlock,\n                                      U32 minMatch)\n{\n    U32 const posDiff = currPosInBlock - optLdm->startPosInBlock;\n    /* Note: ZSTD_match_t actually contains offBase and matchLength (before subtracting MINMATCH) */\n    U32 const candidateMatchLength = optLdm->endPosInBlock - optLdm->startPosInBlock - posDiff;\n\n    /* Ensure that current block position is not outside of the match */\n    if (currPosInBlock < optLdm->startPosInBlock\n      || currPosInBlock >= optLdm->endPosInBlock\n      || candidateMatchLength < minMatch) {\n        return;\n    }\n\n    if (*nbMatches == 0 || ((candidateMatchLength > matches[*nbMatches-1].len) && *nbMatches < ZSTD_OPT_NUM)) {\n        U32 const candidateOffBase = OFFSET_TO_OFFBASE(optLdm->offset);\n        DEBUGLOG(6, \"ZSTD_optLdm_maybeAddMatch(): Adding ldm candidate match (offBase: %u matchLength %u) at block position=%u\",\n                 candidateOffBase, candidateMatchLength, currPosInBlock);\n        matches[*nbMatches].len = candidateMatchLength;\n        matches[*nbMatches].off = candidateOffBase;\n        (*nbMatches)++;\n    }\n}\n\n/* ZSTD_optLdm_processMatchCandidate():\n * Wrapper function to update ldm seq store and call ldm functions as necessary.\n */\nstatic void\nZSTD_optLdm_processMatchCandidate(ZSTD_optLdm_t* optLdm,\n                                  ZSTD_match_t* matches, U32* nbMatches,\n                                  U32 currPosInBlock, U32 remainingBytes,\n                                  U32 minMatch)\n{\n    if (optLdm->seqStore.size == 0 || optLdm->seqStore.pos >= optLdm->seqStore.size) {\n        return;\n    }\n\n    if (currPosInBlock >= optLdm->endPosInBlock) {\n        if (currPosInBlock > optLdm->endPosInBlock) {\n            /* The position at which ZSTD_optLdm_processMatchCandidate() is called is not necessarily\n             * at the end of a match from the ldm seq store, and will often be some bytes\n             * over beyond matchEndPosInBlock. As such, we need to correct for these \"overshoots\"\n             */\n            U32 const posOvershoot = currPosInBlock - optLdm->endPosInBlock;\n            ZSTD_optLdm_skipRawSeqStoreBytes(&optLdm->seqStore, posOvershoot);\n        }\n        ZSTD_opt_getNextMatchAndUpdateSeqStore(optLdm, currPosInBlock, remainingBytes);\n    }\n    ZSTD_optLdm_maybeAddMatch(matches, nbMatches, optLdm, currPosInBlock, minMatch);\n}\n\n\n/*-*******************************\n*  Optimal parser\n*********************************/\n\n#if 0 /* debug */\n\nstatic void\nlistStats(const U32* table, int lastEltID)\n{\n    int const nbElts = lastEltID + 1;\n    int enb;\n    for (enb=0; enb < nbElts; enb++) {\n        (void)table;\n        /* RAWLOG(2, \"%3i:%3i,  \", enb, table[enb]); */\n        RAWLOG(2, \"%4i,\", table[enb]);\n    }\n    RAWLOG(2, \" \\n\");\n}\n\n#endif\n\n#define LIT_PRICE(_p) (int)ZSTD_rawLiteralsCost(_p, 1, optStatePtr, optLevel)\n#define LL_PRICE(_l) (int)ZSTD_litLengthPrice(_l, optStatePtr, optLevel)\n#define LL_INCPRICE(_l) (LL_PRICE(_l) - LL_PRICE(_l-1))\n\nFORCE_INLINE_TEMPLATE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t\nZSTD_compressBlock_opt_generic(ZSTD_MatchState_t* ms,\n                               SeqStore_t* seqStore,\n                               U32 rep[ZSTD_REP_NUM],\n                         const void* src, size_t srcSize,\n                         const int optLevel,\n                         const ZSTD_dictMode_e dictMode)\n{\n    optState_t* const optStatePtr = &ms->opt;\n    const BYTE* const istart = (const BYTE*)src;\n    const BYTE* ip = istart;\n    const BYTE* anchor = istart;\n    const BYTE* const iend = istart + srcSize;\n    const BYTE* const ilimit = iend - 8;\n    const BYTE* const base = ms->window.base;\n    const BYTE* const prefixStart = base + ms->window.dictLimit;\n    const ZSTD_compressionParameters* const cParams = &ms->cParams;\n\n    ZSTD_getAllMatchesFn getAllMatches = ZSTD_selectBtGetAllMatches(ms, dictMode);\n\n    U32 const sufficient_len = MIN(cParams->targetLength, ZSTD_OPT_NUM -1);\n    U32 const minMatch = (cParams->minMatch == 3) ? 3 : 4;\n    U32 nextToUpdate3 = ms->nextToUpdate;\n\n    ZSTD_optimal_t* const opt = optStatePtr->priceTable;\n    ZSTD_match_t* const matches = optStatePtr->matchTable;\n    ZSTD_optimal_t lastStretch;\n    ZSTD_optLdm_t optLdm;\n\n    ZSTD_memset(&lastStretch, 0, sizeof(ZSTD_optimal_t));\n\n    optLdm.seqStore = ms->ldmSeqStore ? *ms->ldmSeqStore : kNullRawSeqStore;\n    optLdm.endPosInBlock = optLdm.startPosInBlock = optLdm.offset = 0;\n    ZSTD_opt_getNextMatchAndUpdateSeqStore(&optLdm, (U32)(ip-istart), (U32)(iend-ip));\n\n    /* init */\n    DEBUGLOG(5, \"ZSTD_compressBlock_opt_generic: current=%u, prefix=%u, nextToUpdate=%u\",\n                (U32)(ip - base), ms->window.dictLimit, ms->nextToUpdate);\n    assert(optLevel <= 2);\n    ZSTD_rescaleFreqs(optStatePtr, (const BYTE*)src, srcSize, optLevel);\n    ip += (ip==prefixStart);\n\n    /* Match Loop */\n    while (ip < ilimit) {\n        U32 cur, last_pos = 0;\n\n        /* find first match */\n        {   U32 const litlen = (U32)(ip - anchor);\n            U32 const ll0 = !litlen;\n            U32 nbMatches = getAllMatches(matches, ms, &nextToUpdate3, ip, iend, rep, ll0, minMatch);\n            ZSTD_optLdm_processMatchCandidate(&optLdm, matches, &nbMatches,\n                                              (U32)(ip-istart), (U32)(iend-ip),\n                                              minMatch);\n            if (!nbMatches) {\n                DEBUGLOG(8, \"no match found at cPos %u\", (unsigned)(ip-istart));\n                ip++;\n                continue;\n            }\n\n            /* Match found: let's store this solution, and eventually find more candidates.\n             * During this forward pass, @opt is used to store stretches,\n             * defined as \"a match followed by N literals\".\n             * Note how this is different from a Sequence, which is \"N literals followed by a match\".\n             * Storing stretches allows us to store different match predecessors\n             * for each literal position part of a literals run. */\n\n            /* initialize opt[0] */\n            opt[0].mlen = 0;  /* there are only literals so far */\n            opt[0].litlen = litlen;\n            /* No need to include the actual price of the literals before the first match\n             * because it is static for the duration of the forward pass, and is included\n             * in every subsequent price. But, we include the literal length because\n             * the cost variation of litlen depends on the value of litlen.\n             */\n            opt[0].price = LL_PRICE(litlen);\n            ZSTD_STATIC_ASSERT(sizeof(opt[0].rep[0]) == sizeof(rep[0]));\n            ZSTD_memcpy(&opt[0].rep, rep, sizeof(opt[0].rep));\n\n            /* large match -> immediate encoding */\n            {   U32 const maxML = matches[nbMatches-1].len;\n                U32 const maxOffBase = matches[nbMatches-1].off;\n                DEBUGLOG(6, \"found %u matches of maxLength=%u and maxOffBase=%u at cPos=%u => start new series\",\n                            nbMatches, maxML, maxOffBase, (U32)(ip-prefixStart));\n\n                if (maxML > sufficient_len) {\n                    lastStretch.litlen = 0;\n                    lastStretch.mlen = maxML;\n                    lastStretch.off = maxOffBase;\n                    DEBUGLOG(6, \"large match (%u>%u) => immediate encoding\",\n                                maxML, sufficient_len);\n                    cur = 0;\n                    last_pos = maxML;\n                    goto _shortestPath;\n            }   }\n\n            /* set prices for first matches starting position == 0 */\n            assert(opt[0].price >= 0);\n            {   U32 pos;\n                U32 matchNb;\n                for (pos = 1; pos < minMatch; pos++) {\n                    opt[pos].price = ZSTD_MAX_PRICE;\n                    opt[pos].mlen = 0;\n                    opt[pos].litlen = litlen + pos;\n                }\n                for (matchNb = 0; matchNb < nbMatches; matchNb++) {\n                    U32 const offBase = matches[matchNb].off;\n                    U32 const end = matches[matchNb].len;\n                    for ( ; pos <= end ; pos++ ) {\n                        int const matchPrice = (int)ZSTD_getMatchPrice(offBase, pos, optStatePtr, optLevel);\n                        int const sequencePrice = opt[0].price + matchPrice;\n                        DEBUGLOG(7, \"rPos:%u => set initial price : %.2f\",\n                                    pos, ZSTD_fCost(sequencePrice));\n                        opt[pos].mlen = pos;\n                        opt[pos].off = offBase;\n                        opt[pos].litlen = 0; /* end of match */\n                        opt[pos].price = sequencePrice + LL_PRICE(0);\n                    }\n                }\n                last_pos = pos-1;\n                opt[pos].price = ZSTD_MAX_PRICE;\n            }\n        }\n\n        /* check further positions */\n        for (cur = 1; cur <= last_pos; cur++) {\n            const BYTE* const inr = ip + cur;\n            assert(cur <= ZSTD_OPT_NUM);\n            DEBUGLOG(7, \"cPos:%i==rPos:%u\", (int)(inr-istart), cur);\n\n            /* Fix current position with one literal if cheaper */\n            {   U32 const litlen = opt[cur-1].litlen + 1;\n                int const price = opt[cur-1].price\n                                + LIT_PRICE(ip+cur-1)\n                                + LL_INCPRICE(litlen);\n                assert(price < 1000000000); /* overflow check */\n                if (price <= opt[cur].price) {\n                    ZSTD_optimal_t const prevMatch = opt[cur];\n                    DEBUGLOG(7, \"cPos:%i==rPos:%u : better price (%.2f<=%.2f) using literal (ll==%u) (hist:%u,%u,%u)\",\n                                (int)(inr-istart), cur, ZSTD_fCost(price), ZSTD_fCost(opt[cur].price), litlen,\n                                opt[cur-1].rep[0], opt[cur-1].rep[1], opt[cur-1].rep[2]);\n                    opt[cur] = opt[cur-1];\n                    opt[cur].litlen = litlen;\n                    opt[cur].price = price;\n                    if ( (optLevel >= 1) /* additional check only for higher modes */\n                      && (prevMatch.litlen == 0) /* replace a match */\n                      && (LL_INCPRICE(1) < 0) /* ll1 is cheaper than ll0 */\n                      && LIKELY(ip + cur < iend)\n                    ) {\n                        /* check next position, in case it would be cheaper */\n                        int with1literal = prevMatch.price + LIT_PRICE(ip+cur) + LL_INCPRICE(1);\n                        int withMoreLiterals = price + LIT_PRICE(ip+cur) + LL_INCPRICE(litlen+1);\n                        DEBUGLOG(7, \"then at next rPos %u : match+1lit %.2f vs %ulits %.2f\",\n                                cur+1, ZSTD_fCost(with1literal), litlen+1, ZSTD_fCost(withMoreLiterals));\n                        if ( (with1literal < withMoreLiterals)\n                          && (with1literal < opt[cur+1].price) ) {\n                            /* update offset history - before it disappears */\n                            U32 const prev = cur - prevMatch.mlen;\n                            Repcodes_t const newReps = ZSTD_newRep(opt[prev].rep, prevMatch.off, opt[prev].litlen==0);\n                            assert(cur >= prevMatch.mlen);\n                            DEBUGLOG(7, \"==> match+1lit is cheaper (%.2f < %.2f) (hist:%u,%u,%u) !\",\n                                        ZSTD_fCost(with1literal), ZSTD_fCost(withMoreLiterals),\n                                        newReps.rep[0], newReps.rep[1], newReps.rep[2] );\n                            opt[cur+1] = prevMatch;  /* mlen & offbase */\n                            ZSTD_memcpy(opt[cur+1].rep, &newReps, sizeof(Repcodes_t));\n                            opt[cur+1].litlen = 1;\n                            opt[cur+1].price = with1literal;\n                            if (last_pos < cur+1) last_pos = cur+1;\n                        }\n                    }\n                } else {\n                    DEBUGLOG(7, \"cPos:%i==rPos:%u : literal would cost more (%.2f>%.2f)\",\n                                (int)(inr-istart), cur, ZSTD_fCost(price), ZSTD_fCost(opt[cur].price));\n                }\n            }\n\n            /* Offset history is not updated during match comparison.\n             * Do it here, now that the match is selected and confirmed.\n             */\n            ZSTD_STATIC_ASSERT(sizeof(opt[cur].rep) == sizeof(Repcodes_t));\n            assert(cur >= opt[cur].mlen);\n            if (opt[cur].litlen == 0) {\n                /* just finished a match => alter offset history */\n                U32 const prev = cur - opt[cur].mlen;\n                Repcodes_t const newReps = ZSTD_newRep(opt[prev].rep, opt[cur].off, opt[prev].litlen==0);\n                ZSTD_memcpy(opt[cur].rep, &newReps, sizeof(Repcodes_t));\n            }\n\n            /* last match must start at a minimum distance of 8 from oend */\n            if (inr > ilimit) continue;\n\n            if (cur == last_pos) break;\n\n            if ( (optLevel==0) /*static_test*/\n              && (opt[cur+1].price <= opt[cur].price + (BITCOST_MULTIPLIER/2)) ) {\n                DEBUGLOG(7, \"skip current position : next rPos(%u) price is cheaper\", cur+1);\n                continue;  /* skip unpromising positions; about ~+6% speed, -0.01 ratio */\n            }\n\n            assert(opt[cur].price >= 0);\n            {   U32 const ll0 = (opt[cur].litlen == 0);\n                int const previousPrice = opt[cur].price;\n                int const basePrice = previousPrice + LL_PRICE(0);\n                U32 nbMatches = getAllMatches(matches, ms, &nextToUpdate3, inr, iend, opt[cur].rep, ll0, minMatch);\n                U32 matchNb;\n\n                ZSTD_optLdm_processMatchCandidate(&optLdm, matches, &nbMatches,\n                                                  (U32)(inr-istart), (U32)(iend-inr),\n                                                  minMatch);\n\n                if (!nbMatches) {\n                    DEBUGLOG(7, \"rPos:%u : no match found\", cur);\n                    continue;\n                }\n\n                {   U32 const longestML = matches[nbMatches-1].len;\n                    DEBUGLOG(7, \"cPos:%i==rPos:%u, found %u matches, of longest ML=%u\",\n                                (int)(inr-istart), cur, nbMatches, longestML);\n\n                    if ( (longestML > sufficient_len)\n                      || (cur + longestML >= ZSTD_OPT_NUM)\n                      || (ip + cur + longestML >= iend) ) {\n                        lastStretch.mlen = longestML;\n                        lastStretch.off = matches[nbMatches-1].off;\n                        lastStretch.litlen = 0;\n                        last_pos = cur + longestML;\n                        goto _shortestPath;\n                }   }\n\n                /* set prices using matches found at position == cur */\n                for (matchNb = 0; matchNb < nbMatches; matchNb++) {\n                    U32 const offset = matches[matchNb].off;\n                    U32 const lastML = matches[matchNb].len;\n                    U32 const startML = (matchNb>0) ? matches[matchNb-1].len+1 : minMatch;\n                    U32 mlen;\n\n                    DEBUGLOG(7, \"testing match %u => offBase=%4u, mlen=%2u, llen=%2u\",\n                                matchNb, matches[matchNb].off, lastML, opt[cur].litlen);\n\n                    for (mlen = lastML; mlen >= startML; mlen--) {  /* scan downward */\n                        U32 const pos = cur + mlen;\n                        int const price = basePrice + (int)ZSTD_getMatchPrice(offset, mlen, optStatePtr, optLevel);\n\n                        if ((pos > last_pos) || (price < opt[pos].price)) {\n                            DEBUGLOG(7, \"rPos:%u (ml=%2u) => new better price (%.2f<%.2f)\",\n                                        pos, mlen, ZSTD_fCost(price), ZSTD_fCost(opt[pos].price));\n                            while (last_pos < pos) {\n                                /* fill empty positions, for future comparisons */\n                                last_pos++;\n                                opt[last_pos].price = ZSTD_MAX_PRICE;\n                                opt[last_pos].litlen = !0;  /* just needs to be != 0, to mean \"not an end of match\" */\n                            }\n                            opt[pos].mlen = mlen;\n                            opt[pos].off = offset;\n                            opt[pos].litlen = 0;\n                            opt[pos].price = price;\n                        } else {\n                            DEBUGLOG(7, \"rPos:%u (ml=%2u) => new price is worse (%.2f>=%.2f)\",\n                                        pos, mlen, ZSTD_fCost(price), ZSTD_fCost(opt[pos].price));\n                            if (optLevel==0) break;  /* early update abort; gets ~+10% speed for about -0.01 ratio loss */\n                        }\n            }   }   }\n            opt[last_pos+1].price = ZSTD_MAX_PRICE;\n        }  /* for (cur = 1; cur <= last_pos; cur++) */\n\n        lastStretch = opt[last_pos];\n        assert(cur >= lastStretch.mlen);\n        cur = last_pos - lastStretch.mlen;\n\n_shortestPath:   /* cur, last_pos, best_mlen, best_off have to be set */\n        assert(opt[0].mlen == 0);\n        assert(last_pos >= lastStretch.mlen);\n        assert(cur == last_pos - lastStretch.mlen);\n\n        if (lastStretch.mlen==0) {\n            /* no solution : all matches have been converted into literals */\n            assert(lastStretch.litlen == (ip - anchor) + last_pos);\n            ip += last_pos;\n            continue;\n        }\n        assert(lastStretch.off > 0);\n\n        /* Update offset history */\n        if (lastStretch.litlen == 0) {\n            /* finishing on a match : update offset history */\n            Repcodes_t const reps = ZSTD_newRep(opt[cur].rep, lastStretch.off, opt[cur].litlen==0);\n            ZSTD_memcpy(rep, &reps, sizeof(Repcodes_t));\n        } else {\n            ZSTD_memcpy(rep, lastStretch.rep, sizeof(Repcodes_t));\n            assert(cur >= lastStretch.litlen);\n            cur -= lastStretch.litlen;\n        }\n\n        /* Let's write the shortest path solution.\n         * It is stored in @opt in reverse order,\n         * starting from @storeEnd (==cur+2),\n         * effectively partially @opt overwriting.\n         * Content is changed too:\n         * - So far, @opt stored stretches, aka a match followed by literals\n         * - Now, it will store sequences, aka literals followed by a match\n         */\n        {   U32 const storeEnd = cur + 2;\n            U32 storeStart = storeEnd;\n            U32 stretchPos = cur;\n\n            DEBUGLOG(6, \"start reverse traversal (last_pos:%u, cur:%u)\",\n                        last_pos, cur); (void)last_pos;\n            assert(storeEnd < ZSTD_OPT_SIZE);\n            DEBUGLOG(6, \"last stretch copied into pos=%u (llen=%u,mlen=%u,ofc=%u)\",\n                        storeEnd, lastStretch.litlen, lastStretch.mlen, lastStretch.off);\n            opt[storeEnd] = lastStretch;  /* note: litlen will be fixed */\n            storeStart = storeEnd;\n            while (1) {\n                ZSTD_optimal_t nextStretch = opt[stretchPos];\n                opt[storeStart].litlen = nextStretch.litlen;\n                DEBUGLOG(6, \"selected sequence (llen=%u,mlen=%u,ofc=%u)\",\n                            opt[storeStart].litlen, opt[storeStart].mlen, opt[storeStart].off);\n                if (nextStretch.mlen == 0) {\n                    /* reaching beginning of segment */\n                    break;\n                }\n                storeStart--;\n                opt[storeStart] = nextStretch; /* note: litlen will be fixed */\n                assert(nextStretch.litlen + nextStretch.mlen <= stretchPos);\n                stretchPos -= nextStretch.litlen + nextStretch.mlen;\n            }\n\n            /* save sequences */\n            DEBUGLOG(6, \"sending selected sequences into seqStore\");\n            {   U32 storePos;\n                for (storePos=storeStart; storePos <= storeEnd; storePos++) {\n                    U32 const llen = opt[storePos].litlen;\n                    U32 const mlen = opt[storePos].mlen;\n                    U32 const offBase = opt[storePos].off;\n                    U32 const advance = llen + mlen;\n                    DEBUGLOG(6, \"considering seq starting at %i, llen=%u, mlen=%u\",\n                                (int)(anchor - istart), (unsigned)llen, (unsigned)mlen);\n\n                    if (mlen==0) {  /* only literals => must be last \"sequence\", actually starting a new stream of sequences */\n                        assert(storePos == storeEnd);   /* must be last sequence */\n                        ip = anchor + llen;     /* last \"sequence\" is a bunch of literals => don't progress anchor */\n                        continue;   /* will finish */\n                    }\n\n                    assert(anchor + llen <= iend);\n                    ZSTD_updateStats(optStatePtr, llen, anchor, offBase, mlen);\n                    ZSTD_storeSeq(seqStore, llen, anchor, iend, offBase, mlen);\n                    anchor += advance;\n                    ip = anchor;\n            }   }\n            DEBUGLOG(7, \"new offset history : %u, %u, %u\", rep[0], rep[1], rep[2]);\n\n            /* update all costs */\n            ZSTD_setBasePrices(optStatePtr, optLevel);\n        }\n    }   /* while (ip < ilimit) */\n\n    /* Return the last literals size */\n    return (size_t)(iend - anchor);\n}\n#endif /* build exclusions */\n\n#ifndef ZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR\nstatic size_t ZSTD_compressBlock_opt0(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        const void* src, size_t srcSize, const ZSTD_dictMode_e dictMode)\n{\n    return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 0 /* optLevel */, dictMode);\n}\n#endif\n\n#ifndef ZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR\nstatic size_t ZSTD_compressBlock_opt2(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        const void* src, size_t srcSize, const ZSTD_dictMode_e dictMode)\n{\n    return ZSTD_compressBlock_opt_generic(ms, seqStore, rep, src, srcSize, 2 /* optLevel */, dictMode);\n}\n#endif\n\n#ifndef ZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR\nsize_t ZSTD_compressBlock_btopt(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        const void* src, size_t srcSize)\n{\n    DEBUGLOG(5, \"ZSTD_compressBlock_btopt\");\n    return ZSTD_compressBlock_opt0(ms, seqStore, rep, src, srcSize, ZSTD_noDict);\n}\n#endif\n\n\n\n\n#ifndef ZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR\n/* ZSTD_initStats_ultra():\n * make a first compression pass, just to seed stats with more accurate starting values.\n * only works on first block, with no dictionary and no ldm.\n * this function cannot error out, its narrow contract must be respected.\n */\nstatic\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nvoid ZSTD_initStats_ultra(ZSTD_MatchState_t* ms,\n                          SeqStore_t* seqStore,\n                          U32 rep[ZSTD_REP_NUM],\n                    const void* src, size_t srcSize)\n{\n    U32 tmpRep[ZSTD_REP_NUM];  /* updated rep codes will sink here */\n    ZSTD_memcpy(tmpRep, rep, sizeof(tmpRep));\n\n    DEBUGLOG(4, \"ZSTD_initStats_ultra (srcSize=%zu)\", srcSize);\n    assert(ms->opt.litLengthSum == 0);    /* first block */\n    assert(seqStore->sequences == seqStore->sequencesStart);   /* no ldm */\n    assert(ms->window.dictLimit == ms->window.lowLimit);   /* no dictionary */\n    assert(ms->window.dictLimit - ms->nextToUpdate <= 1);  /* no prefix (note: intentional overflow, defined as 2-complement) */\n\n    ZSTD_compressBlock_opt2(ms, seqStore, tmpRep, src, srcSize, ZSTD_noDict);   /* generate stats into ms->opt*/\n\n    /* invalidate first scan from history, only keep entropy stats */\n    ZSTD_resetSeqStore(seqStore);\n    ms->window.base -= srcSize;\n    ms->window.dictLimit += (U32)srcSize;\n    ms->window.lowLimit = ms->window.dictLimit;\n    ms->nextToUpdate = ms->window.dictLimit;\n\n}\n\nsize_t ZSTD_compressBlock_btultra(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        const void* src, size_t srcSize)\n{\n    DEBUGLOG(5, \"ZSTD_compressBlock_btultra (srcSize=%zu)\", srcSize);\n    return ZSTD_compressBlock_opt2(ms, seqStore, rep, src, srcSize, ZSTD_noDict);\n}\n\nsize_t ZSTD_compressBlock_btultra2(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        const void* src, size_t srcSize)\n{\n    U32 const curr = (U32)((const BYTE*)src - ms->window.base);\n    DEBUGLOG(5, \"ZSTD_compressBlock_btultra2 (srcSize=%zu)\", srcSize);\n\n    /* 2-passes strategy:\n     * this strategy makes a first pass over first block to collect statistics\n     * in order to seed next round's statistics with it.\n     * After 1st pass, function forgets history, and starts a new block.\n     * Consequently, this can only work if no data has been previously loaded in tables,\n     * aka, no dictionary, no prefix, no ldm preprocessing.\n     * The compression ratio gain is generally small (~0.5% on first block),\n     * the cost is 2x cpu time on first block. */\n    assert(srcSize <= ZSTD_BLOCKSIZE_MAX);\n    if ( (ms->opt.litLengthSum==0)   /* first block */\n      && (seqStore->sequences == seqStore->sequencesStart)  /* no ldm */\n      && (ms->window.dictLimit == ms->window.lowLimit)   /* no dictionary */\n      && (curr == ms->window.dictLimit)    /* start of frame, nothing already loaded nor skipped */\n      && (srcSize > ZSTD_PREDEF_THRESHOLD) /* input large enough to not employ default stats */\n      ) {\n        ZSTD_initStats_ultra(ms, seqStore, rep, src, srcSize);\n    }\n\n    return ZSTD_compressBlock_opt2(ms, seqStore, rep, src, srcSize, ZSTD_noDict);\n}\n#endif\n\n#ifndef ZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR\nsize_t ZSTD_compressBlock_btopt_dictMatchState(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        const void* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_opt0(ms, seqStore, rep, src, srcSize, ZSTD_dictMatchState);\n}\n\nsize_t ZSTD_compressBlock_btopt_extDict(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        const void* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_opt0(ms, seqStore, rep, src, srcSize, ZSTD_extDict);\n}\n#endif\n\n#ifndef ZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR\nsize_t ZSTD_compressBlock_btultra_dictMatchState(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        const void* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_opt2(ms, seqStore, rep, src, srcSize, ZSTD_dictMatchState);\n}\n\nsize_t ZSTD_compressBlock_btultra_extDict(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        const void* src, size_t srcSize)\n{\n    return ZSTD_compressBlock_opt2(ms, seqStore, rep, src, srcSize, ZSTD_extDict);\n}\n#endif\n\n/* note : no btultra2 variant for extDict nor dictMatchState,\n * because btultra2 is not meant to work with dictionaries\n * and is only specific for the first block (no prefix) */\n"
  },
  {
    "path": "lib/compress/zstd_opt.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_OPT_H\n#define ZSTD_OPT_H\n\n#include \"zstd_compress_internal.h\"\n\n#if !defined(ZSTD_EXCLUDE_BTLAZY2_BLOCK_COMPRESSOR) \\\n || !defined(ZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR) \\\n || !defined(ZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR)\n/* used in ZSTD_loadDictionaryContent() */\nvoid ZSTD_updateTree(ZSTD_MatchState_t* ms, const BYTE* ip, const BYTE* iend);\n#endif\n\n#ifndef ZSTD_EXCLUDE_BTOPT_BLOCK_COMPRESSOR\nsize_t ZSTD_compressBlock_btopt(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_btopt_dictMatchState(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_btopt_extDict(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\n\n#define ZSTD_COMPRESSBLOCK_BTOPT ZSTD_compressBlock_btopt\n#define ZSTD_COMPRESSBLOCK_BTOPT_DICTMATCHSTATE ZSTD_compressBlock_btopt_dictMatchState\n#define ZSTD_COMPRESSBLOCK_BTOPT_EXTDICT ZSTD_compressBlock_btopt_extDict\n#else\n#define ZSTD_COMPRESSBLOCK_BTOPT NULL\n#define ZSTD_COMPRESSBLOCK_BTOPT_DICTMATCHSTATE NULL\n#define ZSTD_COMPRESSBLOCK_BTOPT_EXTDICT NULL\n#endif\n\n#ifndef ZSTD_EXCLUDE_BTULTRA_BLOCK_COMPRESSOR\nsize_t ZSTD_compressBlock_btultra(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_btultra_dictMatchState(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\nsize_t ZSTD_compressBlock_btultra_extDict(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\n\n        /* note : no btultra2 variant for extDict nor dictMatchState,\n         * because btultra2 is not meant to work with dictionaries\n         * and is only specific for the first block (no prefix) */\nsize_t ZSTD_compressBlock_btultra2(\n        ZSTD_MatchState_t* ms, SeqStore_t* seqStore, U32 rep[ZSTD_REP_NUM],\n        void const* src, size_t srcSize);\n\n#define ZSTD_COMPRESSBLOCK_BTULTRA ZSTD_compressBlock_btultra\n#define ZSTD_COMPRESSBLOCK_BTULTRA_DICTMATCHSTATE ZSTD_compressBlock_btultra_dictMatchState\n#define ZSTD_COMPRESSBLOCK_BTULTRA_EXTDICT ZSTD_compressBlock_btultra_extDict\n#define ZSTD_COMPRESSBLOCK_BTULTRA2 ZSTD_compressBlock_btultra2\n#else\n#define ZSTD_COMPRESSBLOCK_BTULTRA NULL\n#define ZSTD_COMPRESSBLOCK_BTULTRA_DICTMATCHSTATE NULL\n#define ZSTD_COMPRESSBLOCK_BTULTRA_EXTDICT NULL\n#define ZSTD_COMPRESSBLOCK_BTULTRA2 NULL\n#endif\n\n#endif /* ZSTD_OPT_H */\n"
  },
  {
    "path": "lib/compress/zstd_preSplit.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#include \"../common/compiler.h\" /* ZSTD_ALIGNOF */\n#include \"../common/mem.h\" /* S64 */\n#include \"../common/zstd_deps.h\" /* ZSTD_memset */\n#include \"../common/zstd_internal.h\" /* ZSTD_STATIC_ASSERT */\n#include \"hist.h\" /* HIST_add */\n#include \"zstd_preSplit.h\"\n\n\n#define BLOCKSIZE_MIN 3500\n#define THRESHOLD_PENALTY_RATE 16\n#define THRESHOLD_BASE (THRESHOLD_PENALTY_RATE - 2)\n#define THRESHOLD_PENALTY 3\n\n#define HASHLENGTH 2\n#define HASHLOG_MAX 10\n#define HASHTABLESIZE (1 << HASHLOG_MAX)\n#define HASHMASK (HASHTABLESIZE - 1)\n#define KNUTH 0x9e3779b9\n\n/* for hashLog > 8, hash 2 bytes.\n * for hashLog == 8, just take the byte, no hashing.\n * The speed of this method relies on compile-time constant propagation */\nFORCE_INLINE_TEMPLATE unsigned hash2(const void *p, unsigned hashLog)\n{\n    assert(hashLog >= 8);\n    if (hashLog == 8) return (U32)((const BYTE*)p)[0];\n    assert(hashLog <= HASHLOG_MAX);\n    return (U32)(MEM_read16(p)) * KNUTH >> (32 - hashLog);\n}\n\n\ntypedef struct {\n  unsigned events[HASHTABLESIZE];\n  size_t nbEvents;\n} Fingerprint;\ntypedef struct {\n    Fingerprint pastEvents;\n    Fingerprint newEvents;\n} FPStats;\n\nstatic void initStats(FPStats* fpstats)\n{\n    ZSTD_memset(fpstats, 0, sizeof(FPStats));\n}\n\nFORCE_INLINE_TEMPLATE void\naddEvents_generic(Fingerprint* fp, const void* src, size_t srcSize, size_t samplingRate, unsigned hashLog)\n{\n    const char* p = (const char*)src;\n    size_t limit = srcSize - HASHLENGTH + 1;\n    size_t n;\n    assert(srcSize >= HASHLENGTH);\n    for (n = 0; n < limit; n+=samplingRate) {\n        fp->events[hash2(p+n, hashLog)]++;\n    }\n    fp->nbEvents += limit/samplingRate;\n}\n\nFORCE_INLINE_TEMPLATE void\nrecordFingerprint_generic(Fingerprint* fp, const void* src, size_t srcSize, size_t samplingRate, unsigned hashLog)\n{\n    ZSTD_memset(fp, 0, sizeof(unsigned) * ((size_t)1 << hashLog));\n    fp->nbEvents = 0;\n    addEvents_generic(fp, src, srcSize, samplingRate, hashLog);\n}\n\ntypedef void (*RecordEvents_f)(Fingerprint* fp, const void* src, size_t srcSize);\n\n#define FP_RECORD(_rate) ZSTD_recordFingerprint_##_rate\n\n#define ZSTD_GEN_RECORD_FINGERPRINT(_rate, _hSize)                                 \\\n    static void FP_RECORD(_rate)(Fingerprint* fp, const void* src, size_t srcSize) \\\n    {                                                                              \\\n        recordFingerprint_generic(fp, src, srcSize, _rate, _hSize);                \\\n    }\n\nZSTD_GEN_RECORD_FINGERPRINT(1, 10)\nZSTD_GEN_RECORD_FINGERPRINT(5, 10)\nZSTD_GEN_RECORD_FINGERPRINT(11, 9)\nZSTD_GEN_RECORD_FINGERPRINT(43, 8)\n\n\nstatic U64 abs64(S64 s64) { return (U64)((s64 < 0) ? -s64 : s64); }\n\nstatic U64 fpDistance(const Fingerprint* fp1, const Fingerprint* fp2, unsigned hashLog)\n{\n    U64 distance = 0;\n    size_t n;\n    assert(hashLog <= HASHLOG_MAX);\n    for (n = 0; n < ((size_t)1 << hashLog); n++) {\n        distance +=\n            abs64((S64)fp1->events[n] * (S64)fp2->nbEvents - (S64)fp2->events[n] * (S64)fp1->nbEvents);\n    }\n    return distance;\n}\n\n/* Compare newEvents with pastEvents\n * return 1 when considered \"too different\"\n */\nstatic int compareFingerprints(const Fingerprint* ref,\n                            const Fingerprint* newfp,\n                            int penalty,\n                            unsigned hashLog)\n{\n    assert(ref->nbEvents > 0);\n    assert(newfp->nbEvents > 0);\n    {   U64 p50 = (U64)ref->nbEvents * (U64)newfp->nbEvents;\n        U64 deviation = fpDistance(ref, newfp, hashLog);\n        U64 threshold = p50 * (U64)(THRESHOLD_BASE + penalty) / THRESHOLD_PENALTY_RATE;\n        return deviation >= threshold;\n    }\n}\n\nstatic void mergeEvents(Fingerprint* acc, const Fingerprint* newfp)\n{\n    size_t n;\n    for (n = 0; n < HASHTABLESIZE; n++) {\n        acc->events[n] += newfp->events[n];\n    }\n    acc->nbEvents += newfp->nbEvents;\n}\n\nstatic void flushEvents(FPStats* fpstats)\n{\n    size_t n;\n    for (n = 0; n < HASHTABLESIZE; n++) {\n        fpstats->pastEvents.events[n] = fpstats->newEvents.events[n];\n    }\n    fpstats->pastEvents.nbEvents = fpstats->newEvents.nbEvents;\n    ZSTD_memset(&fpstats->newEvents, 0, sizeof(fpstats->newEvents));\n}\n\nstatic void removeEvents(Fingerprint* acc, const Fingerprint* slice)\n{\n    size_t n;\n    for (n = 0; n < HASHTABLESIZE; n++) {\n        assert(acc->events[n] >= slice->events[n]);\n        acc->events[n] -= slice->events[n];\n    }\n    acc->nbEvents -= slice->nbEvents;\n}\n\n#define CHUNKSIZE (8 << 10)\nstatic size_t ZSTD_splitBlock_byChunks(const void* blockStart, size_t blockSize,\n                        int level,\n                        void* workspace, size_t wkspSize)\n{\n    static const RecordEvents_f records_fs[] = {\n        FP_RECORD(43), FP_RECORD(11), FP_RECORD(5), FP_RECORD(1)\n    };\n    static const unsigned hashParams[] = { 8, 9, 10, 10 };\n    const RecordEvents_f record_f = (assert(0<=level && level<=3), records_fs[level]);\n    FPStats* const fpstats = (FPStats*)workspace;\n    const char* p = (const char*)blockStart;\n    int penalty = THRESHOLD_PENALTY;\n    size_t pos = 0;\n    assert(blockSize == (128 << 10));\n    assert(workspace != NULL);\n    assert((size_t)workspace % ZSTD_ALIGNOF(FPStats) == 0);\n    ZSTD_STATIC_ASSERT(ZSTD_SLIPBLOCK_WORKSPACESIZE >= sizeof(FPStats));\n    assert(wkspSize >= sizeof(FPStats)); (void)wkspSize;\n\n    initStats(fpstats);\n    record_f(&fpstats->pastEvents, p, CHUNKSIZE);\n    for (pos = CHUNKSIZE; pos <= blockSize - CHUNKSIZE; pos += CHUNKSIZE) {\n        record_f(&fpstats->newEvents, p + pos, CHUNKSIZE);\n        if (compareFingerprints(&fpstats->pastEvents, &fpstats->newEvents, penalty, hashParams[level])) {\n            return pos;\n        } else {\n            mergeEvents(&fpstats->pastEvents, &fpstats->newEvents);\n            if (penalty > 0) penalty--;\n        }\n    }\n    assert(pos == blockSize);\n    return blockSize;\n    (void)flushEvents; (void)removeEvents;\n}\n\n/* ZSTD_splitBlock_fromBorders(): very fast strategy :\n * compare fingerprint from beginning and end of the block,\n * derive from their difference if it's preferable to split in the middle,\n * repeat the process a second time, for finer grained decision.\n * 3 times did not brought improvements, so I stopped at 2.\n * Benefits are good enough for a cheap heuristic.\n * More accurate splitting saves more, but speed impact is also more perceptible.\n * For better accuracy, use more elaborate variant *_byChunks.\n */\nstatic size_t ZSTD_splitBlock_fromBorders(const void* blockStart, size_t blockSize,\n                        void* workspace, size_t wkspSize)\n{\n#define SEGMENT_SIZE 512\n    FPStats* const fpstats = (FPStats*)workspace;\n    Fingerprint* middleEvents = (Fingerprint*)(void*)((char*)workspace + 512 * sizeof(unsigned));\n    assert(blockSize == (128 << 10));\n    assert(workspace != NULL);\n    assert((size_t)workspace % ZSTD_ALIGNOF(FPStats) == 0);\n    ZSTD_STATIC_ASSERT(ZSTD_SLIPBLOCK_WORKSPACESIZE >= sizeof(FPStats));\n    assert(wkspSize >= sizeof(FPStats)); (void)wkspSize;\n\n    initStats(fpstats);\n    HIST_add(fpstats->pastEvents.events, blockStart, SEGMENT_SIZE);\n    HIST_add(fpstats->newEvents.events, (const char*)blockStart + blockSize - SEGMENT_SIZE, SEGMENT_SIZE);\n    fpstats->pastEvents.nbEvents = fpstats->newEvents.nbEvents = SEGMENT_SIZE;\n    if (!compareFingerprints(&fpstats->pastEvents, &fpstats->newEvents, 0, 8))\n        return blockSize;\n\n    HIST_add(middleEvents->events, (const char*)blockStart + blockSize/2 - SEGMENT_SIZE/2, SEGMENT_SIZE);\n    middleEvents->nbEvents = SEGMENT_SIZE;\n    {   U64 const distFromBegin = fpDistance(&fpstats->pastEvents, middleEvents, 8);\n        U64 const distFromEnd = fpDistance(&fpstats->newEvents, middleEvents, 8);\n        U64 const minDistance = SEGMENT_SIZE * SEGMENT_SIZE / 3;\n        if (abs64((S64)distFromBegin - (S64)distFromEnd) < minDistance)\n            return 64 KB;\n        return (distFromBegin > distFromEnd) ? 32 KB : 96 KB;\n    }\n}\n\nsize_t ZSTD_splitBlock(const void* blockStart, size_t blockSize,\n                    int level,\n                    void* workspace, size_t wkspSize)\n{\n    DEBUGLOG(6, \"ZSTD_splitBlock (level=%i)\", level);\n    assert(0<=level && level<=4);\n    if (level == 0)\n        return ZSTD_splitBlock_fromBorders(blockStart, blockSize, workspace, wkspSize);\n    /* level >= 1*/\n    return ZSTD_splitBlock_byChunks(blockStart, blockSize, level-1, workspace, wkspSize);\n}\n"
  },
  {
    "path": "lib/compress/zstd_preSplit.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_PRESPLIT_H\n#define ZSTD_PRESPLIT_H\n\n#include   /* size_t */\n\n#define ZSTD_SLIPBLOCK_WORKSPACESIZE 8208\n\n/* ZSTD_splitBlock():\n * @level must be a value between 0 and 4.\n *        higher levels spend more energy to detect block boundaries.\n * @workspace must be aligned for size_t.\n * @wkspSize must be at least >= ZSTD_SLIPBLOCK_WORKSPACESIZE\n * note:\n * For the time being, this function only accepts full 128 KB blocks.\n * Therefore, @blockSize must be == 128 KB.\n * While this could be extended to smaller sizes in the future,\n * it is not yet clear if this would be useful. TBD.\n */\nsize_t ZSTD_splitBlock(const void* blockStart, size_t blockSize,\n                    int level,\n                    void* workspace, size_t wkspSize);\n\n#endif /* ZSTD_PRESPLIT_H */\n"
  },
  {
    "path": "lib/compress/zstdmt_compress.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n\n/* ======   Compiler specifics   ====== */\n#if defined(_MSC_VER)\n#  pragma warning(disable : 4204)   /* disable: C4204: non-constant aggregate initializer */\n#endif\n\n\n/* ======   Dependencies   ====== */\n#include \"../common/allocations.h\" /* ZSTD_customMalloc, ZSTD_customCalloc, ZSTD_customFree */\n#include \"../common/zstd_deps.h\"   /* ZSTD_memcpy, ZSTD_memset, INT_MAX, UINT_MAX */\n#include \"../common/mem.h\"         /* MEM_STATIC */\n#include \"../common/pool.h\"        /* threadpool */\n#include \"../common/threading.h\"   /* mutex */\n#include \"zstd_compress_internal.h\" /* MIN, ERROR, ZSTD_*, ZSTD_highbit32 */\n#include \"zstd_ldm.h\"\n#include \"zstdmt_compress.h\"\n\n/* Guards code to support resizing the SeqPool.\n * We will want to resize the SeqPool to save memory in the future.\n * Until then, comment the code out since it is unused.\n */\n#define ZSTD_RESIZE_SEQPOOL 0\n\n/* ======   Debug   ====== */\n#if defined(DEBUGLEVEL) && (DEBUGLEVEL>=2) \\\n    && !defined(_MSC_VER) \\\n    && !defined(__MINGW32__)\n\n#  include \n#  include \n#  include \n\n#  define DEBUG_PRINTHEX(l,p,n)                                       \\\n    do {                                                              \\\n        unsigned debug_u;                                             \\\n        for (debug_u=0; debug_u<(n); debug_u++)                       \\\n            RAWLOG(l, \"%02X \", ((const unsigned char*)(p))[debug_u]); \\\n        RAWLOG(l, \" \\n\");                                             \\\n    } while (0)\n\nstatic unsigned long long GetCurrentClockTimeMicroseconds(void)\n{\n   static clock_t _ticksPerSecond = 0;\n   if (_ticksPerSecond <= 0) _ticksPerSecond = sysconf(_SC_CLK_TCK);\n\n   {   struct tms junk; clock_t newTicks = (clock_t) times(&junk);\n       return ((((unsigned long long)newTicks)*(1000000))/_ticksPerSecond);\n}  }\n\n#define MUTEX_WAIT_TIME_DLEVEL 6\n#define ZSTD_PTHREAD_MUTEX_LOCK(mutex)                                                  \\\n    do {                                                                                \\\n        if (DEBUGLEVEL >= MUTEX_WAIT_TIME_DLEVEL) {                                     \\\n            unsigned long long const beforeTime = GetCurrentClockTimeMicroseconds();    \\\n            ZSTD_pthread_mutex_lock(mutex);                                             \\\n            {   unsigned long long const afterTime = GetCurrentClockTimeMicroseconds(); \\\n                unsigned long long const elapsedTime = (afterTime-beforeTime);          \\\n                if (elapsedTime > 1000) {                                               \\\n                    /* or whatever threshold you like; I'm using 1 millisecond here */  \\\n                    DEBUGLOG(MUTEX_WAIT_TIME_DLEVEL,                                    \\\n                        \"Thread took %llu microseconds to acquire mutex %s \\n\",         \\\n                        elapsedTime, #mutex);                                           \\\n            }   }                                                                       \\\n        } else {                                                                        \\\n            ZSTD_pthread_mutex_lock(mutex);                                             \\\n        }                                                                               \\\n    } while (0)\n\n#else\n\n#  define ZSTD_PTHREAD_MUTEX_LOCK(m) ZSTD_pthread_mutex_lock(m)\n#  define DEBUG_PRINTHEX(l,p,n) do { } while (0)\n\n#endif\n\n\n/* =====   Buffer Pool   ===== */\n/* a single Buffer Pool can be invoked from multiple threads in parallel */\n\ntypedef struct buffer_s {\n    void* start;\n    size_t capacity;\n} Buffer;\n\nstatic const Buffer g_nullBuffer = { NULL, 0 };\n\ntypedef struct ZSTDMT_bufferPool_s {\n    ZSTD_pthread_mutex_t poolMutex;\n    size_t bufferSize;\n    unsigned totalBuffers;\n    unsigned nbBuffers;\n    ZSTD_customMem cMem;\n    Buffer* buffers;\n} ZSTDMT_bufferPool;\n\nstatic void ZSTDMT_freeBufferPool(ZSTDMT_bufferPool* bufPool)\n{\n    DEBUGLOG(3, \"ZSTDMT_freeBufferPool (address:%08X)\", (U32)(size_t)bufPool);\n    if (!bufPool) return;   /* compatibility with free on NULL */\n    if (bufPool->buffers) {\n        unsigned u;\n        for (u=0; utotalBuffers; u++) {\n            DEBUGLOG(4, \"free buffer %2u (address:%08X)\", u, (U32)(size_t)bufPool->buffers[u].start);\n            ZSTD_customFree(bufPool->buffers[u].start, bufPool->cMem);\n        }\n        ZSTD_customFree(bufPool->buffers, bufPool->cMem);\n    }\n    ZSTD_pthread_mutex_destroy(&bufPool->poolMutex);\n    ZSTD_customFree(bufPool, bufPool->cMem);\n}\n\nstatic ZSTDMT_bufferPool* ZSTDMT_createBufferPool(unsigned maxNbBuffers, ZSTD_customMem cMem)\n{\n    ZSTDMT_bufferPool* const bufPool =\n        (ZSTDMT_bufferPool*)ZSTD_customCalloc(sizeof(ZSTDMT_bufferPool), cMem);\n    if (bufPool==NULL) return NULL;\n    if (ZSTD_pthread_mutex_init(&bufPool->poolMutex, NULL)) {\n        ZSTD_customFree(bufPool, cMem);\n        return NULL;\n    }\n    bufPool->buffers = (Buffer*)ZSTD_customCalloc(maxNbBuffers * sizeof(Buffer), cMem);\n    if (bufPool->buffers==NULL) {\n        ZSTDMT_freeBufferPool(bufPool);\n        return NULL;\n    }\n    bufPool->bufferSize = 64 KB;\n    bufPool->totalBuffers = maxNbBuffers;\n    bufPool->nbBuffers = 0;\n    bufPool->cMem = cMem;\n    return bufPool;\n}\n\n/* only works at initialization, not during compression */\nstatic size_t ZSTDMT_sizeof_bufferPool(ZSTDMT_bufferPool* bufPool)\n{\n    size_t const poolSize = sizeof(*bufPool);\n    size_t const arraySize = bufPool->totalBuffers * sizeof(Buffer);\n    unsigned u;\n    size_t totalBufferSize = 0;\n    ZSTD_pthread_mutex_lock(&bufPool->poolMutex);\n    for (u=0; utotalBuffers; u++)\n        totalBufferSize += bufPool->buffers[u].capacity;\n    ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);\n\n    return poolSize + arraySize + totalBufferSize;\n}\n\n/* ZSTDMT_setBufferSize() :\n * all future buffers provided by this buffer pool will have _at least_ this size\n * note : it's better for all buffers to have same size,\n * as they become freely interchangeable, reducing malloc/free usages and memory fragmentation */\nstatic void ZSTDMT_setBufferSize(ZSTDMT_bufferPool* const bufPool, size_t const bSize)\n{\n    ZSTD_pthread_mutex_lock(&bufPool->poolMutex);\n    DEBUGLOG(4, \"ZSTDMT_setBufferSize: bSize = %u\", (U32)bSize);\n    bufPool->bufferSize = bSize;\n    ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);\n}\n\n\nstatic ZSTDMT_bufferPool* ZSTDMT_expandBufferPool(ZSTDMT_bufferPool* srcBufPool, unsigned maxNbBuffers)\n{\n    if (srcBufPool==NULL) return NULL;\n    if (srcBufPool->totalBuffers >= maxNbBuffers) /* good enough */\n        return srcBufPool;\n    /* need a larger buffer pool */\n    {   ZSTD_customMem const cMem = srcBufPool->cMem;\n        size_t const bSize = srcBufPool->bufferSize;   /* forward parameters */\n        ZSTDMT_bufferPool* newBufPool;\n        ZSTDMT_freeBufferPool(srcBufPool);\n        newBufPool = ZSTDMT_createBufferPool(maxNbBuffers, cMem);\n        if (newBufPool==NULL) return newBufPool;\n        ZSTDMT_setBufferSize(newBufPool, bSize);\n        return newBufPool;\n    }\n}\n\n/** ZSTDMT_getBuffer() :\n *  assumption : bufPool must be valid\n * @return : a buffer, with start pointer and size\n *  note: allocation may fail, in this case, start==NULL and size==0 */\nstatic Buffer ZSTDMT_getBuffer(ZSTDMT_bufferPool* bufPool)\n{\n    size_t const bSize = bufPool->bufferSize;\n    DEBUGLOG(5, \"ZSTDMT_getBuffer: bSize = %u\", (U32)bufPool->bufferSize);\n    ZSTD_pthread_mutex_lock(&bufPool->poolMutex);\n    if (bufPool->nbBuffers) {   /* try to use an existing buffer */\n        Buffer const buf = bufPool->buffers[--(bufPool->nbBuffers)];\n        size_t const availBufferSize = buf.capacity;\n        bufPool->buffers[bufPool->nbBuffers] = g_nullBuffer;\n        if ((availBufferSize >= bSize) & ((availBufferSize>>3) <= bSize)) {\n            /* large enough, but not too much */\n            DEBUGLOG(5, \"ZSTDMT_getBuffer: provide buffer %u of size %u\",\n                        bufPool->nbBuffers, (U32)buf.capacity);\n            ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);\n            return buf;\n        }\n        /* size conditions not respected : scratch this buffer, create new one */\n        DEBUGLOG(5, \"ZSTDMT_getBuffer: existing buffer does not meet size conditions => freeing\");\n        ZSTD_customFree(buf.start, bufPool->cMem);\n    }\n    ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);\n    /* create new buffer */\n    DEBUGLOG(5, \"ZSTDMT_getBuffer: create a new buffer\");\n    {   Buffer buffer;\n        void* const start = ZSTD_customMalloc(bSize, bufPool->cMem);\n        buffer.start = start;   /* note : start can be NULL if malloc fails ! */\n        buffer.capacity = (start==NULL) ? 0 : bSize;\n        if (start==NULL) {\n            DEBUGLOG(5, \"ZSTDMT_getBuffer: buffer allocation failure !!\");\n        } else {\n            DEBUGLOG(5, \"ZSTDMT_getBuffer: created buffer of size %u\", (U32)bSize);\n        }\n        return buffer;\n    }\n}\n\n#if ZSTD_RESIZE_SEQPOOL\n/** ZSTDMT_resizeBuffer() :\n * assumption : bufPool must be valid\n * @return : a buffer that is at least the buffer pool buffer size.\n *           If a reallocation happens, the data in the input buffer is copied.\n */\nstatic Buffer ZSTDMT_resizeBuffer(ZSTDMT_bufferPool* bufPool, Buffer buffer)\n{\n    size_t const bSize = bufPool->bufferSize;\n    if (buffer.capacity < bSize) {\n        void* const start = ZSTD_customMalloc(bSize, bufPool->cMem);\n        Buffer newBuffer;\n        newBuffer.start = start;\n        newBuffer.capacity = start == NULL ? 0 : bSize;\n        if (start != NULL) {\n            assert(newBuffer.capacity >= buffer.capacity);\n            ZSTD_memcpy(newBuffer.start, buffer.start, buffer.capacity);\n            DEBUGLOG(5, \"ZSTDMT_resizeBuffer: created buffer of size %u\", (U32)bSize);\n            return newBuffer;\n        }\n        DEBUGLOG(5, \"ZSTDMT_resizeBuffer: buffer allocation failure !!\");\n    }\n    return buffer;\n}\n#endif\n\n/* store buffer for later re-use, up to pool capacity */\nstatic void ZSTDMT_releaseBuffer(ZSTDMT_bufferPool* bufPool, Buffer buf)\n{\n    DEBUGLOG(5, \"ZSTDMT_releaseBuffer\");\n    if (buf.start == NULL) return;   /* compatible with release on NULL */\n    ZSTD_pthread_mutex_lock(&bufPool->poolMutex);\n    if (bufPool->nbBuffers < bufPool->totalBuffers) {\n        bufPool->buffers[bufPool->nbBuffers++] = buf;  /* stored for later use */\n        DEBUGLOG(5, \"ZSTDMT_releaseBuffer: stored buffer of size %u in slot %u\",\n                    (U32)buf.capacity, (U32)(bufPool->nbBuffers-1));\n        ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);\n        return;\n    }\n    ZSTD_pthread_mutex_unlock(&bufPool->poolMutex);\n    /* Reached bufferPool capacity (note: should not happen) */\n    DEBUGLOG(5, \"ZSTDMT_releaseBuffer: pool capacity reached => freeing \");\n    ZSTD_customFree(buf.start, bufPool->cMem);\n}\n\n/* We need 2 output buffers per worker since each dstBuff must be flushed after it is released.\n * The 3 additional buffers are as follows:\n *   1 buffer for input loading\n *   1 buffer for \"next input\" when submitting current one\n *   1 buffer stuck in queue */\n#define BUF_POOL_MAX_NB_BUFFERS(nbWorkers) (2*(nbWorkers) + 3)\n\n/* After a worker releases its rawSeqStore, it is immediately ready for reuse.\n * So we only need one seq buffer per worker. */\n#define SEQ_POOL_MAX_NB_BUFFERS(nbWorkers) (nbWorkers)\n\n/* =====   Seq Pool Wrapper   ====== */\n\ntypedef ZSTDMT_bufferPool ZSTDMT_seqPool;\n\nstatic size_t ZSTDMT_sizeof_seqPool(ZSTDMT_seqPool* seqPool)\n{\n    return ZSTDMT_sizeof_bufferPool(seqPool);\n}\n\nstatic RawSeqStore_t bufferToSeq(Buffer buffer)\n{\n    RawSeqStore_t seq = kNullRawSeqStore;\n    seq.seq = (rawSeq*)buffer.start;\n    seq.capacity = buffer.capacity / sizeof(rawSeq);\n    return seq;\n}\n\nstatic Buffer seqToBuffer(RawSeqStore_t seq)\n{\n    Buffer buffer;\n    buffer.start = seq.seq;\n    buffer.capacity = seq.capacity * sizeof(rawSeq);\n    return buffer;\n}\n\nstatic RawSeqStore_t ZSTDMT_getSeq(ZSTDMT_seqPool* seqPool)\n{\n    if (seqPool->bufferSize == 0) {\n        return kNullRawSeqStore;\n    }\n    return bufferToSeq(ZSTDMT_getBuffer(seqPool));\n}\n\n#if ZSTD_RESIZE_SEQPOOL\nstatic RawSeqStore_t ZSTDMT_resizeSeq(ZSTDMT_seqPool* seqPool, RawSeqStore_t seq)\n{\n  return bufferToSeq(ZSTDMT_resizeBuffer(seqPool, seqToBuffer(seq)));\n}\n#endif\n\nstatic void ZSTDMT_releaseSeq(ZSTDMT_seqPool* seqPool, RawSeqStore_t seq)\n{\n  ZSTDMT_releaseBuffer(seqPool, seqToBuffer(seq));\n}\n\nstatic void ZSTDMT_setNbSeq(ZSTDMT_seqPool* const seqPool, size_t const nbSeq)\n{\n  ZSTDMT_setBufferSize(seqPool, nbSeq * sizeof(rawSeq));\n}\n\nstatic ZSTDMT_seqPool* ZSTDMT_createSeqPool(unsigned nbWorkers, ZSTD_customMem cMem)\n{\n    ZSTDMT_seqPool* const seqPool = ZSTDMT_createBufferPool(SEQ_POOL_MAX_NB_BUFFERS(nbWorkers), cMem);\n    if (seqPool == NULL) return NULL;\n    ZSTDMT_setNbSeq(seqPool, 0);\n    return seqPool;\n}\n\nstatic void ZSTDMT_freeSeqPool(ZSTDMT_seqPool* seqPool)\n{\n    ZSTDMT_freeBufferPool(seqPool);\n}\n\nstatic ZSTDMT_seqPool* ZSTDMT_expandSeqPool(ZSTDMT_seqPool* pool, U32 nbWorkers)\n{\n    return ZSTDMT_expandBufferPool(pool, SEQ_POOL_MAX_NB_BUFFERS(nbWorkers));\n}\n\n\n/* =====   CCtx Pool   ===== */\n/* a single CCtx Pool can be invoked from multiple threads in parallel */\n\ntypedef struct {\n    ZSTD_pthread_mutex_t poolMutex;\n    int totalCCtx;\n    int availCCtx;\n    ZSTD_customMem cMem;\n    ZSTD_CCtx** cctxs;\n} ZSTDMT_CCtxPool;\n\n/* note : all CCtx borrowed from the pool must be reverted back to the pool _before_ freeing the pool */\nstatic void ZSTDMT_freeCCtxPool(ZSTDMT_CCtxPool* pool)\n{\n    if (!pool) return;\n    ZSTD_pthread_mutex_destroy(&pool->poolMutex);\n    if (pool->cctxs) {\n        int cid;\n        for (cid=0; cidtotalCCtx; cid++)\n            ZSTD_freeCCtx(pool->cctxs[cid]);  /* free compatible with NULL */\n        ZSTD_customFree(pool->cctxs, pool->cMem);\n    }\n    ZSTD_customFree(pool, pool->cMem);\n}\n\n/* ZSTDMT_createCCtxPool() :\n * implies nbWorkers >= 1 , checked by caller ZSTDMT_createCCtx() */\nstatic ZSTDMT_CCtxPool* ZSTDMT_createCCtxPool(int nbWorkers,\n                                              ZSTD_customMem cMem)\n{\n    ZSTDMT_CCtxPool* const cctxPool =\n        (ZSTDMT_CCtxPool*) ZSTD_customCalloc(sizeof(ZSTDMT_CCtxPool), cMem);\n    assert(nbWorkers > 0);\n    if (!cctxPool) return NULL;\n    if (ZSTD_pthread_mutex_init(&cctxPool->poolMutex, NULL)) {\n        ZSTD_customFree(cctxPool, cMem);\n        return NULL;\n    }\n    cctxPool->totalCCtx = nbWorkers;\n    cctxPool->cctxs = (ZSTD_CCtx**)ZSTD_customCalloc(nbWorkers * sizeof(ZSTD_CCtx*), cMem);\n    if (!cctxPool->cctxs) {\n        ZSTDMT_freeCCtxPool(cctxPool);\n        return NULL;\n    }\n    cctxPool->cMem = cMem;\n    cctxPool->cctxs[0] = ZSTD_createCCtx_advanced(cMem);\n    if (!cctxPool->cctxs[0]) { ZSTDMT_freeCCtxPool(cctxPool); return NULL; }\n    cctxPool->availCCtx = 1;   /* at least one cctx for single-thread mode */\n    DEBUGLOG(3, \"cctxPool created, with %u workers\", nbWorkers);\n    return cctxPool;\n}\n\nstatic ZSTDMT_CCtxPool* ZSTDMT_expandCCtxPool(ZSTDMT_CCtxPool* srcPool,\n                                              int nbWorkers)\n{\n    if (srcPool==NULL) return NULL;\n    if (nbWorkers <= srcPool->totalCCtx) return srcPool;   /* good enough */\n    /* need a larger cctx pool */\n    {   ZSTD_customMem const cMem = srcPool->cMem;\n        ZSTDMT_freeCCtxPool(srcPool);\n        return ZSTDMT_createCCtxPool(nbWorkers, cMem);\n    }\n}\n\n/* only works during initialization phase, not during compression */\nstatic size_t ZSTDMT_sizeof_CCtxPool(ZSTDMT_CCtxPool* cctxPool)\n{\n    ZSTD_pthread_mutex_lock(&cctxPool->poolMutex);\n    {   unsigned const nbWorkers = cctxPool->totalCCtx;\n        size_t const poolSize = sizeof(*cctxPool);\n        size_t const arraySize = cctxPool->totalCCtx * sizeof(ZSTD_CCtx*);\n        size_t totalCCtxSize = 0;\n        unsigned u;\n        for (u=0; ucctxs[u]);\n        }\n        ZSTD_pthread_mutex_unlock(&cctxPool->poolMutex);\n        assert(nbWorkers > 0);\n        return poolSize + arraySize + totalCCtxSize;\n    }\n}\n\nstatic ZSTD_CCtx* ZSTDMT_getCCtx(ZSTDMT_CCtxPool* cctxPool)\n{\n    DEBUGLOG(5, \"ZSTDMT_getCCtx\");\n    ZSTD_pthread_mutex_lock(&cctxPool->poolMutex);\n    if (cctxPool->availCCtx) {\n        cctxPool->availCCtx--;\n        {   ZSTD_CCtx* const cctx = cctxPool->cctxs[cctxPool->availCCtx];\n            ZSTD_pthread_mutex_unlock(&cctxPool->poolMutex);\n            return cctx;\n    }   }\n    ZSTD_pthread_mutex_unlock(&cctxPool->poolMutex);\n    DEBUGLOG(5, \"create one more CCtx\");\n    return ZSTD_createCCtx_advanced(cctxPool->cMem);   /* note : can be NULL, when creation fails ! */\n}\n\nstatic void ZSTDMT_releaseCCtx(ZSTDMT_CCtxPool* pool, ZSTD_CCtx* cctx)\n{\n    if (cctx==NULL) return;   /* compatibility with release on NULL */\n    ZSTD_pthread_mutex_lock(&pool->poolMutex);\n    if (pool->availCCtx < pool->totalCCtx)\n        pool->cctxs[pool->availCCtx++] = cctx;\n    else {\n        /* pool overflow : should not happen, since totalCCtx==nbWorkers */\n        DEBUGLOG(4, \"CCtx pool overflow : free cctx\");\n        ZSTD_freeCCtx(cctx);\n    }\n    ZSTD_pthread_mutex_unlock(&pool->poolMutex);\n}\n\n/* ====   Serial State   ==== */\n\ntypedef struct {\n    void const* start;\n    size_t size;\n} Range;\n\ntypedef struct {\n    /* All variables in the struct are protected by mutex. */\n    ZSTD_pthread_mutex_t mutex;\n    ZSTD_pthread_cond_t cond;\n    ZSTD_CCtx_params params;\n    ldmState_t ldmState;\n    XXH64_state_t xxhState;\n    unsigned nextJobID;\n    /* Protects ldmWindow.\n     * Must be acquired after the main mutex when acquiring both.\n     */\n    ZSTD_pthread_mutex_t ldmWindowMutex;\n    ZSTD_pthread_cond_t ldmWindowCond;  /* Signaled when ldmWindow is updated */\n    ZSTD_window_t ldmWindow;  /* A thread-safe copy of ldmState.window */\n} SerialState;\n\nstatic int\nZSTDMT_serialState_reset(SerialState* serialState,\n                         ZSTDMT_seqPool* seqPool,\n                         ZSTD_CCtx_params params,\n                         size_t jobSize,\n                         const void* dict, size_t const dictSize,\n                         ZSTD_dictContentType_e dictContentType)\n{\n    /* Adjust parameters */\n    if (params.ldmParams.enableLdm == ZSTD_ps_enable) {\n        DEBUGLOG(4, \"LDM window size = %u KB\", (1U << params.cParams.windowLog) >> 10);\n        ZSTD_ldm_adjustParameters(¶ms.ldmParams, ¶ms.cParams);\n        assert(params.ldmParams.hashLog >= params.ldmParams.bucketSizeLog);\n        assert(params.ldmParams.hashRateLog < 32);\n    } else {\n        ZSTD_memset(¶ms.ldmParams, 0, sizeof(params.ldmParams));\n    }\n    serialState->nextJobID = 0;\n    if (params.fParams.checksumFlag)\n        XXH64_reset(&serialState->xxhState, 0);\n    if (params.ldmParams.enableLdm == ZSTD_ps_enable) {\n        ZSTD_customMem cMem = params.customMem;\n        unsigned const hashLog = params.ldmParams.hashLog;\n        size_t const hashSize = ((size_t)1 << hashLog) * sizeof(ldmEntry_t);\n        unsigned const bucketLog =\n            params.ldmParams.hashLog - params.ldmParams.bucketSizeLog;\n        unsigned const prevBucketLog =\n            serialState->params.ldmParams.hashLog -\n            serialState->params.ldmParams.bucketSizeLog;\n        size_t const numBuckets = (size_t)1 << bucketLog;\n        /* Size the seq pool tables */\n        ZSTDMT_setNbSeq(seqPool, ZSTD_ldm_getMaxNbSeq(params.ldmParams, jobSize));\n        /* Reset the window */\n        ZSTD_window_init(&serialState->ldmState.window);\n        /* Resize tables and output space if necessary. */\n        if (serialState->ldmState.hashTable == NULL || serialState->params.ldmParams.hashLog < hashLog) {\n            ZSTD_customFree(serialState->ldmState.hashTable, cMem);\n            serialState->ldmState.hashTable = (ldmEntry_t*)ZSTD_customMalloc(hashSize, cMem);\n        }\n        if (serialState->ldmState.bucketOffsets == NULL || prevBucketLog < bucketLog) {\n            ZSTD_customFree(serialState->ldmState.bucketOffsets, cMem);\n            serialState->ldmState.bucketOffsets = (BYTE*)ZSTD_customMalloc(numBuckets, cMem);\n        }\n        if (!serialState->ldmState.hashTable || !serialState->ldmState.bucketOffsets)\n            return 1;\n        /* Zero the tables */\n        ZSTD_memset(serialState->ldmState.hashTable, 0, hashSize);\n        ZSTD_memset(serialState->ldmState.bucketOffsets, 0, numBuckets);\n\n        /* Update window state and fill hash table with dict */\n        serialState->ldmState.loadedDictEnd = 0;\n        if (dictSize > 0) {\n            if (dictContentType == ZSTD_dct_rawContent) {\n                BYTE const* const dictEnd = (const BYTE*)dict + dictSize;\n                ZSTD_window_update(&serialState->ldmState.window, dict, dictSize, /* forceNonContiguous */ 0);\n                ZSTD_ldm_fillHashTable(&serialState->ldmState, (const BYTE*)dict, dictEnd, ¶ms.ldmParams);\n                serialState->ldmState.loadedDictEnd = params.forceWindow ? 0 : (U32)(dictEnd - serialState->ldmState.window.base);\n            } else {\n                /* don't even load anything */\n            }\n        }\n\n        /* Initialize serialState's copy of ldmWindow. */\n        serialState->ldmWindow = serialState->ldmState.window;\n    }\n\n    serialState->params = params;\n    serialState->params.jobSize = (U32)jobSize;\n    return 0;\n}\n\nstatic int ZSTDMT_serialState_init(SerialState* serialState)\n{\n    int initError = 0;\n    ZSTD_memset(serialState, 0, sizeof(*serialState));\n    initError |= ZSTD_pthread_mutex_init(&serialState->mutex, NULL);\n    initError |= ZSTD_pthread_cond_init(&serialState->cond, NULL);\n    initError |= ZSTD_pthread_mutex_init(&serialState->ldmWindowMutex, NULL);\n    initError |= ZSTD_pthread_cond_init(&serialState->ldmWindowCond, NULL);\n    return initError;\n}\n\nstatic void ZSTDMT_serialState_free(SerialState* serialState)\n{\n    ZSTD_customMem cMem = serialState->params.customMem;\n    ZSTD_pthread_mutex_destroy(&serialState->mutex);\n    ZSTD_pthread_cond_destroy(&serialState->cond);\n    ZSTD_pthread_mutex_destroy(&serialState->ldmWindowMutex);\n    ZSTD_pthread_cond_destroy(&serialState->ldmWindowCond);\n    ZSTD_customFree(serialState->ldmState.hashTable, cMem);\n    ZSTD_customFree(serialState->ldmState.bucketOffsets, cMem);\n}\n\nstatic void\nZSTDMT_serialState_genSequences(SerialState* serialState,\n                                RawSeqStore_t* seqStore,\n                                Range src, unsigned jobID)\n{\n    /* Wait for our turn */\n    ZSTD_PTHREAD_MUTEX_LOCK(&serialState->mutex);\n    while (serialState->nextJobID < jobID) {\n        DEBUGLOG(5, \"wait for serialState->cond\");\n        ZSTD_pthread_cond_wait(&serialState->cond, &serialState->mutex);\n    }\n    /* A future job may error and skip our job */\n    if (serialState->nextJobID == jobID) {\n        /* It is now our turn, do any processing necessary */\n        if (serialState->params.ldmParams.enableLdm == ZSTD_ps_enable) {\n            size_t error;\n            DEBUGLOG(6, \"ZSTDMT_serialState_genSequences: LDM update\");\n            assert(seqStore->seq != NULL && seqStore->pos == 0 &&\n                   seqStore->size == 0 && seqStore->capacity > 0);\n            assert(src.size <= serialState->params.jobSize);\n            ZSTD_window_update(&serialState->ldmState.window, src.start, src.size, /* forceNonContiguous */ 0);\n            error = ZSTD_ldm_generateSequences(\n                &serialState->ldmState, seqStore,\n                &serialState->params.ldmParams, src.start, src.size);\n            /* We provide a large enough buffer to never fail. */\n            assert(!ZSTD_isError(error)); (void)error;\n            /* Update ldmWindow to match the ldmState.window and signal the main\n             * thread if it is waiting for a buffer.\n             */\n            ZSTD_PTHREAD_MUTEX_LOCK(&serialState->ldmWindowMutex);\n            serialState->ldmWindow = serialState->ldmState.window;\n            ZSTD_pthread_cond_signal(&serialState->ldmWindowCond);\n            ZSTD_pthread_mutex_unlock(&serialState->ldmWindowMutex);\n        }\n        if (serialState->params.fParams.checksumFlag && src.size > 0)\n            XXH64_update(&serialState->xxhState, src.start, src.size);\n    }\n    /* Now it is the next jobs turn */\n    serialState->nextJobID++;\n    ZSTD_pthread_cond_broadcast(&serialState->cond);\n    ZSTD_pthread_mutex_unlock(&serialState->mutex);\n}\n\nstatic void\nZSTDMT_serialState_applySequences(const SerialState* serialState, /* just for an assert() check */\n                                  ZSTD_CCtx* jobCCtx,\n                                  const RawSeqStore_t* seqStore)\n{\n    if (seqStore->size > 0) {\n        DEBUGLOG(5, \"ZSTDMT_serialState_applySequences: uploading %u external sequences\", (unsigned)seqStore->size);\n        assert(serialState->params.ldmParams.enableLdm == ZSTD_ps_enable); (void)serialState;\n        assert(jobCCtx);\n        ZSTD_referenceExternalSequences(jobCCtx, seqStore->seq, seqStore->size);\n    }\n}\n\nstatic void ZSTDMT_serialState_ensureFinished(SerialState* serialState,\n                                              unsigned jobID, size_t cSize)\n{\n    ZSTD_PTHREAD_MUTEX_LOCK(&serialState->mutex);\n    if (serialState->nextJobID <= jobID) {\n        assert(ZSTD_isError(cSize)); (void)cSize;\n        DEBUGLOG(5, \"Skipping past job %u because of error\", jobID);\n        serialState->nextJobID = jobID + 1;\n        ZSTD_pthread_cond_broadcast(&serialState->cond);\n\n        ZSTD_PTHREAD_MUTEX_LOCK(&serialState->ldmWindowMutex);\n        ZSTD_window_clear(&serialState->ldmWindow);\n        ZSTD_pthread_cond_signal(&serialState->ldmWindowCond);\n        ZSTD_pthread_mutex_unlock(&serialState->ldmWindowMutex);\n    }\n    ZSTD_pthread_mutex_unlock(&serialState->mutex);\n\n}\n\n\n/* ------------------------------------------ */\n/* =====          Worker thread         ===== */\n/* ------------------------------------------ */\n\nstatic const Range kNullRange = { NULL, 0 };\n\ntypedef struct {\n    size_t   consumed;                 /* SHARED - set0 by mtctx, then modified by worker AND read by mtctx */\n    size_t   cSize;                    /* SHARED - set0 by mtctx, then modified by worker AND read by mtctx, then set0 by mtctx */\n    ZSTD_pthread_mutex_t job_mutex;    /* Thread-safe - used by mtctx and worker */\n    ZSTD_pthread_cond_t job_cond;      /* Thread-safe - used by mtctx and worker */\n    ZSTDMT_CCtxPool* cctxPool;         /* Thread-safe - used by mtctx and (all) workers */\n    ZSTDMT_bufferPool* bufPool;        /* Thread-safe - used by mtctx and (all) workers */\n    ZSTDMT_seqPool* seqPool;           /* Thread-safe - used by mtctx and (all) workers */\n    SerialState* serial;               /* Thread-safe - used by mtctx and (all) workers */\n    Buffer dstBuff;                    /* set by worker (or mtctx), then read by worker & mtctx, then modified by mtctx => no barrier */\n    Range prefix;                      /* set by mtctx, then read by worker & mtctx => no barrier */\n    Range src;                         /* set by mtctx, then read by worker & mtctx => no barrier */\n    unsigned jobID;                    /* set by mtctx, then read by worker => no barrier */\n    unsigned firstJob;                 /* set by mtctx, then read by worker => no barrier */\n    unsigned lastJob;                  /* set by mtctx, then read by worker => no barrier */\n    ZSTD_CCtx_params params;           /* set by mtctx, then read by worker => no barrier */\n    const ZSTD_CDict* cdict;           /* set by mtctx, then read by worker => no barrier */\n    unsigned long long fullFrameSize;  /* set by mtctx, then read by worker => no barrier */\n    size_t   dstFlushed;               /* used only by mtctx */\n    unsigned frameChecksumNeeded;      /* used only by mtctx */\n} ZSTDMT_jobDescription;\n\n#define JOB_ERROR(e)                                \\\n    do {                                            \\\n        ZSTD_PTHREAD_MUTEX_LOCK(&job->job_mutex);   \\\n        job->cSize = e;                             \\\n        ZSTD_pthread_mutex_unlock(&job->job_mutex); \\\n        goto _endJob;                               \\\n    } while (0)\n\n/* ZSTDMT_compressionJob() is a POOL_function type */\nstatic void ZSTDMT_compressionJob(void* jobDescription)\n{\n    ZSTDMT_jobDescription* const job = (ZSTDMT_jobDescription*)jobDescription;\n    ZSTD_CCtx_params jobParams = job->params;   /* do not modify job->params ! copy it, modify the copy */\n    ZSTD_CCtx* const cctx = ZSTDMT_getCCtx(job->cctxPool);\n    RawSeqStore_t rawSeqStore = ZSTDMT_getSeq(job->seqPool);\n    Buffer dstBuff = job->dstBuff;\n    size_t lastCBlockSize = 0;\n\n    DEBUGLOG(5, \"ZSTDMT_compressionJob: job %u\", job->jobID);\n    /* resources */\n    if (cctx==NULL) JOB_ERROR(ERROR(memory_allocation));\n    if (dstBuff.start == NULL) {   /* streaming job : doesn't provide a dstBuffer */\n        dstBuff = ZSTDMT_getBuffer(job->bufPool);\n        if (dstBuff.start==NULL) JOB_ERROR(ERROR(memory_allocation));\n        job->dstBuff = dstBuff;   /* this value can be read in ZSTDMT_flush, when it copies the whole job */\n    }\n    if (jobParams.ldmParams.enableLdm == ZSTD_ps_enable && rawSeqStore.seq == NULL)\n        JOB_ERROR(ERROR(memory_allocation));\n\n    /* Don't compute the checksum for chunks, since we compute it externally,\n     * but write it in the header.\n     */\n    if (job->jobID != 0) jobParams.fParams.checksumFlag = 0;\n    /* Don't run LDM for the chunks, since we handle it externally */\n    jobParams.ldmParams.enableLdm = ZSTD_ps_disable;\n    /* Correct nbWorkers to 0. */\n    jobParams.nbWorkers = 0;\n\n\n    /* init */\n\n    /* Perform serial step as early as possible */\n    ZSTDMT_serialState_genSequences(job->serial, &rawSeqStore, job->src, job->jobID);\n\n    if (job->cdict) {\n        size_t const initError = ZSTD_compressBegin_advanced_internal(cctx, NULL, 0, ZSTD_dct_auto, ZSTD_dtlm_fast, job->cdict, &jobParams, job->fullFrameSize);\n        assert(job->firstJob);  /* only allowed for first job */\n        if (ZSTD_isError(initError)) JOB_ERROR(initError);\n    } else {\n        U64 const pledgedSrcSize = job->firstJob ? job->fullFrameSize : job->src.size;\n        {   size_t const forceWindowError = ZSTD_CCtxParams_setParameter(&jobParams, ZSTD_c_forceMaxWindow, !job->firstJob);\n            if (ZSTD_isError(forceWindowError)) JOB_ERROR(forceWindowError);\n        }\n        if (!job->firstJob) {\n            size_t const err = ZSTD_CCtxParams_setParameter(&jobParams, ZSTD_c_deterministicRefPrefix, 0);\n            if (ZSTD_isError(err)) JOB_ERROR(err);\n        }\n        DEBUGLOG(6, \"ZSTDMT_compressionJob: job %u: loading prefix of size %zu\", job->jobID, job->prefix.size);\n        {   size_t const initError = ZSTD_compressBegin_advanced_internal(cctx,\n                                        job->prefix.start, job->prefix.size, ZSTD_dct_rawContent,\n                                        ZSTD_dtlm_fast,\n                                        NULL, /*cdict*/\n                                        &jobParams, pledgedSrcSize);\n            if (ZSTD_isError(initError)) JOB_ERROR(initError);\n    }   }\n\n    /* External Sequences can only be applied after CCtx initialization */\n    ZSTDMT_serialState_applySequences(job->serial, cctx, &rawSeqStore);\n\n    if (!job->firstJob) {  /* flush and overwrite frame header when it's not first job */\n        size_t const hSize = ZSTD_compressContinue_public(cctx, dstBuff.start, dstBuff.capacity, job->src.start, 0);\n        if (ZSTD_isError(hSize)) JOB_ERROR(hSize);\n        DEBUGLOG(5, \"ZSTDMT_compressionJob: flush and overwrite %u bytes of frame header (not first job)\", (U32)hSize);\n        ZSTD_invalidateRepCodes(cctx);\n    }\n\n    /* compress the entire job by smaller chunks, for better granularity */\n    {   size_t const chunkSize = 4*ZSTD_BLOCKSIZE_MAX;\n        int const nbChunks = (int)((job->src.size + (chunkSize-1)) / chunkSize);\n        const BYTE* ip = (const BYTE*) job->src.start;\n        BYTE* const ostart = (BYTE*)dstBuff.start;\n        BYTE* op = ostart;\n        BYTE* oend = op + dstBuff.capacity;\n        int chunkNb;\n        if (sizeof(size_t) > sizeof(int)) assert(job->src.size < ((size_t)INT_MAX) * chunkSize);   /* check overflow */\n        DEBUGLOG(5, \"ZSTDMT_compressionJob: compress %u bytes in %i blocks\", (U32)job->src.size, nbChunks);\n        assert(job->cSize == 0);\n        for (chunkNb = 1; chunkNb < nbChunks; chunkNb++) {\n            size_t const cSize = ZSTD_compressContinue_public(cctx, op, oend-op, ip, chunkSize);\n            if (ZSTD_isError(cSize)) JOB_ERROR(cSize);\n            ip += chunkSize;\n            op += cSize; assert(op < oend);\n            /* stats */\n            ZSTD_PTHREAD_MUTEX_LOCK(&job->job_mutex);\n            job->cSize += cSize;\n            job->consumed = chunkSize * chunkNb;\n            DEBUGLOG(5, \"ZSTDMT_compressionJob: compress new block : cSize==%u bytes (total: %u)\",\n                        (U32)cSize, (U32)job->cSize);\n            ZSTD_pthread_cond_signal(&job->job_cond);   /* warns some more data is ready to be flushed */\n            ZSTD_pthread_mutex_unlock(&job->job_mutex);\n        }\n        /* last block */\n        assert(chunkSize > 0);\n        assert((chunkSize & (chunkSize - 1)) == 0);  /* chunkSize must be power of 2 for mask==(chunkSize-1) to work */\n        if ((nbChunks > 0) | job->lastJob /*must output a \"last block\" flag*/ ) {\n            size_t const lastBlockSize1 = job->src.size & (chunkSize-1);\n            size_t const lastBlockSize = ((lastBlockSize1==0) & (job->src.size>=chunkSize)) ? chunkSize : lastBlockSize1;\n            size_t const cSize = (job->lastJob) ?\n                 ZSTD_compressEnd_public(cctx, op, oend-op, ip, lastBlockSize) :\n                 ZSTD_compressContinue_public(cctx, op, oend-op, ip, lastBlockSize);\n            if (ZSTD_isError(cSize)) JOB_ERROR(cSize);\n            lastCBlockSize = cSize;\n    }   }\n    if (!job->firstJob) {\n        /* Double check that we don't have an ext-dict, because then our\n         * repcode invalidation doesn't work.\n         */\n        assert(!ZSTD_window_hasExtDict(cctx->blockState.matchState.window));\n    }\n    ZSTD_CCtx_trace(cctx, 0);\n\n_endJob:\n    ZSTDMT_serialState_ensureFinished(job->serial, job->jobID, job->cSize);\n    if (job->prefix.size > 0)\n        DEBUGLOG(5, \"Finished with prefix: %zx\", (size_t)job->prefix.start);\n    DEBUGLOG(5, \"Finished with source: %zx\", (size_t)job->src.start);\n    /* release resources */\n    ZSTDMT_releaseSeq(job->seqPool, rawSeqStore);\n    ZSTDMT_releaseCCtx(job->cctxPool, cctx);\n    /* report */\n    ZSTD_PTHREAD_MUTEX_LOCK(&job->job_mutex);\n    if (ZSTD_isError(job->cSize)) assert(lastCBlockSize == 0);\n    job->cSize += lastCBlockSize;\n    job->consumed = job->src.size;  /* when job->consumed == job->src.size , compression job is presumed completed */\n    ZSTD_pthread_cond_signal(&job->job_cond);\n    ZSTD_pthread_mutex_unlock(&job->job_mutex);\n}\n\n\n/* ------------------------------------------ */\n/* =====   Multi-threaded compression   ===== */\n/* ------------------------------------------ */\n\ntypedef struct {\n    Range prefix;         /* read-only non-owned prefix buffer */\n    Buffer buffer;\n    size_t filled;\n} InBuff_t;\n\ntypedef struct {\n  BYTE* buffer;     /* The round input buffer. All jobs get references\n                     * to pieces of the buffer. ZSTDMT_tryGetInputRange()\n                     * handles handing out job input buffers, and makes\n                     * sure it doesn't overlap with any pieces still in use.\n                     */\n  size_t capacity;  /* The capacity of buffer. */\n  size_t pos;       /* The position of the current inBuff in the round\n                     * buffer. Updated past the end if the inBuff once\n                     * the inBuff is sent to the worker thread.\n                     * pos <= capacity.\n                     */\n} RoundBuff_t;\n\nstatic const RoundBuff_t kNullRoundBuff = {NULL, 0, 0};\n\n#define RSYNC_LENGTH 32\n/* Don't create chunks smaller than the zstd block size.\n * This stops us from regressing compression ratio too much,\n * and ensures our output fits in ZSTD_compressBound().\n *\n * If this is shrunk < ZSTD_BLOCKSIZELOG_MIN then\n * ZSTD_COMPRESSBOUND() will need to be updated.\n */\n#define RSYNC_MIN_BLOCK_LOG ZSTD_BLOCKSIZELOG_MAX\n#define RSYNC_MIN_BLOCK_SIZE (1< one job is already prepared, but pool has shortage of workers. Don't create a new job. */\n    InBuff_t inBuff;\n    RoundBuff_t roundBuff;\n    SerialState serial;\n    RSyncState_t rsync;\n    unsigned jobIDMask;\n    unsigned doneJobID;\n    unsigned nextJobID;\n    unsigned frameEnded;\n    unsigned allJobsCompleted;\n    unsigned long long frameContentSize;\n    unsigned long long consumed;\n    unsigned long long produced;\n    ZSTD_customMem cMem;\n    ZSTD_CDict* cdictLocal;\n    const ZSTD_CDict* cdict;\n    unsigned providedFactory: 1;\n};\n\nstatic void ZSTDMT_freeJobsTable(ZSTDMT_jobDescription* jobTable, U32 nbJobs, ZSTD_customMem cMem)\n{\n    U32 jobNb;\n    if (jobTable == NULL) return;\n    for (jobNb=0; jobNb mtctx->jobIDMask+1) {  /* need more job capacity */\n        ZSTDMT_freeJobsTable(mtctx->jobs, mtctx->jobIDMask+1, mtctx->cMem);\n        mtctx->jobIDMask = 0;\n        mtctx->jobs = ZSTDMT_createJobsTable(&nbJobs, mtctx->cMem);\n        if (mtctx->jobs==NULL) return ERROR(memory_allocation);\n        assert((nbJobs != 0) && ((nbJobs & (nbJobs - 1)) == 0));  /* ensure nbJobs is a power of 2 */\n        mtctx->jobIDMask = nbJobs - 1;\n    }\n    return 0;\n}\n\n\n/* ZSTDMT_CCtxParam_setNbWorkers():\n * Internal use only */\nstatic size_t ZSTDMT_CCtxParam_setNbWorkers(ZSTD_CCtx_params* params, unsigned nbWorkers)\n{\n    return ZSTD_CCtxParams_setParameter(params, ZSTD_c_nbWorkers, (int)nbWorkers);\n}\n\nMEM_STATIC ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced_internal(unsigned nbWorkers, ZSTD_customMem cMem, ZSTD_threadPool* pool)\n{\n    ZSTDMT_CCtx* mtctx;\n    U32 nbJobs = nbWorkers + 2;\n    int initError;\n    DEBUGLOG(3, \"ZSTDMT_createCCtx_advanced (nbWorkers = %u)\", nbWorkers);\n\n    if (nbWorkers < 1) return NULL;\n    nbWorkers = MIN(nbWorkers , ZSTDMT_NBWORKERS_MAX);\n    if ((cMem.customAlloc!=NULL) ^ (cMem.customFree!=NULL))\n        /* invalid custom allocator */\n        return NULL;\n\n    mtctx = (ZSTDMT_CCtx*) ZSTD_customCalloc(sizeof(ZSTDMT_CCtx), cMem);\n    if (!mtctx) return NULL;\n    ZSTDMT_CCtxParam_setNbWorkers(&mtctx->params, nbWorkers);\n    mtctx->cMem = cMem;\n    mtctx->allJobsCompleted = 1;\n    if (pool != NULL) {\n      mtctx->factory = pool;\n      mtctx->providedFactory = 1;\n    }\n    else {\n      mtctx->factory = POOL_create_advanced(nbWorkers, 0, cMem);\n      mtctx->providedFactory = 0;\n    }\n    mtctx->jobs = ZSTDMT_createJobsTable(&nbJobs, cMem);\n    assert(nbJobs > 0); assert((nbJobs & (nbJobs - 1)) == 0);  /* ensure nbJobs is a power of 2 */\n    mtctx->jobIDMask = nbJobs - 1;\n    mtctx->bufPool = ZSTDMT_createBufferPool(BUF_POOL_MAX_NB_BUFFERS(nbWorkers), cMem);\n    mtctx->cctxPool = ZSTDMT_createCCtxPool(nbWorkers, cMem);\n    mtctx->seqPool = ZSTDMT_createSeqPool(nbWorkers, cMem);\n    initError = ZSTDMT_serialState_init(&mtctx->serial);\n    mtctx->roundBuff = kNullRoundBuff;\n    if (!mtctx->factory | !mtctx->jobs | !mtctx->bufPool | !mtctx->cctxPool | !mtctx->seqPool | initError) {\n        ZSTDMT_freeCCtx(mtctx);\n        return NULL;\n    }\n    DEBUGLOG(3, \"mt_cctx created, for %u threads\", nbWorkers);\n    return mtctx;\n}\n\nZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbWorkers, ZSTD_customMem cMem, ZSTD_threadPool* pool)\n{\n#ifdef ZSTD_MULTITHREAD\n    return ZSTDMT_createCCtx_advanced_internal(nbWorkers, cMem, pool);\n#else\n    (void)nbWorkers;\n    (void)cMem;\n    (void)pool;\n    return NULL;\n#endif\n}\n\n\n/* ZSTDMT_releaseAllJobResources() :\n * note : ensure all workers are killed first ! */\nstatic void ZSTDMT_releaseAllJobResources(ZSTDMT_CCtx* mtctx)\n{\n    unsigned jobID;\n    DEBUGLOG(3, \"ZSTDMT_releaseAllJobResources\");\n    if (mtctx->jobs) {\n        for (jobID=0; jobID <= mtctx->jobIDMask; jobID++) {\n            /* Copy the mutex/cond out */\n            ZSTD_pthread_mutex_t const mutex = mtctx->jobs[jobID].job_mutex;\n            ZSTD_pthread_cond_t const cond = mtctx->jobs[jobID].job_cond;\n            \n            DEBUGLOG(4, \"job%02u: release dst address %08X\", jobID, (U32)(size_t)mtctx->jobs[jobID].dstBuff.start);\n            ZSTDMT_releaseBuffer(mtctx->bufPool, mtctx->jobs[jobID].dstBuff);\n            \n            /* Clear the job description, but keep the mutex/cond */\n            ZSTD_memset(&mtctx->jobs[jobID], 0, sizeof(mtctx->jobs[jobID]));\n            mtctx->jobs[jobID].job_mutex = mutex;\n            mtctx->jobs[jobID].job_cond = cond;\n        }\n    }\n    mtctx->inBuff.buffer = g_nullBuffer;\n    mtctx->inBuff.filled = 0;\n    mtctx->allJobsCompleted = 1;\n}\n\nstatic void ZSTDMT_waitForAllJobsCompleted(ZSTDMT_CCtx* mtctx)\n{\n    DEBUGLOG(4, \"ZSTDMT_waitForAllJobsCompleted\");\n    while (mtctx->doneJobID < mtctx->nextJobID) {\n        unsigned const jobID = mtctx->doneJobID & mtctx->jobIDMask;\n        ZSTD_PTHREAD_MUTEX_LOCK(&mtctx->jobs[jobID].job_mutex);\n        while (mtctx->jobs[jobID].consumed < mtctx->jobs[jobID].src.size) {\n            DEBUGLOG(4, \"waiting for jobCompleted signal from job %u\", mtctx->doneJobID);   /* we want to block when waiting for data to flush */\n            ZSTD_pthread_cond_wait(&mtctx->jobs[jobID].job_cond, &mtctx->jobs[jobID].job_mutex);\n        }\n        ZSTD_pthread_mutex_unlock(&mtctx->jobs[jobID].job_mutex);\n        mtctx->doneJobID++;\n    }\n}\n\nsize_t ZSTDMT_freeCCtx(ZSTDMT_CCtx* mtctx)\n{\n    if (mtctx==NULL) return 0;   /* compatible with free on NULL */\n    if (!mtctx->providedFactory)\n        POOL_free(mtctx->factory);   /* stop and free worker threads */\n    ZSTDMT_releaseAllJobResources(mtctx);  /* release job resources into pools first */\n    ZSTDMT_freeJobsTable(mtctx->jobs, mtctx->jobIDMask+1, mtctx->cMem);\n    ZSTDMT_freeBufferPool(mtctx->bufPool);\n    ZSTDMT_freeCCtxPool(mtctx->cctxPool);\n    ZSTDMT_freeSeqPool(mtctx->seqPool);\n    ZSTDMT_serialState_free(&mtctx->serial);\n    ZSTD_freeCDict(mtctx->cdictLocal);\n    if (mtctx->roundBuff.buffer)\n        ZSTD_customFree(mtctx->roundBuff.buffer, mtctx->cMem);\n    ZSTD_customFree(mtctx, mtctx->cMem);\n    return 0;\n}\n\nsize_t ZSTDMT_sizeof_CCtx(ZSTDMT_CCtx* mtctx)\n{\n    if (mtctx == NULL) return 0;   /* supports sizeof NULL */\n    return sizeof(*mtctx)\n            + POOL_sizeof(mtctx->factory)\n            + ZSTDMT_sizeof_bufferPool(mtctx->bufPool)\n            + (mtctx->jobIDMask+1) * sizeof(ZSTDMT_jobDescription)\n            + ZSTDMT_sizeof_CCtxPool(mtctx->cctxPool)\n            + ZSTDMT_sizeof_seqPool(mtctx->seqPool)\n            + ZSTD_sizeof_CDict(mtctx->cdictLocal)\n            + mtctx->roundBuff.capacity;\n}\n\n\n/* ZSTDMT_resize() :\n * @return : error code if fails, 0 on success */\nstatic size_t ZSTDMT_resize(ZSTDMT_CCtx* mtctx, unsigned nbWorkers)\n{\n    if (POOL_resize(mtctx->factory, nbWorkers)) return ERROR(memory_allocation);\n    FORWARD_IF_ERROR( ZSTDMT_expandJobsTable(mtctx, nbWorkers) , \"\");\n    mtctx->bufPool = ZSTDMT_expandBufferPool(mtctx->bufPool, BUF_POOL_MAX_NB_BUFFERS(nbWorkers));\n    if (mtctx->bufPool == NULL) return ERROR(memory_allocation);\n    mtctx->cctxPool = ZSTDMT_expandCCtxPool(mtctx->cctxPool, nbWorkers);\n    if (mtctx->cctxPool == NULL) return ERROR(memory_allocation);\n    mtctx->seqPool = ZSTDMT_expandSeqPool(mtctx->seqPool, nbWorkers);\n    if (mtctx->seqPool == NULL) return ERROR(memory_allocation);\n    ZSTDMT_CCtxParam_setNbWorkers(&mtctx->params, nbWorkers);\n    return 0;\n}\n\n\n/*! ZSTDMT_updateCParams_whileCompressing() :\n *  Updates a selected set of compression parameters, remaining compatible with currently active frame.\n *  New parameters will be applied to next compression job. */\nvoid ZSTDMT_updateCParams_whileCompressing(ZSTDMT_CCtx* mtctx, const ZSTD_CCtx_params* cctxParams)\n{\n    U32 const saved_wlog = mtctx->params.cParams.windowLog;   /* Do not modify windowLog while compressing */\n    int const compressionLevel = cctxParams->compressionLevel;\n    DEBUGLOG(5, \"ZSTDMT_updateCParams_whileCompressing (level:%i)\",\n                compressionLevel);\n    mtctx->params.compressionLevel = compressionLevel;\n    {   ZSTD_compressionParameters cParams = ZSTD_getCParamsFromCCtxParams(cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, 0, ZSTD_cpm_noAttachDict);\n        cParams.windowLog = saved_wlog;\n        mtctx->params.cParams = cParams;\n    }\n}\n\n/* ZSTDMT_getFrameProgression():\n * tells how much data has been consumed (input) and produced (output) for current frame.\n * able to count progression inside worker threads.\n * Note : mutex will be acquired during statistics collection inside workers. */\nZSTD_frameProgression ZSTDMT_getFrameProgression(ZSTDMT_CCtx* mtctx)\n{\n    ZSTD_frameProgression fps;\n    DEBUGLOG(5, \"ZSTDMT_getFrameProgression\");\n    fps.ingested = mtctx->consumed + mtctx->inBuff.filled;\n    fps.consumed = mtctx->consumed;\n    fps.produced = fps.flushed = mtctx->produced;\n    fps.currentJobID = mtctx->nextJobID;\n    fps.nbActiveWorkers = 0;\n    {   unsigned jobNb;\n        unsigned lastJobNb = mtctx->nextJobID + mtctx->jobReady; assert(mtctx->jobReady <= 1);\n        DEBUGLOG(6, \"ZSTDMT_getFrameProgression: jobs: from %u to <%u (jobReady:%u)\",\n                    mtctx->doneJobID, lastJobNb, mtctx->jobReady);\n        for (jobNb = mtctx->doneJobID ; jobNb < lastJobNb ; jobNb++) {\n            unsigned const wJobID = jobNb & mtctx->jobIDMask;\n            ZSTDMT_jobDescription* jobPtr = &mtctx->jobs[wJobID];\n            ZSTD_pthread_mutex_lock(&jobPtr->job_mutex);\n            {   size_t const cResult = jobPtr->cSize;\n                size_t const produced = ZSTD_isError(cResult) ? 0 : cResult;\n                size_t const flushed = ZSTD_isError(cResult) ? 0 : jobPtr->dstFlushed;\n                assert(flushed <= produced);\n                fps.ingested += jobPtr->src.size;\n                fps.consumed += jobPtr->consumed;\n                fps.produced += produced;\n                fps.flushed  += flushed;\n                fps.nbActiveWorkers += (jobPtr->consumed < jobPtr->src.size);\n            }\n            ZSTD_pthread_mutex_unlock(&mtctx->jobs[wJobID].job_mutex);\n        }\n    }\n    return fps;\n}\n\n\nsize_t ZSTDMT_toFlushNow(ZSTDMT_CCtx* mtctx)\n{\n    size_t toFlush;\n    unsigned const jobID = mtctx->doneJobID;\n    assert(jobID <= mtctx->nextJobID);\n    if (jobID == mtctx->nextJobID) return 0;   /* no active job => nothing to flush */\n\n    /* look into oldest non-fully-flushed job */\n    {   unsigned const wJobID = jobID & mtctx->jobIDMask;\n        ZSTDMT_jobDescription* const jobPtr = &mtctx->jobs[wJobID];\n        ZSTD_pthread_mutex_lock(&jobPtr->job_mutex);\n        {   size_t const cResult = jobPtr->cSize;\n            size_t const produced = ZSTD_isError(cResult) ? 0 : cResult;\n            size_t const flushed = ZSTD_isError(cResult) ? 0 : jobPtr->dstFlushed;\n            assert(flushed <= produced);\n            assert(jobPtr->consumed <= jobPtr->src.size);\n            toFlush = produced - flushed;\n            /* if toFlush==0, nothing is available to flush.\n             * However, jobID is expected to still be active:\n             * if jobID was already completed and fully flushed,\n             * ZSTDMT_flushProduced() should have already moved onto next job.\n             * Therefore, some input has not yet been consumed. */\n            if (toFlush==0) {\n                assert(jobPtr->consumed < jobPtr->src.size);\n            }\n        }\n        ZSTD_pthread_mutex_unlock(&mtctx->jobs[wJobID].job_mutex);\n    }\n\n    return toFlush;\n}\n\n\n/* ------------------------------------------ */\n/* =====   Multi-threaded compression   ===== */\n/* ------------------------------------------ */\n\nstatic unsigned ZSTDMT_computeTargetJobLog(const ZSTD_CCtx_params* params)\n{\n    unsigned jobLog;\n    if (params->ldmParams.enableLdm == ZSTD_ps_enable) {\n        /* In Long Range Mode, the windowLog is typically oversized.\n         * In which case, it's preferable to determine the jobSize\n         * based on cycleLog instead. */\n        jobLog = MAX(21, ZSTD_cycleLog(params->cParams.chainLog, params->cParams.strategy) + 3);\n    } else {\n        jobLog = MAX(20, params->cParams.windowLog + 2);\n    }\n    return MIN(jobLog, (unsigned)ZSTDMT_JOBLOG_MAX);\n}\n\nstatic int ZSTDMT_overlapLog_default(ZSTD_strategy strat)\n{\n    switch(strat)\n    {\n        case ZSTD_btultra2:\n            return 9;\n        case ZSTD_btultra:\n        case ZSTD_btopt:\n            return 8;\n        case ZSTD_btlazy2:\n        case ZSTD_lazy2:\n            return 7;\n        case ZSTD_lazy:\n        case ZSTD_greedy:\n        case ZSTD_dfast:\n        case ZSTD_fast:\n        default:;\n    }\n    return 6;\n}\n\nstatic int ZSTDMT_overlapLog(int ovlog, ZSTD_strategy strat)\n{\n    assert(0 <= ovlog && ovlog <= 9);\n    if (ovlog == 0) return ZSTDMT_overlapLog_default(strat);\n    return ovlog;\n}\n\nstatic size_t ZSTDMT_computeOverlapSize(const ZSTD_CCtx_params* params)\n{\n    int const overlapRLog = 9 - ZSTDMT_overlapLog(params->overlapLog, params->cParams.strategy);\n    int ovLog = (overlapRLog >= 8) ? 0 : (params->cParams.windowLog - overlapRLog);\n    assert(0 <= overlapRLog && overlapRLog <= 8);\n    if (params->ldmParams.enableLdm == ZSTD_ps_enable) {\n        /* In Long Range Mode, the windowLog is typically oversized.\n         * In which case, it's preferable to determine the jobSize\n         * based on chainLog instead.\n         * Then, ovLog becomes a fraction of the jobSize, rather than windowSize */\n        ovLog = MIN(params->cParams.windowLog, ZSTDMT_computeTargetJobLog(params) - 2)\n                - overlapRLog;\n    }\n    assert(0 <= ovLog && ovLog <= ZSTD_WINDOWLOG_MAX);\n    DEBUGLOG(4, \"overlapLog : %i\", params->overlapLog);\n    DEBUGLOG(4, \"overlap size : %i\", 1 << ovLog);\n    return (ovLog==0) ? 0 : (size_t)1 << ovLog;\n}\n\n/* ====================================== */\n/* =======      Streaming API     ======= */\n/* ====================================== */\n\nsize_t ZSTDMT_initCStream_internal(\n        ZSTDMT_CCtx* mtctx,\n        const void* dict, size_t dictSize, ZSTD_dictContentType_e dictContentType,\n        const ZSTD_CDict* cdict, ZSTD_CCtx_params params,\n        unsigned long long pledgedSrcSize)\n{\n    DEBUGLOG(4, \"ZSTDMT_initCStream_internal (pledgedSrcSize=%u, nbWorkers=%u, cctxPool=%u)\",\n                (U32)pledgedSrcSize, params.nbWorkers, mtctx->cctxPool->totalCCtx);\n\n    /* params supposed partially fully validated at this point */\n    assert(!ZSTD_isError(ZSTD_checkCParams(params.cParams)));\n    assert(!((dict) && (cdict)));  /* either dict or cdict, not both */\n\n    /* init */\n    if (params.nbWorkers != mtctx->params.nbWorkers)\n        FORWARD_IF_ERROR( ZSTDMT_resize(mtctx, (unsigned)params.nbWorkers) , \"\");\n\n    if (params.jobSize != 0 && params.jobSize < ZSTDMT_JOBSIZE_MIN) params.jobSize = ZSTDMT_JOBSIZE_MIN;\n    if (params.jobSize > (size_t)ZSTDMT_JOBSIZE_MAX) params.jobSize = (size_t)ZSTDMT_JOBSIZE_MAX;\n\n    if (mtctx->allJobsCompleted == 0) {   /* previous compression not correctly finished */\n        ZSTDMT_waitForAllJobsCompleted(mtctx);\n        ZSTDMT_releaseAllJobResources(mtctx); /* Will set allJobsCompleted to 1 */\n    }\n\n    mtctx->params = params;\n    mtctx->frameContentSize = pledgedSrcSize;\n    ZSTD_freeCDict(mtctx->cdictLocal);\n    if (dict) {\n        mtctx->cdictLocal = ZSTD_createCDict_advanced(dict, dictSize,\n                                                    ZSTD_dlm_byCopy, dictContentType, /* note : a loadPrefix becomes an internal CDict */\n                                                    params.cParams, mtctx->cMem);\n        mtctx->cdict = mtctx->cdictLocal;\n        if (mtctx->cdictLocal == NULL) return ERROR(memory_allocation);\n    } else {\n        mtctx->cdictLocal = NULL;\n        mtctx->cdict = cdict;\n    }\n\n    mtctx->targetPrefixSize = ZSTDMT_computeOverlapSize(¶ms);\n    DEBUGLOG(4, \"overlapLog=%i => %u KB\", params.overlapLog, (U32)(mtctx->targetPrefixSize>>10));\n    mtctx->targetSectionSize = params.jobSize;\n    if (mtctx->targetSectionSize == 0) {\n        mtctx->targetSectionSize = 1ULL << ZSTDMT_computeTargetJobLog(¶ms);\n    }\n    assert(mtctx->targetSectionSize <= (size_t)ZSTDMT_JOBSIZE_MAX);\n\n    if (params.rsyncable) {\n        /* Aim for the targetsectionSize as the average job size. */\n        U32 const jobSizeKB = (U32)(mtctx->targetSectionSize >> 10);\n        U32 const rsyncBits = (assert(jobSizeKB >= 1), ZSTD_highbit32(jobSizeKB) + 10);\n        /* We refuse to create jobs < RSYNC_MIN_BLOCK_SIZE bytes, so make sure our\n         * expected job size is at least 4x larger. */\n        assert(rsyncBits >= RSYNC_MIN_BLOCK_LOG + 2);\n        DEBUGLOG(4, \"rsyncLog = %u\", rsyncBits);\n        mtctx->rsync.hash = 0;\n        mtctx->rsync.hitMask = (1ULL << rsyncBits) - 1;\n        mtctx->rsync.primePower = ZSTD_rollingHash_primePower(RSYNC_LENGTH);\n    }\n    if (mtctx->targetSectionSize < mtctx->targetPrefixSize) mtctx->targetSectionSize = mtctx->targetPrefixSize;  /* job size must be >= overlap size */\n    DEBUGLOG(4, \"Job Size : %u KB (note : set to %u)\", (U32)(mtctx->targetSectionSize>>10), (U32)params.jobSize);\n    DEBUGLOG(4, \"inBuff Size : %u KB\", (U32)(mtctx->targetSectionSize>>10));\n    ZSTDMT_setBufferSize(mtctx->bufPool, ZSTD_compressBound(mtctx->targetSectionSize));\n    {\n        /* If ldm is enabled we need windowSize space. */\n        size_t const windowSize = mtctx->params.ldmParams.enableLdm == ZSTD_ps_enable ? (1U << mtctx->params.cParams.windowLog) : 0;\n        /* Two buffers of slack, plus extra space for the overlap\n         * This is the minimum slack that LDM works with. One extra because\n         * flush might waste up to targetSectionSize-1 bytes. Another extra\n         * for the overlap (if > 0), then one to fill which doesn't overlap\n         * with the LDM window.\n         */\n        size_t const nbSlackBuffers = 2 + (mtctx->targetPrefixSize > 0);\n        size_t const slackSize = mtctx->targetSectionSize * nbSlackBuffers;\n        /* Compute the total size, and always have enough slack */\n        size_t const nbWorkers = MAX(mtctx->params.nbWorkers, 1);\n        size_t const sectionsSize = mtctx->targetSectionSize * nbWorkers;\n        size_t const capacity = MAX(windowSize, sectionsSize) + slackSize;\n        if (mtctx->roundBuff.capacity < capacity) {\n            if (mtctx->roundBuff.buffer)\n                ZSTD_customFree(mtctx->roundBuff.buffer, mtctx->cMem);\n            mtctx->roundBuff.buffer = (BYTE*)ZSTD_customMalloc(capacity, mtctx->cMem);\n            if (mtctx->roundBuff.buffer == NULL) {\n                mtctx->roundBuff.capacity = 0;\n                return ERROR(memory_allocation);\n            }\n            mtctx->roundBuff.capacity = capacity;\n        }\n    }\n    DEBUGLOG(4, \"roundBuff capacity : %u KB\", (U32)(mtctx->roundBuff.capacity>>10));\n    mtctx->roundBuff.pos = 0;\n    mtctx->inBuff.buffer = g_nullBuffer;\n    mtctx->inBuff.filled = 0;\n    mtctx->inBuff.prefix = kNullRange;\n    mtctx->doneJobID = 0;\n    mtctx->nextJobID = 0;\n    mtctx->frameEnded = 0;\n    mtctx->allJobsCompleted = 0;\n    mtctx->consumed = 0;\n    mtctx->produced = 0;\n\n    /* update dictionary */\n    ZSTD_freeCDict(mtctx->cdictLocal);\n    mtctx->cdictLocal = NULL;\n    mtctx->cdict = NULL;\n    if (dict) {\n        if (dictContentType == ZSTD_dct_rawContent) {\n            mtctx->inBuff.prefix.start = (const BYTE*)dict;\n            mtctx->inBuff.prefix.size = dictSize;\n        } else {\n            /* note : a loadPrefix becomes an internal CDict */\n            mtctx->cdictLocal = ZSTD_createCDict_advanced(dict, dictSize,\n                                                        ZSTD_dlm_byRef, dictContentType,\n                                                        params.cParams, mtctx->cMem);\n            mtctx->cdict = mtctx->cdictLocal;\n            if (mtctx->cdictLocal == NULL) return ERROR(memory_allocation);\n        }\n    } else {\n        mtctx->cdict = cdict;\n    }\n\n    if (ZSTDMT_serialState_reset(&mtctx->serial, mtctx->seqPool, params, mtctx->targetSectionSize,\n                                 dict, dictSize, dictContentType))\n        return ERROR(memory_allocation);\n\n\n    return 0;\n}\n\n\n/* ZSTDMT_writeLastEmptyBlock()\n * Write a single empty block with an end-of-frame to finish a frame.\n * Job must be created from streaming variant.\n * This function is always successful if expected conditions are fulfilled.\n */\nstatic void ZSTDMT_writeLastEmptyBlock(ZSTDMT_jobDescription* job)\n{\n    assert(job->lastJob == 1);\n    assert(job->src.size == 0);   /* last job is empty -> will be simplified into a last empty block */\n    assert(job->firstJob == 0);   /* cannot be first job, as it also needs to create frame header */\n    assert(job->dstBuff.start == NULL);   /* invoked from streaming variant only (otherwise, dstBuff might be user's output) */\n    job->dstBuff = ZSTDMT_getBuffer(job->bufPool);\n    if (job->dstBuff.start == NULL) {\n      job->cSize = ERROR(memory_allocation);\n      return;\n    }\n    assert(job->dstBuff.capacity >= ZSTD_blockHeaderSize);   /* no buffer should ever be that small */\n    job->src = kNullRange;\n    job->cSize = ZSTD_writeLastEmptyBlock(job->dstBuff.start, job->dstBuff.capacity);\n    assert(!ZSTD_isError(job->cSize));\n    assert(job->consumed == 0);\n}\n\nstatic size_t ZSTDMT_createCompressionJob(ZSTDMT_CCtx* mtctx, size_t srcSize, ZSTD_EndDirective endOp)\n{\n    unsigned const jobID = mtctx->nextJobID & mtctx->jobIDMask;\n    int const endFrame = (endOp == ZSTD_e_end);\n\n    if (mtctx->nextJobID > mtctx->doneJobID + mtctx->jobIDMask) {\n        DEBUGLOG(5, \"ZSTDMT_createCompressionJob: will not create new job : table is full\");\n        assert((mtctx->nextJobID & mtctx->jobIDMask) == (mtctx->doneJobID & mtctx->jobIDMask));\n        return 0;\n    }\n\n    if (!mtctx->jobReady) {\n        BYTE const* src = (BYTE const*)mtctx->inBuff.buffer.start;\n        DEBUGLOG(5, \"ZSTDMT_createCompressionJob: preparing job %u to compress %u bytes with %u preload \",\n                    mtctx->nextJobID, (U32)srcSize, (U32)mtctx->inBuff.prefix.size);\n        mtctx->jobs[jobID].src.start = src;\n        mtctx->jobs[jobID].src.size = srcSize;\n        assert(mtctx->inBuff.filled >= srcSize);\n        mtctx->jobs[jobID].prefix = mtctx->inBuff.prefix;\n        mtctx->jobs[jobID].consumed = 0;\n        mtctx->jobs[jobID].cSize = 0;\n        mtctx->jobs[jobID].params = mtctx->params;\n        mtctx->jobs[jobID].cdict = mtctx->nextJobID==0 ? mtctx->cdict : NULL;\n        mtctx->jobs[jobID].fullFrameSize = mtctx->frameContentSize;\n        mtctx->jobs[jobID].dstBuff = g_nullBuffer;\n        mtctx->jobs[jobID].cctxPool = mtctx->cctxPool;\n        mtctx->jobs[jobID].bufPool = mtctx->bufPool;\n        mtctx->jobs[jobID].seqPool = mtctx->seqPool;\n        mtctx->jobs[jobID].serial = &mtctx->serial;\n        mtctx->jobs[jobID].jobID = mtctx->nextJobID;\n        mtctx->jobs[jobID].firstJob = (mtctx->nextJobID==0);\n        mtctx->jobs[jobID].lastJob = endFrame;\n        mtctx->jobs[jobID].frameChecksumNeeded = mtctx->params.fParams.checksumFlag && endFrame && (mtctx->nextJobID>0);\n        mtctx->jobs[jobID].dstFlushed = 0;\n\n        /* Update the round buffer pos and clear the input buffer to be reset */\n        mtctx->roundBuff.pos += srcSize;\n        mtctx->inBuff.buffer = g_nullBuffer;\n        mtctx->inBuff.filled = 0;\n        /* Set the prefix for next job */\n        if (!endFrame) {\n            size_t const newPrefixSize = MIN(srcSize, mtctx->targetPrefixSize);\n            mtctx->inBuff.prefix.start = src + srcSize - newPrefixSize;\n            mtctx->inBuff.prefix.size = newPrefixSize;\n        } else {   /* endFrame==1 => no need for another input buffer */\n            mtctx->inBuff.prefix = kNullRange;\n            mtctx->frameEnded = endFrame;\n            if (mtctx->nextJobID == 0) {\n                /* single job exception : checksum is already calculated directly within worker thread */\n                mtctx->params.fParams.checksumFlag = 0;\n        }   }\n\n        if ( (srcSize == 0)\n          && (mtctx->nextJobID>0)/*single job must also write frame header*/ ) {\n            DEBUGLOG(5, \"ZSTDMT_createCompressionJob: creating a last empty block to end frame\");\n            assert(endOp == ZSTD_e_end);  /* only possible case : need to end the frame with an empty last block */\n            ZSTDMT_writeLastEmptyBlock(mtctx->jobs + jobID);\n            mtctx->nextJobID++;\n            return 0;\n        }\n    }\n\n    DEBUGLOG(5, \"ZSTDMT_createCompressionJob: posting job %u : %u bytes  (end:%u, jobNb == %u (mod:%u))\",\n                mtctx->nextJobID,\n                (U32)mtctx->jobs[jobID].src.size,\n                mtctx->jobs[jobID].lastJob,\n                mtctx->nextJobID,\n                jobID);\n    if (POOL_tryAdd(mtctx->factory, ZSTDMT_compressionJob, &mtctx->jobs[jobID])) {\n        mtctx->nextJobID++;\n        mtctx->jobReady = 0;\n    } else {\n        DEBUGLOG(5, \"ZSTDMT_createCompressionJob: no worker available for job %u\", mtctx->nextJobID);\n        mtctx->jobReady = 1;\n    }\n    return 0;\n}\n\n\n/*! ZSTDMT_flushProduced() :\n *  flush whatever data has been produced but not yet flushed in current job.\n *  move to next job if current one is fully flushed.\n * `output` : `pos` will be updated with amount of data flushed .\n * `blockToFlush` : if >0, the function will block and wait if there is no data available to flush .\n * @return : amount of data remaining within internal buffer, 0 if no more, 1 if unknown but > 0, or an error code */\nstatic size_t ZSTDMT_flushProduced(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output, unsigned blockToFlush, ZSTD_EndDirective end)\n{\n    unsigned const wJobID = mtctx->doneJobID & mtctx->jobIDMask;\n    DEBUGLOG(5, \"ZSTDMT_flushProduced (blocking:%u , job %u <= %u)\",\n                blockToFlush, mtctx->doneJobID, mtctx->nextJobID);\n    assert(output->size >= output->pos);\n\n    ZSTD_PTHREAD_MUTEX_LOCK(&mtctx->jobs[wJobID].job_mutex);\n    if (  blockToFlush\n      && (mtctx->doneJobID < mtctx->nextJobID) ) {\n        assert(mtctx->jobs[wJobID].dstFlushed <= mtctx->jobs[wJobID].cSize);\n        while (mtctx->jobs[wJobID].dstFlushed == mtctx->jobs[wJobID].cSize) {  /* nothing to flush */\n            if (mtctx->jobs[wJobID].consumed == mtctx->jobs[wJobID].src.size) {\n                DEBUGLOG(5, \"job %u is completely consumed (%u == %u) => don't wait for cond, there will be none\",\n                            mtctx->doneJobID, (U32)mtctx->jobs[wJobID].consumed, (U32)mtctx->jobs[wJobID].src.size);\n                break;\n            }\n            DEBUGLOG(5, \"waiting for something to flush from job %u (currently flushed: %u bytes)\",\n                        mtctx->doneJobID, (U32)mtctx->jobs[wJobID].dstFlushed);\n            ZSTD_pthread_cond_wait(&mtctx->jobs[wJobID].job_cond, &mtctx->jobs[wJobID].job_mutex);  /* block when nothing to flush but some to come */\n    }   }\n\n    /* try to flush something */\n    {   size_t cSize = mtctx->jobs[wJobID].cSize;                  /* shared */\n        size_t const srcConsumed = mtctx->jobs[wJobID].consumed;   /* shared */\n        size_t const srcSize = mtctx->jobs[wJobID].src.size;       /* read-only, could be done after mutex lock, but no-declaration-after-statement */\n        ZSTD_pthread_mutex_unlock(&mtctx->jobs[wJobID].job_mutex);\n        if (ZSTD_isError(cSize)) {\n            DEBUGLOG(5, \"ZSTDMT_flushProduced: job %u : compression error detected : %s\",\n                        mtctx->doneJobID, ZSTD_getErrorName(cSize));\n            ZSTDMT_waitForAllJobsCompleted(mtctx);\n            ZSTDMT_releaseAllJobResources(mtctx);\n            return cSize;\n        }\n        /* add frame checksum if necessary (can only happen once) */\n        assert(srcConsumed <= srcSize);\n        if ( (srcConsumed == srcSize)   /* job completed -> worker no longer active */\n          && mtctx->jobs[wJobID].frameChecksumNeeded ) {\n            U32 const checksum = (U32)XXH64_digest(&mtctx->serial.xxhState);\n            DEBUGLOG(4, \"ZSTDMT_flushProduced: writing checksum : %08X \\n\", checksum);\n            MEM_writeLE32((char*)mtctx->jobs[wJobID].dstBuff.start + mtctx->jobs[wJobID].cSize, checksum);\n            cSize += 4;\n            mtctx->jobs[wJobID].cSize += 4;  /* can write this shared value, as worker is no longer active */\n            mtctx->jobs[wJobID].frameChecksumNeeded = 0;\n        }\n\n        if (cSize > 0) {   /* compression is ongoing or completed */\n            size_t const toFlush = MIN(cSize - mtctx->jobs[wJobID].dstFlushed, output->size - output->pos);\n            DEBUGLOG(5, \"ZSTDMT_flushProduced: Flushing %u bytes from job %u (completion:%u/%u, generated:%u)\",\n                        (U32)toFlush, mtctx->doneJobID, (U32)srcConsumed, (U32)srcSize, (U32)cSize);\n            assert(mtctx->doneJobID < mtctx->nextJobID);\n            assert(cSize >= mtctx->jobs[wJobID].dstFlushed);\n            assert(mtctx->jobs[wJobID].dstBuff.start != NULL);\n            if (toFlush > 0) {\n                ZSTD_memcpy((char*)output->dst + output->pos,\n                    (const char*)mtctx->jobs[wJobID].dstBuff.start + mtctx->jobs[wJobID].dstFlushed,\n                    toFlush);\n            }\n            output->pos += toFlush;\n            mtctx->jobs[wJobID].dstFlushed += toFlush;  /* can write : this value is only used by mtctx */\n\n            if ( (srcConsumed == srcSize)    /* job is completed */\n              && (mtctx->jobs[wJobID].dstFlushed == cSize) ) {   /* output buffer fully flushed => free this job position */\n                DEBUGLOG(5, \"Job %u completed (%u bytes), moving to next one\",\n                        mtctx->doneJobID, (U32)mtctx->jobs[wJobID].dstFlushed);\n                ZSTDMT_releaseBuffer(mtctx->bufPool, mtctx->jobs[wJobID].dstBuff);\n                DEBUGLOG(5, \"dstBuffer released\");\n                mtctx->jobs[wJobID].dstBuff = g_nullBuffer;\n                mtctx->jobs[wJobID].cSize = 0;   /* ensure this job slot is considered \"not started\" in future check */\n                mtctx->consumed += srcSize;\n                mtctx->produced += cSize;\n                mtctx->doneJobID++;\n        }   }\n\n        /* return value : how many bytes left in buffer ; fake it to 1 when unknown but >0 */\n        if (cSize > mtctx->jobs[wJobID].dstFlushed) return (cSize - mtctx->jobs[wJobID].dstFlushed);\n        if (srcSize > srcConsumed) return 1;   /* current job not completely compressed */\n    }\n    if (mtctx->doneJobID < mtctx->nextJobID) return 1;   /* some more jobs ongoing */\n    if (mtctx->jobReady) return 1;      /* one job is ready to push, just not yet in the list */\n    if (mtctx->inBuff.filled > 0) return 1;   /* input is not empty, and still needs to be converted into a job */\n    mtctx->allJobsCompleted = mtctx->frameEnded;   /* all jobs are entirely flushed => if this one is last one, frame is completed */\n    if (end == ZSTD_e_end) return !mtctx->frameEnded;  /* for ZSTD_e_end, question becomes : is frame completed ? instead of : are internal buffers fully flushed ? */\n    return 0;   /* internal buffers fully flushed */\n}\n\n/**\n * Returns the range of data used by the earliest job that is not yet complete.\n * If the data of the first job is broken up into two segments, we cover both\n * sections.\n */\nstatic Range ZSTDMT_getInputDataInUse(ZSTDMT_CCtx* mtctx)\n{\n    unsigned const firstJobID = mtctx->doneJobID;\n    unsigned const lastJobID = mtctx->nextJobID;\n    unsigned jobID;\n\n    /* no need to check during first round */\n    size_t roundBuffCapacity = mtctx->roundBuff.capacity;\n    size_t nbJobs1stRoundMin = roundBuffCapacity / mtctx->targetSectionSize;\n    if (lastJobID < nbJobs1stRoundMin) return kNullRange;\n\n    for (jobID = firstJobID; jobID < lastJobID; ++jobID) {\n        unsigned const wJobID = jobID & mtctx->jobIDMask;\n        size_t consumed;\n\n        ZSTD_PTHREAD_MUTEX_LOCK(&mtctx->jobs[wJobID].job_mutex);\n        consumed = mtctx->jobs[wJobID].consumed;\n        ZSTD_pthread_mutex_unlock(&mtctx->jobs[wJobID].job_mutex);\n\n        if (consumed < mtctx->jobs[wJobID].src.size) {\n            Range range = mtctx->jobs[wJobID].prefix;\n            if (range.size == 0) {\n                /* Empty prefix */\n                range = mtctx->jobs[wJobID].src;\n            }\n            /* Job source in multiple segments not supported yet */\n            assert(range.start <= mtctx->jobs[wJobID].src.start);\n            return range;\n        }\n    }\n    return kNullRange;\n}\n\n/**\n * Returns non-zero iff buffer and range overlap.\n */\nstatic int ZSTDMT_isOverlapped(Buffer buffer, Range range)\n{\n    BYTE const* const bufferStart = (BYTE const*)buffer.start;\n    BYTE const* const rangeStart = (BYTE const*)range.start;\n\n    if (rangeStart == NULL || bufferStart == NULL)\n        return 0;\n\n    {\n        BYTE const* const bufferEnd = bufferStart + buffer.capacity;\n        BYTE const* const rangeEnd = rangeStart + range.size;\n\n        /* Empty ranges cannot overlap */\n        if (bufferStart == bufferEnd || rangeStart == rangeEnd)\n            return 0;\n\n        return bufferStart < rangeEnd && rangeStart < bufferEnd;\n    }\n}\n\nstatic int ZSTDMT_doesOverlapWindow(Buffer buffer, ZSTD_window_t window)\n{\n    Range extDict;\n    Range prefix;\n\n    DEBUGLOG(5, \"ZSTDMT_doesOverlapWindow\");\n    extDict.start = window.dictBase + window.lowLimit;\n    extDict.size = window.dictLimit - window.lowLimit;\n\n    prefix.start = window.base + window.dictLimit;\n    prefix.size = window.nextSrc - (window.base + window.dictLimit);\n    DEBUGLOG(5, \"extDict [0x%zx, 0x%zx)\",\n                (size_t)extDict.start,\n                (size_t)extDict.start + extDict.size);\n    DEBUGLOG(5, \"prefix  [0x%zx, 0x%zx)\",\n                (size_t)prefix.start,\n                (size_t)prefix.start + prefix.size);\n\n    return ZSTDMT_isOverlapped(buffer, extDict)\n        || ZSTDMT_isOverlapped(buffer, prefix);\n}\n\nstatic void ZSTDMT_waitForLdmComplete(ZSTDMT_CCtx* mtctx, Buffer buffer)\n{\n    if (mtctx->params.ldmParams.enableLdm == ZSTD_ps_enable) {\n        ZSTD_pthread_mutex_t* mutex = &mtctx->serial.ldmWindowMutex;\n        DEBUGLOG(5, \"ZSTDMT_waitForLdmComplete\");\n        DEBUGLOG(5, \"source  [0x%zx, 0x%zx)\",\n                    (size_t)buffer.start,\n                    (size_t)buffer.start + buffer.capacity);\n        ZSTD_PTHREAD_MUTEX_LOCK(mutex);\n        while (ZSTDMT_doesOverlapWindow(buffer, mtctx->serial.ldmWindow)) {\n            DEBUGLOG(5, \"Waiting for LDM to finish...\");\n            ZSTD_pthread_cond_wait(&mtctx->serial.ldmWindowCond, mutex);\n        }\n        DEBUGLOG(6, \"Done waiting for LDM to finish\");\n        ZSTD_pthread_mutex_unlock(mutex);\n    }\n}\n\n/**\n * Attempts to set the inBuff to the next section to fill.\n * If any part of the new section is still in use we give up.\n * Returns non-zero if the buffer is filled.\n */\nstatic int ZSTDMT_tryGetInputRange(ZSTDMT_CCtx* mtctx)\n{\n    Range const inUse = ZSTDMT_getInputDataInUse(mtctx);\n    size_t const spaceLeft = mtctx->roundBuff.capacity - mtctx->roundBuff.pos;\n    size_t const spaceNeeded = mtctx->targetSectionSize;\n    Buffer buffer;\n\n    DEBUGLOG(5, \"ZSTDMT_tryGetInputRange\");\n    assert(mtctx->inBuff.buffer.start == NULL);\n    assert(mtctx->roundBuff.capacity >= spaceNeeded);\n\n    if (spaceLeft < spaceNeeded) {\n        /* ZSTD_invalidateRepCodes() doesn't work for extDict variants.\n         * Simply copy the prefix to the beginning in that case.\n         */\n        BYTE* const start = (BYTE*)mtctx->roundBuff.buffer;\n        size_t const prefixSize = mtctx->inBuff.prefix.size;\n\n        buffer.start = start;\n        buffer.capacity = prefixSize;\n        if (ZSTDMT_isOverlapped(buffer, inUse)) {\n            DEBUGLOG(5, \"Waiting for buffer...\");\n            return 0;\n        }\n        ZSTDMT_waitForLdmComplete(mtctx, buffer);\n        ZSTD_memmove(start, mtctx->inBuff.prefix.start, prefixSize);\n        mtctx->inBuff.prefix.start = start;\n        mtctx->roundBuff.pos = prefixSize;\n    }\n    buffer.start = mtctx->roundBuff.buffer + mtctx->roundBuff.pos;\n    buffer.capacity = spaceNeeded;\n\n    if (ZSTDMT_isOverlapped(buffer, inUse)) {\n        DEBUGLOG(5, \"Waiting for buffer...\");\n        return 0;\n    }\n    assert(!ZSTDMT_isOverlapped(buffer, mtctx->inBuff.prefix));\n\n    ZSTDMT_waitForLdmComplete(mtctx, buffer);\n\n    DEBUGLOG(5, \"Using prefix range [%zx, %zx)\",\n                (size_t)mtctx->inBuff.prefix.start,\n                (size_t)mtctx->inBuff.prefix.start + mtctx->inBuff.prefix.size);\n    DEBUGLOG(5, \"Using source range [%zx, %zx)\",\n                (size_t)buffer.start,\n                (size_t)buffer.start + buffer.capacity);\n\n\n    mtctx->inBuff.buffer = buffer;\n    mtctx->inBuff.filled = 0;\n    assert(mtctx->roundBuff.pos + buffer.capacity <= mtctx->roundBuff.capacity);\n    return 1;\n}\n\ntypedef struct {\n  size_t toLoad;  /* The number of bytes to load from the input. */\n  int flush;      /* Boolean declaring if we must flush because we found a synchronization point. */\n} SyncPoint;\n\n/**\n * Searches through the input for a synchronization point. If one is found, we\n * will instruct the caller to flush, and return the number of bytes to load.\n * Otherwise, we will load as many bytes as possible and instruct the caller\n * to continue as normal.\n */\nstatic SyncPoint\nfindSynchronizationPoint(ZSTDMT_CCtx const* mtctx, ZSTD_inBuffer const input)\n{\n    BYTE const* const istart = (BYTE const*)input.src + input.pos;\n    U64 const primePower = mtctx->rsync.primePower;\n    U64 const hitMask = mtctx->rsync.hitMask;\n\n    SyncPoint syncPoint;\n    U64 hash;\n    BYTE const* prev;\n    size_t pos;\n\n    syncPoint.toLoad = MIN(input.size - input.pos, mtctx->targetSectionSize - mtctx->inBuff.filled);\n    syncPoint.flush = 0;\n    if (!mtctx->params.rsyncable)\n        /* Rsync is disabled. */\n        return syncPoint;\n    if (mtctx->inBuff.filled + input.size - input.pos < RSYNC_MIN_BLOCK_SIZE)\n        /* We don't emit synchronization points if it would produce too small blocks.\n         * We don't have enough input to find a synchronization point, so don't look.\n         */\n        return syncPoint;\n    if (mtctx->inBuff.filled + syncPoint.toLoad < RSYNC_LENGTH)\n        /* Not enough to compute the hash.\n         * We will miss any synchronization points in this RSYNC_LENGTH byte\n         * window. However, since it depends only in the internal buffers, if the\n         * state is already synchronized, we will remain synchronized.\n         * Additionally, the probability that we miss a synchronization point is\n         * low: RSYNC_LENGTH / targetSectionSize.\n         */\n        return syncPoint;\n    /* Initialize the loop variables. */\n    if (mtctx->inBuff.filled < RSYNC_MIN_BLOCK_SIZE) {\n        /* We don't need to scan the first RSYNC_MIN_BLOCK_SIZE positions\n         * because they can't possibly be a sync point. So we can start\n         * part way through the input buffer.\n         */\n        pos = RSYNC_MIN_BLOCK_SIZE - mtctx->inBuff.filled;\n        if (pos >= RSYNC_LENGTH) {\n            prev = istart + pos - RSYNC_LENGTH;\n            hash = ZSTD_rollingHash_compute(prev, RSYNC_LENGTH);\n        } else {\n            assert(mtctx->inBuff.filled >= RSYNC_LENGTH);\n            prev = (BYTE const*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled - RSYNC_LENGTH;\n            hash = ZSTD_rollingHash_compute(prev + pos, (RSYNC_LENGTH - pos));\n            hash = ZSTD_rollingHash_append(hash, istart, pos);\n        }\n    } else {\n        /* We have enough bytes buffered to initialize the hash,\n         * and have processed enough bytes to find a sync point.\n         * Start scanning at the beginning of the input.\n         */\n        assert(mtctx->inBuff.filled >= RSYNC_MIN_BLOCK_SIZE);\n        assert(RSYNC_MIN_BLOCK_SIZE >= RSYNC_LENGTH);\n        pos = 0;\n        prev = (BYTE const*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled - RSYNC_LENGTH;\n        hash = ZSTD_rollingHash_compute(prev, RSYNC_LENGTH);\n        if ((hash & hitMask) == hitMask) {\n            /* We're already at a sync point so don't load any more until\n             * we're able to flush this sync point.\n             * This likely happened because the job table was full so we\n             * couldn't add our job.\n             */\n            syncPoint.toLoad = 0;\n            syncPoint.flush = 1;\n            return syncPoint;\n        }\n    }\n    /* Starting with the hash of the previous RSYNC_LENGTH bytes, roll\n     * through the input. If we hit a synchronization point, then cut the\n     * job off, and tell the compressor to flush the job. Otherwise, load\n     * all the bytes and continue as normal.\n     * If we go too long without a synchronization point (targetSectionSize)\n     * then a block will be emitted anyways, but this is okay, since if we\n     * are already synchronized we will remain synchronized.\n     */\n    assert(pos < RSYNC_LENGTH || ZSTD_rollingHash_compute(istart + pos - RSYNC_LENGTH, RSYNC_LENGTH) == hash);\n    for (; pos < syncPoint.toLoad; ++pos) {\n        BYTE const toRemove = pos < RSYNC_LENGTH ? prev[pos] : istart[pos - RSYNC_LENGTH];\n        /* This assert is very expensive, and Debian compiles with asserts enabled.\n         * So disable it for now. We can get similar coverage by checking it at the\n         * beginning & end of the loop.\n         * assert(pos < RSYNC_LENGTH || ZSTD_rollingHash_compute(istart + pos - RSYNC_LENGTH, RSYNC_LENGTH) == hash);\n         */\n        hash = ZSTD_rollingHash_rotate(hash, toRemove, istart[pos], primePower);\n        assert(mtctx->inBuff.filled + pos >= RSYNC_MIN_BLOCK_SIZE);\n        if ((hash & hitMask) == hitMask) {\n            syncPoint.toLoad = pos + 1;\n            syncPoint.flush = 1;\n            ++pos; /* for assert */\n            break;\n        }\n    }\n    assert(pos < RSYNC_LENGTH || ZSTD_rollingHash_compute(istart + pos - RSYNC_LENGTH, RSYNC_LENGTH) == hash);\n    return syncPoint;\n}\n\nsize_t ZSTDMT_nextInputSizeHint(const ZSTDMT_CCtx* mtctx)\n{\n    size_t hintInSize = mtctx->targetSectionSize - mtctx->inBuff.filled;\n    if (hintInSize==0) hintInSize = mtctx->targetSectionSize;\n    return hintInSize;\n}\n\n/** ZSTDMT_compressStream_generic() :\n *  internal use only - exposed to be invoked from zstd_compress.c\n *  assumption : output and input are valid (pos <= size)\n * @return : minimum amount of data remaining to flush, 0 if none */\nsize_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,\n                                     ZSTD_outBuffer* output,\n                                     ZSTD_inBuffer* input,\n                                     ZSTD_EndDirective endOp)\n{\n    unsigned forwardInputProgress = 0;\n    DEBUGLOG(5, \"ZSTDMT_compressStream_generic (endOp=%u, srcSize=%u)\",\n                (U32)endOp, (U32)(input->size - input->pos));\n    assert(output->pos <= output->size);\n    assert(input->pos  <= input->size);\n\n    if ((mtctx->frameEnded) && (endOp==ZSTD_e_continue)) {\n        /* current frame being ended. Only flush/end are allowed */\n        return ERROR(stage_wrong);\n    }\n\n    /* fill input buffer */\n    if ( (!mtctx->jobReady)\n      && (input->size > input->pos) ) {   /* support NULL input */\n        if (mtctx->inBuff.buffer.start == NULL) {\n            assert(mtctx->inBuff.filled == 0); /* Can't fill an empty buffer */\n            if (!ZSTDMT_tryGetInputRange(mtctx)) {\n                /* It is only possible for this operation to fail if there are\n                 * still compression jobs ongoing.\n                 */\n                DEBUGLOG(5, \"ZSTDMT_tryGetInputRange failed\");\n                assert(mtctx->doneJobID != mtctx->nextJobID);\n            } else\n                DEBUGLOG(5, \"ZSTDMT_tryGetInputRange completed successfully : mtctx->inBuff.buffer.start = %p\", mtctx->inBuff.buffer.start);\n        }\n        if (mtctx->inBuff.buffer.start != NULL) {\n            SyncPoint const syncPoint = findSynchronizationPoint(mtctx, *input);\n            if (syncPoint.flush && endOp == ZSTD_e_continue) {\n                endOp = ZSTD_e_flush;\n            }\n            assert(mtctx->inBuff.buffer.capacity >= mtctx->targetSectionSize);\n            DEBUGLOG(5, \"ZSTDMT_compressStream_generic: adding %u bytes on top of %u to buffer of size %u\",\n                        (U32)syncPoint.toLoad, (U32)mtctx->inBuff.filled, (U32)mtctx->targetSectionSize);\n            ZSTD_memcpy((char*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled, (const char*)input->src + input->pos, syncPoint.toLoad);\n            input->pos += syncPoint.toLoad;\n            mtctx->inBuff.filled += syncPoint.toLoad;\n            forwardInputProgress = syncPoint.toLoad>0;\n        }\n    }\n    if ((input->pos < input->size) && (endOp == ZSTD_e_end)) {\n        /* Can't end yet because the input is not fully consumed.\n            * We are in one of these cases:\n            * - mtctx->inBuff is NULL & empty: we couldn't get an input buffer so don't create a new job.\n            * - We filled the input buffer: flush this job but don't end the frame.\n            * - We hit a synchronization point: flush this job but don't end the frame.\n            */\n        assert(mtctx->inBuff.filled == 0 || mtctx->inBuff.filled == mtctx->targetSectionSize || mtctx->params.rsyncable);\n        endOp = ZSTD_e_flush;\n    }\n\n    if ( (mtctx->jobReady)\n      || (mtctx->inBuff.filled >= mtctx->targetSectionSize)  /* filled enough : let's compress */\n      || ((endOp != ZSTD_e_continue) && (mtctx->inBuff.filled > 0))  /* something to flush : let's go */\n      || ((endOp == ZSTD_e_end) && (!mtctx->frameEnded)) ) {   /* must finish the frame with a zero-size block */\n        size_t const jobSize = mtctx->inBuff.filled;\n        assert(mtctx->inBuff.filled <= mtctx->targetSectionSize);\n        FORWARD_IF_ERROR( ZSTDMT_createCompressionJob(mtctx, jobSize, endOp) , \"\");\n    }\n\n    /* check for potential compressed data ready to be flushed */\n    {   size_t const remainingToFlush = ZSTDMT_flushProduced(mtctx, output, !forwardInputProgress, endOp); /* block if there was no forward input progress */\n        if (input->pos < input->size) return MAX(remainingToFlush, 1);  /* input not consumed : do not end flush yet */\n        DEBUGLOG(5, \"end of ZSTDMT_compressStream_generic: remainingToFlush = %u\", (U32)remainingToFlush);\n        return remainingToFlush;\n    }\n}\n"
  },
  {
    "path": "lib/compress/zstdmt_compress.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n #ifndef ZSTDMT_COMPRESS_H\n #define ZSTDMT_COMPRESS_H\n\n/* ===   Dependencies   === */\n#include \"../common/zstd_deps.h\"   /* size_t */\n#define ZSTD_STATIC_LINKING_ONLY   /* ZSTD_parameters */\n#include \"../zstd.h\"            /* ZSTD_inBuffer, ZSTD_outBuffer, ZSTDLIB_API */\n\n/* Note : This is an internal API.\n *        These APIs used to be exposed with ZSTDLIB_API,\n *        because it used to be the only way to invoke MT compression.\n *        Now, you must use ZSTD_compress2 and ZSTD_compressStream2() instead.\n *\n *        This API requires ZSTD_MULTITHREAD to be defined during compilation,\n *        otherwise ZSTDMT_createCCtx*() will fail.\n */\n\n/* ===   Constants   === */\n#ifndef ZSTDMT_NBWORKERS_MAX /* a different value can be selected at compile time */\n#  define ZSTDMT_NBWORKERS_MAX ((sizeof(void*)==4) /*32-bit*/ ? 64 : 256)\n#endif\n#ifndef ZSTDMT_JOBSIZE_MIN   /* a different value can be selected at compile time */\n#  define ZSTDMT_JOBSIZE_MIN (512 KB)\n#endif\n#define ZSTDMT_JOBLOG_MAX   (MEM_32bits() ? 29 : 30)\n#define ZSTDMT_JOBSIZE_MAX  (MEM_32bits() ? (512 MB) : (1024 MB))\n\n\n/* ========================================================\n * ===  Private interface, for use by ZSTD_compress.c   ===\n * ===  Not exposed in libzstd. Never invoke directly   ===\n * ======================================================== */\n\n/* ===   Memory management   === */\ntypedef struct ZSTDMT_CCtx_s ZSTDMT_CCtx;\n/* Requires ZSTD_MULTITHREAD to be defined during compilation, otherwise it will return NULL. */\nZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbWorkers,\n                                        ZSTD_customMem cMem,\n\t\t\t\t\tZSTD_threadPool *pool);\nsize_t ZSTDMT_freeCCtx(ZSTDMT_CCtx* mtctx);\n\nsize_t ZSTDMT_sizeof_CCtx(ZSTDMT_CCtx* mtctx);\n\n/* ===   Streaming functions   === */\n\nsize_t ZSTDMT_nextInputSizeHint(const ZSTDMT_CCtx* mtctx);\n\n/*! ZSTDMT_initCStream_internal() :\n *  Private use only. Init streaming operation.\n *  expects params to be valid.\n *  must receive dict, or cdict, or none, but not both.\n *  mtctx can be freshly constructed or reused from a prior compression.\n *  If mtctx is reused, memory allocations from the prior compression may not be freed,\n *  even if they are not needed for the current compression.\n *  @return : 0, or an error code */\nsize_t ZSTDMT_initCStream_internal(ZSTDMT_CCtx* mtctx,\n                    const void* dict, size_t dictSize, ZSTD_dictContentType_e dictContentType,\n                    const ZSTD_CDict* cdict,\n                    ZSTD_CCtx_params params, unsigned long long pledgedSrcSize);\n\n/*! ZSTDMT_compressStream_generic() :\n *  Combines ZSTDMT_compressStream() with optional ZSTDMT_flushStream() or ZSTDMT_endStream()\n *  depending on flush directive.\n * @return : minimum amount of data still to be flushed\n *           0 if fully flushed\n *           or an error code\n *  note : needs to be init using any ZSTD_initCStream*() variant */\nsize_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,\n                                     ZSTD_outBuffer* output,\n                                     ZSTD_inBuffer* input,\n                                     ZSTD_EndDirective endOp);\n\n /*! ZSTDMT_toFlushNow()\n  *  Tell how many bytes are ready to be flushed immediately.\n  *  Probe the oldest active job (not yet entirely flushed) and check its output buffer.\n  *  If return 0, it means there is no active job,\n  *  or, it means oldest job is still active, but everything produced has been flushed so far,\n  *  therefore flushing is limited by speed of oldest job. */\nsize_t ZSTDMT_toFlushNow(ZSTDMT_CCtx* mtctx);\n\n/*! ZSTDMT_updateCParams_whileCompressing() :\n *  Updates only a selected set of compression parameters, to remain compatible with current frame.\n *  New parameters will be applied to next compression job. */\nvoid ZSTDMT_updateCParams_whileCompressing(ZSTDMT_CCtx* mtctx, const ZSTD_CCtx_params* cctxParams);\n\n/*! ZSTDMT_getFrameProgression():\n *  tells how much data has been consumed (input) and produced (output) for current frame.\n *  able to count progression inside worker threads.\n */\nZSTD_frameProgression ZSTDMT_getFrameProgression(ZSTDMT_CCtx* mtctx);\n\n#endif   /* ZSTDMT_COMPRESS_H */\n"
  },
  {
    "path": "lib/decompress/huf_decompress.c",
    "content": "/* ******************************************************************\n * huff0 huffman decoder,\n * part of Finite State Entropy library\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n *  You can contact the author at :\n *  - FSE+HUF source repository : https://github.com/Cyan4973/FiniteStateEntropy\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n****************************************************************** */\n\n/* **************************************************************\n*  Dependencies\n****************************************************************/\n#include                /* size_t */\n#include \"../common/zstd_deps.h\"  /* ZSTD_memcpy, ZSTD_memset */\n#include \"../common/compiler.h\"\n#include \"../common/bitstream.h\"  /* BIT_* */\n#include \"../common/fse.h\"        /* to compress headers */\n#include \"../common/huf.h\"\n#include \"../common/error_private.h\"\n#include \"../common/zstd_internal.h\"\n#include \"../common/bits.h\"       /* ZSTD_highbit32, ZSTD_countTrailingZeros64 */\n\n/* **************************************************************\n*  Constants\n****************************************************************/\n\n#define HUF_DECODER_FAST_TABLELOG 11\n\n/* **************************************************************\n*  Macros\n****************************************************************/\n\n#ifdef HUF_DISABLE_FAST_DECODE\n# define HUF_ENABLE_FAST_DECODE 0\n#else\n# define HUF_ENABLE_FAST_DECODE 1\n#endif\n\n/* These two optional macros force the use one way or another of the two\n * Huffman decompression implementations. You can't force in both directions\n * at the same time.\n */\n#if defined(HUF_FORCE_DECOMPRESS_X1) && \\\n    defined(HUF_FORCE_DECOMPRESS_X2)\n#error \"Cannot force the use of the X1 and X2 decoders at the same time!\"\n#endif\n\n/* When DYNAMIC_BMI2 is enabled, fast decoders are only called when bmi2 is\n * supported at runtime, so we can add the BMI2 target attribute.\n * When it is disabled, we will still get BMI2 if it is enabled statically.\n */\n#if DYNAMIC_BMI2\n# define HUF_FAST_BMI2_ATTRS BMI2_TARGET_ATTRIBUTE\n#else\n# define HUF_FAST_BMI2_ATTRS\n#endif\n\n#ifdef __cplusplus\n# define HUF_EXTERN_C extern \"C\"\n#else\n# define HUF_EXTERN_C\n#endif\n#define HUF_ASM_DECL HUF_EXTERN_C\n\n#if DYNAMIC_BMI2\n# define HUF_NEED_BMI2_FUNCTION 1\n#else\n# define HUF_NEED_BMI2_FUNCTION 0\n#endif\n\n/* **************************************************************\n*  Error Management\n****************************************************************/\n#define HUF_isError ERR_isError\n\n\n/* **************************************************************\n*  Byte alignment for workSpace management\n****************************************************************/\n#define HUF_ALIGN(x, a)         HUF_ALIGN_MASK((x), (a) - 1)\n#define HUF_ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask))\n\n\n/* **************************************************************\n*  BMI2 Variant Wrappers\n****************************************************************/\ntypedef size_t (*HUF_DecompressUsingDTableFn)(void *dst, size_t dstSize,\n                                              const void *cSrc,\n                                              size_t cSrcSize,\n                                              const HUF_DTable *DTable);\n\n#if DYNAMIC_BMI2\n\n#define HUF_DGEN(fn)                                                        \\\n                                                                            \\\n    static size_t fn##_default(                                             \\\n                  void* dst,  size_t dstSize,                               \\\n            const void* cSrc, size_t cSrcSize,                              \\\n            const HUF_DTable* DTable)                                       \\\n    {                                                                       \\\n        return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \\\n    }                                                                       \\\n                                                                            \\\n    static BMI2_TARGET_ATTRIBUTE size_t fn##_bmi2(                          \\\n                  void* dst,  size_t dstSize,                               \\\n            const void* cSrc, size_t cSrcSize,                              \\\n            const HUF_DTable* DTable)                                       \\\n    {                                                                       \\\n        return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \\\n    }                                                                       \\\n                                                                            \\\n    static size_t fn(void* dst, size_t dstSize, void const* cSrc,           \\\n                     size_t cSrcSize, HUF_DTable const* DTable, int flags)  \\\n    {                                                                       \\\n        if (flags & HUF_flags_bmi2) {                                       \\\n            return fn##_bmi2(dst, dstSize, cSrc, cSrcSize, DTable);         \\\n        }                                                                   \\\n        return fn##_default(dst, dstSize, cSrc, cSrcSize, DTable);          \\\n    }\n\n#else\n\n#define HUF_DGEN(fn)                                                        \\\n    static size_t fn(void* dst, size_t dstSize, void const* cSrc,           \\\n                     size_t cSrcSize, HUF_DTable const* DTable, int flags)  \\\n    {                                                                       \\\n        (void)flags;                                                        \\\n        return fn##_body(dst, dstSize, cSrc, cSrcSize, DTable);             \\\n    }\n\n#endif\n\n\n/*-***************************/\n/*  generic DTableDesc       */\n/*-***************************/\ntypedef struct { BYTE maxTableLog; BYTE tableType; BYTE tableLog; BYTE reserved; } DTableDesc;\n\nstatic DTableDesc HUF_getDTableDesc(const HUF_DTable* table)\n{\n    DTableDesc dtd;\n    ZSTD_memcpy(&dtd, table, sizeof(dtd));\n    return dtd;\n}\n\nstatic size_t HUF_initFastDStream(BYTE const* ip) {\n    BYTE const lastByte = ip[7];\n    size_t const bitsConsumed = lastByte ? 8 - ZSTD_highbit32(lastByte) : 0;\n    size_t const value = MEM_readLEST(ip) | 1;\n    assert(bitsConsumed <= 8);\n    assert(sizeof(size_t) == 8);\n    return value << bitsConsumed;\n}\n\n\n/**\n * The input/output arguments to the Huffman fast decoding loop:\n *\n * ip [in/out] - The input pointers, must be updated to reflect what is consumed.\n * op [in/out] - The output pointers, must be updated to reflect what is written.\n * bits [in/out] - The bitstream containers, must be updated to reflect the current state.\n * dt [in] - The decoding table.\n * ilowest [in] - The beginning of the valid range of the input. Decoders may read\n *                down to this pointer. It may be below iend[0].\n * oend [in] - The end of the output stream. op[3] must not cross oend.\n * iend [in] - The end of each input stream. ip[i] may cross iend[i],\n *             as long as it is above ilowest, but that indicates corruption.\n */\ntypedef struct {\n    BYTE const* ip[4];\n    BYTE* op[4];\n    U64 bits[4];\n    void const* dt;\n    BYTE const* ilowest;\n    BYTE* oend;\n    BYTE const* iend[4];\n} HUF_DecompressFastArgs;\n\ntypedef void (*HUF_DecompressFastLoopFn)(HUF_DecompressFastArgs*);\n\n/**\n * Initializes args for the fast decoding loop.\n * @returns 1 on success\n *          0 if the fallback implementation should be used.\n *          Or an error code on failure.\n */\nstatic size_t HUF_DecompressFastArgs_init(HUF_DecompressFastArgs* args, void* dst, size_t dstSize, void const* src, size_t srcSize, const HUF_DTable* DTable)\n{\n    void const* dt = DTable + 1;\n    U32 const dtLog = HUF_getDTableDesc(DTable).tableLog;\n\n    const BYTE* const istart = (const BYTE*)src;\n\n    BYTE* const oend = (BYTE*)ZSTD_maybeNullPtrAdd(dst, (ptrdiff_t)dstSize);\n\n    /* The fast decoding loop assumes 64-bit little-endian.\n     * This condition is false on x32.\n     */\n    if (!MEM_isLittleEndian() || MEM_32bits())\n        return 0;\n\n    /* Avoid nullptr addition */\n    if (dstSize == 0)\n        return 0;\n    assert(dst != NULL);\n\n    /* strict minimum : jump table + 1 byte per stream */\n    if (srcSize < 10)\n        return ERROR(corruption_detected);\n\n    /* Must have at least 8 bytes per stream because we don't handle initializing smaller bit containers.\n     * If table log is not correct at this point, fallback to the old decoder.\n     * On small inputs we don't have enough data to trigger the fast loop, so use the old decoder.\n     */\n    if (dtLog != HUF_DECODER_FAST_TABLELOG)\n        return 0;\n\n    /* Read the jump table. */\n    {\n        size_t const length1 = MEM_readLE16(istart);\n        size_t const length2 = MEM_readLE16(istart+2);\n        size_t const length3 = MEM_readLE16(istart+4);\n        size_t const length4 = srcSize - (length1 + length2 + length3 + 6);\n        args->iend[0] = istart + 6;  /* jumpTable */\n        args->iend[1] = args->iend[0] + length1;\n        args->iend[2] = args->iend[1] + length2;\n        args->iend[3] = args->iend[2] + length3;\n\n        /* HUF_initFastDStream() requires this, and this small of an input\n         * won't benefit from the ASM loop anyways.\n         */\n        if (length1 < 8 || length2 < 8 || length3 < 8 || length4 < 8)\n            return 0;\n        if (length4 > srcSize) return ERROR(corruption_detected);   /* overflow */\n    }\n    /* ip[] contains the position that is currently loaded into bits[]. */\n    args->ip[0] = args->iend[1] - sizeof(U64);\n    args->ip[1] = args->iend[2] - sizeof(U64);\n    args->ip[2] = args->iend[3] - sizeof(U64);\n    args->ip[3] = (BYTE const*)src + srcSize - sizeof(U64);\n\n    /* op[] contains the output pointers. */\n    args->op[0] = (BYTE*)dst;\n    args->op[1] = args->op[0] + (dstSize+3)/4;\n    args->op[2] = args->op[1] + (dstSize+3)/4;\n    args->op[3] = args->op[2] + (dstSize+3)/4;\n\n    /* No point to call the ASM loop for tiny outputs. */\n    if (args->op[3] >= oend)\n        return 0;\n\n    /* bits[] is the bit container.\n        * It is read from the MSB down to the LSB.\n        * It is shifted left as it is read, and zeros are\n        * shifted in. After the lowest valid bit a 1 is\n        * set, so that CountTrailingZeros(bits[]) can be used\n        * to count how many bits we've consumed.\n        */\n    args->bits[0] = HUF_initFastDStream(args->ip[0]);\n    args->bits[1] = HUF_initFastDStream(args->ip[1]);\n    args->bits[2] = HUF_initFastDStream(args->ip[2]);\n    args->bits[3] = HUF_initFastDStream(args->ip[3]);\n\n    /* The decoders must be sure to never read beyond ilowest.\n     * This is lower than iend[0], but allowing decoders to read\n     * down to ilowest can allow an extra iteration or two in the\n     * fast loop.\n     */\n    args->ilowest = istart;\n\n    args->oend = oend;\n    args->dt = dt;\n\n    return 1;\n}\n\nstatic size_t HUF_initRemainingDStream(BIT_DStream_t* bit, HUF_DecompressFastArgs const* args, int stream, BYTE* segmentEnd)\n{\n    /* Validate that we haven't overwritten. */\n    if (args->op[stream] > segmentEnd)\n        return ERROR(corruption_detected);\n    /* Validate that we haven't read beyond iend[].\n        * Note that ip[] may be < iend[] because the MSB is\n        * the next bit to read, and we may have consumed 100%\n        * of the stream, so down to iend[i] - 8 is valid.\n        */\n    if (args->ip[stream] < args->iend[stream] - 8)\n        return ERROR(corruption_detected);\n\n    /* Construct the BIT_DStream_t. */\n    assert(sizeof(size_t) == 8);\n    bit->bitContainer = MEM_readLEST(args->ip[stream]);\n    bit->bitsConsumed = ZSTD_countTrailingZeros64(args->bits[stream]);\n    bit->start = (const char*)args->ilowest;\n    bit->limitPtr = bit->start + sizeof(size_t);\n    bit->ptr = (const char*)args->ip[stream];\n\n    return 0;\n}\n\n/* Calls X(N) for each stream 0, 1, 2, 3. */\n#define HUF_4X_FOR_EACH_STREAM(X) \\\n    do {                          \\\n        X(0);                     \\\n        X(1);                     \\\n        X(2);                     \\\n        X(3);                     \\\n    } while (0)\n\n/* Calls X(N, var) for each stream 0, 1, 2, 3. */\n#define HUF_4X_FOR_EACH_STREAM_WITH_VAR(X, var) \\\n    do {                                        \\\n        X(0, (var));                            \\\n        X(1, (var));                            \\\n        X(2, (var));                            \\\n        X(3, (var));                            \\\n    } while (0)\n\n\n#ifndef HUF_FORCE_DECOMPRESS_X2\n\n/*-***************************/\n/*  single-symbol decoding   */\n/*-***************************/\ntypedef struct { BYTE nbBits; BYTE byte; } HUF_DEltX1;   /* single-symbol decoding */\n\n/**\n * Packs 4 HUF_DEltX1 structs into a U64. This is used to lay down 4 entries at\n * a time.\n */\nstatic U64 HUF_DEltX1_set4(BYTE symbol, BYTE nbBits) {\n    U64 D4;\n    if (MEM_isLittleEndian()) {\n        D4 = (U64)((symbol << 8) + nbBits);\n    } else {\n        D4 = (U64)(symbol + (nbBits << 8));\n    }\n    assert(D4 < (1U << 16));\n    D4 *= 0x0001000100010001ULL;\n    return D4;\n}\n\n/**\n * Increase the tableLog to targetTableLog and rescales the stats.\n * If tableLog > targetTableLog this is a no-op.\n * @returns New tableLog\n */\nstatic U32 HUF_rescaleStats(BYTE* huffWeight, U32* rankVal, U32 nbSymbols, U32 tableLog, U32 targetTableLog)\n{\n    if (tableLog > targetTableLog)\n        return tableLog;\n    if (tableLog < targetTableLog) {\n        U32 const scale = targetTableLog - tableLog;\n        U32 s;\n        /* Increase the weight for all non-zero probability symbols by scale. */\n        for (s = 0; s < nbSymbols; ++s) {\n            huffWeight[s] += (BYTE)((huffWeight[s] == 0) ? 0 : scale);\n        }\n        /* Update rankVal to reflect the new weights.\n         * All weights except 0 get moved to weight + scale.\n         * Weights [1, scale] are empty.\n         */\n        for (s = targetTableLog; s > scale; --s) {\n            rankVal[s] = rankVal[s - scale];\n        }\n        for (s = scale; s > 0; --s) {\n            rankVal[s] = 0;\n        }\n    }\n    return targetTableLog;\n}\n\ntypedef struct {\n        U32 rankVal[HUF_TABLELOG_ABSOLUTEMAX + 1];\n        U32 rankStart[HUF_TABLELOG_ABSOLUTEMAX + 1];\n        U32 statsWksp[HUF_READ_STATS_WORKSPACE_SIZE_U32];\n        BYTE symbols[HUF_SYMBOLVALUE_MAX + 1];\n        BYTE huffWeight[HUF_SYMBOLVALUE_MAX + 1];\n} HUF_ReadDTableX1_Workspace;\n\nsize_t HUF_readDTableX1_wksp(HUF_DTable* DTable, const void* src, size_t srcSize, void* workSpace, size_t wkspSize, int flags)\n{\n    U32 tableLog = 0;\n    U32 nbSymbols = 0;\n    size_t iSize;\n    void* const dtPtr = DTable + 1;\n    HUF_DEltX1* const dt = (HUF_DEltX1*)dtPtr;\n    HUF_ReadDTableX1_Workspace* wksp = (HUF_ReadDTableX1_Workspace*)workSpace;\n\n    DEBUG_STATIC_ASSERT(HUF_DECOMPRESS_WORKSPACE_SIZE >= sizeof(*wksp));\n    if (sizeof(*wksp) > wkspSize) return ERROR(tableLog_tooLarge);\n\n    DEBUG_STATIC_ASSERT(sizeof(DTableDesc) == sizeof(HUF_DTable));\n    /* ZSTD_memset(huffWeight, 0, sizeof(huffWeight)); */   /* is not necessary, even though some analyzer complain ... */\n\n    iSize = HUF_readStats_wksp(wksp->huffWeight, HUF_SYMBOLVALUE_MAX + 1, wksp->rankVal, &nbSymbols, &tableLog, src, srcSize, wksp->statsWksp, sizeof(wksp->statsWksp), flags);\n    if (HUF_isError(iSize)) return iSize;\n\n\n    /* Table header */\n    {   DTableDesc dtd = HUF_getDTableDesc(DTable);\n        U32 const maxTableLog = dtd.maxTableLog + 1;\n        U32 const targetTableLog = MIN(maxTableLog, HUF_DECODER_FAST_TABLELOG);\n        tableLog = HUF_rescaleStats(wksp->huffWeight, wksp->rankVal, nbSymbols, tableLog, targetTableLog);\n        if (tableLog > (U32)(dtd.maxTableLog+1)) return ERROR(tableLog_tooLarge);   /* DTable too small, Huffman tree cannot fit in */\n        dtd.tableType = 0;\n        dtd.tableLog = (BYTE)tableLog;\n        ZSTD_memcpy(DTable, &dtd, sizeof(dtd));\n    }\n\n    /* Compute symbols and rankStart given rankVal:\n     *\n     * rankVal already contains the number of values of each weight.\n     *\n     * symbols contains the symbols ordered by weight. First are the rankVal[0]\n     * weight 0 symbols, followed by the rankVal[1] weight 1 symbols, and so on.\n     * symbols[0] is filled (but unused) to avoid a branch.\n     *\n     * rankStart contains the offset where each rank belongs in the DTable.\n     * rankStart[0] is not filled because there are no entries in the table for\n     * weight 0.\n     */\n    {   int n;\n        U32 nextRankStart = 0;\n        int const unroll = 4;\n        int const nLimit = (int)nbSymbols - unroll + 1;\n        for (n=0; n<(int)tableLog+1; n++) {\n            U32 const curr = nextRankStart;\n            nextRankStart += wksp->rankVal[n];\n            wksp->rankStart[n] = curr;\n        }\n        for (n=0; n < nLimit; n += unroll) {\n            int u;\n            for (u=0; u < unroll; ++u) {\n                size_t const w = wksp->huffWeight[n+u];\n                wksp->symbols[wksp->rankStart[w]++] = (BYTE)(n+u);\n            }\n        }\n        for (; n < (int)nbSymbols; ++n) {\n            size_t const w = wksp->huffWeight[n];\n            wksp->symbols[wksp->rankStart[w]++] = (BYTE)n;\n        }\n    }\n\n    /* fill DTable\n     * We fill all entries of each weight in order.\n     * That way length is a constant for each iteration of the outer loop.\n     * We can switch based on the length to a different inner loop which is\n     * optimized for that particular case.\n     */\n    {   U32 w;\n        int symbol = wksp->rankVal[0];\n        int rankStart = 0;\n        for (w=1; wrankVal[w];\n            int const length = (1 << w) >> 1;\n            int uStart = rankStart;\n            BYTE const nbBits = (BYTE)(tableLog + 1 - w);\n            int s;\n            int u;\n            switch (length) {\n            case 1:\n                for (s=0; ssymbols[symbol + s];\n                    D.nbBits = nbBits;\n                    dt[uStart] = D;\n                    uStart += 1;\n                }\n                break;\n            case 2:\n                for (s=0; ssymbols[symbol + s];\n                    D.nbBits = nbBits;\n                    dt[uStart+0] = D;\n                    dt[uStart+1] = D;\n                    uStart += 2;\n                }\n                break;\n            case 4:\n                for (s=0; ssymbols[symbol + s], nbBits);\n                    MEM_write64(dt + uStart, D4);\n                    uStart += 4;\n                }\n                break;\n            case 8:\n                for (s=0; ssymbols[symbol + s], nbBits);\n                    MEM_write64(dt + uStart, D4);\n                    MEM_write64(dt + uStart + 4, D4);\n                    uStart += 8;\n                }\n                break;\n            default:\n                for (s=0; ssymbols[symbol + s], nbBits);\n                    for (u=0; u < length; u += 16) {\n                        MEM_write64(dt + uStart + u + 0, D4);\n                        MEM_write64(dt + uStart + u + 4, D4);\n                        MEM_write64(dt + uStart + u + 8, D4);\n                        MEM_write64(dt + uStart + u + 12, D4);\n                    }\n                    assert(u == length);\n                    uStart += length;\n                }\n                break;\n            }\n            symbol += symbolCount;\n            rankStart += symbolCount * length;\n        }\n    }\n    return iSize;\n}\n\nFORCE_INLINE_TEMPLATE BYTE\nHUF_decodeSymbolX1(BIT_DStream_t* Dstream, const HUF_DEltX1* dt, const U32 dtLog)\n{\n    size_t const val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */\n    BYTE const c = dt[val].byte;\n    BIT_skipBits(Dstream, dt[val].nbBits);\n    return c;\n}\n\n#define HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr) \\\n    do { *ptr++ = HUF_decodeSymbolX1(DStreamPtr, dt, dtLog); } while (0)\n\n#define HUF_DECODE_SYMBOLX1_1(ptr, DStreamPtr)      \\\n    do {                                            \\\n        if (MEM_64bits() || (HUF_TABLELOG_MAX<=12)) \\\n            HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr); \\\n    } while (0)\n\n#define HUF_DECODE_SYMBOLX1_2(ptr, DStreamPtr)      \\\n    do {                                            \\\n        if (MEM_64bits())                           \\\n            HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr); \\\n    } while (0)\n\nHINT_INLINE size_t\nHUF_decodeStreamX1(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX1* const dt, const U32 dtLog)\n{\n    BYTE* const pStart = p;\n\n    /* up to 4 symbols at a time */\n    if ((pEnd - p) > 3) {\n        while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-3)) {\n            HUF_DECODE_SYMBOLX1_2(p, bitDPtr);\n            HUF_DECODE_SYMBOLX1_1(p, bitDPtr);\n            HUF_DECODE_SYMBOLX1_2(p, bitDPtr);\n            HUF_DECODE_SYMBOLX1_0(p, bitDPtr);\n        }\n    } else {\n        BIT_reloadDStream(bitDPtr);\n    }\n\n    /* [0-3] symbols remaining */\n    if (MEM_32bits())\n        while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd))\n            HUF_DECODE_SYMBOLX1_0(p, bitDPtr);\n\n    /* no more data to retrieve from bitstream, no need to reload */\n    while (p < pEnd)\n        HUF_DECODE_SYMBOLX1_0(p, bitDPtr);\n\n    return (size_t)(pEnd-pStart);\n}\n\nFORCE_INLINE_TEMPLATE size_t\nHUF_decompress1X1_usingDTable_internal_body(\n          void* dst,  size_t dstSize,\n    const void* cSrc, size_t cSrcSize,\n    const HUF_DTable* DTable)\n{\n    BYTE* op = (BYTE*)dst;\n    BYTE* const oend = (BYTE*)ZSTD_maybeNullPtrAdd(op, (ptrdiff_t)dstSize);\n    const void* dtPtr = DTable + 1;\n    const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr;\n    BIT_DStream_t bitD;\n    DTableDesc const dtd = HUF_getDTableDesc(DTable);\n    U32 const dtLog = dtd.tableLog;\n\n    CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) );\n\n    HUF_decodeStreamX1(op, &bitD, oend, dt, dtLog);\n\n    if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);\n\n    return dstSize;\n}\n\n/* HUF_decompress4X1_usingDTable_internal_body():\n * Conditions :\n * @dstSize >= 6\n */\nFORCE_INLINE_TEMPLATE size_t\nHUF_decompress4X1_usingDTable_internal_body(\n          void* dst,  size_t dstSize,\n    const void* cSrc, size_t cSrcSize,\n    const HUF_DTable* DTable)\n{\n    /* Check */\n    if (cSrcSize < 10) return ERROR(corruption_detected);  /* strict minimum : jump table + 1 byte per stream */\n    if (dstSize < 6) return ERROR(corruption_detected);         /* stream 4-split doesn't work */\n\n    {   const BYTE* const istart = (const BYTE*) cSrc;\n        BYTE* const ostart = (BYTE*) dst;\n        BYTE* const oend = ostart + dstSize;\n        BYTE* const olimit = oend - 3;\n        const void* const dtPtr = DTable + 1;\n        const HUF_DEltX1* const dt = (const HUF_DEltX1*)dtPtr;\n\n        /* Init */\n        BIT_DStream_t bitD1;\n        BIT_DStream_t bitD2;\n        BIT_DStream_t bitD3;\n        BIT_DStream_t bitD4;\n        size_t const length1 = MEM_readLE16(istart);\n        size_t const length2 = MEM_readLE16(istart+2);\n        size_t const length3 = MEM_readLE16(istart+4);\n        size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);\n        const BYTE* const istart1 = istart + 6;  /* jumpTable */\n        const BYTE* const istart2 = istart1 + length1;\n        const BYTE* const istart3 = istart2 + length2;\n        const BYTE* const istart4 = istart3 + length3;\n        const size_t segmentSize = (dstSize+3) / 4;\n        BYTE* const opStart2 = ostart + segmentSize;\n        BYTE* const opStart3 = opStart2 + segmentSize;\n        BYTE* const opStart4 = opStart3 + segmentSize;\n        BYTE* op1 = ostart;\n        BYTE* op2 = opStart2;\n        BYTE* op3 = opStart3;\n        BYTE* op4 = opStart4;\n        DTableDesc const dtd = HUF_getDTableDesc(DTable);\n        U32 const dtLog = dtd.tableLog;\n        U32 endSignal = 1;\n\n        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */\n        if (opStart4 > oend) return ERROR(corruption_detected);      /* overflow */\n        assert(dstSize >= 6); /* validated above */\n        CHECK_F( BIT_initDStream(&bitD1, istart1, length1) );\n        CHECK_F( BIT_initDStream(&bitD2, istart2, length2) );\n        CHECK_F( BIT_initDStream(&bitD3, istart3, length3) );\n        CHECK_F( BIT_initDStream(&bitD4, istart4, length4) );\n\n        /* up to 16 symbols per loop (4 symbols per stream) in 64-bit mode */\n        if ((size_t)(oend - op4) >= sizeof(size_t)) {\n            for ( ; (endSignal) & (op4 < olimit) ; ) {\n                HUF_DECODE_SYMBOLX1_2(op1, &bitD1);\n                HUF_DECODE_SYMBOLX1_2(op2, &bitD2);\n                HUF_DECODE_SYMBOLX1_2(op3, &bitD3);\n                HUF_DECODE_SYMBOLX1_2(op4, &bitD4);\n                HUF_DECODE_SYMBOLX1_1(op1, &bitD1);\n                HUF_DECODE_SYMBOLX1_1(op2, &bitD2);\n                HUF_DECODE_SYMBOLX1_1(op3, &bitD3);\n                HUF_DECODE_SYMBOLX1_1(op4, &bitD4);\n                HUF_DECODE_SYMBOLX1_2(op1, &bitD1);\n                HUF_DECODE_SYMBOLX1_2(op2, &bitD2);\n                HUF_DECODE_SYMBOLX1_2(op3, &bitD3);\n                HUF_DECODE_SYMBOLX1_2(op4, &bitD4);\n                HUF_DECODE_SYMBOLX1_0(op1, &bitD1);\n                HUF_DECODE_SYMBOLX1_0(op2, &bitD2);\n                HUF_DECODE_SYMBOLX1_0(op3, &bitD3);\n                HUF_DECODE_SYMBOLX1_0(op4, &bitD4);\n                endSignal &= BIT_reloadDStreamFast(&bitD1) == BIT_DStream_unfinished;\n                endSignal &= BIT_reloadDStreamFast(&bitD2) == BIT_DStream_unfinished;\n                endSignal &= BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished;\n                endSignal &= BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished;\n            }\n        }\n\n        /* check corruption */\n        /* note : should not be necessary : op# advance in lock step, and we control op4.\n         *        but curiously, binary generated by gcc 7.2 & 7.3 with -mbmi2 runs faster when >=1 test is present */\n        if (op1 > opStart2) return ERROR(corruption_detected);\n        if (op2 > opStart3) return ERROR(corruption_detected);\n        if (op3 > opStart4) return ERROR(corruption_detected);\n        /* note : op4 supposed already verified within main loop */\n\n        /* finish bitStreams one by one */\n        HUF_decodeStreamX1(op1, &bitD1, opStart2, dt, dtLog);\n        HUF_decodeStreamX1(op2, &bitD2, opStart3, dt, dtLog);\n        HUF_decodeStreamX1(op3, &bitD3, opStart4, dt, dtLog);\n        HUF_decodeStreamX1(op4, &bitD4, oend,     dt, dtLog);\n\n        /* check */\n        { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);\n          if (!endCheck) return ERROR(corruption_detected); }\n\n        /* decoded size */\n        return dstSize;\n    }\n}\n\n#if HUF_NEED_BMI2_FUNCTION\nstatic BMI2_TARGET_ATTRIBUTE\nsize_t HUF_decompress4X1_usingDTable_internal_bmi2(void* dst, size_t dstSize, void const* cSrc,\n                    size_t cSrcSize, HUF_DTable const* DTable) {\n    return HUF_decompress4X1_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable);\n}\n#endif\n\nstatic\nsize_t HUF_decompress4X1_usingDTable_internal_default(void* dst, size_t dstSize, void const* cSrc,\n                    size_t cSrcSize, HUF_DTable const* DTable) {\n    return HUF_decompress4X1_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable);\n}\n\n#if ZSTD_ENABLE_ASM_X86_64_BMI2\n\nHUF_ASM_DECL void HUF_decompress4X1_usingDTable_internal_fast_asm_loop(HUF_DecompressFastArgs* args) ZSTDLIB_HIDDEN;\n\n#endif\n\nstatic HUF_FAST_BMI2_ATTRS\nvoid HUF_decompress4X1_usingDTable_internal_fast_c_loop(HUF_DecompressFastArgs* args)\n{\n    U64 bits[4];\n    BYTE const* ip[4];\n    BYTE* op[4];\n    U16 const* const dtable = (U16 const*)args->dt;\n    BYTE* const oend = args->oend;\n    BYTE const* const ilowest = args->ilowest;\n\n    /* Copy the arguments to local variables */\n    ZSTD_memcpy(&bits, &args->bits, sizeof(bits));\n    ZSTD_memcpy((void*)(&ip), &args->ip, sizeof(ip));\n    ZSTD_memcpy(&op, &args->op, sizeof(op));\n\n    assert(MEM_isLittleEndian());\n    assert(!MEM_32bits());\n\n    for (;;) {\n        BYTE* olimit;\n        int stream;\n\n        /* Assert loop preconditions */\n#ifndef NDEBUG\n        for (stream = 0; stream < 4; ++stream) {\n            assert(op[stream] <= (stream == 3 ? oend : op[stream + 1]));\n            assert(ip[stream] >= ilowest);\n        }\n#endif\n        /* Compute olimit */\n        {\n            /* Each iteration produces 5 output symbols per stream */\n            size_t const oiters = (size_t)(oend - op[3]) / 5;\n            /* Each iteration consumes up to 11 bits * 5 = 55 bits < 7 bytes\n             * per stream.\n             */\n            size_t const iiters = (size_t)(ip[0] - ilowest) / 7;\n            /* We can safely run iters iterations before running bounds checks */\n            size_t const iters = MIN(oiters, iiters);\n            size_t const symbols = iters * 5;\n\n            /* We can simply check that op[3] < olimit, instead of checking all\n             * of our bounds, since we can't hit the other bounds until we've run\n             * iters iterations, which only happens when op[3] == olimit.\n             */\n            olimit = op[3] + symbols;\n\n            /* Exit fast decoding loop once we reach the end. */\n            if (op[3] == olimit)\n                break;\n\n            /* Exit the decoding loop if any input pointer has crossed the\n             * previous one. This indicates corruption, and a precondition\n             * to our loop is that ip[i] >= ip[0].\n             */\n            for (stream = 1; stream < 4; ++stream) {\n                if (ip[stream] < ip[stream - 1])\n                    goto _out;\n            }\n        }\n\n#ifndef NDEBUG\n        for (stream = 1; stream < 4; ++stream) {\n            assert(ip[stream] >= ip[stream - 1]);\n        }\n#endif\n\n#define HUF_4X1_DECODE_SYMBOL(_stream, _symbol)        \\\n    do {                                               \\\n        U64 const index = bits[(_stream)] >> 53;       \\\n        U16 const entry = dtable[index];               \\\n        bits[(_stream)] <<= entry & 0x3F;              \\\n        op[(_stream)][(_symbol)] = (BYTE)(entry >> 8); \\\n    } while (0)\n\n#define HUF_5X1_RELOAD_STREAM(_stream)                              \\\n    do {                                                            \\\n        U64 const ctz = ZSTD_countTrailingZeros64(bits[(_stream)]); \\\n        U64 const nbBits = ctz & 7;                                 \\\n        U64 const nbBytes = ctz >> 3;                               \\\n        op[(_stream)] += 5;                                         \\\n        ip[(_stream)] -= nbBytes;                                   \\\n        bits[(_stream)] = MEM_read64(ip[(_stream)]) | 1;            \\\n        bits[(_stream)] <<= nbBits;                                 \\\n    } while (0)\n\n        /* Manually unroll the loop because compilers don't consistently\n         * unroll the inner loops, which destroys performance.\n         */\n        do {\n            /* Decode 5 symbols in each of the 4 streams */\n            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X1_DECODE_SYMBOL, 0);\n            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X1_DECODE_SYMBOL, 1);\n            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X1_DECODE_SYMBOL, 2);\n            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X1_DECODE_SYMBOL, 3);\n            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X1_DECODE_SYMBOL, 4);\n\n            /* Reload each of the 4 the bitstreams */\n            HUF_4X_FOR_EACH_STREAM(HUF_5X1_RELOAD_STREAM);\n        } while (op[3] < olimit);\n\n#undef HUF_4X1_DECODE_SYMBOL\n#undef HUF_5X1_RELOAD_STREAM\n    }\n\n_out:\n\n    /* Save the final values of each of the state variables back to args. */\n    ZSTD_memcpy(&args->bits, &bits, sizeof(bits));\n    ZSTD_memcpy((void*)(&args->ip), &ip, sizeof(ip));\n    ZSTD_memcpy(&args->op, &op, sizeof(op));\n}\n\n/**\n * @returns @p dstSize on success (>= 6)\n *          0 if the fallback implementation should be used\n *          An error if an error occurred\n */\nstatic HUF_FAST_BMI2_ATTRS\nsize_t\nHUF_decompress4X1_usingDTable_internal_fast(\n          void* dst,  size_t dstSize,\n    const void* cSrc, size_t cSrcSize,\n    const HUF_DTable* DTable,\n    HUF_DecompressFastLoopFn loopFn)\n{\n    void const* dt = DTable + 1;\n    BYTE const* const ilowest = (BYTE const*)cSrc;\n    BYTE* const oend = (BYTE*)ZSTD_maybeNullPtrAdd(dst, (ptrdiff_t)dstSize);\n    HUF_DecompressFastArgs args;\n    {   size_t const ret = HUF_DecompressFastArgs_init(&args, dst, dstSize, cSrc, cSrcSize, DTable);\n        FORWARD_IF_ERROR(ret, \"Failed to init fast loop args\");\n        if (ret == 0)\n            return 0;\n    }\n\n    assert(args.ip[0] >= args.ilowest);\n    loopFn(&args);\n\n    /* Our loop guarantees that ip[] >= ilowest and that we haven't\n    * overwritten any op[].\n    */\n    assert(args.ip[0] >= ilowest);\n    assert(args.ip[0] >= ilowest);\n    assert(args.ip[1] >= ilowest);\n    assert(args.ip[2] >= ilowest);\n    assert(args.ip[3] >= ilowest);\n    assert(args.op[3] <= oend);\n\n    assert(ilowest == args.ilowest);\n    assert(ilowest + 6 == args.iend[0]);\n    (void)ilowest;\n\n    /* finish bit streams one by one. */\n    {   size_t const segmentSize = (dstSize+3) / 4;\n        BYTE* segmentEnd = (BYTE*)dst;\n        int i;\n        for (i = 0; i < 4; ++i) {\n            BIT_DStream_t bit;\n            if (segmentSize <= (size_t)(oend - segmentEnd))\n                segmentEnd += segmentSize;\n            else\n                segmentEnd = oend;\n            FORWARD_IF_ERROR(HUF_initRemainingDStream(&bit, &args, i, segmentEnd), \"corruption\");\n            /* Decompress and validate that we've produced exactly the expected length. */\n            args.op[i] += HUF_decodeStreamX1(args.op[i], &bit, segmentEnd, (HUF_DEltX1 const*)dt, HUF_DECODER_FAST_TABLELOG);\n            if (args.op[i] != segmentEnd) return ERROR(corruption_detected);\n        }\n    }\n\n    /* decoded size */\n    assert(dstSize != 0);\n    return dstSize;\n}\n\nHUF_DGEN(HUF_decompress1X1_usingDTable_internal)\n\nstatic size_t HUF_decompress4X1_usingDTable_internal(void* dst, size_t dstSize, void const* cSrc,\n                    size_t cSrcSize, HUF_DTable const* DTable, int flags)\n{\n    HUF_DecompressUsingDTableFn fallbackFn = HUF_decompress4X1_usingDTable_internal_default;\n    HUF_DecompressFastLoopFn loopFn = HUF_decompress4X1_usingDTable_internal_fast_c_loop;\n\n#if DYNAMIC_BMI2\n    if (flags & HUF_flags_bmi2) {\n        fallbackFn = HUF_decompress4X1_usingDTable_internal_bmi2;\n# if ZSTD_ENABLE_ASM_X86_64_BMI2\n        if (!(flags & HUF_flags_disableAsm)) {\n            loopFn = HUF_decompress4X1_usingDTable_internal_fast_asm_loop;\n        }\n# endif\n    } else {\n        return fallbackFn(dst, dstSize, cSrc, cSrcSize, DTable);\n    }\n#endif\n\n#if ZSTD_ENABLE_ASM_X86_64_BMI2 && defined(__BMI2__)\n    if (!(flags & HUF_flags_disableAsm)) {\n        loopFn = HUF_decompress4X1_usingDTable_internal_fast_asm_loop;\n    }\n#endif\n\n    if (HUF_ENABLE_FAST_DECODE && !(flags & HUF_flags_disableFast)) {\n        size_t const ret = HUF_decompress4X1_usingDTable_internal_fast(dst, dstSize, cSrc, cSrcSize, DTable, loopFn);\n        if (ret != 0)\n            return ret;\n    }\n    return fallbackFn(dst, dstSize, cSrc, cSrcSize, DTable);\n}\n\nstatic size_t HUF_decompress4X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,\n                                   const void* cSrc, size_t cSrcSize,\n                                   void* workSpace, size_t wkspSize, int flags)\n{\n    const BYTE* ip = (const BYTE*) cSrc;\n\n    size_t const hSize = HUF_readDTableX1_wksp(dctx, cSrc, cSrcSize, workSpace, wkspSize, flags);\n    if (HUF_isError(hSize)) return hSize;\n    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);\n    ip += hSize; cSrcSize -= hSize;\n\n    return HUF_decompress4X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, flags);\n}\n\n#endif /* HUF_FORCE_DECOMPRESS_X2 */\n\n\n#ifndef HUF_FORCE_DECOMPRESS_X1\n\n/* *************************/\n/* double-symbols decoding */\n/* *************************/\n\ntypedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX2;  /* double-symbols decoding */\ntypedef struct { BYTE symbol; } sortedSymbol_t;\ntypedef U32 rankValCol_t[HUF_TABLELOG_MAX + 1];\ntypedef rankValCol_t rankVal_t[HUF_TABLELOG_MAX];\n\n/**\n * Constructs a HUF_DEltX2 in a U32.\n */\nstatic U32 HUF_buildDEltX2U32(U32 symbol, U32 nbBits, U32 baseSeq, int level)\n{\n    U32 seq;\n    DEBUG_STATIC_ASSERT(offsetof(HUF_DEltX2, sequence) == 0);\n    DEBUG_STATIC_ASSERT(offsetof(HUF_DEltX2, nbBits) == 2);\n    DEBUG_STATIC_ASSERT(offsetof(HUF_DEltX2, length) == 3);\n    DEBUG_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(U32));\n    if (MEM_isLittleEndian()) {\n        seq = level == 1 ? symbol : (baseSeq + (symbol << 8));\n        return seq + (nbBits << 16) + ((U32)level << 24);\n    } else {\n        seq = level == 1 ? (symbol << 8) : ((baseSeq << 8) + symbol);\n        return (seq << 16) + (nbBits << 8) + (U32)level;\n    }\n}\n\n/**\n * Constructs a HUF_DEltX2.\n */\nstatic HUF_DEltX2 HUF_buildDEltX2(U32 symbol, U32 nbBits, U32 baseSeq, int level)\n{\n    HUF_DEltX2 DElt;\n    U32 const val = HUF_buildDEltX2U32(symbol, nbBits, baseSeq, level);\n    DEBUG_STATIC_ASSERT(sizeof(DElt) == sizeof(val));\n    ZSTD_memcpy(&DElt, &val, sizeof(val));\n    return DElt;\n}\n\n/**\n * Constructs 2 HUF_DEltX2s and packs them into a U64.\n */\nstatic U64 HUF_buildDEltX2U64(U32 symbol, U32 nbBits, U16 baseSeq, int level)\n{\n    U32 DElt = HUF_buildDEltX2U32(symbol, nbBits, baseSeq, level);\n    return (U64)DElt + ((U64)DElt << 32);\n}\n\n/**\n * Fills the DTable rank with all the symbols from [begin, end) that are each\n * nbBits long.\n *\n * @param DTableRank The start of the rank in the DTable.\n * @param begin The first symbol to fill (inclusive).\n * @param end The last symbol to fill (exclusive).\n * @param nbBits Each symbol is nbBits long.\n * @param tableLog The table log.\n * @param baseSeq If level == 1 { 0 } else { the first level symbol }\n * @param level The level in the table. Must be 1 or 2.\n */\nstatic void HUF_fillDTableX2ForWeight(\n    HUF_DEltX2* DTableRank,\n    sortedSymbol_t const* begin, sortedSymbol_t const* end,\n    U32 nbBits, U32 tableLog,\n    U16 baseSeq, int const level)\n{\n    U32 const length = 1U << ((tableLog - nbBits) & 0x1F /* quiet static-analyzer */);\n    const sortedSymbol_t* ptr;\n    assert(level >= 1 && level <= 2);\n    switch (length) {\n    case 1:\n        for (ptr = begin; ptr != end; ++ptr) {\n            HUF_DEltX2 const DElt = HUF_buildDEltX2(ptr->symbol, nbBits, baseSeq, level);\n            *DTableRank++ = DElt;\n        }\n        break;\n    case 2:\n        for (ptr = begin; ptr != end; ++ptr) {\n            HUF_DEltX2 const DElt = HUF_buildDEltX2(ptr->symbol, nbBits, baseSeq, level);\n            DTableRank[0] = DElt;\n            DTableRank[1] = DElt;\n            DTableRank += 2;\n        }\n        break;\n    case 4:\n        for (ptr = begin; ptr != end; ++ptr) {\n            U64 const DEltX2 = HUF_buildDEltX2U64(ptr->symbol, nbBits, baseSeq, level);\n            ZSTD_memcpy(DTableRank + 0, &DEltX2, sizeof(DEltX2));\n            ZSTD_memcpy(DTableRank + 2, &DEltX2, sizeof(DEltX2));\n            DTableRank += 4;\n        }\n        break;\n    case 8:\n        for (ptr = begin; ptr != end; ++ptr) {\n            U64 const DEltX2 = HUF_buildDEltX2U64(ptr->symbol, nbBits, baseSeq, level);\n            ZSTD_memcpy(DTableRank + 0, &DEltX2, sizeof(DEltX2));\n            ZSTD_memcpy(DTableRank + 2, &DEltX2, sizeof(DEltX2));\n            ZSTD_memcpy(DTableRank + 4, &DEltX2, sizeof(DEltX2));\n            ZSTD_memcpy(DTableRank + 6, &DEltX2, sizeof(DEltX2));\n            DTableRank += 8;\n        }\n        break;\n    default:\n        for (ptr = begin; ptr != end; ++ptr) {\n            U64 const DEltX2 = HUF_buildDEltX2U64(ptr->symbol, nbBits, baseSeq, level);\n            HUF_DEltX2* const DTableRankEnd = DTableRank + length;\n            for (; DTableRank != DTableRankEnd; DTableRank += 8) {\n                ZSTD_memcpy(DTableRank + 0, &DEltX2, sizeof(DEltX2));\n                ZSTD_memcpy(DTableRank + 2, &DEltX2, sizeof(DEltX2));\n                ZSTD_memcpy(DTableRank + 4, &DEltX2, sizeof(DEltX2));\n                ZSTD_memcpy(DTableRank + 6, &DEltX2, sizeof(DEltX2));\n            }\n        }\n        break;\n    }\n}\n\n/* HUF_fillDTableX2Level2() :\n * `rankValOrigin` must be a table of at least (HUF_TABLELOG_MAX + 1) U32 */\nstatic void HUF_fillDTableX2Level2(HUF_DEltX2* DTable, U32 targetLog, const U32 consumedBits,\n                           const U32* rankVal, const int minWeight, const int maxWeight1,\n                           const sortedSymbol_t* sortedSymbols, U32 const* rankStart,\n                           U32 nbBitsBaseline, U16 baseSeq)\n{\n    /* Fill skipped values (all positions up to rankVal[minWeight]).\n     * These are positions only get a single symbol because the combined weight\n     * is too large.\n     */\n    if (minWeight>1) {\n        U32 const length = 1U << ((targetLog - consumedBits) & 0x1F /* quiet static-analyzer */);\n        U64 const DEltX2 = HUF_buildDEltX2U64(baseSeq, consumedBits, /* baseSeq */ 0, /* level */ 1);\n        int const skipSize = rankVal[minWeight];\n        assert(length > 1);\n        assert((U32)skipSize < length);\n        switch (length) {\n        case 2:\n            assert(skipSize == 1);\n            ZSTD_memcpy(DTable, &DEltX2, sizeof(DEltX2));\n            break;\n        case 4:\n            assert(skipSize <= 4);\n            ZSTD_memcpy(DTable + 0, &DEltX2, sizeof(DEltX2));\n            ZSTD_memcpy(DTable + 2, &DEltX2, sizeof(DEltX2));\n            break;\n        default:\n            {\n                int i;\n                for (i = 0; i < skipSize; i += 8) {\n                    ZSTD_memcpy(DTable + i + 0, &DEltX2, sizeof(DEltX2));\n                    ZSTD_memcpy(DTable + i + 2, &DEltX2, sizeof(DEltX2));\n                    ZSTD_memcpy(DTable + i + 4, &DEltX2, sizeof(DEltX2));\n                    ZSTD_memcpy(DTable + i + 6, &DEltX2, sizeof(DEltX2));\n                }\n            }\n        }\n    }\n\n    /* Fill each of the second level symbols by weight. */\n    {\n        int w;\n        for (w = minWeight; w < maxWeight1; ++w) {\n            int const begin = rankStart[w];\n            int const end = rankStart[w+1];\n            U32 const nbBits = nbBitsBaseline - w;\n            U32 const totalBits = nbBits + consumedBits;\n            HUF_fillDTableX2ForWeight(\n                DTable + rankVal[w],\n                sortedSymbols + begin, sortedSymbols + end,\n                totalBits, targetLog,\n                baseSeq, /* level */ 2);\n        }\n    }\n}\n\nstatic void HUF_fillDTableX2(HUF_DEltX2* DTable, const U32 targetLog,\n                           const sortedSymbol_t* sortedList,\n                           const U32* rankStart, rankValCol_t* rankValOrigin, const U32 maxWeight,\n                           const U32 nbBitsBaseline)\n{\n    U32* const rankVal = rankValOrigin[0];\n    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */\n    const U32 minBits  = nbBitsBaseline - maxWeight;\n    int w;\n    int const wEnd = (int)maxWeight + 1;\n\n    /* Fill DTable in order of weight. */\n    for (w = 1; w < wEnd; ++w) {\n        int const begin = (int)rankStart[w];\n        int const end = (int)rankStart[w+1];\n        U32 const nbBits = nbBitsBaseline - w;\n\n        if (targetLog-nbBits >= minBits) {\n            /* Enough room for a second symbol. */\n            int start = rankVal[w];\n            U32 const length = 1U << ((targetLog - nbBits) & 0x1F /* quiet static-analyzer */);\n            int minWeight = nbBits + scaleLog;\n            int s;\n            if (minWeight < 1) minWeight = 1;\n            /* Fill the DTable for every symbol of weight w.\n             * These symbols get at least 1 second symbol.\n             */\n            for (s = begin; s != end; ++s) {\n                HUF_fillDTableX2Level2(\n                    DTable + start, targetLog, nbBits,\n                    rankValOrigin[nbBits], minWeight, wEnd,\n                    sortedList, rankStart,\n                    nbBitsBaseline, sortedList[s].symbol);\n                start += length;\n            }\n        } else {\n            /* Only a single symbol. */\n            HUF_fillDTableX2ForWeight(\n                DTable + rankVal[w],\n                sortedList + begin, sortedList + end,\n                nbBits, targetLog,\n                /* baseSeq */ 0, /* level */ 1);\n        }\n    }\n}\n\ntypedef struct {\n    rankValCol_t rankVal[HUF_TABLELOG_MAX];\n    U32 rankStats[HUF_TABLELOG_MAX + 1];\n    U32 rankStart0[HUF_TABLELOG_MAX + 3];\n    sortedSymbol_t sortedSymbol[HUF_SYMBOLVALUE_MAX + 1];\n    BYTE weightList[HUF_SYMBOLVALUE_MAX + 1];\n    U32 calleeWksp[HUF_READ_STATS_WORKSPACE_SIZE_U32];\n} HUF_ReadDTableX2_Workspace;\n\nsize_t HUF_readDTableX2_wksp(HUF_DTable* DTable,\n                       const void* src, size_t srcSize,\n                             void* workSpace, size_t wkspSize, int flags)\n{\n    U32 tableLog, maxW, nbSymbols;\n    DTableDesc dtd = HUF_getDTableDesc(DTable);\n    U32 maxTableLog = dtd.maxTableLog;\n    size_t iSize;\n    void* dtPtr = DTable+1;   /* force compiler to avoid strict-aliasing */\n    HUF_DEltX2* const dt = (HUF_DEltX2*)dtPtr;\n    U32 *rankStart;\n\n    HUF_ReadDTableX2_Workspace* const wksp = (HUF_ReadDTableX2_Workspace*)workSpace;\n\n    if (sizeof(*wksp) > wkspSize) return ERROR(GENERIC);\n\n    rankStart = wksp->rankStart0 + 1;\n    ZSTD_memset(wksp->rankStats, 0, sizeof(wksp->rankStats));\n    ZSTD_memset(wksp->rankStart0, 0, sizeof(wksp->rankStart0));\n\n    DEBUG_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(HUF_DTable));   /* if compiler fails here, assertion is wrong */\n    if (maxTableLog > HUF_TABLELOG_MAX) return ERROR(tableLog_tooLarge);\n    /* ZSTD_memset(weightList, 0, sizeof(weightList)); */  /* is not necessary, even though some analyzer complain ... */\n\n    iSize = HUF_readStats_wksp(wksp->weightList, HUF_SYMBOLVALUE_MAX + 1, wksp->rankStats, &nbSymbols, &tableLog, src, srcSize, wksp->calleeWksp, sizeof(wksp->calleeWksp), flags);\n    if (HUF_isError(iSize)) return iSize;\n\n    /* check result */\n    if (tableLog > maxTableLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */\n    if (tableLog <= HUF_DECODER_FAST_TABLELOG && maxTableLog > HUF_DECODER_FAST_TABLELOG) maxTableLog = HUF_DECODER_FAST_TABLELOG;\n\n    /* find maxWeight */\n    for (maxW = tableLog; wksp->rankStats[maxW]==0; maxW--) {}  /* necessarily finds a solution before 0 */\n\n    /* Get start index of each weight */\n    {   U32 w, nextRankStart = 0;\n        for (w=1; wrankStats[w];\n            rankStart[w] = curr;\n        }\n        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/\n        rankStart[maxW+1] = nextRankStart;\n    }\n\n    /* sort symbols by weight */\n    {   U32 s;\n        for (s=0; sweightList[s];\n            U32 const r = rankStart[w]++;\n            wksp->sortedSymbol[r].symbol = (BYTE)s;\n        }\n        rankStart[0] = 0;   /* forget 0w symbols; this is beginning of weight(1) */\n    }\n\n    /* Build rankVal */\n    {   U32* const rankVal0 = wksp->rankVal[0];\n        {   int const rescale = (maxTableLog-tableLog) - 1;   /* tableLog <= maxTableLog */\n            U32 nextRankVal = 0;\n            U32 w;\n            for (w=1; wrankStats[w] << (w+rescale);\n                rankVal0[w] = curr;\n        }   }\n        {   U32 const minBits = tableLog+1 - maxW;\n            U32 consumed;\n            for (consumed = minBits; consumed < maxTableLog - minBits + 1; consumed++) {\n                U32* const rankValPtr = wksp->rankVal[consumed];\n                U32 w;\n                for (w = 1; w < maxW+1; w++) {\n                    rankValPtr[w] = rankVal0[w] >> consumed;\n    }   }   }   }\n\n    HUF_fillDTableX2(dt, maxTableLog,\n                   wksp->sortedSymbol,\n                   wksp->rankStart0, wksp->rankVal, maxW,\n                   tableLog+1);\n\n    dtd.tableLog = (BYTE)maxTableLog;\n    dtd.tableType = 1;\n    ZSTD_memcpy(DTable, &dtd, sizeof(dtd));\n    return iSize;\n}\n\n\nFORCE_INLINE_TEMPLATE U32\nHUF_decodeSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)\n{\n    size_t const val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */\n    ZSTD_memcpy(op, &dt[val].sequence, 2);\n    BIT_skipBits(DStream, dt[val].nbBits);\n    return dt[val].length;\n}\n\nFORCE_INLINE_TEMPLATE U32\nHUF_decodeLastSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)\n{\n    size_t const val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */\n    ZSTD_memcpy(op, &dt[val].sequence, 1);\n    if (dt[val].length==1) {\n        BIT_skipBits(DStream, dt[val].nbBits);\n    } else {\n        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) {\n            BIT_skipBits(DStream, dt[val].nbBits);\n            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))\n                /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */\n                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);\n        }\n    }\n    return 1;\n}\n\n#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \\\n    do { ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog); } while (0)\n\n#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr)                     \\\n    do {                                                           \\\n        if (MEM_64bits() || (HUF_TABLELOG_MAX<=12))                \\\n            ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog); \\\n    } while (0)\n\n#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr)                     \\\n    do {                                                           \\\n        if (MEM_64bits())                                          \\\n            ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog); \\\n    } while (0)\n\nHINT_INLINE size_t\nHUF_decodeStreamX2(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd,\n                const HUF_DEltX2* const dt, const U32 dtLog)\n{\n    BYTE* const pStart = p;\n\n    /* up to 8 symbols at a time */\n    if ((size_t)(pEnd - p) >= sizeof(bitDPtr->bitContainer)) {\n        if (dtLog <= 11 && MEM_64bits()) {\n            /* up to 10 symbols at a time */\n            while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-9)) {\n                HUF_DECODE_SYMBOLX2_0(p, bitDPtr);\n                HUF_DECODE_SYMBOLX2_0(p, bitDPtr);\n                HUF_DECODE_SYMBOLX2_0(p, bitDPtr);\n                HUF_DECODE_SYMBOLX2_0(p, bitDPtr);\n                HUF_DECODE_SYMBOLX2_0(p, bitDPtr);\n            }\n        } else {\n            /* up to 8 symbols at a time */\n            while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-(sizeof(bitDPtr->bitContainer)-1))) {\n                HUF_DECODE_SYMBOLX2_2(p, bitDPtr);\n                HUF_DECODE_SYMBOLX2_1(p, bitDPtr);\n                HUF_DECODE_SYMBOLX2_2(p, bitDPtr);\n                HUF_DECODE_SYMBOLX2_0(p, bitDPtr);\n            }\n        }\n    } else {\n        BIT_reloadDStream(bitDPtr);\n    }\n\n    /* closer to end : up to 2 symbols at a time */\n    if ((size_t)(pEnd - p) >= 2) {\n        while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p <= pEnd-2))\n            HUF_DECODE_SYMBOLX2_0(p, bitDPtr);\n\n        while (p <= pEnd-2)\n            HUF_DECODE_SYMBOLX2_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */\n    }\n\n    if (p < pEnd)\n        p += HUF_decodeLastSymbolX2(p, bitDPtr, dt, dtLog);\n\n    return p-pStart;\n}\n\nFORCE_INLINE_TEMPLATE size_t\nHUF_decompress1X2_usingDTable_internal_body(\n          void* dst,  size_t dstSize,\n    const void* cSrc, size_t cSrcSize,\n    const HUF_DTable* DTable)\n{\n    BIT_DStream_t bitD;\n\n    /* Init */\n    CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) );\n\n    /* decode */\n    {   BYTE* const ostart = (BYTE*) dst;\n        BYTE* const oend = (BYTE*)ZSTD_maybeNullPtrAdd(ostart, (ptrdiff_t)dstSize);\n        const void* const dtPtr = DTable+1;   /* force compiler to not use strict-aliasing */\n        const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr;\n        DTableDesc const dtd = HUF_getDTableDesc(DTable);\n        HUF_decodeStreamX2(ostart, &bitD, oend, dt, dtd.tableLog);\n    }\n\n    /* check */\n    if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);\n\n    /* decoded size */\n    return dstSize;\n}\n\n/* HUF_decompress4X2_usingDTable_internal_body():\n * Conditions:\n * @dstSize >= 6\n */\nFORCE_INLINE_TEMPLATE size_t\nHUF_decompress4X2_usingDTable_internal_body(\n          void* dst,  size_t dstSize,\n    const void* cSrc, size_t cSrcSize,\n    const HUF_DTable* DTable)\n{\n    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */\n    if (dstSize < 6) return ERROR(corruption_detected);         /* stream 4-split doesn't work */\n\n    {   const BYTE* const istart = (const BYTE*) cSrc;\n        BYTE* const ostart = (BYTE*) dst;\n        BYTE* const oend = ostart + dstSize;\n        BYTE* const olimit = oend - (sizeof(size_t)-1);\n        const void* const dtPtr = DTable+1;\n        const HUF_DEltX2* const dt = (const HUF_DEltX2*)dtPtr;\n\n        /* Init */\n        BIT_DStream_t bitD1;\n        BIT_DStream_t bitD2;\n        BIT_DStream_t bitD3;\n        BIT_DStream_t bitD4;\n        size_t const length1 = MEM_readLE16(istart);\n        size_t const length2 = MEM_readLE16(istart+2);\n        size_t const length3 = MEM_readLE16(istart+4);\n        size_t const length4 = cSrcSize - (length1 + length2 + length3 + 6);\n        const BYTE* const istart1 = istart + 6;  /* jumpTable */\n        const BYTE* const istart2 = istart1 + length1;\n        const BYTE* const istart3 = istart2 + length2;\n        const BYTE* const istart4 = istart3 + length3;\n        size_t const segmentSize = (dstSize+3) / 4;\n        BYTE* const opStart2 = ostart + segmentSize;\n        BYTE* const opStart3 = opStart2 + segmentSize;\n        BYTE* const opStart4 = opStart3 + segmentSize;\n        BYTE* op1 = ostart;\n        BYTE* op2 = opStart2;\n        BYTE* op3 = opStart3;\n        BYTE* op4 = opStart4;\n        U32 endSignal = 1;\n        DTableDesc const dtd = HUF_getDTableDesc(DTable);\n        U32 const dtLog = dtd.tableLog;\n\n        if (length4 > cSrcSize) return ERROR(corruption_detected);  /* overflow */\n        if (opStart4 > oend) return ERROR(corruption_detected);     /* overflow */\n        assert(dstSize >= 6 /* validated above */);\n        CHECK_F( BIT_initDStream(&bitD1, istart1, length1) );\n        CHECK_F( BIT_initDStream(&bitD2, istart2, length2) );\n        CHECK_F( BIT_initDStream(&bitD3, istart3, length3) );\n        CHECK_F( BIT_initDStream(&bitD4, istart4, length4) );\n\n        /* 16-32 symbols per loop (4-8 symbols per stream) */\n        if ((size_t)(oend - op4) >= sizeof(size_t)) {\n            for ( ; (endSignal) & (op4 < olimit); ) {\n#if defined(__clang__) && (defined(__x86_64__) || defined(__i386__))\n                HUF_DECODE_SYMBOLX2_2(op1, &bitD1);\n                HUF_DECODE_SYMBOLX2_1(op1, &bitD1);\n                HUF_DECODE_SYMBOLX2_2(op1, &bitD1);\n                HUF_DECODE_SYMBOLX2_0(op1, &bitD1);\n                HUF_DECODE_SYMBOLX2_2(op2, &bitD2);\n                HUF_DECODE_SYMBOLX2_1(op2, &bitD2);\n                HUF_DECODE_SYMBOLX2_2(op2, &bitD2);\n                HUF_DECODE_SYMBOLX2_0(op2, &bitD2);\n                endSignal &= BIT_reloadDStreamFast(&bitD1) == BIT_DStream_unfinished;\n                endSignal &= BIT_reloadDStreamFast(&bitD2) == BIT_DStream_unfinished;\n                HUF_DECODE_SYMBOLX2_2(op3, &bitD3);\n                HUF_DECODE_SYMBOLX2_1(op3, &bitD3);\n                HUF_DECODE_SYMBOLX2_2(op3, &bitD3);\n                HUF_DECODE_SYMBOLX2_0(op3, &bitD3);\n                HUF_DECODE_SYMBOLX2_2(op4, &bitD4);\n                HUF_DECODE_SYMBOLX2_1(op4, &bitD4);\n                HUF_DECODE_SYMBOLX2_2(op4, &bitD4);\n                HUF_DECODE_SYMBOLX2_0(op4, &bitD4);\n                endSignal &= BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished;\n                endSignal &= BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished;\n#else\n                HUF_DECODE_SYMBOLX2_2(op1, &bitD1);\n                HUF_DECODE_SYMBOLX2_2(op2, &bitD2);\n                HUF_DECODE_SYMBOLX2_2(op3, &bitD3);\n                HUF_DECODE_SYMBOLX2_2(op4, &bitD4);\n                HUF_DECODE_SYMBOLX2_1(op1, &bitD1);\n                HUF_DECODE_SYMBOLX2_1(op2, &bitD2);\n                HUF_DECODE_SYMBOLX2_1(op3, &bitD3);\n                HUF_DECODE_SYMBOLX2_1(op4, &bitD4);\n                HUF_DECODE_SYMBOLX2_2(op1, &bitD1);\n                HUF_DECODE_SYMBOLX2_2(op2, &bitD2);\n                HUF_DECODE_SYMBOLX2_2(op3, &bitD3);\n                HUF_DECODE_SYMBOLX2_2(op4, &bitD4);\n                HUF_DECODE_SYMBOLX2_0(op1, &bitD1);\n                HUF_DECODE_SYMBOLX2_0(op2, &bitD2);\n                HUF_DECODE_SYMBOLX2_0(op3, &bitD3);\n                HUF_DECODE_SYMBOLX2_0(op4, &bitD4);\n                endSignal = (U32)LIKELY((U32)\n                            (BIT_reloadDStreamFast(&bitD1) == BIT_DStream_unfinished)\n                        & (BIT_reloadDStreamFast(&bitD2) == BIT_DStream_unfinished)\n                        & (BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished)\n                        & (BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished));\n#endif\n            }\n        }\n\n        /* check corruption */\n        if (op1 > opStart2) return ERROR(corruption_detected);\n        if (op2 > opStart3) return ERROR(corruption_detected);\n        if (op3 > opStart4) return ERROR(corruption_detected);\n        /* note : op4 already verified within main loop */\n\n        /* finish bitStreams one by one */\n        HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);\n        HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);\n        HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);\n        HUF_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);\n\n        /* check */\n        { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);\n          if (!endCheck) return ERROR(corruption_detected); }\n\n        /* decoded size */\n        return dstSize;\n    }\n}\n\n#if HUF_NEED_BMI2_FUNCTION\nstatic BMI2_TARGET_ATTRIBUTE\nsize_t HUF_decompress4X2_usingDTable_internal_bmi2(void* dst, size_t dstSize, void const* cSrc,\n                    size_t cSrcSize, HUF_DTable const* DTable) {\n    return HUF_decompress4X2_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable);\n}\n#endif\n\nstatic\nsize_t HUF_decompress4X2_usingDTable_internal_default(void* dst, size_t dstSize, void const* cSrc,\n                    size_t cSrcSize, HUF_DTable const* DTable) {\n    return HUF_decompress4X2_usingDTable_internal_body(dst, dstSize, cSrc, cSrcSize, DTable);\n}\n\n#if ZSTD_ENABLE_ASM_X86_64_BMI2\n\nHUF_ASM_DECL void HUF_decompress4X2_usingDTable_internal_fast_asm_loop(HUF_DecompressFastArgs* args) ZSTDLIB_HIDDEN;\n\n#endif\n\nstatic HUF_FAST_BMI2_ATTRS\nvoid HUF_decompress4X2_usingDTable_internal_fast_c_loop(HUF_DecompressFastArgs* args)\n{\n    U64 bits[4];\n    BYTE const* ip[4];\n    BYTE* op[4];\n    BYTE* oend[4];\n    HUF_DEltX2 const* const dtable = (HUF_DEltX2 const*)args->dt;\n    BYTE const* const ilowest = args->ilowest;\n\n    /* Copy the arguments to local registers. */\n    ZSTD_memcpy(&bits, &args->bits, sizeof(bits));\n    ZSTD_memcpy((void*)(&ip), &args->ip, sizeof(ip));\n    ZSTD_memcpy(&op, &args->op, sizeof(op));\n\n    oend[0] = op[1];\n    oend[1] = op[2];\n    oend[2] = op[3];\n    oend[3] = args->oend;\n\n    assert(MEM_isLittleEndian());\n    assert(!MEM_32bits());\n\n    for (;;) {\n        BYTE* olimit;\n        int stream;\n\n        /* Assert loop preconditions */\n#ifndef NDEBUG\n        for (stream = 0; stream < 4; ++stream) {\n            assert(op[stream] <= oend[stream]);\n            assert(ip[stream] >= ilowest);\n        }\n#endif\n        /* Compute olimit */\n        {\n            /* Each loop does 5 table lookups for each of the 4 streams.\n             * Each table lookup consumes up to 11 bits of input, and produces\n             * up to 2 bytes of output.\n             */\n            /* We can consume up to 7 bytes of input per iteration per stream.\n             * We also know that each input pointer is >= ip[0]. So we can run\n             * iters loops before running out of input.\n             */\n            size_t iters = (size_t)(ip[0] - ilowest) / 7;\n            /* Each iteration can produce up to 10 bytes of output per stream.\n             * Each output stream my advance at different rates. So take the\n             * minimum number of safe iterations among all the output streams.\n             */\n            for (stream = 0; stream < 4; ++stream) {\n                size_t const oiters = (size_t)(oend[stream] - op[stream]) / 10;\n                iters = MIN(iters, oiters);\n            }\n\n            /* Each iteration produces at least 5 output symbols. So until\n             * op[3] crosses olimit, we know we haven't executed iters\n             * iterations yet. This saves us maintaining an iters counter,\n             * at the expense of computing the remaining # of iterations\n             * more frequently.\n             */\n            olimit = op[3] + (iters * 5);\n\n            /* Exit the fast decoding loop once we reach the end. */\n            if (op[3] == olimit)\n                break;\n\n            /* Exit the decoding loop if any input pointer has crossed the\n             * previous one. This indicates corruption, and a precondition\n             * to our loop is that ip[i] >= ip[0].\n             */\n            for (stream = 1; stream < 4; ++stream) {\n                if (ip[stream] < ip[stream - 1])\n                    goto _out;\n            }\n        }\n\n#ifndef NDEBUG\n        for (stream = 1; stream < 4; ++stream) {\n            assert(ip[stream] >= ip[stream - 1]);\n        }\n#endif\n\n#define HUF_4X2_DECODE_SYMBOL(_stream, _decode3)               \\\n    do {                                                       \\\n        if ((_decode3) || (_stream) != 3) {                    \\\n            U64 const index = bits[(_stream)] >> 53;           \\\n            size_t const entry = MEM_readLE32(&dtable[index]); \\\n            MEM_write16(op[(_stream)], (U16)entry);            \\\n            bits[(_stream)] <<= (entry >> 16) & 0x3F;          \\\n            op[(_stream)] += entry >> 24;                      \\\n        }                                                      \\\n    } while (0)\n\n#define HUF_5X2_RELOAD_STREAM(_stream, _decode3)                        \\\n    do {                                                                \\\n        if (_decode3) HUF_4X2_DECODE_SYMBOL(3, 1);                      \\\n        {                                                               \\\n            U64 const ctz = ZSTD_countTrailingZeros64(bits[(_stream)]); \\\n            U64 const nbBits = ctz & 7;                                 \\\n            U64 const nbBytes = ctz >> 3;                               \\\n            ip[(_stream)] -= nbBytes;                                   \\\n            bits[(_stream)] = MEM_read64(ip[(_stream)]) | 1;            \\\n            bits[(_stream)] <<= nbBits;                                 \\\n        }                                                               \\\n    } while (0)\n\n#if defined(__aarch64__)\n#  define HUF_4X2_4WAY 1\n#else\n#  define HUF_4X2_4WAY 0\n#endif\n#define HUF_4X2_3WAY !HUF_4X2_4WAY\n\n        /* Manually unroll the loop because compilers don't consistently\n         * unroll the inner loops, which destroys performance.\n         */\n        do {\n            /* Decode 5 symbols from each of the first 3 or 4 streams.\n             * In the 3-way case the final stream will be decoded during\n             * the reload phase to reduce register pressure.\n             */\n            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, HUF_4X2_4WAY);\n            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, HUF_4X2_4WAY);\n            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, HUF_4X2_4WAY);\n            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, HUF_4X2_4WAY);\n            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_4X2_DECODE_SYMBOL, HUF_4X2_4WAY);\n\n            /* In the 3-way case decode one symbol from the final stream. */\n            HUF_4X2_DECODE_SYMBOL(3, HUF_4X2_3WAY);\n\n            /* In the 3-way case decode 4 symbols from the final stream &\n             * reload bitstreams. The final stream is reloaded last, meaning\n             * that all 5 symbols are decoded from the final stream before\n             * it is reloaded.\n             */\n            HUF_4X_FOR_EACH_STREAM_WITH_VAR(HUF_5X2_RELOAD_STREAM, HUF_4X2_3WAY);\n        } while (op[3] < olimit);\n    }\n\n#undef HUF_4X2_DECODE_SYMBOL\n#undef HUF_5X2_RELOAD_STREAM\n\n_out:\n\n    /* Save the final values of each of the state variables back to args. */\n    ZSTD_memcpy(&args->bits, &bits, sizeof(bits));\n    ZSTD_memcpy((void*)(&args->ip), &ip, sizeof(ip));\n    ZSTD_memcpy(&args->op, &op, sizeof(op));\n}\n\n\nstatic HUF_FAST_BMI2_ATTRS size_t\nHUF_decompress4X2_usingDTable_internal_fast(\n          void* dst,  size_t dstSize,\n    const void* cSrc, size_t cSrcSize,\n    const HUF_DTable* DTable,\n    HUF_DecompressFastLoopFn loopFn) {\n    void const* dt = DTable + 1;\n    const BYTE* const ilowest = (const BYTE*)cSrc;\n    BYTE* const oend = (BYTE*)ZSTD_maybeNullPtrAdd(dst, (ptrdiff_t)dstSize);\n    HUF_DecompressFastArgs args;\n    {\n        size_t const ret = HUF_DecompressFastArgs_init(&args, dst, dstSize, cSrc, cSrcSize, DTable);\n        FORWARD_IF_ERROR(ret, \"Failed to init asm args\");\n        if (ret == 0)\n            return 0;\n    }\n\n    assert(args.ip[0] >= args.ilowest);\n    loopFn(&args);\n\n    /* note : op4 already verified within main loop */\n    assert(args.ip[0] >= ilowest);\n    assert(args.ip[1] >= ilowest);\n    assert(args.ip[2] >= ilowest);\n    assert(args.ip[3] >= ilowest);\n    assert(args.op[3] <= oend);\n\n    assert(ilowest == args.ilowest);\n    assert(ilowest + 6 == args.iend[0]);\n    (void)ilowest;\n\n    /* finish bitStreams one by one */\n    {\n        size_t const segmentSize = (dstSize+3) / 4;\n        BYTE* segmentEnd = (BYTE*)dst;\n        int i;\n        for (i = 0; i < 4; ++i) {\n            BIT_DStream_t bit;\n            if (segmentSize <= (size_t)(oend - segmentEnd))\n                segmentEnd += segmentSize;\n            else\n                segmentEnd = oend;\n            FORWARD_IF_ERROR(HUF_initRemainingDStream(&bit, &args, i, segmentEnd), \"corruption\");\n            args.op[i] += HUF_decodeStreamX2(args.op[i], &bit, segmentEnd, (HUF_DEltX2 const*)dt, HUF_DECODER_FAST_TABLELOG);\n            if (args.op[i] != segmentEnd)\n                return ERROR(corruption_detected);\n        }\n    }\n\n    /* decoded size */\n    return dstSize;\n}\n\nstatic size_t HUF_decompress4X2_usingDTable_internal(void* dst, size_t dstSize, void const* cSrc,\n                    size_t cSrcSize, HUF_DTable const* DTable, int flags)\n{\n    HUF_DecompressUsingDTableFn fallbackFn = HUF_decompress4X2_usingDTable_internal_default;\n    HUF_DecompressFastLoopFn loopFn = HUF_decompress4X2_usingDTable_internal_fast_c_loop;\n\n#if DYNAMIC_BMI2\n    if (flags & HUF_flags_bmi2) {\n        fallbackFn = HUF_decompress4X2_usingDTable_internal_bmi2;\n# if ZSTD_ENABLE_ASM_X86_64_BMI2\n        if (!(flags & HUF_flags_disableAsm)) {\n            loopFn = HUF_decompress4X2_usingDTable_internal_fast_asm_loop;\n        }\n# endif\n    } else {\n        return fallbackFn(dst, dstSize, cSrc, cSrcSize, DTable);\n    }\n#endif\n\n#if ZSTD_ENABLE_ASM_X86_64_BMI2 && defined(__BMI2__)\n    if (!(flags & HUF_flags_disableAsm)) {\n        loopFn = HUF_decompress4X2_usingDTable_internal_fast_asm_loop;\n    }\n#endif\n\n    if (HUF_ENABLE_FAST_DECODE && !(flags & HUF_flags_disableFast)) {\n        size_t const ret = HUF_decompress4X2_usingDTable_internal_fast(dst, dstSize, cSrc, cSrcSize, DTable, loopFn);\n        if (ret != 0)\n            return ret;\n    }\n    return fallbackFn(dst, dstSize, cSrc, cSrcSize, DTable);\n}\n\nHUF_DGEN(HUF_decompress1X2_usingDTable_internal)\n\nsize_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,\n                                   const void* cSrc, size_t cSrcSize,\n                                   void* workSpace, size_t wkspSize, int flags)\n{\n    const BYTE* ip = (const BYTE*) cSrc;\n\n    size_t const hSize = HUF_readDTableX2_wksp(DCtx, cSrc, cSrcSize,\n                                               workSpace, wkspSize, flags);\n    if (HUF_isError(hSize)) return hSize;\n    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);\n    ip += hSize; cSrcSize -= hSize;\n\n    return HUF_decompress1X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, flags);\n}\n\nstatic size_t HUF_decompress4X2_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,\n                                   const void* cSrc, size_t cSrcSize,\n                                   void* workSpace, size_t wkspSize, int flags)\n{\n    const BYTE* ip = (const BYTE*) cSrc;\n\n    size_t hSize = HUF_readDTableX2_wksp(dctx, cSrc, cSrcSize,\n                                         workSpace, wkspSize, flags);\n    if (HUF_isError(hSize)) return hSize;\n    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);\n    ip += hSize; cSrcSize -= hSize;\n\n    return HUF_decompress4X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, flags);\n}\n\n#endif /* HUF_FORCE_DECOMPRESS_X1 */\n\n\n/* ***********************************/\n/* Universal decompression selectors */\n/* ***********************************/\n\n\n#if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2)\ntypedef struct { U32 tableTime; U32 decode256Time; } algo_time_t;\nstatic const algo_time_t algoTime[16 /* Quantization */][2 /* single, double */] =\n{\n    /* single, double, quad */\n    {{0,0}, {1,1}},  /* Q==0 : impossible */\n    {{0,0}, {1,1}},  /* Q==1 : impossible */\n    {{ 150,216}, { 381,119}},   /* Q == 2 : 12-18% */\n    {{ 170,205}, { 514,112}},   /* Q == 3 : 18-25% */\n    {{ 177,199}, { 539,110}},   /* Q == 4 : 25-32% */\n    {{ 197,194}, { 644,107}},   /* Q == 5 : 32-38% */\n    {{ 221,192}, { 735,107}},   /* Q == 6 : 38-44% */\n    {{ 256,189}, { 881,106}},   /* Q == 7 : 44-50% */\n    {{ 359,188}, {1167,109}},   /* Q == 8 : 50-56% */\n    {{ 582,187}, {1570,114}},   /* Q == 9 : 56-62% */\n    {{ 688,187}, {1712,122}},   /* Q ==10 : 62-69% */\n    {{ 825,186}, {1965,136}},   /* Q ==11 : 69-75% */\n    {{ 976,185}, {2131,150}},   /* Q ==12 : 75-81% */\n    {{1180,186}, {2070,175}},   /* Q ==13 : 81-87% */\n    {{1377,185}, {1731,202}},   /* Q ==14 : 87-93% */\n    {{1412,185}, {1695,202}},   /* Q ==15 : 93-99% */\n};\n#endif\n\n/** HUF_selectDecoder() :\n *  Tells which decoder is likely to decode faster,\n *  based on a set of pre-computed metrics.\n * @return : 0==HUF_decompress4X1, 1==HUF_decompress4X2 .\n *  Assumption : 0 < dstSize <= 128 KB */\nU32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize)\n{\n    assert(dstSize > 0);\n    assert(dstSize <= 128*1024);\n#if defined(HUF_FORCE_DECOMPRESS_X1)\n    (void)dstSize;\n    (void)cSrcSize;\n    return 0;\n#elif defined(HUF_FORCE_DECOMPRESS_X2)\n    (void)dstSize;\n    (void)cSrcSize;\n    return 1;\n#else\n    /* decoder timing evaluation */\n    {   U32 const Q = (cSrcSize >= dstSize) ? 15 : (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 */\n        U32 const D256 = (U32)(dstSize >> 8);\n        U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256);\n        U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256);\n        DTime1 += DTime1 >> 5;  /* small advantage to algorithm using less memory, to reduce cache eviction */\n        return DTime1 < DTime0;\n    }\n#endif\n}\n\nsize_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,\n                                  const void* cSrc, size_t cSrcSize,\n                                  void* workSpace, size_t wkspSize, int flags)\n{\n    /* validation checks */\n    if (dstSize == 0) return ERROR(dstSize_tooSmall);\n    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */\n    if (cSrcSize == dstSize) { ZSTD_memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */\n    if (cSrcSize == 1) { ZSTD_memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */\n\n    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);\n#if defined(HUF_FORCE_DECOMPRESS_X1)\n        (void)algoNb;\n        assert(algoNb == 0);\n        return HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,\n                                cSrcSize, workSpace, wkspSize, flags);\n#elif defined(HUF_FORCE_DECOMPRESS_X2)\n        (void)algoNb;\n        assert(algoNb == 1);\n        return HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,\n                                cSrcSize, workSpace, wkspSize, flags);\n#else\n        return algoNb ? HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,\n                                cSrcSize, workSpace, wkspSize, flags):\n                        HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,\n                                cSrcSize, workSpace, wkspSize, flags);\n#endif\n    }\n}\n\n\nsize_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int flags)\n{\n    DTableDesc const dtd = HUF_getDTableDesc(DTable);\n#if defined(HUF_FORCE_DECOMPRESS_X1)\n    (void)dtd;\n    assert(dtd.tableType == 0);\n    return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);\n#elif defined(HUF_FORCE_DECOMPRESS_X2)\n    (void)dtd;\n    assert(dtd.tableType == 1);\n    return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);\n#else\n    return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags) :\n                           HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);\n#endif\n}\n\n#ifndef HUF_FORCE_DECOMPRESS_X2\nsize_t HUF_decompress1X1_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags)\n{\n    const BYTE* ip = (const BYTE*) cSrc;\n\n    size_t const hSize = HUF_readDTableX1_wksp(dctx, cSrc, cSrcSize, workSpace, wkspSize, flags);\n    if (HUF_isError(hSize)) return hSize;\n    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);\n    ip += hSize; cSrcSize -= hSize;\n\n    return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, flags);\n}\n#endif\n\nsize_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int flags)\n{\n    DTableDesc const dtd = HUF_getDTableDesc(DTable);\n#if defined(HUF_FORCE_DECOMPRESS_X1)\n    (void)dtd;\n    assert(dtd.tableType == 0);\n    return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);\n#elif defined(HUF_FORCE_DECOMPRESS_X2)\n    (void)dtd;\n    assert(dtd.tableType == 1);\n    return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);\n#else\n    return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags) :\n                           HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, flags);\n#endif\n}\n\nsize_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int flags)\n{\n    /* validation checks */\n    if (dstSize == 0) return ERROR(dstSize_tooSmall);\n    if (cSrcSize == 0) return ERROR(corruption_detected);\n\n    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);\n#if defined(HUF_FORCE_DECOMPRESS_X1)\n        (void)algoNb;\n        assert(algoNb == 0);\n        return HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, flags);\n#elif defined(HUF_FORCE_DECOMPRESS_X2)\n        (void)algoNb;\n        assert(algoNb == 1);\n        return HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, flags);\n#else\n        return algoNb ? HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, flags) :\n                        HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, flags);\n#endif\n    }\n}\n"
  },
  {
    "path": "lib/decompress/huf_decompress_amd64.S",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#include \"../common/portability_macros.h\"\n\n#if defined(__ELF__) && defined(__GNUC__)\n/* Stack marking\n * ref: https://wiki.gentoo.org/wiki/Hardened/GNU_stack_quickstart\n */\n.section .note.GNU-stack,\"\",%progbits\n\n#if defined(__aarch64__)\n/* Mark that this assembly supports BTI & PAC, because it is empty for aarch64.\n * See: https://github.com/facebook/zstd/issues/3841\n * See: https://gcc.godbolt.org/z/sqr5T4ffK\n * See: https://lore.kernel.org/linux-arm-kernel/20200429211641.9279-8-broonie@kernel.org/\n * See: https://reviews.llvm.org/D62609\n */\n.pushsection .note.gnu.property, \"a\"\n.p2align 3\n.long 4                 /* size of the name - \"GNU\\0\" */\n.long 0x10              /* size of descriptor */\n.long 0x5               /* NT_GNU_PROPERTY_TYPE_0 */\n.asciz \"GNU\"\n.long 0xc0000000        /* pr_type - GNU_PROPERTY_AARCH64_FEATURE_1_AND */\n.long 4                 /* pr_datasz - 4 bytes */\n.long 3                 /* pr_data - GNU_PROPERTY_AARCH64_FEATURE_1_BTI | GNU_PROPERTY_AARCH64_FEATURE_1_PAC */\n.p2align 3              /* pr_padding - bring everything to 8 byte alignment */\n.popsection\n#endif\n\n#endif\n\n// There appears to be an unreconcilable syntax difference between Linux and Darwin assemblers.\n// Name of a private label (i.e. not exported to symbol table) on Darwin has to start with \"L\",\n// on Linux has to start with \".\". There's no way to have a name start with both \".\" and \"L\", so\n// we have to use a macro.\n#if defined(__APPLE__)\n#define LOCAL_LABEL(label) L_ ## label\n#else\n#define LOCAL_LABEL(label) .L_ ## label\n#endif\n\n#if ZSTD_ENABLE_ASM_X86_64_BMI2\n\n/* Calling convention:\n *\n * %rdi (or %rcx on Windows) contains the first argument: HUF_DecompressAsmArgs*.\n * %rbp isn't maintained (no frame pointer).\n * %rsp contains the stack pointer that grows down.\n *      No red-zone is assumed, only addresses >= %rsp are used.\n * All register contents are preserved.\n */\n\nZSTD_HIDE_ASM_FUNCTION(HUF_decompress4X1_usingDTable_internal_fast_asm_loop)\nZSTD_HIDE_ASM_FUNCTION(HUF_decompress4X2_usingDTable_internal_fast_asm_loop)\nZSTD_HIDE_ASM_FUNCTION(_HUF_decompress4X2_usingDTable_internal_fast_asm_loop)\nZSTD_HIDE_ASM_FUNCTION(_HUF_decompress4X1_usingDTable_internal_fast_asm_loop)\n.global HUF_decompress4X1_usingDTable_internal_fast_asm_loop\n.global HUF_decompress4X2_usingDTable_internal_fast_asm_loop\n.global _HUF_decompress4X1_usingDTable_internal_fast_asm_loop\n.global _HUF_decompress4X2_usingDTable_internal_fast_asm_loop\n.text\n\n/* Sets up register mappings for clarity.\n * op[], bits[], dtable & ip[0] each get their own register.\n * ip[1,2,3] & olimit alias var[].\n * %rax is a scratch register.\n */\n\n#define op0    rsi\n#define op1    rbx\n#define op2    rcx\n#define op3    rdi\n\n#define ip0    r8\n#define ip1    r9\n#define ip2    r10\n#define ip3    r11\n\n#define bits0  rbp\n#define bits1  rdx\n#define bits2  r12\n#define bits3  r13\n#define dtable r14\n#define olimit r15\n\n/* var[] aliases ip[1,2,3] & olimit\n * ip[1,2,3] are saved every iteration.\n * olimit is only used in compute_olimit.\n */\n#define var0   r15\n#define var1   r9\n#define var2   r10\n#define var3   r11\n\n/* 32-bit var registers */\n#define vard0  r15d\n#define vard1  r9d\n#define vard2  r10d\n#define vard3  r11d\n\n/* Calls X(N) for each stream 0, 1, 2, 3. */\n#define FOR_EACH_STREAM(X) \\\n    X(0);                  \\\n    X(1);                  \\\n    X(2);                  \\\n    X(3)\n\n/* Calls X(N, idx) for each stream 0, 1, 2, 3. */\n#define FOR_EACH_STREAM_WITH_INDEX(X, idx) \\\n    X(0, idx);                             \\\n    X(1, idx);                             \\\n    X(2, idx);                             \\\n    X(3, idx)\n\n/* Define both _HUF_* & HUF_* symbols because MacOS\n * C symbols are prefixed with '_' & Linux symbols aren't.\n */\n_HUF_decompress4X1_usingDTable_internal_fast_asm_loop:\nHUF_decompress4X1_usingDTable_internal_fast_asm_loop:\n    ZSTD_CET_ENDBRANCH\n    .cfi_startproc\n    .cfi_def_cfa_offset 8\n    .cfi_offset %rip, -8\n    /* Save all registers - even if they are callee saved for simplicity. */\n    push %rax\n    .cfi_def_cfa_offset 16\n    .cfi_offset rax, -16\n    push %rbx\n    .cfi_def_cfa_offset 24\n    .cfi_offset rbx, -24\n    push %rcx\n    .cfi_def_cfa_offset 32\n    .cfi_offset rcx, -32\n    push %rdx\n    .cfi_def_cfa_offset 40\n    .cfi_offset rdx, -40\n    push %rbp\n    .cfi_def_cfa_offset 48\n    .cfi_offset rbp, -48\n    push %rsi\n    .cfi_def_cfa_offset 56\n    .cfi_offset rsi, -56\n    push %rdi\n    .cfi_def_cfa_offset 64\n    .cfi_offset rdi, -64\n    push %r8\n    .cfi_def_cfa_offset 72\n    .cfi_offset r8, -72\n    push %r9\n    .cfi_def_cfa_offset 80\n    .cfi_offset r9, -80\n    push %r10\n    .cfi_def_cfa_offset 88\n    .cfi_offset r10, -88\n    push %r11\n    .cfi_def_cfa_offset 96\n    .cfi_offset r11, -96\n    push %r12\n    .cfi_def_cfa_offset 104\n    .cfi_offset r12, -104\n    push %r13\n    .cfi_def_cfa_offset 112\n    .cfi_offset r13, -112\n    push %r14\n    .cfi_def_cfa_offset 120\n    .cfi_offset r14, -120\n    push %r15\n    .cfi_def_cfa_offset 128\n    .cfi_offset r15, -128\n\n    /* Read HUF_DecompressAsmArgs* args from %rax */\n#if defined(_WIN32)\n    movq %rcx, %rax\n#else\n    movq %rdi, %rax\n#endif\n    movq  0(%rax), %ip0\n    movq  8(%rax), %ip1\n    movq 16(%rax), %ip2\n    movq 24(%rax), %ip3\n    movq 32(%rax), %op0\n    movq 40(%rax), %op1\n    movq 48(%rax), %op2\n    movq 56(%rax), %op3\n    movq 64(%rax), %bits0\n    movq 72(%rax), %bits1\n    movq 80(%rax), %bits2\n    movq 88(%rax), %bits3\n    movq 96(%rax), %dtable\n    push %rax      /* argument */\n    .cfi_def_cfa_offset 136\n    push 104(%rax) /* ilowest */\n    .cfi_def_cfa_offset 144\n    push 112(%rax) /* oend */\n    .cfi_def_cfa_offset 152\n    push %olimit   /* olimit space */\n    .cfi_def_cfa_offset 160\n\n    subq $24, %rsp\n    .cfi_def_cfa_offset 184\n\nLOCAL_LABEL(4X1_compute_olimit):\n    /* Computes how many iterations we can do safely\n     * %r15, %rax may be clobbered\n     * rbx, rdx must be saved\n     * op3 & ip0 mustn't be clobbered\n     */\n    movq %rbx, 0(%rsp)\n    movq %rdx, 8(%rsp)\n\n    movq 32(%rsp), %rax /* rax = oend */\n    subq %op3,    %rax  /* rax = oend - op3 */\n\n    /* r15 = (oend - op3) / 5 */\n    movabsq $-3689348814741910323, %rdx\n    mulq %rdx\n    movq %rdx, %r15\n    shrq $2, %r15\n\n    movq %ip0,     %rax /* rax = ip0 */\n    movq 40(%rsp), %rdx /* rdx = ilowest */\n    subq %rdx,     %rax /* rax = ip0 - ilowest */\n    movq %rax,     %rbx /* rbx = ip0 - ilowest */\n\n    /* rdx = (ip0 - ilowest) / 7 */\n    movabsq $2635249153387078803, %rdx\n    mulq %rdx\n    subq %rdx, %rbx\n    shrq %rbx\n    addq %rbx, %rdx\n    shrq $2, %rdx\n\n    /* r15 = min(%rdx, %r15) */\n    cmpq %rdx, %r15\n    cmova %rdx, %r15\n\n    /* r15 = r15 * 5 */\n    leaq (%r15, %r15, 4), %r15\n\n    /* olimit = op3 + r15 */\n    addq %op3, %olimit\n\n    movq 8(%rsp), %rdx\n    movq 0(%rsp), %rbx\n\n    /* If (op3 + 20 > olimit) */\n    movq %op3, %rax    /* rax = op3 */\n    cmpq %rax, %olimit /* op3 == olimit */\n    je LOCAL_LABEL(4X1_exit)\n\n    /* If (ip1 < ip0) go to exit */\n    cmpq %ip0, %ip1\n    jb LOCAL_LABEL(4X1_exit)\n\n    /* If (ip2 < ip1) go to exit */\n    cmpq %ip1, %ip2\n    jb LOCAL_LABEL(4X1_exit)\n\n    /* If (ip3 < ip2) go to exit */\n    cmpq %ip2, %ip3\n    jb LOCAL_LABEL(4X1_exit)\n\n/* Reads top 11 bits from bits[n]\n * Loads dt[bits[n]] into var[n]\n */\n#define GET_NEXT_DELT(n)                \\\n    movq $53, %var##n;                  \\\n    shrxq %var##n, %bits##n, %var##n;   \\\n    movzwl (%dtable,%var##n,2),%vard##n\n\n/* var[n] must contain the DTable entry computed with GET_NEXT_DELT\n * Moves var[n] to %rax\n * bits[n] <<= var[n] & 63\n * op[n][idx] = %rax >> 8\n * %ah is a way to access bits [8, 16) of %rax\n */\n#define DECODE_FROM_DELT(n, idx)       \\\n    movq %var##n, %rax;                \\\n    shlxq %var##n, %bits##n, %bits##n; \\\n    movb %ah, idx(%op##n)\n\n/* Assumes GET_NEXT_DELT has been called.\n * Calls DECODE_FROM_DELT then GET_NEXT_DELT\n */\n#define DECODE_AND_GET_NEXT(n, idx) \\\n    DECODE_FROM_DELT(n, idx);       \\\n    GET_NEXT_DELT(n)                \\\n\n/* // ctz & nbBytes is stored in bits[n]\n * // nbBits is stored in %rax\n * ctz  = CTZ[bits[n]]\n * nbBits  = ctz & 7\n * nbBytes = ctz >> 3\n * op[n]  += 5\n * ip[n]  -= nbBytes\n * // Note: x86-64 is little-endian ==> no bswap\n * bits[n] = MEM_readST(ip[n]) | 1\n * bits[n] <<= nbBits\n */\n#define RELOAD_BITS(n)             \\\n    bsfq %bits##n, %bits##n;       \\\n    movq %bits##n, %rax;           \\\n    andq $7, %rax;                 \\\n    shrq $3, %bits##n;             \\\n    leaq 5(%op##n), %op##n;        \\\n    subq %bits##n, %ip##n;         \\\n    movq (%ip##n), %bits##n;       \\\n    orq $1, %bits##n;              \\\n    shlx %rax, %bits##n, %bits##n\n\n    /* Store clobbered variables on the stack */\n    movq %olimit, 24(%rsp)\n    movq %ip1, 0(%rsp)\n    movq %ip2, 8(%rsp)\n    movq %ip3, 16(%rsp)\n\n    /* Call GET_NEXT_DELT for each stream */\n    FOR_EACH_STREAM(GET_NEXT_DELT)\n\n    .p2align 6\n\nLOCAL_LABEL(4X1_loop_body):\n    /* Decode 5 symbols in each of the 4 streams (20 total)\n     * Must have called GET_NEXT_DELT for each stream\n     */\n    FOR_EACH_STREAM_WITH_INDEX(DECODE_AND_GET_NEXT, 0)\n    FOR_EACH_STREAM_WITH_INDEX(DECODE_AND_GET_NEXT, 1)\n    FOR_EACH_STREAM_WITH_INDEX(DECODE_AND_GET_NEXT, 2)\n    FOR_EACH_STREAM_WITH_INDEX(DECODE_AND_GET_NEXT, 3)\n    FOR_EACH_STREAM_WITH_INDEX(DECODE_FROM_DELT, 4)\n\n    /* Load ip[1,2,3] from stack (var[] aliases them)\n     * ip[] is needed for RELOAD_BITS\n     * Each will be stored back to the stack after RELOAD\n     */\n    movq 0(%rsp), %ip1\n    movq 8(%rsp), %ip2\n    movq 16(%rsp), %ip3\n\n    /* Reload each stream & fetch the next table entry\n     * to prepare for the next iteration\n     */\n    RELOAD_BITS(0)\n    GET_NEXT_DELT(0)\n\n    RELOAD_BITS(1)\n    movq %ip1, 0(%rsp)\n    GET_NEXT_DELT(1)\n\n    RELOAD_BITS(2)\n    movq %ip2, 8(%rsp)\n    GET_NEXT_DELT(2)\n\n    RELOAD_BITS(3)\n    movq %ip3, 16(%rsp)\n    GET_NEXT_DELT(3)\n\n    /* If op3 < olimit: continue the loop */\n    cmp %op3, 24(%rsp)\n    ja LOCAL_LABEL(4X1_loop_body)\n\n    /* Reload ip[1,2,3] from stack */\n    movq 0(%rsp), %ip1\n    movq 8(%rsp), %ip2\n    movq 16(%rsp), %ip3\n\n    /* Re-compute olimit */\n    jmp LOCAL_LABEL(4X1_compute_olimit)\n\n#undef GET_NEXT_DELT\n#undef DECODE_FROM_DELT\n#undef DECODE\n#undef RELOAD_BITS\nLOCAL_LABEL(4X1_exit):\n    addq $24, %rsp\n    .cfi_def_cfa_offset 160\n\n    /* Restore stack (oend & olimit) */\n    pop %rax /* olimit */\n    .cfi_def_cfa_offset 152\n    pop %rax /* oend */\n    .cfi_def_cfa_offset 144\n    pop %rax /* ilowest */\n    .cfi_def_cfa_offset 136\n    pop %rax /* arg */\n    .cfi_def_cfa_offset 128\n\n    /* Save ip / op / bits */\n    movq %ip0,  0(%rax)\n    movq %ip1,  8(%rax)\n    movq %ip2, 16(%rax)\n    movq %ip3, 24(%rax)\n    movq %op0, 32(%rax)\n    movq %op1, 40(%rax)\n    movq %op2, 48(%rax)\n    movq %op3, 56(%rax)\n    movq %bits0, 64(%rax)\n    movq %bits1, 72(%rax)\n    movq %bits2, 80(%rax)\n    movq %bits3, 88(%rax)\n\n    /* Restore registers */\n    pop %r15\n    .cfi_restore r15\n    .cfi_def_cfa_offset 120\n    pop %r14\n    .cfi_restore r14\n    .cfi_def_cfa_offset 112\n    pop %r13\n    .cfi_restore r13\n    .cfi_def_cfa_offset 104\n    pop %r12\n    .cfi_restore r12\n    .cfi_def_cfa_offset 96\n    pop %r11\n    .cfi_restore r11\n    .cfi_def_cfa_offset 88\n    pop %r10\n    .cfi_restore r10\n    .cfi_def_cfa_offset 80\n    pop %r9\n    .cfi_restore r9\n    .cfi_def_cfa_offset 72\n    pop %r8\n    .cfi_restore r8\n    .cfi_def_cfa_offset 64\n    pop %rdi\n    .cfi_restore rdi\n    .cfi_def_cfa_offset 56\n    pop %rsi\n    .cfi_restore rsi\n    .cfi_def_cfa_offset 48\n    pop %rbp\n    .cfi_restore rbp\n    .cfi_def_cfa_offset 40\n    pop %rdx\n    .cfi_restore rdx\n    .cfi_def_cfa_offset 32\n    pop %rcx\n    .cfi_restore rcx\n    .cfi_def_cfa_offset 24\n    pop %rbx\n    .cfi_restore rbx\n    .cfi_def_cfa_offset 16\n    pop %rax\n    .cfi_restore rax\n    .cfi_def_cfa_offset 8\n    ret\n    .cfi_endproc\n\n_HUF_decompress4X2_usingDTable_internal_fast_asm_loop:\nHUF_decompress4X2_usingDTable_internal_fast_asm_loop:\n    ZSTD_CET_ENDBRANCH\n    .cfi_startproc\n    .cfi_def_cfa_offset 8\n    .cfi_offset %rip, -8\n    /* Save all registers - even if they are callee saved for simplicity. */\n    push %rax\n    .cfi_def_cfa_offset 16\n    .cfi_offset rax, -16\n    push %rbx\n    .cfi_def_cfa_offset 24\n    .cfi_offset rbx, -24\n    push %rcx\n    .cfi_def_cfa_offset 32\n    .cfi_offset rcx, -32\n    push %rdx\n    .cfi_def_cfa_offset 40\n    .cfi_offset rdx, -40\n    push %rbp\n    .cfi_def_cfa_offset 48\n    .cfi_offset rbp, -48\n    push %rsi\n    .cfi_def_cfa_offset 56\n    .cfi_offset rsi, -56\n    push %rdi\n    .cfi_def_cfa_offset 64\n    .cfi_offset rdi, -64\n    push %r8\n    .cfi_def_cfa_offset 72\n    .cfi_offset r8, -72\n    push %r9\n    .cfi_def_cfa_offset 80\n    .cfi_offset r9, -80\n    push %r10\n    .cfi_def_cfa_offset 88\n    .cfi_offset r10, -88\n    push %r11\n    .cfi_def_cfa_offset 96\n    .cfi_offset r11, -96\n    push %r12\n    .cfi_def_cfa_offset 104\n    .cfi_offset r12, -104\n    push %r13\n    .cfi_def_cfa_offset 112\n    .cfi_offset r13, -112\n    push %r14\n    .cfi_def_cfa_offset 120\n    .cfi_offset r14, -120\n    push %r15\n    .cfi_def_cfa_offset 128\n    .cfi_offset r15, -128\n\n    /* Read HUF_DecompressAsmArgs* args from %rax */\n#if defined(_WIN32)\n    movq %rcx, %rax\n#else\n    movq %rdi, %rax\n#endif\n    movq  0(%rax), %ip0\n    movq  8(%rax), %ip1\n    movq 16(%rax), %ip2\n    movq 24(%rax), %ip3\n    movq 32(%rax), %op0\n    movq 40(%rax), %op1\n    movq 48(%rax), %op2\n    movq 56(%rax), %op3\n    movq 64(%rax), %bits0\n    movq 72(%rax), %bits1\n    movq 80(%rax), %bits2\n    movq 88(%rax), %bits3\n    movq 96(%rax), %dtable\n    push %rax      /* argument */\n    .cfi_def_cfa_offset 136\n    push %rax      /* olimit */\n    .cfi_def_cfa_offset 144\n    push 104(%rax) /* ilowest */\n    .cfi_def_cfa_offset 152\n\n    movq 112(%rax), %rax\n    push %rax /* oend3 */\n    .cfi_def_cfa_offset 160\n\n    movq %op3, %rax\n    push %rax /* oend2 */\n    .cfi_def_cfa_offset 168\n\n    movq %op2, %rax\n    push %rax /* oend1 */\n    .cfi_def_cfa_offset 176\n\n    movq %op1, %rax\n    push %rax /* oend0 */\n    .cfi_def_cfa_offset 184\n\n    /* Scratch space */\n    subq $8, %rsp\n    .cfi_def_cfa_offset 192\n\nLOCAL_LABEL(4X2_compute_olimit):\n    /* Computes how many iterations we can do safely\n     * %r15, %rax may be clobbered\n     * rdx must be saved\n     * op[1,2,3,4] & ip0 mustn't be clobbered\n     */\n    movq %rdx, 0(%rsp)\n\n    /* We can consume up to 7 input bytes each iteration. */\n    movq %ip0,     %rax  /* rax = ip0 */\n    movq 40(%rsp), %rdx  /* rdx = ilowest */\n    subq %rdx,     %rax  /* rax = ip0 - ilowest */\n    movq %rax,    %r15   /* r15 = ip0 - ilowest */\n\n    /* rdx = rax / 7 */\n    movabsq $2635249153387078803, %rdx\n    mulq %rdx\n    subq %rdx, %r15\n    shrq %r15\n    addq %r15, %rdx\n    shrq $2, %rdx\n\n    /* r15 = (ip0 - ilowest) / 7 */\n    movq %rdx, %r15\n\n    /* r15 = min(r15, min(oend0 - op0, oend1 - op1, oend2 - op2, oend3 - op3) / 10) */\n    movq 8(%rsp),  %rax /* rax = oend0 */\n    subq %op0,     %rax /* rax = oend0 - op0 */\n    movq 16(%rsp), %rdx /* rdx = oend1 */\n    subq %op1,     %rdx /* rdx = oend1 - op1 */\n\n    cmpq  %rax,    %rdx\n    cmova %rax,    %rdx /* rdx = min(%rdx, %rax) */\n\n    movq 24(%rsp), %rax /* rax = oend2 */\n    subq %op2,     %rax /* rax = oend2 - op2 */\n\n    cmpq  %rax,    %rdx\n    cmova %rax,    %rdx /* rdx = min(%rdx, %rax) */\n\n    movq 32(%rsp), %rax /* rax = oend3 */\n    subq %op3,     %rax /* rax = oend3 - op3 */\n\n    cmpq  %rax,    %rdx\n    cmova %rax,    %rdx /* rdx = min(%rdx, %rax) */\n\n    movabsq $-3689348814741910323, %rax\n    mulq %rdx\n    shrq $3,       %rdx /* rdx = rdx / 10 */\n\n    /* r15 = min(%rdx, %r15) */\n    cmpq  %rdx, %r15\n    cmova %rdx, %r15\n\n    /* olimit = op3 + 5 * r15 */\n    movq %r15, %rax\n    leaq (%op3, %rax, 4), %olimit\n    addq %rax, %olimit\n\n    movq 0(%rsp), %rdx\n\n    /* If (op3 + 10 > olimit) */\n    movq %op3, %rax    /* rax = op3 */\n    cmpq %rax, %olimit /* op3 == olimit */\n    je LOCAL_LABEL(4X2_exit)\n\n    /* If (ip1 < ip0) go to exit */\n    cmpq %ip0, %ip1\n    jb LOCAL_LABEL(4X2_exit)\n\n    /* If (ip2 < ip1) go to exit */\n    cmpq %ip1, %ip2\n    jb LOCAL_LABEL(4X2_exit)\n\n    /* If (ip3 < ip2) go to exit */\n    cmpq %ip2, %ip3\n    jb LOCAL_LABEL(4X2_exit)\n\n#define DECODE(n, idx)              \\\n    movq %bits##n, %rax;            \\\n    shrq $53, %rax;                 \\\n    movzwl 0(%dtable,%rax,4),%r8d;  \\\n    movzbl 2(%dtable,%rax,4),%r15d; \\\n    movzbl 3(%dtable,%rax,4),%eax;  \\\n    movw %r8w, (%op##n);            \\\n    shlxq %r15, %bits##n, %bits##n; \\\n    addq %rax, %op##n\n\n#define RELOAD_BITS(n)              \\\n    bsfq %bits##n, %bits##n;        \\\n    movq %bits##n, %rax;            \\\n    shrq $3, %bits##n;              \\\n    andq $7, %rax;                  \\\n    subq %bits##n, %ip##n;          \\\n    movq (%ip##n), %bits##n;        \\\n    orq $1, %bits##n;               \\\n    shlxq %rax, %bits##n, %bits##n\n\n\n    movq %olimit, 48(%rsp)\n\n    .p2align 6\n\nLOCAL_LABEL(4X2_loop_body):\n    /* We clobber r8, so store it on the stack */\n    movq %r8, 0(%rsp)\n\n    /* Decode 5 symbols from each of the 4 streams (20 symbols total). */\n    FOR_EACH_STREAM_WITH_INDEX(DECODE, 0)\n    FOR_EACH_STREAM_WITH_INDEX(DECODE, 1)\n    FOR_EACH_STREAM_WITH_INDEX(DECODE, 2)\n    FOR_EACH_STREAM_WITH_INDEX(DECODE, 3)\n    FOR_EACH_STREAM_WITH_INDEX(DECODE, 4)\n\n    /* Reload r8 */\n    movq 0(%rsp), %r8\n\n    FOR_EACH_STREAM(RELOAD_BITS)\n\n    cmp %op3, 48(%rsp)\n    ja LOCAL_LABEL(4X2_loop_body)\n    jmp LOCAL_LABEL(4X2_compute_olimit)\n\n#undef DECODE\n#undef RELOAD_BITS\nLOCAL_LABEL(4X2_exit):\n    addq $8, %rsp\n    .cfi_def_cfa_offset 184\n    /* Restore stack (oend & olimit) */\n    pop %rax /* oend0 */\n    .cfi_def_cfa_offset 176\n    pop %rax /* oend1 */\n    .cfi_def_cfa_offset 168\n    pop %rax /* oend2 */\n    .cfi_def_cfa_offset 160\n    pop %rax /* oend3 */\n    .cfi_def_cfa_offset 152\n    pop %rax /* ilowest */\n    .cfi_def_cfa_offset 144\n    pop %rax /* olimit */\n    .cfi_def_cfa_offset 136\n    pop %rax /* arg */\n    .cfi_def_cfa_offset 128\n\n    /* Save ip / op / bits */\n    movq %ip0,  0(%rax)\n    movq %ip1,  8(%rax)\n    movq %ip2, 16(%rax)\n    movq %ip3, 24(%rax)\n    movq %op0, 32(%rax)\n    movq %op1, 40(%rax)\n    movq %op2, 48(%rax)\n    movq %op3, 56(%rax)\n    movq %bits0, 64(%rax)\n    movq %bits1, 72(%rax)\n    movq %bits2, 80(%rax)\n    movq %bits3, 88(%rax)\n\n    /* Restore registers */\n    pop %r15\n    .cfi_restore r15\n    .cfi_def_cfa_offset 120\n    pop %r14\n    .cfi_restore r14\n    .cfi_def_cfa_offset 112\n    pop %r13\n    .cfi_restore r13\n    .cfi_def_cfa_offset 104\n    pop %r12\n    .cfi_restore r12\n    .cfi_def_cfa_offset 96\n    pop %r11\n    .cfi_restore r11\n    .cfi_def_cfa_offset 88\n    pop %r10\n    .cfi_restore r10\n    .cfi_def_cfa_offset 80\n    pop %r9\n    .cfi_restore r9\n    .cfi_def_cfa_offset 72\n    pop %r8\n    .cfi_restore r8\n    .cfi_def_cfa_offset 64\n    pop %rdi\n    .cfi_restore rdi\n    .cfi_def_cfa_offset 56\n    pop %rsi\n    .cfi_restore rsi\n    .cfi_def_cfa_offset 48\n    pop %rbp\n    .cfi_restore rbp\n    .cfi_def_cfa_offset 40\n    pop %rdx\n    .cfi_restore rdx\n    .cfi_def_cfa_offset 32\n    pop %rcx\n    .cfi_restore rcx\n    .cfi_def_cfa_offset 24\n    pop %rbx\n    .cfi_restore rbx\n    .cfi_def_cfa_offset 16\n    pop %rax\n    .cfi_restore rax\n    .cfi_def_cfa_offset 8\n    ret\n    .cfi_endproc\n\n#endif\n"
  },
  {
    "path": "lib/decompress/zstd_ddict.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/* zstd_ddict.c :\n * concentrates all logic that needs to know the internals of ZSTD_DDict object */\n\n/*-*******************************************************\n*  Dependencies\n*********************************************************/\n#include \"../common/allocations.h\"  /* ZSTD_customMalloc, ZSTD_customFree */\n#include \"../common/zstd_deps.h\"   /* ZSTD_memcpy, ZSTD_memmove, ZSTD_memset */\n#include \"../common/cpu.h\"         /* bmi2 */\n#include \"../common/mem.h\"         /* low level memory routines */\n#define FSE_STATIC_LINKING_ONLY\n#include \"../common/fse.h\"\n#include \"../common/huf.h\"\n#include \"zstd_decompress_internal.h\"\n#include \"zstd_ddict.h\"\n\n#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)\n#  include \"../legacy/zstd_legacy.h\"\n#endif\n\n\n\n/*-*******************************************************\n*  Types\n*********************************************************/\nstruct ZSTD_DDict_s {\n    void* dictBuffer;\n    const void* dictContent;\n    size_t dictSize;\n    ZSTD_entropyDTables_t entropy;\n    U32 dictID;\n    U32 entropyPresent;\n    ZSTD_customMem cMem;\n};  /* typedef'd to ZSTD_DDict within \"zstd.h\" */\n\nconst void* ZSTD_DDict_dictContent(const ZSTD_DDict* ddict)\n{\n    assert(ddict != NULL);\n    return ddict->dictContent;\n}\n\nsize_t ZSTD_DDict_dictSize(const ZSTD_DDict* ddict)\n{\n    assert(ddict != NULL);\n    return ddict->dictSize;\n}\n\nvoid ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)\n{\n    DEBUGLOG(4, \"ZSTD_copyDDictParameters\");\n    assert(dctx != NULL);\n    assert(ddict != NULL);\n    dctx->dictID = ddict->dictID;\n    dctx->prefixStart = ddict->dictContent;\n    dctx->virtualStart = ddict->dictContent;\n    dctx->dictEnd = (const BYTE*)ddict->dictContent + ddict->dictSize;\n    dctx->previousDstEnd = dctx->dictEnd;\n#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION\n    dctx->dictContentBeginForFuzzing = dctx->prefixStart;\n    dctx->dictContentEndForFuzzing = dctx->previousDstEnd;\n#endif\n    if (ddict->entropyPresent) {\n        dctx->litEntropy = 1;\n        dctx->fseEntropy = 1;\n        dctx->LLTptr = ddict->entropy.LLTable;\n        dctx->MLTptr = ddict->entropy.MLTable;\n        dctx->OFTptr = ddict->entropy.OFTable;\n        dctx->HUFptr = ddict->entropy.hufTable;\n        dctx->entropy.rep[0] = ddict->entropy.rep[0];\n        dctx->entropy.rep[1] = ddict->entropy.rep[1];\n        dctx->entropy.rep[2] = ddict->entropy.rep[2];\n    } else {\n        dctx->litEntropy = 0;\n        dctx->fseEntropy = 0;\n    }\n}\n\n\nstatic size_t\nZSTD_loadEntropy_intoDDict(ZSTD_DDict* ddict,\n                           ZSTD_dictContentType_e dictContentType)\n{\n    ddict->dictID = 0;\n    ddict->entropyPresent = 0;\n    if (dictContentType == ZSTD_dct_rawContent) return 0;\n\n    if (ddict->dictSize < 8) {\n        if (dictContentType == ZSTD_dct_fullDict)\n            return ERROR(dictionary_corrupted);   /* only accept specified dictionaries */\n        return 0;   /* pure content mode */\n    }\n    {   U32 const magic = MEM_readLE32(ddict->dictContent);\n        if (magic != ZSTD_MAGIC_DICTIONARY) {\n            if (dictContentType == ZSTD_dct_fullDict)\n                return ERROR(dictionary_corrupted);   /* only accept specified dictionaries */\n            return 0;   /* pure content mode */\n        }\n    }\n    ddict->dictID = MEM_readLE32((const char*)ddict->dictContent + ZSTD_FRAMEIDSIZE);\n\n    /* load entropy tables */\n    RETURN_ERROR_IF(ZSTD_isError(ZSTD_loadDEntropy(\n            &ddict->entropy, ddict->dictContent, ddict->dictSize)),\n        dictionary_corrupted, \"\");\n    ddict->entropyPresent = 1;\n    return 0;\n}\n\n\nstatic size_t ZSTD_initDDict_internal(ZSTD_DDict* ddict,\n                                      const void* dict, size_t dictSize,\n                                      ZSTD_dictLoadMethod_e dictLoadMethod,\n                                      ZSTD_dictContentType_e dictContentType)\n{\n    if ((dictLoadMethod == ZSTD_dlm_byRef) || (!dict) || (!dictSize)) {\n        ddict->dictBuffer = NULL;\n        ddict->dictContent = dict;\n        if (!dict) dictSize = 0;\n    } else {\n        void* const internalBuffer = ZSTD_customMalloc(dictSize, ddict->cMem);\n        ddict->dictBuffer = internalBuffer;\n        ddict->dictContent = internalBuffer;\n        if (!internalBuffer) return ERROR(memory_allocation);\n        ZSTD_memcpy(internalBuffer, dict, dictSize);\n    }\n    ddict->dictSize = dictSize;\n    ddict->entropy.hufTable[0] = (HUF_DTable)((ZSTD_HUFFDTABLE_CAPACITY_LOG)*0x1000001);  /* cover both little and big endian */\n\n    /* parse dictionary content */\n    FORWARD_IF_ERROR( ZSTD_loadEntropy_intoDDict(ddict, dictContentType) , \"\");\n\n    return 0;\n}\n\nZSTD_DDict* ZSTD_createDDict_advanced(const void* dict, size_t dictSize,\n                                      ZSTD_dictLoadMethod_e dictLoadMethod,\n                                      ZSTD_dictContentType_e dictContentType,\n                                      ZSTD_customMem customMem)\n{\n    if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;\n\n    {   ZSTD_DDict* const ddict = (ZSTD_DDict*) ZSTD_customMalloc(sizeof(ZSTD_DDict), customMem);\n        if (ddict == NULL) return NULL;\n        ddict->cMem = customMem;\n        {   size_t const initResult = ZSTD_initDDict_internal(ddict,\n                                            dict, dictSize,\n                                            dictLoadMethod, dictContentType);\n            if (ZSTD_isError(initResult)) {\n                ZSTD_freeDDict(ddict);\n                return NULL;\n        }   }\n        return ddict;\n    }\n}\n\n/*! ZSTD_createDDict() :\n*   Create a digested dictionary, to start decompression without startup delay.\n*   `dict` content is copied inside DDict.\n*   Consequently, `dict` can be released after `ZSTD_DDict` creation */\nZSTD_DDict* ZSTD_createDDict(const void* dict, size_t dictSize)\n{\n    ZSTD_customMem const allocator = { NULL, NULL, NULL };\n    return ZSTD_createDDict_advanced(dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto, allocator);\n}\n\n/*! ZSTD_createDDict_byReference() :\n *  Create a digested dictionary, to start decompression without startup delay.\n *  Dictionary content is simply referenced, it will be accessed during decompression.\n *  Warning : dictBuffer must outlive DDict (DDict must be freed before dictBuffer) */\nZSTD_DDict* ZSTD_createDDict_byReference(const void* dictBuffer, size_t dictSize)\n{\n    ZSTD_customMem const allocator = { NULL, NULL, NULL };\n    return ZSTD_createDDict_advanced(dictBuffer, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto, allocator);\n}\n\n\nconst ZSTD_DDict* ZSTD_initStaticDDict(\n                                void* sBuffer, size_t sBufferSize,\n                                const void* dict, size_t dictSize,\n                                ZSTD_dictLoadMethod_e dictLoadMethod,\n                                ZSTD_dictContentType_e dictContentType)\n{\n    size_t const neededSpace = sizeof(ZSTD_DDict)\n                             + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);\n    ZSTD_DDict* const ddict = (ZSTD_DDict*)sBuffer;\n    assert(sBuffer != NULL);\n    assert(dict != NULL);\n    if ((size_t)sBuffer & 7) return NULL;   /* 8-aligned */\n    if (sBufferSize < neededSpace) return NULL;\n    if (dictLoadMethod == ZSTD_dlm_byCopy) {\n        ZSTD_memcpy(ddict+1, dict, dictSize);  /* local copy */\n        dict = ddict+1;\n    }\n    if (ZSTD_isError( ZSTD_initDDict_internal(ddict,\n                                              dict, dictSize,\n                                              ZSTD_dlm_byRef, dictContentType) ))\n        return NULL;\n    return ddict;\n}\n\n\nsize_t ZSTD_freeDDict(ZSTD_DDict* ddict)\n{\n    if (ddict==NULL) return 0;   /* support free on NULL */\n    {   ZSTD_customMem const cMem = ddict->cMem;\n        ZSTD_customFree(ddict->dictBuffer, cMem);\n        ZSTD_customFree(ddict, cMem);\n        return 0;\n    }\n}\n\n/*! ZSTD_estimateDDictSize() :\n *  Estimate amount of memory that will be needed to create a dictionary for decompression.\n *  Note : dictionary created by reference using ZSTD_dlm_byRef are smaller */\nsize_t ZSTD_estimateDDictSize(size_t dictSize, ZSTD_dictLoadMethod_e dictLoadMethod)\n{\n    return sizeof(ZSTD_DDict) + (dictLoadMethod == ZSTD_dlm_byRef ? 0 : dictSize);\n}\n\nsize_t ZSTD_sizeof_DDict(const ZSTD_DDict* ddict)\n{\n    if (ddict==NULL) return 0;   /* support sizeof on NULL */\n    return sizeof(*ddict) + (ddict->dictBuffer ? ddict->dictSize : 0) ;\n}\n\n/*! ZSTD_getDictID_fromDDict() :\n *  Provides the dictID of the dictionary loaded into `ddict`.\n *  If @return == 0, the dictionary is not conformant to Zstandard specification, or empty.\n *  Non-conformant dictionaries can still be loaded, but as content-only dictionaries. */\nunsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict)\n{\n    if (ddict==NULL) return 0;\n    return ddict->dictID;\n}\n"
  },
  {
    "path": "lib/decompress/zstd_ddict.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n\n#ifndef ZSTD_DDICT_H\n#define ZSTD_DDICT_H\n\n/*-*******************************************************\n *  Dependencies\n *********************************************************/\n#include \"../common/zstd_deps.h\"   /* size_t */\n#include \"../zstd.h\"     /* ZSTD_DDict, and several public functions */\n\n\n/*-*******************************************************\n *  Interface\n *********************************************************/\n\n/* note: several prototypes are already published in `zstd.h` :\n * ZSTD_createDDict()\n * ZSTD_createDDict_byReference()\n * ZSTD_createDDict_advanced()\n * ZSTD_freeDDict()\n * ZSTD_initStaticDDict()\n * ZSTD_sizeof_DDict()\n * ZSTD_estimateDDictSize()\n * ZSTD_getDictID_fromDict()\n */\n\nconst void* ZSTD_DDict_dictContent(const ZSTD_DDict* ddict);\nsize_t ZSTD_DDict_dictSize(const ZSTD_DDict* ddict);\n\nvoid ZSTD_copyDDictParameters(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict);\n\n\n\n#endif /* ZSTD_DDICT_H */\n"
  },
  {
    "path": "lib/decompress/zstd_decompress.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n\n/* ***************************************************************\n*  Tuning parameters\n*****************************************************************/\n/*!\n * HEAPMODE :\n * Select how default decompression function ZSTD_decompress() allocates its context,\n * on stack (0), or into heap (1, default; requires malloc()).\n * Note that functions with explicit context such as ZSTD_decompressDCtx() are unaffected.\n */\n#ifndef ZSTD_HEAPMODE\n#  define ZSTD_HEAPMODE 1\n#endif\n\n/*!\n*  LEGACY_SUPPORT :\n*  if set to 1+, ZSTD_decompress() can decode older formats (v0.1+)\n*/\n#ifndef ZSTD_LEGACY_SUPPORT\n#  define ZSTD_LEGACY_SUPPORT 0\n#endif\n\n/*!\n *  MAXWINDOWSIZE_DEFAULT :\n *  maximum window size accepted by DStream __by default__.\n *  Frames requiring more memory will be rejected.\n *  It's possible to set a different limit using ZSTD_DCtx_setMaxWindowSize().\n */\n#ifndef ZSTD_MAXWINDOWSIZE_DEFAULT\n#  define ZSTD_MAXWINDOWSIZE_DEFAULT (((U32)1 << ZSTD_WINDOWLOG_LIMIT_DEFAULT) + 1)\n#endif\n\n/*!\n *  NO_FORWARD_PROGRESS_MAX :\n *  maximum allowed nb of calls to ZSTD_decompressStream()\n *  without any forward progress\n *  (defined as: no byte read from input, and no byte flushed to output)\n *  before triggering an error.\n */\n#ifndef ZSTD_NO_FORWARD_PROGRESS_MAX\n#  define ZSTD_NO_FORWARD_PROGRESS_MAX 16\n#endif\n\n\n/*-*******************************************************\n*  Dependencies\n*********************************************************/\n#include \"../common/zstd_deps.h\"   /* ZSTD_memcpy, ZSTD_memmove, ZSTD_memset */\n#include \"../common/allocations.h\"  /* ZSTD_customMalloc, ZSTD_customCalloc, ZSTD_customFree */\n#include \"../common/error_private.h\"\n#include \"../common/zstd_internal.h\"  /* blockProperties_t */\n#include \"../common/mem.h\"         /* low level memory routines */\n#include \"../common/bits.h\"  /* ZSTD_highbit32 */\n#define FSE_STATIC_LINKING_ONLY\n#include \"../common/fse.h\"\n#include \"../common/huf.h\"\n#include \"../common/xxhash.h\" /* XXH64_reset, XXH64_update, XXH64_digest, XXH64 */\n#include \"zstd_decompress_internal.h\"   /* ZSTD_DCtx */\n#include \"zstd_ddict.h\"  /* ZSTD_DDictDictContent */\n#include \"zstd_decompress_block.h\"   /* ZSTD_decompressBlock_internal */\n\n#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)\n#  include \"../legacy/zstd_legacy.h\"\n#endif\n\n\n\n/*************************************\n * Multiple DDicts Hashset internals *\n *************************************/\n\n#define DDICT_HASHSET_MAX_LOAD_FACTOR_COUNT_MULT 4\n#define DDICT_HASHSET_MAX_LOAD_FACTOR_SIZE_MULT 3  /* These two constants represent SIZE_MULT/COUNT_MULT load factor without using a float.\n                                                    * Currently, that means a 0.75 load factor.\n                                                    * So, if count * COUNT_MULT / size * SIZE_MULT != 0, then we've exceeded\n                                                    * the load factor of the ddict hash set.\n                                                    */\n\n#define DDICT_HASHSET_TABLE_BASE_SIZE 64\n#define DDICT_HASHSET_RESIZE_FACTOR 2\n\n/* Hash function to determine starting position of dict insertion within the table\n * Returns an index between [0, hashSet->ddictPtrTableSize]\n */\nstatic size_t ZSTD_DDictHashSet_getIndex(const ZSTD_DDictHashSet* hashSet, U32 dictID) {\n    const U64 hash = XXH64(&dictID, sizeof(U32), 0);\n    /* DDict ptr table size is a multiple of 2, use size - 1 as mask to get index within [0, hashSet->ddictPtrTableSize) */\n    return hash & (hashSet->ddictPtrTableSize - 1);\n}\n\n/* Adds DDict to a hashset without resizing it.\n * If inserting a DDict with a dictID that already exists in the set, replaces the one in the set.\n * Returns 0 if successful, or a zstd error code if something went wrong.\n */\nstatic size_t ZSTD_DDictHashSet_emplaceDDict(ZSTD_DDictHashSet* hashSet, const ZSTD_DDict* ddict) {\n    const U32 dictID = ZSTD_getDictID_fromDDict(ddict);\n    size_t idx = ZSTD_DDictHashSet_getIndex(hashSet, dictID);\n    const size_t idxRangeMask = hashSet->ddictPtrTableSize - 1;\n    RETURN_ERROR_IF(hashSet->ddictPtrCount == hashSet->ddictPtrTableSize, GENERIC, \"Hash set is full!\");\n    DEBUGLOG(4, \"Hashed index: for dictID: %u is %zu\", dictID, idx);\n    while (hashSet->ddictPtrTable[idx] != NULL) {\n        /* Replace existing ddict if inserting ddict with same dictID */\n        if (ZSTD_getDictID_fromDDict(hashSet->ddictPtrTable[idx]) == dictID) {\n            DEBUGLOG(4, \"DictID already exists, replacing rather than adding\");\n            hashSet->ddictPtrTable[idx] = ddict;\n            return 0;\n        }\n        idx &= idxRangeMask;\n        idx++;\n    }\n    DEBUGLOG(4, \"Final idx after probing for dictID %u is: %zu\", dictID, idx);\n    hashSet->ddictPtrTable[idx] = ddict;\n    hashSet->ddictPtrCount++;\n    return 0;\n}\n\n/* Expands hash table by factor of DDICT_HASHSET_RESIZE_FACTOR and\n * rehashes all values, allocates new table, frees old table.\n * Returns 0 on success, otherwise a zstd error code.\n */\nstatic size_t ZSTD_DDictHashSet_expand(ZSTD_DDictHashSet* hashSet, ZSTD_customMem customMem) {\n    size_t newTableSize = hashSet->ddictPtrTableSize * DDICT_HASHSET_RESIZE_FACTOR;\n    const ZSTD_DDict** newTable = (const ZSTD_DDict**)ZSTD_customCalloc(sizeof(ZSTD_DDict*) * newTableSize, customMem);\n    const ZSTD_DDict** oldTable = hashSet->ddictPtrTable;\n    size_t oldTableSize = hashSet->ddictPtrTableSize;\n    size_t i;\n\n    DEBUGLOG(4, \"Expanding DDict hash table! Old size: %zu new size: %zu\", oldTableSize, newTableSize);\n    RETURN_ERROR_IF(!newTable, memory_allocation, \"Expanded hashset allocation failed!\");\n    hashSet->ddictPtrTable = newTable;\n    hashSet->ddictPtrTableSize = newTableSize;\n    hashSet->ddictPtrCount = 0;\n    for (i = 0; i < oldTableSize; ++i) {\n        if (oldTable[i] != NULL) {\n            FORWARD_IF_ERROR(ZSTD_DDictHashSet_emplaceDDict(hashSet, oldTable[i]), \"\");\n        }\n    }\n    ZSTD_customFree((void*)oldTable, customMem);\n    DEBUGLOG(4, \"Finished re-hash\");\n    return 0;\n}\n\n/* Fetches a DDict with the given dictID\n * Returns the ZSTD_DDict* with the requested dictID. If it doesn't exist, then returns NULL.\n */\nstatic const ZSTD_DDict* ZSTD_DDictHashSet_getDDict(ZSTD_DDictHashSet* hashSet, U32 dictID) {\n    size_t idx = ZSTD_DDictHashSet_getIndex(hashSet, dictID);\n    const size_t idxRangeMask = hashSet->ddictPtrTableSize - 1;\n    DEBUGLOG(4, \"Hashed index: for dictID: %u is %zu\", dictID, idx);\n    for (;;) {\n        size_t currDictID = ZSTD_getDictID_fromDDict(hashSet->ddictPtrTable[idx]);\n        if (currDictID == dictID || currDictID == 0) {\n            /* currDictID == 0 implies a NULL ddict entry */\n            break;\n        } else {\n            idx &= idxRangeMask;    /* Goes to start of table when we reach the end */\n            idx++;\n        }\n    }\n    DEBUGLOG(4, \"Final idx after probing for dictID %u is: %zu\", dictID, idx);\n    return hashSet->ddictPtrTable[idx];\n}\n\n/* Allocates space for and returns a ddict hash set\n * The hash set's ZSTD_DDict* table has all values automatically set to NULL to begin with.\n * Returns NULL if allocation failed.\n */\nstatic ZSTD_DDictHashSet* ZSTD_createDDictHashSet(ZSTD_customMem customMem) {\n    ZSTD_DDictHashSet* ret = (ZSTD_DDictHashSet*)ZSTD_customMalloc(sizeof(ZSTD_DDictHashSet), customMem);\n    DEBUGLOG(4, \"Allocating new hash set\");\n    if (!ret)\n        return NULL;\n    ret->ddictPtrTable = (const ZSTD_DDict**)ZSTD_customCalloc(DDICT_HASHSET_TABLE_BASE_SIZE * sizeof(ZSTD_DDict*), customMem);\n    if (!ret->ddictPtrTable) {\n        ZSTD_customFree(ret, customMem);\n        return NULL;\n    }\n    ret->ddictPtrTableSize = DDICT_HASHSET_TABLE_BASE_SIZE;\n    ret->ddictPtrCount = 0;\n    return ret;\n}\n\n/* Frees the table of ZSTD_DDict* within a hashset, then frees the hashset itself.\n * Note: The ZSTD_DDict* within the table are NOT freed.\n */\nstatic void ZSTD_freeDDictHashSet(ZSTD_DDictHashSet* hashSet, ZSTD_customMem customMem) {\n    DEBUGLOG(4, \"Freeing ddict hash set\");\n    if (hashSet && hashSet->ddictPtrTable) {\n        ZSTD_customFree((void*)hashSet->ddictPtrTable, customMem);\n    }\n    if (hashSet) {\n        ZSTD_customFree(hashSet, customMem);\n    }\n}\n\n/* Public function: Adds a DDict into the ZSTD_DDictHashSet, possibly triggering a resize of the hash set.\n * Returns 0 on success, or a ZSTD error.\n */\nstatic size_t ZSTD_DDictHashSet_addDDict(ZSTD_DDictHashSet* hashSet, const ZSTD_DDict* ddict, ZSTD_customMem customMem) {\n    DEBUGLOG(4, \"Adding dict ID: %u to hashset with - Count: %zu Tablesize: %zu\", ZSTD_getDictID_fromDDict(ddict), hashSet->ddictPtrCount, hashSet->ddictPtrTableSize);\n    if (hashSet->ddictPtrCount * DDICT_HASHSET_MAX_LOAD_FACTOR_COUNT_MULT / hashSet->ddictPtrTableSize * DDICT_HASHSET_MAX_LOAD_FACTOR_SIZE_MULT != 0) {\n        FORWARD_IF_ERROR(ZSTD_DDictHashSet_expand(hashSet, customMem), \"\");\n    }\n    FORWARD_IF_ERROR(ZSTD_DDictHashSet_emplaceDDict(hashSet, ddict), \"\");\n    return 0;\n}\n\n/*-*************************************************************\n*   Context management\n***************************************************************/\nsize_t ZSTD_sizeof_DCtx (const ZSTD_DCtx* dctx)\n{\n    if (dctx==NULL) return 0;   /* support sizeof NULL */\n    return sizeof(*dctx)\n           + ZSTD_sizeof_DDict(dctx->ddictLocal)\n           + dctx->inBuffSize + dctx->outBuffSize;\n}\n\nsize_t ZSTD_estimateDCtxSize(void) { return sizeof(ZSTD_DCtx); }\n\n\nstatic size_t ZSTD_startingInputLength(ZSTD_format_e format)\n{\n    size_t const startingInputLength = ZSTD_FRAMEHEADERSIZE_PREFIX(format);\n    /* only supports formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless */\n    assert( (format == ZSTD_f_zstd1) || (format == ZSTD_f_zstd1_magicless) );\n    return startingInputLength;\n}\n\nstatic void ZSTD_DCtx_resetParameters(ZSTD_DCtx* dctx)\n{\n    assert(dctx->streamStage == zdss_init);\n    dctx->format = ZSTD_f_zstd1;\n    dctx->maxWindowSize = ZSTD_MAXWINDOWSIZE_DEFAULT;\n    dctx->outBufferMode = ZSTD_bm_buffered;\n    dctx->forceIgnoreChecksum = ZSTD_d_validateChecksum;\n    dctx->refMultipleDDicts = ZSTD_rmd_refSingleDDict;\n    dctx->disableHufAsm = 0;\n    dctx->maxBlockSizeParam = 0;\n}\n\nstatic void ZSTD_initDCtx_internal(ZSTD_DCtx* dctx)\n{\n    dctx->staticSize  = 0;\n    dctx->ddict       = NULL;\n    dctx->ddictLocal  = NULL;\n    dctx->dictEnd     = NULL;\n    dctx->ddictIsCold = 0;\n    dctx->dictUses = ZSTD_dont_use;\n    dctx->inBuff      = NULL;\n    dctx->inBuffSize  = 0;\n    dctx->outBuffSize = 0;\n    dctx->streamStage = zdss_init;\n#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)\n    dctx->legacyContext = NULL;\n    dctx->previousLegacyVersion = 0;\n#endif\n    dctx->noForwardProgress = 0;\n    dctx->oversizedDuration = 0;\n    dctx->isFrameDecompression = 1;\n#if DYNAMIC_BMI2\n    dctx->bmi2 = ZSTD_cpuSupportsBmi2();\n#endif\n    dctx->ddictSet = NULL;\n    ZSTD_DCtx_resetParameters(dctx);\n#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION\n    dctx->dictContentEndForFuzzing = NULL;\n#endif\n}\n\nZSTD_DCtx* ZSTD_initStaticDCtx(void *workspace, size_t workspaceSize)\n{\n    ZSTD_DCtx* const dctx = (ZSTD_DCtx*) workspace;\n\n    if ((size_t)workspace & 7) return NULL;  /* 8-aligned */\n    if (workspaceSize < sizeof(ZSTD_DCtx)) return NULL;  /* minimum size */\n\n    ZSTD_initDCtx_internal(dctx);\n    dctx->staticSize = workspaceSize;\n    dctx->inBuff = (char*)(dctx+1);\n    return dctx;\n}\n\nstatic ZSTD_DCtx* ZSTD_createDCtx_internal(ZSTD_customMem customMem) {\n    if ((!customMem.customAlloc) ^ (!customMem.customFree)) return NULL;\n\n    {   ZSTD_DCtx* const dctx = (ZSTD_DCtx*)ZSTD_customMalloc(sizeof(*dctx), customMem);\n        if (!dctx) return NULL;\n        dctx->customMem = customMem;\n        ZSTD_initDCtx_internal(dctx);\n        return dctx;\n    }\n}\n\nZSTD_DCtx* ZSTD_createDCtx_advanced(ZSTD_customMem customMem)\n{\n    return ZSTD_createDCtx_internal(customMem);\n}\n\nZSTD_DCtx* ZSTD_createDCtx(void)\n{\n    DEBUGLOG(3, \"ZSTD_createDCtx\");\n    return ZSTD_createDCtx_internal(ZSTD_defaultCMem);\n}\n\nstatic void ZSTD_clearDict(ZSTD_DCtx* dctx)\n{\n    ZSTD_freeDDict(dctx->ddictLocal);\n    dctx->ddictLocal = NULL;\n    dctx->ddict = NULL;\n    dctx->dictUses = ZSTD_dont_use;\n}\n\nsize_t ZSTD_freeDCtx(ZSTD_DCtx* dctx)\n{\n    if (dctx==NULL) return 0;   /* support free on NULL */\n    RETURN_ERROR_IF(dctx->staticSize, memory_allocation, \"not compatible with static DCtx\");\n    {   ZSTD_customMem const cMem = dctx->customMem;\n        ZSTD_clearDict(dctx);\n        ZSTD_customFree(dctx->inBuff, cMem);\n        dctx->inBuff = NULL;\n#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)\n        if (dctx->legacyContext)\n            ZSTD_freeLegacyStreamContext(dctx->legacyContext, dctx->previousLegacyVersion);\n#endif\n        if (dctx->ddictSet) {\n            ZSTD_freeDDictHashSet(dctx->ddictSet, cMem);\n            dctx->ddictSet = NULL;\n        }\n        ZSTD_customFree(dctx, cMem);\n        return 0;\n    }\n}\n\n/* no longer useful */\nvoid ZSTD_copyDCtx(ZSTD_DCtx* dstDCtx, const ZSTD_DCtx* srcDCtx)\n{\n    size_t const toCopy = (size_t)((char*)(&dstDCtx->inBuff) - (char*)dstDCtx);\n    ZSTD_memcpy(dstDCtx, srcDCtx, toCopy);  /* no need to copy workspace */\n}\n\n/* Given a dctx with a digested frame params, re-selects the correct ZSTD_DDict based on\n * the requested dict ID from the frame. If there exists a reference to the correct ZSTD_DDict, then\n * accordingly sets the ddict to be used to decompress the frame.\n *\n * If no DDict is found, then no action is taken, and the ZSTD_DCtx::ddict remains as-is.\n *\n * ZSTD_d_refMultipleDDicts must be enabled for this function to be called.\n */\nstatic void ZSTD_DCtx_selectFrameDDict(ZSTD_DCtx* dctx) {\n    assert(dctx->refMultipleDDicts && dctx->ddictSet);\n    DEBUGLOG(4, \"Adjusting DDict based on requested dict ID from frame\");\n    if (dctx->ddict) {\n        const ZSTD_DDict* frameDDict = ZSTD_DDictHashSet_getDDict(dctx->ddictSet, dctx->fParams.dictID);\n        if (frameDDict) {\n            DEBUGLOG(4, \"DDict found!\");\n            ZSTD_clearDict(dctx);\n            dctx->dictID = dctx->fParams.dictID;\n            dctx->ddict = frameDDict;\n            dctx->dictUses = ZSTD_use_indefinitely;\n        }\n    }\n}\n\n\n/*-*************************************************************\n *   Frame header decoding\n ***************************************************************/\n\n/*! ZSTD_isFrame() :\n *  Tells if the content of `buffer` starts with a valid Frame Identifier.\n *  Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.\n *  Note 2 : Legacy Frame Identifiers are considered valid only if Legacy Support is enabled.\n *  Note 3 : Skippable Frame Identifiers are considered valid. */\nunsigned ZSTD_isFrame(const void* buffer, size_t size)\n{\n    if (size < ZSTD_FRAMEIDSIZE) return 0;\n    {   U32 const magic = MEM_readLE32(buffer);\n        if (magic == ZSTD_MAGICNUMBER) return 1;\n        if ((magic & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) return 1;\n    }\n#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)\n    if (ZSTD_isLegacy(buffer, size)) return 1;\n#endif\n    return 0;\n}\n\n/*! ZSTD_isSkippableFrame() :\n *  Tells if the content of `buffer` starts with a valid Frame Identifier for a skippable frame.\n *  Note : Frame Identifier is 4 bytes. If `size < 4`, @return will always be 0.\n */\nunsigned ZSTD_isSkippableFrame(const void* buffer, size_t size)\n{\n    if (size < ZSTD_FRAMEIDSIZE) return 0;\n    {   U32 const magic = MEM_readLE32(buffer);\n        if ((magic & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) return 1;\n    }\n    return 0;\n}\n\n/** ZSTD_frameHeaderSize_internal() :\n *  srcSize must be large enough to reach header size fields.\n *  note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless.\n * @return : size of the Frame Header\n *           or an error code, which can be tested with ZSTD_isError() */\nstatic size_t ZSTD_frameHeaderSize_internal(const void* src, size_t srcSize, ZSTD_format_e format)\n{\n    size_t const minInputSize = ZSTD_startingInputLength(format);\n    RETURN_ERROR_IF(srcSize < minInputSize, srcSize_wrong, \"\");\n\n    {   BYTE const fhd = ((const BYTE*)src)[minInputSize-1];\n        U32 const dictID= fhd & 3;\n        U32 const singleSegment = (fhd >> 5) & 1;\n        U32 const fcsId = fhd >> 6;\n        return minInputSize + !singleSegment\n             + ZSTD_did_fieldSize[dictID] + ZSTD_fcs_fieldSize[fcsId]\n             + (singleSegment && !fcsId);\n    }\n}\n\n/** ZSTD_frameHeaderSize() :\n *  srcSize must be >= ZSTD_frameHeaderSize_prefix.\n * @return : size of the Frame Header,\n *           or an error code (if srcSize is too small) */\nsize_t ZSTD_frameHeaderSize(const void* src, size_t srcSize)\n{\n    return ZSTD_frameHeaderSize_internal(src, srcSize, ZSTD_f_zstd1);\n}\n\n\n/** ZSTD_getFrameHeader_advanced() :\n *  decode Frame Header, or require larger `srcSize`.\n *  note : only works for formats ZSTD_f_zstd1 and ZSTD_f_zstd1_magicless\n * @return : 0, `zfhPtr` is correctly filled,\n *          >0, `srcSize` is too small, value is wanted `srcSize` amount,\n**           or an error code, which can be tested using ZSTD_isError() */\nsize_t ZSTD_getFrameHeader_advanced(ZSTD_FrameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format)\n{\n    const BYTE* ip = (const BYTE*)src;\n    size_t const minInputSize = ZSTD_startingInputLength(format);\n\n    DEBUGLOG(5, \"ZSTD_getFrameHeader_advanced: minInputSize = %zu, srcSize = %zu\", minInputSize, srcSize);\n\n    if (srcSize > 0) {\n        /* note : technically could be considered an assert(), since it's an invalid entry */\n        RETURN_ERROR_IF(src==NULL, GENERIC, \"invalid parameter : src==NULL, but srcSize>0\");\n    }\n    if (srcSize < minInputSize) {\n        if (srcSize > 0 && format != ZSTD_f_zstd1_magicless) {\n            /* when receiving less than @minInputSize bytes,\n             * control these bytes at least correspond to a supported magic number\n             * in order to error out early if they don't.\n            **/\n            size_t const toCopy = MIN(4, srcSize);\n            unsigned char hbuf[4]; MEM_writeLE32(hbuf, ZSTD_MAGICNUMBER);\n            assert(src != NULL);\n            ZSTD_memcpy(hbuf, src, toCopy);\n            if ( MEM_readLE32(hbuf) != ZSTD_MAGICNUMBER ) {\n                /* not a zstd frame : let's check if it's a skippable frame */\n                MEM_writeLE32(hbuf, ZSTD_MAGIC_SKIPPABLE_START);\n                ZSTD_memcpy(hbuf, src, toCopy);\n                if ((MEM_readLE32(hbuf) & ZSTD_MAGIC_SKIPPABLE_MASK) != ZSTD_MAGIC_SKIPPABLE_START) {\n                    RETURN_ERROR(prefix_unknown,\n                                \"first bytes don't correspond to any supported magic number\");\n        }   }   }\n        return minInputSize;\n    }\n\n    ZSTD_memset(zfhPtr, 0, sizeof(*zfhPtr));   /* not strictly necessary, but static analyzers may not understand that zfhPtr will be read only if return value is zero, since they are 2 different signals */\n    if ( (format != ZSTD_f_zstd1_magicless)\n      && (MEM_readLE32(src) != ZSTD_MAGICNUMBER) ) {\n        if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {\n            /* skippable frame */\n            if (srcSize < ZSTD_SKIPPABLEHEADERSIZE)\n                return ZSTD_SKIPPABLEHEADERSIZE; /* magic number + frame length */\n            ZSTD_memset(zfhPtr, 0, sizeof(*zfhPtr));\n            zfhPtr->frameType = ZSTD_skippableFrame;\n            zfhPtr->dictID = MEM_readLE32(src) - ZSTD_MAGIC_SKIPPABLE_START;\n            zfhPtr->headerSize = ZSTD_SKIPPABLEHEADERSIZE;\n            zfhPtr->frameContentSize = MEM_readLE32((const char *)src + ZSTD_FRAMEIDSIZE);\n            return 0;\n        }\n        RETURN_ERROR(prefix_unknown, \"\");\n    }\n\n    /* ensure there is enough `srcSize` to fully read/decode frame header */\n    {   size_t const fhsize = ZSTD_frameHeaderSize_internal(src, srcSize, format);\n        if (srcSize < fhsize) return fhsize;\n        zfhPtr->headerSize = (U32)fhsize;\n    }\n\n    {   BYTE const fhdByte = ip[minInputSize-1];\n        size_t pos = minInputSize;\n        U32 const dictIDSizeCode = fhdByte&3;\n        U32 const checksumFlag = (fhdByte>>2)&1;\n        U32 const singleSegment = (fhdByte>>5)&1;\n        U32 const fcsID = fhdByte>>6;\n        U64 windowSize = 0;\n        U32 dictID = 0;\n        U64 frameContentSize = ZSTD_CONTENTSIZE_UNKNOWN;\n        RETURN_ERROR_IF((fhdByte & 0x08) != 0, frameParameter_unsupported,\n                        \"reserved bits, must be zero\");\n\n        if (!singleSegment) {\n            BYTE const wlByte = ip[pos++];\n            U32 const windowLog = (wlByte >> 3) + ZSTD_WINDOWLOG_ABSOLUTEMIN;\n            RETURN_ERROR_IF(windowLog > ZSTD_WINDOWLOG_MAX, frameParameter_windowTooLarge, \"\");\n            windowSize = (1ULL << windowLog);\n            windowSize += (windowSize >> 3) * (wlByte&7);\n        }\n        switch(dictIDSizeCode)\n        {\n            default:\n                assert(0);  /* impossible */\n                ZSTD_FALLTHROUGH;\n            case 0 : break;\n            case 1 : dictID = ip[pos]; pos++; break;\n            case 2 : dictID = MEM_readLE16(ip+pos); pos+=2; break;\n            case 3 : dictID = MEM_readLE32(ip+pos); pos+=4; break;\n        }\n        switch(fcsID)\n        {\n            default:\n                assert(0);  /* impossible */\n                ZSTD_FALLTHROUGH;\n            case 0 : if (singleSegment) frameContentSize = ip[pos]; break;\n            case 1 : frameContentSize = MEM_readLE16(ip+pos)+256; break;\n            case 2 : frameContentSize = MEM_readLE32(ip+pos); break;\n            case 3 : frameContentSize = MEM_readLE64(ip+pos); break;\n        }\n        if (singleSegment) windowSize = frameContentSize;\n\n        zfhPtr->frameType = ZSTD_frame;\n        zfhPtr->frameContentSize = frameContentSize;\n        zfhPtr->windowSize = windowSize;\n        zfhPtr->blockSizeMax = (unsigned) MIN(windowSize, ZSTD_BLOCKSIZE_MAX);\n        zfhPtr->dictID = dictID;\n        zfhPtr->checksumFlag = checksumFlag;\n    }\n    return 0;\n}\n\n/** ZSTD_getFrameHeader() :\n *  decode Frame Header, or require larger `srcSize`.\n *  note : this function does not consume input, it only reads it.\n * @return : 0, `zfhPtr` is correctly filled,\n *          >0, `srcSize` is too small, value is wanted `srcSize` amount,\n *           or an error code, which can be tested using ZSTD_isError() */\nsize_t ZSTD_getFrameHeader(ZSTD_FrameHeader* zfhPtr, const void* src, size_t srcSize)\n{\n    return ZSTD_getFrameHeader_advanced(zfhPtr, src, srcSize, ZSTD_f_zstd1);\n}\n\n/** ZSTD_getFrameContentSize() :\n *  compatible with legacy mode\n * @return : decompressed size of the single frame pointed to be `src` if known, otherwise\n *         - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined\n *         - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small) */\nunsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize)\n{\n#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)\n    if (ZSTD_isLegacy(src, srcSize)) {\n        unsigned long long const ret = ZSTD_getDecompressedSize_legacy(src, srcSize);\n        return ret == 0 ? ZSTD_CONTENTSIZE_UNKNOWN : ret;\n    }\n#endif\n    {   ZSTD_FrameHeader zfh;\n        if (ZSTD_getFrameHeader(&zfh, src, srcSize) != 0)\n            return ZSTD_CONTENTSIZE_ERROR;\n        if (zfh.frameType == ZSTD_skippableFrame) {\n            return 0;\n        } else {\n            return zfh.frameContentSize;\n    }   }\n}\n\nstatic size_t readSkippableFrameSize(void const* src, size_t srcSize)\n{\n    size_t const skippableHeaderSize = ZSTD_SKIPPABLEHEADERSIZE;\n    U32 sizeU32;\n\n    RETURN_ERROR_IF(srcSize < ZSTD_SKIPPABLEHEADERSIZE, srcSize_wrong, \"\");\n\n    sizeU32 = MEM_readLE32((BYTE const*)src + ZSTD_FRAMEIDSIZE);\n    RETURN_ERROR_IF((U32)(sizeU32 + ZSTD_SKIPPABLEHEADERSIZE) < sizeU32,\n                    frameParameter_unsupported, \"\");\n    {   size_t const skippableSize = skippableHeaderSize + sizeU32;\n        RETURN_ERROR_IF(skippableSize > srcSize, srcSize_wrong, \"\");\n        return skippableSize;\n    }\n}\n\n/*! ZSTD_readSkippableFrame() :\n * Retrieves content of a skippable frame, and writes it to dst buffer.\n *\n * The parameter magicVariant will receive the magicVariant that was supplied when the frame was written,\n * i.e. magicNumber - ZSTD_MAGIC_SKIPPABLE_START.  This can be NULL if the caller is not interested\n * in the magicVariant.\n *\n * Returns an error if destination buffer is not large enough, or if this is not a valid skippable frame.\n *\n * @return : number of bytes written or a ZSTD error.\n */\nsize_t ZSTD_readSkippableFrame(void* dst, size_t dstCapacity,\n                               unsigned* magicVariant,  /* optional, can be NULL */\n                         const void* src, size_t srcSize)\n{\n    RETURN_ERROR_IF(srcSize < ZSTD_SKIPPABLEHEADERSIZE, srcSize_wrong, \"\");\n\n    {   U32 const magicNumber = MEM_readLE32(src);\n        size_t skippableFrameSize = readSkippableFrameSize(src, srcSize);\n        size_t skippableContentSize = skippableFrameSize - ZSTD_SKIPPABLEHEADERSIZE;\n\n        /* check input validity */\n        RETURN_ERROR_IF(!ZSTD_isSkippableFrame(src, srcSize), frameParameter_unsupported, \"\");\n        RETURN_ERROR_IF(skippableFrameSize < ZSTD_SKIPPABLEHEADERSIZE || skippableFrameSize > srcSize, srcSize_wrong, \"\");\n        RETURN_ERROR_IF(skippableContentSize > dstCapacity, dstSize_tooSmall, \"\");\n\n        /* deliver payload */\n        if (skippableContentSize > 0  && dst != NULL)\n            ZSTD_memcpy(dst, (const BYTE *)src + ZSTD_SKIPPABLEHEADERSIZE, skippableContentSize);\n        if (magicVariant != NULL)\n            *magicVariant = magicNumber - ZSTD_MAGIC_SKIPPABLE_START;\n        return skippableContentSize;\n    }\n}\n\n/** ZSTD_findDecompressedSize() :\n *  `srcSize` must be the exact length of some number of ZSTD compressed and/or\n *      skippable frames\n *  note: compatible with legacy mode\n * @return : decompressed size of the frames contained */\nunsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize)\n{\n    unsigned long long totalDstSize = 0;\n\n    while (srcSize >= ZSTD_startingInputLength(ZSTD_f_zstd1)) {\n        U32 const magicNumber = MEM_readLE32(src);\n\n        if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {\n            size_t const skippableSize = readSkippableFrameSize(src, srcSize);\n            if (ZSTD_isError(skippableSize)) return ZSTD_CONTENTSIZE_ERROR;\n            assert(skippableSize <= srcSize);\n\n            src = (const BYTE *)src + skippableSize;\n            srcSize -= skippableSize;\n            continue;\n        }\n\n        {   unsigned long long const fcs = ZSTD_getFrameContentSize(src, srcSize);\n            if (fcs >= ZSTD_CONTENTSIZE_ERROR) return fcs;\n\n            if (totalDstSize + fcs < totalDstSize)\n                return ZSTD_CONTENTSIZE_ERROR; /* check for overflow */\n            totalDstSize += fcs;\n        }\n        /* skip to next frame */\n        {   size_t const frameSrcSize = ZSTD_findFrameCompressedSize(src, srcSize);\n            if (ZSTD_isError(frameSrcSize)) return ZSTD_CONTENTSIZE_ERROR;\n            assert(frameSrcSize <= srcSize);\n\n            src = (const BYTE *)src + frameSrcSize;\n            srcSize -= frameSrcSize;\n        }\n    }  /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */\n\n    if (srcSize) return ZSTD_CONTENTSIZE_ERROR;\n\n    return totalDstSize;\n}\n\n/** ZSTD_getDecompressedSize() :\n *  compatible with legacy mode\n * @return : decompressed size if known, 0 otherwise\n             note : 0 can mean any of the following :\n                   - frame content is empty\n                   - decompressed size field is not present in frame header\n                   - frame header unknown / not supported\n                   - frame header not complete (`srcSize` too small) */\nunsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize)\n{\n    unsigned long long const ret = ZSTD_getFrameContentSize(src, srcSize);\n    ZSTD_STATIC_ASSERT(ZSTD_CONTENTSIZE_ERROR < ZSTD_CONTENTSIZE_UNKNOWN);\n    return (ret >= ZSTD_CONTENTSIZE_ERROR) ? 0 : ret;\n}\n\n\n/** ZSTD_decodeFrameHeader() :\n * `headerSize` must be the size provided by ZSTD_frameHeaderSize().\n * If multiple DDict references are enabled, also will choose the correct DDict to use.\n * @return : 0 if success, or an error code, which can be tested using ZSTD_isError() */\nstatic size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* dctx, const void* src, size_t headerSize)\n{\n    size_t const result = ZSTD_getFrameHeader_advanced(&(dctx->fParams), src, headerSize, dctx->format);\n    if (ZSTD_isError(result)) return result;    /* invalid header */\n    RETURN_ERROR_IF(result>0, srcSize_wrong, \"headerSize too small\");\n\n    /* Reference DDict requested by frame if dctx references multiple ddicts */\n    if (dctx->refMultipleDDicts == ZSTD_rmd_refMultipleDDicts && dctx->ddictSet) {\n        ZSTD_DCtx_selectFrameDDict(dctx);\n    }\n\n#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION\n    /* Skip the dictID check in fuzzing mode, because it makes the search\n     * harder.\n     */\n    RETURN_ERROR_IF(dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID),\n                    dictionary_wrong, \"\");\n#endif\n    dctx->validateChecksum = (dctx->fParams.checksumFlag && !dctx->forceIgnoreChecksum) ? 1 : 0;\n    if (dctx->validateChecksum) XXH64_reset(&dctx->xxhState, 0);\n    dctx->processedCSize += headerSize;\n    return 0;\n}\n\nstatic ZSTD_frameSizeInfo ZSTD_errorFrameSizeInfo(size_t ret)\n{\n    ZSTD_frameSizeInfo frameSizeInfo;\n    frameSizeInfo.compressedSize = ret;\n    frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR;\n    return frameSizeInfo;\n}\n\nstatic ZSTD_frameSizeInfo ZSTD_findFrameSizeInfo(const void* src, size_t srcSize, ZSTD_format_e format)\n{\n    ZSTD_frameSizeInfo frameSizeInfo;\n    ZSTD_memset(&frameSizeInfo, 0, sizeof(ZSTD_frameSizeInfo));\n\n#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)\n    if (format == ZSTD_f_zstd1 && ZSTD_isLegacy(src, srcSize))\n        return ZSTD_findFrameSizeInfoLegacy(src, srcSize);\n#endif\n\n    if (format == ZSTD_f_zstd1 && (srcSize >= ZSTD_SKIPPABLEHEADERSIZE)\n        && (MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {\n        frameSizeInfo.compressedSize = readSkippableFrameSize(src, srcSize);\n        assert(ZSTD_isError(frameSizeInfo.compressedSize) ||\n               frameSizeInfo.compressedSize <= srcSize);\n        return frameSizeInfo;\n    } else {\n        const BYTE* ip = (const BYTE*)src;\n        const BYTE* const ipstart = ip;\n        size_t remainingSize = srcSize;\n        size_t nbBlocks = 0;\n        ZSTD_FrameHeader zfh;\n\n        /* Extract Frame Header */\n        {   size_t const ret = ZSTD_getFrameHeader_advanced(&zfh, src, srcSize, format);\n            if (ZSTD_isError(ret))\n                return ZSTD_errorFrameSizeInfo(ret);\n            if (ret > 0)\n                return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));\n        }\n\n        ip += zfh.headerSize;\n        remainingSize -= zfh.headerSize;\n\n        /* Iterate over each block */\n        while (1) {\n            blockProperties_t blockProperties;\n            size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties);\n            if (ZSTD_isError(cBlockSize))\n                return ZSTD_errorFrameSizeInfo(cBlockSize);\n\n            if (ZSTD_blockHeaderSize + cBlockSize > remainingSize)\n                return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));\n\n            ip += ZSTD_blockHeaderSize + cBlockSize;\n            remainingSize -= ZSTD_blockHeaderSize + cBlockSize;\n            nbBlocks++;\n\n            if (blockProperties.lastBlock) break;\n        }\n\n        /* Final frame content checksum */\n        if (zfh.checksumFlag) {\n            if (remainingSize < 4)\n                return ZSTD_errorFrameSizeInfo(ERROR(srcSize_wrong));\n            ip += 4;\n        }\n\n        frameSizeInfo.nbBlocks = nbBlocks;\n        frameSizeInfo.compressedSize = (size_t)(ip - ipstart);\n        frameSizeInfo.decompressedBound = (zfh.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN)\n                                        ? zfh.frameContentSize\n                                        : (unsigned long long)nbBlocks * zfh.blockSizeMax;\n        return frameSizeInfo;\n    }\n}\n\nstatic size_t ZSTD_findFrameCompressedSize_advanced(const void *src, size_t srcSize, ZSTD_format_e format) {\n    ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize, format);\n    return frameSizeInfo.compressedSize;\n}\n\n/** ZSTD_findFrameCompressedSize() :\n * See docs in zstd.h\n * Note: compatible with legacy mode */\nsize_t ZSTD_findFrameCompressedSize(const void *src, size_t srcSize)\n{\n    return ZSTD_findFrameCompressedSize_advanced(src, srcSize, ZSTD_f_zstd1);\n}\n\n/** ZSTD_decompressBound() :\n *  compatible with legacy mode\n *  `src` must point to the start of a ZSTD frame or a skippable frame\n *  `srcSize` must be at least as large as the frame contained\n *  @return : the maximum decompressed size of the compressed source\n */\nunsigned long long ZSTD_decompressBound(const void* src, size_t srcSize)\n{\n    unsigned long long bound = 0;\n    /* Iterate over each frame */\n    while (srcSize > 0) {\n        ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize, ZSTD_f_zstd1);\n        size_t const compressedSize = frameSizeInfo.compressedSize;\n        unsigned long long const decompressedBound = frameSizeInfo.decompressedBound;\n        if (ZSTD_isError(compressedSize) || decompressedBound == ZSTD_CONTENTSIZE_ERROR)\n            return ZSTD_CONTENTSIZE_ERROR;\n        assert(srcSize >= compressedSize);\n        src = (const BYTE*)src + compressedSize;\n        srcSize -= compressedSize;\n        bound += decompressedBound;\n    }\n    return bound;\n}\n\nsize_t ZSTD_decompressionMargin(void const* src, size_t srcSize)\n{\n    size_t margin = 0;\n    unsigned maxBlockSize = 0;\n\n    /* Iterate over each frame */\n    while (srcSize > 0) {\n        ZSTD_frameSizeInfo const frameSizeInfo = ZSTD_findFrameSizeInfo(src, srcSize, ZSTD_f_zstd1);\n        size_t const compressedSize = frameSizeInfo.compressedSize;\n        unsigned long long const decompressedBound = frameSizeInfo.decompressedBound;\n        ZSTD_FrameHeader zfh;\n\n        FORWARD_IF_ERROR(ZSTD_getFrameHeader(&zfh, src, srcSize), \"\");\n        if (ZSTD_isError(compressedSize) || decompressedBound == ZSTD_CONTENTSIZE_ERROR)\n            return ERROR(corruption_detected);\n\n        if (zfh.frameType == ZSTD_frame) {\n            /* Add the frame header to our margin */\n            margin += zfh.headerSize;\n            /* Add the checksum to our margin */\n            margin += zfh.checksumFlag ? 4 : 0;\n            /* Add 3 bytes per block */\n            margin += 3 * frameSizeInfo.nbBlocks;\n\n            /* Compute the max block size */\n            maxBlockSize = MAX(maxBlockSize, zfh.blockSizeMax);\n        } else {\n            assert(zfh.frameType == ZSTD_skippableFrame);\n            /* Add the entire skippable frame size to our margin. */\n            margin += compressedSize;\n        }\n\n        assert(srcSize >= compressedSize);\n        src = (const BYTE*)src + compressedSize;\n        srcSize -= compressedSize;\n    }\n\n    /* Add the max block size back to the margin. */\n    margin += maxBlockSize;\n\n    return margin;\n}\n\n/*-*************************************************************\n *   Frame decoding\n ***************************************************************/\n\n/** ZSTD_insertBlock() :\n *  insert `src` block into `dctx` history. Useful to track uncompressed blocks. */\nsize_t ZSTD_insertBlock(ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize)\n{\n    DEBUGLOG(5, \"ZSTD_insertBlock: %u bytes\", (unsigned)blockSize);\n    ZSTD_checkContinuity(dctx, blockStart, blockSize);\n    dctx->previousDstEnd = (const char*)blockStart + blockSize;\n    return blockSize;\n}\n\n\nstatic size_t ZSTD_copyRawBlock(void* dst, size_t dstCapacity,\n                          const void* src, size_t srcSize)\n{\n    DEBUGLOG(5, \"ZSTD_copyRawBlock\");\n    RETURN_ERROR_IF(srcSize > dstCapacity, dstSize_tooSmall, \"\");\n    if (dst == NULL) {\n        if (srcSize == 0) return 0;\n        RETURN_ERROR(dstBuffer_null, \"\");\n    }\n    ZSTD_memmove(dst, src, srcSize);\n    return srcSize;\n}\n\nstatic size_t ZSTD_setRleBlock(void* dst, size_t dstCapacity,\n                               BYTE b,\n                               size_t regenSize)\n{\n    RETURN_ERROR_IF(regenSize > dstCapacity, dstSize_tooSmall, \"\");\n    if (dst == NULL) {\n        if (regenSize == 0) return 0;\n        RETURN_ERROR(dstBuffer_null, \"\");\n    }\n    ZSTD_memset(dst, b, regenSize);\n    return regenSize;\n}\n\nstatic void ZSTD_DCtx_trace_end(ZSTD_DCtx const* dctx, U64 uncompressedSize, U64 compressedSize, int streaming)\n{\n#if ZSTD_TRACE\n    if (dctx->traceCtx && ZSTD_trace_decompress_end != NULL) {\n        ZSTD_Trace trace;\n        ZSTD_memset(&trace, 0, sizeof(trace));\n        trace.version = ZSTD_VERSION_NUMBER;\n        trace.streaming = streaming;\n        if (dctx->ddict) {\n            trace.dictionaryID = ZSTD_getDictID_fromDDict(dctx->ddict);\n            trace.dictionarySize = ZSTD_DDict_dictSize(dctx->ddict);\n            trace.dictionaryIsCold = dctx->ddictIsCold;\n        }\n        trace.uncompressedSize = (size_t)uncompressedSize;\n        trace.compressedSize = (size_t)compressedSize;\n        trace.dctx = dctx;\n        ZSTD_trace_decompress_end(dctx->traceCtx, &trace);\n    }\n#else\n    (void)dctx;\n    (void)uncompressedSize;\n    (void)compressedSize;\n    (void)streaming;\n#endif\n}\n\n\n/*! ZSTD_decompressFrame() :\n * @dctx must be properly initialized\n *  will update *srcPtr and *srcSizePtr,\n *  to make *srcPtr progress by one frame. */\nstatic size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,\n                                   void* dst, size_t dstCapacity,\n                             const void** srcPtr, size_t *srcSizePtr)\n{\n    const BYTE* const istart = (const BYTE*)(*srcPtr);\n    const BYTE* ip = istart;\n    BYTE* const ostart = (BYTE*)dst;\n    BYTE* const oend = dstCapacity != 0 ? ostart + dstCapacity : ostart;\n    BYTE* op = ostart;\n    size_t remainingSrcSize = *srcSizePtr;\n\n    DEBUGLOG(4, \"ZSTD_decompressFrame (srcSize:%i)\", (int)*srcSizePtr);\n\n    /* check */\n    RETURN_ERROR_IF(\n        remainingSrcSize < ZSTD_FRAMEHEADERSIZE_MIN(dctx->format)+ZSTD_blockHeaderSize,\n        srcSize_wrong, \"\");\n\n    /* Frame Header */\n    {   size_t const frameHeaderSize = ZSTD_frameHeaderSize_internal(\n                ip, ZSTD_FRAMEHEADERSIZE_PREFIX(dctx->format), dctx->format);\n        if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize;\n        RETURN_ERROR_IF(remainingSrcSize < frameHeaderSize+ZSTD_blockHeaderSize,\n                        srcSize_wrong, \"\");\n        FORWARD_IF_ERROR( ZSTD_decodeFrameHeader(dctx, ip, frameHeaderSize) , \"\");\n        ip += frameHeaderSize; remainingSrcSize -= frameHeaderSize;\n    }\n\n    /* Shrink the blockSizeMax if enabled */\n    if (dctx->maxBlockSizeParam != 0)\n        dctx->fParams.blockSizeMax = MIN(dctx->fParams.blockSizeMax, (unsigned)dctx->maxBlockSizeParam);\n\n    /* Loop on each block */\n    while (1) {\n        BYTE* oBlockEnd = oend;\n        size_t decodedSize;\n        blockProperties_t blockProperties;\n        size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSrcSize, &blockProperties);\n        if (ZSTD_isError(cBlockSize)) return cBlockSize;\n\n        ip += ZSTD_blockHeaderSize;\n        remainingSrcSize -= ZSTD_blockHeaderSize;\n        RETURN_ERROR_IF(cBlockSize > remainingSrcSize, srcSize_wrong, \"\");\n\n        if (ip >= op && ip < oBlockEnd) {\n            /* We are decompressing in-place. Limit the output pointer so that we\n             * don't overwrite the block that we are currently reading. This will\n             * fail decompression if the input & output pointers aren't spaced\n             * far enough apart.\n             *\n             * This is important to set, even when the pointers are far enough\n             * apart, because ZSTD_decompressBlock_internal() can decide to store\n             * literals in the output buffer, after the block it is decompressing.\n             * Since we don't want anything to overwrite our input, we have to tell\n             * ZSTD_decompressBlock_internal to never write past ip.\n             *\n             * See ZSTD_allocateLiteralsBuffer() for reference.\n             */\n            oBlockEnd = op + (ip - op);\n        }\n\n        switch(blockProperties.blockType)\n        {\n        case bt_compressed:\n            assert(dctx->isFrameDecompression == 1);\n            decodedSize = ZSTD_decompressBlock_internal(dctx, op, (size_t)(oBlockEnd-op), ip, cBlockSize, not_streaming);\n            break;\n        case bt_raw :\n            /* Use oend instead of oBlockEnd because this function is safe to overlap. It uses memmove. */\n            decodedSize = ZSTD_copyRawBlock(op, (size_t)(oend-op), ip, cBlockSize);\n            break;\n        case bt_rle :\n            decodedSize = ZSTD_setRleBlock(op, (size_t)(oBlockEnd-op), *ip, blockProperties.origSize);\n            break;\n        case bt_reserved :\n        default:\n            RETURN_ERROR(corruption_detected, \"invalid block type\");\n        }\n        FORWARD_IF_ERROR(decodedSize, \"Block decompression failure\");\n        DEBUGLOG(5, \"Decompressed block of dSize = %u\", (unsigned)decodedSize);\n        if (dctx->validateChecksum) {\n            XXH64_update(&dctx->xxhState, op, decodedSize);\n        }\n        if (decodedSize) /* support dst = NULL,0 */ {\n            op += decodedSize;\n        }\n        assert(ip != NULL);\n        ip += cBlockSize;\n        remainingSrcSize -= cBlockSize;\n        if (blockProperties.lastBlock) break;\n    }\n\n    if (dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN) {\n        RETURN_ERROR_IF((U64)(op-ostart) != dctx->fParams.frameContentSize,\n                        corruption_detected, \"\");\n    }\n    if (dctx->fParams.checksumFlag) { /* Frame content checksum verification */\n        RETURN_ERROR_IF(remainingSrcSize<4, checksum_wrong, \"\");\n        if (!dctx->forceIgnoreChecksum) {\n            U32 const checkCalc = (U32)XXH64_digest(&dctx->xxhState);\n            U32 checkRead;\n            checkRead = MEM_readLE32(ip);\n            RETURN_ERROR_IF(checkRead != checkCalc, checksum_wrong, \"\");\n        }\n        ip += 4;\n        remainingSrcSize -= 4;\n    }\n    ZSTD_DCtx_trace_end(dctx, (U64)(op-ostart), (U64)(ip-istart), /* streaming */ 0);\n    /* Allow caller to get size read */\n    DEBUGLOG(4, \"ZSTD_decompressFrame: decompressed frame of size %i, consuming %i bytes of input\", (int)(op-ostart), (int)(ip - (const BYTE*)*srcPtr));\n    *srcPtr = ip;\n    *srcSizePtr = remainingSrcSize;\n    return (size_t)(op-ostart);\n}\n\nstatic\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,\n                                        void* dst, size_t dstCapacity,\n                                  const void* src, size_t srcSize,\n                                  const void* dict, size_t dictSize,\n                                  const ZSTD_DDict* ddict)\n{\n    void* const dststart = dst;\n    int moreThan1Frame = 0;\n\n    DEBUGLOG(5, \"ZSTD_decompressMultiFrame\");\n    assert(dict==NULL || ddict==NULL);  /* either dict or ddict set, not both */\n\n    if (ddict) {\n        dict = ZSTD_DDict_dictContent(ddict);\n        dictSize = ZSTD_DDict_dictSize(ddict);\n    }\n\n    while (srcSize >= ZSTD_startingInputLength(dctx->format)) {\n\n#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)\n        if (dctx->format == ZSTD_f_zstd1 && ZSTD_isLegacy(src, srcSize)) {\n            size_t decodedSize;\n            size_t const frameSize = ZSTD_findFrameCompressedSizeLegacy(src, srcSize);\n            if (ZSTD_isError(frameSize)) return frameSize;\n            RETURN_ERROR_IF(dctx->staticSize, memory_allocation,\n                \"legacy support is not compatible with static dctx\");\n\n            decodedSize = ZSTD_decompressLegacy(dst, dstCapacity, src, frameSize, dict, dictSize);\n            if (ZSTD_isError(decodedSize)) return decodedSize;\n\n            {\n                unsigned long long const expectedSize = ZSTD_getFrameContentSize(src, srcSize);\n                RETURN_ERROR_IF(expectedSize == ZSTD_CONTENTSIZE_ERROR, corruption_detected, \"Corrupted frame header!\");\n                if (expectedSize != ZSTD_CONTENTSIZE_UNKNOWN) {\n                    RETURN_ERROR_IF(expectedSize != decodedSize, corruption_detected,\n                        \"Frame header size does not match decoded size!\");\n                }\n            }\n\n            assert(decodedSize <= dstCapacity);\n            dst = (BYTE*)dst + decodedSize;\n            dstCapacity -= decodedSize;\n\n            src = (const BYTE*)src + frameSize;\n            srcSize -= frameSize;\n\n            continue;\n        }\n#endif\n\n        if (dctx->format == ZSTD_f_zstd1 && srcSize >= 4) {\n            U32 const magicNumber = MEM_readLE32(src);\n            DEBUGLOG(5, \"reading magic number %08X\", (unsigned)magicNumber);\n            if ((magicNumber & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {\n                /* skippable frame detected : skip it */\n                size_t const skippableSize = readSkippableFrameSize(src, srcSize);\n                FORWARD_IF_ERROR(skippableSize, \"invalid skippable frame\");\n                assert(skippableSize <= srcSize);\n\n                src = (const BYTE *)src + skippableSize;\n                srcSize -= skippableSize;\n                continue; /* check next frame */\n        }   }\n\n        if (ddict) {\n            /* we were called from ZSTD_decompress_usingDDict */\n            FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(dctx, ddict), \"\");\n        } else {\n            /* this will initialize correctly with no dict if dict == NULL, so\n             * use this in all cases but ddict */\n            FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDict(dctx, dict, dictSize), \"\");\n        }\n        ZSTD_checkContinuity(dctx, dst, dstCapacity);\n\n        {   const size_t res = ZSTD_decompressFrame(dctx, dst, dstCapacity,\n                                                    &src, &srcSize);\n            RETURN_ERROR_IF(\n                (ZSTD_getErrorCode(res) == ZSTD_error_prefix_unknown)\n             && (moreThan1Frame==1),\n                srcSize_wrong,\n                \"At least one frame successfully completed, \"\n                \"but following bytes are garbage: \"\n                \"it's more likely to be a srcSize error, \"\n                \"specifying more input bytes than size of frame(s). \"\n                \"Note: one could be unlucky, it might be a corruption error instead, \"\n                \"happening right at the place where we expect zstd magic bytes. \"\n                \"But this is _much_ less likely than a srcSize field error.\");\n            if (ZSTD_isError(res)) return res;\n            assert(res <= dstCapacity);\n            if (res != 0)\n                dst = (BYTE*)dst + res;\n            dstCapacity -= res;\n        }\n        moreThan1Frame = 1;\n    }  /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */\n\n    RETURN_ERROR_IF(srcSize, srcSize_wrong, \"input not entirely consumed\");\n\n    return (size_t)((BYTE*)dst - (BYTE*)dststart);\n}\n\nsize_t ZSTD_decompress_usingDict(ZSTD_DCtx* dctx,\n                                 void* dst, size_t dstCapacity,\n                           const void* src, size_t srcSize,\n                           const void* dict, size_t dictSize)\n{\n    return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize, dict, dictSize, NULL);\n}\n\n\nstatic ZSTD_DDict const* ZSTD_getDDict(ZSTD_DCtx* dctx)\n{\n    switch (dctx->dictUses) {\n    default:\n        assert(0 /* Impossible */);\n        ZSTD_FALLTHROUGH;\n    case ZSTD_dont_use:\n        ZSTD_clearDict(dctx);\n        return NULL;\n    case ZSTD_use_indefinitely:\n        return dctx->ddict;\n    case ZSTD_use_once:\n        dctx->dictUses = ZSTD_dont_use;\n        return dctx->ddict;\n    }\n}\n\nsize_t ZSTD_decompressDCtx(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)\n{\n    return ZSTD_decompress_usingDDict(dctx, dst, dstCapacity, src, srcSize, ZSTD_getDDict(dctx));\n}\n\n\nsize_t ZSTD_decompress(void* dst, size_t dstCapacity, const void* src, size_t srcSize)\n{\n#if defined(ZSTD_HEAPMODE) && (ZSTD_HEAPMODE>=1)\n    size_t regenSize;\n    ZSTD_DCtx* const dctx =  ZSTD_createDCtx_internal(ZSTD_defaultCMem);\n    RETURN_ERROR_IF(dctx==NULL, memory_allocation, \"NULL pointer!\");\n    regenSize = ZSTD_decompressDCtx(dctx, dst, dstCapacity, src, srcSize);\n    ZSTD_freeDCtx(dctx);\n    return regenSize;\n#else   /* stack mode */\n    ZSTD_DCtx dctx;\n    ZSTD_initDCtx_internal(&dctx);\n    return ZSTD_decompressDCtx(&dctx, dst, dstCapacity, src, srcSize);\n#endif\n}\n\n\n/*-**************************************\n*   Advanced Streaming Decompression API\n*   Bufferless and synchronous\n****************************************/\nsize_t ZSTD_nextSrcSizeToDecompress(ZSTD_DCtx* dctx) { return dctx->expected; }\n\n/**\n * Similar to ZSTD_nextSrcSizeToDecompress(), but when a block input can be streamed, we\n * allow taking a partial block as the input. Currently only raw uncompressed blocks can\n * be streamed.\n *\n * For blocks that can be streamed, this allows us to reduce the latency until we produce\n * output, and avoid copying the input.\n *\n * @param inputSize - The total amount of input that the caller currently has.\n */\nstatic size_t ZSTD_nextSrcSizeToDecompressWithInputSize(ZSTD_DCtx* dctx, size_t inputSize) {\n    if (!(dctx->stage == ZSTDds_decompressBlock || dctx->stage == ZSTDds_decompressLastBlock))\n        return dctx->expected;\n    if (dctx->bType != bt_raw)\n        return dctx->expected;\n    return BOUNDED(1, inputSize, dctx->expected);\n}\n\nZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx) {\n    switch(dctx->stage)\n    {\n    default:   /* should not happen */\n        assert(0);\n        ZSTD_FALLTHROUGH;\n    case ZSTDds_getFrameHeaderSize:\n        ZSTD_FALLTHROUGH;\n    case ZSTDds_decodeFrameHeader:\n        return ZSTDnit_frameHeader;\n    case ZSTDds_decodeBlockHeader:\n        return ZSTDnit_blockHeader;\n    case ZSTDds_decompressBlock:\n        return ZSTDnit_block;\n    case ZSTDds_decompressLastBlock:\n        return ZSTDnit_lastBlock;\n    case ZSTDds_checkChecksum:\n        return ZSTDnit_checksum;\n    case ZSTDds_decodeSkippableHeader:\n        ZSTD_FALLTHROUGH;\n    case ZSTDds_skipFrame:\n        return ZSTDnit_skippableFrame;\n    }\n}\n\nstatic int ZSTD_isSkipFrame(ZSTD_DCtx* dctx) { return dctx->stage == ZSTDds_skipFrame; }\n\n/** ZSTD_decompressContinue() :\n *  srcSize : must be the exact nb of bytes expected (see ZSTD_nextSrcSizeToDecompress())\n *  @return : nb of bytes generated into `dst` (necessarily <= `dstCapacity)\n *            or an error code, which can be tested using ZSTD_isError() */\nsize_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)\n{\n    DEBUGLOG(5, \"ZSTD_decompressContinue (srcSize:%u)\", (unsigned)srcSize);\n    /* Sanity check */\n    RETURN_ERROR_IF(srcSize != ZSTD_nextSrcSizeToDecompressWithInputSize(dctx, srcSize), srcSize_wrong, \"not allowed\");\n    ZSTD_checkContinuity(dctx, dst, dstCapacity);\n\n    dctx->processedCSize += srcSize;\n\n    switch (dctx->stage)\n    {\n    case ZSTDds_getFrameHeaderSize :\n        assert(src != NULL);\n        if (dctx->format == ZSTD_f_zstd1) {  /* allows header */\n            assert(srcSize >= ZSTD_FRAMEIDSIZE);  /* to read skippable magic number */\n            if ((MEM_readLE32(src) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {        /* skippable frame */\n                ZSTD_memcpy(dctx->headerBuffer, src, srcSize);\n                dctx->expected = ZSTD_SKIPPABLEHEADERSIZE - srcSize;  /* remaining to load to get full skippable frame header */\n                dctx->stage = ZSTDds_decodeSkippableHeader;\n                return 0;\n        }   }\n        dctx->headerSize = ZSTD_frameHeaderSize_internal(src, srcSize, dctx->format);\n        if (ZSTD_isError(dctx->headerSize)) return dctx->headerSize;\n        ZSTD_memcpy(dctx->headerBuffer, src, srcSize);\n        dctx->expected = dctx->headerSize - srcSize;\n        dctx->stage = ZSTDds_decodeFrameHeader;\n        return 0;\n\n    case ZSTDds_decodeFrameHeader:\n        assert(src != NULL);\n        ZSTD_memcpy(dctx->headerBuffer + (dctx->headerSize - srcSize), src, srcSize);\n        FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(dctx, dctx->headerBuffer, dctx->headerSize), \"\");\n        dctx->expected = ZSTD_blockHeaderSize;\n        dctx->stage = ZSTDds_decodeBlockHeader;\n        return 0;\n\n    case ZSTDds_decodeBlockHeader:\n        {   blockProperties_t bp;\n            size_t const cBlockSize = ZSTD_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);\n            if (ZSTD_isError(cBlockSize)) return cBlockSize;\n            RETURN_ERROR_IF(cBlockSize > dctx->fParams.blockSizeMax, corruption_detected, \"Block Size Exceeds Maximum\");\n            dctx->expected = cBlockSize;\n            dctx->bType = bp.blockType;\n            dctx->rleSize = bp.origSize;\n            if (cBlockSize) {\n                dctx->stage = bp.lastBlock ? ZSTDds_decompressLastBlock : ZSTDds_decompressBlock;\n                return 0;\n            }\n            /* empty block */\n            if (bp.lastBlock) {\n                if (dctx->fParams.checksumFlag) {\n                    dctx->expected = 4;\n                    dctx->stage = ZSTDds_checkChecksum;\n                } else {\n                    dctx->expected = 0; /* end of frame */\n                    dctx->stage = ZSTDds_getFrameHeaderSize;\n                }\n            } else {\n                dctx->expected = ZSTD_blockHeaderSize;  /* jump to next header */\n                dctx->stage = ZSTDds_decodeBlockHeader;\n            }\n            return 0;\n        }\n\n    case ZSTDds_decompressLastBlock:\n    case ZSTDds_decompressBlock:\n        DEBUGLOG(5, \"ZSTD_decompressContinue: case ZSTDds_decompressBlock\");\n        {   size_t rSize;\n            switch(dctx->bType)\n            {\n            case bt_compressed:\n                DEBUGLOG(5, \"ZSTD_decompressContinue: case bt_compressed\");\n                assert(dctx->isFrameDecompression == 1);\n                rSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, is_streaming);\n                dctx->expected = 0;  /* Streaming not supported */\n                break;\n            case bt_raw :\n                assert(srcSize <= dctx->expected);\n                rSize = ZSTD_copyRawBlock(dst, dstCapacity, src, srcSize);\n                FORWARD_IF_ERROR(rSize, \"ZSTD_copyRawBlock failed\");\n                assert(rSize == srcSize);\n                dctx->expected -= rSize;\n                break;\n            case bt_rle :\n                rSize = ZSTD_setRleBlock(dst, dstCapacity, *(const BYTE*)src, dctx->rleSize);\n                dctx->expected = 0;  /* Streaming not supported */\n                break;\n            case bt_reserved :   /* should never happen */\n            default:\n                RETURN_ERROR(corruption_detected, \"invalid block type\");\n            }\n            FORWARD_IF_ERROR(rSize, \"\");\n            RETURN_ERROR_IF(rSize > dctx->fParams.blockSizeMax, corruption_detected, \"Decompressed Block Size Exceeds Maximum\");\n            DEBUGLOG(5, \"ZSTD_decompressContinue: decoded size from block : %u\", (unsigned)rSize);\n            dctx->decodedSize += rSize;\n            if (dctx->validateChecksum) XXH64_update(&dctx->xxhState, dst, rSize);\n            dctx->previousDstEnd = (char*)dst + rSize;\n\n            /* Stay on the same stage until we are finished streaming the block. */\n            if (dctx->expected > 0) {\n                return rSize;\n            }\n\n            if (dctx->stage == ZSTDds_decompressLastBlock) {   /* end of frame */\n                DEBUGLOG(4, \"ZSTD_decompressContinue: decoded size from frame : %u\", (unsigned)dctx->decodedSize);\n                RETURN_ERROR_IF(\n                    dctx->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN\n                 && dctx->decodedSize != dctx->fParams.frameContentSize,\n                    corruption_detected, \"\");\n                if (dctx->fParams.checksumFlag) {  /* another round for frame checksum */\n                    dctx->expected = 4;\n                    dctx->stage = ZSTDds_checkChecksum;\n                } else {\n                    ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, /* streaming */ 1);\n                    dctx->expected = 0;   /* ends here */\n                    dctx->stage = ZSTDds_getFrameHeaderSize;\n                }\n            } else {\n                dctx->stage = ZSTDds_decodeBlockHeader;\n                dctx->expected = ZSTD_blockHeaderSize;\n            }\n            return rSize;\n        }\n\n    case ZSTDds_checkChecksum:\n        assert(srcSize == 4);  /* guaranteed by dctx->expected */\n        {\n            if (dctx->validateChecksum) {\n                U32 const h32 = (U32)XXH64_digest(&dctx->xxhState);\n                U32 const check32 = MEM_readLE32(src);\n                DEBUGLOG(4, \"ZSTD_decompressContinue: checksum : calculated %08X :: %08X read\", (unsigned)h32, (unsigned)check32);\n                RETURN_ERROR_IF(check32 != h32, checksum_wrong, \"\");\n            }\n            ZSTD_DCtx_trace_end(dctx, dctx->decodedSize, dctx->processedCSize, /* streaming */ 1);\n            dctx->expected = 0;\n            dctx->stage = ZSTDds_getFrameHeaderSize;\n            return 0;\n        }\n\n    case ZSTDds_decodeSkippableHeader:\n        assert(src != NULL);\n        assert(srcSize <= ZSTD_SKIPPABLEHEADERSIZE);\n        assert(dctx->format != ZSTD_f_zstd1_magicless);\n        ZSTD_memcpy(dctx->headerBuffer + (ZSTD_SKIPPABLEHEADERSIZE - srcSize), src, srcSize);   /* complete skippable header */\n        dctx->expected = MEM_readLE32(dctx->headerBuffer + ZSTD_FRAMEIDSIZE);   /* note : dctx->expected can grow seriously large, beyond local buffer size */\n        dctx->stage = ZSTDds_skipFrame;\n        return 0;\n\n    case ZSTDds_skipFrame:\n        dctx->expected = 0;\n        dctx->stage = ZSTDds_getFrameHeaderSize;\n        return 0;\n\n    default:\n        assert(0);   /* impossible */\n        RETURN_ERROR(GENERIC, \"impossible to reach\");   /* some compilers require default to do something */\n    }\n}\n\n\nstatic size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)\n{\n    dctx->dictEnd = dctx->previousDstEnd;\n    dctx->virtualStart = (const char*)dict - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));\n    dctx->prefixStart = dict;\n    dctx->previousDstEnd = (const char*)dict + dictSize;\n#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION\n    dctx->dictContentBeginForFuzzing = dctx->prefixStart;\n    dctx->dictContentEndForFuzzing = dctx->previousDstEnd;\n#endif\n    return 0;\n}\n\n/*! ZSTD_loadDEntropy() :\n *  dict : must point at beginning of a valid zstd dictionary.\n * @return : size of entropy tables read */\nsize_t\nZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,\n                  const void* const dict, size_t const dictSize)\n{\n    const BYTE* dictPtr = (const BYTE*)dict;\n    const BYTE* const dictEnd = dictPtr + dictSize;\n\n    RETURN_ERROR_IF(dictSize <= 8, dictionary_corrupted, \"dict is too small\");\n    assert(MEM_readLE32(dict) == ZSTD_MAGIC_DICTIONARY);   /* dict must be valid */\n    dictPtr += 8;   /* skip header = magic + dictID */\n\n    ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, OFTable) == offsetof(ZSTD_entropyDTables_t, LLTable) + sizeof(entropy->LLTable));\n    ZSTD_STATIC_ASSERT(offsetof(ZSTD_entropyDTables_t, MLTable) == offsetof(ZSTD_entropyDTables_t, OFTable) + sizeof(entropy->OFTable));\n    ZSTD_STATIC_ASSERT(sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable) >= HUF_DECOMPRESS_WORKSPACE_SIZE);\n    {   void* const workspace = &entropy->LLTable;   /* use fse tables as temporary workspace; implies fse tables are grouped together */\n        size_t const workspaceSize = sizeof(entropy->LLTable) + sizeof(entropy->OFTable) + sizeof(entropy->MLTable);\n#ifdef HUF_FORCE_DECOMPRESS_X1\n        /* in minimal huffman, we always use X1 variants */\n        size_t const hSize = HUF_readDTableX1_wksp(entropy->hufTable,\n                                                dictPtr, dictEnd - dictPtr,\n                                                workspace, workspaceSize, /* flags */ 0);\n#else\n        size_t const hSize = HUF_readDTableX2_wksp(entropy->hufTable,\n                                                dictPtr, (size_t)(dictEnd - dictPtr),\n                                                workspace, workspaceSize, /* flags */ 0);\n#endif\n        RETURN_ERROR_IF(HUF_isError(hSize), dictionary_corrupted, \"\");\n        dictPtr += hSize;\n    }\n\n    {   short offcodeNCount[MaxOff+1];\n        unsigned offcodeMaxValue = MaxOff, offcodeLog;\n        size_t const offcodeHeaderSize = FSE_readNCount(offcodeNCount, &offcodeMaxValue, &offcodeLog, dictPtr, (size_t)(dictEnd-dictPtr));\n        RETURN_ERROR_IF(FSE_isError(offcodeHeaderSize), dictionary_corrupted, \"\");\n        RETURN_ERROR_IF(offcodeMaxValue > MaxOff, dictionary_corrupted, \"\");\n        RETURN_ERROR_IF(offcodeLog > OffFSELog, dictionary_corrupted, \"\");\n        ZSTD_buildFSETable( entropy->OFTable,\n                            offcodeNCount, offcodeMaxValue,\n                            OF_base, OF_bits,\n                            offcodeLog,\n                            entropy->workspace, sizeof(entropy->workspace),\n                            /* bmi2 */0);\n        dictPtr += offcodeHeaderSize;\n    }\n\n    {   short matchlengthNCount[MaxML+1];\n        unsigned matchlengthMaxValue = MaxML, matchlengthLog;\n        size_t const matchlengthHeaderSize = FSE_readNCount(matchlengthNCount, &matchlengthMaxValue, &matchlengthLog, dictPtr, (size_t)(dictEnd-dictPtr));\n        RETURN_ERROR_IF(FSE_isError(matchlengthHeaderSize), dictionary_corrupted, \"\");\n        RETURN_ERROR_IF(matchlengthMaxValue > MaxML, dictionary_corrupted, \"\");\n        RETURN_ERROR_IF(matchlengthLog > MLFSELog, dictionary_corrupted, \"\");\n        ZSTD_buildFSETable( entropy->MLTable,\n                            matchlengthNCount, matchlengthMaxValue,\n                            ML_base, ML_bits,\n                            matchlengthLog,\n                            entropy->workspace, sizeof(entropy->workspace),\n                            /* bmi2 */ 0);\n        dictPtr += matchlengthHeaderSize;\n    }\n\n    {   short litlengthNCount[MaxLL+1];\n        unsigned litlengthMaxValue = MaxLL, litlengthLog;\n        size_t const litlengthHeaderSize = FSE_readNCount(litlengthNCount, &litlengthMaxValue, &litlengthLog, dictPtr, (size_t)(dictEnd-dictPtr));\n        RETURN_ERROR_IF(FSE_isError(litlengthHeaderSize), dictionary_corrupted, \"\");\n        RETURN_ERROR_IF(litlengthMaxValue > MaxLL, dictionary_corrupted, \"\");\n        RETURN_ERROR_IF(litlengthLog > LLFSELog, dictionary_corrupted, \"\");\n        ZSTD_buildFSETable( entropy->LLTable,\n                            litlengthNCount, litlengthMaxValue,\n                            LL_base, LL_bits,\n                            litlengthLog,\n                            entropy->workspace, sizeof(entropy->workspace),\n                            /* bmi2 */ 0);\n        dictPtr += litlengthHeaderSize;\n    }\n\n    RETURN_ERROR_IF(dictPtr+12 > dictEnd, dictionary_corrupted, \"\");\n    {   int i;\n        size_t const dictContentSize = (size_t)(dictEnd - (dictPtr+12));\n        for (i=0; i<3; i++) {\n            U32 const rep = MEM_readLE32(dictPtr); dictPtr += 4;\n            RETURN_ERROR_IF(rep==0 || rep > dictContentSize,\n                            dictionary_corrupted, \"\");\n            entropy->rep[i] = rep;\n    }   }\n\n    return (size_t)(dictPtr - (const BYTE*)dict);\n}\n\nstatic size_t ZSTD_decompress_insertDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)\n{\n    if (dictSize < 8) return ZSTD_refDictContent(dctx, dict, dictSize);\n    {   U32 const magic = MEM_readLE32(dict);\n        if (magic != ZSTD_MAGIC_DICTIONARY) {\n            return ZSTD_refDictContent(dctx, dict, dictSize);   /* pure content mode */\n    }   }\n    dctx->dictID = MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);\n\n    /* load entropy tables */\n    {   size_t const eSize = ZSTD_loadDEntropy(&dctx->entropy, dict, dictSize);\n        RETURN_ERROR_IF(ZSTD_isError(eSize), dictionary_corrupted, \"\");\n        dict = (const char*)dict + eSize;\n        dictSize -= eSize;\n    }\n    dctx->litEntropy = dctx->fseEntropy = 1;\n\n    /* reference dictionary content */\n    return ZSTD_refDictContent(dctx, dict, dictSize);\n}\n\nsize_t ZSTD_decompressBegin(ZSTD_DCtx* dctx)\n{\n    assert(dctx != NULL);\n#if ZSTD_TRACE\n    dctx->traceCtx = (ZSTD_trace_decompress_begin != NULL) ? ZSTD_trace_decompress_begin(dctx) : 0;\n#endif\n    dctx->expected = ZSTD_startingInputLength(dctx->format);  /* dctx->format must be properly set */\n    dctx->stage = ZSTDds_getFrameHeaderSize;\n    dctx->processedCSize = 0;\n    dctx->decodedSize = 0;\n    dctx->previousDstEnd = NULL;\n    dctx->prefixStart = NULL;\n    dctx->virtualStart = NULL;\n    dctx->dictEnd = NULL;\n    dctx->entropy.hufTable[0] = (HUF_DTable)((ZSTD_HUFFDTABLE_CAPACITY_LOG)*0x1000001);  /* cover both little and big endian */\n    dctx->litEntropy = dctx->fseEntropy = 0;\n    dctx->dictID = 0;\n    dctx->bType = bt_reserved;\n    dctx->isFrameDecompression = 1;\n    ZSTD_STATIC_ASSERT(sizeof(dctx->entropy.rep) == sizeof(repStartValue));\n    ZSTD_memcpy(dctx->entropy.rep, repStartValue, sizeof(repStartValue));  /* initial repcodes */\n    dctx->LLTptr = dctx->entropy.LLTable;\n    dctx->MLTptr = dctx->entropy.MLTable;\n    dctx->OFTptr = dctx->entropy.OFTable;\n    dctx->HUFptr = dctx->entropy.hufTable;\n    return 0;\n}\n\nsize_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)\n{\n    FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , \"\");\n    if (dict && dictSize)\n        RETURN_ERROR_IF(\n            ZSTD_isError(ZSTD_decompress_insertDictionary(dctx, dict, dictSize)),\n            dictionary_corrupted, \"\");\n    return 0;\n}\n\n\n/* ======   ZSTD_DDict   ====== */\n\nsize_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)\n{\n    DEBUGLOG(4, \"ZSTD_decompressBegin_usingDDict\");\n    assert(dctx != NULL);\n    if (ddict) {\n        const char* const dictStart = (const char*)ZSTD_DDict_dictContent(ddict);\n        size_t const dictSize = ZSTD_DDict_dictSize(ddict);\n        const void* const dictEnd = dictStart + dictSize;\n        dctx->ddictIsCold = (dctx->dictEnd != dictEnd);\n        DEBUGLOG(4, \"DDict is %s\",\n                    dctx->ddictIsCold ? \"~cold~\" : \"hot!\");\n    }\n    FORWARD_IF_ERROR( ZSTD_decompressBegin(dctx) , \"\");\n    if (ddict) {   /* NULL ddict is equivalent to no dictionary */\n        ZSTD_copyDDictParameters(dctx, ddict);\n    }\n    return 0;\n}\n\n/*! ZSTD_getDictID_fromDict() :\n *  Provides the dictID stored within dictionary.\n *  if @return == 0, the dictionary is not conformant with Zstandard specification.\n *  It can still be loaded, but as a content-only dictionary. */\nunsigned ZSTD_getDictID_fromDict(const void* dict, size_t dictSize)\n{\n    if (dictSize < 8) return 0;\n    if (MEM_readLE32(dict) != ZSTD_MAGIC_DICTIONARY) return 0;\n    return MEM_readLE32((const char*)dict + ZSTD_FRAMEIDSIZE);\n}\n\n/*! ZSTD_getDictID_fromFrame() :\n *  Provides the dictID required to decompress frame stored within `src`.\n *  If @return == 0, the dictID could not be decoded.\n *  This could for one of the following reasons :\n *  - The frame does not require a dictionary (most common case).\n *  - The frame was built with dictID intentionally removed.\n *    Needed dictionary is a hidden piece of information.\n *    Note : this use case also happens when using a non-conformant dictionary.\n *  - `srcSize` is too small, and as a result, frame header could not be decoded.\n *    Note : possible if `srcSize < ZSTD_FRAMEHEADERSIZE_MAX`.\n *  - This is not a Zstandard frame.\n *  When identifying the exact failure cause, it's possible to use\n *  ZSTD_getFrameHeader(), which will provide a more precise error code. */\nunsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize)\n{\n    ZSTD_FrameHeader zfp = { 0, 0, 0, ZSTD_frame, 0, 0, 0, 0, 0 };\n    size_t const hError = ZSTD_getFrameHeader(&zfp, src, srcSize);\n    if (ZSTD_isError(hError)) return 0;\n    return zfp.dictID;\n}\n\n\n/*! ZSTD_decompress_usingDDict() :\n*   Decompression using a pre-digested Dictionary\n*   Use dictionary without significant overhead. */\nsize_t ZSTD_decompress_usingDDict(ZSTD_DCtx* dctx,\n                                  void* dst, size_t dstCapacity,\n                            const void* src, size_t srcSize,\n                            const ZSTD_DDict* ddict)\n{\n    /* pass content and size in case legacy frames are encountered */\n    return ZSTD_decompressMultiFrame(dctx, dst, dstCapacity, src, srcSize,\n                                     NULL, 0,\n                                     ddict);\n}\n\n\n/*=====================================\n*   Streaming decompression\n*====================================*/\n\nZSTD_DStream* ZSTD_createDStream(void)\n{\n    DEBUGLOG(3, \"ZSTD_createDStream\");\n    return ZSTD_createDCtx_internal(ZSTD_defaultCMem);\n}\n\nZSTD_DStream* ZSTD_initStaticDStream(void *workspace, size_t workspaceSize)\n{\n    return ZSTD_initStaticDCtx(workspace, workspaceSize);\n}\n\nZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem)\n{\n    return ZSTD_createDCtx_internal(customMem);\n}\n\nsize_t ZSTD_freeDStream(ZSTD_DStream* zds)\n{\n    return ZSTD_freeDCtx(zds);\n}\n\n\n/* ***  Initialization  *** */\n\nsize_t ZSTD_DStreamInSize(void)  { return ZSTD_BLOCKSIZE_MAX + ZSTD_blockHeaderSize; }\nsize_t ZSTD_DStreamOutSize(void) { return ZSTD_BLOCKSIZE_MAX; }\n\nsize_t ZSTD_DCtx_loadDictionary_advanced(ZSTD_DCtx* dctx,\n                                   const void* dict, size_t dictSize,\n                                         ZSTD_dictLoadMethod_e dictLoadMethod,\n                                         ZSTD_dictContentType_e dictContentType)\n{\n    RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, \"\");\n    ZSTD_clearDict(dctx);\n    if (dict && dictSize != 0) {\n        dctx->ddictLocal = ZSTD_createDDict_advanced(dict, dictSize, dictLoadMethod, dictContentType, dctx->customMem);\n        RETURN_ERROR_IF(dctx->ddictLocal == NULL, memory_allocation, \"NULL pointer!\");\n        dctx->ddict = dctx->ddictLocal;\n        dctx->dictUses = ZSTD_use_indefinitely;\n    }\n    return 0;\n}\n\nsize_t ZSTD_DCtx_loadDictionary_byReference(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)\n{\n    return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byRef, ZSTD_dct_auto);\n}\n\nsize_t ZSTD_DCtx_loadDictionary(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)\n{\n    return ZSTD_DCtx_loadDictionary_advanced(dctx, dict, dictSize, ZSTD_dlm_byCopy, ZSTD_dct_auto);\n}\n\nsize_t ZSTD_DCtx_refPrefix_advanced(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize, ZSTD_dictContentType_e dictContentType)\n{\n    FORWARD_IF_ERROR(ZSTD_DCtx_loadDictionary_advanced(dctx, prefix, prefixSize, ZSTD_dlm_byRef, dictContentType), \"\");\n    dctx->dictUses = ZSTD_use_once;\n    return 0;\n}\n\nsize_t ZSTD_DCtx_refPrefix(ZSTD_DCtx* dctx, const void* prefix, size_t prefixSize)\n{\n    return ZSTD_DCtx_refPrefix_advanced(dctx, prefix, prefixSize, ZSTD_dct_rawContent);\n}\n\n\n/* ZSTD_initDStream_usingDict() :\n * return : expected size, aka ZSTD_startingInputLength().\n * this function cannot fail */\nsize_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize)\n{\n    DEBUGLOG(4, \"ZSTD_initDStream_usingDict\");\n    FORWARD_IF_ERROR( ZSTD_DCtx_reset(zds, ZSTD_reset_session_only) , \"\");\n    FORWARD_IF_ERROR( ZSTD_DCtx_loadDictionary(zds, dict, dictSize) , \"\");\n    return ZSTD_startingInputLength(zds->format);\n}\n\n/* note : this variant can't fail */\nsize_t ZSTD_initDStream(ZSTD_DStream* zds)\n{\n    DEBUGLOG(4, \"ZSTD_initDStream\");\n    FORWARD_IF_ERROR(ZSTD_DCtx_reset(zds, ZSTD_reset_session_only), \"\");\n    FORWARD_IF_ERROR(ZSTD_DCtx_refDDict(zds, NULL), \"\");\n    return ZSTD_startingInputLength(zds->format);\n}\n\n/* ZSTD_initDStream_usingDDict() :\n * ddict will just be referenced, and must outlive decompression session\n * this function cannot fail */\nsize_t ZSTD_initDStream_usingDDict(ZSTD_DStream* dctx, const ZSTD_DDict* ddict)\n{\n    DEBUGLOG(4, \"ZSTD_initDStream_usingDDict\");\n    FORWARD_IF_ERROR( ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only) , \"\");\n    FORWARD_IF_ERROR( ZSTD_DCtx_refDDict(dctx, ddict) , \"\");\n    return ZSTD_startingInputLength(dctx->format);\n}\n\n/* ZSTD_resetDStream() :\n * return : expected size, aka ZSTD_startingInputLength().\n * this function cannot fail */\nsize_t ZSTD_resetDStream(ZSTD_DStream* dctx)\n{\n    DEBUGLOG(4, \"ZSTD_resetDStream\");\n    FORWARD_IF_ERROR(ZSTD_DCtx_reset(dctx, ZSTD_reset_session_only), \"\");\n    return ZSTD_startingInputLength(dctx->format);\n}\n\n\nsize_t ZSTD_DCtx_refDDict(ZSTD_DCtx* dctx, const ZSTD_DDict* ddict)\n{\n    RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, \"\");\n    ZSTD_clearDict(dctx);\n    if (ddict) {\n        dctx->ddict = ddict;\n        dctx->dictUses = ZSTD_use_indefinitely;\n        if (dctx->refMultipleDDicts == ZSTD_rmd_refMultipleDDicts) {\n            if (dctx->ddictSet == NULL) {\n                dctx->ddictSet = ZSTD_createDDictHashSet(dctx->customMem);\n                if (!dctx->ddictSet) {\n                    RETURN_ERROR(memory_allocation, \"Failed to allocate memory for hash set!\");\n                }\n            }\n            assert(!dctx->staticSize);  /* Impossible: ddictSet cannot have been allocated if static dctx */\n            FORWARD_IF_ERROR(ZSTD_DDictHashSet_addDDict(dctx->ddictSet, ddict, dctx->customMem), \"\");\n        }\n    }\n    return 0;\n}\n\n/* ZSTD_DCtx_setMaxWindowSize() :\n * note : no direct equivalence in ZSTD_DCtx_setParameter,\n * since this version sets windowSize, and the other sets windowLog */\nsize_t ZSTD_DCtx_setMaxWindowSize(ZSTD_DCtx* dctx, size_t maxWindowSize)\n{\n    ZSTD_bounds const bounds = ZSTD_dParam_getBounds(ZSTD_d_windowLogMax);\n    size_t const min = (size_t)1 << bounds.lowerBound;\n    size_t const max = (size_t)1 << bounds.upperBound;\n    RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, \"\");\n    RETURN_ERROR_IF(maxWindowSize < min, parameter_outOfBound, \"\");\n    RETURN_ERROR_IF(maxWindowSize > max, parameter_outOfBound, \"\");\n    dctx->maxWindowSize = maxWindowSize;\n    return 0;\n}\n\nsize_t ZSTD_DCtx_setFormat(ZSTD_DCtx* dctx, ZSTD_format_e format)\n{\n    return ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, (int)format);\n}\n\nZSTD_bounds ZSTD_dParam_getBounds(ZSTD_dParameter dParam)\n{\n    ZSTD_bounds bounds = { 0, 0, 0 };\n    switch(dParam) {\n        case ZSTD_d_windowLogMax:\n            bounds.lowerBound = ZSTD_WINDOWLOG_ABSOLUTEMIN;\n            bounds.upperBound = ZSTD_WINDOWLOG_MAX;\n            return bounds;\n        case ZSTD_d_format:\n            bounds.lowerBound = (int)ZSTD_f_zstd1;\n            bounds.upperBound = (int)ZSTD_f_zstd1_magicless;\n            ZSTD_STATIC_ASSERT(ZSTD_f_zstd1 < ZSTD_f_zstd1_magicless);\n            return bounds;\n        case ZSTD_d_stableOutBuffer:\n            bounds.lowerBound = (int)ZSTD_bm_buffered;\n            bounds.upperBound = (int)ZSTD_bm_stable;\n            return bounds;\n        case ZSTD_d_forceIgnoreChecksum:\n            bounds.lowerBound = (int)ZSTD_d_validateChecksum;\n            bounds.upperBound = (int)ZSTD_d_ignoreChecksum;\n            return bounds;\n        case ZSTD_d_refMultipleDDicts:\n            bounds.lowerBound = (int)ZSTD_rmd_refSingleDDict;\n            bounds.upperBound = (int)ZSTD_rmd_refMultipleDDicts;\n            return bounds;\n        case ZSTD_d_disableHuffmanAssembly:\n            bounds.lowerBound = 0;\n            bounds.upperBound = 1;\n            return bounds;\n        case ZSTD_d_maxBlockSize:\n            bounds.lowerBound = ZSTD_BLOCKSIZE_MAX_MIN;\n            bounds.upperBound = ZSTD_BLOCKSIZE_MAX;\n            return bounds;\n\n        default:;\n    }\n    bounds.error = ERROR(parameter_unsupported);\n    return bounds;\n}\n\n/* ZSTD_dParam_withinBounds:\n * @return 1 if value is within dParam bounds,\n * 0 otherwise */\nstatic int ZSTD_dParam_withinBounds(ZSTD_dParameter dParam, int value)\n{\n    ZSTD_bounds const bounds = ZSTD_dParam_getBounds(dParam);\n    if (ZSTD_isError(bounds.error)) return 0;\n    if (value < bounds.lowerBound) return 0;\n    if (value > bounds.upperBound) return 0;\n    return 1;\n}\n\n#define CHECK_DBOUNDS(p,v) {                \\\n    RETURN_ERROR_IF(!ZSTD_dParam_withinBounds(p, v), parameter_outOfBound, \"\"); \\\n}\n\nsize_t ZSTD_DCtx_getParameter(ZSTD_DCtx* dctx, ZSTD_dParameter param, int* value)\n{\n    switch (param) {\n        case ZSTD_d_windowLogMax:\n            *value = (int)ZSTD_highbit32((U32)dctx->maxWindowSize);\n            return 0;\n        case ZSTD_d_format:\n            *value = (int)dctx->format;\n            return 0;\n        case ZSTD_d_stableOutBuffer:\n            *value = (int)dctx->outBufferMode;\n            return 0;\n        case ZSTD_d_forceIgnoreChecksum:\n            *value = (int)dctx->forceIgnoreChecksum;\n            return 0;\n        case ZSTD_d_refMultipleDDicts:\n            *value = (int)dctx->refMultipleDDicts;\n            return 0;\n        case ZSTD_d_disableHuffmanAssembly:\n            *value = (int)dctx->disableHufAsm;\n            return 0;\n        case ZSTD_d_maxBlockSize:\n            *value = dctx->maxBlockSizeParam;\n            return 0;\n        default:;\n    }\n    RETURN_ERROR(parameter_unsupported, \"\");\n}\n\nsize_t ZSTD_DCtx_setParameter(ZSTD_DCtx* dctx, ZSTD_dParameter dParam, int value)\n{\n    RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, \"\");\n    switch(dParam) {\n        case ZSTD_d_windowLogMax:\n            if (value == 0) value = ZSTD_WINDOWLOG_LIMIT_DEFAULT;\n            CHECK_DBOUNDS(ZSTD_d_windowLogMax, value);\n            dctx->maxWindowSize = ((size_t)1) << value;\n            return 0;\n        case ZSTD_d_format:\n            CHECK_DBOUNDS(ZSTD_d_format, value);\n            dctx->format = (ZSTD_format_e)value;\n            return 0;\n        case ZSTD_d_stableOutBuffer:\n            CHECK_DBOUNDS(ZSTD_d_stableOutBuffer, value);\n            dctx->outBufferMode = (ZSTD_bufferMode_e)value;\n            return 0;\n        case ZSTD_d_forceIgnoreChecksum:\n            CHECK_DBOUNDS(ZSTD_d_forceIgnoreChecksum, value);\n            dctx->forceIgnoreChecksum = (ZSTD_forceIgnoreChecksum_e)value;\n            return 0;\n        case ZSTD_d_refMultipleDDicts:\n            CHECK_DBOUNDS(ZSTD_d_refMultipleDDicts, value);\n            if (dctx->staticSize != 0) {\n                RETURN_ERROR(parameter_unsupported, \"Static dctx does not support multiple DDicts!\");\n            }\n            dctx->refMultipleDDicts = (ZSTD_refMultipleDDicts_e)value;\n            return 0;\n        case ZSTD_d_disableHuffmanAssembly:\n            CHECK_DBOUNDS(ZSTD_d_disableHuffmanAssembly, value);\n            dctx->disableHufAsm = value != 0;\n            return 0;\n        case ZSTD_d_maxBlockSize:\n            if (value != 0) CHECK_DBOUNDS(ZSTD_d_maxBlockSize, value);\n            dctx->maxBlockSizeParam = value;\n            return 0;\n        default:;\n    }\n    RETURN_ERROR(parameter_unsupported, \"\");\n}\n\nsize_t ZSTD_DCtx_reset(ZSTD_DCtx* dctx, ZSTD_ResetDirective reset)\n{\n    if ( (reset == ZSTD_reset_session_only)\n      || (reset == ZSTD_reset_session_and_parameters) ) {\n        dctx->streamStage = zdss_init;\n        dctx->noForwardProgress = 0;\n        dctx->isFrameDecompression = 1;\n    }\n    if ( (reset == ZSTD_reset_parameters)\n      || (reset == ZSTD_reset_session_and_parameters) ) {\n        RETURN_ERROR_IF(dctx->streamStage != zdss_init, stage_wrong, \"\");\n        ZSTD_clearDict(dctx);\n        ZSTD_DCtx_resetParameters(dctx);\n    }\n    return 0;\n}\n\n\nsize_t ZSTD_sizeof_DStream(const ZSTD_DStream* dctx)\n{\n    return ZSTD_sizeof_DCtx(dctx);\n}\n\nstatic size_t ZSTD_decodingBufferSize_internal(unsigned long long windowSize, unsigned long long frameContentSize, size_t blockSizeMax)\n{\n    size_t const blockSize = MIN((size_t)MIN(windowSize, ZSTD_BLOCKSIZE_MAX), blockSizeMax);\n    /* We need blockSize + WILDCOPY_OVERLENGTH worth of buffer so that if a block\n     * ends at windowSize + WILDCOPY_OVERLENGTH + 1 bytes, we can start writing\n     * the block at the beginning of the output buffer, and maintain a full window.\n     *\n     * We need another blockSize worth of buffer so that we can store split\n     * literals at the end of the block without overwriting the extDict window.\n     */\n    unsigned long long const neededRBSize = windowSize + (blockSize * 2) + (WILDCOPY_OVERLENGTH * 2);\n    unsigned long long const neededSize = MIN(frameContentSize, neededRBSize);\n    size_t const minRBSize = (size_t) neededSize;\n    RETURN_ERROR_IF((unsigned long long)minRBSize != neededSize,\n                    frameParameter_windowTooLarge, \"\");\n    return minRBSize;\n}\n\nsize_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize)\n{\n    return ZSTD_decodingBufferSize_internal(windowSize, frameContentSize, ZSTD_BLOCKSIZE_MAX);\n}\n\nsize_t ZSTD_estimateDStreamSize(size_t windowSize)\n{\n    size_t const blockSize = MIN(windowSize, ZSTD_BLOCKSIZE_MAX);\n    size_t const inBuffSize = blockSize;  /* no block can be larger */\n    size_t const outBuffSize = ZSTD_decodingBufferSize_min(windowSize, ZSTD_CONTENTSIZE_UNKNOWN);\n    return ZSTD_estimateDCtxSize() + inBuffSize + outBuffSize;\n}\n\nsize_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize)\n{\n    U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX;   /* note : should be user-selectable, but requires an additional parameter (or a dctx) */\n    ZSTD_FrameHeader zfh;\n    size_t const err = ZSTD_getFrameHeader(&zfh, src, srcSize);\n    if (ZSTD_isError(err)) return err;\n    RETURN_ERROR_IF(err>0, srcSize_wrong, \"\");\n    RETURN_ERROR_IF(zfh.windowSize > windowSizeMax,\n                    frameParameter_windowTooLarge, \"\");\n    return ZSTD_estimateDStreamSize((size_t)zfh.windowSize);\n}\n\n\n/* *****   Decompression   ***** */\n\nstatic int ZSTD_DCtx_isOverflow(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize)\n{\n    return (zds->inBuffSize + zds->outBuffSize) >= (neededInBuffSize + neededOutBuffSize) * ZSTD_WORKSPACETOOLARGE_FACTOR;\n}\n\nstatic void ZSTD_DCtx_updateOversizedDuration(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize)\n{\n    if (ZSTD_DCtx_isOverflow(zds, neededInBuffSize, neededOutBuffSize))\n        zds->oversizedDuration++;\n    else\n        zds->oversizedDuration = 0;\n}\n\nstatic int ZSTD_DCtx_isOversizedTooLong(ZSTD_DStream* zds)\n{\n    return zds->oversizedDuration >= ZSTD_WORKSPACETOOLARGE_MAXDURATION;\n}\n\n/* Checks that the output buffer hasn't changed if ZSTD_obm_stable is used. */\nstatic size_t ZSTD_checkOutBuffer(ZSTD_DStream const* zds, ZSTD_outBuffer const* output)\n{\n    ZSTD_outBuffer const expect = zds->expectedOutBuffer;\n    /* No requirement when ZSTD_obm_stable is not enabled. */\n    if (zds->outBufferMode != ZSTD_bm_stable)\n        return 0;\n    /* Any buffer is allowed in zdss_init, this must be the same for every other call until\n     * the context is reset.\n     */\n    if (zds->streamStage == zdss_init)\n        return 0;\n    /* The buffer must match our expectation exactly. */\n    if (expect.dst == output->dst && expect.pos == output->pos && expect.size == output->size)\n        return 0;\n    RETURN_ERROR(dstBuffer_wrong, \"ZSTD_d_stableOutBuffer enabled but output differs!\");\n}\n\n/* Calls ZSTD_decompressContinue() with the right parameters for ZSTD_decompressStream()\n * and updates the stage and the output buffer state. This call is extracted so it can be\n * used both when reading directly from the ZSTD_inBuffer, and in buffered input mode.\n * NOTE: You must break after calling this function since the streamStage is modified.\n */\nstatic size_t ZSTD_decompressContinueStream(\n            ZSTD_DStream* zds, char** op, char* oend,\n            void const* src, size_t srcSize) {\n    int const isSkipFrame = ZSTD_isSkipFrame(zds);\n    if (zds->outBufferMode == ZSTD_bm_buffered) {\n        size_t const dstSize = isSkipFrame ? 0 : zds->outBuffSize - zds->outStart;\n        size_t const decodedSize = ZSTD_decompressContinue(zds,\n                zds->outBuff + zds->outStart, dstSize, src, srcSize);\n        FORWARD_IF_ERROR(decodedSize, \"\");\n        if (!decodedSize && !isSkipFrame) {\n            zds->streamStage = zdss_read;\n        } else {\n            zds->outEnd = zds->outStart + decodedSize;\n            zds->streamStage = zdss_flush;\n        }\n    } else {\n        /* Write directly into the output buffer */\n        size_t const dstSize = isSkipFrame ? 0 : (size_t)(oend - *op);\n        size_t const decodedSize = ZSTD_decompressContinue(zds, *op, dstSize, src, srcSize);\n        FORWARD_IF_ERROR(decodedSize, \"\");\n        *op += decodedSize;\n        /* Flushing is not needed. */\n        zds->streamStage = zdss_read;\n        assert(*op <= oend);\n        assert(zds->outBufferMode == ZSTD_bm_stable);\n    }\n    return 0;\n}\n\nsize_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input)\n{\n    const char* const src = (const char*)input->src;\n    const char* const istart = input->pos != 0 ? src + input->pos : src;\n    const char* const iend = input->size != 0 ? src + input->size : src;\n    const char* ip = istart;\n    char* const dst = (char*)output->dst;\n    char* const ostart = output->pos != 0 ? dst + output->pos : dst;\n    char* const oend = output->size != 0 ? dst + output->size : dst;\n    char* op = ostart;\n    U32 someMoreWork = 1;\n\n    DEBUGLOG(5, \"ZSTD_decompressStream\");\n    assert(zds != NULL);\n    RETURN_ERROR_IF(\n        input->pos > input->size,\n        srcSize_wrong,\n        \"forbidden. in: pos: %u   vs size: %u\",\n        (U32)input->pos, (U32)input->size);\n    RETURN_ERROR_IF(\n        output->pos > output->size,\n        dstSize_tooSmall,\n        \"forbidden. out: pos: %u   vs size: %u\",\n        (U32)output->pos, (U32)output->size);\n    DEBUGLOG(5, \"input size : %u\", (U32)(input->size - input->pos));\n    FORWARD_IF_ERROR(ZSTD_checkOutBuffer(zds, output), \"\");\n\n    while (someMoreWork) {\n        switch(zds->streamStage)\n        {\n        case zdss_init :\n            DEBUGLOG(5, \"stage zdss_init => transparent reset \");\n            zds->streamStage = zdss_loadHeader;\n            zds->lhSize = zds->inPos = zds->outStart = zds->outEnd = 0;\n#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)\n            zds->legacyVersion = 0;\n#endif\n            zds->hostageByte = 0;\n            zds->expectedOutBuffer = *output;\n            ZSTD_FALLTHROUGH;\n\n        case zdss_loadHeader :\n            DEBUGLOG(5, \"stage zdss_loadHeader (srcSize : %u)\", (U32)(iend - ip));\n#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)\n            if (zds->legacyVersion) {\n                RETURN_ERROR_IF(zds->staticSize, memory_allocation,\n                    \"legacy support is incompatible with static dctx\");\n                {   size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, zds->legacyVersion, output, input);\n                    if (hint==0) zds->streamStage = zdss_init;\n                    return hint;\n            }   }\n#endif\n            {   size_t const hSize = ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format);\n                if (zds->refMultipleDDicts && zds->ddictSet) {\n                    ZSTD_DCtx_selectFrameDDict(zds);\n                }\n                if (ZSTD_isError(hSize)) {\n#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)\n                    U32 const legacyVersion = ZSTD_isLegacy(istart, iend-istart);\n                    if (legacyVersion) {\n                        ZSTD_DDict const* const ddict = ZSTD_getDDict(zds);\n                        const void* const dict = ddict ? ZSTD_DDict_dictContent(ddict) : NULL;\n                        size_t const dictSize = ddict ? ZSTD_DDict_dictSize(ddict) : 0;\n                        DEBUGLOG(5, \"ZSTD_decompressStream: detected legacy version v0.%u\", legacyVersion);\n                        RETURN_ERROR_IF(zds->staticSize, memory_allocation,\n                            \"legacy support is incompatible with static dctx\");\n                        FORWARD_IF_ERROR(ZSTD_initLegacyStream(&zds->legacyContext,\n                                    zds->previousLegacyVersion, legacyVersion,\n                                    dict, dictSize), \"\");\n                        zds->legacyVersion = zds->previousLegacyVersion = legacyVersion;\n                        {   size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, legacyVersion, output, input);\n                            if (hint==0) zds->streamStage = zdss_init;   /* or stay in stage zdss_loadHeader */\n                            return hint;\n                    }   }\n#endif\n                    return hSize;   /* error */\n                }\n                if (hSize != 0) {   /* need more input */\n                    size_t const toLoad = hSize - zds->lhSize;   /* if hSize!=0, hSize > zds->lhSize */\n                    size_t const remainingInput = (size_t)(iend-ip);\n                    assert(iend >= ip);\n                    if (toLoad > remainingInput) {   /* not enough input to load full header */\n                        if (remainingInput > 0) {\n                            ZSTD_memcpy(zds->headerBuffer + zds->lhSize, ip, remainingInput);\n                            zds->lhSize += remainingInput;\n                        }\n                        input->pos = input->size;\n                        /* check first few bytes */\n                        FORWARD_IF_ERROR(\n                            ZSTD_getFrameHeader_advanced(&zds->fParams, zds->headerBuffer, zds->lhSize, zds->format),\n                            \"First few bytes detected incorrect\" );\n                        /* return hint input size */\n                        return (MAX((size_t)ZSTD_FRAMEHEADERSIZE_MIN(zds->format), hSize) - zds->lhSize) + ZSTD_blockHeaderSize;   /* remaining header bytes + next block header */\n                    }\n                    assert(ip != NULL);\n                    ZSTD_memcpy(zds->headerBuffer + zds->lhSize, ip, toLoad); zds->lhSize = hSize; ip += toLoad;\n                    break;\n            }   }\n\n            /* check for single-pass mode opportunity */\n            if (zds->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN\n                && zds->fParams.frameType != ZSTD_skippableFrame\n                && (U64)(size_t)(oend-op) >= zds->fParams.frameContentSize) {\n                size_t const cSize = ZSTD_findFrameCompressedSize_advanced(istart, (size_t)(iend-istart), zds->format);\n                if (cSize <= (size_t)(iend-istart)) {\n                    /* shortcut : using single-pass mode */\n                    size_t const decompressedSize = ZSTD_decompress_usingDDict(zds, op, (size_t)(oend-op), istart, cSize, ZSTD_getDDict(zds));\n                    if (ZSTD_isError(decompressedSize)) return decompressedSize;\n                    DEBUGLOG(4, \"shortcut to single-pass ZSTD_decompress_usingDDict()\");\n                    assert(istart != NULL);\n                    ip = istart + cSize;\n                    op = op ? op + decompressedSize : op; /* can occur if frameContentSize = 0 (empty frame) */\n                    zds->expected = 0;\n                    zds->streamStage = zdss_init;\n                    someMoreWork = 0;\n                    break;\n            }   }\n\n            /* Check output buffer is large enough for ZSTD_odm_stable. */\n            if (zds->outBufferMode == ZSTD_bm_stable\n                && zds->fParams.frameType != ZSTD_skippableFrame\n                && zds->fParams.frameContentSize != ZSTD_CONTENTSIZE_UNKNOWN\n                && (U64)(size_t)(oend-op) < zds->fParams.frameContentSize) {\n                RETURN_ERROR(dstSize_tooSmall, \"ZSTD_obm_stable passed but ZSTD_outBuffer is too small\");\n            }\n\n            /* Consume header (see ZSTDds_decodeFrameHeader) */\n            DEBUGLOG(4, \"Consume header\");\n            FORWARD_IF_ERROR(ZSTD_decompressBegin_usingDDict(zds, ZSTD_getDDict(zds)), \"\");\n\n            if (zds->format == ZSTD_f_zstd1\n                && (MEM_readLE32(zds->headerBuffer) & ZSTD_MAGIC_SKIPPABLE_MASK) == ZSTD_MAGIC_SKIPPABLE_START) {  /* skippable frame */\n                zds->expected = MEM_readLE32(zds->headerBuffer + ZSTD_FRAMEIDSIZE);\n                zds->stage = ZSTDds_skipFrame;\n            } else {\n                FORWARD_IF_ERROR(ZSTD_decodeFrameHeader(zds, zds->headerBuffer, zds->lhSize), \"\");\n                zds->expected = ZSTD_blockHeaderSize;\n                zds->stage = ZSTDds_decodeBlockHeader;\n            }\n\n            /* control buffer memory usage */\n            DEBUGLOG(4, \"Control max memory usage (%u KB <= max %u KB)\",\n                        (U32)(zds->fParams.windowSize >>10),\n                        (U32)(zds->maxWindowSize >> 10) );\n            zds->fParams.windowSize = MAX(zds->fParams.windowSize, 1U << ZSTD_WINDOWLOG_ABSOLUTEMIN);\n            RETURN_ERROR_IF(zds->fParams.windowSize > zds->maxWindowSize,\n                            frameParameter_windowTooLarge, \"\");\n            if (zds->maxBlockSizeParam != 0)\n                zds->fParams.blockSizeMax = MIN(zds->fParams.blockSizeMax, (unsigned)zds->maxBlockSizeParam);\n\n            /* Adapt buffer sizes to frame header instructions */\n            {   size_t const neededInBuffSize = MAX(zds->fParams.blockSizeMax, 4 /* frame checksum */);\n                size_t const neededOutBuffSize = zds->outBufferMode == ZSTD_bm_buffered\n                        ? ZSTD_decodingBufferSize_internal(zds->fParams.windowSize, zds->fParams.frameContentSize, zds->fParams.blockSizeMax)\n                        : 0;\n\n                ZSTD_DCtx_updateOversizedDuration(zds, neededInBuffSize, neededOutBuffSize);\n\n                {   int const tooSmall = (zds->inBuffSize < neededInBuffSize) || (zds->outBuffSize < neededOutBuffSize);\n                    int const tooLarge = ZSTD_DCtx_isOversizedTooLong(zds);\n\n                    if (tooSmall || tooLarge) {\n                        size_t const bufferSize = neededInBuffSize + neededOutBuffSize;\n                        DEBUGLOG(4, \"inBuff  : from %u to %u\",\n                                    (U32)zds->inBuffSize, (U32)neededInBuffSize);\n                        DEBUGLOG(4, \"outBuff : from %u to %u\",\n                                    (U32)zds->outBuffSize, (U32)neededOutBuffSize);\n                        if (zds->staticSize) {  /* static DCtx */\n                            DEBUGLOG(4, \"staticSize : %u\", (U32)zds->staticSize);\n                            assert(zds->staticSize >= sizeof(ZSTD_DCtx));  /* controlled at init */\n                            RETURN_ERROR_IF(\n                                bufferSize > zds->staticSize - sizeof(ZSTD_DCtx),\n                                memory_allocation, \"\");\n                        } else {\n                            ZSTD_customFree(zds->inBuff, zds->customMem);\n                            zds->inBuffSize = 0;\n                            zds->outBuffSize = 0;\n                            zds->inBuff = (char*)ZSTD_customMalloc(bufferSize, zds->customMem);\n                            RETURN_ERROR_IF(zds->inBuff == NULL, memory_allocation, \"\");\n                        }\n                        zds->inBuffSize = neededInBuffSize;\n                        zds->outBuff = zds->inBuff + zds->inBuffSize;\n                        zds->outBuffSize = neededOutBuffSize;\n            }   }   }\n            zds->streamStage = zdss_read;\n            ZSTD_FALLTHROUGH;\n\n        case zdss_read:\n            DEBUGLOG(5, \"stage zdss_read\");\n            {   size_t const neededInSize = ZSTD_nextSrcSizeToDecompressWithInputSize(zds, (size_t)(iend - ip));\n                DEBUGLOG(5, \"neededInSize = %u\", (U32)neededInSize);\n                if (neededInSize==0) {  /* end of frame */\n                    zds->streamStage = zdss_init;\n                    someMoreWork = 0;\n                    break;\n                }\n                if ((size_t)(iend-ip) >= neededInSize) {  /* decode directly from src */\n                    FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, ip, neededInSize), \"\");\n                    assert(ip != NULL);\n                    ip += neededInSize;\n                    /* Function modifies the stage so we must break */\n                    break;\n            }   }\n            if (ip==iend) { someMoreWork = 0; break; }   /* no more input */\n            zds->streamStage = zdss_load;\n            ZSTD_FALLTHROUGH;\n\n        case zdss_load:\n            {   size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zds);\n                size_t const toLoad = neededInSize - zds->inPos;\n                int const isSkipFrame = ZSTD_isSkipFrame(zds);\n                size_t loadedSize;\n                /* At this point we shouldn't be decompressing a block that we can stream. */\n                assert(neededInSize == ZSTD_nextSrcSizeToDecompressWithInputSize(zds, (size_t)(iend - ip)));\n                if (isSkipFrame) {\n                    loadedSize = MIN(toLoad, (size_t)(iend-ip));\n                } else {\n                    RETURN_ERROR_IF(toLoad > zds->inBuffSize - zds->inPos,\n                                    corruption_detected,\n                                    \"should never happen\");\n                    loadedSize = ZSTD_limitCopy(zds->inBuff + zds->inPos, toLoad, ip, (size_t)(iend-ip));\n                }\n                if (loadedSize != 0) {\n                    /* ip may be NULL */\n                    ip += loadedSize;\n                    zds->inPos += loadedSize;\n                }\n                if (loadedSize < toLoad) { someMoreWork = 0; break; }   /* not enough input, wait for more */\n\n                /* decode loaded input */\n                zds->inPos = 0;   /* input is consumed */\n                FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, zds->inBuff, neededInSize), \"\");\n                /* Function modifies the stage so we must break */\n                break;\n            }\n        case zdss_flush:\n            {\n                size_t const toFlushSize = zds->outEnd - zds->outStart;\n                size_t const flushedSize = ZSTD_limitCopy(op, (size_t)(oend-op), zds->outBuff + zds->outStart, toFlushSize);\n\n                op = op ? op + flushedSize : op;\n\n                zds->outStart += flushedSize;\n                if (flushedSize == toFlushSize) {  /* flush completed */\n                    zds->streamStage = zdss_read;\n                    if ( (zds->outBuffSize < zds->fParams.frameContentSize)\n                        && (zds->outStart + zds->fParams.blockSizeMax > zds->outBuffSize) ) {\n                        DEBUGLOG(5, \"restart filling outBuff from beginning (left:%i, needed:%u)\",\n                                (int)(zds->outBuffSize - zds->outStart),\n                                (U32)zds->fParams.blockSizeMax);\n                        zds->outStart = zds->outEnd = 0;\n                    }\n                    break;\n            }   }\n            /* cannot complete flush */\n            someMoreWork = 0;\n            break;\n\n        default:\n            assert(0);    /* impossible */\n            RETURN_ERROR(GENERIC, \"impossible to reach\");   /* some compilers require default to do something */\n    }   }\n\n    /* result */\n    input->pos = (size_t)(ip - (const char*)(input->src));\n    output->pos = (size_t)(op - (char*)(output->dst));\n\n    /* Update the expected output buffer for ZSTD_obm_stable. */\n    zds->expectedOutBuffer = *output;\n\n    if ((ip==istart) && (op==ostart)) {  /* no forward progress */\n        zds->noForwardProgress ++;\n        if (zds->noForwardProgress >= ZSTD_NO_FORWARD_PROGRESS_MAX) {\n            RETURN_ERROR_IF(op==oend, noForwardProgress_destFull, \"\");\n            RETURN_ERROR_IF(ip==iend, noForwardProgress_inputEmpty, \"\");\n            assert(0);\n        }\n    } else {\n        zds->noForwardProgress = 0;\n    }\n    {   size_t nextSrcSizeHint = ZSTD_nextSrcSizeToDecompress(zds);\n        if (!nextSrcSizeHint) {   /* frame fully decoded */\n            if (zds->outEnd == zds->outStart) {  /* output fully flushed */\n                if (zds->hostageByte) {\n                    if (input->pos >= input->size) {\n                        /* can't release hostage (not present) */\n                        zds->streamStage = zdss_read;\n                        return 1;\n                    }\n                    input->pos++;  /* release hostage */\n                }   /* zds->hostageByte */\n                return 0;\n            }  /* zds->outEnd == zds->outStart */\n            if (!zds->hostageByte) { /* output not fully flushed; keep last byte as hostage; will be released when all output is flushed */\n                input->pos--;   /* note : pos > 0, otherwise, impossible to finish reading last block */\n                zds->hostageByte=1;\n            }\n            return 1;\n        }  /* nextSrcSizeHint==0 */\n        nextSrcSizeHint += ZSTD_blockHeaderSize * (ZSTD_nextInputType(zds) == ZSTDnit_block);   /* preload header of next block */\n        assert(zds->inPos <= nextSrcSizeHint);\n        nextSrcSizeHint -= zds->inPos;   /* part already loaded*/\n        return nextSrcSizeHint;\n    }\n}\n\nsize_t ZSTD_decompressStream_simpleArgs (\n                            ZSTD_DCtx* dctx,\n                            void* dst, size_t dstCapacity, size_t* dstPos,\n                      const void* src, size_t srcSize, size_t* srcPos)\n{\n    ZSTD_outBuffer output;\n    ZSTD_inBuffer  input;\n    output.dst = dst;\n    output.size = dstCapacity;\n    output.pos = *dstPos;\n    input.src = src;\n    input.size = srcSize;\n    input.pos = *srcPos;\n    {   size_t const cErr = ZSTD_decompressStream(dctx, &output, &input);\n        *dstPos = output.pos;\n        *srcPos = input.pos;\n        return cErr;\n    }\n}\n"
  },
  {
    "path": "lib/decompress/zstd_decompress_block.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/* zstd_decompress_block :\n * this module takes care of decompressing _compressed_ block */\n\n/*-*******************************************************\n*  Dependencies\n*********************************************************/\n#include \"../common/zstd_deps.h\"   /* ZSTD_memcpy, ZSTD_memmove, ZSTD_memset */\n#include \"../common/compiler.h\"    /* prefetch */\n#include \"../common/mem.h\"         /* low level memory routines */\n#include \n#define FSE_STATIC_LINKING_ONLY\n#include \"../common/fse.h\"\n#include \"../common/huf.h\"\n#include \"../common/zstd_internal.h\"\n#include \"zstd_decompress_internal.h\"   /* ZSTD_DCtx */\n#include \"zstd_decompress_block.h\"\n#include \"../common/bits.h\"  /* ZSTD_highbit32 */\n\n/*_*******************************************************\n*  Macros\n**********************************************************/\n\n/* These two optional macros force the use one way or another of the two\n * ZSTD_decompressSequences implementations. You can't force in both directions\n * at the same time.\n */\n#if defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \\\n    defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)\n#error \"Cannot force the use of the short and the long ZSTD_decompressSequences variants!\"\n#endif\n\n\n/*_*******************************************************\n*  Memory operations\n**********************************************************/\nstatic void ZSTD_copy4(void* dst, const void* src) { ZSTD_memcpy(dst, src, 4); }\n\n\n/*-*************************************************************\n *   Block decoding\n ***************************************************************/\n\nstatic size_t ZSTD_blockSizeMax(ZSTD_DCtx const* dctx)\n{\n    size_t const blockSizeMax = dctx->isFrameDecompression ? dctx->fParams.blockSizeMax : ZSTD_BLOCKSIZE_MAX;\n    assert(blockSizeMax <= ZSTD_BLOCKSIZE_MAX);\n    return blockSizeMax;\n}\n\n/*! ZSTD_getcBlockSize() :\n *  Provides the size of compressed block from block header `src` */\nsize_t ZSTD_getcBlockSize(const void* src, size_t srcSize,\n                          blockProperties_t* bpPtr)\n{\n    RETURN_ERROR_IF(srcSize < ZSTD_blockHeaderSize, srcSize_wrong, \"\");\n\n    {   U32 const cBlockHeader = MEM_readLE24(src);\n        U32 const cSize = cBlockHeader >> 3;\n        bpPtr->lastBlock = cBlockHeader & 1;\n        bpPtr->blockType = (blockType_e)((cBlockHeader >> 1) & 3);\n        bpPtr->origSize = cSize;   /* only useful for RLE */\n        if (bpPtr->blockType == bt_rle) return 1;\n        RETURN_ERROR_IF(bpPtr->blockType == bt_reserved, corruption_detected, \"\");\n        return cSize;\n    }\n}\n\n/* Allocate buffer for literals, either overlapping current dst, or split between dst and litExtraBuffer, or stored entirely within litExtraBuffer */\nstatic void ZSTD_allocateLiteralsBuffer(ZSTD_DCtx* dctx, void* const dst, const size_t dstCapacity, const size_t litSize,\n    const streaming_operation streaming, const size_t expectedWriteSize, const unsigned splitImmediately)\n{\n    size_t const blockSizeMax = ZSTD_blockSizeMax(dctx);\n    assert(litSize <= blockSizeMax);\n    assert(dctx->isFrameDecompression || streaming == not_streaming);\n    assert(expectedWriteSize <= blockSizeMax);\n    if (streaming == not_streaming && dstCapacity > blockSizeMax + WILDCOPY_OVERLENGTH + litSize + WILDCOPY_OVERLENGTH) {\n        /* If we aren't streaming, we can just put the literals after the output\n         * of the current block. We don't need to worry about overwriting the\n         * extDict of our window, because it doesn't exist.\n         * So if we have space after the end of the block, just put it there.\n         */\n        dctx->litBuffer = (BYTE*)dst + blockSizeMax + WILDCOPY_OVERLENGTH;\n        dctx->litBufferEnd = dctx->litBuffer + litSize;\n        dctx->litBufferLocation = ZSTD_in_dst;\n    } else if (litSize <= ZSTD_LITBUFFEREXTRASIZE) {\n        /* Literals fit entirely within the extra buffer, put them there to avoid\n         * having to split the literals.\n         */\n        dctx->litBuffer = dctx->litExtraBuffer;\n        dctx->litBufferEnd = dctx->litBuffer + litSize;\n        dctx->litBufferLocation = ZSTD_not_in_dst;\n    } else {\n        assert(blockSizeMax > ZSTD_LITBUFFEREXTRASIZE);\n        /* Literals must be split between the output block and the extra lit\n         * buffer. We fill the extra lit buffer with the tail of the literals,\n         * and put the rest of the literals at the end of the block, with\n         * WILDCOPY_OVERLENGTH of buffer room to allow for overreads.\n         * This MUST not write more than our maxBlockSize beyond dst, because in\n         * streaming mode, that could overwrite part of our extDict window.\n         */\n        if (splitImmediately) {\n            /* won't fit in litExtraBuffer, so it will be split between end of dst and extra buffer */\n            dctx->litBuffer = (BYTE*)dst + expectedWriteSize - litSize + ZSTD_LITBUFFEREXTRASIZE - WILDCOPY_OVERLENGTH;\n            dctx->litBufferEnd = dctx->litBuffer + litSize - ZSTD_LITBUFFEREXTRASIZE;\n        } else {\n            /* initially this will be stored entirely in dst during huffman decoding, it will partially be shifted to litExtraBuffer after */\n            dctx->litBuffer = (BYTE*)dst + expectedWriteSize - litSize;\n            dctx->litBufferEnd = (BYTE*)dst + expectedWriteSize;\n        }\n        dctx->litBufferLocation = ZSTD_split;\n        assert(dctx->litBufferEnd <= (BYTE*)dst + expectedWriteSize);\n    }\n}\n\n/*! ZSTD_decodeLiteralsBlock() :\n * Where it is possible to do so without being stomped by the output during decompression, the literals block will be stored\n * in the dstBuffer.  If there is room to do so, it will be stored in full in the excess dst space after where the current\n * block will be output.  Otherwise it will be stored at the end of the current dst blockspace, with a small portion being\n * stored in dctx->litExtraBuffer to help keep it \"ahead\" of the current output write.\n *\n * @return : nb of bytes read from src (< srcSize )\n *  note : symbol not declared but exposed for fullbench */\nstatic size_t ZSTD_decodeLiteralsBlock(ZSTD_DCtx* dctx,\n                          const void* src, size_t srcSize,   /* note : srcSize < BLOCKSIZE */\n                          void* dst, size_t dstCapacity, const streaming_operation streaming)\n{\n    DEBUGLOG(5, \"ZSTD_decodeLiteralsBlock\");\n    RETURN_ERROR_IF(srcSize < MIN_CBLOCK_SIZE, corruption_detected, \"\");\n\n    {   const BYTE* const istart = (const BYTE*) src;\n        SymbolEncodingType_e const litEncType = (SymbolEncodingType_e)(istart[0] & 3);\n        size_t const blockSizeMax = ZSTD_blockSizeMax(dctx);\n\n        switch(litEncType)\n        {\n        case set_repeat:\n            DEBUGLOG(5, \"set_repeat flag : re-using stats from previous compressed literals block\");\n            RETURN_ERROR_IF(dctx->litEntropy==0, dictionary_corrupted, \"\");\n            ZSTD_FALLTHROUGH;\n\n        case set_compressed:\n            RETURN_ERROR_IF(srcSize < 5, corruption_detected, \"srcSize >= MIN_CBLOCK_SIZE == 2; here we need up to 5 for case 3\");\n            {   size_t lhSize, litSize, litCSize;\n                U32 singleStream=0;\n                U32 const lhlCode = (istart[0] >> 2) & 3;\n                U32 const lhc = MEM_readLE32(istart);\n                size_t hufSuccess;\n                size_t expectedWriteSize = MIN(blockSizeMax, dstCapacity);\n                int const flags = 0\n                    | (ZSTD_DCtx_get_bmi2(dctx) ? HUF_flags_bmi2 : 0)\n                    | (dctx->disableHufAsm ? HUF_flags_disableAsm : 0);\n                switch(lhlCode)\n                {\n                case 0: case 1: default:   /* note : default is impossible, since lhlCode into [0..3] */\n                    /* 2 - 2 - 10 - 10 */\n                    singleStream = !lhlCode;\n                    lhSize = 3;\n                    litSize  = (lhc >> 4) & 0x3FF;\n                    litCSize = (lhc >> 14) & 0x3FF;\n                    break;\n                case 2:\n                    /* 2 - 2 - 14 - 14 */\n                    lhSize = 4;\n                    litSize  = (lhc >> 4) & 0x3FFF;\n                    litCSize = lhc >> 18;\n                    break;\n                case 3:\n                    /* 2 - 2 - 18 - 18 */\n                    lhSize = 5;\n                    litSize  = (lhc >> 4) & 0x3FFFF;\n                    litCSize = (lhc >> 22) + ((size_t)istart[4] << 10);\n                    break;\n                }\n                RETURN_ERROR_IF(litSize > 0 && dst == NULL, dstSize_tooSmall, \"NULL not handled\");\n                RETURN_ERROR_IF(litSize > blockSizeMax, corruption_detected, \"\");\n                if (!singleStream)\n                    RETURN_ERROR_IF(litSize < MIN_LITERALS_FOR_4_STREAMS, literals_headerWrong,\n                        \"Not enough literals (%zu) for the 4-streams mode (min %u)\",\n                        litSize, MIN_LITERALS_FOR_4_STREAMS);\n                RETURN_ERROR_IF(litCSize + lhSize > srcSize, corruption_detected, \"\");\n                RETURN_ERROR_IF(expectedWriteSize < litSize , dstSize_tooSmall, \"\");\n                ZSTD_allocateLiteralsBuffer(dctx, dst, dstCapacity, litSize, streaming, expectedWriteSize, 0);\n\n                /* prefetch huffman table if cold */\n                if (dctx->ddictIsCold && (litSize > 768 /* heuristic */)) {\n                    PREFETCH_AREA(dctx->HUFptr, sizeof(dctx->entropy.hufTable));\n                }\n\n                if (litEncType==set_repeat) {\n                    if (singleStream) {\n                        hufSuccess = HUF_decompress1X_usingDTable(\n                            dctx->litBuffer, litSize, istart+lhSize, litCSize,\n                            dctx->HUFptr, flags);\n                    } else {\n                        assert(litSize >= MIN_LITERALS_FOR_4_STREAMS);\n                        hufSuccess = HUF_decompress4X_usingDTable(\n                            dctx->litBuffer, litSize, istart+lhSize, litCSize,\n                            dctx->HUFptr, flags);\n                    }\n                } else {\n                    if (singleStream) {\n#if defined(HUF_FORCE_DECOMPRESS_X2)\n                        hufSuccess = HUF_decompress1X_DCtx_wksp(\n                            dctx->entropy.hufTable, dctx->litBuffer, litSize,\n                            istart+lhSize, litCSize, dctx->workspace,\n                            sizeof(dctx->workspace), flags);\n#else\n                        hufSuccess = HUF_decompress1X1_DCtx_wksp(\n                            dctx->entropy.hufTable, dctx->litBuffer, litSize,\n                            istart+lhSize, litCSize, dctx->workspace,\n                            sizeof(dctx->workspace), flags);\n#endif\n                    } else {\n                        hufSuccess = HUF_decompress4X_hufOnly_wksp(\n                            dctx->entropy.hufTable, dctx->litBuffer, litSize,\n                            istart+lhSize, litCSize, dctx->workspace,\n                            sizeof(dctx->workspace), flags);\n                    }\n                }\n                if (dctx->litBufferLocation == ZSTD_split)\n                {\n                    assert(litSize > ZSTD_LITBUFFEREXTRASIZE);\n                    ZSTD_memcpy(dctx->litExtraBuffer, dctx->litBufferEnd - ZSTD_LITBUFFEREXTRASIZE, ZSTD_LITBUFFEREXTRASIZE);\n                    ZSTD_memmove(dctx->litBuffer + ZSTD_LITBUFFEREXTRASIZE - WILDCOPY_OVERLENGTH, dctx->litBuffer, litSize - ZSTD_LITBUFFEREXTRASIZE);\n                    dctx->litBuffer += ZSTD_LITBUFFEREXTRASIZE - WILDCOPY_OVERLENGTH;\n                    dctx->litBufferEnd -= WILDCOPY_OVERLENGTH;\n                    assert(dctx->litBufferEnd <= (BYTE*)dst + blockSizeMax);\n                }\n\n                RETURN_ERROR_IF(HUF_isError(hufSuccess), corruption_detected, \"\");\n\n                dctx->litPtr = dctx->litBuffer;\n                dctx->litSize = litSize;\n                dctx->litEntropy = 1;\n                if (litEncType==set_compressed) dctx->HUFptr = dctx->entropy.hufTable;\n                return litCSize + lhSize;\n            }\n\n        case set_basic:\n            {   size_t litSize, lhSize;\n                U32 const lhlCode = ((istart[0]) >> 2) & 3;\n                size_t expectedWriteSize = MIN(blockSizeMax, dstCapacity);\n                switch(lhlCode)\n                {\n                case 0: case 2: default:   /* note : default is impossible, since lhlCode into [0..3] */\n                    lhSize = 1;\n                    litSize = istart[0] >> 3;\n                    break;\n                case 1:\n                    lhSize = 2;\n                    litSize = MEM_readLE16(istart) >> 4;\n                    break;\n                case 3:\n                    lhSize = 3;\n                    RETURN_ERROR_IF(srcSize<3, corruption_detected, \"srcSize >= MIN_CBLOCK_SIZE == 2; here we need lhSize = 3\");\n                    litSize = MEM_readLE24(istart) >> 4;\n                    break;\n                }\n\n                RETURN_ERROR_IF(litSize > 0 && dst == NULL, dstSize_tooSmall, \"NULL not handled\");\n                RETURN_ERROR_IF(litSize > blockSizeMax, corruption_detected, \"\");\n                RETURN_ERROR_IF(expectedWriteSize < litSize, dstSize_tooSmall, \"\");\n                ZSTD_allocateLiteralsBuffer(dctx, dst, dstCapacity, litSize, streaming, expectedWriteSize, 1);\n                if (lhSize+litSize+WILDCOPY_OVERLENGTH > srcSize) {  /* risk reading beyond src buffer with wildcopy */\n                    RETURN_ERROR_IF(litSize+lhSize > srcSize, corruption_detected, \"\");\n                    if (dctx->litBufferLocation == ZSTD_split)\n                    {\n                        ZSTD_memcpy(dctx->litBuffer, istart + lhSize, litSize - ZSTD_LITBUFFEREXTRASIZE);\n                        ZSTD_memcpy(dctx->litExtraBuffer, istart + lhSize + litSize - ZSTD_LITBUFFEREXTRASIZE, ZSTD_LITBUFFEREXTRASIZE);\n                    }\n                    else\n                    {\n                        ZSTD_memcpy(dctx->litBuffer, istart + lhSize, litSize);\n                    }\n                    dctx->litPtr = dctx->litBuffer;\n                    dctx->litSize = litSize;\n                    return lhSize+litSize;\n                }\n                /* direct reference into compressed stream */\n                dctx->litPtr = istart+lhSize;\n                dctx->litSize = litSize;\n                dctx->litBufferEnd = dctx->litPtr + litSize;\n                dctx->litBufferLocation = ZSTD_not_in_dst;\n                return lhSize+litSize;\n            }\n\n        case set_rle:\n            {   U32 const lhlCode = ((istart[0]) >> 2) & 3;\n                size_t litSize, lhSize;\n                size_t expectedWriteSize = MIN(blockSizeMax, dstCapacity);\n                switch(lhlCode)\n                {\n                case 0: case 2: default:   /* note : default is impossible, since lhlCode into [0..3] */\n                    lhSize = 1;\n                    litSize = istart[0] >> 3;\n                    break;\n                case 1:\n                    lhSize = 2;\n                    RETURN_ERROR_IF(srcSize<3, corruption_detected, \"srcSize >= MIN_CBLOCK_SIZE == 2; here we need lhSize+1 = 3\");\n                    litSize = MEM_readLE16(istart) >> 4;\n                    break;\n                case 3:\n                    lhSize = 3;\n                    RETURN_ERROR_IF(srcSize<4, corruption_detected, \"srcSize >= MIN_CBLOCK_SIZE == 2; here we need lhSize+1 = 4\");\n                    litSize = MEM_readLE24(istart) >> 4;\n                    break;\n                }\n                RETURN_ERROR_IF(litSize > 0 && dst == NULL, dstSize_tooSmall, \"NULL not handled\");\n                RETURN_ERROR_IF(litSize > blockSizeMax, corruption_detected, \"\");\n                RETURN_ERROR_IF(expectedWriteSize < litSize, dstSize_tooSmall, \"\");\n                ZSTD_allocateLiteralsBuffer(dctx, dst, dstCapacity, litSize, streaming, expectedWriteSize, 1);\n                if (dctx->litBufferLocation == ZSTD_split)\n                {\n                    ZSTD_memset(dctx->litBuffer, istart[lhSize], litSize - ZSTD_LITBUFFEREXTRASIZE);\n                    ZSTD_memset(dctx->litExtraBuffer, istart[lhSize], ZSTD_LITBUFFEREXTRASIZE);\n                }\n                else\n                {\n                    ZSTD_memset(dctx->litBuffer, istart[lhSize], litSize);\n                }\n                dctx->litPtr = dctx->litBuffer;\n                dctx->litSize = litSize;\n                return lhSize+1;\n            }\n        default:\n            RETURN_ERROR(corruption_detected, \"impossible\");\n        }\n    }\n}\n\n/* Hidden declaration for fullbench */\nsize_t ZSTD_decodeLiteralsBlock_wrapper(ZSTD_DCtx* dctx,\n                          const void* src, size_t srcSize,\n                          void* dst, size_t dstCapacity);\nsize_t ZSTD_decodeLiteralsBlock_wrapper(ZSTD_DCtx* dctx,\n                          const void* src, size_t srcSize,\n                          void* dst, size_t dstCapacity)\n{\n    dctx->isFrameDecompression = 0;\n    return ZSTD_decodeLiteralsBlock(dctx, src, srcSize, dst, dstCapacity, not_streaming);\n}\n\n/* Default FSE distribution tables.\n * These are pre-calculated FSE decoding tables using default distributions as defined in specification :\n * https://github.com/facebook/zstd/blob/release/doc/zstd_compression_format.md#default-distributions\n * They were generated programmatically with following method :\n * - start from default distributions, present in /lib/common/zstd_internal.h\n * - generate tables normally, using ZSTD_buildFSETable()\n * - printout the content of tables\n * - prettify output, report below, test with fuzzer to ensure it's correct */\n\n/* Default FSE distribution table for Literal Lengths */\nstatic const ZSTD_seqSymbol LL_defaultDTable[(1<tableLog = 0;\n    DTableH->fastMode = 0;\n\n    cell->nbBits = 0;\n    cell->nextState = 0;\n    assert(nbAddBits < 255);\n    cell->nbAdditionalBits = nbAddBits;\n    cell->baseValue = baseValue;\n}\n\n\n/* ZSTD_buildFSETable() :\n * generate FSE decoding table for one symbol (ll, ml or off)\n * cannot fail if input is valid =>\n * all inputs are presumed validated at this stage */\nFORCE_INLINE_TEMPLATE\nvoid ZSTD_buildFSETable_body(ZSTD_seqSymbol* dt,\n            const short* normalizedCounter, unsigned maxSymbolValue,\n            const U32* baseValue, const U8* nbAdditionalBits,\n            unsigned tableLog, void* wksp, size_t wkspSize)\n{\n    ZSTD_seqSymbol* const tableDecode = dt+1;\n    U32 const maxSV1 = maxSymbolValue + 1;\n    U32 const tableSize = 1 << tableLog;\n\n    U16* symbolNext = (U16*)wksp;\n    BYTE* spread = (BYTE*)(symbolNext + MaxSeq + 1);\n    U32 highThreshold = tableSize - 1;\n\n\n    /* Sanity Checks */\n    assert(maxSymbolValue <= MaxSeq);\n    assert(tableLog <= MaxFSELog);\n    assert(wkspSize >= ZSTD_BUILD_FSE_TABLE_WKSP_SIZE);\n    (void)wkspSize;\n    /* Init, lay down lowprob symbols */\n    {   ZSTD_seqSymbol_header DTableH;\n        DTableH.tableLog = tableLog;\n        DTableH.fastMode = 1;\n        {   S16 const largeLimit= (S16)(1 << (tableLog-1));\n            U32 s;\n            for (s=0; s= largeLimit) DTableH.fastMode=0;\n                    assert(normalizedCounter[s]>=0);\n                    symbolNext[s] = (U16)normalizedCounter[s];\n        }   }   }\n        ZSTD_memcpy(dt, &DTableH, sizeof(DTableH));\n    }\n\n    /* Spread symbols */\n    assert(tableSize <= 512);\n    /* Specialized symbol spreading for the case when there are\n     * no low probability (-1 count) symbols. When compressing\n     * small blocks we avoid low probability symbols to hit this\n     * case, since header decoding speed matters more.\n     */\n    if (highThreshold == tableSize - 1) {\n        size_t const tableMask = tableSize-1;\n        size_t const step = FSE_TABLESTEP(tableSize);\n        /* First lay down the symbols in order.\n         * We use a uint64_t to lay down 8 bytes at a time. This reduces branch\n         * misses since small blocks generally have small table logs, so nearly\n         * all symbols have counts <= 8. We ensure we have 8 bytes at the end of\n         * our buffer to handle the over-write.\n         */\n        {\n            U64 const add = 0x0101010101010101ull;\n            size_t pos = 0;\n            U64 sv = 0;\n            U32 s;\n            for (s=0; s=0);\n                pos += (size_t)n;\n            }\n        }\n        /* Now we spread those positions across the table.\n         * The benefit of doing it in two stages is that we avoid the\n         * variable size inner loop, which caused lots of branch misses.\n         * Now we can run through all the positions without any branch misses.\n         * We unroll the loop twice, since that is what empirically worked best.\n         */\n        {\n            size_t position = 0;\n            size_t s;\n            size_t const unroll = 2;\n            assert(tableSize % unroll == 0); /* FSE_MIN_TABLELOG is 5 */\n            for (s = 0; s < (size_t)tableSize; s += unroll) {\n                size_t u;\n                for (u = 0; u < unroll; ++u) {\n                    size_t const uPosition = (position + (u * step)) & tableMask;\n                    tableDecode[uPosition].baseValue = spread[s + u];\n                }\n                position = (position + (unroll * step)) & tableMask;\n            }\n            assert(position == 0);\n        }\n    } else {\n        U32 const tableMask = tableSize-1;\n        U32 const step = FSE_TABLESTEP(tableSize);\n        U32 s, position = 0;\n        for (s=0; s highThreshold)) position = (position + step) & tableMask;   /* lowprob area */\n        }   }\n        assert(position == 0); /* position must reach all cells once, otherwise normalizedCounter is incorrect */\n    }\n\n    /* Build Decoding table */\n    {\n        U32 u;\n        for (u=0; u max, corruption_detected, \"\");\n        {   U32 const symbol = *(const BYTE*)src;\n            U32 const baseline = baseValue[symbol];\n            U8 const nbBits = nbAdditionalBits[symbol];\n            ZSTD_buildSeqTable_rle(DTableSpace, baseline, nbBits);\n        }\n        *DTablePtr = DTableSpace;\n        return 1;\n    case set_basic :\n        *DTablePtr = defaultTable;\n        return 0;\n    case set_repeat:\n        RETURN_ERROR_IF(!flagRepeatTable, corruption_detected, \"\");\n        /* prefetch FSE table if used */\n        if (ddictIsCold && (nbSeq > 24 /* heuristic */)) {\n            const void* const pStart = *DTablePtr;\n            size_t const pSize = sizeof(ZSTD_seqSymbol) * (SEQSYMBOL_TABLE_SIZE(maxLog));\n            PREFETCH_AREA(pStart, pSize);\n        }\n        return 0;\n    case set_compressed :\n        {   unsigned tableLog;\n            S16 norm[MaxSeq+1];\n            size_t const headerSize = FSE_readNCount(norm, &max, &tableLog, src, srcSize);\n            RETURN_ERROR_IF(FSE_isError(headerSize), corruption_detected, \"\");\n            RETURN_ERROR_IF(tableLog > maxLog, corruption_detected, \"\");\n            ZSTD_buildFSETable(DTableSpace, norm, max, baseValue, nbAdditionalBits, tableLog, wksp, wkspSize, bmi2);\n            *DTablePtr = DTableSpace;\n            return headerSize;\n        }\n    default :\n        assert(0);\n        RETURN_ERROR(GENERIC, \"impossible\");\n    }\n}\n\nsize_t ZSTD_decodeSeqHeaders(ZSTD_DCtx* dctx, int* nbSeqPtr,\n                             const void* src, size_t srcSize)\n{\n    const BYTE* const istart = (const BYTE*)src;\n    const BYTE* const iend = istart + srcSize;\n    const BYTE* ip = istart;\n    int nbSeq;\n    DEBUGLOG(5, \"ZSTD_decodeSeqHeaders\");\n\n    /* check */\n    RETURN_ERROR_IF(srcSize < MIN_SEQUENCES_SIZE, srcSize_wrong, \"\");\n\n    /* SeqHead */\n    nbSeq = *ip++;\n    if (nbSeq > 0x7F) {\n        if (nbSeq == 0xFF) {\n            RETURN_ERROR_IF(ip+2 > iend, srcSize_wrong, \"\");\n            nbSeq = MEM_readLE16(ip) + LONGNBSEQ;\n            ip+=2;\n        } else {\n            RETURN_ERROR_IF(ip >= iend, srcSize_wrong, \"\");\n            nbSeq = ((nbSeq-0x80)<<8) + *ip++;\n        }\n    }\n    *nbSeqPtr = nbSeq;\n\n    if (nbSeq == 0) {\n        /* No sequence : section ends immediately */\n        RETURN_ERROR_IF(ip != iend, corruption_detected,\n            \"extraneous data present in the Sequences section\");\n        return (size_t)(ip - istart);\n    }\n\n    /* FSE table descriptors */\n    RETURN_ERROR_IF(ip+1 > iend, srcSize_wrong, \"\"); /* minimum possible size: 1 byte for symbol encoding types */\n    RETURN_ERROR_IF(*ip & 3, corruption_detected, \"\"); /* The last field, Reserved, must be all-zeroes. */\n    {   SymbolEncodingType_e const LLtype = (SymbolEncodingType_e)(*ip >> 6);\n        SymbolEncodingType_e const OFtype = (SymbolEncodingType_e)((*ip >> 4) & 3);\n        SymbolEncodingType_e const MLtype = (SymbolEncodingType_e)((*ip >> 2) & 3);\n        ip++;\n\n        /* Build DTables */\n        assert(ip <= iend);\n        {   size_t const llhSize = ZSTD_buildSeqTable(dctx->entropy.LLTable, &dctx->LLTptr,\n                                                      LLtype, MaxLL, LLFSELog,\n                                                      ip, (size_t)(iend-ip),\n                                                      LL_base, LL_bits,\n                                                      LL_defaultDTable, dctx->fseEntropy,\n                                                      dctx->ddictIsCold, nbSeq,\n                                                      dctx->workspace, sizeof(dctx->workspace),\n                                                      ZSTD_DCtx_get_bmi2(dctx));\n            RETURN_ERROR_IF(ZSTD_isError(llhSize), corruption_detected, \"ZSTD_buildSeqTable failed\");\n            ip += llhSize;\n        }\n\n        assert(ip <= iend);\n        {   size_t const ofhSize = ZSTD_buildSeqTable(dctx->entropy.OFTable, &dctx->OFTptr,\n                                                      OFtype, MaxOff, OffFSELog,\n                                                      ip, (size_t)(iend-ip),\n                                                      OF_base, OF_bits,\n                                                      OF_defaultDTable, dctx->fseEntropy,\n                                                      dctx->ddictIsCold, nbSeq,\n                                                      dctx->workspace, sizeof(dctx->workspace),\n                                                      ZSTD_DCtx_get_bmi2(dctx));\n            RETURN_ERROR_IF(ZSTD_isError(ofhSize), corruption_detected, \"ZSTD_buildSeqTable failed\");\n            ip += ofhSize;\n        }\n\n        assert(ip <= iend);\n        {   size_t const mlhSize = ZSTD_buildSeqTable(dctx->entropy.MLTable, &dctx->MLTptr,\n                                                      MLtype, MaxML, MLFSELog,\n                                                      ip, (size_t)(iend-ip),\n                                                      ML_base, ML_bits,\n                                                      ML_defaultDTable, dctx->fseEntropy,\n                                                      dctx->ddictIsCold, nbSeq,\n                                                      dctx->workspace, sizeof(dctx->workspace),\n                                                      ZSTD_DCtx_get_bmi2(dctx));\n            RETURN_ERROR_IF(ZSTD_isError(mlhSize), corruption_detected, \"ZSTD_buildSeqTable failed\");\n            ip += mlhSize;\n        }\n    }\n\n    return (size_t)(ip-istart);\n}\n\n\ntypedef struct {\n    size_t litLength;\n    size_t matchLength;\n    size_t offset;\n} seq_t;\n\ntypedef struct {\n    size_t state;\n    const ZSTD_seqSymbol* table;\n} ZSTD_fseState;\n\ntypedef struct {\n    BIT_DStream_t DStream;\n    ZSTD_fseState stateLL;\n    ZSTD_fseState stateOffb;\n    ZSTD_fseState stateML;\n    size_t prevOffset[ZSTD_REP_NUM];\n} seqState_t;\n\n/*! ZSTD_overlapCopy8() :\n *  Copies 8 bytes from ip to op and updates op and ip where ip <= op.\n *  If the offset is < 8 then the offset is spread to at least 8 bytes.\n *\n *  Precondition: *ip <= *op\n *  Postcondition: *op - *op >= 8\n */\nHINT_INLINE void ZSTD_overlapCopy8(BYTE** op, BYTE const** ip, size_t offset)\n{\n    assert(*ip <= *op);\n    if (offset < 8) {\n        /* close range match, overlap */\n        static const U32 dec32table[] = { 0, 1, 2, 1, 4, 4, 4, 4 };   /* added */\n        static const int dec64table[] = { 8, 8, 8, 7, 8, 9,10,11 };   /* subtracted */\n        int const sub2 = dec64table[offset];\n        (*op)[0] = (*ip)[0];\n        (*op)[1] = (*ip)[1];\n        (*op)[2] = (*ip)[2];\n        (*op)[3] = (*ip)[3];\n        *ip += dec32table[offset];\n        ZSTD_copy4(*op+4, *ip);\n        *ip -= sub2;\n    } else {\n        ZSTD_copy8(*op, *ip);\n    }\n    *ip += 8;\n    *op += 8;\n    assert(*op - *ip >= 8);\n}\n\n/*! ZSTD_safecopy() :\n *  Specialized version of memcpy() that is allowed to READ up to WILDCOPY_OVERLENGTH past the input buffer\n *  and write up to 16 bytes past oend_w (op >= oend_w is allowed).\n *  This function is only called in the uncommon case where the sequence is near the end of the block. It\n *  should be fast for a single long sequence, but can be slow for several short sequences.\n *\n *  @param ovtype controls the overlap detection\n *         - ZSTD_no_overlap: The source and destination are guaranteed to be at least WILDCOPY_VECLEN bytes apart.\n *         - ZSTD_overlap_src_before_dst: The src and dst may overlap and may be any distance apart.\n *           The src buffer must be before the dst buffer.\n */\nstatic void\nZSTD_safecopy(BYTE* op, const BYTE* const oend_w, BYTE const* ip, size_t length, ZSTD_overlap_e ovtype)\n{\n    ptrdiff_t const diff = op - ip;\n    BYTE* const oend = op + length;\n\n    assert((ovtype == ZSTD_no_overlap && (diff <= -8 || diff >= 8 || op >= oend_w)) ||\n           (ovtype == ZSTD_overlap_src_before_dst && diff >= 0));\n\n    if (length < 8) {\n        /* Handle short lengths. */\n        while (op < oend) *op++ = *ip++;\n        return;\n    }\n    if (ovtype == ZSTD_overlap_src_before_dst) {\n        /* Copy 8 bytes and ensure the offset >= 8 when there can be overlap. */\n        assert(length >= 8);\n        assert(diff > 0);\n        ZSTD_overlapCopy8(&op, &ip, (size_t)diff);\n        length -= 8;\n        assert(op - ip >= 8);\n        assert(op <= oend);\n    }\n\n    if (oend <= oend_w) {\n        /* No risk of overwrite. */\n        ZSTD_wildcopy(op, ip, length, ovtype);\n        return;\n    }\n    if (op <= oend_w) {\n        /* Wildcopy until we get close to the end. */\n        assert(oend > oend_w);\n        ZSTD_wildcopy(op, ip, (size_t)(oend_w - op), ovtype);\n        ip += oend_w - op;\n        op += oend_w - op;\n    }\n    /* Handle the leftovers. */\n    while (op < oend) *op++ = *ip++;\n}\n\n/* ZSTD_safecopyDstBeforeSrc():\n * This version allows overlap with dst before src, or handles the non-overlap case with dst after src\n * Kept separate from more common ZSTD_safecopy case to avoid performance impact to the safecopy common case */\nstatic void ZSTD_safecopyDstBeforeSrc(BYTE* op, const BYTE* ip, size_t length)\n{\n    ptrdiff_t const diff = op - ip;\n    BYTE* const oend = op + length;\n\n    if (length < 8 || diff > -8) {\n        /* Handle short lengths, close overlaps, and dst not before src. */\n        while (op < oend) *op++ = *ip++;\n        return;\n    }\n\n    if (op <= oend - WILDCOPY_OVERLENGTH && diff < -WILDCOPY_VECLEN) {\n        ZSTD_wildcopy(op, ip, (size_t)(oend - WILDCOPY_OVERLENGTH - op), ZSTD_no_overlap);\n        ip += oend - WILDCOPY_OVERLENGTH - op;\n        op += oend - WILDCOPY_OVERLENGTH - op;\n    }\n\n    /* Handle the leftovers. */\n    while (op < oend) *op++ = *ip++;\n}\n\n/* ZSTD_execSequenceEnd():\n * This version handles cases that are near the end of the output buffer. It requires\n * more careful checks to make sure there is no overflow. By separating out these hard\n * and unlikely cases, we can speed up the common cases.\n *\n * NOTE: This function needs to be fast for a single long sequence, but doesn't need\n * to be optimized for many small sequences, since those fall into ZSTD_execSequence().\n */\nFORCE_NOINLINE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_execSequenceEnd(BYTE* op,\n    BYTE* const oend, seq_t sequence,\n    const BYTE** litPtr, const BYTE* const litLimit,\n    const BYTE* const prefixStart, const BYTE* const virtualStart, const BYTE* const dictEnd)\n{\n    BYTE* const oLitEnd = op + sequence.litLength;\n    size_t const sequenceLength = sequence.litLength + sequence.matchLength;\n    const BYTE* const iLitEnd = *litPtr + sequence.litLength;\n    const BYTE* match = oLitEnd - sequence.offset;\n    BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH;\n\n    /* bounds checks : careful of address space overflow in 32-bit mode */\n    RETURN_ERROR_IF(sequenceLength > (size_t)(oend - op), dstSize_tooSmall, \"last match must fit within dstBuffer\");\n    RETURN_ERROR_IF(sequence.litLength > (size_t)(litLimit - *litPtr), corruption_detected, \"try to read beyond literal buffer\");\n    assert(op < op + sequenceLength);\n    assert(oLitEnd < op + sequenceLength);\n\n    /* copy literals */\n    ZSTD_safecopy(op, oend_w, *litPtr, sequence.litLength, ZSTD_no_overlap);\n    op = oLitEnd;\n    *litPtr = iLitEnd;\n\n    /* copy Match */\n    if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {\n        /* offset beyond prefix */\n        RETURN_ERROR_IF(sequence.offset > (size_t)(oLitEnd - virtualStart), corruption_detected, \"\");\n        match = dictEnd - (prefixStart - match);\n        if (match + sequence.matchLength <= dictEnd) {\n            ZSTD_memmove(oLitEnd, match, sequence.matchLength);\n            return sequenceLength;\n        }\n        /* span extDict & currentPrefixSegment */\n        {   size_t const length1 = (size_t)(dictEnd - match);\n            ZSTD_memmove(oLitEnd, match, length1);\n            op = oLitEnd + length1;\n            sequence.matchLength -= length1;\n            match = prefixStart;\n        }\n    }\n    ZSTD_safecopy(op, oend_w, match, sequence.matchLength, ZSTD_overlap_src_before_dst);\n    return sequenceLength;\n}\n\n/* ZSTD_execSequenceEndSplitLitBuffer():\n * This version is intended to be used during instances where the litBuffer is still split.  It is kept separate to avoid performance impact for the good case.\n */\nFORCE_NOINLINE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_execSequenceEndSplitLitBuffer(BYTE* op,\n    BYTE* const oend, const BYTE* const oend_w, seq_t sequence,\n    const BYTE** litPtr, const BYTE* const litLimit,\n    const BYTE* const prefixStart, const BYTE* const virtualStart, const BYTE* const dictEnd)\n{\n    BYTE* const oLitEnd = op + sequence.litLength;\n    size_t const sequenceLength = sequence.litLength + sequence.matchLength;\n    const BYTE* const iLitEnd = *litPtr + sequence.litLength;\n    const BYTE* match = oLitEnd - sequence.offset;\n\n\n    /* bounds checks : careful of address space overflow in 32-bit mode */\n    RETURN_ERROR_IF(sequenceLength > (size_t)(oend - op), dstSize_tooSmall, \"last match must fit within dstBuffer\");\n    RETURN_ERROR_IF(sequence.litLength > (size_t)(litLimit - *litPtr), corruption_detected, \"try to read beyond literal buffer\");\n    assert(op < op + sequenceLength);\n    assert(oLitEnd < op + sequenceLength);\n\n    /* copy literals */\n    RETURN_ERROR_IF(op > *litPtr && op < *litPtr + sequence.litLength, dstSize_tooSmall, \"output should not catch up to and overwrite literal buffer\");\n    ZSTD_safecopyDstBeforeSrc(op, *litPtr, sequence.litLength);\n    op = oLitEnd;\n    *litPtr = iLitEnd;\n\n    /* copy Match */\n    if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {\n        /* offset beyond prefix */\n        RETURN_ERROR_IF(sequence.offset > (size_t)(oLitEnd - virtualStart), corruption_detected, \"\");\n        match = dictEnd - (prefixStart - match);\n        if (match + sequence.matchLength <= dictEnd) {\n            ZSTD_memmove(oLitEnd, match, sequence.matchLength);\n            return sequenceLength;\n        }\n        /* span extDict & currentPrefixSegment */\n        {   size_t const length1 = (size_t)(dictEnd - match);\n            ZSTD_memmove(oLitEnd, match, length1);\n            op = oLitEnd + length1;\n            sequence.matchLength -= length1;\n            match = prefixStart;\n        }\n    }\n    ZSTD_safecopy(op, oend_w, match, sequence.matchLength, ZSTD_overlap_src_before_dst);\n    return sequenceLength;\n}\n\nHINT_INLINE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_execSequence(BYTE* op,\n    BYTE* const oend, seq_t sequence,\n    const BYTE** litPtr, const BYTE* const litLimit,\n    const BYTE* const prefixStart, const BYTE* const virtualStart, const BYTE* const dictEnd)\n{\n    BYTE* const oLitEnd = op + sequence.litLength;\n    size_t const sequenceLength = sequence.litLength + sequence.matchLength;\n    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */\n    BYTE* const oend_w = oend - WILDCOPY_OVERLENGTH;   /* risk : address space underflow on oend=NULL */\n    const BYTE* const iLitEnd = *litPtr + sequence.litLength;\n    const BYTE* match = oLitEnd - sequence.offset;\n\n    assert(op != NULL /* Precondition */);\n    assert(oend_w < oend /* No underflow */);\n\n#if defined(__aarch64__)\n    /* prefetch sequence starting from match that will be used for copy later */\n    PREFETCH_L1(match);\n#endif\n    /* Handle edge cases in a slow path:\n     *   - Read beyond end of literals\n     *   - Match end is within WILDCOPY_OVERLIMIT of oend\n     *   - 32-bit mode and the match length overflows\n     */\n    if (UNLIKELY(\n        iLitEnd > litLimit ||\n        oMatchEnd > oend_w ||\n        (MEM_32bits() && (size_t)(oend - op) < sequenceLength + WILDCOPY_OVERLENGTH)))\n        return ZSTD_execSequenceEnd(op, oend, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd);\n\n    /* Assumptions (everything else goes into ZSTD_execSequenceEnd()) */\n    assert(op <= oLitEnd /* No overflow */);\n    assert(oLitEnd < oMatchEnd /* Non-zero match & no overflow */);\n    assert(oMatchEnd <= oend /* No underflow */);\n    assert(iLitEnd <= litLimit /* Literal length is in bounds */);\n    assert(oLitEnd <= oend_w /* Can wildcopy literals */);\n    assert(oMatchEnd <= oend_w /* Can wildcopy matches */);\n\n    /* Copy Literals:\n     * Split out litLength <= 16 since it is nearly always true. +1.6% on gcc-9.\n     * We likely don't need the full 32-byte wildcopy.\n     */\n    assert(WILDCOPY_OVERLENGTH >= 16);\n    ZSTD_copy16(op, (*litPtr));\n    if (UNLIKELY(sequence.litLength > 16)) {\n        ZSTD_wildcopy(op + 16, (*litPtr) + 16, sequence.litLength - 16, ZSTD_no_overlap);\n    }\n    op = oLitEnd;\n    *litPtr = iLitEnd;   /* update for next sequence */\n\n    /* Copy Match */\n    if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {\n        /* offset beyond prefix -> go into extDict */\n        RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, \"\");\n        match = dictEnd + (match - prefixStart);\n        if (match + sequence.matchLength <= dictEnd) {\n            ZSTD_memmove(oLitEnd, match, sequence.matchLength);\n            return sequenceLength;\n        }\n        /* span extDict & currentPrefixSegment */\n        {   size_t const length1 = (size_t)(dictEnd - match);\n            ZSTD_memmove(oLitEnd, match, length1);\n            op = oLitEnd + length1;\n            sequence.matchLength -= length1;\n            match = prefixStart;\n        }\n    }\n    /* Match within prefix of 1 or more bytes */\n    assert(op <= oMatchEnd);\n    assert(oMatchEnd <= oend_w);\n    assert(match >= prefixStart);\n    assert(sequence.matchLength >= 1);\n\n    /* Nearly all offsets are >= WILDCOPY_VECLEN bytes, which means we can use wildcopy\n     * without overlap checking.\n     */\n    if (LIKELY(sequence.offset >= WILDCOPY_VECLEN)) {\n        /* We bet on a full wildcopy for matches, since we expect matches to be\n         * longer than literals (in general). In silesia, ~10% of matches are longer\n         * than 16 bytes.\n         */\n        ZSTD_wildcopy(op, match, sequence.matchLength, ZSTD_no_overlap);\n        return sequenceLength;\n    }\n    assert(sequence.offset < WILDCOPY_VECLEN);\n\n    /* Copy 8 bytes and spread the offset to be >= 8. */\n    ZSTD_overlapCopy8(&op, &match, sequence.offset);\n\n    /* If the match length is > 8 bytes, then continue with the wildcopy. */\n    if (sequence.matchLength > 8) {\n        assert(op < oMatchEnd);\n        ZSTD_wildcopy(op, match, sequence.matchLength - 8, ZSTD_overlap_src_before_dst);\n    }\n    return sequenceLength;\n}\n\nHINT_INLINE\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nsize_t ZSTD_execSequenceSplitLitBuffer(BYTE* op,\n    BYTE* const oend, const BYTE* const oend_w, seq_t sequence,\n    const BYTE** litPtr, const BYTE* const litLimit,\n    const BYTE* const prefixStart, const BYTE* const virtualStart, const BYTE* const dictEnd)\n{\n    BYTE* const oLitEnd = op + sequence.litLength;\n    size_t const sequenceLength = sequence.litLength + sequence.matchLength;\n    BYTE* const oMatchEnd = op + sequenceLength;   /* risk : address space overflow (32-bits) */\n    const BYTE* const iLitEnd = *litPtr + sequence.litLength;\n    const BYTE* match = oLitEnd - sequence.offset;\n\n    assert(op != NULL /* Precondition */);\n    assert(oend_w < oend /* No underflow */);\n    /* Handle edge cases in a slow path:\n     *   - Read beyond end of literals\n     *   - Match end is within WILDCOPY_OVERLIMIT of oend\n     *   - 32-bit mode and the match length overflows\n     */\n    if (UNLIKELY(\n            iLitEnd > litLimit ||\n            oMatchEnd > oend_w ||\n            (MEM_32bits() && (size_t)(oend - op) < sequenceLength + WILDCOPY_OVERLENGTH)))\n        return ZSTD_execSequenceEndSplitLitBuffer(op, oend, oend_w, sequence, litPtr, litLimit, prefixStart, virtualStart, dictEnd);\n\n    /* Assumptions (everything else goes into ZSTD_execSequenceEnd()) */\n    assert(op <= oLitEnd /* No overflow */);\n    assert(oLitEnd < oMatchEnd /* Non-zero match & no overflow */);\n    assert(oMatchEnd <= oend /* No underflow */);\n    assert(iLitEnd <= litLimit /* Literal length is in bounds */);\n    assert(oLitEnd <= oend_w /* Can wildcopy literals */);\n    assert(oMatchEnd <= oend_w /* Can wildcopy matches */);\n\n    /* Copy Literals:\n     * Split out litLength <= 16 since it is nearly always true. +1.6% on gcc-9.\n     * We likely don't need the full 32-byte wildcopy.\n     */\n    assert(WILDCOPY_OVERLENGTH >= 16);\n    ZSTD_copy16(op, (*litPtr));\n    if (UNLIKELY(sequence.litLength > 16)) {\n        ZSTD_wildcopy(op+16, (*litPtr)+16, sequence.litLength-16, ZSTD_no_overlap);\n    }\n    op = oLitEnd;\n    *litPtr = iLitEnd;   /* update for next sequence */\n\n    /* Copy Match */\n    if (sequence.offset > (size_t)(oLitEnd - prefixStart)) {\n        /* offset beyond prefix -> go into extDict */\n        RETURN_ERROR_IF(UNLIKELY(sequence.offset > (size_t)(oLitEnd - virtualStart)), corruption_detected, \"\");\n        match = dictEnd + (match - prefixStart);\n        if (match + sequence.matchLength <= dictEnd) {\n            ZSTD_memmove(oLitEnd, match, sequence.matchLength);\n            return sequenceLength;\n        }\n        /* span extDict & currentPrefixSegment */\n        {   size_t const length1 = (size_t)(dictEnd - match);\n            ZSTD_memmove(oLitEnd, match, length1);\n            op = oLitEnd + length1;\n            sequence.matchLength -= length1;\n            match = prefixStart;\n    }   }\n    /* Match within prefix of 1 or more bytes */\n    assert(op <= oMatchEnd);\n    assert(oMatchEnd <= oend_w);\n    assert(match >= prefixStart);\n    assert(sequence.matchLength >= 1);\n\n    /* Nearly all offsets are >= WILDCOPY_VECLEN bytes, which means we can use wildcopy\n     * without overlap checking.\n     */\n    if (LIKELY(sequence.offset >= WILDCOPY_VECLEN)) {\n        /* We bet on a full wildcopy for matches, since we expect matches to be\n         * longer than literals (in general). In silesia, ~10% of matches are longer\n         * than 16 bytes.\n         */\n        ZSTD_wildcopy(op, match, sequence.matchLength, ZSTD_no_overlap);\n        return sequenceLength;\n    }\n    assert(sequence.offset < WILDCOPY_VECLEN);\n\n    /* Copy 8 bytes and spread the offset to be >= 8. */\n    ZSTD_overlapCopy8(&op, &match, sequence.offset);\n\n    /* If the match length is > 8 bytes, then continue with the wildcopy. */\n    if (sequence.matchLength > 8) {\n        assert(op < oMatchEnd);\n        ZSTD_wildcopy(op, match, sequence.matchLength-8, ZSTD_overlap_src_before_dst);\n    }\n    return sequenceLength;\n}\n\n\nstatic void\nZSTD_initFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, const ZSTD_seqSymbol* dt)\n{\n    const void* ptr = dt;\n    const ZSTD_seqSymbol_header* const DTableH = (const ZSTD_seqSymbol_header*)ptr;\n    DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);\n    DEBUGLOG(6, \"ZSTD_initFseState : val=%u using %u bits\",\n                (U32)DStatePtr->state, DTableH->tableLog);\n    BIT_reloadDStream(bitD);\n    DStatePtr->table = dt + 1;\n}\n\nFORCE_INLINE_TEMPLATE void\nZSTD_updateFseStateWithDInfo(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, U16 nextState, U32 nbBits)\n{\n    size_t const lowBits = BIT_readBits(bitD, nbBits);\n    DStatePtr->state = nextState + lowBits;\n}\n\n/* We need to add at most (ZSTD_WINDOWLOG_MAX_32 - 1) bits to read the maximum\n * offset bits. But we can only read at most STREAM_ACCUMULATOR_MIN_32\n * bits before reloading. This value is the maximum number of bytes we read\n * after reloading when we are decoding long offsets.\n */\n#define LONG_OFFSETS_MAX_EXTRA_BITS_32                       \\\n    (ZSTD_WINDOWLOG_MAX_32 > STREAM_ACCUMULATOR_MIN_32       \\\n        ? ZSTD_WINDOWLOG_MAX_32 - STREAM_ACCUMULATOR_MIN_32  \\\n        : 0)\n\ntypedef enum { ZSTD_lo_isRegularOffset, ZSTD_lo_isLongOffset=1 } ZSTD_longOffset_e;\n\n/**\n * ZSTD_decodeSequence():\n * @p longOffsets : tells the decoder to reload more bit while decoding large offsets\n *                  only used in 32-bit mode\n * @return : Sequence (litL + matchL + offset)\n */\nFORCE_INLINE_TEMPLATE seq_t\nZSTD_decodeSequence(seqState_t* seqState, const ZSTD_longOffset_e longOffsets, const int isLastSeq)\n{\n    seq_t seq;\n#if defined(__aarch64__)\n    size_t prevOffset0 = seqState->prevOffset[0];\n    size_t prevOffset1 = seqState->prevOffset[1];\n    size_t prevOffset2 = seqState->prevOffset[2];\n    /*\n     * ZSTD_seqSymbol is a 64 bits wide structure.\n     * It can be loaded in one operation\n     * and its fields extracted by simply shifting or bit-extracting on aarch64.\n     * GCC doesn't recognize this and generates more unnecessary ldr/ldrb/ldrh\n     * operations that cause performance drop. This can be avoided by using this\n     * ZSTD_memcpy hack.\n     */\n#  if defined(__GNUC__) && !defined(__clang__)\n    ZSTD_seqSymbol llDInfoS, mlDInfoS, ofDInfoS;\n    ZSTD_seqSymbol* const llDInfo = &llDInfoS;\n    ZSTD_seqSymbol* const mlDInfo = &mlDInfoS;\n    ZSTD_seqSymbol* const ofDInfo = &ofDInfoS;\n    ZSTD_memcpy(llDInfo, seqState->stateLL.table + seqState->stateLL.state, sizeof(ZSTD_seqSymbol));\n    ZSTD_memcpy(mlDInfo, seqState->stateML.table + seqState->stateML.state, sizeof(ZSTD_seqSymbol));\n    ZSTD_memcpy(ofDInfo, seqState->stateOffb.table + seqState->stateOffb.state, sizeof(ZSTD_seqSymbol));\n#  else\n    const ZSTD_seqSymbol* const llDInfo = seqState->stateLL.table + seqState->stateLL.state;\n    const ZSTD_seqSymbol* const mlDInfo = seqState->stateML.table + seqState->stateML.state;\n    const ZSTD_seqSymbol* const ofDInfo = seqState->stateOffb.table + seqState->stateOffb.state;\n#  endif\n    (void)longOffsets;\n    seq.matchLength = mlDInfo->baseValue;\n    seq.litLength = llDInfo->baseValue;\n    {   U32 const ofBase = ofDInfo->baseValue;\n        BYTE const llBits = llDInfo->nbAdditionalBits;\n        BYTE const mlBits = mlDInfo->nbAdditionalBits;\n        BYTE const ofBits = ofDInfo->nbAdditionalBits;\n        BYTE const totalBits = llBits+mlBits+ofBits;\n\n        U16 const llNext = llDInfo->nextState;\n        U16 const mlNext = mlDInfo->nextState;\n        U16 const ofNext = ofDInfo->nextState;\n        U32 const llnbBits = llDInfo->nbBits;\n        U32 const mlnbBits = mlDInfo->nbBits;\n        U32 const ofnbBits = ofDInfo->nbBits;\n\n        assert(llBits <= MaxLLBits);\n        assert(mlBits <= MaxMLBits);\n        assert(ofBits <= MaxOff);\n        /* As GCC has better branch and block analyzers, sometimes it is only\n         * valuable to mark likeliness for Clang.\n         */\n\n        /* sequence */\n        {   size_t offset;\n            if (ofBits > 1) {\n                ZSTD_STATIC_ASSERT(ZSTD_lo_isLongOffset == 1);\n                ZSTD_STATIC_ASSERT(LONG_OFFSETS_MAX_EXTRA_BITS_32 == 5);\n                ZSTD_STATIC_ASSERT(STREAM_ACCUMULATOR_MIN_32 > LONG_OFFSETS_MAX_EXTRA_BITS_32);\n                ZSTD_STATIC_ASSERT(STREAM_ACCUMULATOR_MIN_32 - LONG_OFFSETS_MAX_EXTRA_BITS_32 >= MaxMLBits);\n                offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/);   /* <=  (ZSTD_WINDOWLOG_MAX-1) bits */\n                prevOffset2 = prevOffset1;\n                prevOffset1 = prevOffset0;\n                prevOffset0 = offset;\n            } else {\n                U32 const ll0 = (llDInfo->baseValue == 0);\n                if (LIKELY((ofBits == 0))) {\n                    if (ll0) {\n                        offset = prevOffset1;\n                        prevOffset1 = prevOffset0;\n                        prevOffset0 = offset;\n                    } else {\n                        offset = prevOffset0;\n                    }\n                } else {\n                    offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1);\n                    {   size_t temp = (offset == 1)   ? prevOffset1\n                                      : (offset == 3) ? prevOffset0 - 1\n                                      : (offset >= 2) ? prevOffset2\n                                      : prevOffset0;\n                        /* 0 is not valid: input corrupted => force offset to -1 =>\n                         * corruption detected at execSequence.\n                         */\n                        temp -= !temp;\n                        prevOffset2 = (offset == 1) ? prevOffset2 : prevOffset1;\n                        prevOffset1 = prevOffset0;\n                        prevOffset0 = offset = temp;\n            }   }   }\n            seq.offset = offset;\n        }\n\n        if (mlBits > 0)\n            seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/);\n\n        if (UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog)))\n            BIT_reloadDStream(&seqState->DStream);\n\n        /* Ensure there are enough bits to read the rest of data in 64-bit mode. */\n        ZSTD_STATIC_ASSERT(16+LLFSELog+MLFSELog+OffFSELog < STREAM_ACCUMULATOR_MIN_64);\n\n        if (llBits > 0)\n            seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/*>0*/);\n\n        DEBUGLOG(6, \"seq: litL=%u, matchL=%u, offset=%u\",\n                    (U32)seq.litLength, (U32)seq.matchLength, (U32)seq.offset);\n\n        if (!isLastSeq) {\n            /* Don't update FSE state for last sequence. */\n            ZSTD_updateFseStateWithDInfo(&seqState->stateLL, &seqState->DStream, llNext, llnbBits);    /* <=  9 bits */\n            ZSTD_updateFseStateWithDInfo(&seqState->stateML, &seqState->DStream, mlNext, mlnbBits);    /* <=  9 bits */\n            ZSTD_updateFseStateWithDInfo(&seqState->stateOffb, &seqState->DStream, ofNext, ofnbBits);  /* <=  8 bits */\n            BIT_reloadDStream(&seqState->DStream);\n        }\n    }\n    seqState->prevOffset[0] = prevOffset0;\n    seqState->prevOffset[1] = prevOffset1;\n    seqState->prevOffset[2] = prevOffset2;\n#else   /* !defined(__aarch64__) */\n    const ZSTD_seqSymbol* const llDInfo = seqState->stateLL.table + seqState->stateLL.state;\n    const ZSTD_seqSymbol* const mlDInfo = seqState->stateML.table + seqState->stateML.state;\n    const ZSTD_seqSymbol* const ofDInfo = seqState->stateOffb.table + seqState->stateOffb.state;\n    seq.matchLength = mlDInfo->baseValue;\n    seq.litLength = llDInfo->baseValue;\n    {   U32 const ofBase = ofDInfo->baseValue;\n        BYTE const llBits = llDInfo->nbAdditionalBits;\n        BYTE const mlBits = mlDInfo->nbAdditionalBits;\n        BYTE const ofBits = ofDInfo->nbAdditionalBits;\n        BYTE const totalBits = llBits+mlBits+ofBits;\n\n        U16 const llNext = llDInfo->nextState;\n        U16 const mlNext = mlDInfo->nextState;\n        U16 const ofNext = ofDInfo->nextState;\n        U32 const llnbBits = llDInfo->nbBits;\n        U32 const mlnbBits = mlDInfo->nbBits;\n        U32 const ofnbBits = ofDInfo->nbBits;\n\n        assert(llBits <= MaxLLBits);\n        assert(mlBits <= MaxMLBits);\n        assert(ofBits <= MaxOff);\n        /* As GCC has better branch and block analyzers, sometimes it is only\n         * valuable to mark likeliness for Clang.\n         */\n\n        /* sequence */\n        {   size_t offset;\n            if (ofBits > 1) {\n                ZSTD_STATIC_ASSERT(ZSTD_lo_isLongOffset == 1);\n                ZSTD_STATIC_ASSERT(LONG_OFFSETS_MAX_EXTRA_BITS_32 == 5);\n                ZSTD_STATIC_ASSERT(STREAM_ACCUMULATOR_MIN_32 > LONG_OFFSETS_MAX_EXTRA_BITS_32);\n                ZSTD_STATIC_ASSERT(STREAM_ACCUMULATOR_MIN_32 - LONG_OFFSETS_MAX_EXTRA_BITS_32 >= MaxMLBits);\n                if (MEM_32bits() && longOffsets && (ofBits >= STREAM_ACCUMULATOR_MIN_32)) {\n                    /* Always read extra bits, this keeps the logic simple,\n                     * avoids branches, and avoids accidentally reading 0 bits.\n                     */\n                    U32 const extraBits = LONG_OFFSETS_MAX_EXTRA_BITS_32;\n                    offset = ofBase + (BIT_readBitsFast(&seqState->DStream, ofBits - extraBits) << extraBits);\n                    BIT_reloadDStream(&seqState->DStream);\n                    offset += BIT_readBitsFast(&seqState->DStream, extraBits);\n                } else {\n                    offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/);   /* <=  (ZSTD_WINDOWLOG_MAX-1) bits */\n                    if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);\n                }\n                seqState->prevOffset[2] = seqState->prevOffset[1];\n                seqState->prevOffset[1] = seqState->prevOffset[0];\n                seqState->prevOffset[0] = offset;\n            } else {\n                U32 const ll0 = (llDInfo->baseValue == 0);\n                if (LIKELY((ofBits == 0))) {\n                    offset = seqState->prevOffset[ll0];\n                    seqState->prevOffset[1] = seqState->prevOffset[!ll0];\n                    seqState->prevOffset[0] = offset;\n                } else {\n                    offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1);\n                    {   size_t temp = (offset==3) ? seqState->prevOffset[0] - 1 : seqState->prevOffset[offset];\n                        temp -= !temp; /* 0 is not valid: input corrupted => force offset to -1 => corruption detected at execSequence */\n                        if (offset != 1) seqState->prevOffset[2] = seqState->prevOffset[1];\n                        seqState->prevOffset[1] = seqState->prevOffset[0];\n                        seqState->prevOffset[0] = offset = temp;\n            }   }   }\n            seq.offset = offset;\n        }\n\n        if (mlBits > 0)\n            seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/);\n\n        if (MEM_32bits() && (mlBits+llBits >= STREAM_ACCUMULATOR_MIN_32-LONG_OFFSETS_MAX_EXTRA_BITS_32))\n            BIT_reloadDStream(&seqState->DStream);\n        if (MEM_64bits() && UNLIKELY(totalBits >= STREAM_ACCUMULATOR_MIN_64-(LLFSELog+MLFSELog+OffFSELog)))\n            BIT_reloadDStream(&seqState->DStream);\n        /* Ensure there are enough bits to read the rest of data in 64-bit mode. */\n        ZSTD_STATIC_ASSERT(16+LLFSELog+MLFSELog+OffFSELog < STREAM_ACCUMULATOR_MIN_64);\n\n        if (llBits > 0)\n            seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/*>0*/);\n\n        if (MEM_32bits())\n            BIT_reloadDStream(&seqState->DStream);\n\n        DEBUGLOG(6, \"seq: litL=%u, matchL=%u, offset=%u\",\n                    (U32)seq.litLength, (U32)seq.matchLength, (U32)seq.offset);\n\n        if (!isLastSeq) {\n            /* Don't update FSE state for last sequence. */\n            ZSTD_updateFseStateWithDInfo(&seqState->stateLL, &seqState->DStream, llNext, llnbBits);    /* <=  9 bits */\n            ZSTD_updateFseStateWithDInfo(&seqState->stateML, &seqState->DStream, mlNext, mlnbBits);    /* <=  9 bits */\n            if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);    /* <= 18 bits */\n            ZSTD_updateFseStateWithDInfo(&seqState->stateOffb, &seqState->DStream, ofNext, ofnbBits);  /* <=  8 bits */\n            BIT_reloadDStream(&seqState->DStream);\n        }\n    }\n#endif  /* defined(__aarch64__) */\n\n    return seq;\n}\n\n#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)\n#if DEBUGLEVEL >= 1\nstatic int ZSTD_dictionaryIsActive(ZSTD_DCtx const* dctx, BYTE const* prefixStart, BYTE const* oLitEnd)\n{\n    size_t const windowSize = dctx->fParams.windowSize;\n    /* No dictionary used. */\n    if (dctx->dictContentEndForFuzzing == NULL) return 0;\n    /* Dictionary is our prefix. */\n    if (prefixStart == dctx->dictContentBeginForFuzzing) return 1;\n    /* Dictionary is not our ext-dict. */\n    if (dctx->dictEnd != dctx->dictContentEndForFuzzing) return 0;\n    /* Dictionary is not within our window size. */\n    if ((size_t)(oLitEnd - prefixStart) >= windowSize) return 0;\n    /* Dictionary is active. */\n    return 1;\n}\n#endif\n\nstatic void ZSTD_assertValidSequence(\n        ZSTD_DCtx const* dctx,\n        BYTE const* op, BYTE const* oend,\n        seq_t const seq,\n        BYTE const* prefixStart, BYTE const* virtualStart)\n{\n#if DEBUGLEVEL >= 1\n    if (dctx->isFrameDecompression) {\n        size_t const windowSize = dctx->fParams.windowSize;\n        size_t const sequenceSize = seq.litLength + seq.matchLength;\n        BYTE const* const oLitEnd = op + seq.litLength;\n        DEBUGLOG(6, \"Checking sequence: litL=%u matchL=%u offset=%u\",\n                (U32)seq.litLength, (U32)seq.matchLength, (U32)seq.offset);\n        assert(op <= oend);\n        assert((size_t)(oend - op) >= sequenceSize);\n        assert(sequenceSize <= ZSTD_blockSizeMax(dctx));\n        if (ZSTD_dictionaryIsActive(dctx, prefixStart, oLitEnd)) {\n            size_t const dictSize = (size_t)((char const*)dctx->dictContentEndForFuzzing - (char const*)dctx->dictContentBeginForFuzzing);\n            /* Offset must be within the dictionary. */\n            assert(seq.offset <= (size_t)(oLitEnd - virtualStart));\n            assert(seq.offset <= windowSize + dictSize);\n        } else {\n            /* Offset must be within our window. */\n            assert(seq.offset <= windowSize);\n        }\n    }\n#else\n    (void)dctx, (void)op, (void)oend, (void)seq, (void)prefixStart, (void)virtualStart;\n#endif\n}\n#endif\n\n#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG\n\n\nFORCE_INLINE_TEMPLATE size_t\nDONT_VECTORIZE\nZSTD_decompressSequences_bodySplitLitBuffer( ZSTD_DCtx* dctx,\n                               void* dst, size_t maxDstSize,\n                         const void* seqStart, size_t seqSize, int nbSeq,\n                         const ZSTD_longOffset_e isLongOffset)\n{\n    BYTE* const ostart = (BYTE*)dst;\n    BYTE* const oend = (BYTE*)ZSTD_maybeNullPtrAdd(ostart, (ptrdiff_t)maxDstSize);\n    BYTE* op = ostart;\n    const BYTE* litPtr = dctx->litPtr;\n    const BYTE* litBufferEnd = dctx->litBufferEnd;\n    const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart);\n    const BYTE* const vBase = (const BYTE*) (dctx->virtualStart);\n    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);\n    DEBUGLOG(5, \"ZSTD_decompressSequences_bodySplitLitBuffer (%i seqs)\", nbSeq);\n\n    /* Literals are split between internal buffer & output buffer */\n    if (nbSeq) {\n        seqState_t seqState;\n        dctx->fseEntropy = 1;\n        { U32 i; for (i=0; ientropy.rep[i]; }\n        RETURN_ERROR_IF(\n            ERR_isError(BIT_initDStream(&seqState.DStream, seqStart, seqSize)),\n            corruption_detected, \"\");\n        ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);\n        ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);\n        ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);\n        assert(dst != NULL);\n\n        ZSTD_STATIC_ASSERT(\n                BIT_DStream_unfinished < BIT_DStream_completed &&\n                BIT_DStream_endOfBuffer < BIT_DStream_completed &&\n                BIT_DStream_completed < BIT_DStream_overflow);\n\n        /* decompress without overrunning litPtr begins */\n        {   seq_t sequence = {0,0,0};  /* some static analyzer believe that @sequence is not initialized (it necessarily is, since for(;;) loop as at least one iteration) */\n            /* Align the decompression loop to 32 + 16 bytes.\n                *\n                * zstd compiled with gcc-9 on an Intel i9-9900k shows 10% decompression\n                * speed swings based on the alignment of the decompression loop. This\n                * performance swing is caused by parts of the decompression loop falling\n                * out of the DSB. The entire decompression loop should fit in the DSB,\n                * when it can't we get much worse performance. You can measure if you've\n                * hit the good case or the bad case with this perf command for some\n                * compressed file test.zst:\n                *\n                *   perf stat -e cycles -e instructions -e idq.all_dsb_cycles_any_uops \\\n                *             -e idq.all_mite_cycles_any_uops -- ./zstd -tq test.zst\n                *\n                * If you see most cycles served out of the MITE you've hit the bad case.\n                * If you see most cycles served out of the DSB you've hit the good case.\n                * If it is pretty even then you may be in an okay case.\n                *\n                * This issue has been reproduced on the following CPUs:\n                *   - Kabylake: Macbook Pro (15-inch, 2019) 2.4 GHz Intel Core i9\n                *               Use Instruments->Counters to get DSB/MITE cycles.\n                *               I never got performance swings, but I was able to\n                *               go from the good case of mostly DSB to half of the\n                *               cycles served from MITE.\n                *   - Coffeelake: Intel i9-9900k\n                *   - Coffeelake: Intel i7-9700k\n                *\n                * I haven't been able to reproduce the instability or DSB misses on any\n                * of the following CPUS:\n                *   - Haswell\n                *   - Broadwell: Intel(R) Xeon(R) CPU E5-2680 v4 @ 2.40GH\n                *   - Skylake\n                *\n                * Alignment is done for each of the three major decompression loops:\n                *   - ZSTD_decompressSequences_bodySplitLitBuffer - presplit section of the literal buffer\n                *   - ZSTD_decompressSequences_bodySplitLitBuffer - postsplit section of the literal buffer\n                *   - ZSTD_decompressSequences_body\n                * Alignment choices are made to minimize large swings on bad cases and influence on performance\n                * from changes external to this code, rather than to overoptimize on the current commit.\n                *\n                * If you are seeing performance stability this script can help test.\n                * It tests on 4 commits in zstd where I saw performance change.\n                *\n                *   https://gist.github.com/terrelln/9889fc06a423fd5ca6e99351564473f4\n                */\n#if defined(__GNUC__) && defined(__x86_64__)\n            __asm__(\".p2align 6\");\n#  if __GNUC__ >= 7\n\t    /* good for gcc-7, gcc-9, and gcc-11 */\n            __asm__(\"nop\");\n            __asm__(\".p2align 5\");\n            __asm__(\"nop\");\n            __asm__(\".p2align 4\");\n#    if __GNUC__ == 8 || __GNUC__ == 10\n\t    /* good for gcc-8 and gcc-10 */\n            __asm__(\"nop\");\n            __asm__(\".p2align 3\");\n#    endif\n#  endif\n#endif\n\n            /* Handle the initial state where litBuffer is currently split between dst and litExtraBuffer */\n            for ( ; nbSeq; nbSeq--) {\n                sequence = ZSTD_decodeSequence(&seqState, isLongOffset, nbSeq==1);\n                if (litPtr + sequence.litLength > dctx->litBufferEnd) break;\n                {   size_t const oneSeqSize = ZSTD_execSequenceSplitLitBuffer(op, oend, litPtr + sequence.litLength - WILDCOPY_OVERLENGTH, sequence, &litPtr, litBufferEnd, prefixStart, vBase, dictEnd);\n#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)\n                    assert(!ZSTD_isError(oneSeqSize));\n                    ZSTD_assertValidSequence(dctx, op, oend, sequence, prefixStart, vBase);\n#endif\n                    if (UNLIKELY(ZSTD_isError(oneSeqSize)))\n                        return oneSeqSize;\n                    DEBUGLOG(6, \"regenerated sequence size : %u\", (U32)oneSeqSize);\n                    op += oneSeqSize;\n            }   }\n            DEBUGLOG(6, \"reached: (litPtr + sequence.litLength > dctx->litBufferEnd)\");\n\n            /* If there are more sequences, they will need to read literals from litExtraBuffer; copy over the remainder from dst and update litPtr and litEnd */\n            if (nbSeq > 0) {\n                const size_t leftoverLit = (size_t)(dctx->litBufferEnd - litPtr);\n                assert(dctx->litBufferEnd >= litPtr);\n                DEBUGLOG(6, \"There are %i sequences left, and %zu/%zu literals left in buffer\", nbSeq, leftoverLit, sequence.litLength);\n                if (leftoverLit) {\n                    RETURN_ERROR_IF(leftoverLit > (size_t)(oend - op), dstSize_tooSmall, \"remaining lit must fit within dstBuffer\");\n                    ZSTD_safecopyDstBeforeSrc(op, litPtr, leftoverLit);\n                    sequence.litLength -= leftoverLit;\n                    op += leftoverLit;\n                }\n                litPtr = dctx->litExtraBuffer;\n                litBufferEnd = dctx->litExtraBuffer + ZSTD_LITBUFFEREXTRASIZE;\n                dctx->litBufferLocation = ZSTD_not_in_dst;\n                {   size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litBufferEnd, prefixStart, vBase, dictEnd);\n#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)\n                    assert(!ZSTD_isError(oneSeqSize));\n                    ZSTD_assertValidSequence(dctx, op, oend, sequence, prefixStart, vBase);\n#endif\n                    if (UNLIKELY(ZSTD_isError(oneSeqSize)))\n                        return oneSeqSize;\n                    DEBUGLOG(6, \"regenerated sequence size : %u\", (U32)oneSeqSize);\n                    op += oneSeqSize;\n                }\n                nbSeq--;\n            }\n        }\n\n        if (nbSeq > 0) {\n            /* there is remaining lit from extra buffer */\n\n#if defined(__GNUC__) && defined(__x86_64__)\n            __asm__(\".p2align 6\");\n            __asm__(\"nop\");\n#  if __GNUC__ != 7\n            /* worse for gcc-7 better for gcc-8, gcc-9, and gcc-10 and clang */\n            __asm__(\".p2align 4\");\n            __asm__(\"nop\");\n            __asm__(\".p2align 3\");\n#  elif __GNUC__ >= 11\n            __asm__(\".p2align 3\");\n#  else\n            __asm__(\".p2align 5\");\n            __asm__(\"nop\");\n            __asm__(\".p2align 3\");\n#  endif\n#endif\n\n            for ( ; nbSeq ; nbSeq--) {\n                seq_t const sequence = ZSTD_decodeSequence(&seqState, isLongOffset, nbSeq==1);\n                size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litBufferEnd, prefixStart, vBase, dictEnd);\n#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)\n                assert(!ZSTD_isError(oneSeqSize));\n                ZSTD_assertValidSequence(dctx, op, oend, sequence, prefixStart, vBase);\n#endif\n                if (UNLIKELY(ZSTD_isError(oneSeqSize)))\n                    return oneSeqSize;\n                DEBUGLOG(6, \"regenerated sequence size : %u\", (U32)oneSeqSize);\n                op += oneSeqSize;\n            }\n        }\n\n        /* check if reached exact end */\n        DEBUGLOG(5, \"ZSTD_decompressSequences_bodySplitLitBuffer: after decode loop, remaining nbSeq : %i\", nbSeq);\n        RETURN_ERROR_IF(nbSeq, corruption_detected, \"\");\n        DEBUGLOG(5, \"bitStream : start=%p, ptr=%p, bitsConsumed=%u\", seqState.DStream.start, seqState.DStream.ptr, seqState.DStream.bitsConsumed);\n        RETURN_ERROR_IF(!BIT_endOfDStream(&seqState.DStream), corruption_detected, \"\");\n        /* save reps for next block */\n        { U32 i; for (i=0; ientropy.rep[i] = (U32)(seqState.prevOffset[i]); }\n    }\n\n    /* last literal segment */\n    if (dctx->litBufferLocation == ZSTD_split) {\n        /* split hasn't been reached yet, first get dst then copy litExtraBuffer */\n        size_t const lastLLSize = (size_t)(litBufferEnd - litPtr);\n        DEBUGLOG(6, \"copy last literals from segment : %u\", (U32)lastLLSize);\n        RETURN_ERROR_IF(lastLLSize > (size_t)(oend - op), dstSize_tooSmall, \"\");\n        if (op != NULL) {\n            ZSTD_memmove(op, litPtr, lastLLSize);\n            op += lastLLSize;\n        }\n        litPtr = dctx->litExtraBuffer;\n        litBufferEnd = dctx->litExtraBuffer + ZSTD_LITBUFFEREXTRASIZE;\n        dctx->litBufferLocation = ZSTD_not_in_dst;\n    }\n    /* copy last literals from internal buffer */\n    {   size_t const lastLLSize = (size_t)(litBufferEnd - litPtr);\n        DEBUGLOG(6, \"copy last literals from internal buffer : %u\", (U32)lastLLSize);\n        RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall, \"\");\n        if (op != NULL) {\n            ZSTD_memcpy(op, litPtr, lastLLSize);\n            op += lastLLSize;\n    }   }\n\n    DEBUGLOG(6, \"decoded block of size %u bytes\", (U32)(op - ostart));\n    return (size_t)(op - ostart);\n}\n\nFORCE_INLINE_TEMPLATE size_t\nDONT_VECTORIZE\nZSTD_decompressSequences_body(ZSTD_DCtx* dctx,\n    void* dst, size_t maxDstSize,\n    const void* seqStart, size_t seqSize, int nbSeq,\n    const ZSTD_longOffset_e isLongOffset)\n{\n    BYTE* const ostart = (BYTE*)dst;\n    BYTE* const oend = (dctx->litBufferLocation == ZSTD_not_in_dst) ?\n                        (BYTE*)ZSTD_maybeNullPtrAdd(ostart, (ptrdiff_t)maxDstSize) :\n                        dctx->litBuffer;\n    BYTE* op = ostart;\n    const BYTE* litPtr = dctx->litPtr;\n    const BYTE* const litEnd = litPtr + dctx->litSize;\n    const BYTE* const prefixStart = (const BYTE*)(dctx->prefixStart);\n    const BYTE* const vBase = (const BYTE*)(dctx->virtualStart);\n    const BYTE* const dictEnd = (const BYTE*)(dctx->dictEnd);\n    DEBUGLOG(5, \"ZSTD_decompressSequences_body: nbSeq = %d\", nbSeq);\n\n    /* Regen sequences */\n    if (nbSeq) {\n        seqState_t seqState;\n        dctx->fseEntropy = 1;\n        { U32 i; for (i = 0; i < ZSTD_REP_NUM; i++) seqState.prevOffset[i] = dctx->entropy.rep[i]; }\n        RETURN_ERROR_IF(\n            ERR_isError(BIT_initDStream(&seqState.DStream, seqStart, seqSize)),\n            corruption_detected, \"\");\n        ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);\n        ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);\n        ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);\n        assert(dst != NULL);\n\n#if defined(__GNUC__) && defined(__x86_64__)\n            __asm__(\".p2align 6\");\n            __asm__(\"nop\");\n#  if __GNUC__ >= 7\n            __asm__(\".p2align 5\");\n            __asm__(\"nop\");\n            __asm__(\".p2align 3\");\n#  else\n            __asm__(\".p2align 4\");\n            __asm__(\"nop\");\n            __asm__(\".p2align 3\");\n#  endif\n#endif\n\n        for ( ; nbSeq ; nbSeq--) {\n            seq_t const sequence = ZSTD_decodeSequence(&seqState, isLongOffset, nbSeq==1);\n            size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequence, &litPtr, litEnd, prefixStart, vBase, dictEnd);\n#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)\n            assert(!ZSTD_isError(oneSeqSize));\n            ZSTD_assertValidSequence(dctx, op, oend, sequence, prefixStart, vBase);\n#endif\n            if (UNLIKELY(ZSTD_isError(oneSeqSize)))\n                return oneSeqSize;\n            DEBUGLOG(6, \"regenerated sequence size : %u\", (U32)oneSeqSize);\n            op += oneSeqSize;\n        }\n\n        /* check if reached exact end */\n        assert(nbSeq == 0);\n        RETURN_ERROR_IF(!BIT_endOfDStream(&seqState.DStream), corruption_detected, \"\");\n        /* save reps for next block */\n        { U32 i; for (i=0; ientropy.rep[i] = (U32)(seqState.prevOffset[i]); }\n    }\n\n    /* last literal segment */\n    {   size_t const lastLLSize = (size_t)(litEnd - litPtr);\n        DEBUGLOG(6, \"copy last literals : %u\", (U32)lastLLSize);\n        RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall, \"\");\n        if (op != NULL) {\n            ZSTD_memcpy(op, litPtr, lastLLSize);\n            op += lastLLSize;\n    }   }\n\n    DEBUGLOG(6, \"decoded block of size %u bytes\", (U32)(op - ostart));\n    return (size_t)(op - ostart);\n}\n\nstatic size_t\nZSTD_decompressSequences_default(ZSTD_DCtx* dctx,\n                                 void* dst, size_t maxDstSize,\n                           const void* seqStart, size_t seqSize, int nbSeq,\n                           const ZSTD_longOffset_e isLongOffset)\n{\n    return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);\n}\n\nstatic size_t\nZSTD_decompressSequencesSplitLitBuffer_default(ZSTD_DCtx* dctx,\n                                               void* dst, size_t maxDstSize,\n                                         const void* seqStart, size_t seqSize, int nbSeq,\n                                         const ZSTD_longOffset_e isLongOffset)\n{\n    return ZSTD_decompressSequences_bodySplitLitBuffer(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);\n}\n#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */\n\n#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT\n\nFORCE_INLINE_TEMPLATE\n\nsize_t ZSTD_prefetchMatch(size_t prefetchPos, seq_t const sequence,\n                   const BYTE* const prefixStart, const BYTE* const dictEnd)\n{\n    prefetchPos += sequence.litLength;\n    {   const BYTE* const matchBase = (sequence.offset > prefetchPos) ? dictEnd : prefixStart;\n        /* note : this operation can overflow when seq.offset is really too large, which can only happen when input is corrupted.\n         * No consequence though : memory address is only used for prefetching, not for dereferencing */\n        const BYTE* const match = (const BYTE*)ZSTD_wrappedPtrSub(ZSTD_wrappedPtrAdd(matchBase, (ptrdiff_t)prefetchPos), (ptrdiff_t)sequence.offset);\n        PREFETCH_L1(match); PREFETCH_L1(ZSTD_wrappedPtrAdd(match, CACHELINE_SIZE));   /* note : it's safe to invoke PREFETCH() on any memory address, including invalid ones */\n    }\n    return prefetchPos + sequence.matchLength;\n}\n\n/* This decoding function employs prefetching\n * to reduce latency impact of cache misses.\n * It's generally employed when block contains a significant portion of long-distance matches\n * or when coupled with a \"cold\" dictionary */\nFORCE_INLINE_TEMPLATE size_t\nZSTD_decompressSequencesLong_body(\n                               ZSTD_DCtx* dctx,\n                               void* dst, size_t maxDstSize,\n                         const void* seqStart, size_t seqSize, int nbSeq,\n                         const ZSTD_longOffset_e isLongOffset)\n{\n    BYTE* const ostart = (BYTE*)dst;\n    BYTE* const oend = (dctx->litBufferLocation == ZSTD_in_dst) ?\n                        dctx->litBuffer :\n                        (BYTE*)ZSTD_maybeNullPtrAdd(ostart, (ptrdiff_t)maxDstSize);\n    BYTE* op = ostart;\n    const BYTE* litPtr = dctx->litPtr;\n    const BYTE* litBufferEnd = dctx->litBufferEnd;\n    const BYTE* const prefixStart = (const BYTE*) (dctx->prefixStart);\n    const BYTE* const dictStart = (const BYTE*) (dctx->virtualStart);\n    const BYTE* const dictEnd = (const BYTE*) (dctx->dictEnd);\n\n    /* Regen sequences */\n    if (nbSeq) {\n#define STORED_SEQS 8\n#define STORED_SEQS_MASK (STORED_SEQS-1)\n#define ADVANCED_SEQS STORED_SEQS\n        seq_t sequences[STORED_SEQS];\n        int const seqAdvance = MIN(nbSeq, ADVANCED_SEQS);\n        seqState_t seqState;\n        int seqNb;\n        size_t prefetchPos = (size_t)(op-prefixStart); /* track position relative to prefixStart */\n\n        dctx->fseEntropy = 1;\n        { int i; for (i=0; ientropy.rep[i]; }\n        assert(dst != NULL);\n        RETURN_ERROR_IF(\n            ERR_isError(BIT_initDStream(&seqState.DStream, seqStart, seqSize)),\n            corruption_detected, \"\");\n        ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);\n        ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);\n        ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);\n\n        /* prepare in advance */\n        for (seqNb=0; seqNblitBufferLocation == ZSTD_split && litPtr + sequences[(seqNb - ADVANCED_SEQS) & STORED_SEQS_MASK].litLength > dctx->litBufferEnd) {\n                /* lit buffer is reaching split point, empty out the first buffer and transition to litExtraBuffer */\n                const size_t leftoverLit = (size_t)(dctx->litBufferEnd - litPtr);\n                assert(dctx->litBufferEnd >= litPtr);\n                if (leftoverLit) {\n                    RETURN_ERROR_IF(leftoverLit > (size_t)(oend - op), dstSize_tooSmall, \"remaining lit must fit within dstBuffer\");\n                    ZSTD_safecopyDstBeforeSrc(op, litPtr, leftoverLit);\n                    sequences[(seqNb - ADVANCED_SEQS) & STORED_SEQS_MASK].litLength -= leftoverLit;\n                    op += leftoverLit;\n                }\n                litPtr = dctx->litExtraBuffer;\n                litBufferEnd = dctx->litExtraBuffer + ZSTD_LITBUFFEREXTRASIZE;\n                dctx->litBufferLocation = ZSTD_not_in_dst;\n                {   size_t const oneSeqSize = ZSTD_execSequence(op, oend, sequences[(seqNb - ADVANCED_SEQS) & STORED_SEQS_MASK], &litPtr, litBufferEnd, prefixStart, dictStart, dictEnd);\n#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)\n                    assert(!ZSTD_isError(oneSeqSize));\n                    ZSTD_assertValidSequence(dctx, op, oend, sequences[(seqNb - ADVANCED_SEQS) & STORED_SEQS_MASK], prefixStart, dictStart);\n#endif\n                    if (ZSTD_isError(oneSeqSize)) return oneSeqSize;\n\n                    prefetchPos = ZSTD_prefetchMatch(prefetchPos, sequence, prefixStart, dictEnd);\n                    sequences[seqNb & STORED_SEQS_MASK] = sequence;\n                    op += oneSeqSize;\n            }   }\n            else\n            {\n                /* lit buffer is either wholly contained in first or second split, or not split at all*/\n                size_t const oneSeqSize = dctx->litBufferLocation == ZSTD_split ?\n                    ZSTD_execSequenceSplitLitBuffer(op, oend, litPtr + sequences[(seqNb - ADVANCED_SEQS) & STORED_SEQS_MASK].litLength - WILDCOPY_OVERLENGTH, sequences[(seqNb - ADVANCED_SEQS) & STORED_SEQS_MASK], &litPtr, litBufferEnd, prefixStart, dictStart, dictEnd) :\n                    ZSTD_execSequence(op, oend, sequences[(seqNb - ADVANCED_SEQS) & STORED_SEQS_MASK], &litPtr, litBufferEnd, prefixStart, dictStart, dictEnd);\n#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)\n                assert(!ZSTD_isError(oneSeqSize));\n                ZSTD_assertValidSequence(dctx, op, oend, sequences[(seqNb - ADVANCED_SEQS) & STORED_SEQS_MASK], prefixStart, dictStart);\n#endif\n                if (ZSTD_isError(oneSeqSize)) return oneSeqSize;\n\n                prefetchPos = ZSTD_prefetchMatch(prefetchPos, sequence, prefixStart, dictEnd);\n                sequences[seqNb & STORED_SEQS_MASK] = sequence;\n                op += oneSeqSize;\n            }\n        }\n        RETURN_ERROR_IF(!BIT_endOfDStream(&seqState.DStream), corruption_detected, \"\");\n\n        /* finish queue */\n        seqNb -= seqAdvance;\n        for ( ; seqNblitBufferLocation == ZSTD_split && litPtr + sequence->litLength > dctx->litBufferEnd) {\n                const size_t leftoverLit = (size_t)(dctx->litBufferEnd - litPtr);\n                assert(dctx->litBufferEnd >= litPtr);\n                if (leftoverLit) {\n                    RETURN_ERROR_IF(leftoverLit > (size_t)(oend - op), dstSize_tooSmall, \"remaining lit must fit within dstBuffer\");\n                    ZSTD_safecopyDstBeforeSrc(op, litPtr, leftoverLit);\n                    sequence->litLength -= leftoverLit;\n                    op += leftoverLit;\n                }\n                litPtr = dctx->litExtraBuffer;\n                litBufferEnd = dctx->litExtraBuffer + ZSTD_LITBUFFEREXTRASIZE;\n                dctx->litBufferLocation = ZSTD_not_in_dst;\n                {   size_t const oneSeqSize = ZSTD_execSequence(op, oend, *sequence, &litPtr, litBufferEnd, prefixStart, dictStart, dictEnd);\n#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)\n                    assert(!ZSTD_isError(oneSeqSize));\n                    ZSTD_assertValidSequence(dctx, op, oend, sequences[seqNb&STORED_SEQS_MASK], prefixStart, dictStart);\n#endif\n                    if (ZSTD_isError(oneSeqSize)) return oneSeqSize;\n                    op += oneSeqSize;\n                }\n            }\n            else\n            {\n                size_t const oneSeqSize = dctx->litBufferLocation == ZSTD_split ?\n                    ZSTD_execSequenceSplitLitBuffer(op, oend, litPtr + sequence->litLength - WILDCOPY_OVERLENGTH, *sequence, &litPtr, litBufferEnd, prefixStart, dictStart, dictEnd) :\n                    ZSTD_execSequence(op, oend, *sequence, &litPtr, litBufferEnd, prefixStart, dictStart, dictEnd);\n#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && defined(FUZZING_ASSERT_VALID_SEQUENCE)\n                assert(!ZSTD_isError(oneSeqSize));\n                ZSTD_assertValidSequence(dctx, op, oend, sequences[seqNb&STORED_SEQS_MASK], prefixStart, dictStart);\n#endif\n                if (ZSTD_isError(oneSeqSize)) return oneSeqSize;\n                op += oneSeqSize;\n            }\n        }\n\n        /* save reps for next block */\n        { U32 i; for (i=0; ientropy.rep[i] = (U32)(seqState.prevOffset[i]); }\n    }\n\n    /* last literal segment */\n    if (dctx->litBufferLocation == ZSTD_split) { /* first deplete literal buffer in dst, then copy litExtraBuffer */\n        size_t const lastLLSize = (size_t)(litBufferEnd - litPtr);\n        assert(litBufferEnd >= litPtr);\n        RETURN_ERROR_IF(lastLLSize > (size_t)(oend - op), dstSize_tooSmall, \"\");\n        if (op != NULL) {\n            ZSTD_memmove(op, litPtr, lastLLSize);\n            op += lastLLSize;\n        }\n        litPtr = dctx->litExtraBuffer;\n        litBufferEnd = dctx->litExtraBuffer + ZSTD_LITBUFFEREXTRASIZE;\n    }\n    {   size_t const lastLLSize = (size_t)(litBufferEnd - litPtr);\n        assert(litBufferEnd >= litPtr);\n        RETURN_ERROR_IF(lastLLSize > (size_t)(oend-op), dstSize_tooSmall, \"\");\n        if (op != NULL) {\n            ZSTD_memmove(op, litPtr, lastLLSize);\n            op += lastLLSize;\n        }\n    }\n\n    return (size_t)(op - ostart);\n}\n\nstatic size_t\nZSTD_decompressSequencesLong_default(ZSTD_DCtx* dctx,\n                                 void* dst, size_t maxDstSize,\n                           const void* seqStart, size_t seqSize, int nbSeq,\n                           const ZSTD_longOffset_e isLongOffset)\n{\n    return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);\n}\n#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */\n\n\n\n#if DYNAMIC_BMI2\n\n#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG\nstatic BMI2_TARGET_ATTRIBUTE size_t\nDONT_VECTORIZE\nZSTD_decompressSequences_bmi2(ZSTD_DCtx* dctx,\n                                 void* dst, size_t maxDstSize,\n                           const void* seqStart, size_t seqSize, int nbSeq,\n                           const ZSTD_longOffset_e isLongOffset)\n{\n    return ZSTD_decompressSequences_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);\n}\nstatic BMI2_TARGET_ATTRIBUTE size_t\nDONT_VECTORIZE\nZSTD_decompressSequencesSplitLitBuffer_bmi2(ZSTD_DCtx* dctx,\n                                 void* dst, size_t maxDstSize,\n                           const void* seqStart, size_t seqSize, int nbSeq,\n                           const ZSTD_longOffset_e isLongOffset)\n{\n    return ZSTD_decompressSequences_bodySplitLitBuffer(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);\n}\n#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */\n\n#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT\nstatic BMI2_TARGET_ATTRIBUTE size_t\nZSTD_decompressSequencesLong_bmi2(ZSTD_DCtx* dctx,\n                                 void* dst, size_t maxDstSize,\n                           const void* seqStart, size_t seqSize, int nbSeq,\n                           const ZSTD_longOffset_e isLongOffset)\n{\n    return ZSTD_decompressSequencesLong_body(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);\n}\n#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */\n\n#endif /* DYNAMIC_BMI2 */\n\n#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG\nstatic size_t\nZSTD_decompressSequences(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize,\n                   const void* seqStart, size_t seqSize, int nbSeq,\n                   const ZSTD_longOffset_e isLongOffset)\n{\n    DEBUGLOG(5, \"ZSTD_decompressSequences\");\n#if DYNAMIC_BMI2\n    if (ZSTD_DCtx_get_bmi2(dctx)) {\n        return ZSTD_decompressSequences_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);\n    }\n#endif\n    return ZSTD_decompressSequences_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);\n}\nstatic size_t\nZSTD_decompressSequencesSplitLitBuffer(ZSTD_DCtx* dctx, void* dst, size_t maxDstSize,\n                                 const void* seqStart, size_t seqSize, int nbSeq,\n                                 const ZSTD_longOffset_e isLongOffset)\n{\n    DEBUGLOG(5, \"ZSTD_decompressSequencesSplitLitBuffer\");\n#if DYNAMIC_BMI2\n    if (ZSTD_DCtx_get_bmi2(dctx)) {\n        return ZSTD_decompressSequencesSplitLitBuffer_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);\n    }\n#endif\n    return ZSTD_decompressSequencesSplitLitBuffer_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);\n}\n#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG */\n\n\n#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT\n/* ZSTD_decompressSequencesLong() :\n * decompression function triggered when a minimum share of offsets is considered \"long\",\n * aka out of cache.\n * note : \"long\" definition seems overloaded here, sometimes meaning \"wider than bitstream register\", and sometimes meaning \"farther than memory cache distance\".\n * This function will try to mitigate main memory latency through the use of prefetching */\nstatic size_t\nZSTD_decompressSequencesLong(ZSTD_DCtx* dctx,\n                             void* dst, size_t maxDstSize,\n                             const void* seqStart, size_t seqSize, int nbSeq,\n                             const ZSTD_longOffset_e isLongOffset)\n{\n    DEBUGLOG(5, \"ZSTD_decompressSequencesLong\");\n#if DYNAMIC_BMI2\n    if (ZSTD_DCtx_get_bmi2(dctx)) {\n        return ZSTD_decompressSequencesLong_bmi2(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);\n    }\n#endif\n  return ZSTD_decompressSequencesLong_default(dctx, dst, maxDstSize, seqStart, seqSize, nbSeq, isLongOffset);\n}\n#endif /* ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT */\n\n\n/**\n * @returns The total size of the history referenceable by zstd, including\n * both the prefix and the extDict. At @p op any offset larger than this\n * is invalid.\n */\nstatic size_t ZSTD_totalHistorySize(void* curPtr, const void* virtualStart)\n{\n    return (size_t)((char*)curPtr - (const char*)virtualStart);\n}\n\ntypedef struct {\n    unsigned longOffsetShare;\n    unsigned maxNbAdditionalBits;\n} ZSTD_OffsetInfo;\n\n/* ZSTD_getOffsetInfo() :\n * condition : offTable must be valid\n * @return : \"share\" of long offsets (arbitrarily defined as > (1<<23))\n *           compared to maximum possible of (1< 22) info.longOffsetShare += 1;\n        }\n\n        assert(tableLog <= OffFSELog);\n        info.longOffsetShare <<= (OffFSELog - tableLog);  /* scale to OffFSELog */\n    }\n\n    return info;\n}\n\n/**\n * @returns The maximum offset we can decode in one read of our bitstream, without\n * reloading more bits in the middle of the offset bits read. Any offsets larger\n * than this must use the long offset decoder.\n */\nstatic size_t ZSTD_maxShortOffset(void)\n{\n    if (MEM_64bits()) {\n        /* We can decode any offset without reloading bits.\n         * This might change if the max window size grows.\n         */\n        ZSTD_STATIC_ASSERT(ZSTD_WINDOWLOG_MAX <= 31);\n        return (size_t)-1;\n    } else {\n        /* The maximum offBase is (1 << (STREAM_ACCUMULATOR_MIN + 1)) - 1.\n         * This offBase would require STREAM_ACCUMULATOR_MIN extra bits.\n         * Then we have to subtract ZSTD_REP_NUM to get the maximum possible offset.\n         */\n        size_t const maxOffbase = ((size_t)1 << (STREAM_ACCUMULATOR_MIN + 1)) - 1;\n        size_t const maxOffset = maxOffbase - ZSTD_REP_NUM;\n        assert(ZSTD_highbit32((U32)maxOffbase) == STREAM_ACCUMULATOR_MIN);\n        return maxOffset;\n    }\n}\n\nsize_t\nZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,\n                              void* dst, size_t dstCapacity,\n                        const void* src, size_t srcSize, const streaming_operation streaming)\n{   /* blockType == blockCompressed */\n    const BYTE* ip = (const BYTE*)src;\n    DEBUGLOG(5, \"ZSTD_decompressBlock_internal (cSize : %u)\", (unsigned)srcSize);\n\n    /* Note : the wording of the specification\n     * allows compressed block to be sized exactly ZSTD_blockSizeMax(dctx).\n     * This generally does not happen, as it makes little sense,\n     * since an uncompressed block would feature same size and have no decompression cost.\n     * Also, note that decoder from reference libzstd before < v1.5.4\n     * would consider this edge case as an error.\n     * As a consequence, avoid generating compressed blocks of size ZSTD_blockSizeMax(dctx)\n     * for broader compatibility with the deployed ecosystem of zstd decoders */\n    RETURN_ERROR_IF(srcSize > ZSTD_blockSizeMax(dctx), srcSize_wrong, \"\");\n\n    /* Decode literals section */\n    {   size_t const litCSize = ZSTD_decodeLiteralsBlock(dctx, src, srcSize, dst, dstCapacity, streaming);\n        DEBUGLOG(5, \"ZSTD_decodeLiteralsBlock : cSize=%u, nbLiterals=%zu\", (U32)litCSize, dctx->litSize);\n        if (ZSTD_isError(litCSize)) return litCSize;\n        ip += litCSize;\n        srcSize -= litCSize;\n    }\n\n    /* Build Decoding Tables */\n    {\n        /* Compute the maximum block size, which must also work when !frame and fParams are unset.\n         * Additionally, take the min with dstCapacity to ensure that the totalHistorySize fits in a size_t.\n         */\n        size_t const blockSizeMax = MIN(dstCapacity, ZSTD_blockSizeMax(dctx));\n        size_t const totalHistorySize = ZSTD_totalHistorySize(ZSTD_maybeNullPtrAdd(dst, (ptrdiff_t)blockSizeMax), (BYTE const*)dctx->virtualStart);\n        /* isLongOffset must be true if there are long offsets.\n         * Offsets are long if they are larger than ZSTD_maxShortOffset().\n         * We don't expect that to be the case in 64-bit mode.\n         *\n         * We check here to see if our history is large enough to allow long offsets.\n         * If it isn't, then we can't possible have (valid) long offsets. If the offset\n         * is invalid, then it is okay to read it incorrectly.\n         *\n         * If isLongOffsets is true, then we will later check our decoding table to see\n         * if it is even possible to generate long offsets.\n         */\n        ZSTD_longOffset_e isLongOffset = (ZSTD_longOffset_e)(MEM_32bits() && (totalHistorySize > ZSTD_maxShortOffset()));\n        /* These macros control at build-time which decompressor implementation\n         * we use. If neither is defined, we do some inspection and dispatch at\n         * runtime.\n         */\n#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \\\n    !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)\n        int usePrefetchDecoder = dctx->ddictIsCold;\n#else\n        /* Set to 1 to avoid computing offset info if we don't need to.\n         * Otherwise this value is ignored.\n         */\n        int usePrefetchDecoder = 1;\n#endif\n        int nbSeq;\n        size_t const seqHSize = ZSTD_decodeSeqHeaders(dctx, &nbSeq, ip, srcSize);\n        if (ZSTD_isError(seqHSize)) return seqHSize;\n        ip += seqHSize;\n        srcSize -= seqHSize;\n\n        RETURN_ERROR_IF((dst == NULL || dstCapacity == 0) && nbSeq > 0, dstSize_tooSmall, \"NULL not handled\");\n        RETURN_ERROR_IF(MEM_64bits() && sizeof(size_t) == sizeof(void*) && (size_t)(-1) - (size_t)dst < (size_t)(1 << 20), dstSize_tooSmall,\n                \"invalid dst\");\n\n        /* If we could potentially have long offsets, or we might want to use the prefetch decoder,\n         * compute information about the share of long offsets, and the maximum nbAdditionalBits.\n         * NOTE: could probably use a larger nbSeq limit\n         */\n        if (isLongOffset || (!usePrefetchDecoder && (totalHistorySize > (1u << 24)) && (nbSeq > 8))) {\n            ZSTD_OffsetInfo const info = ZSTD_getOffsetInfo(dctx->OFTptr, nbSeq);\n            if (isLongOffset && info.maxNbAdditionalBits <= STREAM_ACCUMULATOR_MIN) {\n                /* If isLongOffset, but the maximum number of additional bits that we see in our table is small\n                 * enough, then we know it is impossible to have too long an offset in this block, so we can\n                 * use the regular offset decoder.\n                 */\n                isLongOffset = ZSTD_lo_isRegularOffset;\n            }\n            if (!usePrefetchDecoder) {\n                U32 const minShare = MEM_64bits() ? 7 : 20; /* heuristic values, correspond to 2.73% and 7.81% */\n                usePrefetchDecoder = (info.longOffsetShare >= minShare);\n            }\n        }\n\n        dctx->ddictIsCold = 0;\n\n#if !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT) && \\\n    !defined(ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG)\n        if (usePrefetchDecoder) {\n#else\n        (void)usePrefetchDecoder;\n        {\n#endif\n#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_SHORT\n            return ZSTD_decompressSequencesLong(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset);\n#endif\n        }\n\n#ifndef ZSTD_FORCE_DECOMPRESS_SEQUENCES_LONG\n        /* else */\n        if (dctx->litBufferLocation == ZSTD_split)\n            return ZSTD_decompressSequencesSplitLitBuffer(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset);\n        else\n            return ZSTD_decompressSequences(dctx, dst, dstCapacity, ip, srcSize, nbSeq, isLongOffset);\n#endif\n    }\n}\n\n\nZSTD_ALLOW_POINTER_OVERFLOW_ATTR\nvoid ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst, size_t dstSize)\n{\n    if (dst != dctx->previousDstEnd && dstSize > 0) {   /* not contiguous */\n        dctx->dictEnd = dctx->previousDstEnd;\n        dctx->virtualStart = (const char*)dst - ((const char*)(dctx->previousDstEnd) - (const char*)(dctx->prefixStart));\n        dctx->prefixStart = dst;\n        dctx->previousDstEnd = dst;\n    }\n}\n\n\nsize_t ZSTD_decompressBlock_deprecated(ZSTD_DCtx* dctx,\n                                       void* dst, size_t dstCapacity,\n                                 const void* src, size_t srcSize)\n{\n    size_t dSize;\n    dctx->isFrameDecompression = 0;\n    ZSTD_checkContinuity(dctx, dst, dstCapacity);\n    dSize = ZSTD_decompressBlock_internal(dctx, dst, dstCapacity, src, srcSize, not_streaming);\n    FORWARD_IF_ERROR(dSize, \"\");\n    dctx->previousDstEnd = (char*)dst + dSize;\n    return dSize;\n}\n\n\n/* NOTE: Must just wrap ZSTD_decompressBlock_deprecated() */\nsize_t ZSTD_decompressBlock(ZSTD_DCtx* dctx,\n                            void* dst, size_t dstCapacity,\n                      const void* src, size_t srcSize)\n{\n    return ZSTD_decompressBlock_deprecated(dctx, dst, dstCapacity, src, srcSize);\n}\n"
  },
  {
    "path": "lib/decompress/zstd_decompress_block.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n\n#ifndef ZSTD_DEC_BLOCK_H\n#define ZSTD_DEC_BLOCK_H\n\n/*-*******************************************************\n *  Dependencies\n *********************************************************/\n#include \"../common/zstd_deps.h\"   /* size_t */\n#include \"../zstd.h\"    /* DCtx, and some public functions */\n#include \"../common/zstd_internal.h\"  /* blockProperties_t, and some public functions */\n#include \"zstd_decompress_internal.h\"  /* ZSTD_seqSymbol */\n\n\n/* ===   Prototypes   === */\n\n/* note: prototypes already published within `zstd.h` :\n * ZSTD_decompressBlock()\n */\n\n/* note: prototypes already published within `zstd_internal.h` :\n * ZSTD_getcBlockSize()\n * ZSTD_decodeSeqHeaders()\n */\n\n\n /* Streaming state is used to inform allocation of the literal buffer */\ntypedef enum {\n    not_streaming = 0,\n    is_streaming = 1\n} streaming_operation;\n\n/* ZSTD_decompressBlock_internal() :\n * decompress block, starting at `src`,\n * into destination buffer `dst`.\n * @return : decompressed block size,\n *           or an error code (which can be tested using ZSTD_isError())\n */\nsize_t ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,\n                               void* dst, size_t dstCapacity,\n                         const void* src, size_t srcSize, const streaming_operation streaming);\n\n/* ZSTD_buildFSETable() :\n * generate FSE decoding table for one symbol (ll, ml or off)\n * this function must be called with valid parameters only\n * (dt is large enough, normalizedCounter distribution total is a power of 2, max is within range, etc.)\n * in which case it cannot fail.\n * The workspace must be 4-byte aligned and at least ZSTD_BUILD_FSE_TABLE_WKSP_SIZE bytes, which is\n * defined in zstd_decompress_internal.h.\n * Internal use only.\n */\nvoid ZSTD_buildFSETable(ZSTD_seqSymbol* dt,\n             const short* normalizedCounter, unsigned maxSymbolValue,\n             const U32* baseValue, const U8* nbAdditionalBits,\n                   unsigned tableLog, void* wksp, size_t wkspSize,\n                   int bmi2);\n\n/* Internal definition of ZSTD_decompressBlock() to avoid deprecation warnings. */\nsize_t ZSTD_decompressBlock_deprecated(ZSTD_DCtx* dctx,\n                            void* dst, size_t dstCapacity,\n                      const void* src, size_t srcSize);\n\n\n#endif /* ZSTD_DEC_BLOCK_H */\n"
  },
  {
    "path": "lib/decompress/zstd_decompress_internal.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n\n/* zstd_decompress_internal:\n * objects and definitions shared within lib/decompress modules */\n\n #ifndef ZSTD_DECOMPRESS_INTERNAL_H\n #define ZSTD_DECOMPRESS_INTERNAL_H\n\n\n/*-*******************************************************\n *  Dependencies\n *********************************************************/\n#include \"../common/mem.h\"             /* BYTE, U16, U32 */\n#include \"../common/zstd_internal.h\"   /* constants : MaxLL, MaxML, MaxOff, LLFSELog, etc. */\n\n\n\n/*-*******************************************************\n *  Constants\n *********************************************************/\nstatic UNUSED_ATTR const U32 LL_base[MaxLL+1] = {\n                 0,    1,    2,     3,     4,     5,     6,      7,\n                 8,    9,   10,    11,    12,    13,    14,     15,\n                16,   18,   20,    22,    24,    28,    32,     40,\n                48,   64, 0x80, 0x100, 0x200, 0x400, 0x800, 0x1000,\n                0x2000, 0x4000, 0x8000, 0x10000 };\n\nstatic UNUSED_ATTR const U32 OF_base[MaxOff+1] = {\n                 0,        1,       1,       5,     0xD,     0x1D,     0x3D,     0x7D,\n                 0xFD,   0x1FD,   0x3FD,   0x7FD,   0xFFD,   0x1FFD,   0x3FFD,   0x7FFD,\n                 0xFFFD, 0x1FFFD, 0x3FFFD, 0x7FFFD, 0xFFFFD, 0x1FFFFD, 0x3FFFFD, 0x7FFFFD,\n                 0xFFFFFD, 0x1FFFFFD, 0x3FFFFFD, 0x7FFFFFD, 0xFFFFFFD, 0x1FFFFFFD, 0x3FFFFFFD, 0x7FFFFFFD };\n\nstatic UNUSED_ATTR const U8 OF_bits[MaxOff+1] = {\n                     0,  1,  2,  3,  4,  5,  6,  7,\n                     8,  9, 10, 11, 12, 13, 14, 15,\n                    16, 17, 18, 19, 20, 21, 22, 23,\n                    24, 25, 26, 27, 28, 29, 30, 31 };\n\nstatic UNUSED_ATTR const U32 ML_base[MaxML+1] = {\n                     3,  4,  5,    6,     7,     8,     9,    10,\n                    11, 12, 13,   14,    15,    16,    17,    18,\n                    19, 20, 21,   22,    23,    24,    25,    26,\n                    27, 28, 29,   30,    31,    32,    33,    34,\n                    35, 37, 39,   41,    43,    47,    51,    59,\n                    67, 83, 99, 0x83, 0x103, 0x203, 0x403, 0x803,\n                    0x1003, 0x2003, 0x4003, 0x8003, 0x10003 };\n\n\n/*-*******************************************************\n *  Decompression types\n *********************************************************/\n typedef struct {\n     U32 fastMode;\n     U32 tableLog;\n } ZSTD_seqSymbol_header;\n\n typedef struct {\n     U16  nextState;\n     BYTE nbAdditionalBits;\n     BYTE nbBits;\n     U32  baseValue;\n } ZSTD_seqSymbol;\n\n #define SEQSYMBOL_TABLE_SIZE(log)   (1 + (1 << (log)))\n\n#define ZSTD_BUILD_FSE_TABLE_WKSP_SIZE (sizeof(S16) * (MaxSeq + 1) + (1u << MaxFSELog) + sizeof(U64))\n#define ZSTD_BUILD_FSE_TABLE_WKSP_SIZE_U32 ((ZSTD_BUILD_FSE_TABLE_WKSP_SIZE + sizeof(U32) - 1) / sizeof(U32))\n#define ZSTD_HUFFDTABLE_CAPACITY_LOG 12\n\ntypedef struct {\n    ZSTD_seqSymbol LLTable[SEQSYMBOL_TABLE_SIZE(LLFSELog)];    /* Note : Space reserved for FSE Tables */\n    ZSTD_seqSymbol OFTable[SEQSYMBOL_TABLE_SIZE(OffFSELog)];   /* is also used as temporary workspace while building hufTable during DDict creation */\n    ZSTD_seqSymbol MLTable[SEQSYMBOL_TABLE_SIZE(MLFSELog)];    /* and therefore must be at least HUF_DECOMPRESS_WORKSPACE_SIZE large */\n    HUF_DTable hufTable[HUF_DTABLE_SIZE(ZSTD_HUFFDTABLE_CAPACITY_LOG)];  /* can accommodate HUF_decompress4X */\n    U32 rep[ZSTD_REP_NUM];\n    U32 workspace[ZSTD_BUILD_FSE_TABLE_WKSP_SIZE_U32];\n} ZSTD_entropyDTables_t;\n\ntypedef enum { ZSTDds_getFrameHeaderSize, ZSTDds_decodeFrameHeader,\n               ZSTDds_decodeBlockHeader, ZSTDds_decompressBlock,\n               ZSTDds_decompressLastBlock, ZSTDds_checkChecksum,\n               ZSTDds_decodeSkippableHeader, ZSTDds_skipFrame } ZSTD_dStage;\n\ntypedef enum { zdss_init=0, zdss_loadHeader,\n               zdss_read, zdss_load, zdss_flush } ZSTD_dStreamStage;\n\ntypedef enum {\n    ZSTD_use_indefinitely = -1,  /* Use the dictionary indefinitely */\n    ZSTD_dont_use = 0,           /* Do not use the dictionary (if one exists free it) */\n    ZSTD_use_once = 1            /* Use the dictionary once and set to ZSTD_dont_use */\n} ZSTD_dictUses_e;\n\n/* Hashset for storing references to multiple ZSTD_DDict within ZSTD_DCtx */\ntypedef struct {\n    const ZSTD_DDict** ddictPtrTable;\n    size_t ddictPtrTableSize;\n    size_t ddictPtrCount;\n} ZSTD_DDictHashSet;\n\n#ifndef ZSTD_DECODER_INTERNAL_BUFFER\n#  define ZSTD_DECODER_INTERNAL_BUFFER  (1 << 16)\n#endif\n\n#define ZSTD_LBMIN 64\n#define ZSTD_LBMAX (128 << 10)\n\n/* extra buffer, compensates when dst is not large enough to store litBuffer */\n#define ZSTD_LITBUFFEREXTRASIZE  BOUNDED(ZSTD_LBMIN, ZSTD_DECODER_INTERNAL_BUFFER, ZSTD_LBMAX)\n\ntypedef enum {\n    ZSTD_not_in_dst = 0,  /* Stored entirely within litExtraBuffer */\n    ZSTD_in_dst = 1,           /* Stored entirely within dst (in memory after current output write) */\n    ZSTD_split = 2            /* Split between litExtraBuffer and dst */\n} ZSTD_litLocation_e;\n\nstruct ZSTD_DCtx_s\n{\n    const ZSTD_seqSymbol* LLTptr;\n    const ZSTD_seqSymbol* MLTptr;\n    const ZSTD_seqSymbol* OFTptr;\n    const HUF_DTable* HUFptr;\n    ZSTD_entropyDTables_t entropy;\n    U32 workspace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];   /* space needed when building huffman tables */\n    const void* previousDstEnd;   /* detect continuity */\n    const void* prefixStart;      /* start of current segment */\n    const void* virtualStart;     /* virtual start of previous segment if it was just before current one */\n    const void* dictEnd;          /* end of previous segment */\n    size_t expected;\n    ZSTD_FrameHeader fParams;\n    U64 processedCSize;\n    U64 decodedSize;\n    blockType_e bType;            /* used in ZSTD_decompressContinue(), store blockType between block header decoding and block decompression stages */\n    ZSTD_dStage stage;\n    U32 litEntropy;\n    U32 fseEntropy;\n    XXH64_state_t xxhState;\n    size_t headerSize;\n    ZSTD_format_e format;\n    ZSTD_forceIgnoreChecksum_e forceIgnoreChecksum;   /* User specified: if == 1, will ignore checksums in compressed frame. Default == 0 */\n    U32 validateChecksum;         /* if == 1, will validate checksum. Is == 1 if (fParams.checksumFlag == 1) and (forceIgnoreChecksum == 0). */\n    const BYTE* litPtr;\n    ZSTD_customMem customMem;\n    size_t litSize;\n    size_t rleSize;\n    size_t staticSize;\n    int isFrameDecompression;\n#if DYNAMIC_BMI2\n    int bmi2;                     /* == 1 if the CPU supports BMI2 and 0 otherwise. CPU support is determined dynamically once per context lifetime. */\n#endif\n\n    /* dictionary */\n    ZSTD_DDict* ddictLocal;\n    const ZSTD_DDict* ddict;     /* set by ZSTD_initDStream_usingDDict(), or ZSTD_DCtx_refDDict() */\n    U32 dictID;\n    int ddictIsCold;             /* if == 1 : dictionary is \"new\" for working context, and presumed \"cold\" (not in cpu cache) */\n    ZSTD_dictUses_e dictUses;\n    ZSTD_DDictHashSet* ddictSet;                    /* Hash set for multiple ddicts */\n    ZSTD_refMultipleDDicts_e refMultipleDDicts;     /* User specified: if == 1, will allow references to multiple DDicts. Default == 0 (disabled) */\n    int disableHufAsm;\n    int maxBlockSizeParam;\n\n    /* streaming */\n    ZSTD_dStreamStage streamStage;\n    char*  inBuff;\n    size_t inBuffSize;\n    size_t inPos;\n    size_t maxWindowSize;\n    char*  outBuff;\n    size_t outBuffSize;\n    size_t outStart;\n    size_t outEnd;\n    size_t lhSize;\n#if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT>=1)\n    void* legacyContext;\n    U32 previousLegacyVersion;\n    U32 legacyVersion;\n#endif\n    U32 hostageByte;\n    int noForwardProgress;\n    ZSTD_bufferMode_e outBufferMode;\n    ZSTD_outBuffer expectedOutBuffer;\n\n    /* workspace */\n    BYTE* litBuffer;\n    const BYTE* litBufferEnd;\n    ZSTD_litLocation_e litBufferLocation;\n    BYTE litExtraBuffer[ZSTD_LITBUFFEREXTRASIZE + WILDCOPY_OVERLENGTH]; /* literal buffer can be split between storage within dst and within this scratch buffer */\n    BYTE headerBuffer[ZSTD_FRAMEHEADERSIZE_MAX];\n\n    size_t oversizedDuration;\n\n#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION\n    void const* dictContentBeginForFuzzing;\n    void const* dictContentEndForFuzzing;\n#endif\n\n    /* Tracing */\n#if ZSTD_TRACE\n    ZSTD_TraceCtx traceCtx;\n#endif\n};  /* typedef'd to ZSTD_DCtx within \"zstd.h\" */\n\nMEM_STATIC int ZSTD_DCtx_get_bmi2(const struct ZSTD_DCtx_s *dctx) {\n#if DYNAMIC_BMI2\n    return dctx->bmi2;\n#else\n    (void)dctx;\n    return 0;\n#endif\n}\n\n/*-*******************************************************\n *  Shared internal functions\n *********************************************************/\n\n/*! ZSTD_loadDEntropy() :\n *  dict : must point at beginning of a valid zstd dictionary.\n * @return : size of dictionary header (size of magic number + dict ID + entropy tables) */\nsize_t ZSTD_loadDEntropy(ZSTD_entropyDTables_t* entropy,\n                   const void* const dict, size_t const dictSize);\n\n/*! ZSTD_checkContinuity() :\n *  check if next `dst` follows previous position, where decompression ended.\n *  If yes, do nothing (continue on current segment).\n *  If not, classify previous segment as \"external dictionary\", and start a new segment.\n *  This function cannot fail. */\nvoid ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst, size_t dstSize);\n\n\n#endif /* ZSTD_DECOMPRESS_INTERNAL_H */\n"
  },
  {
    "path": "lib/deprecated/zbuff.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/* ***************************************************************\n*  NOTES/WARNINGS\n******************************************************************/\n/* The streaming API defined here is deprecated.\n * Consider migrating towards ZSTD_compressStream() API in `zstd.h`\n * See 'lib/README.md'.\n *****************************************************************/\n\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n\n#ifndef ZSTD_BUFFERED_H_23987\n#define ZSTD_BUFFERED_H_23987\n\n/* *************************************\n*  Dependencies\n***************************************/\n#include       /* size_t */\n#include \"../zstd.h\"        /* ZSTD_CStream, ZSTD_DStream, ZSTDLIB_API */\n\n\n/* ***************************************************************\n*  Compiler specifics\n*****************************************************************/\n/* Deprecation warnings */\n/* Should these warnings be a problem,\n * it is generally possible to disable them,\n * typically with -Wno-deprecated-declarations for gcc\n * or _CRT_SECURE_NO_WARNINGS in Visual.\n * Otherwise, it's also possible to define ZBUFF_DISABLE_DEPRECATE_WARNINGS\n */\n#ifdef ZBUFF_DISABLE_DEPRECATE_WARNINGS\n#  define ZBUFF_DEPRECATED(message) ZSTDLIB_API  /* disable deprecation warnings */\n#else\n#  if defined (__cplusplus) && (__cplusplus >= 201402) /* C++14 or greater */\n#    define ZBUFF_DEPRECATED(message) [[deprecated(message)]] ZSTDLIB_API\n#  elif (defined(GNUC) && (GNUC > 4 || (GNUC == 4 && GNUC_MINOR >= 5))) || defined(__clang__)\n#    define ZBUFF_DEPRECATED(message) ZSTDLIB_API __attribute__((deprecated(message)))\n#  elif defined(__GNUC__) && (__GNUC__ >= 3)\n#    define ZBUFF_DEPRECATED(message) ZSTDLIB_API __attribute__((deprecated))\n#  elif defined(_MSC_VER)\n#    define ZBUFF_DEPRECATED(message) ZSTDLIB_API __declspec(deprecated(message))\n#  else\n#    pragma message(\"WARNING: You need to implement ZBUFF_DEPRECATED for this compiler\")\n#    define ZBUFF_DEPRECATED(message) ZSTDLIB_API\n#  endif\n#endif /* ZBUFF_DISABLE_DEPRECATE_WARNINGS */\n\n\n/* *************************************\n*  Streaming functions\n***************************************/\n/* This is the easier \"buffered\" streaming API,\n*  using an internal buffer to lift all restrictions on user-provided buffers\n*  which can be any size, any place, for both input and output.\n*  ZBUFF and ZSTD are 100% interoperable,\n*  frames created by one can be decoded by the other one */\n\ntypedef ZSTD_CStream ZBUFF_CCtx;\nZBUFF_DEPRECATED(\"use ZSTD_createCStream\") ZBUFF_CCtx* ZBUFF_createCCtx(void);\nZBUFF_DEPRECATED(\"use ZSTD_freeCStream\")   size_t      ZBUFF_freeCCtx(ZBUFF_CCtx* cctx);\n\nZBUFF_DEPRECATED(\"use ZSTD_initCStream\")           size_t ZBUFF_compressInit(ZBUFF_CCtx* cctx, int compressionLevel);\nZBUFF_DEPRECATED(\"use ZSTD_initCStream_usingDict\") size_t ZBUFF_compressInitDictionary(ZBUFF_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel);\n\nZBUFF_DEPRECATED(\"use ZSTD_compressStream\") size_t ZBUFF_compressContinue(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr, const void* src, size_t* srcSizePtr);\nZBUFF_DEPRECATED(\"use ZSTD_flushStream\")    size_t ZBUFF_compressFlush(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr);\nZBUFF_DEPRECATED(\"use ZSTD_endStream\")      size_t ZBUFF_compressEnd(ZBUFF_CCtx* cctx, void* dst, size_t* dstCapacityPtr);\n\n/*-*************************************************\n*  Streaming compression - howto\n*\n*  A ZBUFF_CCtx object is required to track streaming operation.\n*  Use ZBUFF_createCCtx() and ZBUFF_freeCCtx() to create/release resources.\n*  ZBUFF_CCtx objects can be reused multiple times.\n*\n*  Start by initializing ZBUF_CCtx.\n*  Use ZBUFF_compressInit() to start a new compression operation.\n*  Use ZBUFF_compressInitDictionary() for a compression which requires a dictionary.\n*\n*  Use ZBUFF_compressContinue() repetitively to consume input stream.\n*  *srcSizePtr and *dstCapacityPtr can be any size.\n*  The function will report how many bytes were read or written within *srcSizePtr and *dstCapacityPtr.\n*  Note that it may not consume the entire input, in which case it's up to the caller to present again remaining data.\n*  The content of `dst` will be overwritten (up to *dstCapacityPtr) at each call, so save its content if it matters or change @dst .\n*  @return : a hint to preferred nb of bytes to use as input for next function call (it's just a hint, to improve latency)\n*            or an error code, which can be tested using ZBUFF_isError().\n*\n*  At any moment, it's possible to flush whatever data remains within buffer, using ZBUFF_compressFlush().\n*  The nb of bytes written into `dst` will be reported into *dstCapacityPtr.\n*  Note that the function cannot output more than *dstCapacityPtr,\n*  therefore, some content might still be left into internal buffer if *dstCapacityPtr is too small.\n*  @return : nb of bytes still present into internal buffer (0 if it's empty)\n*            or an error code, which can be tested using ZBUFF_isError().\n*\n*  ZBUFF_compressEnd() instructs to finish a frame.\n*  It will perform a flush and write frame epilogue.\n*  The epilogue is required for decoders to consider a frame completed.\n*  Similar to ZBUFF_compressFlush(), it may not be able to output the entire internal buffer content if *dstCapacityPtr is too small.\n*  In which case, call again ZBUFF_compressFlush() to complete the flush.\n*  @return : nb of bytes still present into internal buffer (0 if it's empty)\n*            or an error code, which can be tested using ZBUFF_isError().\n*\n*  Hint : _recommended buffer_ sizes (not compulsory) : ZBUFF_recommendedCInSize() / ZBUFF_recommendedCOutSize()\n*  input : ZBUFF_recommendedCInSize==128 KB block size is the internal unit, use this value to reduce intermediate stages (better latency)\n*  output : ZBUFF_recommendedCOutSize==ZSTD_compressBound(128 KB) + 3 + 3 : ensures it's always possible to write/flush/end a full block. Skip some buffering.\n*  By using both, it ensures that input will be entirely consumed, and output will always contain the result, reducing intermediate buffering.\n* **************************************************/\n\n\ntypedef ZSTD_DStream ZBUFF_DCtx;\nZBUFF_DEPRECATED(\"use ZSTD_createDStream\") ZBUFF_DCtx* ZBUFF_createDCtx(void);\nZBUFF_DEPRECATED(\"use ZSTD_freeDStream\")   size_t      ZBUFF_freeDCtx(ZBUFF_DCtx* dctx);\n\nZBUFF_DEPRECATED(\"use ZSTD_initDStream\")           size_t ZBUFF_decompressInit(ZBUFF_DCtx* dctx);\nZBUFF_DEPRECATED(\"use ZSTD_initDStream_usingDict\") size_t ZBUFF_decompressInitDictionary(ZBUFF_DCtx* dctx, const void* dict, size_t dictSize);\n\nZBUFF_DEPRECATED(\"use ZSTD_decompressStream\") size_t ZBUFF_decompressContinue(ZBUFF_DCtx* dctx,\n                                            void* dst, size_t* dstCapacityPtr,\n                                      const void* src, size_t* srcSizePtr);\n\n/*-***************************************************************************\n*  Streaming decompression howto\n*\n*  A ZBUFF_DCtx object is required to track streaming operations.\n*  Use ZBUFF_createDCtx() and ZBUFF_freeDCtx() to create/release resources.\n*  Use ZBUFF_decompressInit() to start a new decompression operation,\n*   or ZBUFF_decompressInitDictionary() if decompression requires a dictionary.\n*  Note that ZBUFF_DCtx objects can be re-init multiple times.\n*\n*  Use ZBUFF_decompressContinue() repetitively to consume your input.\n*  *srcSizePtr and *dstCapacityPtr can be any size.\n*  The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr.\n*  Note that it may not consume the entire input, in which case it's up to the caller to present remaining input again.\n*  The content of `dst` will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters, or change `dst`.\n*  @return : 0 when a frame is completely decoded and fully flushed,\n*            1 when there is still some data left within internal buffer to flush,\n*            >1 when more data is expected, with value being a suggested next input size (it's just a hint, which helps latency),\n*            or an error code, which can be tested using ZBUFF_isError().\n*\n*  Hint : recommended buffer sizes (not compulsory) : ZBUFF_recommendedDInSize() and ZBUFF_recommendedDOutSize()\n*  output : ZBUFF_recommendedDOutSize== 128 KB block size is the internal unit, it ensures it's always possible to write a full block when decoded.\n*  input  : ZBUFF_recommendedDInSize == 128KB + 3;\n*           just follow indications from ZBUFF_decompressContinue() to minimize latency. It should always be <= 128 KB + 3 .\n* *******************************************************************************/\n\n\n/* *************************************\n*  Tool functions\n***************************************/\nZBUFF_DEPRECATED(\"use ZSTD_isError\")      unsigned ZBUFF_isError(size_t errorCode);\nZBUFF_DEPRECATED(\"use ZSTD_getErrorName\") const char* ZBUFF_getErrorName(size_t errorCode);\n\n/** Functions below provide recommended buffer sizes for Compression or Decompression operations.\n*   These sizes are just hints, they tend to offer better latency */\nZBUFF_DEPRECATED(\"use ZSTD_CStreamInSize\")  size_t ZBUFF_recommendedCInSize(void);\nZBUFF_DEPRECATED(\"use ZSTD_CStreamOutSize\") size_t ZBUFF_recommendedCOutSize(void);\nZBUFF_DEPRECATED(\"use ZSTD_DStreamInSize\")  size_t ZBUFF_recommendedDInSize(void);\nZBUFF_DEPRECATED(\"use ZSTD_DStreamOutSize\") size_t ZBUFF_recommendedDOutSize(void);\n\n#endif  /* ZSTD_BUFFERED_H_23987 */\n\n\n#ifdef ZBUFF_STATIC_LINKING_ONLY\n#ifndef ZBUFF_STATIC_H_30298098432\n#define ZBUFF_STATIC_H_30298098432\n\n/* ====================================================================================\n * The definitions in this section are considered experimental.\n * They should never be used in association with a dynamic library, as they may change in the future.\n * They are provided for advanced usages.\n * Use them only in association with static linking.\n * ==================================================================================== */\n\n/*--- Dependency ---*/\n#define ZSTD_STATIC_LINKING_ONLY   /* ZSTD_parameters, ZSTD_customMem */\n#include \"../zstd.h\"\n\n\n/*--- Custom memory allocator ---*/\n/*! ZBUFF_createCCtx_advanced() :\n *  Create a ZBUFF compression context using external alloc and free functions */\nZBUFF_DEPRECATED(\"use ZSTD_createCStream_advanced\") ZBUFF_CCtx* ZBUFF_createCCtx_advanced(ZSTD_customMem customMem);\n\n/*! ZBUFF_createDCtx_advanced() :\n *  Create a ZBUFF decompression context using external alloc and free functions */\nZBUFF_DEPRECATED(\"use ZSTD_createDStream_advanced\") ZBUFF_DCtx* ZBUFF_createDCtx_advanced(ZSTD_customMem customMem);\n\n\n/*--- Advanced Streaming Initialization ---*/\nZBUFF_DEPRECATED(\"use ZSTD_initDStream_usingDict\") size_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* zbc,\n                                               const void* dict, size_t dictSize,\n                                               ZSTD_parameters params, unsigned long long pledgedSrcSize);\n\n\n#endif    /* ZBUFF_STATIC_H_30298098432 */\n#endif    /* ZBUFF_STATIC_LINKING_ONLY */\n\n\n#if defined (__cplusplus)\n}\n#endif\n"
  },
  {
    "path": "lib/deprecated/zbuff_common.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/*-*************************************\n*  Dependencies\n***************************************/\n#include \"../common/error_private.h\"\n#include \"zbuff.h\"\n\n/*-****************************************\n*  ZBUFF Error Management  (deprecated)\n******************************************/\n\n/*! ZBUFF_isError() :\n*   tells if a return value is an error code */\nunsigned ZBUFF_isError(size_t errorCode) { return ERR_isError(errorCode); }\n/*! ZBUFF_getErrorName() :\n*   provides error code string from function result (useful for debugging) */\nconst char* ZBUFF_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }\n"
  },
  {
    "path": "lib/deprecated/zbuff_compress.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n\n\n/* *************************************\n*  Dependencies\n***************************************/\n#define ZBUFF_STATIC_LINKING_ONLY\n#include \"zbuff.h\"\n#include \"../common/error_private.h\"\n\n\n/*-***********************************************************\n*  Streaming compression\n*\n*  A ZBUFF_CCtx object is required to track streaming operation.\n*  Use ZBUFF_createCCtx() and ZBUFF_freeCCtx() to create/release resources.\n*  Use ZBUFF_compressInit() to start a new compression operation.\n*  ZBUFF_CCtx objects can be reused multiple times.\n*\n*  Use ZBUFF_compressContinue() repetitively to consume your input.\n*  *srcSizePtr and *dstCapacityPtr can be any size.\n*  The function will report how many bytes were read or written by modifying *srcSizePtr and *dstCapacityPtr.\n*  Note that it may not consume the entire input, in which case it's up to the caller to call again the function with remaining input.\n*  The content of dst will be overwritten (up to *dstCapacityPtr) at each function call, so save its content if it matters or change dst .\n*  @return : a hint to preferred nb of bytes to use as input for next function call (it's only a hint, to improve latency)\n*            or an error code, which can be tested using ZBUFF_isError().\n*\n*  ZBUFF_compressFlush() can be used to instruct ZBUFF to compress and output whatever remains within its buffer.\n*  Note that it will not output more than *dstCapacityPtr.\n*  Therefore, some content might still be left into its internal buffer if dst buffer is too small.\n*  @return : nb of bytes still present into internal buffer (0 if it's empty)\n*            or an error code, which can be tested using ZBUFF_isError().\n*\n*  ZBUFF_compressEnd() instructs to finish a frame.\n*  It will perform a flush and write frame epilogue.\n*  Similar to ZBUFF_compressFlush(), it may not be able to output the entire internal buffer content if *dstCapacityPtr is too small.\n*  @return : nb of bytes still present into internal buffer (0 if it's empty)\n*            or an error code, which can be tested using ZBUFF_isError().\n*\n*  Hint : recommended buffer sizes (not compulsory)\n*  input : ZSTD_BLOCKSIZE_MAX (128 KB), internal unit size, it improves latency to use this value.\n*  output : ZSTD_compressBound(ZSTD_BLOCKSIZE_MAX) + ZSTD_blockHeaderSize + ZBUFF_endFrameSize : ensures it's always possible to write/flush/end a full block at best speed.\n* ***********************************************************/\n\nZBUFF_CCtx* ZBUFF_createCCtx(void)\n{\n    return ZSTD_createCStream();\n}\n\nZBUFF_CCtx* ZBUFF_createCCtx_advanced(ZSTD_customMem customMem)\n{\n    return ZSTD_createCStream_advanced(customMem);\n}\n\nsize_t ZBUFF_freeCCtx(ZBUFF_CCtx* zbc)\n{\n    return ZSTD_freeCStream(zbc);\n}\n\n\n/* ======   Initialization   ====== */\n\nsize_t ZBUFF_compressInit_advanced(ZBUFF_CCtx* zbc,\n                                   const void* dict, size_t dictSize,\n                                   ZSTD_parameters params, unsigned long long pledgedSrcSize)\n{\n    if (pledgedSrcSize==0) pledgedSrcSize = ZSTD_CONTENTSIZE_UNKNOWN;  /* preserve \"0 == unknown\" behavior */\n    FORWARD_IF_ERROR(ZSTD_CCtx_reset(zbc, ZSTD_reset_session_only), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setPledgedSrcSize(zbc, pledgedSrcSize), \"\");\n\n    FORWARD_IF_ERROR(ZSTD_checkCParams(params.cParams), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_windowLog, params.cParams.windowLog), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_hashLog, params.cParams.hashLog), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_chainLog, params.cParams.chainLog), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_searchLog, params.cParams.searchLog), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_minMatch, params.cParams.minMatch), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_targetLength, params.cParams.targetLength), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_strategy, params.cParams.strategy), \"\");\n\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_contentSizeFlag, params.fParams.contentSizeFlag), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_checksumFlag, params.fParams.checksumFlag), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_dictIDFlag, params.fParams.noDictIDFlag), \"\");\n\n    FORWARD_IF_ERROR(ZSTD_CCtx_loadDictionary(zbc, dict, dictSize), \"\");\n    return 0;\n}\n\nsize_t ZBUFF_compressInitDictionary(ZBUFF_CCtx* zbc, const void* dict, size_t dictSize, int compressionLevel)\n{\n    FORWARD_IF_ERROR(ZSTD_CCtx_reset(zbc, ZSTD_reset_session_only), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(zbc, ZSTD_c_compressionLevel, compressionLevel), \"\");\n    FORWARD_IF_ERROR(ZSTD_CCtx_loadDictionary(zbc, dict, dictSize), \"\");\n    return 0;\n}\n\nsize_t ZBUFF_compressInit(ZBUFF_CCtx* zbc, int compressionLevel)\n{\n    return ZSTD_initCStream(zbc, compressionLevel);\n}\n\n/* ======   Compression   ====== */\n\n\nsize_t ZBUFF_compressContinue(ZBUFF_CCtx* zbc,\n                              void* dst, size_t* dstCapacityPtr,\n                        const void* src, size_t* srcSizePtr)\n{\n    size_t result;\n    ZSTD_outBuffer outBuff;\n    ZSTD_inBuffer inBuff;\n    outBuff.dst = dst;\n    outBuff.pos = 0;\n    outBuff.size = *dstCapacityPtr;\n    inBuff.src = src;\n    inBuff.pos = 0;\n    inBuff.size = *srcSizePtr;\n    result = ZSTD_compressStream(zbc, &outBuff, &inBuff);\n    *dstCapacityPtr = outBuff.pos;\n    *srcSizePtr = inBuff.pos;\n    return result;\n}\n\n\n\n/* ======   Finalize   ====== */\n\nsize_t ZBUFF_compressFlush(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr)\n{\n    size_t result;\n    ZSTD_outBuffer outBuff;\n    outBuff.dst = dst;\n    outBuff.pos = 0;\n    outBuff.size = *dstCapacityPtr;\n    result = ZSTD_flushStream(zbc, &outBuff);\n    *dstCapacityPtr = outBuff.pos;\n    return result;\n}\n\n\nsize_t ZBUFF_compressEnd(ZBUFF_CCtx* zbc, void* dst, size_t* dstCapacityPtr)\n{\n    size_t result;\n    ZSTD_outBuffer outBuff;\n    outBuff.dst = dst;\n    outBuff.pos = 0;\n    outBuff.size = *dstCapacityPtr;\n    result = ZSTD_endStream(zbc, &outBuff);\n    *dstCapacityPtr = outBuff.pos;\n    return result;\n}\n\n\n\n/* *************************************\n*  Tool functions\n***************************************/\nsize_t ZBUFF_recommendedCInSize(void)  { return ZSTD_CStreamInSize(); }\nsize_t ZBUFF_recommendedCOutSize(void) { return ZSTD_CStreamOutSize(); }\n"
  },
  {
    "path": "lib/deprecated/zbuff_decompress.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n\n\n/* *************************************\n*  Dependencies\n***************************************/\n#define ZSTD_DISABLE_DEPRECATE_WARNINGS  /* suppress warning on ZSTD_initDStream_usingDict */\n#include \"../zstd.h\"        /* ZSTD_CStream, ZSTD_DStream, ZSTDLIB_API */\n#define ZBUFF_STATIC_LINKING_ONLY\n#include \"zbuff.h\"\n\n\nZBUFF_DCtx* ZBUFF_createDCtx(void)\n{\n    return ZSTD_createDStream();\n}\n\nZBUFF_DCtx* ZBUFF_createDCtx_advanced(ZSTD_customMem customMem)\n{\n    return ZSTD_createDStream_advanced(customMem);\n}\n\nsize_t ZBUFF_freeDCtx(ZBUFF_DCtx* zbd)\n{\n    return ZSTD_freeDStream(zbd);\n}\n\n\n/* *** Initialization *** */\n\nsize_t ZBUFF_decompressInitDictionary(ZBUFF_DCtx* zbd, const void* dict, size_t dictSize)\n{\n    return ZSTD_initDStream_usingDict(zbd, dict, dictSize);\n}\n\nsize_t ZBUFF_decompressInit(ZBUFF_DCtx* zbd)\n{\n    return ZSTD_initDStream(zbd);\n}\n\n\n/* *** Decompression *** */\n\nsize_t ZBUFF_decompressContinue(ZBUFF_DCtx* zbd,\n                                void* dst, size_t* dstCapacityPtr,\n                          const void* src, size_t* srcSizePtr)\n{\n    ZSTD_outBuffer outBuff;\n    ZSTD_inBuffer inBuff;\n    size_t result;\n    outBuff.dst  = dst;\n    outBuff.pos  = 0;\n    outBuff.size = *dstCapacityPtr;\n    inBuff.src  = src;\n    inBuff.pos  = 0;\n    inBuff.size = *srcSizePtr;\n    result = ZSTD_decompressStream(zbd, &outBuff, &inBuff);\n    *dstCapacityPtr = outBuff.pos;\n    *srcSizePtr = inBuff.pos;\n    return result;\n}\n\n\n/* *************************************\n*  Tool functions\n***************************************/\nsize_t ZBUFF_recommendedDInSize(void)  { return ZSTD_DStreamInSize(); }\nsize_t ZBUFF_recommendedDOutSize(void) { return ZSTD_DStreamOutSize(); }\n"
  },
  {
    "path": "lib/dictBuilder/cover.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/* *****************************************************************************\n * Constructs a dictionary using a heuristic based on the following paper:\n *\n * Liao, Petri, Moffat, Wirth\n * Effective Construction of Relative Lempel-Ziv Dictionaries\n * Published in WWW 2016.\n *\n * Adapted from code originally written by @ot (Giuseppe Ottaviano).\n ******************************************************************************/\n\n/*-*************************************\n*  Dependencies\n***************************************/\n/* qsort_r is an extension.\n *\n * Android NDK does not ship qsort_r().\n */\n#if (defined(__linux__) && !defined(__ANDROID__)) || defined(__CYGWIN__) || defined(__MSYS__)\n# ifndef _GNU_SOURCE\n#   define _GNU_SOURCE\n# endif\n#endif\n\n#define __STDC_WANT_LIB_EXT1__ 1 /* request C11 Annex K, which includes qsort_s() */\n\n#include   /* fprintf */\n#include  /* malloc, free, qsort_r */\n\n#include  /* memset */\n#include    /* clock */\n\n#ifndef ZDICT_STATIC_LINKING_ONLY\n#  define ZDICT_STATIC_LINKING_ONLY\n#endif\n\n#include \"../common/debug.h\" /* DEBUG_STATIC_ASSERT */\n#include \"../common/mem.h\" /* read */\n#include \"../common/pool.h\" /* POOL_ctx */\n#include \"../common/threading.h\" /* ZSTD_pthread_mutex_t */\n#include \"../common/zstd_internal.h\" /* includes zstd.h */\n#include \"../common/bits.h\" /* ZSTD_highbit32 */\n#include \"../zdict.h\"\n#include \"cover.h\"\n\n/*-*************************************\n*  Constants\n***************************************/\n/**\n* There are 32bit indexes used to ref samples, so limit samples size to 4GB\n* on 64bit builds.\n* For 32bit builds we choose 1 GB.\n* Most 32bit platforms have 2GB user-mode addressable space and we allocate a large\n* contiguous buffer, so 1GB is already a high limit.\n*/\n#define COVER_MAX_SAMPLES_SIZE (sizeof(size_t) == 8 ? ((unsigned)-1) : ((unsigned)1 GB))\n#define COVER_DEFAULT_SPLITPOINT 1.0\n\n/**\n * Select the qsort() variant used by cover\n */\n#define ZDICT_QSORT_MIN 0\n#define ZDICT_QSORT_C90 ZDICT_QSORT_MIN\n#define ZDICT_QSORT_GNU 1\n#define ZDICT_QSORT_APPLE 2\n#define ZDICT_QSORT_MSVC 3\n#define ZDICT_QSORT_C11 ZDICT_QSORT_MAX\n#define ZDICT_QSORT_MAX 4\n\n#ifndef ZDICT_QSORT\n# if defined(__APPLE__)\n#   define ZDICT_QSORT ZDICT_QSORT_APPLE /* uses qsort_r() with a different order for parameters */\n# elif (defined(__linux__) && !defined(__ANDROID__)) || defined(__CYGWIN__) || defined(__MSYS__)\n#   define ZDICT_QSORT ZDICT_QSORT_GNU /* uses qsort_r() */\n# elif defined(_WIN32) && defined(_MSC_VER)\n#   define ZDICT_QSORT ZDICT_QSORT_MSVC /* uses qsort_s() with a different order for parameters */\n# elif defined(STDC_LIB_EXT1) && (STDC_LIB_EXT1 > 0) /* C11 Annex K */\n#   define ZDICT_QSORT ZDICT_QSORT_C11 /* uses qsort_s() */\n# else\n#   define ZDICT_QSORT ZDICT_QSORT_C90 /* uses standard qsort() which is not re-entrant (requires global variable) */\n# endif\n#endif\n\n\n/*-*************************************\n*  Console display\n*\n* Captures the `displayLevel` variable in the local scope.\n***************************************/\n#undef  DISPLAY\n#define DISPLAY(...)                                                           \\\n  {                                                                            \\\n    fprintf(stderr, __VA_ARGS__);                                              \\\n    fflush(stderr);                                                            \\\n  }\n#undef  DISPLAYLEVEL\n#define DISPLAYLEVEL(l, ...)                                                   \\\n  if (displayLevel >= l) {                                                     \\\n    DISPLAY(__VA_ARGS__);                                                      \\\n  } /* 0 : no display;   1: errors;   2: default;  3: details;  4: debug */\n\n#undef  DISPLAYUPDATE\n#define DISPLAYUPDATE(lastUpdateTime, l, ...)                                  \\\n  if (displayLevel >= l) {                                                     \\\n    const clock_t refreshRate = CLOCKS_PER_SEC * 15 / 100;                     \\\n    if ((clock() - lastUpdateTime > refreshRate) || (displayLevel >= 4)) {     \\\n      lastUpdateTime = clock();                                                \\\n      DISPLAY(__VA_ARGS__);                                                    \\\n    }                                                                          \\\n  }\n\n/*-*************************************\n* Hash table\n***************************************\n* A small specialized hash map for storing activeDmers.\n* The map does not resize, so if it becomes full it will loop forever.\n* Thus, the map must be large enough to store every value.\n* The map implements linear probing and keeps its load less than 0.5.\n*/\n\n#define MAP_EMPTY_VALUE ((U32)-1)\ntypedef struct COVER_map_pair_t_s {\n  U32 key;\n  U32 value;\n} COVER_map_pair_t;\n\ntypedef struct COVER_map_s {\n  COVER_map_pair_t *data;\n  U32 sizeLog;\n  U32 size;\n  U32 sizeMask;\n} COVER_map_t;\n\n/**\n * Clear the map.\n */\nstatic void COVER_map_clear(COVER_map_t *map) {\n  memset(map->data, MAP_EMPTY_VALUE, map->size * sizeof(COVER_map_pair_t));\n}\n\n/**\n * Initializes a map of the given size.\n * Returns 1 on success and 0 on failure.\n * The map must be destroyed with COVER_map_destroy().\n * The map is only guaranteed to be large enough to hold size elements.\n */\nstatic int COVER_map_init(COVER_map_t *map, U32 size) {\n  map->sizeLog = ZSTD_highbit32(size) + 2;\n  map->size = (U32)1 << map->sizeLog;\n  map->sizeMask = map->size - 1;\n  map->data = (COVER_map_pair_t *)malloc(map->size * sizeof(COVER_map_pair_t));\n  if (!map->data) {\n    map->sizeLog = 0;\n    map->size = 0;\n    return 0;\n  }\n  COVER_map_clear(map);\n  return 1;\n}\n\n/**\n * Internal hash function\n */\nstatic const U32 COVER_prime4bytes = 2654435761U;\nstatic U32 COVER_map_hash(COVER_map_t *map, U32 key) {\n  return (key * COVER_prime4bytes) >> (32 - map->sizeLog);\n}\n\n/**\n * Helper function that returns the index that a key should be placed into.\n */\nstatic U32 COVER_map_index(COVER_map_t *map, U32 key) {\n  const U32 hash = COVER_map_hash(map, key);\n  U32 i;\n  for (i = hash;; i = (i + 1) & map->sizeMask) {\n    COVER_map_pair_t *pos = &map->data[i];\n    if (pos->value == MAP_EMPTY_VALUE) {\n      return i;\n    }\n    if (pos->key == key) {\n      return i;\n    }\n  }\n}\n\n/**\n * Returns the pointer to the value for key.\n * If key is not in the map, it is inserted and the value is set to 0.\n * The map must not be full.\n */\nstatic U32 *COVER_map_at(COVER_map_t *map, U32 key) {\n  COVER_map_pair_t *pos = &map->data[COVER_map_index(map, key)];\n  if (pos->value == MAP_EMPTY_VALUE) {\n    pos->key = key;\n    pos->value = 0;\n  }\n  return &pos->value;\n}\n\n/**\n * Deletes key from the map if present.\n */\nstatic void COVER_map_remove(COVER_map_t *map, U32 key) {\n  U32 i = COVER_map_index(map, key);\n  COVER_map_pair_t* del = &map->data[i];\n  U32 shift = 1;\n  if (del->value == MAP_EMPTY_VALUE) {\n    return;\n  }\n  for (i = (i + 1) & map->sizeMask;; i = (i + 1) & map->sizeMask) {\n    COVER_map_pair_t *const pos = &map->data[i];\n    /* If the position is empty we are done */\n    if (pos->value == MAP_EMPTY_VALUE) {\n      del->value = MAP_EMPTY_VALUE;\n      return;\n    }\n    /* If pos can be moved to del do so */\n    if (((i - COVER_map_hash(map, pos->key)) & map->sizeMask) >= shift) {\n      del->key = pos->key;\n      del->value = pos->value;\n      del = pos;\n      shift = 1;\n    } else {\n      ++shift;\n    }\n  }\n}\n\n/**\n * Destroys a map that is inited with COVER_map_init().\n */\nstatic void COVER_map_destroy(COVER_map_t *map) {\n  if (map->data) {\n    free(map->data);\n  }\n  map->data = NULL;\n  map->size = 0;\n}\n\n/*-*************************************\n* Context\n***************************************/\n\ntypedef struct {\n  const BYTE *samples;\n  size_t *offsets;\n  const size_t *samplesSizes;\n  size_t nbSamples;\n  size_t nbTrainSamples;\n  size_t nbTestSamples;\n  U32 *suffix;\n  size_t suffixSize;\n  U32 *freqs;\n  U32 *dmerAt;\n  unsigned d;\n  int displayLevel;\n} COVER_ctx_t;\n\n#if ZDICT_QSORT == ZDICT_QSORT_C90\n/* Use global context for non-reentrant sort functions */\nstatic COVER_ctx_t *g_coverCtx = NULL;\n#endif\n\n/*-*************************************\n*  Helper functions\n***************************************/\n\n/**\n * Returns the sum of the sample sizes.\n */\nsize_t COVER_sum(const size_t *samplesSizes, unsigned nbSamples) {\n  size_t sum = 0;\n  unsigned i;\n  for (i = 0; i < nbSamples; ++i) {\n    sum += samplesSizes[i];\n  }\n  return sum;\n}\n\n/**\n * Returns -1 if the dmer at lp is less than the dmer at rp.\n * Return 0 if the dmers at lp and rp are equal.\n * Returns 1 if the dmer at lp is greater than the dmer at rp.\n */\nstatic int COVER_cmp(COVER_ctx_t *ctx, const void *lp, const void *rp) {\n  U32 const lhs = *(U32 const *)lp;\n  U32 const rhs = *(U32 const *)rp;\n  return memcmp(ctx->samples + lhs, ctx->samples + rhs, ctx->d);\n}\n/**\n * Faster version for d <= 8.\n */\nstatic int COVER_cmp8(COVER_ctx_t *ctx, const void *lp, const void *rp) {\n  U64 const mask = (ctx->d == 8) ? (U64)-1 : (((U64)1 << (8 * ctx->d)) - 1);\n  U64 const lhs = MEM_readLE64(ctx->samples + *(U32 const *)lp) & mask;\n  U64 const rhs = MEM_readLE64(ctx->samples + *(U32 const *)rp) & mask;\n  if (lhs < rhs) {\n    return -1;\n  }\n  return (lhs > rhs);\n}\n\n/**\n * Same as COVER_cmp() except ties are broken by pointer value\n */\n#if (ZDICT_QSORT == ZDICT_QSORT_MSVC) || (ZDICT_QSORT == ZDICT_QSORT_APPLE)\nstatic int WIN_CDECL COVER_strict_cmp(void* g_coverCtx, const void* lp, const void* rp) {\n#elif (ZDICT_QSORT == ZDICT_QSORT_GNU) || (ZDICT_QSORT == ZDICT_QSORT_C11)\nstatic int COVER_strict_cmp(const void *lp, const void *rp, void *g_coverCtx) {\n#else /* C90 fallback.*/\nstatic int COVER_strict_cmp(const void *lp, const void *rp) {\n#endif\n  int result = COVER_cmp((COVER_ctx_t*)g_coverCtx, lp, rp);\n  if (result == 0) {\n    result = lp < rp ? -1 : 1;\n  }\n  return result;\n}\n/**\n * Faster version for d <= 8.\n */\n#if (ZDICT_QSORT == ZDICT_QSORT_MSVC) || (ZDICT_QSORT == ZDICT_QSORT_APPLE)\nstatic int WIN_CDECL COVER_strict_cmp8(void* g_coverCtx, const void* lp, const void* rp) {\n#elif (ZDICT_QSORT == ZDICT_QSORT_GNU) || (ZDICT_QSORT == ZDICT_QSORT_C11)\nstatic int COVER_strict_cmp8(const void *lp, const void *rp, void *g_coverCtx) {\n#else /* C90 fallback.*/\nstatic int COVER_strict_cmp8(const void *lp, const void *rp) {\n#endif\n  int result = COVER_cmp8((COVER_ctx_t*)g_coverCtx, lp, rp);\n  if (result == 0) {\n    result = lp < rp ? -1 : 1;\n  }\n  return result;\n}\n\n/**\n * Abstract away divergence of qsort_r() parameters.\n * Hopefully when C11 become the norm, we will be able\n * to clean it up.\n */\nstatic void stableSort(COVER_ctx_t *ctx)\n{\n    DEBUG_STATIC_ASSERT(ZDICT_QSORT_MIN <= ZDICT_QSORT && ZDICT_QSORT <= ZDICT_QSORT_MAX);\n#if (ZDICT_QSORT == ZDICT_QSORT_APPLE)\n    qsort_r(ctx->suffix, ctx->suffixSize, sizeof(U32),\n            ctx,\n            (ctx->d <= 8 ? &COVER_strict_cmp8 : &COVER_strict_cmp));\n#elif (ZDICT_QSORT == ZDICT_QSORT_GNU)\n    qsort_r(ctx->suffix, ctx->suffixSize, sizeof(U32),\n            (ctx->d <= 8 ? &COVER_strict_cmp8 : &COVER_strict_cmp),\n            ctx);\n#elif (ZDICT_QSORT == ZDICT_QSORT_MSVC)\n    qsort_s(ctx->suffix, ctx->suffixSize, sizeof(U32),\n            (ctx->d <= 8 ? &COVER_strict_cmp8 : &COVER_strict_cmp),\n            ctx);\n#elif (ZDICT_QSORT == ZDICT_QSORT_C11)\n    qsort_s(ctx->suffix, ctx->suffixSize, sizeof(U32),\n            (ctx->d <= 8 ? &COVER_strict_cmp8 : &COVER_strict_cmp),\n            ctx);\n#else /* C90 fallback.*/\n    g_coverCtx = ctx;\n    /* TODO(cavalcanti): implement a reentrant qsort() when _r is not available. */\n    qsort(ctx->suffix, ctx->suffixSize, sizeof(U32),\n          (ctx->d <= 8 ? &COVER_strict_cmp8 : &COVER_strict_cmp));\n#endif\n}\n\n/**\n * Returns the first pointer in [first, last) whose element does not compare\n * less than value.  If no such element exists it returns last.\n */\nstatic const size_t *COVER_lower_bound(const size_t* first, const size_t* last,\n                                       size_t value) {\n  size_t count = (size_t)(last - first);\n  assert(last >= first);\n  while (count != 0) {\n    size_t step = count / 2;\n    const size_t *ptr = first;\n    ptr += step;\n    if (*ptr < value) {\n      first = ++ptr;\n      count -= step + 1;\n    } else {\n      count = step;\n    }\n  }\n  return first;\n}\n\n/**\n * Generic groupBy function.\n * Groups an array sorted by cmp into groups with equivalent values.\n * Calls grp for each group.\n */\nstatic void\nCOVER_groupBy(const void *data, size_t count, size_t size, COVER_ctx_t *ctx,\n              int (*cmp)(COVER_ctx_t *, const void *, const void *),\n              void (*grp)(COVER_ctx_t *, const void *, const void *)) {\n  const BYTE *ptr = (const BYTE *)data;\n  size_t num = 0;\n  while (num < count) {\n    const BYTE *grpEnd = ptr + size;\n    ++num;\n    while (num < count && cmp(ctx, ptr, grpEnd) == 0) {\n      grpEnd += size;\n      ++num;\n    }\n    grp(ctx, ptr, grpEnd);\n    ptr = grpEnd;\n  }\n}\n\n/*-*************************************\n*  Cover functions\n***************************************/\n\n/**\n * Called on each group of positions with the same dmer.\n * Counts the frequency of each dmer and saves it in the suffix array.\n * Fills `ctx->dmerAt`.\n */\nstatic void COVER_group(COVER_ctx_t *ctx, const void *group,\n                        const void *groupEnd) {\n  /* The group consists of all the positions with the same first d bytes. */\n  const U32 *grpPtr = (const U32 *)group;\n  const U32 *grpEnd = (const U32 *)groupEnd;\n  /* The dmerId is how we will reference this dmer.\n   * This allows us to map the whole dmer space to a much smaller space, the\n   * size of the suffix array.\n   */\n  const U32 dmerId = (U32)(grpPtr - ctx->suffix);\n  /* Count the number of samples this dmer shows up in */\n  U32 freq = 0;\n  /* Details */\n  const size_t *curOffsetPtr = ctx->offsets;\n  const size_t *offsetsEnd = ctx->offsets + ctx->nbSamples;\n  /* Once *grpPtr >= curSampleEnd this occurrence of the dmer is in a\n   * different sample than the last.\n   */\n  size_t curSampleEnd = ctx->offsets[0];\n  for (; grpPtr != grpEnd; ++grpPtr) {\n    /* Save the dmerId for this position so we can get back to it. */\n    ctx->dmerAt[*grpPtr] = dmerId;\n    /* Dictionaries only help for the first reference to the dmer.\n     * After that zstd can reference the match from the previous reference.\n     * So only count each dmer once for each sample it is in.\n     */\n    if (*grpPtr < curSampleEnd) {\n      continue;\n    }\n    freq += 1;\n    /* Binary search to find the end of the sample *grpPtr is in.\n     * In the common case that grpPtr + 1 == grpEnd we can skip the binary\n     * search because the loop is over.\n     */\n    if (grpPtr + 1 != grpEnd) {\n      const size_t *sampleEndPtr =\n          COVER_lower_bound(curOffsetPtr, offsetsEnd, *grpPtr);\n      curSampleEnd = *sampleEndPtr;\n      curOffsetPtr = sampleEndPtr + 1;\n    }\n  }\n  /* At this point we are never going to look at this segment of the suffix\n   * array again.  We take advantage of this fact to save memory.\n   * We store the frequency of the dmer in the first position of the group,\n   * which is dmerId.\n   */\n  ctx->suffix[dmerId] = freq;\n}\n\n\n/**\n * Selects the best segment in an epoch.\n * Segments of are scored according to the function:\n *\n * Let F(d) be the frequency of dmer d.\n * Let S_i be the dmer at position i of segment S which has length k.\n *\n *     Score(S) = F(S_1) + F(S_2) + ... + F(S_{k-d+1})\n *\n * Once the dmer d is in the dictionary we set F(d) = 0.\n */\nstatic COVER_segment_t COVER_selectSegment(const COVER_ctx_t *ctx, U32 *freqs,\n                                           COVER_map_t *activeDmers, U32 begin,\n                                           U32 end,\n                                           ZDICT_cover_params_t parameters) {\n  /* Constants */\n  const U32 k = parameters.k;\n  const U32 d = parameters.d;\n  const U32 dmersInK = k - d + 1;\n  /* Try each segment (activeSegment) and save the best (bestSegment) */\n  COVER_segment_t bestSegment = {0, 0, 0};\n  COVER_segment_t activeSegment;\n  /* Reset the activeDmers in the segment */\n  COVER_map_clear(activeDmers);\n  /* The activeSegment starts at the beginning of the epoch. */\n  activeSegment.begin = begin;\n  activeSegment.end = begin;\n  activeSegment.score = 0;\n  /* Slide the activeSegment through the whole epoch.\n   * Save the best segment in bestSegment.\n   */\n  while (activeSegment.end < end) {\n    /* The dmerId for the dmer at the next position */\n    U32 newDmer = ctx->dmerAt[activeSegment.end];\n    /* The entry in activeDmers for this dmerId */\n    U32 *newDmerOcc = COVER_map_at(activeDmers, newDmer);\n    /* If the dmer isn't already present in the segment add its score. */\n    if (*newDmerOcc == 0) {\n      /* The paper suggest using the L-0.5 norm, but experiments show that it\n       * doesn't help.\n       */\n      activeSegment.score += freqs[newDmer];\n    }\n    /* Add the dmer to the segment */\n    activeSegment.end += 1;\n    *newDmerOcc += 1;\n\n    /* If the window is now too large, drop the first position */\n    if (activeSegment.end - activeSegment.begin == dmersInK + 1) {\n      U32 delDmer = ctx->dmerAt[activeSegment.begin];\n      U32 *delDmerOcc = COVER_map_at(activeDmers, delDmer);\n      activeSegment.begin += 1;\n      *delDmerOcc -= 1;\n      /* If this is the last occurrence of the dmer, subtract its score */\n      if (*delDmerOcc == 0) {\n        COVER_map_remove(activeDmers, delDmer);\n        activeSegment.score -= freqs[delDmer];\n      }\n    }\n\n    /* If this segment is the best so far save it */\n    if (activeSegment.score > bestSegment.score) {\n      bestSegment = activeSegment;\n    }\n  }\n  {\n    /* Trim off the zero frequency head and tail from the segment. */\n    U32 newBegin = bestSegment.end;\n    U32 newEnd = bestSegment.begin;\n    U32 pos;\n    for (pos = bestSegment.begin; pos != bestSegment.end; ++pos) {\n      U32 freq = freqs[ctx->dmerAt[pos]];\n      if (freq != 0) {\n        newBegin = MIN(newBegin, pos);\n        newEnd = pos + 1;\n      }\n    }\n    bestSegment.begin = newBegin;\n    bestSegment.end = newEnd;\n  }\n  {\n    /* Zero out the frequency of each dmer covered by the chosen segment. */\n    U32 pos;\n    for (pos = bestSegment.begin; pos != bestSegment.end; ++pos) {\n      freqs[ctx->dmerAt[pos]] = 0;\n    }\n  }\n  return bestSegment;\n}\n\n/**\n * Check the validity of the parameters.\n * Returns non-zero if the parameters are valid and 0 otherwise.\n */\nstatic int COVER_checkParameters(ZDICT_cover_params_t parameters,\n                                 size_t maxDictSize) {\n  /* k and d are required parameters */\n  if (parameters.d == 0 || parameters.k == 0) {\n    return 0;\n  }\n  /* k <= maxDictSize */\n  if (parameters.k > maxDictSize) {\n    return 0;\n  }\n  /* d <= k */\n  if (parameters.d > parameters.k) {\n    return 0;\n  }\n  /* 0 < splitPoint <= 1 */\n  if (parameters.splitPoint <= 0 || parameters.splitPoint > 1){\n    return 0;\n  }\n  return 1;\n}\n\n/**\n * Clean up a context initialized with `COVER_ctx_init()`.\n */\nstatic void COVER_ctx_destroy(COVER_ctx_t *ctx) {\n  if (!ctx) {\n    return;\n  }\n  if (ctx->suffix) {\n    free(ctx->suffix);\n    ctx->suffix = NULL;\n  }\n  if (ctx->freqs) {\n    free(ctx->freqs);\n    ctx->freqs = NULL;\n  }\n  if (ctx->dmerAt) {\n    free(ctx->dmerAt);\n    ctx->dmerAt = NULL;\n  }\n  if (ctx->offsets) {\n    free(ctx->offsets);\n    ctx->offsets = NULL;\n  }\n}\n\n/**\n * Prepare a context for dictionary building.\n * The context is only dependent on the parameter `d` and can be used multiple\n * times.\n * Returns 0 on success or error code on error.\n * The context must be destroyed with `COVER_ctx_destroy()`.\n */\nstatic size_t COVER_ctx_init(COVER_ctx_t *ctx, const void *samplesBuffer,\n                          const size_t *samplesSizes, unsigned nbSamples,\n                          unsigned d, double splitPoint, int displayLevel)\n{\n  const BYTE *const samples = (const BYTE *)samplesBuffer;\n  const size_t totalSamplesSize = COVER_sum(samplesSizes, nbSamples);\n  /* Split samples into testing and training sets */\n  const unsigned nbTrainSamples = splitPoint < 1.0 ? (unsigned)((double)nbSamples * splitPoint) : nbSamples;\n  const unsigned nbTestSamples = splitPoint < 1.0 ? nbSamples - nbTrainSamples : nbSamples;\n  const size_t trainingSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes, nbTrainSamples) : totalSamplesSize;\n  const size_t testSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes + nbTrainSamples, nbTestSamples) : totalSamplesSize;\n  ctx->displayLevel = displayLevel;\n  /* Checks */\n  if (totalSamplesSize < MAX(d, sizeof(U64)) ||\n      totalSamplesSize >= (size_t)COVER_MAX_SAMPLES_SIZE) {\n    DISPLAYLEVEL(1, \"Total samples size is too large (%u MB), maximum size is %u MB\\n\",\n                 (unsigned)(totalSamplesSize>>20), (COVER_MAX_SAMPLES_SIZE >> 20));\n    return ERROR(srcSize_wrong);\n  }\n  /* Check if there are at least 5 training samples */\n  if (nbTrainSamples < 5) {\n    DISPLAYLEVEL(1, \"Total number of training samples is %u and is invalid.\", nbTrainSamples);\n    return ERROR(srcSize_wrong);\n  }\n  /* Check if there's testing sample */\n  if (nbTestSamples < 1) {\n    DISPLAYLEVEL(1, \"Total number of testing samples is %u and is invalid.\", nbTestSamples);\n    return ERROR(srcSize_wrong);\n  }\n  /* Zero the context */\n  memset(ctx, 0, sizeof(*ctx));\n  DISPLAYLEVEL(2, \"Training on %u samples of total size %u\\n\", nbTrainSamples,\n               (unsigned)trainingSamplesSize);\n  DISPLAYLEVEL(2, \"Testing on %u samples of total size %u\\n\", nbTestSamples,\n               (unsigned)testSamplesSize);\n  ctx->samples = samples;\n  ctx->samplesSizes = samplesSizes;\n  ctx->nbSamples = nbSamples;\n  ctx->nbTrainSamples = nbTrainSamples;\n  ctx->nbTestSamples = nbTestSamples;\n  /* Partial suffix array */\n  ctx->suffixSize = trainingSamplesSize - MAX(d, sizeof(U64)) + 1;\n  ctx->suffix = (U32 *)malloc(ctx->suffixSize * sizeof(U32));\n  /* Maps index to the dmerID */\n  ctx->dmerAt = (U32 *)malloc(ctx->suffixSize * sizeof(U32));\n  /* The offsets of each file */\n  ctx->offsets = (size_t *)malloc((nbSamples + 1) * sizeof(size_t));\n  if (!ctx->suffix || !ctx->dmerAt || !ctx->offsets) {\n    DISPLAYLEVEL(1, \"Failed to allocate scratch buffers\\n\");\n    COVER_ctx_destroy(ctx);\n    return ERROR(memory_allocation);\n  }\n  ctx->freqs = NULL;\n  ctx->d = d;\n\n  /* Fill offsets from the samplesSizes */\n  {\n    U32 i;\n    ctx->offsets[0] = 0;\n    for (i = 1; i <= nbSamples; ++i) {\n      ctx->offsets[i] = ctx->offsets[i - 1] + samplesSizes[i - 1];\n    }\n  }\n  DISPLAYLEVEL(2, \"Constructing partial suffix array\\n\");\n  {\n    /* suffix is a partial suffix array.\n     * It only sorts suffixes by their first parameters.d bytes.\n     * The sort is stable, so each dmer group is sorted by position in input.\n     */\n    U32 i;\n    for (i = 0; i < ctx->suffixSize; ++i) {\n      ctx->suffix[i] = i;\n    }\n    stableSort(ctx);\n  }\n  DISPLAYLEVEL(2, \"Computing frequencies\\n\");\n  /* For each dmer group (group of positions with the same first d bytes):\n   * 1. For each position we set dmerAt[position] = dmerID.  The dmerID is\n   *    (groupBeginPtr - suffix).  This allows us to go from position to\n   *    dmerID so we can look up values in freq.\n   * 2. We calculate how many samples the dmer occurs in and save it in\n   *    freqs[dmerId].\n   */\n  COVER_groupBy(ctx->suffix, ctx->suffixSize, sizeof(U32), ctx,\n                (ctx->d <= 8 ? &COVER_cmp8 : &COVER_cmp), &COVER_group);\n  ctx->freqs = ctx->suffix;\n  ctx->suffix = NULL;\n  return 0;\n}\n\nvoid COVER_warnOnSmallCorpus(size_t maxDictSize, size_t nbDmers, int displayLevel)\n{\n  const double ratio = (double)nbDmers / (double)maxDictSize;\n  if (ratio >= 10) {\n      return;\n  }\n  DISPLAYLEVEL(1,\n               \"WARNING: The maximum dictionary size %u is too large \"\n               \"compared to the source size %u! \"\n               \"size(source)/size(dictionary) = %f, but it should be >= \"\n               \"10! This may lead to a subpar dictionary! We recommend \"\n               \"training on sources at least 10x, and preferably 100x \"\n               \"the size of the dictionary! \\n\", (U32)maxDictSize,\n               (U32)nbDmers, ratio);\n}\n\nCOVER_epoch_info_t COVER_computeEpochs(U32 maxDictSize,\n                                       U32 nbDmers, U32 k, U32 passes)\n{\n  const U32 minEpochSize = k * 10;\n  COVER_epoch_info_t epochs;\n  epochs.num = MAX(1, maxDictSize / k / passes);\n  epochs.size = nbDmers / epochs.num;\n  if (epochs.size >= minEpochSize) {\n      assert(epochs.size * epochs.num <= nbDmers);\n      return epochs;\n  }\n  epochs.size = MIN(minEpochSize, nbDmers);\n  epochs.num = nbDmers / epochs.size;\n  assert(epochs.size * epochs.num <= nbDmers);\n  return epochs;\n}\n\n/**\n * Given the prepared context build the dictionary.\n */\nstatic size_t COVER_buildDictionary(const COVER_ctx_t *ctx, U32 *freqs,\n                                    COVER_map_t *activeDmers, void *dictBuffer,\n                                    size_t dictBufferCapacity,\n                                    ZDICT_cover_params_t parameters) {\n  BYTE *const dict = (BYTE *)dictBuffer;\n  size_t tail = dictBufferCapacity;\n  /* Divide the data into epochs. We will select one segment from each epoch. */\n  const COVER_epoch_info_t epochs = COVER_computeEpochs(\n      (U32)dictBufferCapacity, (U32)ctx->suffixSize, parameters.k, 4);\n  const size_t maxZeroScoreRun = MAX(10, MIN(100, epochs.num >> 3));\n  size_t zeroScoreRun = 0;\n  size_t epoch;\n  clock_t lastUpdateTime = 0;\n  const int displayLevel = ctx->displayLevel;\n  DISPLAYLEVEL(2, \"Breaking content into %u epochs of size %u\\n\",\n                (U32)epochs.num, (U32)epochs.size);\n  /* Loop through the epochs until there are no more segments or the dictionary\n   * is full.\n   */\n  for (epoch = 0; tail > 0; epoch = (epoch + 1) % epochs.num) {\n    const U32 epochBegin = (U32)(epoch * epochs.size);\n    const U32 epochEnd = epochBegin + epochs.size;\n    size_t segmentSize;\n    /* Select a segment */\n    COVER_segment_t segment = COVER_selectSegment(\n        ctx, freqs, activeDmers, epochBegin, epochEnd, parameters);\n    /* If the segment covers no dmers, then we are out of content.\n     * There may be new content in other epochs, for continue for some time.\n     */\n    if (segment.score == 0) {\n      if (++zeroScoreRun >= maxZeroScoreRun) {\n          break;\n      }\n      continue;\n    }\n    zeroScoreRun = 0;\n    /* Trim the segment if necessary and if it is too small then we are done */\n    segmentSize = MIN(segment.end - segment.begin + parameters.d - 1, tail);\n    if (segmentSize < parameters.d) {\n      break;\n    }\n    /* We fill the dictionary from the back to allow the best segments to be\n     * referenced with the smallest offsets.\n     */\n    tail -= segmentSize;\n    memcpy(dict + tail, ctx->samples + segment.begin, segmentSize);\n    DISPLAYUPDATE(\n        lastUpdateTime,\n        2, \"\\r%u%%       \",\n        (unsigned)(((dictBufferCapacity - tail) * 100) / dictBufferCapacity));\n  }\n  DISPLAYLEVEL(2, \"\\r%79s\\r\", \"\");\n  return tail;\n}\n\nZDICTLIB_STATIC_API size_t ZDICT_trainFromBuffer_cover(\n    void *dictBuffer, size_t dictBufferCapacity,\n    const void *samplesBuffer, const size_t *samplesSizes, unsigned nbSamples,\n    ZDICT_cover_params_t parameters)\n{\n  BYTE* const dict = (BYTE*)dictBuffer;\n  COVER_ctx_t ctx;\n  COVER_map_t activeDmers;\n  const int displayLevel = (int)parameters.zParams.notificationLevel;\n  parameters.splitPoint = 1.0;\n  /* Checks */\n  if (!COVER_checkParameters(parameters, dictBufferCapacity)) {\n    DISPLAYLEVEL(1, \"Cover parameters incorrect\\n\");\n    return ERROR(parameter_outOfBound);\n  }\n  if (nbSamples == 0) {\n    DISPLAYLEVEL(1, \"Cover must have at least one input file\\n\");\n    return ERROR(srcSize_wrong);\n  }\n  if (dictBufferCapacity < ZDICT_DICTSIZE_MIN) {\n    DISPLAYLEVEL(1, \"dictBufferCapacity must be at least %u\\n\",\n                 ZDICT_DICTSIZE_MIN);\n    return ERROR(dstSize_tooSmall);\n  }\n  /* Initialize context and activeDmers */\n  {\n    size_t const initVal = COVER_ctx_init(&ctx, samplesBuffer, samplesSizes, nbSamples,\n                      parameters.d, parameters.splitPoint, displayLevel);\n    if (ZSTD_isError(initVal)) {\n      return initVal;\n    }\n  }\n  COVER_warnOnSmallCorpus(dictBufferCapacity, ctx.suffixSize, displayLevel);\n  if (!COVER_map_init(&activeDmers, parameters.k - parameters.d + 1)) {\n    DISPLAYLEVEL(1, \"Failed to allocate dmer map: out of memory\\n\");\n    COVER_ctx_destroy(&ctx);\n    return ERROR(memory_allocation);\n  }\n\n  DISPLAYLEVEL(2, \"Building dictionary\\n\");\n  {\n    const size_t tail =\n        COVER_buildDictionary(&ctx, ctx.freqs, &activeDmers, dictBuffer,\n                              dictBufferCapacity, parameters);\n    const size_t dictionarySize = ZDICT_finalizeDictionary(\n        dict, dictBufferCapacity, dict + tail, dictBufferCapacity - tail,\n        samplesBuffer, samplesSizes, nbSamples, parameters.zParams);\n    if (!ZSTD_isError(dictionarySize)) {\n      DISPLAYLEVEL(2, \"Constructed dictionary of size %u\\n\",\n                   (unsigned)dictionarySize);\n    }\n    COVER_ctx_destroy(&ctx);\n    COVER_map_destroy(&activeDmers);\n    return dictionarySize;\n  }\n}\n\n\n\nsize_t COVER_checkTotalCompressedSize(const ZDICT_cover_params_t parameters,\n                                    const size_t *samplesSizes, const BYTE *samples,\n                                    size_t *offsets,\n                                    size_t nbTrainSamples, size_t nbSamples,\n                                    BYTE *const dict, size_t dictBufferCapacity) {\n  size_t totalCompressedSize = ERROR(GENERIC);\n  /* Pointers */\n  ZSTD_CCtx *cctx;\n  ZSTD_CDict *cdict;\n  void *dst;\n  /* Local variables */\n  size_t dstCapacity;\n  size_t i;\n  /* Allocate dst with enough space to compress the maximum sized sample */\n  {\n    size_t maxSampleSize = 0;\n    i = parameters.splitPoint < 1.0 ? nbTrainSamples : 0;\n    for (; i < nbSamples; ++i) {\n      maxSampleSize = MAX(samplesSizes[i], maxSampleSize);\n    }\n    dstCapacity = ZSTD_compressBound(maxSampleSize);\n    dst = malloc(dstCapacity);\n  }\n  /* Create the cctx and cdict */\n  cctx = ZSTD_createCCtx();\n  cdict = ZSTD_createCDict(dict, dictBufferCapacity,\n                           parameters.zParams.compressionLevel);\n  if (!dst || !cctx || !cdict) {\n    goto _compressCleanup;\n  }\n  /* Compress each sample and sum their sizes (or error) */\n  totalCompressedSize = dictBufferCapacity;\n  i = parameters.splitPoint < 1.0 ? nbTrainSamples : 0;\n  for (; i < nbSamples; ++i) {\n    const size_t size = ZSTD_compress_usingCDict(\n        cctx, dst, dstCapacity, samples + offsets[i],\n        samplesSizes[i], cdict);\n    if (ZSTD_isError(size)) {\n      totalCompressedSize = size;\n      goto _compressCleanup;\n    }\n    totalCompressedSize += size;\n  }\n_compressCleanup:\n  ZSTD_freeCCtx(cctx);\n  ZSTD_freeCDict(cdict);\n  if (dst) {\n    free(dst);\n  }\n  return totalCompressedSize;\n}\n\n\n/**\n * Initialize the `COVER_best_t`.\n */\nvoid COVER_best_init(COVER_best_t *best) {\n  if (best==NULL) return; /* compatible with init on NULL */\n  (void)ZSTD_pthread_mutex_init(&best->mutex, NULL);\n  (void)ZSTD_pthread_cond_init(&best->cond, NULL);\n  best->liveJobs = 0;\n  best->dict = NULL;\n  best->dictSize = 0;\n  best->compressedSize = (size_t)-1;\n  memset(&best->parameters, 0, sizeof(best->parameters));\n}\n\n/**\n * Wait until liveJobs == 0.\n */\nvoid COVER_best_wait(COVER_best_t *best) {\n  if (!best) {\n    return;\n  }\n  ZSTD_pthread_mutex_lock(&best->mutex);\n  while (best->liveJobs != 0) {\n    ZSTD_pthread_cond_wait(&best->cond, &best->mutex);\n  }\n  ZSTD_pthread_mutex_unlock(&best->mutex);\n}\n\n/**\n * Call COVER_best_wait() and then destroy the COVER_best_t.\n */\nvoid COVER_best_destroy(COVER_best_t *best) {\n  if (!best) {\n    return;\n  }\n  COVER_best_wait(best);\n  if (best->dict) {\n    free(best->dict);\n  }\n  ZSTD_pthread_mutex_destroy(&best->mutex);\n  ZSTD_pthread_cond_destroy(&best->cond);\n}\n\n/**\n * Called when a thread is about to be launched.\n * Increments liveJobs.\n */\nvoid COVER_best_start(COVER_best_t *best) {\n  if (!best) {\n    return;\n  }\n  ZSTD_pthread_mutex_lock(&best->mutex);\n  ++best->liveJobs;\n  ZSTD_pthread_mutex_unlock(&best->mutex);\n}\n\n/**\n * Called when a thread finishes executing, both on error or success.\n * Decrements liveJobs and signals any waiting threads if liveJobs == 0.\n * If this dictionary is the best so far save it and its parameters.\n */\nvoid COVER_best_finish(COVER_best_t* best,\n                      ZDICT_cover_params_t parameters,\n                      COVER_dictSelection_t selection)\n{\n  void* dict = selection.dictContent;\n  size_t compressedSize = selection.totalCompressedSize;\n  size_t dictSize = selection.dictSize;\n  if (!best) {\n    return;\n  }\n  {\n    size_t liveJobs;\n    ZSTD_pthread_mutex_lock(&best->mutex);\n    --best->liveJobs;\n    liveJobs = best->liveJobs;\n    /* If the new dictionary is better */\n    if (compressedSize < best->compressedSize) {\n      /* Allocate space if necessary */\n      if (!best->dict || best->dictSize < dictSize) {\n        if (best->dict) {\n          free(best->dict);\n        }\n        best->dict = malloc(dictSize);\n        if (!best->dict) {\n          best->compressedSize = ERROR(GENERIC);\n          best->dictSize = 0;\n          ZSTD_pthread_cond_signal(&best->cond);\n          ZSTD_pthread_mutex_unlock(&best->mutex);\n          return;\n        }\n      }\n      /* Save the dictionary, parameters, and size */\n      if (dict) {\n        memcpy(best->dict, dict, dictSize);\n        best->dictSize = dictSize;\n        best->parameters = parameters;\n        best->compressedSize = compressedSize;\n      }\n    }\n    if (liveJobs == 0) {\n      ZSTD_pthread_cond_broadcast(&best->cond);\n    }\n    ZSTD_pthread_mutex_unlock(&best->mutex);\n  }\n}\n\nstatic COVER_dictSelection_t setDictSelection(BYTE* buf, size_t s, size_t csz)\n{\n    COVER_dictSelection_t ds;\n    ds.dictContent = buf;\n    ds.dictSize = s;\n    ds.totalCompressedSize = csz;\n    return ds;\n}\n\nCOVER_dictSelection_t COVER_dictSelectionError(size_t error) {\n    return setDictSelection(NULL, 0, error);\n}\n\nunsigned COVER_dictSelectionIsError(COVER_dictSelection_t selection) {\n  return (ZSTD_isError(selection.totalCompressedSize) || !selection.dictContent);\n}\n\nvoid COVER_dictSelectionFree(COVER_dictSelection_t selection){\n  free(selection.dictContent);\n}\n\nCOVER_dictSelection_t COVER_selectDict(BYTE* customDictContent, size_t dictBufferCapacity,\n        size_t dictContentSize, const BYTE* samplesBuffer, const size_t* samplesSizes, unsigned nbFinalizeSamples,\n        size_t nbCheckSamples, size_t nbSamples, ZDICT_cover_params_t params, size_t* offsets, size_t totalCompressedSize) {\n\n  size_t largestDict = 0;\n  size_t largestCompressed = 0;\n  BYTE* customDictContentEnd = customDictContent + dictContentSize;\n\n  BYTE* largestDictbuffer = (BYTE*)malloc(dictBufferCapacity);\n  BYTE* candidateDictBuffer = (BYTE*)malloc(dictBufferCapacity);\n  double regressionTolerance = ((double)params.shrinkDictMaxRegression / 100.0) + 1.00;\n\n  if (!largestDictbuffer || !candidateDictBuffer) {\n    free(largestDictbuffer);\n    free(candidateDictBuffer);\n    return COVER_dictSelectionError(dictContentSize);\n  }\n\n  /* Initial dictionary size and compressed size */\n  memcpy(largestDictbuffer, customDictContent, dictContentSize);\n  dictContentSize = ZDICT_finalizeDictionary(\n    largestDictbuffer, dictBufferCapacity, customDictContent, dictContentSize,\n    samplesBuffer, samplesSizes, nbFinalizeSamples, params.zParams);\n\n  if (ZDICT_isError(dictContentSize)) {\n    free(largestDictbuffer);\n    free(candidateDictBuffer);\n    return COVER_dictSelectionError(dictContentSize);\n  }\n\n  totalCompressedSize = COVER_checkTotalCompressedSize(params, samplesSizes,\n                                                       samplesBuffer, offsets,\n                                                       nbCheckSamples, nbSamples,\n                                                       largestDictbuffer, dictContentSize);\n\n  if (ZSTD_isError(totalCompressedSize)) {\n    free(largestDictbuffer);\n    free(candidateDictBuffer);\n    return COVER_dictSelectionError(totalCompressedSize);\n  }\n\n  if (params.shrinkDict == 0) {\n    free(candidateDictBuffer);\n    return setDictSelection(largestDictbuffer, dictContentSize, totalCompressedSize);\n  }\n\n  largestDict = dictContentSize;\n  largestCompressed = totalCompressedSize;\n  dictContentSize = ZDICT_DICTSIZE_MIN;\n\n  /* Largest dict is initially at least ZDICT_DICTSIZE_MIN */\n  while (dictContentSize < largestDict) {\n    memcpy(candidateDictBuffer, largestDictbuffer, largestDict);\n    dictContentSize = ZDICT_finalizeDictionary(\n      candidateDictBuffer, dictBufferCapacity, customDictContentEnd - dictContentSize, dictContentSize,\n      samplesBuffer, samplesSizes, nbFinalizeSamples, params.zParams);\n\n    if (ZDICT_isError(dictContentSize)) {\n      free(largestDictbuffer);\n      free(candidateDictBuffer);\n      return COVER_dictSelectionError(dictContentSize);\n\n    }\n\n    totalCompressedSize = COVER_checkTotalCompressedSize(params, samplesSizes,\n                                                         samplesBuffer, offsets,\n                                                         nbCheckSamples, nbSamples,\n                                                         candidateDictBuffer, dictContentSize);\n\n    if (ZSTD_isError(totalCompressedSize)) {\n      free(largestDictbuffer);\n      free(candidateDictBuffer);\n      return COVER_dictSelectionError(totalCompressedSize);\n    }\n\n    if ((double)totalCompressedSize <= (double)largestCompressed * regressionTolerance) {\n      free(largestDictbuffer);\n      return setDictSelection( candidateDictBuffer, dictContentSize, totalCompressedSize );\n    }\n    dictContentSize *= 2;\n  }\n  dictContentSize = largestDict;\n  totalCompressedSize = largestCompressed;\n  free(candidateDictBuffer);\n  return setDictSelection( largestDictbuffer, dictContentSize, totalCompressedSize );\n}\n\n/**\n * Parameters for COVER_tryParameters().\n */\ntypedef struct COVER_tryParameters_data_s {\n  const COVER_ctx_t *ctx;\n  COVER_best_t *best;\n  size_t dictBufferCapacity;\n  ZDICT_cover_params_t parameters;\n} COVER_tryParameters_data_t;\n\n/**\n * Tries a set of parameters and updates the COVER_best_t with the results.\n * This function is thread safe if zstd is compiled with multithreaded support.\n * It takes its parameters as an *OWNING* opaque pointer to support threading.\n */\nstatic void COVER_tryParameters(void *opaque)\n{\n  /* Save parameters as local variables */\n  COVER_tryParameters_data_t *const data = (COVER_tryParameters_data_t*)opaque;\n  const COVER_ctx_t *const ctx = data->ctx;\n  const ZDICT_cover_params_t parameters = data->parameters;\n  size_t dictBufferCapacity = data->dictBufferCapacity;\n  size_t totalCompressedSize = ERROR(GENERIC);\n  /* Allocate space for hash table, dict, and freqs */\n  COVER_map_t activeDmers;\n  BYTE* const dict = (BYTE*)malloc(dictBufferCapacity);\n  COVER_dictSelection_t selection = COVER_dictSelectionError(ERROR(GENERIC));\n  U32* const freqs = (U32*)malloc(ctx->suffixSize * sizeof(U32));\n  const int displayLevel = ctx->displayLevel;\n  if (!COVER_map_init(&activeDmers, parameters.k - parameters.d + 1)) {\n    DISPLAYLEVEL(1, \"Failed to allocate dmer map: out of memory\\n\");\n    goto _cleanup;\n  }\n  if (!dict || !freqs) {\n    DISPLAYLEVEL(1, \"Failed to allocate buffers: out of memory\\n\");\n    goto _cleanup;\n  }\n  /* Copy the frequencies because we need to modify them */\n  memcpy(freqs, ctx->freqs, ctx->suffixSize * sizeof(U32));\n  /* Build the dictionary */\n  {\n    const size_t tail = COVER_buildDictionary(ctx, freqs, &activeDmers, dict,\n                                              dictBufferCapacity, parameters);\n    selection = COVER_selectDict(dict + tail, dictBufferCapacity, dictBufferCapacity - tail,\n        ctx->samples, ctx->samplesSizes, (unsigned)ctx->nbTrainSamples, ctx->nbTrainSamples, ctx->nbSamples, parameters, ctx->offsets,\n        totalCompressedSize);\n\n    if (COVER_dictSelectionIsError(selection)) {\n      DISPLAYLEVEL(1, \"Failed to select dictionary\\n\");\n      goto _cleanup;\n    }\n  }\n_cleanup:\n  free(dict);\n  COVER_best_finish(data->best, parameters, selection);\n  free(data);\n  COVER_map_destroy(&activeDmers);\n  COVER_dictSelectionFree(selection);\n  free(freqs);\n}\n\nZDICTLIB_STATIC_API size_t ZDICT_optimizeTrainFromBuffer_cover(\n    void* dictBuffer, size_t dictBufferCapacity, const void* samplesBuffer,\n    const size_t* samplesSizes, unsigned nbSamples,\n    ZDICT_cover_params_t* parameters)\n{\n  /* constants */\n  const unsigned nbThreads = parameters->nbThreads;\n  const double splitPoint =\n      parameters->splitPoint <= 0.0 ? COVER_DEFAULT_SPLITPOINT : parameters->splitPoint;\n  const unsigned kMinD = parameters->d == 0 ? 6 : parameters->d;\n  const unsigned kMaxD = parameters->d == 0 ? 8 : parameters->d;\n  const unsigned kMinK = parameters->k == 0 ? 50 : parameters->k;\n  const unsigned kMaxK = parameters->k == 0 ? 2000 : parameters->k;\n  const unsigned kSteps = parameters->steps == 0 ? 40 : parameters->steps;\n  const unsigned kStepSize = MAX((kMaxK - kMinK) / kSteps, 1);\n  const unsigned kIterations =\n      (1 + (kMaxD - kMinD) / 2) * (1 + (kMaxK - kMinK) / kStepSize);\n  const unsigned shrinkDict = 0;\n  /* Local variables */\n  int displayLevel = (int)parameters->zParams.notificationLevel;\n  unsigned iteration = 1;\n  unsigned d;\n  unsigned k;\n  COVER_best_t best;\n  POOL_ctx *pool = NULL;\n  int warned = 0;\n  clock_t lastUpdateTime = 0;\n\n  /* Checks */\n  if (splitPoint <= 0 || splitPoint > 1) {\n    DISPLAYLEVEL(1, \"Incorrect parameters\\n\");\n    return ERROR(parameter_outOfBound);\n  }\n  if (kMinK < kMaxD || kMaxK < kMinK) {\n    DISPLAYLEVEL(1, \"Incorrect parameters\\n\");\n    return ERROR(parameter_outOfBound);\n  }\n  if (nbSamples == 0) {\n    DISPLAYLEVEL(1, \"Cover must have at least one input file\\n\");\n    return ERROR(srcSize_wrong);\n  }\n  if (dictBufferCapacity < ZDICT_DICTSIZE_MIN) {\n    DISPLAYLEVEL(1, \"dictBufferCapacity must be at least %u\\n\",\n                 ZDICT_DICTSIZE_MIN);\n    return ERROR(dstSize_tooSmall);\n  }\n  if (nbThreads > 1) {\n    pool = POOL_create(nbThreads, 1);\n    if (!pool) {\n      return ERROR(memory_allocation);\n    }\n  }\n  /* Initialization */\n  COVER_best_init(&best);\n  /* Loop through d first because each new value needs a new context */\n  DISPLAYLEVEL(2, \"Trying %u different sets of parameters\\n\",\n                    kIterations);\n  for (d = kMinD; d <= kMaxD; d += 2) {\n    /* Initialize the context for this value of d */\n    COVER_ctx_t ctx;\n    DISPLAYLEVEL(3, \"d=%u\\n\", d);\n    {\n      /* Turn down global display level to clean up display at level 2 and below */\n      const int childDisplayLevel = (displayLevel == 0) ? 0 : displayLevel - 1;\n      const size_t initVal = COVER_ctx_init(&ctx, samplesBuffer, samplesSizes, nbSamples, d, splitPoint, childDisplayLevel);\n      if (ZSTD_isError(initVal)) {\n        DISPLAYLEVEL(1, \"Failed to initialize context\\n\");\n        COVER_best_destroy(&best);\n        POOL_free(pool);\n        return initVal;\n      }\n    }\n    if (!warned) {\n      COVER_warnOnSmallCorpus(dictBufferCapacity, ctx.suffixSize, displayLevel);\n      warned = 1;\n    }\n    /* Loop through k reusing the same context */\n    for (k = kMinK; k <= kMaxK; k += kStepSize) {\n      /* Prepare the arguments */\n      COVER_tryParameters_data_t *data = (COVER_tryParameters_data_t *)malloc(\n          sizeof(COVER_tryParameters_data_t));\n      DISPLAYLEVEL(3, \"k=%u\\n\", k);\n      if (!data) {\n        DISPLAYLEVEL(1, \"Failed to allocate parameters\\n\");\n        COVER_best_destroy(&best);\n        COVER_ctx_destroy(&ctx);\n        POOL_free(pool);\n        return ERROR(memory_allocation);\n      }\n      data->ctx = &ctx;\n      data->best = &best;\n      data->dictBufferCapacity = dictBufferCapacity;\n      data->parameters = *parameters;\n      data->parameters.k = k;\n      data->parameters.d = d;\n      data->parameters.splitPoint = splitPoint;\n      data->parameters.steps = kSteps;\n      data->parameters.shrinkDict = shrinkDict;\n      data->parameters.zParams.notificationLevel = (unsigned)ctx.displayLevel;\n      /* Check the parameters */\n      if (!COVER_checkParameters(data->parameters, dictBufferCapacity)) {\n        DISPLAYLEVEL(1, \"Cover parameters incorrect\\n\");\n        free(data);\n        continue;\n      }\n      /* Call the function and pass ownership of data to it */\n      COVER_best_start(&best);\n      if (pool) {\n        POOL_add(pool, &COVER_tryParameters, data);\n      } else {\n        COVER_tryParameters(data);\n      }\n      /* Print status */\n      DISPLAYUPDATE(lastUpdateTime, 2, \"\\r%u%%       \",\n                    (unsigned)((iteration * 100) / kIterations));\n      ++iteration;\n    }\n    COVER_best_wait(&best);\n    COVER_ctx_destroy(&ctx);\n  }\n  DISPLAYLEVEL(2, \"\\r%79s\\r\", \"\");\n  /* Fill the output buffer and parameters with output of the best parameters */\n  {\n    const size_t dictSize = best.dictSize;\n    if (ZSTD_isError(best.compressedSize)) {\n      const size_t compressedSize = best.compressedSize;\n      COVER_best_destroy(&best);\n      POOL_free(pool);\n      return compressedSize;\n    }\n    *parameters = best.parameters;\n    memcpy(dictBuffer, best.dict, dictSize);\n    COVER_best_destroy(&best);\n    POOL_free(pool);\n    return dictSize;\n  }\n}\n"
  },
  {
    "path": "lib/dictBuilder/cover.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZDICT_STATIC_LINKING_ONLY\n#  define ZDICT_STATIC_LINKING_ONLY\n#endif\n\n#include \"../common/threading.h\" /* ZSTD_pthread_mutex_t */\n#include \"../common/mem.h\"   /* U32, BYTE */\n#include \"../zdict.h\"\n\n/**\n * COVER_best_t is used for two purposes:\n * 1. Synchronizing threads.\n * 2. Saving the best parameters and dictionary.\n *\n * All of the methods except COVER_best_init() are thread safe if zstd is\n * compiled with multithreaded support.\n */\ntypedef struct COVER_best_s {\n  ZSTD_pthread_mutex_t mutex;\n  ZSTD_pthread_cond_t cond;\n  size_t liveJobs;\n  void *dict;\n  size_t dictSize;\n  ZDICT_cover_params_t parameters;\n  size_t compressedSize;\n} COVER_best_t;\n\n/**\n * A segment is a range in the source as well as the score of the segment.\n */\ntypedef struct {\n  U32 begin;\n  U32 end;\n  U32 score;\n} COVER_segment_t;\n\n/**\n *Number of epochs and size of each epoch.\n */\ntypedef struct {\n  U32 num;\n  U32 size;\n} COVER_epoch_info_t;\n\n/**\n * Struct used for the dictionary selection function.\n */\ntypedef struct COVER_dictSelection {\n  BYTE* dictContent;\n  size_t dictSize;\n  size_t totalCompressedSize;\n} COVER_dictSelection_t;\n\n/**\n * Computes the number of epochs and the size of each epoch.\n * We will make sure that each epoch gets at least 10 * k bytes.\n *\n * The COVER algorithms divide the data up into epochs of equal size and\n * select one segment from each epoch.\n *\n * @param maxDictSize The maximum allowed dictionary size.\n * @param nbDmers     The number of dmers we are training on.\n * @param k           The parameter k (segment size).\n * @param passes      The target number of passes over the dmer corpus.\n *                    More passes means a better dictionary.\n */\nCOVER_epoch_info_t COVER_computeEpochs(U32 maxDictSize, U32 nbDmers,\n                                       U32 k, U32 passes);\n\n/**\n * Warns the user when their corpus is too small.\n */\nvoid COVER_warnOnSmallCorpus(size_t maxDictSize, size_t nbDmers, int displayLevel);\n\n/**\n *  Checks total compressed size of a dictionary\n */\nsize_t COVER_checkTotalCompressedSize(const ZDICT_cover_params_t parameters,\n                                      const size_t *samplesSizes, const BYTE *samples,\n                                      size_t *offsets,\n                                      size_t nbTrainSamples, size_t nbSamples,\n                                      BYTE *const dict, size_t dictBufferCapacity);\n\n/**\n * Returns the sum of the sample sizes.\n */\nsize_t COVER_sum(const size_t *samplesSizes, unsigned nbSamples) ;\n\n/**\n * Initialize the `COVER_best_t`.\n */\nvoid COVER_best_init(COVER_best_t *best);\n\n/**\n * Wait until liveJobs == 0.\n */\nvoid COVER_best_wait(COVER_best_t *best);\n\n/**\n * Call COVER_best_wait() and then destroy the COVER_best_t.\n */\nvoid COVER_best_destroy(COVER_best_t *best);\n\n/**\n * Called when a thread is about to be launched.\n * Increments liveJobs.\n */\nvoid COVER_best_start(COVER_best_t *best);\n\n/**\n * Called when a thread finishes executing, both on error or success.\n * Decrements liveJobs and signals any waiting threads if liveJobs == 0.\n * If this dictionary is the best so far save it and its parameters.\n */\nvoid COVER_best_finish(COVER_best_t *best, ZDICT_cover_params_t parameters,\n                       COVER_dictSelection_t selection);\n/**\n * Error function for COVER_selectDict function. Checks if the return\n * value is an error.\n */\nunsigned COVER_dictSelectionIsError(COVER_dictSelection_t selection);\n\n /**\n  * Error function for COVER_selectDict function. Returns a struct where\n  * return.totalCompressedSize is a ZSTD error.\n  */\nCOVER_dictSelection_t COVER_dictSelectionError(size_t error);\n\n/**\n * Always call after selectDict is called to free up used memory from\n * newly created dictionary.\n */\nvoid COVER_dictSelectionFree(COVER_dictSelection_t selection);\n\n/**\n * Called to finalize the dictionary and select one based on whether or not\n * the shrink-dict flag was enabled. If enabled the dictionary used is the\n * smallest dictionary within a specified regression of the compressed size\n * from the largest dictionary.\n */\n COVER_dictSelection_t COVER_selectDict(BYTE* customDictContent, size_t dictBufferCapacity,\n                       size_t dictContentSize, const BYTE* samplesBuffer, const size_t* samplesSizes, unsigned nbFinalizeSamples,\n                       size_t nbCheckSamples, size_t nbSamples, ZDICT_cover_params_t params, size_t* offsets, size_t totalCompressedSize);\n"
  },
  {
    "path": "lib/dictBuilder/divsufsort.c",
    "content": "/*\n * divsufsort.c for libdivsufsort-lite\n * Copyright (c) 2003-2008 Yuta Mori All Rights Reserved.\n *\n * Permission is hereby granted, free of charge, to any person\n * obtaining a copy of this software and associated documentation\n * files (the \"Software\"), to deal in the Software without\n * restriction, including without limitation the rights to use,\n * copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the\n * Software is furnished to do so, subject to the following\n * conditions:\n *\n * The above copyright notice and this permission notice shall be\n * included in all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n * OTHER DEALINGS IN THE SOFTWARE.\n */\n\n/*- Compiler specifics -*/\n#if defined(_MSC_VER)\n#  pragma warning(disable : 4127)    /* C4127 : Condition expression is constant */\n#endif\n\n\n/*- Dependencies -*/\n#include \n#include \n#include \n#include \n#include \n\n#include \"divsufsort.h\"\n\n#define PTRDIFF_TO_INT(x) (assert((x) <= INT_MAX && (x) >= INT_MIN), (int)(x))\n\n/*- Constants -*/\n#if defined(INLINE)\n# undef INLINE\n#endif\n#if !defined(INLINE)\n# define INLINE __inline\n#endif\n#if defined(ALPHABET_SIZE) && (ALPHABET_SIZE < 1)\n# undef ALPHABET_SIZE\n#endif\n#if !defined(ALPHABET_SIZE)\n# define ALPHABET_SIZE (256)\n#endif\n#define BUCKET_A_SIZE (ALPHABET_SIZE)\n#define BUCKET_B_SIZE (ALPHABET_SIZE * ALPHABET_SIZE)\n#if defined(SS_INSERTIONSORT_THRESHOLD)\n# if SS_INSERTIONSORT_THRESHOLD < 1\n#  undef SS_INSERTIONSORT_THRESHOLD\n#  define SS_INSERTIONSORT_THRESHOLD (1)\n# endif\n#else\n# define SS_INSERTIONSORT_THRESHOLD (8)\n#endif\n#if defined(SS_BLOCKSIZE)\n# if SS_BLOCKSIZE < 0\n#  undef SS_BLOCKSIZE\n#  define SS_BLOCKSIZE (0)\n# elif 32768 <= SS_BLOCKSIZE\n#  undef SS_BLOCKSIZE\n#  define SS_BLOCKSIZE (32767)\n# endif\n#else\n# define SS_BLOCKSIZE (1024)\n#endif\n/* minstacksize = log(SS_BLOCKSIZE) / log(3) * 2 */\n#if SS_BLOCKSIZE == 0\n# define SS_MISORT_STACKSIZE (96)\n#elif SS_BLOCKSIZE <= 4096\n# define SS_MISORT_STACKSIZE (16)\n#else\n# define SS_MISORT_STACKSIZE (24)\n#endif\n#define SS_SMERGE_STACKSIZE (32)\n#define TR_INSERTIONSORT_THRESHOLD (8)\n#define TR_STACKSIZE (64)\n\n\n/*- Macros -*/\n#ifndef SWAP\n# define SWAP(_a, _b) do { t = (_a); (_a) = (_b); (_b) = t; } while(0)\n#endif /* SWAP */\n#ifndef MIN\n# define MIN(_a, _b) (((_a) < (_b)) ? (_a) : (_b))\n#endif /* MIN */\n#ifndef MAX\n# define MAX(_a, _b) (((_a) > (_b)) ? (_a) : (_b))\n#endif /* MAX */\n#define STACK_PUSH(_a, _b, _c, _d)\\\n  do {\\\n    assert(ssize < STACK_SIZE);\\\n    stack[ssize].a = (_a), stack[ssize].b = (_b),\\\n    stack[ssize].c = (_c), stack[ssize++].d = (_d);\\\n  } while(0)\n#define STACK_PUSH5(_a, _b, _c, _d, _e)\\\n  do {\\\n    assert(ssize < STACK_SIZE);\\\n    stack[ssize].a = (_a), stack[ssize].b = (_b),\\\n    stack[ssize].c = (_c), stack[ssize].d = (_d), stack[ssize++].e = (_e);\\\n  } while(0)\n#define STACK_POP(_a, _b, _c, _d)\\\n  do {\\\n    assert(0 <= ssize);\\\n    if(ssize == 0) { return; }\\\n    (_a) = stack[--ssize].a, (_b) = stack[ssize].b,\\\n    (_c) = stack[ssize].c, (_d) = stack[ssize].d;\\\n  } while(0)\n#define STACK_POP5(_a, _b, _c, _d, _e)\\\n  do {\\\n    assert(0 <= ssize);\\\n    if(ssize == 0) { return; }\\\n    (_a) = stack[--ssize].a, (_b) = stack[ssize].b,\\\n    (_c) = stack[ssize].c, (_d) = stack[ssize].d, (_e) = stack[ssize].e;\\\n  } while(0)\n#define BUCKET_A(_c0) bucket_A[(_c0)]\n#if ALPHABET_SIZE == 256\n#define BUCKET_B(_c0, _c1) (bucket_B[((_c1) << 8) | (_c0)])\n#define BUCKET_BSTAR(_c0, _c1) (bucket_B[((_c0) << 8) | (_c1)])\n#else\n#define BUCKET_B(_c0, _c1) (bucket_B[(_c1) * ALPHABET_SIZE + (_c0)])\n#define BUCKET_BSTAR(_c0, _c1) (bucket_B[(_c0) * ALPHABET_SIZE + (_c1)])\n#endif\n\n\n/*- Private Functions -*/\n\nstatic const int lg_table[256]= {\n -1,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,\n  5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,\n  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,\n  6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,\n  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,\n  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,\n  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,\n  7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7\n};\n\n#if (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE)\n\nstatic INLINE\nint\nss_ilg(int n) {\n#if SS_BLOCKSIZE == 0\n  return (n & 0xffff0000) ?\n          ((n & 0xff000000) ?\n            24 + lg_table[(n >> 24) & 0xff] :\n            16 + lg_table[(n >> 16) & 0xff]) :\n          ((n & 0x0000ff00) ?\n             8 + lg_table[(n >>  8) & 0xff] :\n             0 + lg_table[(n >>  0) & 0xff]);\n#elif SS_BLOCKSIZE < 256\n  return lg_table[n];\n#else\n  return (n & 0xff00) ?\n          8 + lg_table[(n >> 8) & 0xff] :\n          0 + lg_table[(n >> 0) & 0xff];\n#endif\n}\n\n#endif /* (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) */\n\n#if SS_BLOCKSIZE != 0\n\nstatic const int sqq_table[256] = {\n  0,  16,  22,  27,  32,  35,  39,  42,  45,  48,  50,  53,  55,  57,  59,  61,\n 64,  65,  67,  69,  71,  73,  75,  76,  78,  80,  81,  83,  84,  86,  87,  89,\n 90,  91,  93,  94,  96,  97,  98,  99, 101, 102, 103, 104, 106, 107, 108, 109,\n110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126,\n128, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,\n143, 144, 144, 145, 146, 147, 148, 149, 150, 150, 151, 152, 153, 154, 155, 155,\n156, 157, 158, 159, 160, 160, 161, 162, 163, 163, 164, 165, 166, 167, 167, 168,\n169, 170, 170, 171, 172, 173, 173, 174, 175, 176, 176, 177, 178, 178, 179, 180,\n181, 181, 182, 183, 183, 184, 185, 185, 186, 187, 187, 188, 189, 189, 190, 191,\n192, 192, 193, 193, 194, 195, 195, 196, 197, 197, 198, 199, 199, 200, 201, 201,\n202, 203, 203, 204, 204, 205, 206, 206, 207, 208, 208, 209, 209, 210, 211, 211,\n212, 212, 213, 214, 214, 215, 215, 216, 217, 217, 218, 218, 219, 219, 220, 221,\n221, 222, 222, 223, 224, 224, 225, 225, 226, 226, 227, 227, 228, 229, 229, 230,\n230, 231, 231, 232, 232, 233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238,\n239, 240, 240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247,\n247, 248, 248, 249, 249, 250, 250, 251, 251, 252, 252, 253, 253, 254, 254, 255\n};\n\nstatic INLINE\nint\nss_isqrt(int x) {\n  int y, e;\n\n  if(x >= (SS_BLOCKSIZE * SS_BLOCKSIZE)) { return SS_BLOCKSIZE; }\n  e = ((unsigned)x & 0xffff0000) ?\n        (((unsigned)x & 0xff000000) ?\n          24 + lg_table[(x >> 24) & 0xff] :\n          16 + lg_table[(x >> 16) & 0xff]) :\n        ((x & 0x0000ff00) ?\n           8 + lg_table[(x >>  8) & 0xff] :\n           0 + lg_table[(x >>  0) & 0xff]);\n\n  if(e >= 16) {\n    y = sqq_table[x >> ((e - 6) - (e & 1))] << ((e >> 1) - 7);\n    if(e >= 24) { y = (y + 1 + x / y) >> 1; }\n    y = (y + 1 + x / y) >> 1;\n  } else if(e >= 8) {\n    y = (sqq_table[x >> ((e - 6) - (e & 1))] >> (7 - (e >> 1))) + 1;\n  } else {\n    return sqq_table[x] >> 4;\n  }\n\n  return (x < (y * y)) ? y - 1 : y;\n}\n\n#endif /* SS_BLOCKSIZE != 0 */\n\n\n/*---------------------------------------------------------------------------*/\n\n/* Compares two suffixes. */\nstatic INLINE\nint\nss_compare(const unsigned char *T,\n           const int *p1, const int *p2,\n           int depth) {\n  const unsigned char *U1, *U2, *U1n, *U2n;\n\n  for(U1 = T + depth + *p1,\n      U2 = T + depth + *p2,\n      U1n = T + *(p1 + 1) + 2,\n      U2n = T + *(p2 + 1) + 2;\n      (U1 < U1n) && (U2 < U2n) && (*U1 == *U2);\n      ++U1, ++U2) {\n  }\n\n  return U1 < U1n ?\n        (U2 < U2n ? *U1 - *U2 : 1) :\n        (U2 < U2n ? -1 : 0);\n}\n\n\n/*---------------------------------------------------------------------------*/\n\n#if (SS_BLOCKSIZE != 1) && (SS_INSERTIONSORT_THRESHOLD != 1)\n\n/* Insertionsort for small size groups */\nstatic\nvoid\nss_insertionsort(const unsigned char *T, const int *PA,\n                 int *first, int *last, int depth) {\n  int *i, *j;\n  int t;\n  int r;\n\n  for(i = last - 2; first <= i; --i) {\n    for(t = *i, j = i + 1; 0 < (r = ss_compare(T, PA + t, PA + *j, depth));) {\n      do { *(j - 1) = *j; } while((++j < last) && (*j < 0));\n      if(last <= j) { break; }\n    }\n    if(r == 0) { *j = ~*j; }\n    *(j - 1) = t;\n  }\n}\n\n#endif /* (SS_BLOCKSIZE != 1) && (SS_INSERTIONSORT_THRESHOLD != 1) */\n\n\n/*---------------------------------------------------------------------------*/\n\n#if (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE)\n\nstatic INLINE\nvoid\nss_fixdown(const unsigned char *Td, const int *PA,\n           int *SA, int i, int size) {\n  int j, k;\n  int v;\n  int c, d, e;\n\n  for(v = SA[i], c = Td[PA[v]]; (j = 2 * i + 1) < size; SA[i] = SA[k], i = k) {\n    d = Td[PA[SA[k = j++]]];\n    if(d < (e = Td[PA[SA[j]]])) { k = j; d = e; }\n    if(d <= c) { break; }\n  }\n  SA[i] = v;\n}\n\n/* Simple top-down heapsort. */\nstatic\nvoid\nss_heapsort(const unsigned char *Td, const int *PA, int *SA, int size) {\n  int i, m;\n  int t;\n\n  m = size;\n  if((size % 2) == 0) {\n    m--;\n    if(Td[PA[SA[m / 2]]] < Td[PA[SA[m]]]) { SWAP(SA[m], SA[m / 2]); }\n  }\n\n  for(i = m / 2 - 1; 0 <= i; --i) { ss_fixdown(Td, PA, SA, i, m); }\n  if((size % 2) == 0) { SWAP(SA[0], SA[m]); ss_fixdown(Td, PA, SA, 0, m); }\n  for(i = m - 1; 0 < i; --i) {\n    t = SA[0], SA[0] = SA[i];\n    ss_fixdown(Td, PA, SA, 0, i);\n    SA[i] = t;\n  }\n}\n\n\n/*---------------------------------------------------------------------------*/\n\n/* Returns the median of three elements. */\nstatic INLINE\nint *\nss_median3(const unsigned char *Td, const int *PA,\n           int *v1, int *v2, int *v3) {\n  int *t;\n  if(Td[PA[*v1]] > Td[PA[*v2]]) { SWAP(v1, v2); }\n  if(Td[PA[*v2]] > Td[PA[*v3]]) {\n    if(Td[PA[*v1]] > Td[PA[*v3]]) { return v1; }\n    else { return v3; }\n  }\n  return v2;\n}\n\n/* Returns the median of five elements. */\nstatic INLINE\nint *\nss_median5(const unsigned char *Td, const int *PA,\n           int *v1, int *v2, int *v3, int *v4, int *v5) {\n  int *t;\n  if(Td[PA[*v2]] > Td[PA[*v3]]) { SWAP(v2, v3); }\n  if(Td[PA[*v4]] > Td[PA[*v5]]) { SWAP(v4, v5); }\n  if(Td[PA[*v2]] > Td[PA[*v4]]) { SWAP(v2, v4); SWAP(v3, v5); }\n  if(Td[PA[*v1]] > Td[PA[*v3]]) { SWAP(v1, v3); }\n  if(Td[PA[*v1]] > Td[PA[*v4]]) { SWAP(v1, v4); SWAP(v3, v5); }\n  if(Td[PA[*v3]] > Td[PA[*v4]]) { return v4; }\n  return v3;\n}\n\n/* Returns the pivot element. */\nstatic INLINE\nint *\nss_pivot(const unsigned char *Td, const int *PA, int *first, int *last) {\n  int *middle;\n  int t;\n\n  t = PTRDIFF_TO_INT(last - first);\n  middle = first + t / 2;\n\n  if(t <= 512) {\n    if(t <= 32) {\n      return ss_median3(Td, PA, first, middle, last - 1);\n    } else {\n      t >>= 2;\n      return ss_median5(Td, PA, first, first + t, middle, last - 1 - t, last - 1);\n    }\n  }\n  t >>= 3;\n  first  = ss_median3(Td, PA, first, first + t, first + (t << 1));\n  middle = ss_median3(Td, PA, middle - t, middle, middle + t);\n  last   = ss_median3(Td, PA, last - 1 - (t << 1), last - 1 - t, last - 1);\n  return ss_median3(Td, PA, first, middle, last);\n}\n\n\n/*---------------------------------------------------------------------------*/\n\n/* Binary partition for substrings. */\nstatic INLINE\nint *\nss_partition(const int *PA,\n                    int *first, int *last, int depth) {\n  int *a, *b;\n  int t;\n  for(a = first - 1, b = last;;) {\n    for(; (++a < b) && ((PA[*a] + depth) >= (PA[*a + 1] + 1));) { *a = ~*a; }\n    for(; (a < --b) && ((PA[*b] + depth) <  (PA[*b + 1] + 1));) { }\n    if(b <= a) { break; }\n    t = ~*b;\n    *b = *a;\n    *a = t;\n  }\n  if(first < a) { *first = ~*first; }\n  return a;\n}\n\n/* Multikey introsort for medium size groups. */\nstatic\nvoid\nss_mintrosort(const unsigned char *T, const int *PA,\n              int *first, int *last,\n              int depth) {\n#define STACK_SIZE SS_MISORT_STACKSIZE\n  struct { int *a, *b, c; int d; } stack[STACK_SIZE];\n  const unsigned char *Td;\n  int *a, *b, *c, *d, *e, *f;\n  int s, t;\n  int ssize;\n  int limit;\n  int v, x = 0;\n\n  for(ssize = 0, limit = ss_ilg(PTRDIFF_TO_INT(last - first));;) {\n\n    if((last - first) <= SS_INSERTIONSORT_THRESHOLD) {\n#if 1 < SS_INSERTIONSORT_THRESHOLD\n      if(1 < (last - first)) { ss_insertionsort(T, PA, first, last, depth); }\n#endif\n      STACK_POP(first, last, depth, limit);\n      continue;\n    }\n\n    Td = T + depth;\n    if(limit-- == 0) { ss_heapsort(Td, PA, first, PTRDIFF_TO_INT(last - first)); }\n    if(limit < 0) {\n      for(a = first + 1, v = Td[PA[*first]]; a < last; ++a) {\n        if((x = Td[PA[*a]]) != v) {\n          if(1 < (a - first)) { break; }\n          v = x;\n          first = a;\n        }\n      }\n      if(Td[PA[*first] - 1] < v) {\n        first = ss_partition(PA, first, a, depth);\n      }\n      if((a - first) <= (last - a)) {\n        if(1 < (a - first)) {\n          STACK_PUSH(a, last, depth, -1);\n          last = a, depth += 1, limit = ss_ilg(PTRDIFF_TO_INT(a - first));\n        } else {\n          first = a, limit = -1;\n        }\n      } else {\n        if(1 < (last - a)) {\n          STACK_PUSH(first, a, depth + 1, ss_ilg(PTRDIFF_TO_INT(a - first)));\n          first = a, limit = -1;\n        } else {\n          last = a, depth += 1, limit = ss_ilg(PTRDIFF_TO_INT(a - first));\n        }\n      }\n      continue;\n    }\n\n    /* choose pivot */\n    a = ss_pivot(Td, PA, first, last);\n    v = Td[PA[*a]];\n    SWAP(*first, *a);\n\n    /* partition */\n    for(b = first; (++b < last) && ((x = Td[PA[*b]]) == v);) { }\n    if(((a = b) < last) && (x < v)) {\n      for(; (++b < last) && ((x = Td[PA[*b]]) <= v);) {\n        if(x == v) { SWAP(*b, *a); ++a; }\n      }\n    }\n    for(c = last; (b < --c) && ((x = Td[PA[*c]]) == v);) { }\n    if((b < (d = c)) && (x > v)) {\n      for(; (b < --c) && ((x = Td[PA[*c]]) >= v);) {\n        if(x == v) { SWAP(*c, *d); --d; }\n      }\n    }\n    for(; b < c;) {\n      SWAP(*b, *c);\n      for(; (++b < c) && ((x = Td[PA[*b]]) <= v);) {\n        if(x == v) { SWAP(*b, *a); ++a; }\n      }\n      for(; (b < --c) && ((x = Td[PA[*c]]) >= v);) {\n        if(x == v) { SWAP(*c, *d); --d; }\n      }\n    }\n\n    if(a <= d) {\n      c = b - 1;\n\n      if((s = PTRDIFF_TO_INT(a - first)) > (t = PTRDIFF_TO_INT(b - a))) { s = t; }\n      for(e = first, f = b - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }\n      if((s = PTRDIFF_TO_INT(d - c)) > (t = PTRDIFF_TO_INT(last - d - 1))) { s = t; }\n      for(e = b, f = last - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }\n\n      a = first + (b - a), c = last - (d - c);\n      b = (v <= Td[PA[*a] - 1]) ? a : ss_partition(PA, a, c, depth);\n\n      if((a - first) <= (last - c)) {\n        if((last - c) <= (c - b)) {\n          STACK_PUSH(b, c, depth + 1, ss_ilg(PTRDIFF_TO_INT(c - b)));\n          STACK_PUSH(c, last, depth, limit);\n          last = a;\n        } else if((a - first) <= (c - b)) {\n          STACK_PUSH(c, last, depth, limit);\n          STACK_PUSH(b, c, depth + 1, ss_ilg(PTRDIFF_TO_INT(c - b)));\n          last = a;\n        } else {\n          STACK_PUSH(c, last, depth, limit);\n          STACK_PUSH(first, a, depth, limit);\n          first = b, last = c, depth += 1, limit = ss_ilg(PTRDIFF_TO_INT(c - b));\n        }\n      } else {\n        if((a - first) <= (c - b)) {\n          STACK_PUSH(b, c, depth + 1, ss_ilg(PTRDIFF_TO_INT(c - b)));\n          STACK_PUSH(first, a, depth, limit);\n          first = c;\n        } else if((last - c) <= (c - b)) {\n          STACK_PUSH(first, a, depth, limit);\n          STACK_PUSH(b, c, depth + 1, ss_ilg(PTRDIFF_TO_INT(c - b)));\n          first = c;\n        } else {\n          STACK_PUSH(first, a, depth, limit);\n          STACK_PUSH(c, last, depth, limit);\n          first = b, last = c, depth += 1, limit = ss_ilg(PTRDIFF_TO_INT(c - b));\n        }\n      }\n    } else {\n      limit += 1;\n      if(Td[PA[*first] - 1] < v) {\n        first = ss_partition(PA, first, last, depth);\n        limit = ss_ilg(PTRDIFF_TO_INT(last - first));\n      }\n      depth += 1;\n    }\n  }\n#undef STACK_SIZE\n}\n\n#endif /* (SS_BLOCKSIZE == 0) || (SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE) */\n\n\n/*---------------------------------------------------------------------------*/\n\n#if SS_BLOCKSIZE != 0\n\nstatic INLINE\nvoid\nss_blockswap(int *a, int *b, int n) {\n  int t;\n  for(; 0 < n; --n, ++a, ++b) {\n    t = *a, *a = *b, *b = t;\n  }\n}\n\nstatic INLINE\nvoid\nss_rotate(int *first, int *middle, int *last) {\n  int *a, *b, t;\n  int l, r;\n  l = PTRDIFF_TO_INT(middle - first);\n  r = PTRDIFF_TO_INT(last - middle);\n  for(; (0 < l) && (0 < r);) {\n    if(l == r) { ss_blockswap(first, middle, l); break; }\n    if(l < r) {\n      a = last - 1, b = middle - 1;\n      t = *a;\n      do {\n        *a-- = *b, *b-- = *a;\n        if(b < first) {\n          *a = t;\n          last = a;\n          if((r -= l + 1) <= l) { break; }\n          a -= 1, b = middle - 1;\n          t = *a;\n        }\n      } while(1);\n    } else {\n      a = first, b = middle;\n      t = *a;\n      do {\n        *a++ = *b, *b++ = *a;\n        if(last <= b) {\n          *a = t;\n          first = a + 1;\n          if((l -= r + 1) <= r) { break; }\n          a += 1, b = middle;\n          t = *a;\n        }\n      } while(1);\n    }\n  }\n}\n\n\n/*---------------------------------------------------------------------------*/\n\nstatic\nvoid\nss_inplacemerge(const unsigned char *T, const int *PA,\n                int *first, int *middle, int *last,\n                int depth) {\n  const int *p;\n  int *a, *b;\n  int len, half;\n  int q, r;\n  int x;\n\n  for(;;) {\n    if(*(last - 1) < 0) { x = 1; p = PA + ~*(last - 1); }\n    else                { x = 0; p = PA +  *(last - 1); }\n    for(a = first, len = PTRDIFF_TO_INT(middle - first), half = len >> 1, r = -1;\n        0 < len;\n        len = half, half >>= 1) {\n      b = a + half;\n      q = ss_compare(T, PA + ((0 <= *b) ? *b : ~*b), p, depth);\n      if(q < 0) {\n        a = b + 1;\n        half -= (len & 1) ^ 1;\n      } else {\n        r = q;\n      }\n    }\n    if(a < middle) {\n      if(r == 0) { *a = ~*a; }\n      ss_rotate(a, middle, last);\n      last -= middle - a;\n      middle = a;\n      if(first == middle) { break; }\n    }\n    --last;\n    if(x != 0) { while(*--last < 0) { } }\n    if(middle == last) { break; }\n  }\n}\n\n\n/*---------------------------------------------------------------------------*/\n\n/* Merge-forward with internal buffer. */\nstatic\nvoid\nss_mergeforward(const unsigned char *T, const int *PA,\n                int *first, int *middle, int *last,\n                int *buf, int depth) {\n  int *a, *b, *c, *bufend;\n  int t;\n  int r;\n\n  bufend = buf + (middle - first) - 1;\n  ss_blockswap(buf, first, PTRDIFF_TO_INT(middle - first));\n\n  for(t = *(a = first), b = buf, c = middle;;) {\n    r = ss_compare(T, PA + *b, PA + *c, depth);\n    if(r < 0) {\n      do {\n        *a++ = *b;\n        if(bufend <= b) { *bufend = t; return; }\n        *b++ = *a;\n      } while(*b < 0);\n    } else if(r > 0) {\n      do {\n        *a++ = *c, *c++ = *a;\n        if(last <= c) {\n          while(b < bufend) { *a++ = *b, *b++ = *a; }\n          *a = *b, *b = t;\n          return;\n        }\n      } while(*c < 0);\n    } else {\n      *c = ~*c;\n      do {\n        *a++ = *b;\n        if(bufend <= b) { *bufend = t; return; }\n        *b++ = *a;\n      } while(*b < 0);\n\n      do {\n        *a++ = *c, *c++ = *a;\n        if(last <= c) {\n          while(b < bufend) { *a++ = *b, *b++ = *a; }\n          *a = *b, *b = t;\n          return;\n        }\n      } while(*c < 0);\n    }\n  }\n}\n\n/* Merge-backward with internal buffer. */\nstatic\nvoid\nss_mergebackward(const unsigned char *T, const int *PA,\n                 int *first, int *middle, int *last,\n                 int *buf, int depth) {\n  const int *p1, *p2;\n  int *a, *b, *c, *bufend;\n  int t;\n  int r;\n  int x;\n\n  bufend = buf + (last - middle) - 1;\n  ss_blockswap(buf, middle, PTRDIFF_TO_INT(last - middle));\n\n  x = 0;\n  if(*bufend < 0)       { p1 = PA + ~*bufend; x |= 1; }\n  else                  { p1 = PA +  *bufend; }\n  if(*(middle - 1) < 0) { p2 = PA + ~*(middle - 1); x |= 2; }\n  else                  { p2 = PA +  *(middle - 1); }\n  for(t = *(a = last - 1), b = bufend, c = middle - 1;;) {\n    r = ss_compare(T, p1, p2, depth);\n    if(0 < r) {\n      if(x & 1) { do { *a-- = *b, *b-- = *a; } while(*b < 0); x ^= 1; }\n      *a-- = *b;\n      if(b <= buf) { *buf = t; break; }\n      *b-- = *a;\n      if(*b < 0) { p1 = PA + ~*b; x |= 1; }\n      else       { p1 = PA +  *b; }\n    } else if(r < 0) {\n      if(x & 2) { do { *a-- = *c, *c-- = *a; } while(*c < 0); x ^= 2; }\n      *a-- = *c, *c-- = *a;\n      if(c < first) {\n        while(buf < b) { *a-- = *b, *b-- = *a; }\n        *a = *b, *b = t;\n        break;\n      }\n      if(*c < 0) { p2 = PA + ~*c; x |= 2; }\n      else       { p2 = PA +  *c; }\n    } else {\n      if(x & 1) { do { *a-- = *b, *b-- = *a; } while(*b < 0); x ^= 1; }\n      *a-- = ~*b;\n      if(b <= buf) { *buf = t; break; }\n      *b-- = *a;\n      if(x & 2) { do { *a-- = *c, *c-- = *a; } while(*c < 0); x ^= 2; }\n      *a-- = *c, *c-- = *a;\n      if(c < first) {\n        while(buf < b) { *a-- = *b, *b-- = *a; }\n        *a = *b, *b = t;\n        break;\n      }\n      if(*b < 0) { p1 = PA + ~*b; x |= 1; }\n      else       { p1 = PA +  *b; }\n      if(*c < 0) { p2 = PA + ~*c; x |= 2; }\n      else       { p2 = PA +  *c; }\n    }\n  }\n}\n\n/* D&C based merge. */\nstatic\nvoid\nss_swapmerge(const unsigned char *T, const int *PA,\n             int *first, int *middle, int *last,\n             int *buf, int bufsize, int depth) {\n#define STACK_SIZE SS_SMERGE_STACKSIZE\n#define GETIDX(a) ((0 <= (a)) ? (a) : (~(a)))\n#define MERGE_CHECK(a, b, c)\\\n  do {\\\n    if(((c) & 1) ||\\\n       (((c) & 2) && (ss_compare(T, PA + GETIDX(*((a) - 1)), PA + *(a), depth) == 0))) {\\\n      *(a) = ~*(a);\\\n    }\\\n    if(((c) & 4) && ((ss_compare(T, PA + GETIDX(*((b) - 1)), PA + *(b), depth) == 0))) {\\\n      *(b) = ~*(b);\\\n    }\\\n  } while(0)\n  struct { int *a, *b, *c; int d; } stack[STACK_SIZE];\n  int *l, *r, *lm, *rm;\n  int m, len, half;\n  int ssize;\n  int check, next;\n\n  for(check = 0, ssize = 0;;) {\n    if((last - middle) <= bufsize) {\n      if((first < middle) && (middle < last)) {\n        ss_mergebackward(T, PA, first, middle, last, buf, depth);\n      }\n      MERGE_CHECK(first, last, check);\n      STACK_POP(first, middle, last, check);\n      continue;\n    }\n\n    if((middle - first) <= bufsize) {\n      if(first < middle) {\n        ss_mergeforward(T, PA, first, middle, last, buf, depth);\n      }\n      MERGE_CHECK(first, last, check);\n      STACK_POP(first, middle, last, check);\n      continue;\n    }\n\n    for(m = 0, len = PTRDIFF_TO_INT(MIN(middle - first, last - middle)), half = len >> 1;\n        0 < len;\n        len = half, half >>= 1) {\n      if(ss_compare(T, PA + GETIDX(*(middle + m + half)),\n                       PA + GETIDX(*(middle - m - half - 1)), depth) < 0) {\n        m += half + 1;\n        half -= (len & 1) ^ 1;\n      }\n    }\n\n    if(0 < m) {\n      lm = middle - m, rm = middle + m;\n      ss_blockswap(lm, middle, m);\n      l = r = middle, next = 0;\n      if(rm < last) {\n        if(*rm < 0) {\n          *rm = ~*rm;\n          if(first < lm) { for(; *--l < 0;) { } next |= 4; }\n          next |= 1;\n        } else if(first < lm) {\n          for(; *r < 0; ++r) { }\n          next |= 2;\n        }\n      }\n\n      if((l - first) <= (last - r)) {\n        STACK_PUSH(r, rm, last, (next & 3) | (check & 4));\n        middle = lm, last = l, check = (check & 3) | (next & 4);\n      } else {\n        if((next & 2) && (r == middle)) { next ^= 6; }\n        STACK_PUSH(first, lm, l, (check & 3) | (next & 4));\n        first = r, middle = rm, check = (next & 3) | (check & 4);\n      }\n    } else {\n      if(ss_compare(T, PA + GETIDX(*(middle - 1)), PA + *middle, depth) == 0) {\n        *middle = ~*middle;\n      }\n      MERGE_CHECK(first, last, check);\n      STACK_POP(first, middle, last, check);\n    }\n  }\n#undef STACK_SIZE\n}\n\n#endif /* SS_BLOCKSIZE != 0 */\n\n\n/*---------------------------------------------------------------------------*/\n\n/* Substring sort */\nstatic\nvoid\nsssort(const unsigned char *T, const int *PA,\n       int *first, int *last,\n       int *buf, int bufsize,\n       int depth, int n, int lastsuffix) {\n  int *a;\n#if SS_BLOCKSIZE != 0\n  int *b, *middle, *curbuf;\n  int j, k, curbufsize, limit;\n#endif\n  int i;\n\n  if(lastsuffix != 0) { ++first; }\n\n#if SS_BLOCKSIZE == 0\n  ss_mintrosort(T, PA, first, last, depth);\n#else\n  if((bufsize < SS_BLOCKSIZE) &&\n      (bufsize < PTRDIFF_TO_INT(last - first)) &&\n      (bufsize < (limit = ss_isqrt(PTRDIFF_TO_INT(last - first))))) {\n    if(SS_BLOCKSIZE < limit) { limit = SS_BLOCKSIZE; }\n    buf = middle = last - limit, bufsize = limit;\n  } else {\n    middle = last, limit = 0;\n  }\n  for(a = first, i = 0; SS_BLOCKSIZE < (middle - a); a += SS_BLOCKSIZE, ++i) {\n#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE\n    ss_mintrosort(T, PA, a, a + SS_BLOCKSIZE, depth);\n#elif 1 < SS_BLOCKSIZE\n    ss_insertionsort(T, PA, a, a + SS_BLOCKSIZE, depth);\n#endif\n    curbufsize = PTRDIFF_TO_INT(last - (a + SS_BLOCKSIZE));\n    curbuf = a + SS_BLOCKSIZE;\n    if(curbufsize <= bufsize) { curbufsize = bufsize, curbuf = buf; }\n    for(b = a, k = SS_BLOCKSIZE, j = i; j & 1; b -= k, k <<= 1, j >>= 1) {\n      ss_swapmerge(T, PA, b - k, b, b + k, curbuf, curbufsize, depth);\n    }\n  }\n#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE\n  ss_mintrosort(T, PA, a, middle, depth);\n#elif 1 < SS_BLOCKSIZE\n  ss_insertionsort(T, PA, a, middle, depth);\n#endif\n  for(k = SS_BLOCKSIZE; i != 0; k <<= 1, i >>= 1) {\n    if(i & 1) {\n      ss_swapmerge(T, PA, a - k, a, middle, buf, bufsize, depth);\n      a -= k;\n    }\n  }\n  if(limit != 0) {\n#if SS_INSERTIONSORT_THRESHOLD < SS_BLOCKSIZE\n    ss_mintrosort(T, PA, middle, last, depth);\n#elif 1 < SS_BLOCKSIZE\n    ss_insertionsort(T, PA, middle, last, depth);\n#endif\n    ss_inplacemerge(T, PA, first, middle, last, depth);\n  }\n#endif\n\n  if(lastsuffix != 0) {\n    /* Insert last type B* suffix. */\n    int PAi[2]; PAi[0] = PA[*(first - 1)], PAi[1] = n - 2;\n    for(a = first, i = *(first - 1);\n        (a < last) && ((*a < 0) || (0 < ss_compare(T, &(PAi[0]), PA + *a, depth)));\n        ++a) {\n      *(a - 1) = *a;\n    }\n    *(a - 1) = i;\n  }\n}\n\n\n/*---------------------------------------------------------------------------*/\n\nstatic INLINE\nint\ntr_ilg(int n) {\n  return (n & 0xffff0000) ?\n          ((n & 0xff000000) ?\n            24 + lg_table[(n >> 24) & 0xff] :\n            16 + lg_table[(n >> 16) & 0xff]) :\n          ((n & 0x0000ff00) ?\n             8 + lg_table[(n >>  8) & 0xff] :\n             0 + lg_table[(n >>  0) & 0xff]);\n}\n\n\n/*---------------------------------------------------------------------------*/\n\n/* Simple insertionsort for small size groups. */\nstatic\nvoid\ntr_insertionsort(const int *ISAd, int *first, int *last) {\n  int *a, *b;\n  int t, r;\n\n  for(a = first + 1; a < last; ++a) {\n    for(t = *a, b = a - 1; 0 > (r = ISAd[t] - ISAd[*b]);) {\n      do { *(b + 1) = *b; } while((first <= --b) && (*b < 0));\n      if(b < first) { break; }\n    }\n    if(r == 0) { *b = ~*b; }\n    *(b + 1) = t;\n  }\n}\n\n\n/*---------------------------------------------------------------------------*/\n\nstatic INLINE\nvoid\ntr_fixdown(const int *ISAd, int *SA, int i, int size) {\n  int j, k;\n  int v;\n  int c, d, e;\n\n  for(v = SA[i], c = ISAd[v]; (j = 2 * i + 1) < size; SA[i] = SA[k], i = k) {\n    d = ISAd[SA[k = j++]];\n    if(d < (e = ISAd[SA[j]])) { k = j; d = e; }\n    if(d <= c) { break; }\n  }\n  SA[i] = v;\n}\n\n/* Simple top-down heapsort. */\nstatic\nvoid\ntr_heapsort(const int *ISAd, int *SA, int size) {\n  int i, m;\n  int t;\n\n  m = size;\n  if((size % 2) == 0) {\n    m--;\n    if(ISAd[SA[m / 2]] < ISAd[SA[m]]) { SWAP(SA[m], SA[m / 2]); }\n  }\n\n  for(i = m / 2 - 1; 0 <= i; --i) { tr_fixdown(ISAd, SA, i, m); }\n  if((size % 2) == 0) { SWAP(SA[0], SA[m]); tr_fixdown(ISAd, SA, 0, m); }\n  for(i = m - 1; 0 < i; --i) {\n    t = SA[0], SA[0] = SA[i];\n    tr_fixdown(ISAd, SA, 0, i);\n    SA[i] = t;\n  }\n}\n\n\n/*---------------------------------------------------------------------------*/\n\n/* Returns the median of three elements. */\nstatic INLINE\nint *\ntr_median3(const int *ISAd, int *v1, int *v2, int *v3) {\n  int *t;\n  if(ISAd[*v1] > ISAd[*v2]) { SWAP(v1, v2); }\n  if(ISAd[*v2] > ISAd[*v3]) {\n    if(ISAd[*v1] > ISAd[*v3]) { return v1; }\n    else { return v3; }\n  }\n  return v2;\n}\n\n/* Returns the median of five elements. */\nstatic INLINE\nint *\ntr_median5(const int *ISAd,\n           int *v1, int *v2, int *v3, int *v4, int *v5) {\n  int *t;\n  if(ISAd[*v2] > ISAd[*v3]) { SWAP(v2, v3); }\n  if(ISAd[*v4] > ISAd[*v5]) { SWAP(v4, v5); }\n  if(ISAd[*v2] > ISAd[*v4]) { SWAP(v2, v4); SWAP(v3, v5); }\n  if(ISAd[*v1] > ISAd[*v3]) { SWAP(v1, v3); }\n  if(ISAd[*v1] > ISAd[*v4]) { SWAP(v1, v4); SWAP(v3, v5); }\n  if(ISAd[*v3] > ISAd[*v4]) { return v4; }\n  return v3;\n}\n\n/* Returns the pivot element. */\nstatic INLINE\nint *\ntr_pivot(const int *ISAd, int *first, int *last) {\n  int *middle;\n  int t;\n\n  t = PTRDIFF_TO_INT(last - first);\n  middle = first + t / 2;\n\n  if(t <= 512) {\n    if(t <= 32) {\n      return tr_median3(ISAd, first, middle, last - 1);\n    } else {\n      t >>= 2;\n      return tr_median5(ISAd, first, first + t, middle, last - 1 - t, last - 1);\n    }\n  }\n  t >>= 3;\n  first  = tr_median3(ISAd, first, first + t, first + (t << 1));\n  middle = tr_median3(ISAd, middle - t, middle, middle + t);\n  last   = tr_median3(ISAd, last - 1 - (t << 1), last - 1 - t, last - 1);\n  return tr_median3(ISAd, first, middle, last);\n}\n\n\n/*---------------------------------------------------------------------------*/\n\ntypedef struct _trbudget_t trbudget_t;\nstruct _trbudget_t {\n  int chance;\n  int remain;\n  int incval;\n  int count;\n};\n\nstatic INLINE\nvoid\ntrbudget_init(trbudget_t *budget, int chance, int incval) {\n  budget->chance = chance;\n  budget->remain = budget->incval = incval;\n}\n\nstatic INLINE\nint\ntrbudget_check(trbudget_t *budget, int size) {\n  if(size <= budget->remain) { budget->remain -= size; return 1; }\n  if(budget->chance == 0) { budget->count += size; return 0; }\n  budget->remain += budget->incval - size;\n  budget->chance -= 1;\n  return 1;\n}\n\n\n/*---------------------------------------------------------------------------*/\n\nstatic INLINE\nvoid\ntr_partition(const int *ISAd,\n             int *first, int *middle, int *last,\n             int **pa, int **pb, int v) {\n  int *a, *b, *c, *d, *e, *f;\n  int t, s;\n  int x = 0;\n\n  for(b = middle - 1; (++b < last) && ((x = ISAd[*b]) == v);) { }\n  if(((a = b) < last) && (x < v)) {\n    for(; (++b < last) && ((x = ISAd[*b]) <= v);) {\n      if(x == v) { SWAP(*b, *a); ++a; }\n    }\n  }\n  for(c = last; (b < --c) && ((x = ISAd[*c]) == v);) { }\n  if((b < (d = c)) && (x > v)) {\n    for(; (b < --c) && ((x = ISAd[*c]) >= v);) {\n      if(x == v) { SWAP(*c, *d); --d; }\n    }\n  }\n  for(; b < c;) {\n    SWAP(*b, *c);\n    for(; (++b < c) && ((x = ISAd[*b]) <= v);) {\n      if(x == v) { SWAP(*b, *a); ++a; }\n    }\n    for(; (b < --c) && ((x = ISAd[*c]) >= v);) {\n      if(x == v) { SWAP(*c, *d); --d; }\n    }\n  }\n\n  if(a <= d) {\n    c = b - 1;\n    if((s = PTRDIFF_TO_INT(a - first)) > (t = PTRDIFF_TO_INT(b - a))) { s = t; }\n    for(e = first, f = b - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }\n    if((s = PTRDIFF_TO_INT(d - c)) > (t = PTRDIFF_TO_INT(last - d - 1))) { s = t; }\n    for(e = b, f = last - s; 0 < s; --s, ++e, ++f) { SWAP(*e, *f); }\n    first += (b - a), last -= (d - c);\n  }\n  *pa = first, *pb = last;\n}\n\nstatic\nvoid\ntr_copy(int *ISA, const int *SA,\n        int *first, int *a, int *b, int *last,\n        int depth) {\n  /* sort suffixes of middle partition\n     by using sorted order of suffixes of left and right partition. */\n  int *c, *d, *e;\n  int s, v;\n\n  v = PTRDIFF_TO_INT(b - SA - 1);\n  for(c = first, d = a - 1; c <= d; ++c) {\n    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {\n      *++d = s;\n      ISA[s] = PTRDIFF_TO_INT(d - SA);\n    }\n  }\n  for(c = last - 1, e = d + 1, d = b; e < d; --c) {\n    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {\n      *--d = s;\n      ISA[s] = PTRDIFF_TO_INT(d - SA);\n    }\n  }\n}\n\nstatic\nvoid\ntr_partialcopy(int *ISA, const int *SA,\n               int *first, int *a, int *b, int *last,\n               int depth) {\n  int *c, *d, *e;\n  int s, v;\n  int rank, lastrank, newrank = -1;\n\n  v = PTRDIFF_TO_INT(b - SA - 1);\n  lastrank = -1;\n  for(c = first, d = a - 1; c <= d; ++c) {\n    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {\n      *++d = s;\n      rank = ISA[s + depth];\n      if(lastrank != rank) { lastrank = rank; newrank = PTRDIFF_TO_INT(d - SA); }\n      ISA[s] = newrank;\n    }\n  }\n\n  lastrank = -1;\n  for(e = d; first <= e; --e) {\n    rank = ISA[*e];\n    if(lastrank != rank) { lastrank = rank; newrank = PTRDIFF_TO_INT(e - SA); }\n    if(newrank != rank) { ISA[*e] = newrank; }\n  }\n\n  lastrank = -1;\n  for(c = last - 1, e = d + 1, d = b; e < d; --c) {\n    if((0 <= (s = *c - depth)) && (ISA[s] == v)) {\n      *--d = s;\n      rank = ISA[s + depth];\n      if(lastrank != rank) { lastrank = rank; newrank = PTRDIFF_TO_INT(d - SA); }\n      ISA[s] = newrank;\n    }\n  }\n}\n\nstatic\nvoid\ntr_introsort(int *ISA, const int *ISAd,\n             int *SA, int *first, int *last,\n             trbudget_t *budget) {\n#define STACK_SIZE TR_STACKSIZE\n  struct { const int *a; int *b, *c; int d, e; }stack[STACK_SIZE];\n  int *a, *b, *c;\n  int t;\n  int v, x = 0;\n  int incr = PTRDIFF_TO_INT(ISAd - ISA);\n  int limit, next;\n  int ssize, trlink = -1;\n\n  for(ssize = 0, limit = tr_ilg(PTRDIFF_TO_INT(last - first));;) {\n\n    if(limit < 0) {\n      if(limit == -1) {\n        /* tandem repeat partition */\n        tr_partition(ISAd - incr, first, first, last, &a, &b, PTRDIFF_TO_INT(last - SA - 1));\n\n        /* update ranks */\n        if(a < last) {\n          for(c = first, v = PTRDIFF_TO_INT(a - SA - 1); c < a; ++c) { ISA[*c] = v; }\n        }\n        if(b < last) {\n          for(c = a, v = PTRDIFF_TO_INT(b - SA - 1); c < b; ++c) { ISA[*c] = v; }\n        }\n\n        /* push */\n        if(1 < (b - a)) {\n          STACK_PUSH5(NULL, a, b, 0, 0);\n          STACK_PUSH5(ISAd - incr, first, last, -2, trlink);\n          trlink = ssize - 2;\n        }\n        if((a - first) <= (last - b)) {\n          if(1 < (a - first)) {\n            STACK_PUSH5(ISAd, b, last, tr_ilg(PTRDIFF_TO_INT(last - b)), trlink);\n            last = a, limit = tr_ilg(PTRDIFF_TO_INT(a - first));\n          } else if(1 < (last - b)) {\n            first = b, limit = tr_ilg(PTRDIFF_TO_INT(last - b));\n          } else {\n            STACK_POP5(ISAd, first, last, limit, trlink);\n          }\n        } else {\n          if(1 < (last - b)) {\n            STACK_PUSH5(ISAd, first, a, tr_ilg(PTRDIFF_TO_INT(a - first)), trlink);\n            first = b, limit = tr_ilg(PTRDIFF_TO_INT(last - b));\n          } else if(1 < (a - first)) {\n            last = a, limit = tr_ilg(PTRDIFF_TO_INT(a - first));\n          } else {\n            STACK_POP5(ISAd, first, last, limit, trlink);\n          }\n        }\n      } else if(limit == -2) {\n        /* tandem repeat copy */\n        a = stack[--ssize].b, b = stack[ssize].c;\n        if(stack[ssize].d == 0) {\n          tr_copy(ISA, SA, first, a, b, last, PTRDIFF_TO_INT(ISAd - ISA));\n        } else {\n          if(0 <= trlink) { stack[trlink].d = -1; }\n          tr_partialcopy(ISA, SA, first, a, b, last, PTRDIFF_TO_INT(ISAd - ISA));\n        }\n        STACK_POP5(ISAd, first, last, limit, trlink);\n      } else {\n        /* sorted partition */\n        if(0 <= *first) {\n          a = first;\n          do { ISA[*a] = PTRDIFF_TO_INT(a - SA); } while((++a < last) && (0 <= *a));\n          first = a;\n        }\n        if(first < last) {\n          a = first; do { *a = ~*a; } while(*++a < 0);\n          next = (ISA[*a] != ISAd[*a]) ? tr_ilg(PTRDIFF_TO_INT(a - first + 1)) : -1;\n          if(++a < last) { for(b = first, v = PTRDIFF_TO_INT(a - SA - 1); b < a; ++b) { ISA[*b] = v; } }\n\n          /* push */\n          if(trbudget_check(budget, PTRDIFF_TO_INT(a - first))) {\n            if((a - first) <= (last - a)) {\n              STACK_PUSH5(ISAd, a, last, -3, trlink);\n              ISAd += incr, last = a, limit = next;\n            } else {\n              if(1 < (last - a)) {\n                STACK_PUSH5(ISAd + incr, first, a, next, trlink);\n                first = a, limit = -3;\n              } else {\n                ISAd += incr, last = a, limit = next;\n              }\n            }\n          } else {\n            if(0 <= trlink) { stack[trlink].d = -1; }\n            if(1 < (last - a)) {\n              first = a, limit = -3;\n            } else {\n              STACK_POP5(ISAd, first, last, limit, trlink);\n            }\n          }\n        } else {\n          STACK_POP5(ISAd, first, last, limit, trlink);\n        }\n      }\n      continue;\n    }\n\n    if((last - first) <= TR_INSERTIONSORT_THRESHOLD) {\n      tr_insertionsort(ISAd, first, last);\n      limit = -3;\n      continue;\n    }\n\n    if(limit-- == 0) {\n      tr_heapsort(ISAd, first, PTRDIFF_TO_INT(last - first));\n      for(a = last - 1; first < a; a = b) {\n        for(x = ISAd[*a], b = a - 1; (first <= b) && (ISAd[*b] == x); --b) { *b = ~*b; }\n      }\n      limit = -3;\n      continue;\n    }\n\n    /* choose pivot */\n    a = tr_pivot(ISAd, first, last);\n    SWAP(*first, *a);\n    v = ISAd[*first];\n\n    /* partition */\n    tr_partition(ISAd, first, first + 1, last, &a, &b, v);\n    if((last - first) != (b - a)) {\n      next = (ISA[*a] != v) ? tr_ilg(PTRDIFF_TO_INT(b - a)) : -1;\n\n      /* update ranks */\n      for(c = first, v = PTRDIFF_TO_INT(a - SA - 1); c < a; ++c) { ISA[*c] = v; }\n      if(b < last) { for(c = a, v = PTRDIFF_TO_INT(b - SA - 1); c < b; ++c) { ISA[*c] = v; } }\n\n      /* push */\n      if((1 < (b - a)) && (trbudget_check(budget, PTRDIFF_TO_INT(b - a)))) {\n        if((a - first) <= (last - b)) {\n          if((last - b) <= (b - a)) {\n            if(1 < (a - first)) {\n              STACK_PUSH5(ISAd + incr, a, b, next, trlink);\n              STACK_PUSH5(ISAd, b, last, limit, trlink);\n              last = a;\n            } else if(1 < (last - b)) {\n              STACK_PUSH5(ISAd + incr, a, b, next, trlink);\n              first = b;\n            } else {\n              ISAd += incr, first = a, last = b, limit = next;\n            }\n          } else if((a - first) <= (b - a)) {\n            if(1 < (a - first)) {\n              STACK_PUSH5(ISAd, b, last, limit, trlink);\n              STACK_PUSH5(ISAd + incr, a, b, next, trlink);\n              last = a;\n            } else {\n              STACK_PUSH5(ISAd, b, last, limit, trlink);\n              ISAd += incr, first = a, last = b, limit = next;\n            }\n          } else {\n            STACK_PUSH5(ISAd, b, last, limit, trlink);\n            STACK_PUSH5(ISAd, first, a, limit, trlink);\n            ISAd += incr, first = a, last = b, limit = next;\n          }\n        } else {\n          if((a - first) <= (b - a)) {\n            if(1 < (last - b)) {\n              STACK_PUSH5(ISAd + incr, a, b, next, trlink);\n              STACK_PUSH5(ISAd, first, a, limit, trlink);\n              first = b;\n            } else if(1 < (a - first)) {\n              STACK_PUSH5(ISAd + incr, a, b, next, trlink);\n              last = a;\n            } else {\n              ISAd += incr, first = a, last = b, limit = next;\n            }\n          } else if((last - b) <= (b - a)) {\n            if(1 < (last - b)) {\n              STACK_PUSH5(ISAd, first, a, limit, trlink);\n              STACK_PUSH5(ISAd + incr, a, b, next, trlink);\n              first = b;\n            } else {\n              STACK_PUSH5(ISAd, first, a, limit, trlink);\n              ISAd += incr, first = a, last = b, limit = next;\n            }\n          } else {\n            STACK_PUSH5(ISAd, first, a, limit, trlink);\n            STACK_PUSH5(ISAd, b, last, limit, trlink);\n            ISAd += incr, first = a, last = b, limit = next;\n          }\n        }\n      } else {\n        if((1 < (b - a)) && (0 <= trlink)) { stack[trlink].d = -1; }\n        if((a - first) <= (last - b)) {\n          if(1 < (a - first)) {\n            STACK_PUSH5(ISAd, b, last, limit, trlink);\n            last = a;\n          } else if(1 < (last - b)) {\n            first = b;\n          } else {\n            STACK_POP5(ISAd, first, last, limit, trlink);\n          }\n        } else {\n          if(1 < (last - b)) {\n            STACK_PUSH5(ISAd, first, a, limit, trlink);\n            first = b;\n          } else if(1 < (a - first)) {\n            last = a;\n          } else {\n            STACK_POP5(ISAd, first, last, limit, trlink);\n          }\n        }\n      }\n    } else {\n      if(trbudget_check(budget, PTRDIFF_TO_INT(last - first))) {\n        limit = tr_ilg(PTRDIFF_TO_INT(last - first)), ISAd += incr;\n      } else {\n        if(0 <= trlink) { stack[trlink].d = -1; }\n        STACK_POP5(ISAd, first, last, limit, trlink);\n      }\n    }\n  }\n#undef STACK_SIZE\n}\n\n\n\n/*---------------------------------------------------------------------------*/\n\n/* Tandem repeat sort */\nstatic\nvoid\ntrsort(int *ISA, int *SA, int n, int depth) {\n  int *ISAd;\n  int *first, *last;\n  trbudget_t budget;\n  int t, skip, unsorted;\n\n  trbudget_init(&budget, tr_ilg(n) * 2 / 3, n);\n/*  trbudget_init(&budget, tr_ilg(n) * 3 / 4, n); */\n  for(ISAd = ISA + depth; -n < *SA; ISAd += ISAd - ISA) {\n    first = SA;\n    skip = 0;\n    unsorted = 0;\n    do {\n      if((t = *first) < 0) { first -= t; skip += t; }\n      else {\n        if(skip != 0) { *(first + skip) = skip; skip = 0; }\n        last = SA + ISA[t] + 1;\n        if(1 < (last - first)) {\n          budget.count = 0;\n          tr_introsort(ISA, ISAd, SA, first, last, &budget);\n          if(budget.count != 0) { unsorted += budget.count; }\n          else { skip = PTRDIFF_TO_INT(first - last); }\n        } else if((last - first) == 1) {\n          skip = -1;\n        }\n        first = last;\n      }\n    } while(first < (SA + n));\n    if(skip != 0) { *(first + skip) = skip; }\n    if(unsorted == 0) { break; }\n  }\n}\n\n\n/*---------------------------------------------------------------------------*/\n\n/* Sorts suffixes of type B*. */\nstatic\nint\nsort_typeBstar(const unsigned char *T, int *SA,\n               int *bucket_A, int *bucket_B,\n               int n, int openMP) {\n  int *PAb, *ISAb, *buf;\n#ifdef LIBBSC_OPENMP\n  int *curbuf;\n  int l;\n#endif\n  int i, j, k, t, m, bufsize;\n  int c0, c1;\n#ifdef LIBBSC_OPENMP\n  int d0, d1;\n#endif\n  (void)openMP;\n\n  /* Initialize bucket arrays. */\n  for(i = 0; i < BUCKET_A_SIZE; ++i) { bucket_A[i] = 0; }\n  for(i = 0; i < BUCKET_B_SIZE; ++i) { bucket_B[i] = 0; }\n\n  /* Count the number of occurrences of the first one or two characters of each\n     type A, B and B* suffix. Moreover, store the beginning position of all\n     type B* suffixes into the array SA. */\n  for(i = n - 1, m = n, c0 = T[n - 1]; 0 <= i;) {\n    /* type A suffix. */\n    do { ++BUCKET_A(c1 = c0); } while((0 <= --i) && ((c0 = T[i]) >= c1));\n    if(0 <= i) {\n      /* type B* suffix. */\n      ++BUCKET_BSTAR(c0, c1);\n      SA[--m] = i;\n      /* type B suffix. */\n      for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0) {\n        ++BUCKET_B(c0, c1);\n      }\n    }\n  }\n  m = n - m;\n/*\nnote:\n  A type B* suffix is lexicographically smaller than a type B suffix that\n  begins with the same first two characters.\n*/\n\n  /* Calculate the index of start/end point of each bucket. */\n  for(c0 = 0, i = 0, j = 0; c0 < ALPHABET_SIZE; ++c0) {\n    t = i + BUCKET_A(c0);\n    BUCKET_A(c0) = i + j; /* start point */\n    i = t + BUCKET_B(c0, c0);\n    for(c1 = c0 + 1; c1 < ALPHABET_SIZE; ++c1) {\n      j += BUCKET_BSTAR(c0, c1);\n      BUCKET_BSTAR(c0, c1) = j; /* end point */\n      i += BUCKET_B(c0, c1);\n    }\n  }\n\n  if(0 < m) {\n    /* Sort the type B* suffixes by their first two characters. */\n    PAb = SA + n - m; ISAb = SA + m;\n    for(i = m - 2; 0 <= i; --i) {\n      t = PAb[i], c0 = T[t], c1 = T[t + 1];\n      SA[--BUCKET_BSTAR(c0, c1)] = i;\n    }\n    t = PAb[m - 1], c0 = T[t], c1 = T[t + 1];\n    SA[--BUCKET_BSTAR(c0, c1)] = m - 1;\n\n    /* Sort the type B* substrings using sssort. */\n#ifdef LIBBSC_OPENMP\n    if (openMP)\n    {\n        buf = SA + m;\n        c0 = ALPHABET_SIZE - 2, c1 = ALPHABET_SIZE - 1, j = m;\n#pragma omp parallel default(shared) private(bufsize, curbuf, k, l, d0, d1)\n        {\n          bufsize = (n - (2 * m)) / omp_get_num_threads();\n          curbuf = buf + omp_get_thread_num() * bufsize;\n          k = 0;\n          for(;;) {\n            #pragma omp critical(sssort_lock)\n            {\n              if(0 < (l = j)) {\n                d0 = c0, d1 = c1;\n                do {\n                  k = BUCKET_BSTAR(d0, d1);\n                  if(--d1 <= d0) {\n                    d1 = ALPHABET_SIZE - 1;\n                    if(--d0 < 0) { break; }\n                  }\n                } while(((l - k) <= 1) && (0 < (l = k)));\n                c0 = d0, c1 = d1, j = k;\n              }\n            }\n            if(l == 0) { break; }\n            sssort(T, PAb, SA + k, SA + l,\n                   curbuf, bufsize, 2, n, *(SA + k) == (m - 1));\n          }\n        }\n    }\n    else\n    {\n        buf = SA + m, bufsize = n - (2 * m);\n        for(c0 = ALPHABET_SIZE - 2, j = m; 0 < j; --c0) {\n          for(c1 = ALPHABET_SIZE - 1; c0 < c1; j = i, --c1) {\n            i = BUCKET_BSTAR(c0, c1);\n            if(1 < (j - i)) {\n              sssort(T, PAb, SA + i, SA + j,\n                     buf, bufsize, 2, n, *(SA + i) == (m - 1));\n            }\n          }\n        }\n    }\n#else\n    buf = SA + m, bufsize = n - (2 * m);\n    for(c0 = ALPHABET_SIZE - 2, j = m; 0 < j; --c0) {\n      for(c1 = ALPHABET_SIZE - 1; c0 < c1; j = i, --c1) {\n        i = BUCKET_BSTAR(c0, c1);\n        if(1 < (j - i)) {\n          sssort(T, PAb, SA + i, SA + j,\n                 buf, bufsize, 2, n, *(SA + i) == (m - 1));\n        }\n      }\n    }\n#endif\n\n    /* Compute ranks of type B* substrings. */\n    for(i = m - 1; 0 <= i; --i) {\n      if(0 <= SA[i]) {\n        j = i;\n        do { ISAb[SA[i]] = i; } while((0 <= --i) && (0 <= SA[i]));\n        SA[i + 1] = i - j;\n        if(i <= 0) { break; }\n      }\n      j = i;\n      do { ISAb[SA[i] = ~SA[i]] = j; } while(SA[--i] < 0);\n      ISAb[SA[i]] = j;\n    }\n\n    /* Construct the inverse suffix array of type B* suffixes using trsort. */\n    trsort(ISAb, SA, m, 1);\n\n    /* Set the sorted order of type B* suffixes. */\n    for(i = n - 1, j = m, c0 = T[n - 1]; 0 <= i;) {\n      for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) >= c1); --i, c1 = c0) { }\n      if(0 <= i) {\n        t = i;\n        for(--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0) { }\n        SA[ISAb[--j]] = ((t == 0) || (1 < (t - i))) ? t : ~t;\n      }\n    }\n\n    /* Calculate the index of start/end point of each bucket. */\n    BUCKET_B(ALPHABET_SIZE - 1, ALPHABET_SIZE - 1) = n; /* end point */\n    for(c0 = ALPHABET_SIZE - 2, k = m - 1; 0 <= c0; --c0) {\n      i = BUCKET_A(c0 + 1) - 1;\n      for(c1 = ALPHABET_SIZE - 1; c0 < c1; --c1) {\n        t = i - BUCKET_B(c0, c1);\n        BUCKET_B(c0, c1) = i; /* end point */\n\n        /* Move all type B* suffixes to the correct position. */\n        for(i = t, j = BUCKET_BSTAR(c0, c1);\n            j <= k;\n            --i, --k) { SA[i] = SA[k]; }\n      }\n      BUCKET_BSTAR(c0, c0 + 1) = i - BUCKET_B(c0, c0) + 1; /* start point */\n      BUCKET_B(c0, c0) = i; /* end point */\n    }\n  }\n\n  return m;\n}\n\n/* Constructs the suffix array by using the sorted order of type B* suffixes. */\nstatic\nvoid\nconstruct_SA(const unsigned char *T, int *SA,\n             int *bucket_A, int *bucket_B,\n             int n, int m) {\n  int *i, *j, *k;\n  int s;\n  int c0, c1, c2;\n\n  if(0 < m) {\n    /* Construct the sorted order of type B suffixes by using\n       the sorted order of type B* suffixes. */\n    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {\n      /* Scan the suffix array from right to left. */\n      for(i = SA + BUCKET_BSTAR(c1, c1 + 1),\n          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1;\n          i <= j;\n          --j) {\n        if(0 < (s = *j)) {\n          assert(T[s] == c1);\n          assert(((s + 1) < n) && (T[s] <= T[s + 1]));\n          assert(T[s - 1] <= T[s]);\n          *j = ~s;\n          c0 = T[--s];\n          if((0 < s) && (T[s - 1] > c0)) { s = ~s; }\n          if(c0 != c2) {\n            if(0 <= c2) { BUCKET_B(c2, c1) = PTRDIFF_TO_INT(k - SA); }\n            k = SA + BUCKET_B(c2 = c0, c1);\n          }\n          assert(k < j); assert(k != NULL);\n          *k-- = s;\n        } else {\n          assert(((s == 0) && (T[s] == c1)) || (s < 0));\n          *j = ~s;\n        }\n      }\n    }\n  }\n\n  /* Construct the suffix array by using\n     the sorted order of type B suffixes. */\n  k = SA + BUCKET_A(c2 = T[n - 1]);\n  *k++ = (T[n - 2] < c2) ? ~(n - 1) : (n - 1);\n  /* Scan the suffix array from left to right. */\n  for(i = SA, j = SA + n; i < j; ++i) {\n    if(0 < (s = *i)) {\n      assert(T[s - 1] >= T[s]);\n      c0 = T[--s];\n      if((s == 0) || (T[s - 1] < c0)) { s = ~s; }\n      if(c0 != c2) {\n        BUCKET_A(c2) = PTRDIFF_TO_INT(k - SA);\n        k = SA + BUCKET_A(c2 = c0);\n      }\n      assert(i < k);\n      *k++ = s;\n    } else {\n      assert(s < 0);\n      *i = ~s;\n    }\n  }\n}\n\n/* Constructs the burrows-wheeler transformed string directly\n   by using the sorted order of type B* suffixes. */\nstatic\nint\nconstruct_BWT(const unsigned char *T, int *SA,\n              int *bucket_A, int *bucket_B,\n              int n, int m) {\n  int *i, *j, *k, *orig;\n  int s;\n  int c0, c1, c2;\n\n  if(0 < m) {\n    /* Construct the sorted order of type B suffixes by using\n       the sorted order of type B* suffixes. */\n    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {\n      /* Scan the suffix array from right to left. */\n      for(i = SA + BUCKET_BSTAR(c1, c1 + 1),\n          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1;\n          i <= j;\n          --j) {\n        if(0 < (s = *j)) {\n          assert(T[s] == c1);\n          assert(((s + 1) < n) && (T[s] <= T[s + 1]));\n          assert(T[s - 1] <= T[s]);\n          c0 = T[--s];\n          *j = ~((int)c0);\n          if((0 < s) && (T[s - 1] > c0)) { s = ~s; }\n          if(c0 != c2) {\n            if(0 <= c2) { BUCKET_B(c2, c1) = PTRDIFF_TO_INT(k - SA); }\n            k = SA + BUCKET_B(c2 = c0, c1);\n          }\n          assert(k < j); assert(k != NULL);\n          *k-- = s;\n        } else if(s != 0) {\n          *j = ~s;\n#ifndef NDEBUG\n        } else {\n          assert(T[s] == c1);\n#endif\n        }\n      }\n    }\n  }\n\n  /* Construct the BWTed string by using\n     the sorted order of type B suffixes. */\n  k = SA + BUCKET_A(c2 = T[n - 1]);\n  *k++ = (T[n - 2] < c2) ? ~((int)T[n - 2]) : (n - 1);\n  /* Scan the suffix array from left to right. */\n  for(i = SA, j = SA + n, orig = SA; i < j; ++i) {\n    if(0 < (s = *i)) {\n      assert(T[s - 1] >= T[s]);\n      c0 = T[--s];\n      *i = c0;\n      if((0 < s) && (T[s - 1] < c0)) { s = ~((int)T[s - 1]); }\n      if(c0 != c2) {\n        BUCKET_A(c2) = PTRDIFF_TO_INT(k - SA);\n        k = SA + BUCKET_A(c2 = c0);\n      }\n      assert(i < k);\n      *k++ = s;\n    } else if(s != 0) {\n      *i = ~s;\n    } else {\n      orig = i;\n    }\n  }\n\n  return PTRDIFF_TO_INT(orig - SA);\n}\n\n/* Constructs the burrows-wheeler transformed string directly\n   by using the sorted order of type B* suffixes. */\nstatic\nint\nconstruct_BWT_indexes(const unsigned char *T, int *SA,\n                      int *bucket_A, int *bucket_B,\n                      int n, int m,\n                      unsigned char * num_indexes, int * indexes) {\n  int *i, *j, *k, *orig;\n  int s;\n  int c0, c1, c2;\n\n  int mod = n / 8;\n  {\n      mod |= mod >> 1;  mod |= mod >> 2;\n      mod |= mod >> 4;  mod |= mod >> 8;\n      mod |= mod >> 16; mod >>= 1;\n\n      *num_indexes = (unsigned char)((n - 1) / (mod + 1));\n  }\n\n  if(0 < m) {\n    /* Construct the sorted order of type B suffixes by using\n       the sorted order of type B* suffixes. */\n    for(c1 = ALPHABET_SIZE - 2; 0 <= c1; --c1) {\n      /* Scan the suffix array from right to left. */\n      for(i = SA + BUCKET_BSTAR(c1, c1 + 1),\n          j = SA + BUCKET_A(c1 + 1) - 1, k = NULL, c2 = -1;\n          i <= j;\n          --j) {\n        if(0 < (s = *j)) {\n          assert(T[s] == c1);\n          assert(((s + 1) < n) && (T[s] <= T[s + 1]));\n          assert(T[s - 1] <= T[s]);\n\n          if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = PTRDIFF_TO_INT(j - SA);\n\n          c0 = T[--s];\n          *j = ~((int)c0);\n          if((0 < s) && (T[s - 1] > c0)) { s = ~s; }\n          if(c0 != c2) {\n            if(0 <= c2) { BUCKET_B(c2, c1) = PTRDIFF_TO_INT(k - SA); }\n            k = SA + BUCKET_B(c2 = c0, c1);\n          }\n          assert(k < j); assert(k != NULL);\n          *k-- = s;\n        } else if(s != 0) {\n          *j = ~s;\n#ifndef NDEBUG\n        } else {\n          assert(T[s] == c1);\n#endif\n        }\n      }\n    }\n  }\n\n  /* Construct the BWTed string by using\n     the sorted order of type B suffixes. */\n  k = SA + BUCKET_A(c2 = T[n - 1]);\n  if (T[n - 2] < c2) {\n    if (((n - 1) & mod) == 0) indexes[(n - 1) / (mod + 1) - 1] = PTRDIFF_TO_INT(k - SA);\n    *k++ = ~((int)T[n - 2]);\n  }\n  else {\n    *k++ = n - 1;\n  }\n\n  /* Scan the suffix array from left to right. */\n  for(i = SA, j = SA + n, orig = SA; i < j; ++i) {\n    if(0 < (s = *i)) {\n      assert(T[s - 1] >= T[s]);\n\n      if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = PTRDIFF_TO_INT(i - SA);\n\n      c0 = T[--s];\n      *i = c0;\n      if(c0 != c2) {\n        BUCKET_A(c2) = PTRDIFF_TO_INT(k - SA);\n        k = SA + BUCKET_A(c2 = c0);\n      }\n      assert(i < k);\n      if((0 < s) && (T[s - 1] < c0)) {\n          if ((s & mod) == 0) indexes[s / (mod + 1) - 1] = PTRDIFF_TO_INT(k - SA);\n          *k++ = ~((int)T[s - 1]);\n      } else\n        *k++ = s;\n    } else if(s != 0) {\n      *i = ~s;\n    } else {\n      orig = i;\n    }\n  }\n\n  return PTRDIFF_TO_INT(orig - SA);\n}\n\n\n/*---------------------------------------------------------------------------*/\n\n/*- Function -*/\n\nint\ndivsufsort(const unsigned char *T, int *SA, int n, int openMP) {\n  int *bucket_A, *bucket_B;\n  int m;\n  int err = 0;\n\n  /* Check arguments. */\n  if((T == NULL) || (SA == NULL) || (n < 0)) { return -1; }\n  else if(n == 0) { return 0; }\n  else if(n == 1) { SA[0] = 0; return 0; }\n  else if(n == 2) { m = (T[0] < T[1]); SA[m ^ 1] = 0, SA[m] = 1; return 0; }\n\n  bucket_A = (int *)malloc(BUCKET_A_SIZE * sizeof(int));\n  bucket_B = (int *)malloc(BUCKET_B_SIZE * sizeof(int));\n\n  /* Suffixsort. */\n  if((bucket_A != NULL) && (bucket_B != NULL)) {\n    m = sort_typeBstar(T, SA, bucket_A, bucket_B, n, openMP);\n    construct_SA(T, SA, bucket_A, bucket_B, n, m);\n  } else {\n    err = -2;\n  }\n\n  free(bucket_B);\n  free(bucket_A);\n\n  return err;\n}\n\nint\ndivbwt(const unsigned char *T, unsigned char *U, int *A, int n, unsigned char * num_indexes, int * indexes, int openMP) {\n  int *B;\n  int *bucket_A, *bucket_B;\n  int m, pidx, i;\n\n  /* Check arguments. */\n  if((T == NULL) || (U == NULL) || (n < 0)) { return -1; }\n  else if(n <= 1) { if(n == 1) { U[0] = T[0]; } return n; }\n\n  if((B = A) == NULL) { B = (int *)malloc((size_t)(n + 1) * sizeof(int)); }\n  bucket_A = (int *)malloc(BUCKET_A_SIZE * sizeof(int));\n  bucket_B = (int *)malloc(BUCKET_B_SIZE * sizeof(int));\n\n  /* Burrows-Wheeler Transform. */\n  if((B != NULL) && (bucket_A != NULL) && (bucket_B != NULL)) {\n    m = sort_typeBstar(T, B, bucket_A, bucket_B, n, openMP);\n\n    if (num_indexes == NULL || indexes == NULL) {\n        pidx = construct_BWT(T, B, bucket_A, bucket_B, n, m);\n    } else {\n        pidx = construct_BWT_indexes(T, B, bucket_A, bucket_B, n, m, num_indexes, indexes);\n    }\n\n    /* Copy to output string. */\n    U[0] = T[n - 1];\n    for(i = 0; i < pidx; ++i) { U[i + 1] = (unsigned char)B[i]; }\n    for(i += 1; i < n; ++i) { U[i] = (unsigned char)B[i]; }\n    pidx += 1;\n  } else {\n    pidx = -2;\n  }\n\n  free(bucket_B);\n  free(bucket_A);\n  if(A == NULL) { free(B); }\n\n  return pidx;\n}\n"
  },
  {
    "path": "lib/dictBuilder/divsufsort.h",
    "content": "/*\n * divsufsort.h for libdivsufsort-lite\n * Copyright (c) 2003-2008 Yuta Mori All Rights Reserved.\n *\n * Permission is hereby granted, free of charge, to any person\n * obtaining a copy of this software and associated documentation\n * files (the \"Software\"), to deal in the Software without\n * restriction, including without limitation the rights to use,\n * copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the\n * Software is furnished to do so, subject to the following\n * conditions:\n *\n * The above copyright notice and this permission notice shall be\n * included in all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n * OTHER DEALINGS IN THE SOFTWARE.\n */\n\n#ifndef _DIVSUFSORT_H\n#define _DIVSUFSORT_H 1\n\n/*- Prototypes -*/\n\n/**\n * Constructs the suffix array of a given string.\n * @param T [0..n-1] The input string.\n * @param SA [0..n-1] The output array of suffixes.\n * @param n The length of the given string.\n * @param openMP enables OpenMP optimization.\n * @return 0 if no error occurred, -1 or -2 otherwise.\n */\nint\ndivsufsort(const unsigned char *T, int *SA, int n, int openMP);\n\n/**\n * Constructs the burrows-wheeler transformed string of a given string.\n * @param T [0..n-1] The input string.\n * @param U [0..n-1] The output string. (can be T)\n * @param A [0..n-1] The temporary array. (can be NULL)\n * @param n The length of the given string.\n * @param num_indexes The length of secondary indexes array. (can be NULL)\n * @param indexes The secondary indexes array. (can be NULL)\n * @param openMP enables OpenMP optimization.\n * @return The primary index if no error occurred, -1 or -2 otherwise.\n */\nint\ndivbwt(const unsigned char *T, unsigned char *U, int *A, int n, unsigned char * num_indexes, int * indexes, int openMP);\n\n#endif /* _DIVSUFSORT_H */\n"
  },
  {
    "path": "lib/dictBuilder/fastcover.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n/*-*************************************\n*  Dependencies\n***************************************/\n#include   /* fprintf */\n#include  /* malloc, free, qsort */\n#include  /* memset */\n#include    /* clock */\n\n#ifndef ZDICT_STATIC_LINKING_ONLY\n#  define ZDICT_STATIC_LINKING_ONLY\n#endif\n\n#include \"../common/mem.h\" /* read */\n#include \"../common/pool.h\"\n#include \"../common/threading.h\"\n#include \"../common/zstd_internal.h\" /* includes zstd.h */\n#include \"../compress/zstd_compress_internal.h\" /* ZSTD_hash*() */\n#include \"../zdict.h\"\n#include \"cover.h\"\n\n\n/*-*************************************\n*  Constants\n***************************************/\n/**\n* There are 32bit indexes used to ref samples, so limit samples size to 4GB\n* on 64bit builds.\n* For 32bit builds we choose 1 GB.\n* Most 32bit platforms have 2GB user-mode addressable space and we allocate a large\n* contiguous buffer, so 1GB is already a high limit.\n*/\n#define FASTCOVER_MAX_SAMPLES_SIZE (sizeof(size_t) == 8 ? ((unsigned)-1) : ((unsigned)1 GB))\n#define FASTCOVER_MAX_F 31\n#define FASTCOVER_MAX_ACCEL 10\n#define FASTCOVER_DEFAULT_SPLITPOINT 0.75\n#define DEFAULT_F 20\n#define DEFAULT_ACCEL 1\n\n\n/*-*************************************\n*  Console display\n*\n* Captures the `displayLevel` variable in the local scope.\n***************************************/\n#undef  DISPLAY\n#define DISPLAY(...)                                                           \\\n  {                                                                            \\\n    fprintf(stderr, __VA_ARGS__);                                              \\\n    fflush(stderr);                                                            \\\n  }\n#undef  DISPLAYLEVEL\n#define DISPLAYLEVEL(l, ...)                                                   \\\n  if (displayLevel >= l) {                                                     \\\n    DISPLAY(__VA_ARGS__);                                                      \\\n  } /* 0 : no display;   1: errors;   2: default;  3: details;  4: debug */\n\n#undef  DISPLAYUPDATE\n#define DISPLAYUPDATE(lastUpdateTime, l, ...)                                  \\\n  if (displayLevel >= l) {                                                     \\\n    const clock_t refreshRate = CLOCKS_PER_SEC * 15 / 100;                     \\\n    if ((clock() - lastUpdateTime > refreshRate) || (displayLevel >= 4)) {     \\\n      lastUpdateTime = clock();                                                \\\n      DISPLAY(__VA_ARGS__);                                                    \\\n    }                                                                          \\\n  }\n\n\n/*-*************************************\n* Hash Functions\n***************************************/\n/**\n * Hash the d-byte value pointed to by p and mod 2^f into the frequency vector\n */\nstatic size_t FASTCOVER_hashPtrToIndex(const void* p, U32 f, unsigned d) {\n  if (d == 6) {\n    return ZSTD_hash6Ptr(p, f);\n  }\n  return ZSTD_hash8Ptr(p, f);\n}\n\n\n/*-*************************************\n* Acceleration\n***************************************/\ntypedef struct {\n  unsigned finalize;    /* Percentage of training samples used for ZDICT_finalizeDictionary */\n  unsigned skip;        /* Number of dmer skipped between each dmer counted in computeFrequency */\n} FASTCOVER_accel_t;\n\n\nstatic const FASTCOVER_accel_t FASTCOVER_defaultAccelParameters[FASTCOVER_MAX_ACCEL+1] = {\n  { 100, 0 },   /* accel = 0, should not happen because accel = 0 defaults to accel = 1 */\n  { 100, 0 },   /* accel = 1 */\n  { 50, 1 },   /* accel = 2 */\n  { 34, 2 },   /* accel = 3 */\n  { 25, 3 },   /* accel = 4 */\n  { 20, 4 },   /* accel = 5 */\n  { 17, 5 },   /* accel = 6 */\n  { 14, 6 },   /* accel = 7 */\n  { 13, 7 },   /* accel = 8 */\n  { 11, 8 },   /* accel = 9 */\n  { 10, 9 },   /* accel = 10 */\n};\n\n\n/*-*************************************\n* Context\n***************************************/\ntypedef struct {\n  const BYTE *samples;\n  size_t *offsets;\n  const size_t *samplesSizes;\n  size_t nbSamples;\n  size_t nbTrainSamples;\n  size_t nbTestSamples;\n  size_t nbDmers;\n  U32 *freqs;\n  unsigned d;\n  unsigned f;\n  FASTCOVER_accel_t accelParams;\n  int displayLevel;\n} FASTCOVER_ctx_t;\n\n\n/*-*************************************\n*  Helper functions\n***************************************/\n/**\n * Selects the best segment in an epoch.\n * Segments of are scored according to the function:\n *\n * Let F(d) be the frequency of all dmers with hash value d.\n * Let S_i be hash value of the dmer at position i of segment S which has length k.\n *\n *     Score(S) = F(S_1) + F(S_2) + ... + F(S_{k-d+1})\n *\n * Once the dmer with hash value d is in the dictionary we set F(d) = 0.\n */\nstatic COVER_segment_t FASTCOVER_selectSegment(const FASTCOVER_ctx_t *ctx,\n                                              U32 *freqs, U32 begin, U32 end,\n                                              ZDICT_cover_params_t parameters,\n                                              U16* segmentFreqs) {\n  /* Constants */\n  const U32 k = parameters.k;\n  const U32 d = parameters.d;\n  const U32 f = ctx->f;\n  const U32 dmersInK = k - d + 1;\n\n  /* Try each segment (activeSegment) and save the best (bestSegment) */\n  COVER_segment_t bestSegment = {0, 0, 0};\n  COVER_segment_t activeSegment;\n\n  /* Reset the activeDmers in the segment */\n  /* The activeSegment starts at the beginning of the epoch. */\n  activeSegment.begin = begin;\n  activeSegment.end = begin;\n  activeSegment.score = 0;\n\n  /* Slide the activeSegment through the whole epoch.\n   * Save the best segment in bestSegment.\n   */\n  while (activeSegment.end < end) {\n    /* Get hash value of current dmer */\n    const size_t idx = FASTCOVER_hashPtrToIndex(ctx->samples + activeSegment.end, f, d);\n\n    /* Add frequency of this index to score if this is the first occurrence of index in active segment */\n    if (segmentFreqs[idx] == 0) {\n      activeSegment.score += freqs[idx];\n    }\n    /* Increment end of segment and segmentFreqs*/\n    activeSegment.end += 1;\n    segmentFreqs[idx] += 1;\n    /* If the window is now too large, drop the first position */\n    if (activeSegment.end - activeSegment.begin == dmersInK + 1) {\n      /* Get hash value of the dmer to be eliminated from active segment */\n      const size_t delIndex = FASTCOVER_hashPtrToIndex(ctx->samples + activeSegment.begin, f, d);\n      segmentFreqs[delIndex] -= 1;\n      /* Subtract frequency of this index from score if this is the last occurrence of this index in active segment */\n      if (segmentFreqs[delIndex] == 0) {\n        activeSegment.score -= freqs[delIndex];\n      }\n      /* Increment start of segment */\n      activeSegment.begin += 1;\n    }\n\n    /* If this segment is the best so far save it */\n    if (activeSegment.score > bestSegment.score) {\n      bestSegment = activeSegment;\n    }\n  }\n\n  /* Zero out rest of segmentFreqs array */\n  while (activeSegment.begin < end) {\n    const size_t delIndex = FASTCOVER_hashPtrToIndex(ctx->samples + activeSegment.begin, f, d);\n    segmentFreqs[delIndex] -= 1;\n    activeSegment.begin += 1;\n  }\n\n  {\n    /*  Zero the frequency of hash value of each dmer covered by the chosen segment. */\n    U32 pos;\n    for (pos = bestSegment.begin; pos != bestSegment.end; ++pos) {\n      const size_t i = FASTCOVER_hashPtrToIndex(ctx->samples + pos, f, d);\n      freqs[i] = 0;\n    }\n  }\n\n  return bestSegment;\n}\n\n\nstatic int FASTCOVER_checkParameters(ZDICT_cover_params_t parameters,\n                                     size_t maxDictSize, unsigned f,\n                                     unsigned accel) {\n  /* k, d, and f are required parameters */\n  if (parameters.d == 0 || parameters.k == 0) {\n    return 0;\n  }\n  /* d has to be 6 or 8 */\n  if (parameters.d != 6 && parameters.d != 8) {\n    return 0;\n  }\n  /* k <= maxDictSize */\n  if (parameters.k > maxDictSize) {\n    return 0;\n  }\n  /* d <= k */\n  if (parameters.d > parameters.k) {\n    return 0;\n  }\n  /* 0 < f <= FASTCOVER_MAX_F*/\n  if (f > FASTCOVER_MAX_F || f == 0) {\n    return 0;\n  }\n  /* 0 < splitPoint <= 1 */\n  if (parameters.splitPoint <= 0 || parameters.splitPoint > 1) {\n    return 0;\n  }\n  /* 0 < accel <= 10 */\n  if (accel > 10 || accel == 0) {\n    return 0;\n  }\n  return 1;\n}\n\n\n/**\n * Clean up a context initialized with `FASTCOVER_ctx_init()`.\n */\nstatic void\nFASTCOVER_ctx_destroy(FASTCOVER_ctx_t* ctx)\n{\n    if (!ctx) return;\n\n    free(ctx->freqs);\n    ctx->freqs = NULL;\n\n    free(ctx->offsets);\n    ctx->offsets = NULL;\n}\n\n\n/**\n * Calculate for frequency of hash value of each dmer in ctx->samples\n */\nstatic void\nFASTCOVER_computeFrequency(U32* freqs, const FASTCOVER_ctx_t* ctx)\n{\n    const unsigned f = ctx->f;\n    const unsigned d = ctx->d;\n    const unsigned skip = ctx->accelParams.skip;\n    const unsigned readLength = MAX(d, 8);\n    size_t i;\n    assert(ctx->nbTrainSamples >= 5);\n    assert(ctx->nbTrainSamples <= ctx->nbSamples);\n    for (i = 0; i < ctx->nbTrainSamples; i++) {\n        size_t start = ctx->offsets[i];  /* start of current dmer */\n        size_t const currSampleEnd = ctx->offsets[i+1];\n        while (start + readLength <= currSampleEnd) {\n            const size_t dmerIndex = FASTCOVER_hashPtrToIndex(ctx->samples + start, f, d);\n            freqs[dmerIndex]++;\n            start = start + skip + 1;\n        }\n    }\n}\n\n\n/**\n * Prepare a context for dictionary building.\n * The context is only dependent on the parameter `d` and can be used multiple\n * times.\n * Returns 0 on success or error code on error.\n * The context must be destroyed with `FASTCOVER_ctx_destroy()`.\n */\nstatic size_t\nFASTCOVER_ctx_init(FASTCOVER_ctx_t* ctx,\n                   const void* samplesBuffer,\n                   const size_t* samplesSizes, unsigned nbSamples,\n                   unsigned d, double splitPoint, unsigned f,\n                   FASTCOVER_accel_t accelParams,\n                   int displayLevel)\n{\n    const BYTE* const samples = (const BYTE*)samplesBuffer;\n    const size_t totalSamplesSize = COVER_sum(samplesSizes, nbSamples);\n    /* Split samples into testing and training sets */\n    const unsigned nbTrainSamples = splitPoint < 1.0 ? (unsigned)((double)nbSamples * splitPoint) : nbSamples;\n    const unsigned nbTestSamples = splitPoint < 1.0 ? nbSamples - nbTrainSamples : nbSamples;\n    const size_t trainingSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes, nbTrainSamples) : totalSamplesSize;\n    const size_t testSamplesSize = splitPoint < 1.0 ? COVER_sum(samplesSizes + nbTrainSamples, nbTestSamples) : totalSamplesSize;\n    ctx->displayLevel = displayLevel;\n\n    /* Checks */\n    if (totalSamplesSize < MAX(d, sizeof(U64)) ||\n        totalSamplesSize >= (size_t)FASTCOVER_MAX_SAMPLES_SIZE) {\n        DISPLAYLEVEL(1, \"Total samples size is too large (%u MB), maximum size is %u MB\\n\",\n                    (unsigned)(totalSamplesSize >> 20), (FASTCOVER_MAX_SAMPLES_SIZE >> 20));\n        return ERROR(srcSize_wrong);\n    }\n\n    /* Check if there are at least 5 training samples */\n    if (nbTrainSamples < 5) {\n        DISPLAYLEVEL(1, \"Total number of training samples is %u and is invalid\\n\", nbTrainSamples);\n        return ERROR(srcSize_wrong);\n    }\n\n    /* Check if there's testing sample */\n    if (nbTestSamples < 1) {\n        DISPLAYLEVEL(1, \"Total number of testing samples is %u and is invalid.\\n\", nbTestSamples);\n        return ERROR(srcSize_wrong);\n    }\n\n    /* Zero the context */\n    memset(ctx, 0, sizeof(*ctx));\n    DISPLAYLEVEL(2, \"Training on %u samples of total size %u\\n\", nbTrainSamples,\n                    (unsigned)trainingSamplesSize);\n    DISPLAYLEVEL(2, \"Testing on %u samples of total size %u\\n\", nbTestSamples,\n                    (unsigned)testSamplesSize);\n\n    ctx->samples = samples;\n    ctx->samplesSizes = samplesSizes;\n    ctx->nbSamples = nbSamples;\n    ctx->nbTrainSamples = nbTrainSamples;\n    ctx->nbTestSamples = nbTestSamples;\n    ctx->nbDmers = trainingSamplesSize - MAX(d, sizeof(U64)) + 1;\n    ctx->d = d;\n    ctx->f = f;\n    ctx->accelParams = accelParams;\n\n    /* The offsets of each file */\n    ctx->offsets = (size_t*)calloc((nbSamples + 1), sizeof(size_t));\n    if (ctx->offsets == NULL) {\n        DISPLAYLEVEL(1, \"Failed to allocate scratch buffers \\n\");\n        FASTCOVER_ctx_destroy(ctx);\n        return ERROR(memory_allocation);\n    }\n\n    /* Fill offsets from the samplesSizes */\n    {   U32 i;\n        ctx->offsets[0] = 0;\n        assert(nbSamples >= 5);\n        for (i = 1; i <= nbSamples; ++i) {\n            ctx->offsets[i] = ctx->offsets[i - 1] + samplesSizes[i - 1];\n        }\n    }\n\n    /* Initialize frequency array of size 2^f */\n    ctx->freqs = (U32*)calloc(((U64)1 << f), sizeof(U32));\n    if (ctx->freqs == NULL) {\n        DISPLAYLEVEL(1, \"Failed to allocate frequency table \\n\");\n        FASTCOVER_ctx_destroy(ctx);\n        return ERROR(memory_allocation);\n    }\n\n    DISPLAYLEVEL(2, \"Computing frequencies\\n\");\n    FASTCOVER_computeFrequency(ctx->freqs, ctx);\n\n    return 0;\n}\n\n\n/**\n * Given the prepared context build the dictionary.\n */\nstatic size_t\nFASTCOVER_buildDictionary(const FASTCOVER_ctx_t* ctx,\n                          U32* freqs,\n                          void* dictBuffer, size_t dictBufferCapacity,\n                          ZDICT_cover_params_t parameters,\n                          U16* segmentFreqs)\n{\n  BYTE *const dict = (BYTE *)dictBuffer;\n  size_t tail = dictBufferCapacity;\n  /* Divide the data into epochs. We will select one segment from each epoch. */\n  const COVER_epoch_info_t epochs = COVER_computeEpochs(\n      (U32)dictBufferCapacity, (U32)ctx->nbDmers, parameters.k, 1);\n  const size_t maxZeroScoreRun = 10;\n  const int displayLevel = ctx->displayLevel;\n  size_t zeroScoreRun = 0;\n  clock_t lastUpdateTime = 0;\n  size_t epoch;\n  DISPLAYLEVEL(2, \"Breaking content into %u epochs of size %u\\n\",\n                (U32)epochs.num, (U32)epochs.size);\n  /* Loop through the epochs until there are no more segments or the dictionary\n   * is full.\n   */\n  for (epoch = 0; tail > 0; epoch = (epoch + 1) % epochs.num) {\n    const U32 epochBegin = (U32)(epoch * epochs.size);\n    const U32 epochEnd = epochBegin + epochs.size;\n    size_t segmentSize;\n    /* Select a segment */\n    COVER_segment_t segment = FASTCOVER_selectSegment(\n        ctx, freqs, epochBegin, epochEnd, parameters, segmentFreqs);\n\n    /* If the segment covers no dmers, then we are out of content.\n     * There may be new content in other epochs, for continue for some time.\n     */\n    if (segment.score == 0) {\n      if (++zeroScoreRun >= maxZeroScoreRun) {\n          break;\n      }\n      continue;\n    }\n    zeroScoreRun = 0;\n\n    /* Trim the segment if necessary and if it is too small then we are done */\n    segmentSize = MIN(segment.end - segment.begin + parameters.d - 1, tail);\n    if (segmentSize < parameters.d) {\n      break;\n    }\n\n    /* We fill the dictionary from the back to allow the best segments to be\n     * referenced with the smallest offsets.\n     */\n    tail -= segmentSize;\n    memcpy(dict + tail, ctx->samples + segment.begin, segmentSize);\n    DISPLAYUPDATE(\n        lastUpdateTime,\n        2, \"\\r%u%%       \",\n        (unsigned)(((dictBufferCapacity - tail) * 100) / dictBufferCapacity));\n  }\n  DISPLAYLEVEL(2, \"\\r%79s\\r\", \"\");\n  return tail;\n}\n\n/**\n * Parameters for FASTCOVER_tryParameters().\n */\ntypedef struct FASTCOVER_tryParameters_data_s {\n    const FASTCOVER_ctx_t* ctx;\n    COVER_best_t* best;\n    size_t dictBufferCapacity;\n    ZDICT_cover_params_t parameters;\n} FASTCOVER_tryParameters_data_t;\n\n\n/**\n * Tries a set of parameters and updates the COVER_best_t with the results.\n * This function is thread safe if zstd is compiled with multithreaded support.\n * It takes its parameters as an *OWNING* opaque pointer to support threading.\n */\nstatic void FASTCOVER_tryParameters(void* opaque)\n{\n  /* Save parameters as local variables */\n  FASTCOVER_tryParameters_data_t *const data = (FASTCOVER_tryParameters_data_t*)opaque;\n  const FASTCOVER_ctx_t *const ctx = data->ctx;\n  const ZDICT_cover_params_t parameters = data->parameters;\n  size_t dictBufferCapacity = data->dictBufferCapacity;\n  size_t totalCompressedSize = ERROR(GENERIC);\n  /* Initialize array to keep track of frequency of dmer within activeSegment */\n  U16* segmentFreqs = (U16*)calloc(((U64)1 << ctx->f), sizeof(U16));\n  /* Allocate space for hash table, dict, and freqs */\n  BYTE *const dict = (BYTE*)malloc(dictBufferCapacity);\n  COVER_dictSelection_t selection = COVER_dictSelectionError(ERROR(GENERIC));\n  U32* freqs = (U32*) malloc(((U64)1 << ctx->f) * sizeof(U32));\n  const int displayLevel = ctx->displayLevel;\n  if (!segmentFreqs || !dict || !freqs) {\n    DISPLAYLEVEL(1, \"Failed to allocate buffers: out of memory\\n\");\n    goto _cleanup;\n  }\n  /* Copy the frequencies because we need to modify them */\n  memcpy(freqs, ctx->freqs, ((U64)1 << ctx->f) * sizeof(U32));\n  /* Build the dictionary */\n  { const size_t tail = FASTCOVER_buildDictionary(ctx, freqs, dict, dictBufferCapacity,\n                                                    parameters, segmentFreqs);\n\n    const unsigned nbFinalizeSamples = (unsigned)(ctx->nbTrainSamples * ctx->accelParams.finalize / 100);\n    selection = COVER_selectDict(dict + tail, dictBufferCapacity, dictBufferCapacity - tail,\n         ctx->samples, ctx->samplesSizes, nbFinalizeSamples, ctx->nbTrainSamples, ctx->nbSamples, parameters, ctx->offsets,\n         totalCompressedSize);\n\n    if (COVER_dictSelectionIsError(selection)) {\n      DISPLAYLEVEL(1, \"Failed to select dictionary\\n\");\n      goto _cleanup;\n    }\n  }\n_cleanup:\n  free(dict);\n  COVER_best_finish(data->best, parameters, selection);\n  free(data);\n  free(segmentFreqs);\n  COVER_dictSelectionFree(selection);\n  free(freqs);\n}\n\n\nstatic void\nFASTCOVER_convertToCoverParams(ZDICT_fastCover_params_t fastCoverParams,\n                               ZDICT_cover_params_t* coverParams)\n{\n    coverParams->k = fastCoverParams.k;\n    coverParams->d = fastCoverParams.d;\n    coverParams->steps = fastCoverParams.steps;\n    coverParams->nbThreads = fastCoverParams.nbThreads;\n    coverParams->splitPoint = fastCoverParams.splitPoint;\n    coverParams->zParams = fastCoverParams.zParams;\n    coverParams->shrinkDict = fastCoverParams.shrinkDict;\n}\n\n\nstatic void\nFASTCOVER_convertToFastCoverParams(ZDICT_cover_params_t coverParams,\n                                   ZDICT_fastCover_params_t* fastCoverParams,\n                                   unsigned f, unsigned accel)\n{\n    fastCoverParams->k = coverParams.k;\n    fastCoverParams->d = coverParams.d;\n    fastCoverParams->steps = coverParams.steps;\n    fastCoverParams->nbThreads = coverParams.nbThreads;\n    fastCoverParams->splitPoint = coverParams.splitPoint;\n    fastCoverParams->f = f;\n    fastCoverParams->accel = accel;\n    fastCoverParams->zParams = coverParams.zParams;\n    fastCoverParams->shrinkDict = coverParams.shrinkDict;\n}\n\n\nZDICTLIB_STATIC_API size_t\nZDICT_trainFromBuffer_fastCover(void* dictBuffer, size_t dictBufferCapacity,\n                                const void* samplesBuffer,\n                                const size_t* samplesSizes, unsigned nbSamples,\n                                ZDICT_fastCover_params_t parameters)\n{\n    BYTE* const dict = (BYTE*)dictBuffer;\n    FASTCOVER_ctx_t ctx;\n    ZDICT_cover_params_t coverParams;\n    FASTCOVER_accel_t accelParams;\n    const int displayLevel = (int)parameters.zParams.notificationLevel;\n    /* Assign splitPoint and f if not provided */\n    parameters.splitPoint = 1.0;\n    parameters.f = parameters.f == 0 ? DEFAULT_F : parameters.f;\n    parameters.accel = parameters.accel == 0 ? DEFAULT_ACCEL : parameters.accel;\n    /* Convert to cover parameter */\n    memset(&coverParams, 0 , sizeof(coverParams));\n    FASTCOVER_convertToCoverParams(parameters, &coverParams);\n    /* Checks */\n    if (!FASTCOVER_checkParameters(coverParams, dictBufferCapacity, parameters.f,\n                                   parameters.accel)) {\n      DISPLAYLEVEL(1, \"FASTCOVER parameters incorrect\\n\");\n      return ERROR(parameter_outOfBound);\n    }\n    if (nbSamples == 0) {\n      DISPLAYLEVEL(1, \"FASTCOVER must have at least one input file\\n\");\n      return ERROR(srcSize_wrong);\n    }\n    if (dictBufferCapacity < ZDICT_DICTSIZE_MIN) {\n      DISPLAYLEVEL(1, \"dictBufferCapacity must be at least %u\\n\",\n                   ZDICT_DICTSIZE_MIN);\n      return ERROR(dstSize_tooSmall);\n    }\n    /* Assign corresponding FASTCOVER_accel_t to accelParams*/\n    accelParams = FASTCOVER_defaultAccelParameters[parameters.accel];\n    /* Initialize context */\n    {\n      size_t const initVal = FASTCOVER_ctx_init(&ctx, samplesBuffer, samplesSizes, nbSamples,\n                            coverParams.d, parameters.splitPoint, parameters.f,\n                            accelParams, displayLevel);\n      if (ZSTD_isError(initVal)) {\n        DISPLAYLEVEL(1, \"Failed to initialize context\\n\");\n        return initVal;\n      }\n    }\n    COVER_warnOnSmallCorpus(dictBufferCapacity, ctx.nbDmers, displayLevel);\n    /* Build the dictionary */\n    DISPLAYLEVEL(2, \"Building dictionary\\n\");\n    {\n      /* Initialize array to keep track of frequency of dmer within activeSegment */\n      U16* segmentFreqs = (U16 *)calloc(((U64)1 << parameters.f), sizeof(U16));\n      const size_t tail = FASTCOVER_buildDictionary(&ctx, ctx.freqs, dictBuffer,\n                                                dictBufferCapacity, coverParams, segmentFreqs);\n      const unsigned nbFinalizeSamples = (unsigned)(ctx.nbTrainSamples * ctx.accelParams.finalize / 100);\n      const size_t dictionarySize = ZDICT_finalizeDictionary(\n          dict, dictBufferCapacity, dict + tail, dictBufferCapacity - tail,\n          samplesBuffer, samplesSizes, nbFinalizeSamples, coverParams.zParams);\n      if (!ZSTD_isError(dictionarySize)) {\n          DISPLAYLEVEL(2, \"Constructed dictionary of size %u\\n\",\n                      (unsigned)dictionarySize);\n      }\n      FASTCOVER_ctx_destroy(&ctx);\n      free(segmentFreqs);\n      return dictionarySize;\n    }\n}\n\n\nZDICTLIB_STATIC_API size_t\nZDICT_optimizeTrainFromBuffer_fastCover(\n                    void* dictBuffer, size_t dictBufferCapacity,\n                    const void* samplesBuffer,\n                    const size_t* samplesSizes, unsigned nbSamples,\n                    ZDICT_fastCover_params_t* parameters)\n{\n    ZDICT_cover_params_t coverParams;\n    FASTCOVER_accel_t accelParams;\n    /* constants */\n    const unsigned nbThreads = parameters->nbThreads;\n    const double splitPoint =\n        parameters->splitPoint <= 0.0 ? FASTCOVER_DEFAULT_SPLITPOINT : parameters->splitPoint;\n    const unsigned kMinD = parameters->d == 0 ? 6 : parameters->d;\n    const unsigned kMaxD = parameters->d == 0 ? 8 : parameters->d;\n    const unsigned kMinK = parameters->k == 0 ? 50 : parameters->k;\n    const unsigned kMaxK = parameters->k == 0 ? 2000 : parameters->k;\n    const unsigned kSteps = parameters->steps == 0 ? 40 : parameters->steps;\n    const unsigned kStepSize = MAX((kMaxK - kMinK) / kSteps, 1);\n    const unsigned kIterations =\n        (1 + (kMaxD - kMinD) / 2) * (1 + (kMaxK - kMinK) / kStepSize);\n    const unsigned f = parameters->f == 0 ? DEFAULT_F : parameters->f;\n    const unsigned accel = parameters->accel == 0 ? DEFAULT_ACCEL : parameters->accel;\n    const unsigned shrinkDict = 0;\n    /* Local variables */\n    const int displayLevel = (int)parameters->zParams.notificationLevel;\n    unsigned iteration = 1;\n    unsigned d;\n    unsigned k;\n    COVER_best_t best;\n    POOL_ctx *pool = NULL;\n    int warned = 0;\n    clock_t lastUpdateTime = 0;\n    /* Checks */\n    if (splitPoint <= 0 || splitPoint > 1) {\n      DISPLAYLEVEL(1, \"Incorrect splitPoint\\n\");\n      return ERROR(parameter_outOfBound);\n    }\n    if (accel == 0 || accel > FASTCOVER_MAX_ACCEL) {\n      DISPLAYLEVEL(1, \"Incorrect accel\\n\");\n      return ERROR(parameter_outOfBound);\n    }\n    if (kMinK < kMaxD || kMaxK < kMinK) {\n      DISPLAYLEVEL(1, \"Incorrect k\\n\");\n      return ERROR(parameter_outOfBound);\n    }\n    if (nbSamples == 0) {\n      DISPLAYLEVEL(1, \"FASTCOVER must have at least one input file\\n\");\n      return ERROR(srcSize_wrong);\n    }\n    if (dictBufferCapacity < ZDICT_DICTSIZE_MIN) {\n      DISPLAYLEVEL(1, \"dictBufferCapacity must be at least %u\\n\",\n                   ZDICT_DICTSIZE_MIN);\n      return ERROR(dstSize_tooSmall);\n    }\n    if (nbThreads > 1) {\n      pool = POOL_create(nbThreads, 1);\n      if (!pool) {\n        return ERROR(memory_allocation);\n      }\n    }\n    /* Initialization */\n    COVER_best_init(&best);\n    memset(&coverParams, 0 , sizeof(coverParams));\n    FASTCOVER_convertToCoverParams(*parameters, &coverParams);\n    accelParams = FASTCOVER_defaultAccelParameters[accel];\n    /* Loop through d first because each new value needs a new context */\n    DISPLAYLEVEL(2, \"Trying %u different sets of parameters\\n\", kIterations);\n    for (d = kMinD; d <= kMaxD; d += 2) {\n      /* Initialize the context for this value of d */\n      FASTCOVER_ctx_t ctx;\n      DISPLAYLEVEL(3, \"d=%u\\n\", d);\n      {\n        /* Turn down global display level to clean up display at level 2 and below */\n        const int childDisplayLevel = displayLevel == 0 ? 0 : displayLevel - 1;\n        size_t const initVal = FASTCOVER_ctx_init(&ctx, samplesBuffer, samplesSizes, nbSamples, d, splitPoint, f, accelParams, childDisplayLevel);\n        if (ZSTD_isError(initVal)) {\n          DISPLAYLEVEL(1, \"Failed to initialize context\\n\");\n          COVER_best_destroy(&best);\n          POOL_free(pool);\n          return initVal;\n        }\n      }\n      if (!warned) {\n        COVER_warnOnSmallCorpus(dictBufferCapacity, ctx.nbDmers, displayLevel);\n        warned = 1;\n      }\n      /* Loop through k reusing the same context */\n      for (k = kMinK; k <= kMaxK; k += kStepSize) {\n        /* Prepare the arguments */\n        FASTCOVER_tryParameters_data_t *data = (FASTCOVER_tryParameters_data_t *)malloc(\n            sizeof(FASTCOVER_tryParameters_data_t));\n        DISPLAYLEVEL(3, \"k=%u\\n\", k);\n        if (!data) {\n          DISPLAYLEVEL(1, \"Failed to allocate parameters\\n\");\n          COVER_best_destroy(&best);\n          FASTCOVER_ctx_destroy(&ctx);\n          POOL_free(pool);\n          return ERROR(memory_allocation);\n        }\n        data->ctx = &ctx;\n        data->best = &best;\n        data->dictBufferCapacity = dictBufferCapacity;\n        data->parameters = coverParams;\n        data->parameters.k = k;\n        data->parameters.d = d;\n        data->parameters.splitPoint = splitPoint;\n        data->parameters.steps = kSteps;\n        data->parameters.shrinkDict = shrinkDict;\n        data->parameters.zParams.notificationLevel = (unsigned)ctx.displayLevel;\n        /* Check the parameters */\n        if (!FASTCOVER_checkParameters(data->parameters, dictBufferCapacity,\n                                       data->ctx->f, accel)) {\n          DISPLAYLEVEL(1, \"FASTCOVER parameters incorrect\\n\");\n          free(data);\n          continue;\n        }\n        /* Call the function and pass ownership of data to it */\n        COVER_best_start(&best);\n        if (pool) {\n          POOL_add(pool, &FASTCOVER_tryParameters, data);\n        } else {\n          FASTCOVER_tryParameters(data);\n        }\n        /* Print status */\n        DISPLAYUPDATE(lastUpdateTime,\n                      2, \"\\r%u%%       \",\n                      (unsigned)((iteration * 100) / kIterations));\n        ++iteration;\n      }\n      COVER_best_wait(&best);\n      FASTCOVER_ctx_destroy(&ctx);\n    }\n    DISPLAYLEVEL(2, \"\\r%79s\\r\", \"\");\n    /* Fill the output buffer and parameters with output of the best parameters */\n    {\n      const size_t dictSize = best.dictSize;\n      if (ZSTD_isError(best.compressedSize)) {\n        const size_t compressedSize = best.compressedSize;\n        COVER_best_destroy(&best);\n        POOL_free(pool);\n        return compressedSize;\n      }\n      FASTCOVER_convertToFastCoverParams(best.parameters, parameters, f, accel);\n      memcpy(dictBuffer, best.dict, dictSize);\n      COVER_best_destroy(&best);\n      POOL_free(pool);\n      return dictSize;\n    }\n\n}\n"
  },
  {
    "path": "lib/dictBuilder/zdict.c",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n\n/*-**************************************\n*  Tuning parameters\n****************************************/\n#define MINRATIO 4   /* minimum nb of apparition to be selected in dictionary */\n#define ZDICT_MAX_SAMPLES_SIZE (2000U << 20)\n#define ZDICT_MIN_SAMPLES_SIZE (ZDICT_CONTENTSIZE_MIN * MINRATIO)\n\n\n/*-**************************************\n*  Compiler Options\n****************************************/\n/* Unix Large Files support (>4GB) */\n#define _FILE_OFFSET_BITS 64\n#if (defined(__sun__) && (!defined(__LP64__)))   /* Sun Solaris 32-bits requires specific definitions */\n#  ifndef _LARGEFILE_SOURCE\n#  define _LARGEFILE_SOURCE\n#  endif\n#elif ! defined(__LP64__)                        /* No point defining Large file for 64 bit */\n#  ifndef _LARGEFILE64_SOURCE\n#  define _LARGEFILE64_SOURCE\n#  endif\n#endif\n\n\n/*-*************************************\n*  Dependencies\n***************************************/\n#include         /* malloc, free */\n#include         /* memset */\n#include          /* fprintf, fopen, ftello64 */\n#include           /* clock */\n\n#ifndef ZDICT_STATIC_LINKING_ONLY\n#  define ZDICT_STATIC_LINKING_ONLY\n#endif\n\n#include \"../common/mem.h\"           /* read */\n#include \"../common/fse.h\"           /* FSE_normalizeCount, FSE_writeNCount */\n#include \"../common/huf.h\"           /* HUF_buildCTable, HUF_writeCTable */\n#include \"../common/zstd_internal.h\" /* includes zstd.h */\n#include \"../common/xxhash.h\"        /* XXH64 */\n#include \"../compress/zstd_compress_internal.h\" /* ZSTD_loadCEntropy() */\n#include \"../zdict.h\"\n#include \"divsufsort.h\"\n#include \"../common/bits.h\"          /* ZSTD_NbCommonBytes */\n\n\n/*-*************************************\n*  Constants\n***************************************/\n#define KB *(1 <<10)\n#define MB *(1 <<20)\n#define GB *(1U<<30)\n\n#define DICTLISTSIZE_DEFAULT 10000\n\n#define NOISELENGTH 32\n\nstatic const U32 g_selectivity_default = 9;\n\n\n/*-*************************************\n*  Console display\n***************************************/\n#undef  DISPLAY\n#define DISPLAY(...)         do { fprintf(stderr, __VA_ARGS__); fflush( stderr ); } while (0)\n#undef  DISPLAYLEVEL\n#define DISPLAYLEVEL(l, ...) do { if (notificationLevel>=l) { DISPLAY(__VA_ARGS__); } } while (0)    /* 0 : no display;   1: errors;   2: default;  3: details;  4: debug */\n\nstatic clock_t ZDICT_clockSpan(clock_t nPrevious) { return clock() - nPrevious; }\n\nstatic void ZDICT_printHex(const void* ptr, size_t length)\n{\n    const BYTE* const b = (const BYTE*)ptr;\n    size_t u;\n    for (u=0; u126) c = '.';   /* non-printable char */\n        DISPLAY(\"%c\", c);\n    }\n}\n\n\n/*-********************************************************\n*  Helper functions\n**********************************************************/\nunsigned ZDICT_isError(size_t errorCode) { return ERR_isError(errorCode); }\n\nconst char* ZDICT_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }\n\nunsigned ZDICT_getDictID(const void* dictBuffer, size_t dictSize)\n{\n    if (dictSize < 8) return 0;\n    if (MEM_readLE32(dictBuffer) != ZSTD_MAGIC_DICTIONARY) return 0;\n    return MEM_readLE32((const char*)dictBuffer + 4);\n}\n\nsize_t ZDICT_getDictHeaderSize(const void* dictBuffer, size_t dictSize)\n{\n    size_t headerSize;\n    if (dictSize <= 8 || MEM_readLE32(dictBuffer) != ZSTD_MAGIC_DICTIONARY) return ERROR(dictionary_corrupted);\n\n    {   ZSTD_compressedBlockState_t* bs = (ZSTD_compressedBlockState_t*)malloc(sizeof(ZSTD_compressedBlockState_t));\n        U32* wksp = (U32*)malloc(HUF_WORKSPACE_SIZE);\n        if (!bs || !wksp) {\n            headerSize = ERROR(memory_allocation);\n        } else {\n            ZSTD_reset_compressedBlockState(bs);\n            headerSize = ZSTD_loadCEntropy(bs, wksp, dictBuffer, dictSize);\n        }\n\n        free(bs);\n        free(wksp);\n    }\n\n    return headerSize;\n}\n\n/*-********************************************************\n*  Dictionary training functions\n**********************************************************/\n/*! ZDICT_count() :\n    Count the nb of common bytes between 2 pointers.\n    Note : this function presumes end of buffer followed by noisy guard band.\n*/\nstatic size_t ZDICT_count(const void* pIn, const void* pMatch)\n{\n    const char* const pStart = (const char*)pIn;\n    for (;;) {\n        size_t const diff = MEM_readST(pMatch) ^ MEM_readST(pIn);\n        if (!diff) {\n            pIn = (const char*)pIn+sizeof(size_t);\n            pMatch = (const char*)pMatch+sizeof(size_t);\n            continue;\n        }\n        pIn = (const char*)pIn+ZSTD_NbCommonBytes(diff);\n        return (size_t)((const char*)pIn - pStart);\n    }\n}\n\n\ntypedef struct {\n    U32 pos;\n    U32 length;\n    U32 savings;\n} dictItem;\n\nstatic void ZDICT_initDictItem(dictItem* d)\n{\n    d->pos = 1;\n    d->length = 0;\n    d->savings = (U32)(-1);\n}\n\n\n#define LLIMIT 64          /* heuristic determined experimentally */\n#define MINMATCHLENGTH 7   /* heuristic determined experimentally */\nstatic dictItem ZDICT_analyzePos(\n                       BYTE* doneMarks,\n                       const unsigned* suffix, U32 start,\n                       const void* buffer, U32 minRatio, U32 notificationLevel)\n{\n    U32 lengthList[LLIMIT] = {0};\n    U32 cumulLength[LLIMIT] = {0};\n    U32 savings[LLIMIT] = {0};\n    const BYTE* b = (const BYTE*)buffer;\n    size_t maxLength = LLIMIT;\n    size_t pos = (size_t)suffix[start];\n    U32 end = start;\n    dictItem solution;\n\n    /* init */\n    memset(&solution, 0, sizeof(solution));\n    doneMarks[pos] = 1;\n\n    /* trivial repetition cases */\n    if ( (MEM_read16(b+pos+0) == MEM_read16(b+pos+2))\n       ||(MEM_read16(b+pos+1) == MEM_read16(b+pos+3))\n       ||(MEM_read16(b+pos+2) == MEM_read16(b+pos+4)) ) {\n        /* skip and mark segment */\n        U16 const pattern16 = MEM_read16(b+pos+4);\n        U32 u, patternEnd = 6;\n        while (MEM_read16(b+pos+patternEnd) == pattern16) patternEnd+=2 ;\n        if (b[pos+patternEnd] == b[pos+patternEnd-1]) patternEnd++;\n        for (u=1; u= MINMATCHLENGTH);\n    }\n\n    /* look backward */\n    {   size_t length;\n        do {\n            length = ZDICT_count(b + pos, b + *(suffix+start-1));\n            if (length >=MINMATCHLENGTH) start--;\n        } while(length >= MINMATCHLENGTH);\n    }\n\n    /* exit if not found a minimum nb of repetitions */\n    if (end-start < minRatio) {\n        U32 idx;\n        for(idx=start; idx= %i at pos %7u  \", (unsigned)(end-start), MINMATCHLENGTH, (unsigned)pos);\n        DISPLAYLEVEL(4, \"\\n\");\n\n        for (mml = MINMATCHLENGTH ; ; mml++) {\n            BYTE currentChar = 0;\n            U32 currentCount = 0;\n            U32 currentID = refinedStart;\n            U32 id;\n            U32 selectedCount = 0;\n            U32 selectedID = currentID;\n            for (id =refinedStart; id < refinedEnd; id++) {\n                if (b[suffix[id] + mml] != currentChar) {\n                    if (currentCount > selectedCount) {\n                        selectedCount = currentCount;\n                        selectedID = currentID;\n                    }\n                    currentID = id;\n                    currentChar = b[ suffix[id] + mml];\n                    currentCount = 0;\n                }\n                currentCount ++;\n            }\n            if (currentCount > selectedCount) {  /* for last */\n                selectedCount = currentCount;\n                selectedID = currentID;\n            }\n\n            if (selectedCount < minRatio)\n                break;\n            refinedStart = selectedID;\n            refinedEnd = refinedStart + selectedCount;\n        }\n\n        /* evaluate gain based on new dict */\n        start = refinedStart;\n        pos = suffix[refinedStart];\n        end = start;\n        memset(lengthList, 0, sizeof(lengthList));\n\n        /* look forward */\n        {   size_t length;\n            do {\n                end++;\n                length = ZDICT_count(b + pos, b + suffix[end]);\n                if (length >= LLIMIT) length = LLIMIT-1;\n                lengthList[length]++;\n            } while (length >=MINMATCHLENGTH);\n        }\n\n        /* look backward */\n        {   size_t length = MINMATCHLENGTH;\n            while ((length >= MINMATCHLENGTH) & (start > 0)) {\n                length = ZDICT_count(b + pos, b + suffix[start - 1]);\n                if (length >= LLIMIT) length = LLIMIT - 1;\n                lengthList[length]++;\n                if (length >= MINMATCHLENGTH) start--;\n            }\n        }\n\n        /* largest useful length */\n        memset(cumulLength, 0, sizeof(cumulLength));\n        cumulLength[maxLength-1] = lengthList[maxLength-1];\n        for (i=(int)(maxLength-2); i>=0; i--)\n            cumulLength[i] = cumulLength[i+1] + lengthList[i];\n\n        {   unsigned u;\n            for (u=LLIMIT-1; u>=MINMATCHLENGTH; u--) if (cumulLength[u]>=minRatio) break;\n            maxLength = u;\n        }\n\n        /* reduce maxLength in case of final into repetitive data */\n        {   U32 l = (U32)maxLength;\n            BYTE const c = b[pos + maxLength-1];\n            while (b[pos+l-2]==c) l--;\n            maxLength = l;\n        }\n        if (maxLength < MINMATCHLENGTH) return solution;   /* skip : no long-enough solution */\n\n        /* calculate savings */\n        savings[5] = 0;\n        {   unsigned u;\n            for (u=MINMATCHLENGTH; u<=maxLength; u++)\n                savings[u] = savings[u-1] + (lengthList[u] * (u-3));\n        }\n\n        DISPLAYLEVEL(4, \"Selected dict at position %u, of length %u : saves %u (ratio: %.2f)  \\n\",\n                     (unsigned)pos, (unsigned)maxLength, (unsigned)savings[maxLength], (double)savings[maxLength] / (double)maxLength);\n\n        solution.pos = (U32)pos;\n        solution.length = (U32)maxLength;\n        solution.savings = savings[maxLength];\n\n        /* mark positions done */\n        {   U32 id;\n            for (id=start; id solution.length) length = solution.length;\n                }\n                pEnd = (U32)(testedPos + length);\n                for (p=testedPos; ppos;\n    const U32 eltEnd = elt.pos + elt.length;\n    const char* const buf = (const char*) buffer;\n\n    /* tail overlap */\n    U32 u; for (u=1; u elt.pos) && (table[u].pos <= eltEnd)) {  /* overlap, existing > new */\n            /* append */\n            U32 const addedLength = table[u].pos - elt.pos;\n            table[u].length += addedLength;\n            table[u].pos = elt.pos;\n            table[u].savings += elt.savings * addedLength / elt.length;   /* rough approx */\n            table[u].savings += elt.length / 8;    /* rough approx bonus */\n            elt = table[u];\n            /* sort : improve rank */\n            while ((u>1) && (table[u-1].savings < elt.savings))\n                table[u] = table[u-1], u--;\n            table[u] = elt;\n            return u;\n    }   }\n\n    /* front overlap */\n    for (u=1; u= elt.pos) && (table[u].pos < elt.pos)) {  /* overlap, existing < new */\n            /* append */\n            int const addedLength = (int)eltEnd - (int)(table[u].pos + table[u].length); /* note: can be negative */\n            table[u].savings += elt.length / 8;    /* rough approx bonus */\n            if (addedLength > 0) {   /* otherwise, elt fully included into existing */\n                table[u].length += (unsigned)addedLength;\n                table[u].savings += elt.savings * (unsigned)addedLength / elt.length;   /* rough approx */\n            }\n            /* sort : improve rank */\n            elt = table[u];\n            while ((u>1) && (table[u-1].savings < elt.savings))\n                table[u] = table[u-1], u--;\n            table[u] = elt;\n            return u;\n        }\n\n        if (MEM_read64(buf + table[u].pos) == MEM_read64(buf + elt.pos + 1)) {\n            if (isIncluded(buf + table[u].pos, buf + elt.pos + 1, table[u].length)) {\n                size_t const addedLength = MAX( elt.length - table[u].length , 1 );\n                table[u].pos = elt.pos;\n                table[u].savings += (U32)(elt.savings * addedLength / elt.length);\n                table[u].length = MIN(elt.length, table[u].length + 1);\n                return u;\n            }\n        }\n    }\n\n    return 0;\n}\n\n\nstatic void ZDICT_removeDictItem(dictItem* table, U32 id)\n{\n    /* convention : table[0].pos stores nb of elts */\n    U32 const max = table[0].pos;\n    U32 u;\n    if (!id) return;   /* protection, should never happen */\n    for (u=id; upos--;\n}\n\n\nstatic void ZDICT_insertDictItem(dictItem* table, U32 maxSize, dictItem elt, const void* buffer)\n{\n    /* merge if possible */\n    U32 mergeId = ZDICT_tryMerge(table, elt, 0, buffer);\n    if (mergeId) {\n        U32 newMerge = 1;\n        while (newMerge) {\n            newMerge = ZDICT_tryMerge(table, table[mergeId], mergeId, buffer);\n            if (newMerge) ZDICT_removeDictItem(table, mergeId);\n            mergeId = newMerge;\n        }\n        return;\n    }\n\n    /* insert */\n    {   U32 current;\n        U32 nextElt = table->pos;\n        if (nextElt >= maxSize) nextElt = maxSize-1;\n        current = nextElt-1;\n        while (table[current].savings < elt.savings) {\n            table[current+1] = table[current];\n            current--;\n        }\n        table[current+1] = elt;\n        table->pos = nextElt+1;\n    }\n}\n\n\nstatic U32 ZDICT_dictSize(const dictItem* dictList)\n{\n    U32 u, dictSize = 0;\n    for (u=1; u=l) {                            \\\n                if (ZDICT_clockSpan(displayClock) > refreshRate) { \\\n                    displayClock = clock();                        \\\n                    DISPLAY(__VA_ARGS__);                          \\\n                }                                                  \\\n                if (notificationLevel>=4) fflush(stderr);          \\\n            }                                                      \\\n        } while (0)\n\n    /* init */\n    DISPLAYLEVEL(2, \"\\r%70s\\r\", \"\");   /* clean display line */\n    if (!suffix0 || !reverseSuffix || !doneMarks || !filePos) {\n        result = ERROR(memory_allocation);\n        goto _cleanup;\n    }\n    if (minRatio < MINRATIO) minRatio = MINRATIO;\n    memset(doneMarks, 0, bufferSize+16);\n\n    /* limit sample set size (divsufsort limitation)*/\n    if (bufferSize > ZDICT_MAX_SAMPLES_SIZE) DISPLAYLEVEL(3, \"sample set too large : reduced to %u MB ...\\n\", (unsigned)(ZDICT_MAX_SAMPLES_SIZE>>20));\n    while (bufferSize > ZDICT_MAX_SAMPLES_SIZE) bufferSize -= fileSizes[--nbFiles];\n\n    /* sort */\n    DISPLAYLEVEL(2, \"sorting %u files of total size %u MB ...\\n\", nbFiles, (unsigned)(bufferSize>>20));\n    {   int const divSuftSortResult = divsufsort((const unsigned char*)buffer, (int*)suffix, (int)bufferSize, 0);\n        if (divSuftSortResult != 0) { result = ERROR(GENERIC); goto _cleanup; }\n    }\n    suffix[bufferSize] = (unsigned)bufferSize;   /* leads into noise */\n    suffix0[0] = (unsigned)bufferSize;           /* leads into noise */\n    /* build reverse suffix sort */\n    {   size_t pos;\n        for (pos=0; pos < bufferSize; pos++)\n            reverseSuffix[suffix[pos]] = (U32)pos;\n        /* note filePos tracks borders between samples.\n           It's not used at this stage, but planned to become useful in a later update */\n        filePos[0] = 0;\n        for (pos=1; pos> 21);\n    }\n}\n\n\ntypedef struct\n{\n    ZSTD_CDict* dict;    /* dictionary */\n    ZSTD_CCtx* zc;     /* working context */\n    void* workPlace;   /* must be ZSTD_BLOCKSIZE_MAX allocated */\n} EStats_ress_t;\n\n#define MAXREPOFFSET 1024\n\nstatic void ZDICT_countEStats(EStats_ress_t esr, const ZSTD_parameters* params,\n                              unsigned* countLit, unsigned* offsetcodeCount, unsigned* matchlengthCount, unsigned* litlengthCount, U32* repOffsets,\n                              const void* src, size_t srcSize,\n                              U32 notificationLevel)\n{\n    size_t const blockSizeMax = MIN (ZSTD_BLOCKSIZE_MAX, 1 << params->cParams.windowLog);\n    size_t cSize;\n\n    if (srcSize > blockSizeMax) srcSize = blockSizeMax;   /* protection vs large samples */\n    {   size_t const errorCode = ZSTD_compressBegin_usingCDict_deprecated(esr.zc, esr.dict);\n        if (ZSTD_isError(errorCode)) { DISPLAYLEVEL(1, \"warning : ZSTD_compressBegin_usingCDict failed \\n\"); return; }\n\n    }\n    cSize = ZSTD_compressBlock_deprecated(esr.zc, esr.workPlace, ZSTD_BLOCKSIZE_MAX, src, srcSize);\n    if (ZSTD_isError(cSize)) { DISPLAYLEVEL(3, \"warning : could not compress sample size %u \\n\", (unsigned)srcSize); return; }\n\n    if (cSize) {  /* if == 0; block is not compressible */\n        const SeqStore_t* const seqStorePtr = ZSTD_getSeqStore(esr.zc);\n\n        /* literals stats */\n        {   const BYTE* bytePtr;\n            for(bytePtr = seqStorePtr->litStart; bytePtr < seqStorePtr->lit; bytePtr++)\n                countLit[*bytePtr]++;\n        }\n\n        /* seqStats */\n        {   U32 const nbSeq = (U32)(seqStorePtr->sequences - seqStorePtr->sequencesStart);\n            ZSTD_seqToCodes(seqStorePtr);\n\n            {   const BYTE* codePtr = seqStorePtr->ofCode;\n                U32 u;\n                for (u=0; umlCode;\n                U32 u;\n                for (u=0; ullCode;\n                U32 u;\n                for (u=0; u= 2) { /* rep offsets */\n                const SeqDef* const seq = seqStorePtr->sequencesStart;\n                U32 offset1 = seq[0].offBase - ZSTD_REP_NUM;\n                U32 offset2 = seq[1].offBase - ZSTD_REP_NUM;\n                if (offset1 >= MAXREPOFFSET) offset1 = 0;\n                if (offset2 >= MAXREPOFFSET) offset2 = 0;\n                repOffsets[offset1] += 3;\n                repOffsets[offset2] += 1;\n    }   }   }\n}\n\nstatic size_t ZDICT_totalSampleSize(const size_t* fileSizes, unsigned nbFiles)\n{\n    size_t total=0;\n    unsigned u;\n    for (u=0; u0; u--) {\n        offsetCount_t tmp;\n        if (table[u-1].count >= table[u].count) break;\n        tmp = table[u-1];\n        table[u-1] = table[u];\n        table[u] = tmp;\n    }\n}\n\n/* ZDICT_flatLit() :\n * rewrite `countLit` to contain a mostly flat but still compressible distribution of literals.\n * necessary to avoid generating a non-compressible distribution that HUF_writeCTable() cannot encode.\n */\nstatic void ZDICT_flatLit(unsigned* countLit)\n{\n    int u;\n    for (u=1; u<256; u++) countLit[u] = 2;\n    countLit[0]   = 4;\n    countLit[253] = 1;\n    countLit[254] = 1;\n}\n\n#define OFFCODE_MAX 30  /* only applicable to first block */\nstatic size_t ZDICT_analyzeEntropy(void*  dstBuffer, size_t maxDstSize,\n                                   int compressionLevel,\n                             const void*  srcBuffer, const size_t* fileSizes, unsigned nbFiles,\n                             const void* dictBuffer, size_t  dictBufferSize,\n                                   unsigned notificationLevel)\n{\n    unsigned countLit[256];\n    HUF_CREATE_STATIC_CTABLE(hufTable, 255);\n    unsigned offcodeCount[OFFCODE_MAX+1];\n    short offcodeNCount[OFFCODE_MAX+1];\n    U32 offcodeMax = ZSTD_highbit32((U32)(dictBufferSize + 128 KB));\n    unsigned matchLengthCount[MaxML+1];\n    short matchLengthNCount[MaxML+1];\n    unsigned litLengthCount[MaxLL+1];\n    short litLengthNCount[MaxLL+1];\n    U32 repOffset[MAXREPOFFSET];\n    offsetCount_t bestRepOffset[ZSTD_REP_NUM+1];\n    EStats_ress_t esr = { NULL, NULL, NULL };\n    ZSTD_parameters params;\n    U32 u, huffLog = 11, Offlog = OffFSELog, mlLog = MLFSELog, llLog = LLFSELog, total;\n    size_t pos = 0, errorCode;\n    size_t eSize = 0;\n    size_t const totalSrcSize = ZDICT_totalSampleSize(fileSizes, nbFiles);\n    size_t const averageSampleSize = totalSrcSize / (nbFiles + !nbFiles);\n    BYTE* dstPtr = (BYTE*)dstBuffer;\n    U32 wksp[HUF_CTABLE_WORKSPACE_SIZE_U32];\n\n    /* init */\n    DEBUGLOG(4, \"ZDICT_analyzeEntropy\");\n    if (offcodeMax>OFFCODE_MAX) { eSize = ERROR(dictionaryCreation_failed); goto _cleanup; }   /* too large dictionary */\n    for (u=0; u<256; u++) countLit[u] = 1;   /* any character must be described */\n    for (u=0; u<=offcodeMax; u++) offcodeCount[u] = 1;\n    for (u=0; u<=MaxML; u++) matchLengthCount[u] = 1;\n    for (u=0; u<=MaxLL; u++) litLengthCount[u] = 1;\n    memset(repOffset, 0, sizeof(repOffset));\n    repOffset[1] = repOffset[4] = repOffset[8] = 1;\n    memset(bestRepOffset, 0, sizeof(bestRepOffset));\n    if (compressionLevel==0) compressionLevel = ZSTD_CLEVEL_DEFAULT;\n    params = ZSTD_getParams(compressionLevel, averageSampleSize, dictBufferSize);\n\n    esr.dict = ZSTD_createCDict_advanced(dictBuffer, dictBufferSize, ZSTD_dlm_byRef, ZSTD_dct_rawContent, params.cParams, ZSTD_defaultCMem);\n    esr.zc = ZSTD_createCCtx();\n    esr.workPlace = malloc(ZSTD_BLOCKSIZE_MAX);\n    if (!esr.dict || !esr.zc || !esr.workPlace) {\n        eSize = ERROR(memory_allocation);\n        DISPLAYLEVEL(1, \"Not enough memory \\n\");\n        goto _cleanup;\n    }\n\n    /* collect stats on all samples */\n    for (u=0; u= 4) {\n        /* writeStats */\n        DISPLAYLEVEL(4, \"Offset Code Frequencies : \\n\");\n        for (u=0; u<=offcodeMax; u++) {\n            DISPLAYLEVEL(4, \"%2u :%7u \\n\", u, offcodeCount[u]);\n    }   }\n\n    /* analyze, build stats, starting with literals */\n    {   size_t maxNbBits = HUF_buildCTable_wksp(hufTable, countLit, 255, huffLog, wksp, sizeof(wksp));\n        if (HUF_isError(maxNbBits)) {\n            eSize = maxNbBits;\n            DISPLAYLEVEL(1, \" HUF_buildCTable error \\n\");\n            goto _cleanup;\n        }\n        if (maxNbBits==8) {  /* not compressible : will fail on HUF_writeCTable() */\n            DISPLAYLEVEL(2, \"warning : pathological dataset : literals are not compressible : samples are noisy or too regular \\n\");\n            ZDICT_flatLit(countLit);  /* replace distribution by a fake \"mostly flat but still compressible\" distribution, that HUF_writeCTable() can encode */\n            maxNbBits = HUF_buildCTable_wksp(hufTable, countLit, 255, huffLog, wksp, sizeof(wksp));\n            assert(maxNbBits==9);\n        }\n        huffLog = (U32)maxNbBits;\n    }\n\n    /* looking for most common first offsets */\n    {   U32 offset;\n        for (offset=1; offset dictBufferCapacity) {\n        dictContentSize = dictBufferCapacity - hSize;\n    }\n\n    /* Pad the dictionary content with zeros if it is too small */\n    if (dictContentSize < minContentSize) {\n        RETURN_ERROR_IF(hSize + minContentSize > dictBufferCapacity, dstSize_tooSmall,\n                        \"dictBufferCapacity too small to fit max repcode\");\n        paddingSize = minContentSize - dictContentSize;\n    } else {\n        paddingSize = 0;\n    }\n\n    {\n        size_t const dictSize = hSize + paddingSize + dictContentSize;\n\n        /* The dictionary consists of the header, optional padding, and the content.\n         * The padding comes before the content because the \"best\" position in the\n         * dictionary is the last byte.\n         */\n        BYTE* const outDictHeader = (BYTE*)dictBuffer;\n        BYTE* const outDictPadding = outDictHeader + hSize;\n        BYTE* const outDictContent = outDictPadding + paddingSize;\n\n        assert(dictSize <= dictBufferCapacity);\n        assert(outDictContent + dictContentSize == (BYTE*)dictBuffer + dictSize);\n\n        /* First copy the customDictContent into its final location.\n         * `customDictContent` and `dictBuffer` may overlap, so we must\n         * do this before any other writes into the output buffer.\n         * Then copy the header & padding into the output buffer.\n         */\n        memmove(outDictContent, customDictContent, dictContentSize);\n        memcpy(outDictHeader, header, hSize);\n        memset(outDictPadding, 0, paddingSize);\n\n        return dictSize;\n    }\n}\n\n\nstatic size_t ZDICT_addEntropyTablesFromBuffer_advanced(\n        void* dictBuffer, size_t dictContentSize, size_t dictBufferCapacity,\n        const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,\n        ZDICT_params_t params)\n{\n    int const compressionLevel = (params.compressionLevel == 0) ? ZSTD_CLEVEL_DEFAULT : params.compressionLevel;\n    U32 const notificationLevel = params.notificationLevel;\n    size_t hSize = 8;\n\n    /* calculate entropy tables */\n    DISPLAYLEVEL(2, \"\\r%70s\\r\", \"\");   /* clean display line */\n    DISPLAYLEVEL(2, \"statistics ... \\n\");\n    {   size_t const eSize = ZDICT_analyzeEntropy((char*)dictBuffer+hSize, dictBufferCapacity-hSize,\n                                  compressionLevel,\n                                  samplesBuffer, samplesSizes, nbSamples,\n                                  (char*)dictBuffer + dictBufferCapacity - dictContentSize, dictContentSize,\n                                  notificationLevel);\n        if (ZDICT_isError(eSize)) return eSize;\n        hSize += eSize;\n    }\n\n    /* add dictionary header (after entropy tables) */\n    MEM_writeLE32(dictBuffer, ZSTD_MAGIC_DICTIONARY);\n    {   U64 const randomID = XXH64((char*)dictBuffer + dictBufferCapacity - dictContentSize, dictContentSize, 0);\n        U32 const compliantID = (randomID % ((1U<<31)-32768)) + 32768;\n        U32 const dictID = params.dictID ? params.dictID : compliantID;\n        MEM_writeLE32((char*)dictBuffer+4, dictID);\n    }\n\n    if (hSize + dictContentSize < dictBufferCapacity)\n        memmove((char*)dictBuffer + hSize, (char*)dictBuffer + dictBufferCapacity - dictContentSize, dictContentSize);\n    return MIN(dictBufferCapacity, hSize+dictContentSize);\n}\n\n/*! ZDICT_trainFromBuffer_unsafe_legacy() :\n*   Warning : `samplesBuffer` must be followed by noisy guard band !!!\n*   @return : size of dictionary, or an error code which can be tested with ZDICT_isError()\n*/\nstatic size_t ZDICT_trainFromBuffer_unsafe_legacy(\n                            void* dictBuffer, size_t maxDictSize,\n                            const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,\n                            ZDICT_legacy_params_t params)\n{\n    U32 const dictListSize = MAX(MAX(DICTLISTSIZE_DEFAULT, nbSamples), (U32)(maxDictSize/16));\n    dictItem* const dictList = (dictItem*)malloc(dictListSize * sizeof(*dictList));\n    unsigned const selectivity = params.selectivityLevel == 0 ? g_selectivity_default : params.selectivityLevel;\n    unsigned const minRep = (selectivity > 30) ? MINRATIO : nbSamples >> selectivity;\n    size_t const targetDictSize = maxDictSize;\n    size_t const samplesBuffSize = ZDICT_totalSampleSize(samplesSizes, nbSamples);\n    size_t dictSize = 0;\n    U32 const notificationLevel = params.zParams.notificationLevel;\n\n    /* checks */\n    if (!dictList) return ERROR(memory_allocation);\n    if (maxDictSize < ZDICT_DICTSIZE_MIN) { free(dictList); return ERROR(dstSize_tooSmall); }   /* requested dictionary size is too small */\n    if (samplesBuffSize < ZDICT_MIN_SAMPLES_SIZE) { free(dictList); return ERROR(dictionaryCreation_failed); }   /* not enough source to create dictionary */\n\n    /* init */\n    ZDICT_initDictItem(dictList);\n\n    /* build dictionary */\n    ZDICT_trainBuffer_legacy(dictList, dictListSize,\n                       samplesBuffer, samplesBuffSize,\n                       samplesSizes, nbSamples,\n                       minRep, notificationLevel);\n\n    /* display best matches */\n    if (params.zParams.notificationLevel>= 3) {\n        unsigned const nb = MIN(25, dictList[0].pos);\n        unsigned const dictContentSize = ZDICT_dictSize(dictList);\n        unsigned u;\n        DISPLAYLEVEL(3, \"\\n %u segments found, of total size %u \\n\", (unsigned)dictList[0].pos-1, dictContentSize);\n        DISPLAYLEVEL(3, \"list %u best segments \\n\", nb-1);\n        for (u=1; u samplesBuffSize) || ((pos + length) > samplesBuffSize)) {\n                free(dictList);\n                return ERROR(GENERIC);   /* should never happen */\n            }\n            DISPLAYLEVEL(3, \"%3u:%3u bytes at pos %8u, savings %7u bytes |\",\n                         u, length, pos, (unsigned)dictList[u].savings);\n            ZDICT_printHex((const char*)samplesBuffer+pos, printedLength);\n            DISPLAYLEVEL(3, \"| \\n\");\n    }   }\n\n\n    /* create dictionary */\n    {   unsigned dictContentSize = ZDICT_dictSize(dictList);\n        if (dictContentSize < ZDICT_CONTENTSIZE_MIN) { free(dictList); return ERROR(dictionaryCreation_failed); }   /* dictionary content too small */\n        if (dictContentSize < targetDictSize/4) {\n            DISPLAYLEVEL(2, \"!  warning : selected content significantly smaller than requested (%u < %u) \\n\", dictContentSize, (unsigned)maxDictSize);\n            if (samplesBuffSize < 10 * targetDictSize)\n                DISPLAYLEVEL(2, \"!  consider increasing the number of samples (total size : %u MB)\\n\", (unsigned)(samplesBuffSize>>20));\n            if (minRep > MINRATIO) {\n                DISPLAYLEVEL(2, \"!  consider increasing selectivity to produce larger dictionary (-s%u) \\n\", selectivity+1);\n                DISPLAYLEVEL(2, \"!  note : larger dictionaries are not necessarily better, test its efficiency on samples \\n\");\n            }\n        }\n\n        if ((dictContentSize > targetDictSize*3) && (nbSamples > 2*MINRATIO) && (selectivity>1)) {\n            unsigned proposedSelectivity = selectivity-1;\n            while ((nbSamples >> proposedSelectivity) <= MINRATIO) { proposedSelectivity--; }\n            DISPLAYLEVEL(2, \"!  note : calculated dictionary significantly larger than requested (%u > %u) \\n\", dictContentSize, (unsigned)maxDictSize);\n            DISPLAYLEVEL(2, \"!  consider increasing dictionary size, or produce denser dictionary (-s%u) \\n\", proposedSelectivity);\n            DISPLAYLEVEL(2, \"!  always test dictionary efficiency on real samples \\n\");\n        }\n\n        /* limit dictionary size */\n        {   U32 const max = dictList->pos;   /* convention : nb of useful elts within dictList */\n            U32 currentSize = 0;\n            U32 n; for (n=1; n targetDictSize) { currentSize -= dictList[n].length; break; }\n            }\n            dictList->pos = n;\n            dictContentSize = currentSize;\n        }\n\n        /* build dict content */\n        {   U32 u;\n            BYTE* ptr = (BYTE*)dictBuffer + maxDictSize;\n            for (u=1; upos; u++) {\n                U32 l = dictList[u].length;\n                ptr -= l;\n                if (ptr<(BYTE*)dictBuffer) { free(dictList); return ERROR(GENERIC); }   /* should not happen */\n                memcpy(ptr, (const char*)samplesBuffer+dictList[u].pos, l);\n        }   }\n\n        dictSize = ZDICT_addEntropyTablesFromBuffer_advanced(dictBuffer, dictContentSize, maxDictSize,\n                                                             samplesBuffer, samplesSizes, nbSamples,\n                                                             params.zParams);\n    }\n\n    /* clean up */\n    free(dictList);\n    return dictSize;\n}\n\n\n/* ZDICT_trainFromBuffer_legacy() :\n * issue : samplesBuffer need to be followed by a noisy guard band.\n * work around : duplicate the buffer, and add the noise */\nsize_t ZDICT_trainFromBuffer_legacy(void* dictBuffer, size_t dictBufferCapacity,\n                              const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,\n                              ZDICT_legacy_params_t params)\n{\n    size_t result;\n    void* newBuff;\n    size_t const sBuffSize = ZDICT_totalSampleSize(samplesSizes, nbSamples);\n    if (sBuffSize < ZDICT_MIN_SAMPLES_SIZE) return 0;   /* not enough content => no dictionary */\n\n    newBuff = malloc(sBuffSize + NOISELENGTH);\n    if (!newBuff) return ERROR(memory_allocation);\n\n    memcpy(newBuff, samplesBuffer, sBuffSize);\n    ZDICT_fillNoise((char*)newBuff + sBuffSize, NOISELENGTH);   /* guard band, for end of buffer condition */\n\n    result =\n        ZDICT_trainFromBuffer_unsafe_legacy(dictBuffer, dictBufferCapacity, newBuff,\n                                            samplesSizes, nbSamples, params);\n    free(newBuff);\n    return result;\n}\n\n\nsize_t ZDICT_trainFromBuffer(void* dictBuffer, size_t dictBufferCapacity,\n                             const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples)\n{\n    ZDICT_fastCover_params_t params;\n    DEBUGLOG(3, \"ZDICT_trainFromBuffer\");\n    memset(¶ms, 0, sizeof(params));\n    params.d = 8;\n    params.steps = 4;\n    /* Use default level since no compression level information is available */\n    params.zParams.compressionLevel = ZSTD_CLEVEL_DEFAULT;\n#if defined(DEBUGLEVEL) && (DEBUGLEVEL>=1)\n    params.zParams.notificationLevel = DEBUGLEVEL;\n#endif\n    return ZDICT_optimizeTrainFromBuffer_fastCover(dictBuffer, dictBufferCapacity,\n                                               samplesBuffer, samplesSizes, nbSamples,\n                                               ¶ms);\n}\n\nsize_t ZDICT_addEntropyTablesFromBuffer(void* dictBuffer, size_t dictContentSize, size_t dictBufferCapacity,\n                                  const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples)\n{\n    ZDICT_params_t params;\n    memset(¶ms, 0, sizeof(params));\n    return ZDICT_addEntropyTablesFromBuffer_advanced(dictBuffer, dictContentSize, dictBufferCapacity,\n                                                     samplesBuffer, samplesSizes, nbSamples,\n                                                     params);\n}\n"
  },
  {
    "path": "lib/dll/example/Makefile",
    "content": "# ################################################################\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n# All rights reserved.\n#\n# This source code is licensed under both the BSD-style license (found in the\n# LICENSE file in the root directory of this source tree) and the GPLv2 (found\n# in the COPYING file in the root directory of this source tree).\n# You may select, at your option, one of the above-listed licenses.\n# ################################################################\n\nVOID    := /dev/null\nZSTDDIR  := ../include\nLIBDIR  := ../static\nDLLDIR  := ../dll\n\nCFLAGS  ?= -O3   # can select custom flags. For example : CFLAGS=\"-O2 -g\" make\nCFLAGS  += -Wall -Wextra -Wundef -Wcast-qual -Wcast-align -Wshadow -Wswitch-enum \\\n           -Wdeclaration-after-statement -Wstrict-prototypes \\\n           -Wpointer-arith -Wstrict-aliasing=1\nCFLAGS  += $(MOREFLAGS)\nCPPFLAGS:= -I$(ZSTDDIR) -DXXH_NAMESPACE=ZSTD_\nFLAGS   := $(CFLAGS) $(CPPFLAGS) $(LDFLAGS)\n\n\n# Define *.exe as extension for Windows systems\nifneq (,$(filter Windows%,$(OS)))\nEXT =.exe\nelse\nEXT =\nendif\n\n.PHONY: default fullbench-dll fullbench-lib\n\n\ndefault: all\n\nall: fullbench-dll fullbench-lib\n\n\nfullbench-lib: fullbench.c datagen.c\n\t$(CC) $(FLAGS) $^ -o $@$(EXT) $(LIBDIR)/libzstd_static.lib\n\nfullbench-dll: fullbench.c datagen.c\n\t$(CC) $(FLAGS) $^ -o $@$(EXT) -DZSTD_DLL_IMPORT=1 $(DLLDIR)/libzstd.dll\n\nclean:\n\t@$(RM) fullbench-dll$(EXT) fullbench-lib$(EXT) \\\n\t@echo Cleaning completed\n"
  },
  {
    "path": "lib/dll/example/README.md",
    "content": "# ZSTD Windows binary package\n\n## The package contents\n\n- `zstd.exe` : Command Line Utility, supporting gzip-like arguments\n- `dll\\libzstd.dll` : The ZSTD dynamic library (DLL)\n- `dll\\libzstd.lib` : The import library of the ZSTD dynamic library (DLL) for Visual C++\n- `example\\` : The example of usage of the ZSTD library\n- `include\\` : Header files required by the ZSTD library\n- `static\\libzstd_static.lib` : The static ZSTD library (LIB)\n\n## Usage of Command Line Interface\n\nCommand Line Interface (CLI) supports gzip-like arguments.\nBy default CLI takes an input file and compresses it to an output file:\n\n    Usage: zstd [arg] [input] [output]\n\nThe full list of commands for CLI can be obtained with `-h` or `-H`. The ratio can\nbe improved with commands from `-3` to `-16` but higher levels also have slower\ncompression. CLI includes in-memory compression benchmark module with compression\nlevels starting from `-b` and ending with `-e` with iteration time of `-i` seconds.\nCLI supports aggregation of parameters i.e. `-b1`, `-e18`, and `-i1` can be joined\ninto `-b1e18i1`.\n\n## The example of usage of static and dynamic ZSTD libraries with gcc/MinGW\n\nUse `cd example` and `make` to build `fullbench-dll` and `fullbench-lib`.\n`fullbench-dll` uses a dynamic ZSTD library from the `dll` directory.\n`fullbench-lib` uses a static ZSTD library from the `lib` directory.\n\n## Using ZSTD DLL with gcc/MinGW\n\nThe header files from `include\\` and the dynamic library `dll\\libzstd.dll`\nare required to compile a project using gcc/MinGW.\nThe dynamic library has to be added to linking options.\nIt means that if a project that uses ZSTD consists of a single `test-dll.c`\nfile it should be linked with `dll\\libzstd.dll`. For example:\n\n    gcc $(CFLAGS) -Iinclude\\ test-dll.c -o test-dll dll\\libzstd.dll\n\nThe compiled executable will require ZSTD DLL which is available at `dll\\libzstd.dll`.\n\n## The example of usage of static and dynamic ZSTD libraries with Visual C++\n\nOpen `example\\fullbench-dll.sln` to compile `fullbench-dll` that uses a\ndynamic ZSTD library from the `dll` directory. The solution works with Visual C++\n2010 or newer. When one will open the solution with Visual C++ newer than 2010\nthen the solution will be upgraded to the current version.\n\n## Using ZSTD DLL with Visual C++\n\nThe header files from `include\\` and the import library `dll\\libzstd.lib`\nare required to compile a project using Visual C++.\n\n1. The path to header files should be added to `Additional Include Directories` that can\n   be found in project properties `C/C++` then `General`.\n2. The import library has to be added to `Additional Dependencies` that can\n   be found in project properties `Linker` then `Input`.\n   If one will provide only the name `libzstd.lib` without a full path to the library\n   the directory has to be added to `Linker\\General\\Additional Library Directories`.\n\nThe compiled executable will require ZSTD DLL which is available at `dll\\libzstd.dll`.\n"
  },
  {
    "path": "lib/dll/example/build_package.bat",
    "content": "@echo off\r\nsetlocal\r\n\r\nrem Detect build type based on available files\r\nset BUILD_TYPE=make\r\nif exist \"build\\cmake\\build\\lib\\Release\\zstd_static.lib\" set BUILD_TYPE=cmake\r\n\r\necho Detected build type: %BUILD_TYPE%\r\n\r\nrem Create required directories\r\nmkdir bin\\dll bin\\static bin\\example bin\\include\r\n\r\nrem Copy common files using a subroutine. Exits immediately on failure.\r\ncall :copyFile \"tests\\fullbench.c\" \"bin\\example\\\"\r\ncall :copyFile \"programs\\datagen.c\" \"bin\\example\\\"\r\ncall :copyFile \"programs\\datagen.h\" \"bin\\example\\\"\r\ncall :copyFile \"programs\\util.h\" \"bin\\example\\\"\r\ncall :copyFile \"programs\\platform.h\" \"bin\\example\\\"\r\ncall :copyFile \"lib\\common\\mem.h\" \"bin\\example\\\"\r\ncall :copyFile \"lib\\common\\zstd_internal.h\" \"bin\\example\\\"\r\ncall :copyFile \"lib\\common\\error_private.h\" \"bin\\example\\\"\r\ncall :copyFile \"lib\\common\\xxhash.h\" \"bin\\example\\\"\r\ncall :copyFile \"lib\\dll\\example\\Makefile\" \"bin\\example\\\"\r\ncall :copyFile \"lib\\dll\\example\\fullbench-dll.*\" \"bin\\example\\\"\r\ncall :copyFile \"lib\\zstd.h\" \"bin\\include\\\"\r\ncall :copyFile \"lib\\zstd_errors.h\" \"bin\\include\\\"\r\ncall :copyFile \"lib\\zdict.h\" \"bin\\include\\\"\r\n\r\nrem Copy build-specific files\r\nif \"%BUILD_TYPE%\"==\"cmake\" (\r\n    echo Copying CMake build artifacts...\r\n    call :copyFile \"build\\cmake\\build\\lib\\Release\\zstd_static.lib\" \"bin\\static\\libzstd_static.lib\"\r\n    call :copyFile \"build\\cmake\\build\\lib\\Release\\zstd.dll\" \"bin\\dll\\libzstd.dll\"\r\n    call :copyFile \"build\\cmake\\build\\lib\\Release\\zstd.lib\" \"bin\\dll\\zstd.lib\"\r\n    call :copyFile \"build\\cmake\\build\\programs\\Release\\zstd.exe\" \"bin\\zstd.exe\"\r\n    call :copyFile \"lib\\dll\\example\\README.md\" \"bin\\README.md\"\r\n) else (\r\n    echo Copying Make build artifacts...\r\n    call :copyFile \"lib\\libzstd.a\" \"bin\\static\\libzstd_static.lib\"\r\n    call :copyFile \"lib\\dll\\libzstd.*\" \"bin\\dll\\\"\r\n    call :copyFile \"programs\\zstd.exe\" \"bin\\zstd.exe\"\r\n    call :copyFile \"lib\\dll\\example\\README.md\" \"bin\\\"\r\n)\r\n\r\necho Build package created successfully for %BUILD_TYPE% build!\r\nendlocal\r\nexit /b 0\r\n\r\n:copyFile\r\ncopy \"%~1\" \"%~2\"\r\nif errorlevel 1 (\r\n    echo Failed to copy \"%~1\"\r\n    exit 1\r\n)\r\nexit /b"
  },
  {
    "path": "lib/dll/example/fullbench-dll.sln",
    "content": "Microsoft Visual Studio Solution File, Format Version 12.00\r\n# Visual Studio Express 2012 for Windows Desktop\r\nProject(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \"fullbench-dll\", \"fullbench-dll.vcxproj\", \"{13992FD2-077E-4954-B065-A428198201A9}\"\r\nEndProject\r\nGlobal\r\n\tGlobalSection(SolutionConfigurationPlatforms) = preSolution\r\n\t\tDebug|Win32 = Debug|Win32\r\n\t\tDebug|x64 = Debug|x64\r\n\t\tRelease|Win32 = Release|Win32\r\n\t\tRelease|x64 = Release|x64\r\n\tEndGlobalSection\r\n\tGlobalSection(ProjectConfigurationPlatforms) = postSolution\r\n\t\t{13992FD2-077E-4954-B065-A428198201A9}.Debug|Win32.ActiveCfg = Debug|Win32\r\n\t\t{13992FD2-077E-4954-B065-A428198201A9}.Debug|Win32.Build.0 = Debug|Win32\r\n\t\t{13992FD2-077E-4954-B065-A428198201A9}.Debug|x64.ActiveCfg = Debug|x64\r\n\t\t{13992FD2-077E-4954-B065-A428198201A9}.Debug|x64.Build.0 = Debug|x64\r\n\t\t{13992FD2-077E-4954-B065-A428198201A9}.Release|Win32.ActiveCfg = Release|Win32\r\n\t\t{13992FD2-077E-4954-B065-A428198201A9}.Release|Win32.Build.0 = Release|Win32\r\n\t\t{13992FD2-077E-4954-B065-A428198201A9}.Release|x64.ActiveCfg = Release|x64\r\n\t\t{13992FD2-077E-4954-B065-A428198201A9}.Release|x64.Build.0 = Release|x64\r\n\tEndGlobalSection\r\n\tGlobalSection(SolutionProperties) = preSolution\r\n\t\tHideSolutionNode = FALSE\r\n\tEndGlobalSection\r\nEndGlobal\r\n"
  },
  {
    "path": "lib/dll/example/fullbench-dll.vcxproj",
    "content": "\r\n\r\n  \r\n    \r\n      Debug\r\n      Win32\r\n    \r\n    \r\n      Debug\r\n      x64\r\n    \r\n    \r\n      Release\r\n      Win32\r\n    \r\n    \r\n      Release\r\n      x64\r\n    \r\n  \r\n  \r\n    {00000000-1CC8-4FD7-9281-6B8DBB9D3DF8}\r\n    Win32Proj\r\n    fullbench-dll\r\n    $(SolutionDir)bin\\$(Platform)_$(Configuration)\\\r\n    $(SolutionDir)bin\\obj\\$(RootNamespace)_$(Platform)_$(Configuration)\\\r\n  \r\n  \r\n  \r\n    Application\r\n    true\r\n    MultiByte\r\n  \r\n  \r\n    Application\r\n    true\r\n    MultiByte\r\n  \r\n  \r\n    Application\r\n    false\r\n    true\r\n    MultiByte\r\n  \r\n  \r\n    Application\r\n    false\r\n    true\r\n    MultiByte\r\n  \r\n  \r\n  \r\n  \r\n  \r\n    \r\n  \r\n  \r\n    \r\n  \r\n  \r\n    \r\n  \r\n  \r\n    \r\n  \r\n  \r\n  \r\n    true\r\n    $(IncludePath);$(SolutionDir)..\\..\\lib;$(SolutionDir)..\\..\\programs;$(SolutionDir)..\\..\\lib\\legacy;$(SolutionDir)..\\..\\lib\\common;$(UniversalCRT_IncludePath);\r\n    false\r\n  \r\n  \r\n    true\r\n    $(IncludePath);$(SolutionDir)..\\..\\lib;$(SolutionDir)..\\..\\programs;$(SolutionDir)..\\..\\lib\\legacy;$(SolutionDir)..\\..\\lib\\common;$(UniversalCRT_IncludePath);\r\n    false\r\n  \r\n  \r\n    false\r\n    $(IncludePath);$(SolutionDir)..\\..\\lib;$(SolutionDir)..\\..\\programs;$(SolutionDir)..\\..\\lib\\legacy;$(SolutionDir)..\\..\\lib\\common;$(UniversalCRT_IncludePath);\r\n    false\r\n  \r\n  \r\n    false\r\n    $(IncludePath);$(SolutionDir)..\\..\\lib;$(SolutionDir)..\\..\\programs;$(SolutionDir)..\\..\\lib\\legacy;$(SolutionDir)..\\..\\lib\\common;$(UniversalCRT_IncludePath);\r\n    false\r\n  \r\n  \r\n    \r\n      \r\n      \r\n      Level4\r\n      Disabled\r\n      WIN32;_DEBUG;_CONSOLE;ZSTD_DLL_IMPORT=1;%(PreprocessorDefinitions)\r\n      true\r\n      false\r\n      ..\\include\r\n    \r\n    \r\n      Console\r\n      true\r\n      $(SolutionDir)..\\dll;%(AdditionalLibraryDirectories)\r\n      libzstd.lib;%(AdditionalDependencies)\r\n      false\r\n    \r\n  \r\n  \r\n    \r\n      \r\n      \r\n      Level4\r\n      Disabled\r\n      WIN32;_DEBUG;_CONSOLE;ZSTD_DLL_IMPORT=1;%(PreprocessorDefinitions)\r\n      true\r\n      false\r\n      ..\\include\r\n    \r\n    \r\n      Console\r\n      true\r\n      $(SolutionDir)..\\dll;%(AdditionalLibraryDirectories)\r\n      libzstd.lib;%(AdditionalDependencies)\r\n    \r\n  \r\n  \r\n    \r\n      Level4\r\n      \r\n      \r\n      MaxSpeed\r\n      true\r\n      true\r\n      WIN32;_DEBUG;_CONSOLE;ZSTD_DLL_IMPORT=1;%(PreprocessorDefinitions)\r\n      false\r\n      ..\\include\r\n      false\r\n      MultiThreaded\r\n    \r\n    \r\n      Console\r\n      true\r\n      true\r\n      true\r\n      $(SolutionDir)..\\dll;%(AdditionalLibraryDirectories)\r\n      libzstd.lib;%(AdditionalDependencies)\r\n      false\r\n    \r\n  \r\n  \r\n    \r\n      Level4\r\n      \r\n      \r\n      MaxSpeed\r\n      true\r\n      true\r\n      WIN32;_DEBUG;_CONSOLE;ZSTD_DLL_IMPORT=1;%(PreprocessorDefinitions)\r\n      false\r\n      false\r\n      ..\\include\r\n      MultiThreaded\r\n    \r\n    \r\n      Console\r\n      true\r\n      true\r\n      true\r\n      $(SolutionDir)..\\dll;%(AdditionalLibraryDirectories)\r\n      libzstd.lib;%(AdditionalDependencies)\r\n    \r\n  \r\n  \r\n    \r\n    \r\n  \r\n  \r\n    \r\n  \r\n  \r\n  \r\n  \r\n"
  },
  {
    "path": "lib/install_oses.mk",
    "content": "# ################################################################\n# Copyright (c) Meta Platforms, Inc. and affiliates.\n# All rights reserved.\n#\n# This source code is licensed under both the BSD-style license (found in the\n# LICENSE file in the root directory of this source tree) and the GPLv2 (found\n# in the COPYING file in the root directory of this source tree).\n# You may select, at your option, one of the above-listed licenses.\n# ################################################################\n\n# This included Makefile provides the following variables :\n# UNAME, INSTALL_OS_LIST\n\nUNAME := $(shell sh -c 'MSYSTEM=\"MSYS\" uname')\n\n# List of OSes for which target install is supported\nINSTALL_OS_LIST ?= Linux Darwin GNU/kFreeBSD GNU OpenBSD FreeBSD NetBSD DragonFly SunOS Haiku AIX MSYS_NT% CYGWIN_NT%\n"
  },
  {
    "path": "lib/legacy/zstd_legacy.h",
    "content": "/*\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_LEGACY_H\n#define ZSTD_LEGACY_H\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n\n/* *************************************\n*  Includes\n***************************************/\n#include \"../common/mem.h\"            /* MEM_STATIC */\n#include \"../common/error_private.h\"  /* ERROR */\n#include \"../common/zstd_internal.h\"  /* ZSTD_inBuffer, ZSTD_outBuffer, ZSTD_frameSizeInfo */\n\n#if !defined (ZSTD_LEGACY_SUPPORT) || (ZSTD_LEGACY_SUPPORT == 0)\n#  undef ZSTD_LEGACY_SUPPORT\n#  define ZSTD_LEGACY_SUPPORT 8\n#endif\n\n#if (ZSTD_LEGACY_SUPPORT <= 1)\n#  include \"zstd_v01.h\"\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 2)\n#  include \"zstd_v02.h\"\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 3)\n#  include \"zstd_v03.h\"\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 4)\n#  include \"zstd_v04.h\"\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 5)\n#  include \"zstd_v05.h\"\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 6)\n#  include \"zstd_v06.h\"\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 7)\n#  include \"zstd_v07.h\"\n#endif\n\n/** ZSTD_isLegacy() :\n    @return : > 0 if supported by legacy decoder. 0 otherwise.\n              return value is the version.\n*/\nMEM_STATIC unsigned ZSTD_isLegacy(const void* src, size_t srcSize)\n{\n    U32 magicNumberLE;\n    if (srcSize<4) return 0;\n    magicNumberLE = MEM_readLE32(src);\n    switch(magicNumberLE)\n    {\n#if (ZSTD_LEGACY_SUPPORT <= 1)\n        case ZSTDv01_magicNumberLE:return 1;\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 2)\n        case ZSTDv02_magicNumber : return 2;\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 3)\n        case ZSTDv03_magicNumber : return 3;\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 4)\n        case ZSTDv04_magicNumber : return 4;\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 5)\n        case ZSTDv05_MAGICNUMBER : return 5;\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 6)\n        case ZSTDv06_MAGICNUMBER : return 6;\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 7)\n        case ZSTDv07_MAGICNUMBER : return 7;\n#endif\n        default : return 0;\n    }\n}\n\n\nMEM_STATIC unsigned long long ZSTD_getDecompressedSize_legacy(const void* src, size_t srcSize)\n{\n    U32 const version = ZSTD_isLegacy(src, srcSize);\n    if (version < 5) return 0;  /* no decompressed size in frame header, or not a legacy format */\n#if (ZSTD_LEGACY_SUPPORT <= 5)\n    if (version==5) {\n        ZSTDv05_parameters fParams;\n        size_t const frResult = ZSTDv05_getFrameParams(&fParams, src, srcSize);\n        if (frResult != 0) return 0;\n        return fParams.srcSize;\n    }\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 6)\n    if (version==6) {\n        ZSTDv06_frameParams fParams;\n        size_t const frResult = ZSTDv06_getFrameParams(&fParams, src, srcSize);\n        if (frResult != 0) return 0;\n        return fParams.frameContentSize;\n    }\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 7)\n    if (version==7) {\n        ZSTDv07_frameParams fParams;\n        size_t const frResult = ZSTDv07_getFrameParams(&fParams, src, srcSize);\n        if (frResult != 0) return 0;\n        return fParams.frameContentSize;\n    }\n#endif\n    return 0;   /* should not be possible */\n}\n\n\nMEM_STATIC size_t ZSTD_decompressLegacy(\n                     void* dst, size_t dstCapacity,\n               const void* src, size_t compressedSize,\n               const void* dict,size_t dictSize)\n{\n    U32 const version = ZSTD_isLegacy(src, compressedSize);\n    char x;\n    /* Avoid passing NULL to legacy decoding. */\n    if (dst == NULL) {\n        assert(dstCapacity == 0);\n        dst = &x;\n    }\n    if (src == NULL) {\n        assert(compressedSize == 0);\n        src = &x;\n    }\n    if (dict == NULL) {\n        assert(dictSize == 0);\n        dict = &x;\n    }\n    (void)dst; (void)dstCapacity; (void)dict; (void)dictSize;  /* unused when ZSTD_LEGACY_SUPPORT >= 8 */\n    switch(version)\n    {\n#if (ZSTD_LEGACY_SUPPORT <= 1)\n        case 1 :\n            return ZSTDv01_decompress(dst, dstCapacity, src, compressedSize);\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 2)\n        case 2 :\n            return ZSTDv02_decompress(dst, dstCapacity, src, compressedSize);\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 3)\n        case 3 :\n            return ZSTDv03_decompress(dst, dstCapacity, src, compressedSize);\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 4)\n        case 4 :\n            return ZSTDv04_decompress(dst, dstCapacity, src, compressedSize);\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 5)\n        case 5 :\n            {   size_t result;\n                ZSTDv05_DCtx* const zd = ZSTDv05_createDCtx();\n                if (zd==NULL) return ERROR(memory_allocation);\n                result = ZSTDv05_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize);\n                ZSTDv05_freeDCtx(zd);\n                return result;\n            }\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 6)\n        case 6 :\n            {   size_t result;\n                ZSTDv06_DCtx* const zd = ZSTDv06_createDCtx();\n                if (zd==NULL) return ERROR(memory_allocation);\n                result = ZSTDv06_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize);\n                ZSTDv06_freeDCtx(zd);\n                return result;\n            }\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 7)\n        case 7 :\n            {   size_t result;\n                ZSTDv07_DCtx* const zd = ZSTDv07_createDCtx();\n                if (zd==NULL) return ERROR(memory_allocation);\n                result = ZSTDv07_decompress_usingDict(zd, dst, dstCapacity, src, compressedSize, dict, dictSize);\n                ZSTDv07_freeDCtx(zd);\n                return result;\n            }\n#endif\n        default :\n            return ERROR(prefix_unknown);\n    }\n}\n\nMEM_STATIC ZSTD_frameSizeInfo ZSTD_findFrameSizeInfoLegacy(const void *src, size_t srcSize)\n{\n    ZSTD_frameSizeInfo frameSizeInfo;\n    U32 const version = ZSTD_isLegacy(src, srcSize);\n    switch(version)\n    {\n#if (ZSTD_LEGACY_SUPPORT <= 1)\n        case 1 :\n            ZSTDv01_findFrameSizeInfoLegacy(src, srcSize,\n                &frameSizeInfo.compressedSize,\n                &frameSizeInfo.decompressedBound);\n            break;\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 2)\n        case 2 :\n            ZSTDv02_findFrameSizeInfoLegacy(src, srcSize,\n                &frameSizeInfo.compressedSize,\n                &frameSizeInfo.decompressedBound);\n            break;\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 3)\n        case 3 :\n            ZSTDv03_findFrameSizeInfoLegacy(src, srcSize,\n                &frameSizeInfo.compressedSize,\n                &frameSizeInfo.decompressedBound);\n            break;\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 4)\n        case 4 :\n            ZSTDv04_findFrameSizeInfoLegacy(src, srcSize,\n                &frameSizeInfo.compressedSize,\n                &frameSizeInfo.decompressedBound);\n            break;\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 5)\n        case 5 :\n            ZSTDv05_findFrameSizeInfoLegacy(src, srcSize,\n                &frameSizeInfo.compressedSize,\n                &frameSizeInfo.decompressedBound);\n            break;\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 6)\n        case 6 :\n            ZSTDv06_findFrameSizeInfoLegacy(src, srcSize,\n                &frameSizeInfo.compressedSize,\n                &frameSizeInfo.decompressedBound);\n            break;\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 7)\n        case 7 :\n            ZSTDv07_findFrameSizeInfoLegacy(src, srcSize,\n                &frameSizeInfo.compressedSize,\n                &frameSizeInfo.decompressedBound);\n            break;\n#endif\n        default :\n            frameSizeInfo.compressedSize = ERROR(prefix_unknown);\n            frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR;\n            break;\n    }\n    if (!ZSTD_isError(frameSizeInfo.compressedSize) && frameSizeInfo.compressedSize > srcSize) {\n        frameSizeInfo.compressedSize = ERROR(srcSize_wrong);\n        frameSizeInfo.decompressedBound = ZSTD_CONTENTSIZE_ERROR;\n    }\n    /* In all cases, decompressedBound == nbBlocks * ZSTD_BLOCKSIZE_MAX.\n     * So we can compute nbBlocks without having to change every function.\n     */\n    if (frameSizeInfo.decompressedBound != ZSTD_CONTENTSIZE_ERROR) {\n        assert((frameSizeInfo.decompressedBound & (ZSTD_BLOCKSIZE_MAX - 1)) == 0);\n        frameSizeInfo.nbBlocks = (size_t)(frameSizeInfo.decompressedBound / ZSTD_BLOCKSIZE_MAX);\n    }\n    return frameSizeInfo;\n}\n\nMEM_STATIC size_t ZSTD_findFrameCompressedSizeLegacy(const void *src, size_t srcSize)\n{\n    ZSTD_frameSizeInfo frameSizeInfo = ZSTD_findFrameSizeInfoLegacy(src, srcSize);\n    return frameSizeInfo.compressedSize;\n}\n\nMEM_STATIC size_t ZSTD_freeLegacyStreamContext(void* legacyContext, U32 version)\n{\n    switch(version)\n    {\n        default :\n        case 1 :\n        case 2 :\n        case 3 :\n            (void)legacyContext;\n            return ERROR(version_unsupported);\n#if (ZSTD_LEGACY_SUPPORT <= 4)\n        case 4 : return ZBUFFv04_freeDCtx((ZBUFFv04_DCtx*)legacyContext);\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 5)\n        case 5 : return ZBUFFv05_freeDCtx((ZBUFFv05_DCtx*)legacyContext);\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 6)\n        case 6 : return ZBUFFv06_freeDCtx((ZBUFFv06_DCtx*)legacyContext);\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 7)\n        case 7 : return ZBUFFv07_freeDCtx((ZBUFFv07_DCtx*)legacyContext);\n#endif\n    }\n}\n\n\nMEM_STATIC size_t ZSTD_initLegacyStream(void** legacyContext, U32 prevVersion, U32 newVersion,\n                                        const void* dict, size_t dictSize)\n{\n    char x;\n    /* Avoid passing NULL to legacy decoding. */\n    if (dict == NULL) {\n        assert(dictSize == 0);\n        dict = &x;\n    }\n    DEBUGLOG(5, \"ZSTD_initLegacyStream for v0.%u\", newVersion);\n    if (prevVersion != newVersion) ZSTD_freeLegacyStreamContext(*legacyContext, prevVersion);\n    switch(newVersion)\n    {\n        default :\n        case 1 :\n        case 2 :\n        case 3 :\n            (void)dict; (void)dictSize;\n            return 0;\n#if (ZSTD_LEGACY_SUPPORT <= 4)\n        case 4 :\n        {\n            ZBUFFv04_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv04_createDCtx() : (ZBUFFv04_DCtx*)*legacyContext;\n            if (dctx==NULL) return ERROR(memory_allocation);\n            ZBUFFv04_decompressInit(dctx);\n            ZBUFFv04_decompressWithDictionary(dctx, dict, dictSize);\n            *legacyContext = dctx;\n            return 0;\n        }\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 5)\n        case 5 :\n        {\n            ZBUFFv05_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv05_createDCtx() : (ZBUFFv05_DCtx*)*legacyContext;\n            if (dctx==NULL) return ERROR(memory_allocation);\n            ZBUFFv05_decompressInitDictionary(dctx, dict, dictSize);\n            *legacyContext = dctx;\n            return 0;\n        }\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 6)\n        case 6 :\n        {\n            ZBUFFv06_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv06_createDCtx() : (ZBUFFv06_DCtx*)*legacyContext;\n            if (dctx==NULL) return ERROR(memory_allocation);\n            ZBUFFv06_decompressInitDictionary(dctx, dict, dictSize);\n            *legacyContext = dctx;\n            return 0;\n        }\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 7)\n        case 7 :\n        {\n            ZBUFFv07_DCtx* dctx = (prevVersion != newVersion) ? ZBUFFv07_createDCtx() : (ZBUFFv07_DCtx*)*legacyContext;\n            if (dctx==NULL) return ERROR(memory_allocation);\n            ZBUFFv07_decompressInitDictionary(dctx, dict, dictSize);\n            *legacyContext = dctx;\n            return 0;\n        }\n#endif\n    }\n}\n\n\n\nMEM_STATIC size_t ZSTD_decompressLegacyStream(void* legacyContext, U32 version,\n                                              ZSTD_outBuffer* output, ZSTD_inBuffer* input)\n{\n    static char x;\n    /* Avoid passing NULL to legacy decoding. */\n    if (output->dst == NULL) {\n        assert(output->size == 0);\n        output->dst = &x;\n    }\n    if (input->src == NULL) {\n        assert(input->size == 0);\n        input->src = &x;\n    }\n    DEBUGLOG(5, \"ZSTD_decompressLegacyStream for v0.%u\", version);\n    switch(version)\n    {\n        default :\n        case 1 :\n        case 2 :\n        case 3 :\n            (void)legacyContext; (void)output; (void)input;\n            return ERROR(version_unsupported);\n#if (ZSTD_LEGACY_SUPPORT <= 4)\n        case 4 :\n            {\n                ZBUFFv04_DCtx* dctx = (ZBUFFv04_DCtx*) legacyContext;\n                const void* src = (const char*)input->src + input->pos;\n                size_t readSize = input->size - input->pos;\n                void* dst = (char*)output->dst + output->pos;\n                size_t decodedSize = output->size - output->pos;\n                size_t const hintSize = ZBUFFv04_decompressContinue(dctx, dst, &decodedSize, src, &readSize);\n                output->pos += decodedSize;\n                input->pos += readSize;\n                return hintSize;\n            }\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 5)\n        case 5 :\n            {\n                ZBUFFv05_DCtx* dctx = (ZBUFFv05_DCtx*) legacyContext;\n                const void* src = (const char*)input->src + input->pos;\n                size_t readSize = input->size - input->pos;\n                void* dst = (char*)output->dst + output->pos;\n                size_t decodedSize = output->size - output->pos;\n                size_t const hintSize = ZBUFFv05_decompressContinue(dctx, dst, &decodedSize, src, &readSize);\n                output->pos += decodedSize;\n                input->pos += readSize;\n                return hintSize;\n            }\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 6)\n        case 6 :\n            {\n                ZBUFFv06_DCtx* dctx = (ZBUFFv06_DCtx*) legacyContext;\n                const void* src = (const char*)input->src + input->pos;\n                size_t readSize = input->size - input->pos;\n                void* dst = (char*)output->dst + output->pos;\n                size_t decodedSize = output->size - output->pos;\n                size_t const hintSize = ZBUFFv06_decompressContinue(dctx, dst, &decodedSize, src, &readSize);\n                output->pos += decodedSize;\n                input->pos += readSize;\n                return hintSize;\n            }\n#endif\n#if (ZSTD_LEGACY_SUPPORT <= 7)\n        case 7 :\n            {\n                ZBUFFv07_DCtx* dctx = (ZBUFFv07_DCtx*) legacyContext;\n                const void* src = (const char*)input->src + input->pos;\n                size_t readSize = input->size - input->pos;\n                void* dst = (char*)output->dst + output->pos;\n                size_t decodedSize = output->size - output->pos;\n                size_t const hintSize = ZBUFFv07_decompressContinue(dctx, dst, &decodedSize, src, &readSize);\n                output->pos += decodedSize;\n                input->pos += readSize;\n                return hintSize;\n            }\n#endif\n    }\n}\n\n\n#if defined (__cplusplus)\n}\n#endif\n\n#endif   /* ZSTD_LEGACY_H */\n"
  },
  {
    "path": "lib/legacy/zstd_v01.c",
    "content": "/*\n * Copyright (c) Yann Collet, Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n\n/******************************************\n*  Includes\n******************************************/\n#include     /* size_t, ptrdiff_t */\n#include \"zstd_v01.h\"\n#include \"../common/compiler.h\"\n#include \"../common/error_private.h\"\n\n\n/******************************************\n*  Static allocation\n******************************************/\n/* You can statically allocate FSE CTable/DTable as a table of unsigned using below macro */\n#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)\n*  Increasing memory usage improves compression ratio\n*  Reduced memory usage can improve speed, due to cache effect\n*  Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */\n#define FSE_MAX_MEMORY_USAGE 14\n#define FSE_DEFAULT_MEMORY_USAGE 13\n\n/* FSE_MAX_SYMBOL_VALUE :\n*  Maximum symbol value authorized.\n*  Required for proper stack allocation */\n#define FSE_MAX_SYMBOL_VALUE 255\n\n\n/****************************************************************\n*  template functions type & suffix\n****************************************************************/\n#define FSE_FUNCTION_TYPE BYTE\n#define FSE_FUNCTION_EXTENSION\n\n\n/****************************************************************\n*  Byte symbol type\n****************************************************************/\ntypedef struct\n{\n    unsigned short newState;\n    unsigned char  symbol;\n    unsigned char  nbBits;\n} FSE_decode_t;   /* size == U32 */\n\n\n\n/****************************************************************\n*  Compiler specifics\n****************************************************************/\n#ifdef _MSC_VER    /* Visual Studio */\n#  define FORCE_INLINE static __forceinline\n#  include                     /* For Visual 2005 */\n#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */\n#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */\n#else\n#  define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)\n#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */\n#    ifdef __GNUC__\n#      define FORCE_INLINE static inline __attribute__((always_inline))\n#    else\n#      define FORCE_INLINE static inline\n#    endif\n#  else\n#    define FORCE_INLINE static\n#  endif /* __STDC_VERSION__ */\n#endif\n\n\n/****************************************************************\n*  Includes\n****************************************************************/\n#include      /* malloc, free, qsort */\n#include      /* memcpy, memset */\n#include       /* printf (debug) */\n\n\n#ifndef MEM_ACCESS_MODULE\n#define MEM_ACCESS_MODULE\n/****************************************************************\n*  Basic Types\n*****************************************************************/\n#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */\n# include \ntypedef  uint8_t BYTE;\ntypedef uint16_t U16;\ntypedef  int16_t S16;\ntypedef uint32_t U32;\ntypedef  int32_t S32;\ntypedef uint64_t U64;\ntypedef  int64_t S64;\n#else\ntypedef unsigned char       BYTE;\ntypedef unsigned short      U16;\ntypedef   signed short      S16;\ntypedef unsigned int        U32;\ntypedef   signed int        S32;\ntypedef unsigned long long  U64;\ntypedef   signed long long  S64;\n#endif\n\n#endif   /* MEM_ACCESS_MODULE */\n\n/****************************************************************\n*  Memory I/O\n*****************************************************************/\n\nstatic unsigned FSE_32bits(void)\n{\n    return sizeof(void*)==4;\n}\n\nstatic unsigned FSE_isLittleEndian(void)\n{\n    const union { U32 i; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */\n    return one.c[0];\n}\n\nstatic U16 FSE_read16(const void* memPtr)\n{\n    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;\n}\n\nstatic U32 FSE_read32(const void* memPtr)\n{\n    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;\n}\n\nstatic U64 FSE_read64(const void* memPtr)\n{\n    U64 val; memcpy(&val, memPtr, sizeof(val)); return val;\n}\n\nstatic U16 FSE_readLE16(const void* memPtr)\n{\n    if (FSE_isLittleEndian())\n        return FSE_read16(memPtr);\n    else\n    {\n        const BYTE* p = (const BYTE*)memPtr;\n        return (U16)(p[0] + (p[1]<<8));\n    }\n}\n\nstatic U32 FSE_readLE32(const void* memPtr)\n{\n    if (FSE_isLittleEndian())\n        return FSE_read32(memPtr);\n    else\n    {\n        const BYTE* p = (const BYTE*)memPtr;\n        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));\n    }\n}\n\n\nstatic U64 FSE_readLE64(const void* memPtr)\n{\n    if (FSE_isLittleEndian())\n        return FSE_read64(memPtr);\n    else\n    {\n        const BYTE* p = (const BYTE*)memPtr;\n        return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)\n                     + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));\n    }\n}\n\nstatic size_t FSE_readLEST(const void* memPtr)\n{\n    if (FSE_32bits())\n        return (size_t)FSE_readLE32(memPtr);\n    else\n        return (size_t)FSE_readLE64(memPtr);\n}\n\n\n\n/****************************************************************\n*  Constants\n*****************************************************************/\n#define FSE_MAX_TABLELOG  (FSE_MAX_MEMORY_USAGE-2)\n#define FSE_MAX_TABLESIZE (1U< FSE_TABLELOG_ABSOLUTE_MAX\n#error \"FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported\"\n#endif\n\n\n/****************************************************************\n*  Error Management\n****************************************************************/\n#define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */\n\n\n/****************************************************************\n*  Complex types\n****************************************************************/\ntypedef struct\n{\n    int deltaFindState;\n    U32 deltaNbBits;\n} FSE_symbolCompressionTransform; /* total 8 bytes */\n\ntypedef U32 DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];\n\n/****************************************************************\n*  Internal functions\n****************************************************************/\nFORCE_INLINE unsigned FSE_highbit32 (U32 val)\n{\n#   if defined(_MSC_VER)   /* Visual */\n    unsigned long r;\n    return _BitScanReverse(&r, val) ? (unsigned)r : 0;\n#   elif defined(__GNUC__) && (GCC_VERSION >= 304)   /* GCC Intrinsic */\n    return __builtin_clz (val) ^ 31;\n#   else   /* Software version */\n    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };\n    U32 v = val;\n    unsigned r;\n    v |= v >> 1;\n    v |= v >> 2;\n    v |= v >> 4;\n    v |= v >> 8;\n    v |= v >> 16;\n    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];\n    return r;\n#   endif\n}\n\n\n/****************************************************************\n*  Templates\n****************************************************************/\n/*\n  designed to be included\n  for type-specific functions (template emulation in C)\n  Objective is to write these functions only once, for improved maintenance\n*/\n\n/* safety checks */\n#ifndef FSE_FUNCTION_EXTENSION\n#  error \"FSE_FUNCTION_EXTENSION must be defined\"\n#endif\n#ifndef FSE_FUNCTION_TYPE\n#  error \"FSE_FUNCTION_TYPE must be defined\"\n#endif\n\n/* Function names */\n#define FSE_CAT(X,Y) X##Y\n#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)\n#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)\n\n\n\nstatic U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; }\n\n#define FSE_DECODE_TYPE FSE_decode_t\n\n\ntypedef struct {\n    U16 tableLog;\n    U16 fastMode;\n} FSE_DTableHeader;   /* sizeof U32 */\n\nstatic size_t FSE_buildDTable\n(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)\n{\n    void* ptr = dt;\n    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;\n    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*)(ptr) + 1;   /* because dt is unsigned, 32-bits aligned on 32-bits */\n    const U32 tableSize = 1 << tableLog;\n    const U32 tableMask = tableSize-1;\n    const U32 step = FSE_tableStep(tableSize);\n    U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1];\n    U32 position = 0;\n    U32 highThreshold = tableSize-1;\n    const S16 largeLimit= (S16)(1 << (tableLog-1));\n    U32 noLarge = 1;\n    U32 s;\n\n    /* Sanity Checks */\n    if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return (size_t)-FSE_ERROR_maxSymbolValue_tooLarge;\n    if (tableLog > FSE_MAX_TABLELOG) return (size_t)-FSE_ERROR_tableLog_tooLarge;\n\n    /* Init, lay down lowprob symbols */\n    DTableH[0].tableLog = (U16)tableLog;\n    for (s=0; s<=maxSymbolValue; s++)\n    {\n        if (normalizedCounter[s]==-1)\n        {\n            tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;\n            symbolNext[s] = 1;\n        }\n        else\n        {\n            if (normalizedCounter[s] >= largeLimit) noLarge=0;\n            symbolNext[s] = normalizedCounter[s];\n        }\n    }\n\n    /* Spread symbols */\n    for (s=0; s<=maxSymbolValue; s++)\n    {\n        int i;\n        for (i=0; i highThreshold) position = (position + step) & tableMask;   /* lowprob area */\n        }\n    }\n\n    if (position!=0) return (size_t)-FSE_ERROR_GENERIC;   /* position must reach all cells once, otherwise normalizedCounter is incorrect */\n\n    /* Build Decoding table */\n    {\n        U32 i;\n        for (i=0; ifastMode = (U16)noLarge;\n    return 0;\n}\n\n\n/******************************************\n*  FSE byte symbol\n******************************************/\n#ifndef FSE_COMMONDEFS_ONLY\n\nstatic unsigned FSE_isError(size_t code) { return (code > (size_t)(-FSE_ERROR_maxCode)); }\n\nstatic short FSE_abs(short a)\n{\n    return a<0? (short)-a : a;\n}\n\n\n/****************************************************************\n*  Header bitstream management\n****************************************************************/\nstatic size_t FSE_readNCount (short* normalizedCounter, unsigned* maxSVPtr, unsigned* tableLogPtr,\n                 const void* headerBuffer, size_t hbSize)\n{\n    const BYTE* const istart = (const BYTE*) headerBuffer;\n    const BYTE* const iend = istart + hbSize;\n    const BYTE* ip = istart;\n    int nbBits;\n    int remaining;\n    int threshold;\n    U32 bitStream;\n    int bitCount;\n    unsigned charnum = 0;\n    int previous0 = 0;\n\n    if (hbSize < 4) return (size_t)-FSE_ERROR_srcSize_wrong;\n    bitStream = FSE_readLE32(ip);\n    nbBits = (bitStream & 0xF) + FSE_MIN_TABLELOG;   /* extract tableLog */\n    if (nbBits > FSE_TABLELOG_ABSOLUTE_MAX) return (size_t)-FSE_ERROR_tableLog_tooLarge;\n    bitStream >>= 4;\n    bitCount = 4;\n    *tableLogPtr = nbBits;\n    remaining = (1<1) && (charnum<=*maxSVPtr))\n    {\n        if (previous0)\n        {\n            unsigned n0 = charnum;\n            while ((bitStream & 0xFFFF) == 0xFFFF)\n            {\n                n0+=24;\n                if (ip < iend-5)\n                {\n                    ip+=2;\n                    bitStream = FSE_readLE32(ip) >> bitCount;\n                }\n                else\n                {\n                    bitStream >>= 16;\n                    bitCount+=16;\n                }\n            }\n            while ((bitStream & 3) == 3)\n            {\n                n0+=3;\n                bitStream>>=2;\n                bitCount+=2;\n            }\n            n0 += bitStream & 3;\n            bitCount += 2;\n            if (n0 > *maxSVPtr) return (size_t)-FSE_ERROR_maxSymbolValue_tooSmall;\n            while (charnum < n0) normalizedCounter[charnum++] = 0;\n            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))\n            {\n                ip += bitCount>>3;\n                bitCount &= 7;\n                bitStream = FSE_readLE32(ip) >> bitCount;\n            }\n            else\n                bitStream >>= 2;\n        }\n        {\n            const short max = (short)((2*threshold-1)-remaining);\n            short count;\n\n            if ((bitStream & (threshold-1)) < (U32)max)\n            {\n                count = (short)(bitStream & (threshold-1));\n                bitCount   += nbBits-1;\n            }\n            else\n            {\n                count = (short)(bitStream & (2*threshold-1));\n                if (count >= threshold) count -= max;\n                bitCount   += nbBits;\n            }\n\n            count--;   /* extra accuracy */\n            remaining -= FSE_abs(count);\n            normalizedCounter[charnum++] = count;\n            previous0 = !count;\n            while (remaining < threshold)\n            {\n                nbBits--;\n                threshold >>= 1;\n            }\n\n            {\n                if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))\n                {\n                    ip += bitCount>>3;\n                    bitCount &= 7;\n                }\n                else\n                {\n                    bitCount -= (int)(8 * (iend - 4 - ip));\n                    ip = iend - 4;\n                }\n                bitStream = FSE_readLE32(ip) >> (bitCount & 31);\n            }\n        }\n    }\n    if (remaining != 1) return (size_t)-FSE_ERROR_GENERIC;\n    *maxSVPtr = charnum-1;\n\n    ip += (bitCount+7)>>3;\n    if ((size_t)(ip-istart) > hbSize) return (size_t)-FSE_ERROR_srcSize_wrong;\n    return ip-istart;\n}\n\n\n/*********************************************************\n*  Decompression (Byte symbols)\n*********************************************************/\nstatic size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)\n{\n    void* ptr = dt;\n    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;\n    FSE_decode_t* const cell = (FSE_decode_t*)(ptr) + 1;   /* because dt is unsigned */\n\n    DTableH->tableLog = 0;\n    DTableH->fastMode = 0;\n\n    cell->newState = 0;\n    cell->symbol = symbolValue;\n    cell->nbBits = 0;\n\n    return 0;\n}\n\n\nstatic size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)\n{\n    void* ptr = dt;\n    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;\n    FSE_decode_t* const dinfo = (FSE_decode_t*)(ptr) + 1;   /* because dt is unsigned */\n    const unsigned tableSize = 1 << nbBits;\n    const unsigned tableMask = tableSize - 1;\n    const unsigned maxSymbolValue = tableMask;\n    unsigned s;\n\n    /* Sanity checks */\n    if (nbBits < 1) return (size_t)-FSE_ERROR_GENERIC;             /* min size */\n\n    /* Build Decoding Table */\n    DTableH->tableLog = (U16)nbBits;\n    DTableH->fastMode = 1;\n    for (s=0; s<=maxSymbolValue; s++)\n    {\n        dinfo[s].newState = 0;\n        dinfo[s].symbol = (BYTE)s;\n        dinfo[s].nbBits = (BYTE)nbBits;\n    }\n\n    return 0;\n}\n\n\n/* FSE_initDStream\n * Initialize a FSE_DStream_t.\n * srcBuffer must point at the beginning of an FSE block.\n * The function result is the size of the FSE_block (== srcSize).\n * If srcSize is too small, the function will return an errorCode;\n */\nstatic size_t FSE_initDStream(FSE_DStream_t* bitD, const void* srcBuffer, size_t srcSize)\n{\n    if (srcSize < 1) return (size_t)-FSE_ERROR_srcSize_wrong;\n\n    if (srcSize >=  sizeof(size_t))\n    {\n        U32 contain32;\n        bitD->start = (const char*)srcBuffer;\n        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(size_t);\n        bitD->bitContainer = FSE_readLEST(bitD->ptr);\n        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];\n        if (contain32 == 0) return (size_t)-FSE_ERROR_GENERIC;   /* stop bit not present */\n        bitD->bitsConsumed = 8 - FSE_highbit32(contain32);\n    }\n    else\n    {\n        U32 contain32;\n        bitD->start = (const char*)srcBuffer;\n        bitD->ptr   = bitD->start;\n        bitD->bitContainer = *(const BYTE*)(bitD->start);\n        switch(srcSize)\n        {\n            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16);\n                    /* fallthrough */\n            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);\n                    /* fallthrough */\n            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);\n                    /* fallthrough */\n            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24;\n                    /* fallthrough */\n            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16;\n                    /* fallthrough */\n            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8;\n                    /* fallthrough */\n            default:;\n        }\n        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];\n        if (contain32 == 0) return (size_t)-FSE_ERROR_GENERIC;   /* stop bit not present */\n        bitD->bitsConsumed = 8 - FSE_highbit32(contain32);\n        bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8;\n    }\n\n    return srcSize;\n}\n\n\n/*!FSE_lookBits\n * Provides next n bits from the bitContainer.\n * bitContainer is not modified (bits are still present for next read/look)\n * On 32-bits, maxNbBits==25\n * On 64-bits, maxNbBits==57\n * return : value extracted.\n */\nstatic size_t FSE_lookBits(FSE_DStream_t* bitD, U32 nbBits)\n{\n    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;\n    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);\n}\n\nstatic size_t FSE_lookBitsFast(FSE_DStream_t* bitD, U32 nbBits)   /* only if nbBits >= 1 !! */\n{\n    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;\n    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);\n}\n\nstatic void FSE_skipBits(FSE_DStream_t* bitD, U32 nbBits)\n{\n    bitD->bitsConsumed += nbBits;\n}\n\n\n/*!FSE_readBits\n * Read next n bits from the bitContainer.\n * On 32-bits, don't read more than maxNbBits==25\n * On 64-bits, don't read more than maxNbBits==57\n * Use the fast variant *only* if n >= 1.\n * return : value extracted.\n */\nstatic size_t FSE_readBits(FSE_DStream_t* bitD, U32 nbBits)\n{\n    size_t value = FSE_lookBits(bitD, nbBits);\n    FSE_skipBits(bitD, nbBits);\n    return value;\n}\n\nstatic size_t FSE_readBitsFast(FSE_DStream_t* bitD, U32 nbBits)   /* only if nbBits >= 1 !! */\n{\n    size_t value = FSE_lookBitsFast(bitD, nbBits);\n    FSE_skipBits(bitD, nbBits);\n    return value;\n}\n\nstatic unsigned FSE_reloadDStream(FSE_DStream_t* bitD)\n{\n    if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */\n        return FSE_DStream_tooFar;\n\n    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer))\n    {\n        bitD->ptr -= bitD->bitsConsumed >> 3;\n        bitD->bitsConsumed &= 7;\n        bitD->bitContainer = FSE_readLEST(bitD->ptr);\n        return FSE_DStream_unfinished;\n    }\n    if (bitD->ptr == bitD->start)\n    {\n        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return FSE_DStream_endOfBuffer;\n        return FSE_DStream_completed;\n    }\n    {\n        U32 nbBytes = bitD->bitsConsumed >> 3;\n        U32 result = FSE_DStream_unfinished;\n        if (bitD->ptr - nbBytes < bitD->start)\n        {\n            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */\n            result = FSE_DStream_endOfBuffer;\n        }\n        bitD->ptr -= nbBytes;\n        bitD->bitsConsumed -= nbBytes*8;\n        bitD->bitContainer = FSE_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */\n        return result;\n    }\n}\n\n\nstatic void FSE_initDState(FSE_DState_t* DStatePtr, FSE_DStream_t* bitD, const FSE_DTable* dt)\n{\n    const void* ptr = dt;\n    const FSE_DTableHeader* const DTableH = (const FSE_DTableHeader*)ptr;\n    DStatePtr->state = FSE_readBits(bitD, DTableH->tableLog);\n    FSE_reloadDStream(bitD);\n    DStatePtr->table = dt + 1;\n}\n\nstatic BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, FSE_DStream_t* bitD)\n{\n    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];\n    const U32  nbBits = DInfo.nbBits;\n    BYTE symbol = DInfo.symbol;\n    size_t lowBits = FSE_readBits(bitD, nbBits);\n\n    DStatePtr->state = DInfo.newState + lowBits;\n    return symbol;\n}\n\nstatic BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, FSE_DStream_t* bitD)\n{\n    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];\n    const U32 nbBits = DInfo.nbBits;\n    BYTE symbol = DInfo.symbol;\n    size_t lowBits = FSE_readBitsFast(bitD, nbBits);\n\n    DStatePtr->state = DInfo.newState + lowBits;\n    return symbol;\n}\n\n/* FSE_endOfDStream\n   Tells if bitD has reached end of bitStream or not */\n\nstatic unsigned FSE_endOfDStream(const FSE_DStream_t* bitD)\n{\n    return ((bitD->ptr == bitD->start) && (bitD->bitsConsumed == sizeof(bitD->bitContainer)*8));\n}\n\nstatic unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)\n{\n    return DStatePtr->state == 0;\n}\n\n\nFORCE_INLINE size_t FSE_decompress_usingDTable_generic(\n          void* dst, size_t maxDstSize,\n    const void* cSrc, size_t cSrcSize,\n    const FSE_DTable* dt, const unsigned fast)\n{\n    BYTE* const ostart = (BYTE*) dst;\n    BYTE* op = ostart;\n    BYTE* const omax = op + maxDstSize;\n    BYTE* const olimit = omax-3;\n\n    FSE_DStream_t bitD;\n    FSE_DState_t state1;\n    FSE_DState_t state2;\n    size_t errorCode;\n\n    /* Init */\n    errorCode = FSE_initDStream(&bitD, cSrc, cSrcSize);   /* replaced last arg by maxCompressed Size */\n    if (FSE_isError(errorCode)) return errorCode;\n\n    FSE_initDState(&state1, &bitD, dt);\n    FSE_initDState(&state2, &bitD, dt);\n\n#define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD)\n\n    /* 4 symbols per loop */\n    for ( ; (FSE_reloadDStream(&bitD)==FSE_DStream_unfinished) && (op sizeof(bitD.bitContainer)*8)    /* This test must be static */\n            FSE_reloadDStream(&bitD);\n\n        op[1] = FSE_GETSYMBOL(&state2);\n\n        if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */\n            { if (FSE_reloadDStream(&bitD) > FSE_DStream_unfinished) { op+=2; break; } }\n\n        op[2] = FSE_GETSYMBOL(&state1);\n\n        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */\n            FSE_reloadDStream(&bitD);\n\n        op[3] = FSE_GETSYMBOL(&state2);\n    }\n\n    /* tail */\n    /* note : FSE_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly FSE_DStream_completed */\n    while (1)\n    {\n        if ( (FSE_reloadDStream(&bitD)>FSE_DStream_completed) || (op==omax) || (FSE_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) )\n            break;\n\n        *op++ = FSE_GETSYMBOL(&state1);\n\n        if ( (FSE_reloadDStream(&bitD)>FSE_DStream_completed) || (op==omax) || (FSE_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) )\n            break;\n\n        *op++ = FSE_GETSYMBOL(&state2);\n    }\n\n    /* end ? */\n    if (FSE_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2))\n        return op-ostart;\n\n    if (op==omax) return (size_t)-FSE_ERROR_dstSize_tooSmall;   /* dst buffer is full, but cSrc unfinished */\n\n    return (size_t)-FSE_ERROR_corruptionDetected;\n}\n\n\nstatic size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,\n                            const void* cSrc, size_t cSrcSize,\n                            const FSE_DTable* dt)\n{\n    FSE_DTableHeader DTableH;\n    memcpy(&DTableH, dt, sizeof(DTableH));   /* memcpy() into local variable, to avoid strict aliasing warning */\n\n    /* select fast mode (static) */\n    if (DTableH.fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);\n    return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);\n}\n\n\nstatic size_t FSE_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)\n{\n    const BYTE* const istart = (const BYTE*)cSrc;\n    const BYTE* ip = istart;\n    short counting[FSE_MAX_SYMBOL_VALUE+1];\n    DTable_max_t dt;   /* Static analyzer seems unable to understand this table will be properly initialized later */\n    unsigned tableLog;\n    unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;\n    size_t errorCode;\n\n    if (cSrcSize<2) return (size_t)-FSE_ERROR_srcSize_wrong;   /* too small input size */\n\n    /* normal FSE decoding mode */\n    errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);\n    if (FSE_isError(errorCode)) return errorCode;\n    if (errorCode >= cSrcSize) return (size_t)-FSE_ERROR_srcSize_wrong;   /* too small input size */\n    ip += errorCode;\n    cSrcSize -= errorCode;\n\n    errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog);\n    if (FSE_isError(errorCode)) return errorCode;\n\n    /* always return, even if it is an error code */\n    return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);\n}\n\n\n\n/* *******************************************************\n*  Huff0 : Huffman block compression\n*********************************************************/\n#define HUF_MAX_SYMBOL_VALUE 255\n#define HUF_DEFAULT_TABLELOG  12       /* used by default, when not specified */\n#define HUF_MAX_TABLELOG  12           /* max possible tableLog; for allocation purpose; can be modified */\n#define HUF_ABSOLUTEMAX_TABLELOG  16   /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */\n#if (HUF_MAX_TABLELOG > HUF_ABSOLUTEMAX_TABLELOG)\n#  error \"HUF_MAX_TABLELOG is too large !\"\n#endif\n\ntypedef struct HUF_CElt_s {\n  U16  val;\n  BYTE nbBits;\n} HUF_CElt ;\n\ntypedef struct nodeElt_s {\n    U32 count;\n    U16 parent;\n    BYTE byte;\n    BYTE nbBits;\n} nodeElt;\n\n\n/* *******************************************************\n*  Huff0 : Huffman block decompression\n*********************************************************/\ntypedef struct {\n    BYTE byte;\n    BYTE nbBits;\n} HUF_DElt;\n\nstatic size_t HUF_readDTable (U16* DTable, const void* src, size_t srcSize)\n{\n    BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1];\n    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];  /* large enough for values from 0 to 16 */\n    U32 weightTotal;\n    U32 maxBits;\n    const BYTE* ip = (const BYTE*) src;\n    size_t iSize;\n    size_t oSize;\n    U32 n;\n    U32 nextRankStart;\n    void* ptr = DTable+1;\n    HUF_DElt* const dt = (HUF_DElt*)ptr;\n\n    if (!srcSize) return (size_t)-FSE_ERROR_srcSize_wrong;\n    iSize = ip[0];\n\n    FSE_STATIC_ASSERT(sizeof(HUF_DElt) == sizeof(U16));   /* if compilation fails here, assertion is false */\n    //memset(huffWeight, 0, sizeof(huffWeight));   /* should not be necessary, but some analyzer complain ... */\n    if (iSize >= 128)  /* special header */\n    {\n        if (iSize >= (242))   /* RLE */\n        {\n            static int l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };\n            oSize = l[iSize-242];\n            memset(huffWeight, 1, sizeof(huffWeight));\n            iSize = 0;\n        }\n        else   /* Incompressible */\n        {\n            oSize = iSize - 127;\n            iSize = ((oSize+1)/2);\n            if (iSize+1 > srcSize) return (size_t)-FSE_ERROR_srcSize_wrong;\n            ip += 1;\n            for (n=0; n> 4;\n                huffWeight[n+1] = ip[n/2] & 15;\n            }\n        }\n    }\n    else  /* header compressed with FSE (normal case) */\n    {\n        if (iSize+1 > srcSize) return (size_t)-FSE_ERROR_srcSize_wrong;\n        oSize = FSE_decompress(huffWeight, HUF_MAX_SYMBOL_VALUE, ip+1, iSize);   /* max 255 values decoded, last one is implied */\n        if (FSE_isError(oSize)) return oSize;\n    }\n\n    /* collect weight stats */\n    memset(rankVal, 0, sizeof(rankVal));\n    weightTotal = 0;\n    for (n=0; n= HUF_ABSOLUTEMAX_TABLELOG) return (size_t)-FSE_ERROR_corruptionDetected;\n        rankVal[huffWeight[n]]++;\n        weightTotal += (1 << huffWeight[n]) >> 1;\n    }\n    if (weightTotal == 0) return (size_t)-FSE_ERROR_corruptionDetected;\n\n    /* get last non-null symbol weight (implied, total must be 2^n) */\n    maxBits = FSE_highbit32(weightTotal) + 1;\n    if (maxBits > DTable[0]) return (size_t)-FSE_ERROR_tableLog_tooLarge;   /* DTable is too small */\n    DTable[0] = (U16)maxBits;\n    {\n        U32 total = 1 << maxBits;\n        U32 rest = total - weightTotal;\n        U32 verif = 1 << FSE_highbit32(rest);\n        U32 lastWeight = FSE_highbit32(rest) + 1;\n        if (verif != rest) return (size_t)-FSE_ERROR_corruptionDetected;    /* last value must be a clean power of 2 */\n        huffWeight[oSize] = (BYTE)lastWeight;\n        rankVal[lastWeight]++;\n    }\n\n    /* check tree construction validity */\n    if ((rankVal[1] < 2) || (rankVal[1] & 1)) return (size_t)-FSE_ERROR_corruptionDetected;   /* by construction : at least 2 elts of rank 1, must be even */\n\n    /* Prepare ranks */\n    nextRankStart = 0;\n    for (n=1; n<=maxBits; n++)\n    {\n        U32 current = nextRankStart;\n        nextRankStart += (rankVal[n] << (n-1));\n        rankVal[n] = current;\n    }\n\n    /* fill DTable */\n    for (n=0; n<=oSize; n++)\n    {\n        const U32 w = huffWeight[n];\n        const U32 length = (1 << w) >> 1;\n        U32 i;\n        HUF_DElt D;\n        D.byte = (BYTE)n; D.nbBits = (BYTE)(maxBits + 1 - w);\n        for (i = rankVal[w]; i < rankVal[w] + length; i++)\n            dt[i] = D;\n        rankVal[w] += length;\n    }\n\n    return iSize+1;\n}\n\n\nstatic BYTE HUF_decodeSymbol(FSE_DStream_t* Dstream, const HUF_DElt* dt, const U32 dtLog)\n{\n        const size_t val = FSE_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */\n        const BYTE c = dt[val].byte;\n        FSE_skipBits(Dstream, dt[val].nbBits);\n        return c;\n}\n\nstatic size_t HUF_decompress_usingDTable(   /* -3% slower when non static */\n          void* dst, size_t maxDstSize,\n    const void* cSrc, size_t cSrcSize,\n    const U16* DTable)\n{\n    if (cSrcSize < 6) return (size_t)-FSE_ERROR_srcSize_wrong;\n    {\n        BYTE* const ostart = (BYTE*) dst;\n        BYTE* op = ostart;\n        BYTE* const omax = op + maxDstSize;\n        BYTE* const olimit = maxDstSize < 15 ? op : omax-15;\n\n        const void* ptr = DTable;\n        const HUF_DElt* const dt = (const HUF_DElt*)(ptr)+1;\n        const U32 dtLog = DTable[0];\n        size_t errorCode;\n        U32 reloadStatus;\n\n        /* Init */\n\n        const U16* jumpTable = (const U16*)cSrc;\n        const size_t length1 = FSE_readLE16(jumpTable);\n        const size_t length2 = FSE_readLE16(jumpTable+1);\n        const size_t length3 = FSE_readLE16(jumpTable+2);\n        const size_t length4 = cSrcSize - 6 - length1 - length2 - length3;   /* check coherency !! */\n        const char* const start1 = (const char*)(cSrc) + 6;\n        const char* const start2 = start1 + length1;\n        const char* const start3 = start2 + length2;\n        const char* const start4 = start3 + length3;\n        FSE_DStream_t bitD1, bitD2, bitD3, bitD4;\n\n        if (length1+length2+length3+6 >= cSrcSize) return (size_t)-FSE_ERROR_srcSize_wrong;\n\n        errorCode = FSE_initDStream(&bitD1, start1, length1);\n        if (FSE_isError(errorCode)) return errorCode;\n        errorCode = FSE_initDStream(&bitD2, start2, length2);\n        if (FSE_isError(errorCode)) return errorCode;\n        errorCode = FSE_initDStream(&bitD3, start3, length3);\n        if (FSE_isError(errorCode)) return errorCode;\n        errorCode = FSE_initDStream(&bitD4, start4, length4);\n        if (FSE_isError(errorCode)) return errorCode;\n\n        reloadStatus=FSE_reloadDStream(&bitD2);\n\n        /* 16 symbols per loop */\n        for ( ; (reloadStatus12)) FSE_reloadDStream(&Dstream)\n\n    #define HUF_DECODE_SYMBOL_2(n, Dstream) \\\n            op[n] = HUF_decodeSymbol(&Dstream, dt, dtLog); \\\n            if (FSE_32bits()) FSE_reloadDStream(&Dstream)\n\n            HUF_DECODE_SYMBOL_1( 0, bitD1);\n            HUF_DECODE_SYMBOL_1( 1, bitD2);\n            HUF_DECODE_SYMBOL_1( 2, bitD3);\n            HUF_DECODE_SYMBOL_1( 3, bitD4);\n            HUF_DECODE_SYMBOL_2( 4, bitD1);\n            HUF_DECODE_SYMBOL_2( 5, bitD2);\n            HUF_DECODE_SYMBOL_2( 6, bitD3);\n            HUF_DECODE_SYMBOL_2( 7, bitD4);\n            HUF_DECODE_SYMBOL_1( 8, bitD1);\n            HUF_DECODE_SYMBOL_1( 9, bitD2);\n            HUF_DECODE_SYMBOL_1(10, bitD3);\n            HUF_DECODE_SYMBOL_1(11, bitD4);\n            HUF_DECODE_SYMBOL_0(12, bitD1);\n            HUF_DECODE_SYMBOL_0(13, bitD2);\n            HUF_DECODE_SYMBOL_0(14, bitD3);\n            HUF_DECODE_SYMBOL_0(15, bitD4);\n        }\n\n        if (reloadStatus!=FSE_DStream_completed)   /* not complete : some bitStream might be FSE_DStream_unfinished */\n            return (size_t)-FSE_ERROR_corruptionDetected;\n\n        /* tail */\n        {\n            /* bitTail = bitD1; */   /* *much* slower : -20% !??! */\n            FSE_DStream_t bitTail;\n            bitTail.ptr = bitD1.ptr;\n            bitTail.bitsConsumed = bitD1.bitsConsumed;\n            bitTail.bitContainer = bitD1.bitContainer;   /* required in case of FSE_DStream_endOfBuffer */\n            bitTail.start = start1;\n            for ( ; (FSE_reloadDStream(&bitTail) < FSE_DStream_completed) && (op= cSrcSize) return (size_t)-FSE_ERROR_srcSize_wrong;\n    ip += errorCode;\n    cSrcSize -= errorCode;\n\n    return HUF_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, DTable);\n}\n\n\n#endif   /* FSE_COMMONDEFS_ONLY */\n\n/*\n    zstd - standard compression library\n    Copyright (C) 2014-2015, Yann Collet.\n\n    BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php)\n\n    Redistribution and use in source and binary forms, with or without\n    modification, are permitted provided that the following conditions are\n    met:\n    * Redistributions of source code must retain the above copyright\n    notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above\n    copyright notice, this list of conditions and the following disclaimer\n    in the documentation and/or other materials provided with the\n    distribution.\n    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n    \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n    You can contact the author at :\n    - zstd source repository : https://github.com/Cyan4973/zstd\n    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c\n*/\n\n/****************************************************************\n*  Tuning parameters\n*****************************************************************/\n/* MEMORY_USAGE :\n*  Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)\n*  Increasing memory usage improves compression ratio\n*  Reduced memory usage can improve speed, due to cache effect */\n#define ZSTD_MEMORY_USAGE 17\n\n\n/**************************************\n   CPU Feature Detection\n**************************************/\n/*\n * Automated efficient unaligned memory access detection\n * Based on known hardware architectures\n * This list will be updated thanks to feedbacks\n */\n#if defined(CPU_HAS_EFFICIENT_UNALIGNED_MEMORY_ACCESS) \\\n    || defined(__ARM_FEATURE_UNALIGNED) \\\n    || defined(__i386__) || defined(__x86_64__) \\\n    || defined(_M_IX86) || defined(_M_X64) \\\n    || defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_8__) \\\n    || (defined(_M_ARM) && (_M_ARM >= 7))\n#  define ZSTD_UNALIGNED_ACCESS 1\n#else\n#  define ZSTD_UNALIGNED_ACCESS 0\n#endif\n\n\n/********************************************************\n*  Includes\n*********************************************************/\n#include       /* calloc */\n#include       /* memcpy, memmove */\n#include        /* debug : printf */\n\n\n/********************************************************\n*  Compiler specifics\n*********************************************************/\n#ifdef __AVX2__\n#  include    /* AVX2 intrinsics */\n#endif\n\n#ifdef _MSC_VER    /* Visual Studio */\n#  include                     /* For Visual 2005 */\n#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */\n#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */\n#endif\n\n\n#ifndef MEM_ACCESS_MODULE\n#define MEM_ACCESS_MODULE\n/********************************************************\n*  Basic Types\n*********************************************************/\n#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */\n# if defined(_AIX)\n#  include \n# else\n#  include  /* intptr_t */\n# endif\ntypedef  uint8_t BYTE;\ntypedef uint16_t U16;\ntypedef  int16_t S16;\ntypedef uint32_t U32;\ntypedef  int32_t S32;\ntypedef uint64_t U64;\n#else\ntypedef unsigned char       BYTE;\ntypedef unsigned short      U16;\ntypedef   signed short      S16;\ntypedef unsigned int        U32;\ntypedef   signed int        S32;\ntypedef unsigned long long  U64;\n#endif\n\n#endif   /* MEM_ACCESS_MODULE */\n\n\n/********************************************************\n*  Constants\n*********************************************************/\nstatic const U32 ZSTD_magicNumber = 0xFD2FB51E;   /* 3rd version : seqNb header */\n\n#define HASH_LOG (ZSTD_MEMORY_USAGE - 2)\n#define HASH_TABLESIZE (1 << HASH_LOG)\n#define HASH_MASK (HASH_TABLESIZE - 1)\n\n#define KNUTH 2654435761\n\n#define BIT7 128\n#define BIT6  64\n#define BIT5  32\n#define BIT4  16\n\n#define KB *(1 <<10)\n#define MB *(1 <<20)\n#define GB *(1U<<30)\n\n#define BLOCKSIZE (128 KB)                 /* define, for static allocation */\n\n#define WORKPLACESIZE (BLOCKSIZE*3)\n#define MINMATCH 4\n#define MLbits   7\n#define LLbits   6\n#define Offbits  5\n#define MaxML  ((1<>3];\n#else\n    U32 hashTable[HASH_TABLESIZE];\n#endif\n    BYTE buffer[WORKPLACESIZE];\n} cctxi_t;\n\n\n\n\n/**************************************\n*  Error Management\n**************************************/\n/* published entry point */\nunsigned ZSTDv01_isError(size_t code) { return ERR_isError(code); }\n\n\n/**************************************\n*  Tool functions\n**************************************/\n#define ZSTD_VERSION_MAJOR    0    /* for breaking interface changes  */\n#define ZSTD_VERSION_MINOR    1    /* for new (non-breaking) interface capabilities */\n#define ZSTD_VERSION_RELEASE  3    /* for tweaks, bug-fixes, or development */\n#define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)\n\n/**************************************************************\n*   Decompression code\n**************************************************************/\n\nstatic size_t ZSTDv01_getcBlockSize(const void* src, size_t srcSize, blockProperties_t* bpPtr)\n{\n    const BYTE* const in = (const BYTE* const)src;\n    BYTE headerFlags;\n    U32 cSize;\n\n    if (srcSize < 3) return ERROR(srcSize_wrong);\n\n    headerFlags = *in;\n    cSize = in[2] + (in[1]<<8) + ((in[0] & 7)<<16);\n\n    bpPtr->blockType = (blockType_t)(headerFlags >> 6);\n    bpPtr->origSize = (bpPtr->blockType == bt_rle) ? cSize : 0;\n\n    if (bpPtr->blockType == bt_end) return 0;\n    if (bpPtr->blockType == bt_rle) return 1;\n    return cSize;\n}\n\n\nstatic size_t ZSTD_copyUncompressedBlock(void* dst, size_t maxDstSize, const void* src, size_t srcSize)\n{\n    if (srcSize > maxDstSize) return ERROR(dstSize_tooSmall);\n    if (srcSize > 0) {\n        memcpy(dst, src, srcSize);\n    }\n    return srcSize;\n}\n\n\nstatic size_t ZSTD_decompressLiterals(void* ctx,\n                                      void* dst, size_t maxDstSize,\n                                const void* src, size_t srcSize)\n{\n    BYTE* op = (BYTE*)dst;\n    BYTE* const oend = op + maxDstSize;\n    const BYTE* ip = (const BYTE*)src;\n    size_t errorCode;\n    size_t litSize;\n\n    /* check : minimum 2, for litSize, +1, for content */\n    if (srcSize <= 3) return ERROR(corruption_detected);\n\n    litSize = ip[1] + (ip[0]<<8);\n    litSize += ((ip[-3] >> 3) & 7) << 16;   /* mmmmh.... */\n    op = oend - litSize;\n\n    (void)ctx;\n    if (litSize > maxDstSize) return ERROR(dstSize_tooSmall);\n    errorCode = HUF_decompress(op, litSize, ip+2, srcSize-2);\n    if (FSE_isError(errorCode)) return ERROR(GENERIC);\n    return litSize;\n}\n\n\nstatic size_t ZSTDv01_decodeLiteralsBlock(void* ctx,\n                                void* dst, size_t maxDstSize,\n                          const BYTE** litStart, size_t* litSize,\n                          const void* src, size_t srcSize)\n{\n    const BYTE* const istart = (const BYTE* const)src;\n    const BYTE* ip = istart;\n    BYTE* const ostart = (BYTE* const)dst;\n    BYTE* const oend = ostart + maxDstSize;\n    blockProperties_t litbp;\n\n    size_t litcSize = ZSTDv01_getcBlockSize(src, srcSize, &litbp);\n    if (ZSTDv01_isError(litcSize)) return litcSize;\n    if (litcSize > srcSize - ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);\n    ip += ZSTD_blockHeaderSize;\n\n    switch(litbp.blockType)\n    {\n    case bt_raw:\n        *litStart = ip;\n        ip += litcSize;\n        *litSize = litcSize;\n        break;\n    case bt_rle:\n        {\n            size_t rleSize = litbp.origSize;\n            if (rleSize>maxDstSize) return ERROR(dstSize_tooSmall);\n            if (!srcSize) return ERROR(srcSize_wrong);\n            if (rleSize > 0) {\n                memset(oend - rleSize, *ip, rleSize);\n            }\n            *litStart = oend - rleSize;\n            *litSize = rleSize;\n            ip++;\n            break;\n        }\n    case bt_compressed:\n        {\n            size_t decodedLitSize = ZSTD_decompressLiterals(ctx, dst, maxDstSize, ip, litcSize);\n            if (ZSTDv01_isError(decodedLitSize)) return decodedLitSize;\n            *litStart = oend - decodedLitSize;\n            *litSize = decodedLitSize;\n            ip += litcSize;\n            break;\n        }\n    case bt_end:\n    default:\n        return ERROR(GENERIC);\n    }\n\n    return ip-istart;\n}\n\n\nstatic size_t ZSTDv01_decodeSeqHeaders(int* nbSeq, const BYTE** dumpsPtr, size_t* dumpsLengthPtr,\n                         FSE_DTable* DTableLL, FSE_DTable* DTableML, FSE_DTable* DTableOffb,\n                         const void* src, size_t srcSize)\n{\n    const BYTE* const istart = (const BYTE* const)src;\n    const BYTE* ip = istart;\n    const BYTE* const iend = istart + srcSize;\n    U32 LLtype, Offtype, MLtype;\n    U32 LLlog, Offlog, MLlog;\n    size_t dumpsLength;\n\n    /* check */\n    if (srcSize < 5) return ERROR(srcSize_wrong);\n\n    /* SeqHead */\n    *nbSeq = ZSTD_readLE16(ip); ip+=2;\n    LLtype  = *ip >> 6;\n    Offtype = (*ip >> 4) & 3;\n    MLtype  = (*ip >> 2) & 3;\n    if (*ip & 2)\n    {\n        dumpsLength  = ip[2];\n        dumpsLength += ip[1] << 8;\n        ip += 3;\n    }\n    else\n    {\n        dumpsLength  = ip[1];\n        dumpsLength += (ip[0] & 1) << 8;\n        ip += 2;\n    }\n    *dumpsPtr = ip;\n    ip += dumpsLength;\n    *dumpsLengthPtr = dumpsLength;\n\n    /* check */\n    if (ip > iend-3) return ERROR(srcSize_wrong); /* min : all 3 are \"raw\", hence no header, but at least xxLog bits per type */\n\n    /* sequences */\n    {\n        S16 norm[MaxML+1];    /* assumption : MaxML >= MaxLL and MaxOff */\n        size_t headerSize;\n\n        /* Build DTables */\n        switch(LLtype)\n        {\n        case bt_rle :\n            LLlog = 0;\n            FSE_buildDTable_rle(DTableLL, *ip++); break;\n        case bt_raw :\n            LLlog = LLbits;\n            FSE_buildDTable_raw(DTableLL, LLbits); break;\n        default :\n            {   U32 max = MaxLL;\n                headerSize = FSE_readNCount(norm, &max, &LLlog, ip, iend-ip);\n                if (FSE_isError(headerSize)) return ERROR(GENERIC);\n                if (LLlog > LLFSELog) return ERROR(corruption_detected);\n                ip += headerSize;\n                FSE_buildDTable(DTableLL, norm, max, LLlog);\n        }   }\n\n        switch(Offtype)\n        {\n        case bt_rle :\n            Offlog = 0;\n            if (ip > iend-2) return ERROR(srcSize_wrong); /* min : \"raw\", hence no header, but at least xxLog bits */\n            FSE_buildDTable_rle(DTableOffb, *ip++); break;\n        case bt_raw :\n            Offlog = Offbits;\n            FSE_buildDTable_raw(DTableOffb, Offbits); break;\n        default :\n            {   U32 max = MaxOff;\n                headerSize = FSE_readNCount(norm, &max, &Offlog, ip, iend-ip);\n                if (FSE_isError(headerSize)) return ERROR(GENERIC);\n                if (Offlog > OffFSELog) return ERROR(corruption_detected);\n                ip += headerSize;\n                FSE_buildDTable(DTableOffb, norm, max, Offlog);\n        }   }\n\n        switch(MLtype)\n        {\n        case bt_rle :\n            MLlog = 0;\n            if (ip > iend-2) return ERROR(srcSize_wrong); /* min : \"raw\", hence no header, but at least xxLog bits */\n            FSE_buildDTable_rle(DTableML, *ip++); break;\n        case bt_raw :\n            MLlog = MLbits;\n            FSE_buildDTable_raw(DTableML, MLbits); break;\n        default :\n            {   U32 max = MaxML;\n                headerSize = FSE_readNCount(norm, &max, &MLlog, ip, iend-ip);\n                if (FSE_isError(headerSize)) return ERROR(GENERIC);\n                if (MLlog > MLFSELog) return ERROR(corruption_detected);\n                ip += headerSize;\n                FSE_buildDTable(DTableML, norm, max, MLlog);\n    }   }   }\n\n    return ip-istart;\n}\n\n\ntypedef struct {\n    size_t litLength;\n    size_t offset;\n    size_t matchLength;\n} seq_t;\n\ntypedef struct {\n    FSE_DStream_t DStream;\n    FSE_DState_t stateLL;\n    FSE_DState_t stateOffb;\n    FSE_DState_t stateML;\n    size_t prevOffset;\n    const BYTE* dumps;\n    const BYTE* dumpsEnd;\n} seqState_t;\n\n\nstatic void ZSTD_decodeSequence(seq_t* seq, seqState_t* seqState)\n{\n    size_t litLength;\n    size_t prevOffset;\n    size_t offset;\n    size_t matchLength;\n    const BYTE* dumps = seqState->dumps;\n    const BYTE* const de = seqState->dumpsEnd;\n\n    /* Literal length */\n    litLength = FSE_decodeSymbol(&(seqState->stateLL), &(seqState->DStream));\n    prevOffset = litLength ? seq->offset : seqState->prevOffset;\n    seqState->prevOffset = seq->offset;\n    if (litLength == MaxLL)\n    {\n        const U32 add = dumpsstateOffb), &(seqState->DStream));\n        if (ZSTD_32bits()) FSE_reloadDStream(&(seqState->DStream));\n        nbBits = offsetCode - 1;\n        if (offsetCode==0) nbBits = 0;   /* cmove */\n        offset = ((size_t)1 << (nbBits & ((sizeof(offset)*8)-1))) + FSE_readBits(&(seqState->DStream), nbBits);\n        if (ZSTD_32bits()) FSE_reloadDStream(&(seqState->DStream));\n        if (offsetCode==0) offset = prevOffset;\n    }\n\n    /* MatchLength */\n    matchLength = FSE_decodeSymbol(&(seqState->stateML), &(seqState->DStream));\n    if (matchLength == MaxML)\n    {\n        const U32 add = dumpslitLength = litLength;\n    seq->offset = offset;\n    seq->matchLength = matchLength;\n    seqState->dumps = dumps;\n}\n\n\nstatic size_t ZSTD_execSequence(BYTE* op,\n                                seq_t sequence,\n                                const BYTE** litPtr, const BYTE* const litLimit,\n                                BYTE* const base, BYTE* const oend)\n{\n    static const int dec32table[] = {0, 1, 2, 1, 4, 4, 4, 4};   /* added */\n    static const int dec64table[] = {8, 8, 8, 7, 8, 9,10,11};   /* subtracted */\n    const BYTE* const ostart = op;\n    BYTE* const oLitEnd = op + sequence.litLength;\n    const size_t litLength = sequence.litLength;\n    BYTE* const endMatch = op + litLength + sequence.matchLength;    /* risk : address space overflow (32-bits) */\n    const BYTE* const litEnd = *litPtr + litLength;\n\n    /* checks */\n    size_t const seqLength = sequence.litLength + sequence.matchLength;\n\n    if (seqLength > (size_t)(oend - op)) return ERROR(dstSize_tooSmall);\n    if (sequence.litLength > (size_t)(litLimit - *litPtr)) return ERROR(corruption_detected);\n    /* Now we know there are no overflow in literal nor match lengths, can use pointer checks */\n    if (sequence.offset > (U32)(oLitEnd - base)) return ERROR(corruption_detected);\n\n    if (endMatch > oend) return ERROR(dstSize_tooSmall);   /* overwrite beyond dst buffer */\n    if (litEnd > litLimit) return ERROR(corruption_detected);   /* overRead beyond lit buffer */\n    if (sequence.matchLength > (size_t)(*litPtr-op)) return ERROR(dstSize_tooSmall);  /* overwrite literal segment */\n\n    /* copy Literals */\n    ZSTD_memmove(op, *litPtr, sequence.litLength);   /* note : v0.1 seems to allow scenarios where output or input are close to end of buffer */\n\n    op += litLength;\n    *litPtr = litEnd;   /* update for next sequence */\n\n    /* check : last match must be at a minimum distance of 8 from end of dest buffer */\n    if (oend-op < 8) return ERROR(dstSize_tooSmall);\n\n    /* copy Match */\n    {\n        const U32 overlapRisk = (((size_t)(litEnd - endMatch)) < 12);\n        const BYTE* match = op - sequence.offset;            /* possible underflow at op - offset ? */\n        size_t qutt = 12;\n        U64 saved[2];\n\n        /* check */\n        if (match < base) return ERROR(corruption_detected);\n        if (sequence.offset > (size_t)base) return ERROR(corruption_detected);\n\n        /* save beginning of literal sequence, in case of write overlap */\n        if (overlapRisk)\n        {\n            if ((endMatch + qutt) > oend) qutt = oend-endMatch;\n            memcpy(saved, endMatch, qutt);\n        }\n\n        if (sequence.offset < 8)\n        {\n            const int dec64 = dec64table[sequence.offset];\n            op[0] = match[0];\n            op[1] = match[1];\n            op[2] = match[2];\n            op[3] = match[3];\n            match += dec32table[sequence.offset];\n            ZSTD_copy4(op+4, match);\n            match -= dec64;\n        } else { ZSTD_copy8(op, match); }\n        op += 8; match += 8;\n\n        if (endMatch > oend-(16-MINMATCH))\n        {\n            if (op < oend-8)\n            {\n                ZSTD_wildcopy(op, match, (oend-8) - op);\n                match += (oend-8) - op;\n                op = oend-8;\n            }\n            while (opLLTable;\n    U32* DTableML = dctx->MLTable;\n    U32* DTableOffb = dctx->OffTable;\n    BYTE* const base = (BYTE*) (dctx->base);\n\n    /* Build Decoding Tables */\n    errorCode = ZSTDv01_decodeSeqHeaders(&nbSeq, &dumps, &dumpsLength,\n                                      DTableLL, DTableML, DTableOffb,\n                                      ip, iend-ip);\n    if (ZSTDv01_isError(errorCode)) return errorCode;\n    ip += errorCode;\n\n    /* Regen sequences */\n    {\n        seq_t sequence;\n        seqState_t seqState;\n\n        memset(&sequence, 0, sizeof(sequence));\n        seqState.dumps = dumps;\n        seqState.dumpsEnd = dumps + dumpsLength;\n        seqState.prevOffset = 1;\n        errorCode = FSE_initDStream(&(seqState.DStream), ip, iend-ip);\n        if (FSE_isError(errorCode)) return ERROR(corruption_detected);\n        FSE_initDState(&(seqState.stateLL), &(seqState.DStream), DTableLL);\n        FSE_initDState(&(seqState.stateOffb), &(seqState.DStream), DTableOffb);\n        FSE_initDState(&(seqState.stateML), &(seqState.DStream), DTableML);\n\n        for ( ; (FSE_reloadDStream(&(seqState.DStream)) <= FSE_DStream_completed) && (nbSeq>0) ; )\n        {\n            size_t oneSeqSize;\n            nbSeq--;\n            ZSTD_decodeSequence(&sequence, &seqState);\n            oneSeqSize = ZSTD_execSequence(op, sequence, &litPtr, litEnd, base, oend);\n            if (ZSTDv01_isError(oneSeqSize)) return oneSeqSize;\n            op += oneSeqSize;\n        }\n\n        /* check if reached exact end */\n        if ( !FSE_endOfDStream(&(seqState.DStream)) ) return ERROR(corruption_detected);   /* requested too much : data is corrupted */\n        if (nbSeq<0) return ERROR(corruption_detected);   /* requested too many sequences : data is corrupted */\n\n        /* last literal segment */\n        {\n            size_t lastLLSize = litEnd - litPtr;\n            if (op+lastLLSize > oend) return ERROR(dstSize_tooSmall);\n            if (lastLLSize > 0) {\n                if (op != litPtr) memmove(op, litPtr, lastLLSize);\n                op += lastLLSize;\n            }\n        }\n    }\n\n    return op-ostart;\n}\n\n\nstatic size_t ZSTD_decompressBlock(\n                            void* ctx,\n                            void* dst, size_t maxDstSize,\n                      const void* src, size_t srcSize)\n{\n    /* blockType == blockCompressed, srcSize is trusted */\n    const BYTE* ip = (const BYTE*)src;\n    const BYTE* litPtr = NULL;\n    size_t litSize = 0;\n    size_t errorCode;\n\n    /* Decode literals sub-block */\n    errorCode = ZSTDv01_decodeLiteralsBlock(ctx, dst, maxDstSize, &litPtr, &litSize, src, srcSize);\n    if (ZSTDv01_isError(errorCode)) return errorCode;\n    ip += errorCode;\n    srcSize -= errorCode;\n\n    return ZSTD_decompressSequences(ctx, dst, maxDstSize, ip, srcSize, litPtr, litSize);\n}\n\n\nsize_t ZSTDv01_decompressDCtx(void* ctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)\n{\n    const BYTE* ip = (const BYTE*)src;\n    const BYTE* iend = ip + srcSize;\n    BYTE* const ostart = (BYTE* const)dst;\n    BYTE* op = ostart;\n    BYTE* const oend = ostart + maxDstSize;\n    size_t remainingSize = srcSize;\n    U32 magicNumber;\n    size_t errorCode=0;\n    blockProperties_t blockProperties = { 0 };\n\n    /* Frame Header */\n    if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);\n    magicNumber = ZSTD_readBE32(src);\n    if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown);\n    ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize;\n\n    /* Loop on each block */\n    while (1)\n    {\n        size_t blockSize = ZSTDv01_getcBlockSize(ip, iend-ip, &blockProperties);\n        if (ZSTDv01_isError(blockSize)) return blockSize;\n\n        ip += ZSTD_blockHeaderSize;\n        remainingSize -= ZSTD_blockHeaderSize;\n        if (blockSize > remainingSize) return ERROR(srcSize_wrong);\n\n        switch(blockProperties.blockType)\n        {\n        case bt_compressed:\n            errorCode = ZSTD_decompressBlock(ctx, op, oend-op, ip, blockSize);\n            break;\n        case bt_raw :\n            errorCode = ZSTD_copyUncompressedBlock(op, oend-op, ip, blockSize);\n            break;\n        case bt_rle :\n            return ERROR(GENERIC);   /* not yet supported */\n            break;\n        case bt_end :\n            /* end of frame */\n            if (remainingSize) return ERROR(srcSize_wrong);\n            break;\n        default:\n            return ERROR(GENERIC);\n        }\n        if (blockSize == 0) break;   /* bt_end */\n\n        if (ZSTDv01_isError(errorCode)) return errorCode;\n        op += errorCode;\n        ip += blockSize;\n        remainingSize -= blockSize;\n    }\n\n    return op-ostart;\n}\n\nsize_t ZSTDv01_decompress(void* dst, size_t maxDstSize, const void* src, size_t srcSize)\n{\n    dctx_t ctx;\n    ctx.base = dst;\n    return ZSTDv01_decompressDCtx(&ctx, dst, maxDstSize, src, srcSize);\n}\n\n/* ZSTD_errorFrameSizeInfoLegacy() :\n   assumes `cSize` and `dBound` are _not_ NULL */\nstatic void ZSTD_errorFrameSizeInfoLegacy(size_t* cSize, unsigned long long* dBound, size_t ret)\n{\n    *cSize = ret;\n    *dBound = ZSTD_CONTENTSIZE_ERROR;\n}\n\nvoid ZSTDv01_findFrameSizeInfoLegacy(const void *src, size_t srcSize, size_t* cSize, unsigned long long* dBound)\n{\n    const BYTE* ip = (const BYTE*)src;\n    size_t remainingSize = srcSize;\n    size_t nbBlocks = 0;\n    U32 magicNumber;\n    blockProperties_t blockProperties;\n\n    /* Frame Header */\n    if (srcSize < ZSTD_frameHeaderSize+ZSTD_blockHeaderSize) {\n        ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));\n        return;\n    }\n    magicNumber = ZSTD_readBE32(src);\n    if (magicNumber != ZSTD_magicNumber) {\n        ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(prefix_unknown));\n        return;\n    }\n    ip += ZSTD_frameHeaderSize; remainingSize -= ZSTD_frameHeaderSize;\n\n    /* Loop on each block */\n    while (1)\n    {\n        size_t blockSize = ZSTDv01_getcBlockSize(ip, remainingSize, &blockProperties);\n        if (ZSTDv01_isError(blockSize)) {\n            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, blockSize);\n            return;\n        }\n\n        ip += ZSTD_blockHeaderSize;\n        remainingSize -= ZSTD_blockHeaderSize;\n        if (blockSize > remainingSize) {\n            ZSTD_errorFrameSizeInfoLegacy(cSize, dBound, ERROR(srcSize_wrong));\n            return;\n        }\n\n        if (blockSize == 0) break;   /* bt_end */\n\n        ip += blockSize;\n        remainingSize -= blockSize;\n        nbBlocks++;\n    }\n\n    *cSize = ip - (const BYTE*)src;\n    *dBound = nbBlocks * BLOCKSIZE;\n}\n\n/*******************************\n*  Streaming Decompression API\n*******************************/\n\nsize_t ZSTDv01_resetDCtx(ZSTDv01_Dctx* dctx)\n{\n    dctx->expected = ZSTD_frameHeaderSize;\n    dctx->phase = 0;\n    dctx->previousDstEnd = NULL;\n    dctx->base = NULL;\n    return 0;\n}\n\nZSTDv01_Dctx* ZSTDv01_createDCtx(void)\n{\n    ZSTDv01_Dctx* dctx = (ZSTDv01_Dctx*)malloc(sizeof(ZSTDv01_Dctx));\n    if (dctx==NULL) return NULL;\n    ZSTDv01_resetDCtx(dctx);\n    return dctx;\n}\n\nsize_t ZSTDv01_freeDCtx(ZSTDv01_Dctx* dctx)\n{\n    free(dctx);\n    return 0;\n}\n\nsize_t ZSTDv01_nextSrcSizeToDecompress(ZSTDv01_Dctx* dctx)\n{\n    return ((dctx_t*)dctx)->expected;\n}\n\nsize_t ZSTDv01_decompressContinue(ZSTDv01_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize)\n{\n    dctx_t* ctx = (dctx_t*)dctx;\n\n    /* Sanity check */\n    if (srcSize != ctx->expected) return ERROR(srcSize_wrong);\n    if (dst != ctx->previousDstEnd)  /* not contiguous */\n        ctx->base = dst;\n\n    /* Decompress : frame header */\n    if (ctx->phase == 0)\n    {\n        /* Check frame magic header */\n        U32 magicNumber = ZSTD_readBE32(src);\n        if (magicNumber != ZSTD_magicNumber) return ERROR(prefix_unknown);\n        ctx->phase = 1;\n        ctx->expected = ZSTD_blockHeaderSize;\n        return 0;\n    }\n\n    /* Decompress : block header */\n    if (ctx->phase == 1)\n    {\n        blockProperties_t bp;\n        size_t blockSize = ZSTDv01_getcBlockSize(src, ZSTD_blockHeaderSize, &bp);\n        if (ZSTDv01_isError(blockSize)) return blockSize;\n        if (bp.blockType == bt_end)\n        {\n            ctx->expected = 0;\n            ctx->phase = 0;\n        }\n        else\n        {\n            ctx->expected = blockSize;\n            ctx->bType = bp.blockType;\n            ctx->phase = 2;\n        }\n\n        return 0;\n    }\n\n    /* Decompress : block content */\n    {\n        size_t rSize;\n        switch(ctx->bType)\n        {\n        case bt_compressed:\n            rSize = ZSTD_decompressBlock(ctx, dst, maxDstSize, src, srcSize);\n            break;\n        case bt_raw :\n            rSize = ZSTD_copyUncompressedBlock(dst, maxDstSize, src, srcSize);\n            break;\n        case bt_rle :\n            return ERROR(GENERIC);   /* not yet handled */\n            break;\n        case bt_end :   /* should never happen (filtered at phase 1) */\n            rSize = 0;\n            break;\n        default:\n            return ERROR(GENERIC);\n        }\n        ctx->phase = 1;\n        ctx->expected = ZSTD_blockHeaderSize;\n        if (ZSTDv01_isError(rSize)) return rSize;\n        ctx->previousDstEnd = (void*)( ((char*)dst) + rSize);\n        return rSize;\n    }\n\n}\n"
  },
  {
    "path": "lib/legacy/zstd_v01.h",
    "content": "/*\n * Copyright (c) Yann Collet, Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n#ifndef ZSTD_V01_H_28739879432\n#define ZSTD_V01_H_28739879432\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n\n/* *************************************\n*  Includes\n***************************************/\n#include    /* size_t */\n\n\n/* *************************************\n*  Simple one-step function\n***************************************/\n/**\nZSTDv01_decompress() : decompress ZSTD frames compliant with v0.1.x format\n    compressedSize : is the exact source size\n    maxOriginalSize : is the size of the 'dst' buffer, which must be already allocated.\n                      It must be equal or larger than originalSize, otherwise decompression will fail.\n    return : the number of bytes decompressed into destination buffer (originalSize)\n             or an errorCode if it fails (which can be tested using ZSTDv01_isError())\n*/\nsize_t ZSTDv01_decompress( void* dst, size_t maxOriginalSize,\n                     const void* src, size_t compressedSize);\n\n /**\n ZSTDv01_findFrameSizeInfoLegacy() : get the source length and decompressed bound of a ZSTD frame compliant with v0.1.x format\n     srcSize : The size of the 'src' buffer, at least as large as the frame pointed to by 'src'\n     cSize (output parameter)  : the number of bytes that would be read to decompress this frame\n                                 or an error code if it fails (which can be tested using ZSTDv01_isError())\n     dBound (output parameter) : an upper-bound for the decompressed size of the data in the frame\n                                 or ZSTD_CONTENTSIZE_ERROR if an error occurs\n\n     note : assumes `cSize` and `dBound` are _not_ NULL.\n */\nvoid ZSTDv01_findFrameSizeInfoLegacy(const void *src, size_t srcSize,\n                                     size_t* cSize, unsigned long long* dBound);\n\n/**\nZSTDv01_isError() : tells if the result of ZSTDv01_decompress() is an error\n*/\nunsigned ZSTDv01_isError(size_t code);\n\n\n/* *************************************\n*  Advanced functions\n***************************************/\ntypedef struct ZSTDv01_Dctx_s ZSTDv01_Dctx;\nZSTDv01_Dctx* ZSTDv01_createDCtx(void);\nsize_t ZSTDv01_freeDCtx(ZSTDv01_Dctx* dctx);\n\nsize_t ZSTDv01_decompressDCtx(void* ctx,\n                              void* dst, size_t maxOriginalSize,\n                        const void* src, size_t compressedSize);\n\n/* *************************************\n*  Streaming functions\n***************************************/\nsize_t ZSTDv01_resetDCtx(ZSTDv01_Dctx* dctx);\n\nsize_t ZSTDv01_nextSrcSizeToDecompress(ZSTDv01_Dctx* dctx);\nsize_t ZSTDv01_decompressContinue(ZSTDv01_Dctx* dctx, void* dst, size_t maxDstSize, const void* src, size_t srcSize);\n/**\n  Use above functions alternatively.\n  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().\n  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.\n  Result is the number of bytes regenerated within 'dst'.\n  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.\n*/\n\n/* *************************************\n*  Prefix - version detection\n***************************************/\n#define ZSTDv01_magicNumber   0xFD2FB51E   /* Big Endian version */\n#define ZSTDv01_magicNumberLE 0x1EB52FFD   /* Little Endian version */\n\n\n#if defined (__cplusplus)\n}\n#endif\n\n#endif /* ZSTD_V01_H_28739879432 */\n"
  },
  {
    "path": "lib/legacy/zstd_v02.c",
    "content": "/*\n * Copyright (c) Yann Collet, Meta Platforms, Inc. and affiliates.\n * All rights reserved.\n *\n * This source code is licensed under both the BSD-style license (found in the\n * LICENSE file in the root directory of this source tree) and the GPLv2 (found\n * in the COPYING file in the root directory of this source tree).\n * You may select, at your option, one of the above-listed licenses.\n */\n\n\n#include     /* size_t, ptrdiff_t */\n#include \"zstd_v02.h\"\n#include \"../common/compiler.h\"\n#include \"../common/error_private.h\"\n\n\n/******************************************\n*  Compiler-specific\n******************************************/\n#if defined(_MSC_VER)   /* Visual Studio */\n#   include   /* _byteswap_ulong */\n#   include   /* _byteswap_* */\n#endif\n\n\n/* ******************************************************************\n   mem.h\n   low-level memory access routines\n   Copyright (C) 2013-2015, Yann Collet.\n\n   BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php)\n\n   Redistribution and use in source and binary forms, with or without\n   modification, are permitted provided that the following conditions are\n   met:\n\n       * Redistributions of source code must retain the above copyright\n   notice, this list of conditions and the following disclaimer.\n       * Redistributions in binary form must reproduce the above\n   copyright notice, this list of conditions and the following disclaimer\n   in the documentation and/or other materials provided with the\n   distribution.\n\n   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n   \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n    You can contact the author at :\n    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy\n    - Public forum : https://groups.google.com/forum/#!forum/lz4c\n****************************************************************** */\n#ifndef MEM_H_MODULE\n#define MEM_H_MODULE\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n\n/******************************************\n*  Includes\n******************************************/\n#include     /* size_t, ptrdiff_t */\n#include     /* memcpy */\n\n\n/****************************************************************\n*  Basic Types\n*****************************************************************/\n#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)\n# if defined(_AIX)\n#  include \n# else\n#  include  /* intptr_t */\n# endif\n  typedef  uint8_t BYTE;\n  typedef uint16_t U16;\n  typedef  int16_t S16;\n  typedef uint32_t U32;\n  typedef  int32_t S32;\n  typedef uint64_t U64;\n  typedef  int64_t S64;\n#else\n  typedef unsigned char       BYTE;\n  typedef unsigned short      U16;\n  typedef   signed short      S16;\n  typedef unsigned int        U32;\n  typedef   signed int        S32;\n  typedef unsigned long long  U64;\n  typedef   signed long long  S64;\n#endif\n\n\n/****************************************************************\n*  Memory I/O\n*****************************************************************/\n\nMEM_STATIC unsigned MEM_32bits(void) { return sizeof(void*)==4; }\nMEM_STATIC unsigned MEM_64bits(void) { return sizeof(void*)==8; }\n\nMEM_STATIC unsigned MEM_isLittleEndian(void)\n{\n    const union { U32 u; BYTE c[4]; } one = { 1 };   /* don't use static : performance detrimental  */\n    return one.c[0];\n}\n\nMEM_STATIC U16 MEM_read16(const void* memPtr)\n{\n    U16 val; memcpy(&val, memPtr, sizeof(val)); return val;\n}\n\nMEM_STATIC U32 MEM_read32(const void* memPtr)\n{\n    U32 val; memcpy(&val, memPtr, sizeof(val)); return val;\n}\n\nMEM_STATIC U64 MEM_read64(const void* memPtr)\n{\n    U64 val; memcpy(&val, memPtr, sizeof(val)); return val;\n}\n\nMEM_STATIC void MEM_write16(void* memPtr, U16 value)\n{\n    memcpy(memPtr, &value, sizeof(value));\n}\n\nMEM_STATIC U16 MEM_readLE16(const void* memPtr)\n{\n    if (MEM_isLittleEndian())\n        return MEM_read16(memPtr);\n    else\n    {\n        const BYTE* p = (const BYTE*)memPtr;\n        return (U16)(p[0] + (p[1]<<8));\n    }\n}\n\nMEM_STATIC void MEM_writeLE16(void* memPtr, U16 val)\n{\n    if (MEM_isLittleEndian())\n    {\n        MEM_write16(memPtr, val);\n    }\n    else\n    {\n        BYTE* p = (BYTE*)memPtr;\n        p[0] = (BYTE)val;\n        p[1] = (BYTE)(val>>8);\n    }\n}\n\nMEM_STATIC U32 MEM_readLE24(const void* memPtr)\n{\n    return MEM_readLE16(memPtr) + (((const BYTE*)memPtr)[2] << 16);\n}\n\nMEM_STATIC U32 MEM_readLE32(const void* memPtr)\n{\n    if (MEM_isLittleEndian())\n        return MEM_read32(memPtr);\n    else\n    {\n        const BYTE* p = (const BYTE*)memPtr;\n        return (U32)((U32)p[0] + ((U32)p[1]<<8) + ((U32)p[2]<<16) + ((U32)p[3]<<24));\n    }\n}\n\n\nMEM_STATIC U64 MEM_readLE64(const void* memPtr)\n{\n    if (MEM_isLittleEndian())\n        return MEM_read64(memPtr);\n    else\n    {\n        const BYTE* p = (const BYTE*)memPtr;\n        return (U64)((U64)p[0] + ((U64)p[1]<<8) + ((U64)p[2]<<16) + ((U64)p[3]<<24)\n                     + ((U64)p[4]<<32) + ((U64)p[5]<<40) + ((U64)p[6]<<48) + ((U64)p[7]<<56));\n    }\n}\n\n\nMEM_STATIC size_t MEM_readLEST(const void* memPtr)\n{\n    if (MEM_32bits())\n        return (size_t)MEM_readLE32(memPtr);\n    else\n        return (size_t)MEM_readLE64(memPtr);\n}\n\n#if defined (__cplusplus)\n}\n#endif\n\n#endif /* MEM_H_MODULE */\n\n\n/* ******************************************************************\n   bitstream\n   Part of NewGen Entropy library\n   header file (to include)\n   Copyright (C) 2013-2015, Yann Collet.\n\n   BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php)\n\n   Redistribution and use in source and binary forms, with or without\n   modification, are permitted provided that the following conditions are\n   met:\n\n       * Redistributions of source code must retain the above copyright\n   notice, this list of conditions and the following disclaimer.\n       * Redistributions in binary form must reproduce the above\n   copyright notice, this list of conditions and the following disclaimer\n   in the documentation and/or other materials provided with the\n   distribution.\n\n   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n   \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n   You can contact the author at :\n   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy\n   - Public forum : https://groups.google.com/forum/#!forum/lz4c\n****************************************************************** */\n#ifndef BITSTREAM_H_MODULE\n#define BITSTREAM_H_MODULE\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n\n\n/*\n*  This API consists of small unitary functions, which highly benefit from being inlined.\n*  Since link-time-optimization is not available for all compilers,\n*  these functions are defined into a .h to be included.\n*/\n\n\n/**********************************************\n*  bitStream decompression API (read backward)\n**********************************************/\ntypedef struct\n{\n    size_t   bitContainer;\n    unsigned bitsConsumed;\n    const char* ptr;\n    const char* start;\n} BIT_DStream_t;\n\ntypedef enum { BIT_DStream_unfinished = 0,\n               BIT_DStream_endOfBuffer = 1,\n               BIT_DStream_completed = 2,\n               BIT_DStream_overflow = 3 } BIT_DStream_status;  /* result of BIT_reloadDStream() */\n               /* 1,2,4,8 would be better for bitmap combinations, but slows down performance a bit ... :( */\n\nMEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);\nMEM_STATIC size_t   BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);\nMEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);\nMEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);\n\n\n/******************************************\n*  unsafe API\n******************************************/\nMEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);\n/* faster, but works only if nbBits >= 1 */\n\n\n\n/****************************************************************\n*  Helper functions\n****************************************************************/\nMEM_STATIC unsigned BIT_highbit32 (U32 val)\n{\n#   if defined(_MSC_VER)   /* Visual */\n    unsigned long r;\n    return _BitScanReverse(&r, val) ? (unsigned)r : 0;\n#   elif defined(__GNUC__) && (__GNUC__ >= 3)   /* Use GCC Intrinsic */\n    return __builtin_clz (val) ^ 31;\n#   else   /* Software version */\n    static const unsigned DeBruijnClz[32] = { 0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30, 8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31 };\n    U32 v = val;\n    unsigned r;\n    v |= v >> 1;\n    v |= v >> 2;\n    v |= v >> 4;\n    v |= v >> 8;\n    v |= v >> 16;\n    r = DeBruijnClz[ (U32) (v * 0x07C4ACDDU) >> 27];\n    return r;\n#   endif\n}\n\n\n\n/**********************************************************\n* bitStream decoding\n**********************************************************/\n\n/*!BIT_initDStream\n*  Initialize a BIT_DStream_t.\n*  @bitD : a pointer to an already allocated BIT_DStream_t structure\n*  @srcBuffer must point at the beginning of a bitStream\n*  @srcSize must be the exact size of the bitStream\n*  @result : size of stream (== srcSize) or an errorCode if a problem is detected\n*/\nMEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)\n{\n    if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }\n\n    if (srcSize >=  sizeof(size_t))   /* normal case */\n    {\n        U32 contain32;\n        bitD->start = (const char*)srcBuffer;\n        bitD->ptr   = (const char*)srcBuffer + srcSize - sizeof(size_t);\n        bitD->bitContainer = MEM_readLEST(bitD->ptr);\n        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];\n        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */\n        bitD->bitsConsumed = 8 - BIT_highbit32(contain32);\n    }\n    else\n    {\n        U32 contain32;\n        bitD->start = (const char*)srcBuffer;\n        bitD->ptr   = bitD->start;\n        bitD->bitContainer = *(const BYTE*)(bitD->start);\n        switch(srcSize)\n        {\n            case 7: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[6]) << (sizeof(size_t)*8 - 16);\n                    /* fallthrough */\n            case 6: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[5]) << (sizeof(size_t)*8 - 24);\n                    /* fallthrough */\n            case 5: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[4]) << (sizeof(size_t)*8 - 32);\n                    /* fallthrough */\n            case 4: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[3]) << 24;\n                    /* fallthrough */\n            case 3: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[2]) << 16;\n                    /* fallthrough */\n            case 2: bitD->bitContainer += (size_t)(((const BYTE*)(bitD->start))[1]) <<  8;\n                    /* fallthrough */\n            default:;\n        }\n        contain32 = ((const BYTE*)srcBuffer)[srcSize-1];\n        if (contain32 == 0) return ERROR(GENERIC);   /* endMark not present */\n        bitD->bitsConsumed = 8 - BIT_highbit32(contain32);\n        bitD->bitsConsumed += (U32)(sizeof(size_t) - srcSize)*8;\n    }\n\n    return srcSize;\n}\n\nMEM_STATIC size_t BIT_lookBits(BIT_DStream_t* bitD, U32 nbBits)\n{\n    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;\n    return ((bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> 1) >> ((bitMask-nbBits) & bitMask);\n}\n\n/*! BIT_lookBitsFast :\n*   unsafe version; only works if nbBits >= 1 */\nMEM_STATIC size_t BIT_lookBitsFast(BIT_DStream_t* bitD, U32 nbBits)\n{\n    const U32 bitMask = sizeof(bitD->bitContainer)*8 - 1;\n    return (bitD->bitContainer << (bitD->bitsConsumed & bitMask)) >> (((bitMask+1)-nbBits) & bitMask);\n}\n\nMEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)\n{\n    bitD->bitsConsumed += nbBits;\n}\n\nMEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)\n{\n    size_t value = BIT_lookBits(bitD, nbBits);\n    BIT_skipBits(bitD, nbBits);\n    return value;\n}\n\n/*!BIT_readBitsFast :\n*  unsafe version; only works if nbBits >= 1 */\nMEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)\n{\n    size_t value = BIT_lookBitsFast(bitD, nbBits);\n    BIT_skipBits(bitD, nbBits);\n    return value;\n}\n\nMEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)\n{\n    if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* should never happen */\n        return BIT_DStream_overflow;\n\n    if (bitD->ptr >= bitD->start + sizeof(bitD->bitContainer))\n    {\n        bitD->ptr -= bitD->bitsConsumed >> 3;\n        bitD->bitsConsumed &= 7;\n        bitD->bitContainer = MEM_readLEST(bitD->ptr);\n        return BIT_DStream_unfinished;\n    }\n    if (bitD->ptr == bitD->start)\n    {\n        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;\n        return BIT_DStream_completed;\n    }\n    {\n        U32 nbBytes = bitD->bitsConsumed >> 3;\n        BIT_DStream_status result = BIT_DStream_unfinished;\n        if (bitD->ptr - nbBytes < bitD->start)\n        {\n            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */\n            result = BIT_DStream_endOfBuffer;\n        }\n        bitD->ptr -= nbBytes;\n        bitD->bitsConsumed -= nbBytes*8;\n        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD) */\n        return result;\n    }\n}\n\n/*! BIT_endOfDStream\n*   @return Tells if DStream has reached its exact end\n*/\nMEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)\n{\n    return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));\n}\n\n#if defined (__cplusplus)\n}\n#endif\n\n#endif /* BITSTREAM_H_MODULE */\n/* ******************************************************************\n   Error codes and messages\n   Copyright (C) 2013-2015, Yann Collet\n\n   BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php)\n\n   Redistribution and use in source and binary forms, with or without\n   modification, are permitted provided that the following conditions are\n   met:\n\n       * Redistributions of source code must retain the above copyright\n   notice, this list of conditions and the following disclaimer.\n       * Redistributions in binary form must reproduce the above\n   copyright notice, this list of conditions and the following disclaimer\n   in the documentation and/or other materials provided with the\n   distribution.\n\n   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n   \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n   You can contact the author at :\n   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy\n   - Public forum : https://groups.google.com/forum/#!forum/lz4c\n****************************************************************** */\n#ifndef ERROR_H_MODULE\n#define ERROR_H_MODULE\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n\n\n/******************************************\n*  Compiler-specific\n******************************************/\n#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)\n#  define ERR_STATIC static inline\n#elif defined(_MSC_VER)\n#  define ERR_STATIC static __inline\n#elif defined(__GNUC__)\n#  define ERR_STATIC static __attribute__((unused))\n#else\n#  define ERR_STATIC static  /* this version may generate warnings for unused static functions; disable the relevant warning */\n#endif\n\n\n/******************************************\n*  Error Management\n******************************************/\n#define PREFIX(name) ZSTD_error_##name\n\n#define ERROR(name) (size_t)-PREFIX(name)\n\n#define ERROR_LIST(ITEM) \\\n        ITEM(PREFIX(No_Error)) ITEM(PREFIX(GENERIC)) \\\n        ITEM(PREFIX(dstSize_tooSmall)) ITEM(PREFIX(srcSize_wrong)) \\\n        ITEM(PREFIX(prefix_unknown)) ITEM(PREFIX(corruption_detected)) \\\n        ITEM(PREFIX(tableLog_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooLarge)) ITEM(PREFIX(maxSymbolValue_tooSmall)) \\\n        ITEM(PREFIX(maxCode))\n\n#define ERROR_GENERATE_ENUM(ENUM) ENUM,\ntypedef enum { ERROR_LIST(ERROR_GENERATE_ENUM) } ERR_codes;  /* enum is exposed, to detect & handle specific errors; compare function result to -enum value */\n\n#define ERROR_CONVERTTOSTRING(STRING) #STRING,\n#define ERROR_GENERATE_STRING(EXPR) ERROR_CONVERTTOSTRING(EXPR)\nstatic const char* ERR_strings[] = { ERROR_LIST(ERROR_GENERATE_STRING) };\n\nERR_STATIC unsigned ERR_isError(size_t code) { return (code > ERROR(maxCode)); }\n\nERR_STATIC const char* ERR_getErrorName(size_t code)\n{\n    static const char* codeError = \"Unspecified error code\";\n    if (ERR_isError(code)) return ERR_strings[-(int)(code)];\n    return codeError;\n}\n\n\n#if defined (__cplusplus)\n}\n#endif\n\n#endif /* ERROR_H_MODULE */\n/*\nConstructor and Destructor of type FSE_CTable\n    Note that its size depends on 'tableLog' and 'maxSymbolValue' */\ntypedef unsigned FSE_CTable;   /* don't allocate that. It's just a way to be more restrictive than void* */\ntypedef unsigned FSE_DTable;   /* don't allocate that. It's just a way to be more restrictive than void* */\n\n\n/* ******************************************************************\n   FSE : Finite State Entropy coder\n   header file for static linking (only)\n   Copyright (C) 2013-2015, Yann Collet\n\n   BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php)\n\n   Redistribution and use in source and binary forms, with or without\n   modification, are permitted provided that the following conditions are\n   met:\n\n       * Redistributions of source code must retain the above copyright\n   notice, this list of conditions and the following disclaimer.\n       * Redistributions in binary form must reproduce the above\n   copyright notice, this list of conditions and the following disclaimer\n   in the documentation and/or other materials provided with the\n   distribution.\n\n   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n   \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n   You can contact the author at :\n   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy\n   - Public forum : https://groups.google.com/forum/#!forum/lz4c\n****************************************************************** */\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n\n\n/******************************************\n*  Static allocation\n******************************************/\n/* FSE buffer bounds */\n#define FSE_NCOUNTBOUND 512\n#define FSE_BLOCKBOUND(size) (size + (size>>7))\n#define FSE_COMPRESSBOUND(size) (FSE_NCOUNTBOUND + FSE_BLOCKBOUND(size))   /* Macro version, useful for static allocation */\n\n/* You can statically allocate FSE CTable/DTable as a table of unsigned using below macro */\n#define FSE_CTABLE_SIZE_U32(maxTableLog, maxSymbolValue)   (1 + (1<<(maxTableLog-1)) + ((maxSymbolValue+1)*2))\n#define FSE_DTABLE_SIZE_U32(maxTableLog)                   (1 + (1<= 1 (otherwise, result will be corrupted) */\n\n\n/******************************************\n*  Implementation of inline functions\n******************************************/\n\n/* decompression */\n\ntypedef struct {\n    U16 tableLog;\n    U16 fastMode;\n} FSE_DTableHeader;   /* sizeof U32 */\n\ntypedef struct\n{\n    unsigned short newState;\n    unsigned char  symbol;\n    unsigned char  nbBits;\n} FSE_decode_t;   /* size == U32 */\n\nMEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)\n{\n    FSE_DTableHeader DTableH;\n    memcpy(&DTableH, dt, sizeof(DTableH));\n    DStatePtr->state = BIT_readBits(bitD, DTableH.tableLog);\n    BIT_reloadDStream(bitD);\n    DStatePtr->table = dt + 1;\n}\n\nMEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)\n{\n    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];\n    const U32  nbBits = DInfo.nbBits;\n    BYTE symbol = DInfo.symbol;\n    size_t lowBits = BIT_readBits(bitD, nbBits);\n\n    DStatePtr->state = DInfo.newState + lowBits;\n    return symbol;\n}\n\nMEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)\n{\n    const FSE_decode_t DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];\n    const U32 nbBits = DInfo.nbBits;\n    BYTE symbol = DInfo.symbol;\n    size_t lowBits = BIT_readBitsFast(bitD, nbBits);\n\n    DStatePtr->state = DInfo.newState + lowBits;\n    return symbol;\n}\n\nMEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)\n{\n    return DStatePtr->state == 0;\n}\n\n\n#if defined (__cplusplus)\n}\n#endif\n/* ******************************************************************\n   Huff0 : Huffman coder, part of New Generation Entropy library\n   header file for static linking (only)\n   Copyright (C) 2013-2015, Yann Collet\n\n   BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php)\n\n   Redistribution and use in source and binary forms, with or without\n   modification, are permitted provided that the following conditions are\n   met:\n\n       * Redistributions of source code must retain the above copyright\n   notice, this list of conditions and the following disclaimer.\n       * Redistributions in binary form must reproduce the above\n   copyright notice, this list of conditions and the following disclaimer\n   in the documentation and/or other materials provided with the\n   distribution.\n\n   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n   \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n   You can contact the author at :\n   - Source repository : https://github.com/Cyan4973/FiniteStateEntropy\n   - Public forum : https://groups.google.com/forum/#!forum/lz4c\n****************************************************************** */\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n\n/******************************************\n*  Static allocation macros\n******************************************/\n/* Huff0 buffer bounds */\n#define HUF_CTABLEBOUND 129\n#define HUF_BLOCKBOUND(size) (size + (size>>8) + 8)   /* only true if incompressible pre-filtered with fast heuristic */\n#define HUF_COMPRESSBOUND(size) (HUF_CTABLEBOUND + HUF_BLOCKBOUND(size))   /* Macro version, useful for static allocation */\n\n/* static allocation of Huff0's DTable */\n#define HUF_DTABLE_SIZE(maxTableLog)   (1 + (1<   /* size_t */\n\n\n/* *************************************\n*  Version\n***************************************/\n#define ZSTD_VERSION_MAJOR    0    /* for breaking interface changes  */\n#define ZSTD_VERSION_MINOR    2    /* for new (non-breaking) interface capabilities */\n#define ZSTD_VERSION_RELEASE  2    /* for tweaks, bug-fixes, or development */\n#define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)\n\n\n/* *************************************\n*  Advanced functions\n***************************************/\ntypedef struct ZSTD_CCtx_s ZSTD_CCtx;   /* incomplete type */\n\n#if defined (__cplusplus)\n}\n#endif\n/*\n    zstd - standard compression library\n    Header File for static linking only\n    Copyright (C) 2014-2015, Yann Collet.\n\n    BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php)\n\n    Redistribution and use in source and binary forms, with or without\n    modification, are permitted provided that the following conditions are\n    met:\n    * Redistributions of source code must retain the above copyright\n    notice, this list of conditions and the following disclaimer.\n    * Redistributions in binary form must reproduce the above\n    copyright notice, this list of conditions and the following disclaimer\n    in the documentation and/or other materials provided with the\n    distribution.\n    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n    \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n    You can contact the author at :\n    - zstd source repository : https://github.com/Cyan4973/zstd\n    - ztsd public forum : https://groups.google.com/forum/#!forum/lz4c\n*/\n\n/* The objects defined into this file should be considered experimental.\n * They are not labelled stable, as their prototype may change in the future.\n * You can use them for tests, provide feedback, or if you can endure risk of future changes.\n */\n\n#if defined (__cplusplus)\nextern \"C\" {\n#endif\n\n/* *************************************\n*  Streaming functions\n***************************************/\n\ntypedef struct ZSTDv02_Dctx_s ZSTD_DCtx;\n\n/*\n  Use above functions alternatively.\n  ZSTD_nextSrcSizeToDecompress() tells how much bytes to provide as 'srcSize' to ZSTD_decompressContinue().\n  ZSTD_decompressContinue() will use previous data blocks to improve compression if they are located prior to current block.\n  Result is the number of bytes regenerated within 'dst'.\n  It can be zero, which is not an error; it just means ZSTD_decompressContinue() has decoded some header.\n*/\n\n/* *************************************\n*  Prefix - version detection\n***************************************/\n#define ZSTD_magicNumber 0xFD2FB522   /* v0.2 (current)*/\n\n\n#if defined (__cplusplus)\n}\n#endif\n/* ******************************************************************\n   FSE : Finite State Entropy coder\n   Copyright (C) 2013-2015, Yann Collet.\n\n   BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php)\n\n   Redistribution and use in source and binary forms, with or without\n   modification, are permitted provided that the following conditions are\n   met:\n\n       * Redistributions of source code must retain the above copyright\n   notice, this list of conditions and the following disclaimer.\n       * Redistributions in binary form must reproduce the above\n   copyright notice, this list of conditions and the following disclaimer\n   in the documentation and/or other materials provided with the\n   distribution.\n\n   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n   \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n    You can contact the author at :\n    - FSE source repository : https://github.com/Cyan4973/FiniteStateEntropy\n    - Public forum : https://groups.google.com/forum/#!forum/lz4c\n****************************************************************** */\n\n#ifndef FSE_COMMONDEFS_ONLY\n\n/****************************************************************\n*  Tuning parameters\n****************************************************************/\n/* MEMORY_USAGE :\n*  Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)\n*  Increasing memory usage improves compression ratio\n*  Reduced memory usage can improve speed, due to cache effect\n*  Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */\n#define FSE_MAX_MEMORY_USAGE 14\n#define FSE_DEFAULT_MEMORY_USAGE 13\n\n/* FSE_MAX_SYMBOL_VALUE :\n*  Maximum symbol value authorized.\n*  Required for proper stack allocation */\n#define FSE_MAX_SYMBOL_VALUE 255\n\n\n/****************************************************************\n*  template functions type & suffix\n****************************************************************/\n#define FSE_FUNCTION_TYPE BYTE\n#define FSE_FUNCTION_EXTENSION\n\n\n/****************************************************************\n*  Byte symbol type\n****************************************************************/\n#endif   /* !FSE_COMMONDEFS_ONLY */\n\n\n/****************************************************************\n*  Compiler specifics\n****************************************************************/\n#ifdef _MSC_VER    /* Visual Studio */\n#  define FORCE_INLINE static __forceinline\n#  include                     /* For Visual 2005 */\n#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */\n#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */\n#else\n#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */\n#    ifdef __GNUC__\n#      define FORCE_INLINE static inline __attribute__((always_inline))\n#    else\n#      define FORCE_INLINE static inline\n#    endif\n#  else\n#    define FORCE_INLINE static\n#  endif /* __STDC_VERSION__ */\n#endif\n\n\n/****************************************************************\n*  Includes\n****************************************************************/\n#include      /* malloc, free, qsort */\n#include      /* memcpy, memset */\n#include       /* printf (debug) */\n\n/****************************************************************\n*  Constants\n*****************************************************************/\n#define FSE_MAX_TABLELOG  (FSE_MAX_MEMORY_USAGE-2)\n#define FSE_MAX_TABLESIZE (1U< FSE_TABLELOG_ABSOLUTE_MAX\n#error \"FSE_MAX_TABLELOG > FSE_TABLELOG_ABSOLUTE_MAX is not supported\"\n#endif\n\n\n/****************************************************************\n*  Error Management\n****************************************************************/\n#define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */\n\n\n/****************************************************************\n*  Complex types\n****************************************************************/\ntypedef U32 DTable_max_t[FSE_DTABLE_SIZE_U32(FSE_MAX_TABLELOG)];\n\n\n/****************************************************************\n*  Templates\n****************************************************************/\n/*\n  designed to be included\n  for type-specific functions (template emulation in C)\n  Objective is to write these functions only once, for improved maintenance\n*/\n\n/* safety checks */\n#ifndef FSE_FUNCTION_EXTENSION\n#  error \"FSE_FUNCTION_EXTENSION must be defined\"\n#endif\n#ifndef FSE_FUNCTION_TYPE\n#  error \"FSE_FUNCTION_TYPE must be defined\"\n#endif\n\n/* Function names */\n#define FSE_CAT(X,Y) X##Y\n#define FSE_FUNCTION_NAME(X,Y) FSE_CAT(X,Y)\n#define FSE_TYPE_NAME(X,Y) FSE_CAT(X,Y)\n\n\n/* Function templates */\n\n#define FSE_DECODE_TYPE FSE_decode_t\n\nstatic U32 FSE_tableStep(U32 tableSize) { return (tableSize>>1) + (tableSize>>3) + 3; }\n\nstatic size_t FSE_buildDTable\n(FSE_DTable* dt, const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)\n{\n    void* ptr = dt+1;\n    FSE_DECODE_TYPE* const tableDecode = (FSE_DECODE_TYPE*)ptr;\n    FSE_DTableHeader DTableH;\n    const U32 tableSize = 1 << tableLog;\n    const U32 tableMask = tableSize-1;\n    const U32 step = FSE_tableStep(tableSize);\n    U16 symbolNext[FSE_MAX_SYMBOL_VALUE+1];\n    U32 position = 0;\n    U32 highThreshold = tableSize-1;\n    const S16 largeLimit= (S16)(1 << (tableLog-1));\n    U32 noLarge = 1;\n    U32 s;\n\n    /* Sanity Checks */\n    if (maxSymbolValue > FSE_MAX_SYMBOL_VALUE) return ERROR(maxSymbolValue_tooLarge);\n    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);\n\n    /* Init, lay down lowprob symbols */\n    DTableH.tableLog = (U16)tableLog;\n    for (s=0; s<=maxSymbolValue; s++)\n    {\n        if (normalizedCounter[s]==-1)\n        {\n            tableDecode[highThreshold--].symbol = (FSE_FUNCTION_TYPE)s;\n            symbolNext[s] = 1;\n        }\n        else\n        {\n            if (normalizedCounter[s] >= largeLimit) noLarge=0;\n            symbolNext[s] = normalizedCounter[s];\n        }\n    }\n\n    /* Spread symbols */\n    for (s=0; s<=maxSymbolValue; s++)\n    {\n        int i;\n        for (i=0; i highThreshold) position = (position + step) & tableMask;   /* lowprob area */\n        }\n    }\n\n    if (position!=0) return ERROR(GENERIC);   /* position must reach all cells once, otherwise normalizedCounter is incorrect */\n\n    /* Build Decoding table */\n    {\n        U32 i;\n        for (i=0; i FSE_TABLELOG_ABSOLUTE_MAX) return ERROR(tableLog_tooLarge);\n    bitStream >>= 4;\n    bitCount = 4;\n    *tableLogPtr = nbBits;\n    remaining = (1<1) && (charnum<=*maxSVPtr))\n    {\n        if (previous0)\n        {\n            unsigned n0 = charnum;\n            while ((bitStream & 0xFFFF) == 0xFFFF)\n            {\n                n0+=24;\n                if (ip < iend-5)\n                {\n                    ip+=2;\n                    bitStream = MEM_readLE32(ip) >> bitCount;\n                }\n                else\n                {\n                    bitStream >>= 16;\n                    bitCount+=16;\n                }\n            }\n            while ((bitStream & 3) == 3)\n            {\n                n0+=3;\n                bitStream>>=2;\n                bitCount+=2;\n            }\n            n0 += bitStream & 3;\n            bitCount += 2;\n            if (n0 > *maxSVPtr) return ERROR(maxSymbolValue_tooSmall);\n            while (charnum < n0) normalizedCounter[charnum++] = 0;\n            if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))\n            {\n                ip += bitCount>>3;\n                bitCount &= 7;\n                bitStream = MEM_readLE32(ip) >> bitCount;\n            }\n            else\n                bitStream >>= 2;\n        }\n        {\n            const short max = (short)((2*threshold-1)-remaining);\n            short count;\n\n            if ((bitStream & (threshold-1)) < (U32)max)\n            {\n                count = (short)(bitStream & (threshold-1));\n                bitCount   += nbBits-1;\n            }\n            else\n            {\n                count = (short)(bitStream & (2*threshold-1));\n                if (count >= threshold) count -= max;\n                bitCount   += nbBits;\n            }\n\n            count--;   /* extra accuracy */\n            remaining -= FSE_abs(count);\n            normalizedCounter[charnum++] = count;\n            previous0 = !count;\n            while (remaining < threshold)\n            {\n                nbBits--;\n                threshold >>= 1;\n            }\n\n            {\n                if ((ip <= iend-7) || (ip + (bitCount>>3) <= iend-4))\n                {\n                    ip += bitCount>>3;\n                    bitCount &= 7;\n                }\n                else\n                {\n                    bitCount -= (int)(8 * (iend - 4 - ip));\n                    ip = iend - 4;\n                }\n                bitStream = MEM_readLE32(ip) >> (bitCount & 31);\n            }\n        }\n    }\n    if (remaining != 1) return ERROR(GENERIC);\n    *maxSVPtr = charnum-1;\n\n    ip += (bitCount+7)>>3;\n    if ((size_t)(ip-istart) > hbSize) return ERROR(srcSize_wrong);\n    return ip-istart;\n}\n\n\n/*********************************************************\n*  Decompression (Byte symbols)\n*********************************************************/\nstatic size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)\n{\n    void* ptr = dt;\n    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;\n    FSE_decode_t* const cell = (FSE_decode_t*)(ptr) + 1;   /* because dt is unsigned */\n\n    DTableH->tableLog = 0;\n    DTableH->fastMode = 0;\n\n    cell->newState = 0;\n    cell->symbol = symbolValue;\n    cell->nbBits = 0;\n\n    return 0;\n}\n\n\nstatic size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)\n{\n    void* ptr = dt;\n    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;\n    FSE_decode_t* const dinfo = (FSE_decode_t*)(ptr) + 1;   /* because dt is unsigned */\n    const unsigned tableSize = 1 << nbBits;\n    const unsigned tableMask = tableSize - 1;\n    const unsigned maxSymbolValue = tableMask;\n    unsigned s;\n\n    /* Sanity checks */\n    if (nbBits < 1) return ERROR(GENERIC);         /* min size */\n\n    /* Build Decoding Table */\n    DTableH->tableLog = (U16)nbBits;\n    DTableH->fastMode = 1;\n    for (s=0; s<=maxSymbolValue; s++)\n    {\n        dinfo[s].newState = 0;\n        dinfo[s].symbol = (BYTE)s;\n        dinfo[s].nbBits = (BYTE)nbBits;\n    }\n\n    return 0;\n}\n\nFORCE_INLINE size_t FSE_decompress_usingDTable_generic(\n          void* dst, size_t maxDstSize,\n    const void* cSrc, size_t cSrcSize,\n    const FSE_DTable* dt, const unsigned fast)\n{\n    BYTE* const ostart = (BYTE*) dst;\n    BYTE* op = ostart;\n    BYTE* const omax = op + maxDstSize;\n    BYTE* const olimit = omax-3;\n\n    BIT_DStream_t bitD;\n    FSE_DState_t state1;\n    FSE_DState_t state2;\n    size_t errorCode;\n\n    /* Init */\n    errorCode = BIT_initDStream(&bitD, cSrc, cSrcSize);   /* replaced last arg by maxCompressed Size */\n    if (FSE_isError(errorCode)) return errorCode;\n\n    FSE_initDState(&state1, &bitD, dt);\n    FSE_initDState(&state2, &bitD, dt);\n\n#define FSE_GETSYMBOL(statePtr) fast ? FSE_decodeSymbolFast(statePtr, &bitD) : FSE_decodeSymbol(statePtr, &bitD)\n\n    /* 4 symbols per loop */\n    for ( ; (BIT_reloadDStream(&bitD)==BIT_DStream_unfinished) && (op sizeof(bitD.bitContainer)*8)    /* This test must be static */\n            BIT_reloadDStream(&bitD);\n\n        op[1] = FSE_GETSYMBOL(&state2);\n\n        if (FSE_MAX_TABLELOG*4+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */\n            { if (BIT_reloadDStream(&bitD) > BIT_DStream_unfinished) { op+=2; break; } }\n\n        op[2] = FSE_GETSYMBOL(&state1);\n\n        if (FSE_MAX_TABLELOG*2+7 > sizeof(bitD.bitContainer)*8)    /* This test must be static */\n            BIT_reloadDStream(&bitD);\n\n        op[3] = FSE_GETSYMBOL(&state2);\n    }\n\n    /* tail */\n    /* note : BIT_reloadDStream(&bitD) >= FSE_DStream_partiallyFilled; Ends at exactly BIT_DStream_completed */\n    while (1)\n    {\n        if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state1))) )\n            break;\n\n        *op++ = FSE_GETSYMBOL(&state1);\n\n        if ( (BIT_reloadDStream(&bitD)>BIT_DStream_completed) || (op==omax) || (BIT_endOfDStream(&bitD) && (fast || FSE_endOfDState(&state2))) )\n            break;\n\n        *op++ = FSE_GETSYMBOL(&state2);\n    }\n\n    /* end ? */\n    if (BIT_endOfDStream(&bitD) && FSE_endOfDState(&state1) && FSE_endOfDState(&state2))\n        return op-ostart;\n\n    if (op==omax) return ERROR(dstSize_tooSmall);   /* dst buffer is full, but cSrc unfinished */\n\n    return ERROR(corruption_detected);\n}\n\n\nstatic size_t FSE_decompress_usingDTable(void* dst, size_t originalSize,\n                            const void* cSrc, size_t cSrcSize,\n                            const FSE_DTable* dt)\n{\n    FSE_DTableHeader DTableH;\n    memcpy(&DTableH, dt, sizeof(DTableH));\n\n    /* select fast mode (static) */\n    if (DTableH.fastMode) return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 1);\n    return FSE_decompress_usingDTable_generic(dst, originalSize, cSrc, cSrcSize, dt, 0);\n}\n\n\nstatic size_t FSE_decompress(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize)\n{\n    const BYTE* const istart = (const BYTE*)cSrc;\n    const BYTE* ip = istart;\n    short counting[FSE_MAX_SYMBOL_VALUE+1];\n    DTable_max_t dt;   /* Static analyzer seems unable to understand this table will be properly initialized later */\n    unsigned tableLog;\n    unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;\n    size_t errorCode;\n\n    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* too small input size */\n\n    /* normal FSE decoding mode */\n    errorCode = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);\n    if (FSE_isError(errorCode)) return errorCode;\n    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);   /* too small input size */\n    ip += errorCode;\n    cSrcSize -= errorCode;\n\n    errorCode = FSE_buildDTable (dt, counting, maxSymbolValue, tableLog);\n    if (FSE_isError(errorCode)) return errorCode;\n\n    /* always return, even if it is an error code */\n    return FSE_decompress_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);\n}\n\n\n\n#endif   /* FSE_COMMONDEFS_ONLY */\n/* ******************************************************************\n   Huff0 : Huffman coder, part of New Generation Entropy library\n   Copyright (C) 2013-2015, Yann Collet.\n\n   BSD 2-Clause License (https://opensource.org/licenses/bsd-license.php)\n\n   Redistribution and use in source and binary forms, with or without\n   modification, are permitted provided that the following conditions are\n   met:\n\n       * Redistributions of source code must retain the above copyright\n   notice, this list of conditions and the following disclaimer.\n       * Redistributions in binary form must reproduce the above\n   copyright notice, this list of conditions and the following disclaimer\n   in the documentation and/or other materials provided with the\n   distribution.\n\n   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n   \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\n   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\n   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n    You can contact the author at :\n    - FSE+Huff0 source repository : https://github.com/Cyan4973/FiniteStateEntropy\n    - Public forum : https://groups.google.com/forum/#!forum/lz4c\n****************************************************************** */\n\n/****************************************************************\n*  Compiler specifics\n****************************************************************/\n#if defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)\n/* inline is defined */\n#elif defined(_MSC_VER)\n#  define inline __inline\n#else\n#  define inline /* disable inline */\n#endif\n\n\n#ifdef _MSC_VER    /* Visual Studio */\n#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */\n#endif\n\n\n/****************************************************************\n*  Includes\n****************************************************************/\n#include      /* malloc, free, qsort */\n#include      /* memcpy, memset */\n#include       /* printf (debug) */\n\n/****************************************************************\n*  Error Management\n****************************************************************/\n#define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */\n\n\n/******************************************\n*  Helper functions\n******************************************/\nstatic unsigned HUF_isError(size_t code) { return ERR_isError(code); }\n\n#define HUF_ABSOLUTEMAX_TABLELOG  16   /* absolute limit of HUF_MAX_TABLELOG. Beyond that value, code does not work */\n#define HUF_MAX_TABLELOG  12           /* max configured tableLog (for static allocation); can be modified up to HUF_ABSOLUTEMAX_TABLELOG */\n#define HUF_DEFAULT_TABLELOG  HUF_MAX_TABLELOG   /* tableLog by default, when not specified */\n#define HUF_MAX_SYMBOL_VALUE 255\n#if (HUF_MAX_TABLELOG > HUF_ABSOLUTEMAX_TABLELOG)\n#  error \"HUF_MAX_TABLELOG is too large !\"\n#endif\n\n\n\n/*********************************************************\n*  Huff0 : Huffman block decompression\n*********************************************************/\ntypedef struct { BYTE byte; BYTE nbBits; } HUF_DEltX2;   /* single-symbol decoding */\n\ntypedef struct { U16 sequence; BYTE nbBits; BYTE length; } HUF_DEltX4;  /* double-symbols decoding */\n\ntypedef struct { BYTE symbol; BYTE weight; } sortedSymbol_t;\n\n/*! HUF_readStats\n    Read compact Huffman tree, saved by HUF_writeCTable\n    @huffWeight : destination buffer\n    @return : size read from `src`\n*/\nstatic size_t HUF_readStats(BYTE* huffWeight, size_t hwSize, U32* rankStats,\n                            U32* nbSymbolsPtr, U32* tableLogPtr,\n                            const void* src, size_t srcSize)\n{\n    U32 weightTotal;\n    U32 tableLog;\n    const BYTE* ip = (const BYTE*) src;\n    size_t iSize;\n    size_t oSize;\n    U32 n;\n\n    if (!srcSize) return ERROR(srcSize_wrong);\n    iSize = ip[0];\n    //memset(huffWeight, 0, hwSize);   /* is not necessary, even though some analyzer complain ... */\n\n    if (iSize >= 128)  /* special header */\n    {\n        if (iSize >= (242))   /* RLE */\n        {\n            static int l[14] = { 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 127, 128 };\n            oSize = l[iSize-242];\n            memset(huffWeight, 1, hwSize);\n            iSize = 0;\n        }\n        else   /* Incompressible */\n        {\n            oSize = iSize - 127;\n            iSize = ((oSize+1)/2);\n            if (iSize+1 > srcSize) return ERROR(srcSize_wrong);\n            if (oSize >= hwSize) return ERROR(corruption_detected);\n            ip += 1;\n            for (n=0; n> 4;\n                huffWeight[n+1] = ip[n/2] & 15;\n            }\n        }\n    }\n    else  /* header compressed with FSE (normal case) */\n    {\n        if (iSize+1 > srcSize) return ERROR(srcSize_wrong);\n        oSize = FSE_decompress(huffWeight, hwSize-1, ip+1, iSize);   /* max (hwSize-1) values decoded, as last one is implied */\n        if (FSE_isError(oSize)) return oSize;\n    }\n\n    /* collect weight stats */\n    memset(rankStats, 0, (HUF_ABSOLUTEMAX_TABLELOG + 1) * sizeof(U32));\n    weightTotal = 0;\n    for (n=0; n= HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);\n        rankStats[huffWeight[n]]++;\n        weightTotal += (1 << huffWeight[n]) >> 1;\n    }\n    if (weightTotal == 0) return ERROR(corruption_detected);\n\n    /* get last non-null symbol weight (implied, total must be 2^n) */\n    tableLog = BIT_highbit32(weightTotal) + 1;\n    if (tableLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(corruption_detected);\n    {\n        U32 total = 1 << tableLog;\n        U32 rest = total - weightTotal;\n        U32 verif = 1 << BIT_highbit32(rest);\n        U32 lastWeight = BIT_highbit32(rest) + 1;\n        if (verif != rest) return ERROR(corruption_detected);    /* last value must be a clean power of 2 */\n        huffWeight[oSize] = (BYTE)lastWeight;\n        rankStats[lastWeight]++;\n    }\n\n    /* check tree construction validity */\n    if ((rankStats[1] < 2) || (rankStats[1] & 1)) return ERROR(corruption_detected);   /* by construction : at least 2 elts of rank 1, must be even */\n\n    /* results */\n    *nbSymbolsPtr = (U32)(oSize+1);\n    *tableLogPtr = tableLog;\n    return iSize+1;\n}\n\n\n/**************************/\n/* single-symbol decoding */\n/**************************/\n\nstatic size_t HUF_readDTableX2 (U16* DTable, const void* src, size_t srcSize)\n{\n    BYTE huffWeight[HUF_MAX_SYMBOL_VALUE + 1];\n    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];   /* large enough for values from 0 to 16 */\n    U32 tableLog = 0;\n    const BYTE* ip = (const BYTE*) src;\n    size_t iSize = ip[0];\n    U32 nbSymbols = 0;\n    U32 n;\n    U32 nextRankStart;\n    void* ptr = DTable+1;\n    HUF_DEltX2* const dt = (HUF_DEltX2*)ptr;\n\n    HUF_STATIC_ASSERT(sizeof(HUF_DEltX2) == sizeof(U16));   /* if compilation fails here, assertion is false */\n    //memset(huffWeight, 0, sizeof(huffWeight));   /* is not necessary, even though some analyzer complain ... */\n\n    iSize = HUF_readStats(huffWeight, HUF_MAX_SYMBOL_VALUE + 1, rankVal, &nbSymbols, &tableLog, src, srcSize);\n    if (HUF_isError(iSize)) return iSize;\n\n    /* check result */\n    if (tableLog > DTable[0]) return ERROR(tableLog_tooLarge);   /* DTable is too small */\n    DTable[0] = (U16)tableLog;   /* maybe should separate sizeof DTable, as allocated, from used size of DTable, in case of DTable re-use */\n\n    /* Prepare ranks */\n    nextRankStart = 0;\n    for (n=1; n<=tableLog; n++)\n    {\n        U32 current = nextRankStart;\n        nextRankStart += (rankVal[n] << (n-1));\n        rankVal[n] = current;\n    }\n\n    /* fill DTable */\n    for (n=0; n> 1;\n        U32 i;\n        HUF_DEltX2 D;\n        D.byte = (BYTE)n; D.nbBits = (BYTE)(tableLog + 1 - w);\n        for (i = rankVal[w]; i < rankVal[w] + length; i++)\n            dt[i] = D;\n        rankVal[w] += length;\n    }\n\n    return iSize;\n}\n\nstatic BYTE HUF_decodeSymbolX2(BIT_DStream_t* Dstream, const HUF_DEltX2* dt, const U32 dtLog)\n{\n        const size_t val = BIT_lookBitsFast(Dstream, dtLog); /* note : dtLog >= 1 */\n        const BYTE c = dt[val].byte;\n        BIT_skipBits(Dstream, dt[val].nbBits);\n        return c;\n}\n\n#define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \\\n    *ptr++ = HUF_decodeSymbolX2(DStreamPtr, dt, dtLog)\n\n#define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \\\n    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \\\n        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)\n\n#define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \\\n    if (MEM_64bits()) \\\n        HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)\n\nstatic inline size_t HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX2* const dt, const U32 dtLog)\n{\n    BYTE* const pStart = p;\n\n    /* up to 4 symbols at a time */\n    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-4))\n    {\n        HUF_DECODE_SYMBOLX2_2(p, bitDPtr);\n        HUF_DECODE_SYMBOLX2_1(p, bitDPtr);\n        HUF_DECODE_SYMBOLX2_2(p, bitDPtr);\n        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);\n    }\n\n    /* closer to the end */\n    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd))\n        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);\n\n    /* no more data to retrieve from bitstream, hence no need to reload */\n    while (p < pEnd)\n        HUF_DECODE_SYMBOLX2_0(p, bitDPtr);\n\n    return pEnd-pStart;\n}\n\n\nstatic size_t HUF_decompress4X2_usingDTable(\n          void* dst,  size_t dstSize,\n    const void* cSrc, size_t cSrcSize,\n    const U16* DTable)\n{\n    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */\n\n    {\n        const BYTE* const istart = (const BYTE*) cSrc;\n        BYTE* const ostart = (BYTE*) dst;\n        BYTE* const oend = ostart + dstSize;\n\n        const void* ptr = DTable;\n        const HUF_DEltX2* const dt = ((const HUF_DEltX2*)ptr) +1;\n        const U32 dtLog = DTable[0];\n        size_t errorCode;\n\n        /* Init */\n        BIT_DStream_t bitD1;\n        BIT_DStream_t bitD2;\n        BIT_DStream_t bitD3;\n        BIT_DStream_t bitD4;\n        const size_t length1 = MEM_readLE16(istart);\n        const size_t length2 = MEM_readLE16(istart+2);\n        const size_t length3 = MEM_readLE16(istart+4);\n        size_t length4;\n        const BYTE* const istart1 = istart + 6;  /* jumpTable */\n        const BYTE* const istart2 = istart1 + length1;\n        const BYTE* const istart3 = istart2 + length2;\n        const BYTE* const istart4 = istart3 + length3;\n        const size_t segmentSize = (dstSize+3) / 4;\n        BYTE* const opStart2 = ostart + segmentSize;\n        BYTE* const opStart3 = opStart2 + segmentSize;\n        BYTE* const opStart4 = opStart3 + segmentSize;\n        BYTE* op1 = ostart;\n        BYTE* op2 = opStart2;\n        BYTE* op3 = opStart3;\n        BYTE* op4 = opStart4;\n        U32 endSignal;\n\n        length4 = cSrcSize - (length1 + length2 + length3 + 6);\n        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */\n        errorCode = BIT_initDStream(&bitD1, istart1, length1);\n        if (HUF_isError(errorCode)) return errorCode;\n        errorCode = BIT_initDStream(&bitD2, istart2, length2);\n        if (HUF_isError(errorCode)) return errorCode;\n        errorCode = BIT_initDStream(&bitD3, istart3, length3);\n        if (HUF_isError(errorCode)) return errorCode;\n        errorCode = BIT_initDStream(&bitD4, istart4, length4);\n        if (HUF_isError(errorCode)) return errorCode;\n\n        /* 16-32 symbols per loop (4-8 symbols per stream) */\n        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);\n        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )\n        {\n            HUF_DECODE_SYMBOLX2_2(op1, &bitD1);\n            HUF_DECODE_SYMBOLX2_2(op2, &bitD2);\n            HUF_DECODE_SYMBOLX2_2(op3, &bitD3);\n            HUF_DECODE_SYMBOLX2_2(op4, &bitD4);\n            HUF_DECODE_SYMBOLX2_1(op1, &bitD1);\n            HUF_DECODE_SYMBOLX2_1(op2, &bitD2);\n            HUF_DECODE_SYMBOLX2_1(op3, &bitD3);\n            HUF_DECODE_SYMBOLX2_1(op4, &bitD4);\n            HUF_DECODE_SYMBOLX2_2(op1, &bitD1);\n            HUF_DECODE_SYMBOLX2_2(op2, &bitD2);\n            HUF_DECODE_SYMBOLX2_2(op3, &bitD3);\n            HUF_DECODE_SYMBOLX2_2(op4, &bitD4);\n            HUF_DECODE_SYMBOLX2_0(op1, &bitD1);\n            HUF_DECODE_SYMBOLX2_0(op2, &bitD2);\n            HUF_DECODE_SYMBOLX2_0(op3, &bitD3);\n            HUF_DECODE_SYMBOLX2_0(op4, &bitD4);\n\n            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);\n        }\n\n        /* check corruption */\n        if (op1 > opStart2) return ERROR(corruption_detected);\n        if (op2 > opStart3) return ERROR(corruption_detected);\n        if (op3 > opStart4) return ERROR(corruption_detected);\n        /* note : op4 supposed already verified within main loop */\n\n        /* finish bitStreams one by one */\n        HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);\n        HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);\n        HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);\n        HUF_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);\n\n        /* check */\n        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);\n        if (!endSignal) return ERROR(corruption_detected);\n\n        /* decoded size */\n        return dstSize;\n    }\n}\n\n\nstatic size_t HUF_decompress4X2 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)\n{\n    HUF_CREATE_STATIC_DTABLEX2(DTable, HUF_MAX_TABLELOG);\n    const BYTE* ip = (const BYTE*) cSrc;\n    size_t errorCode;\n\n    errorCode = HUF_readDTableX2 (DTable, cSrc, cSrcSize);\n    if (HUF_isError(errorCode)) return errorCode;\n    if (errorCode >= cSrcSize) return ERROR(srcSize_wrong);\n    ip += errorCode;\n    cSrcSize -= errorCode;\n\n    return HUF_decompress4X2_usingDTable (dst, dstSize, ip, cSrcSize, DTable);\n}\n\n\n/***************************/\n/* double-symbols decoding */\n/***************************/\n\nstatic void HUF_fillDTableX4Level2(HUF_DEltX4* DTable, U32 sizeLog, const U32 consumed,\n                           const U32* rankValOrigin, const int minWeight,\n                           const sortedSymbol_t* sortedSymbols, const U32 sortedListSize,\n                           U32 nbBitsBaseline, U16 baseSeq)\n{\n    HUF_DEltX4 DElt;\n    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];\n    U32 s;\n\n    /* get pre-calculated rankVal */\n    memcpy(rankVal, rankValOrigin, sizeof(rankVal));\n\n    /* fill skipped values */\n    if (minWeight>1)\n    {\n        U32 i, skipSize = rankVal[minWeight];\n        MEM_writeLE16(&(DElt.sequence), baseSeq);\n        DElt.nbBits   = (BYTE)(consumed);\n        DElt.length   = 1;\n        for (i = 0; i < skipSize; i++)\n            DTable[i] = DElt;\n    }\n\n    /* fill DTable */\n    for (s=0; s= 1 */\n\n        rankVal[weight] += length;\n    }\n}\n\ntypedef U32 rankVal_t[HUF_ABSOLUTEMAX_TABLELOG][HUF_ABSOLUTEMAX_TABLELOG + 1];\n\nstatic void HUF_fillDTableX4(HUF_DEltX4* DTable, const U32 targetLog,\n                           const sortedSymbol_t* sortedList, const U32 sortedListSize,\n                           const U32* rankStart, rankVal_t rankValOrigin, const U32 maxWeight,\n                           const U32 nbBitsBaseline)\n{\n    U32 rankVal[HUF_ABSOLUTEMAX_TABLELOG + 1];\n    const int scaleLog = nbBitsBaseline - targetLog;   /* note : targetLog >= srcLog, hence scaleLog <= 1 */\n    const U32 minBits  = nbBitsBaseline - maxWeight;\n    U32 s;\n\n    memcpy(rankVal, rankValOrigin, sizeof(rankVal));\n\n    /* fill DTable */\n    for (s=0; s= minBits)   /* enough room for a second symbol */\n        {\n            U32 sortedRank;\n            int minWeight = nbBits + scaleLog;\n            if (minWeight < 1) minWeight = 1;\n            sortedRank = rankStart[minWeight];\n            HUF_fillDTableX4Level2(DTable+start, targetLog-nbBits, nbBits,\n                           rankValOrigin[nbBits], minWeight,\n                           sortedList+sortedRank, sortedListSize-sortedRank,\n                           nbBitsBaseline, symbol);\n        }\n        else\n        {\n            U32 i;\n            const U32 end = start + length;\n            HUF_DEltX4 DElt;\n\n            MEM_writeLE16(&(DElt.sequence), symbol);\n            DElt.nbBits   = (BYTE)(nbBits);\n            DElt.length   = 1;\n            for (i = start; i < end; i++)\n                DTable[i] = DElt;\n        }\n        rankVal[weight] += length;\n    }\n}\n\nstatic size_t HUF_readDTableX4 (U32* DTable, const void* src, size_t srcSize)\n{\n    BYTE weightList[HUF_MAX_SYMBOL_VALUE + 1];\n    sortedSymbol_t sortedSymbol[HUF_MAX_SYMBOL_VALUE + 1];\n    U32 rankStats[HUF_ABSOLUTEMAX_TABLELOG + 1] = { 0 };\n    U32 rankStart0[HUF_ABSOLUTEMAX_TABLELOG + 2] = { 0 };\n    U32* const rankStart = rankStart0+1;\n    rankVal_t rankVal;\n    U32 tableLog, maxW, sizeOfSort, nbSymbols;\n    const U32 memLog = DTable[0];\n    const BYTE* ip = (const BYTE*) src;\n    size_t iSize = ip[0];\n    void* ptr = DTable;\n    HUF_DEltX4* const dt = ((HUF_DEltX4*)ptr) + 1;\n\n    HUF_STATIC_ASSERT(sizeof(HUF_DEltX4) == sizeof(U32));   /* if compilation fails here, assertion is false */\n    if (memLog > HUF_ABSOLUTEMAX_TABLELOG) return ERROR(tableLog_tooLarge);\n    //memset(weightList, 0, sizeof(weightList));   /* is not necessary, even though some analyzer complain ... */\n\n    iSize = HUF_readStats(weightList, HUF_MAX_SYMBOL_VALUE + 1, rankStats, &nbSymbols, &tableLog, src, srcSize);\n    if (HUF_isError(iSize)) return iSize;\n\n    /* check result */\n    if (tableLog > memLog) return ERROR(tableLog_tooLarge);   /* DTable can't fit code depth */\n\n    /* find maxWeight */\n    for (maxW = tableLog; rankStats[maxW]==0; maxW--)\n        {if (!maxW) return ERROR(GENERIC); }  /* necessarily finds a solution before maxW==0 */\n\n    /* Get start index of each weight */\n    {\n        U32 w, nextRankStart = 0;\n        for (w=1; w<=maxW; w++)\n        {\n            U32 current = nextRankStart;\n            nextRankStart += rankStats[w];\n            rankStart[w] = current;\n        }\n        rankStart[0] = nextRankStart;   /* put all 0w symbols at the end of sorted list*/\n        sizeOfSort = nextRankStart;\n    }\n\n    /* sort symbols by weight */\n    {\n        U32 s;\n        for (s=0; s> consumed;\n            }\n        }\n    }\n\n    HUF_fillDTableX4(dt, memLog,\n                   sortedSymbol, sizeOfSort,\n                   rankStart0, rankVal, maxW,\n                   tableLog+1);\n\n    return iSize;\n}\n\n\nstatic U32 HUF_decodeSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)\n{\n    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */\n    memcpy(op, dt+val, 2);\n    BIT_skipBits(DStream, dt[val].nbBits);\n    return dt[val].length;\n}\n\nstatic U32 HUF_decodeLastSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DEltX4* dt, const U32 dtLog)\n{\n    const size_t val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */\n    memcpy(op, dt+val, 1);\n    if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits);\n    else\n    {\n        if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8))\n        {\n            BIT_skipBits(DStream, dt[val].nbBits);\n            if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))\n                DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);   /* ugly hack; works only because it's the last symbol. Note : can't easily extract nbBits from just this symbol */\n        }\n    }\n    return 1;\n}\n\n\n#define HUF_DECODE_SYMBOLX4_0(ptr, DStreamPtr) \\\n    ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)\n\n#define HUF_DECODE_SYMBOLX4_1(ptr, DStreamPtr) \\\n    if (MEM_64bits() || (HUF_MAX_TABLELOG<=12)) \\\n        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)\n\n#define HUF_DECODE_SYMBOLX4_2(ptr, DStreamPtr) \\\n    if (MEM_64bits()) \\\n        ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)\n\nstatic inline size_t HUF_decodeStreamX4(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const HUF_DEltX4* const dt, const U32 dtLog)\n{\n    BYTE* const pStart = p;\n\n    /* up to 8 symbols at a time */\n    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p < pEnd-7))\n    {\n        HUF_DECODE_SYMBOLX4_2(p, bitDPtr);\n        HUF_DECODE_SYMBOLX4_1(p, bitDPtr);\n        HUF_DECODE_SYMBOLX4_2(p, bitDPtr);\n        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);\n    }\n\n    /* closer to the end */\n    while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) && (p <= pEnd-2))\n        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);\n\n    while (p <= pEnd-2)\n        HUF_DECODE_SYMBOLX4_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */\n\n    if (p < pEnd)\n        p += HUF_decodeLastSymbolX4(p, bitDPtr, dt, dtLog);\n\n    return p-pStart;\n}\n\n\n\nstatic size_t HUF_decompress4X4_usingDTable(\n          void* dst,  size_t dstSize,\n    const void* cSrc, size_t cSrcSize,\n    const U32* DTable)\n{\n    if (cSrcSize < 10) return ERROR(corruption_detected);   /* strict minimum : jump table + 1 byte per stream */\n\n    {\n        const BYTE* const istart = (const BYTE*) cSrc;\n        BYTE* const ostart = (BYTE*) dst;\n        BYTE* const oend = ostart + dstSize;\n\n        const void* ptr = DTable;\n        const HUF_DEltX4* const dt = ((const HUF_DEltX4*)ptr) +1;\n        const U32 dtLog = DTable[0];\n        size_t errorCode;\n\n        /* Init */\n        BIT_DStream_t bitD1;\n        BIT_DStream_t bitD2;\n        BIT_DStream_t bitD3;\n        BIT_DStream_t bitD4;\n        const size_t length1 = MEM_readLE16(istart);\n        const size_t length2 = MEM_readLE16(istart+2);\n        const size_t length3 = MEM_readLE16(istart+4);\n        size_t length4;\n        const BYTE* const istart1 = istart + 6;  /* jumpTable */\n        const BYTE* const istart2 = istart1 + length1;\n        const BYTE* const istart3 = istart2 + length2;\n        const BYTE* const istart4 = istart3 + length3;\n        const size_t segmentSize = (dstSize+3) / 4;\n        BYTE* const opStart2 = ostart + segmentSize;\n        BYTE* const opStart3 = opStart2 + segmentSize;\n        BYTE* const opStart4 = opStart3 + segmentSize;\n        BYTE* op1 = ostart;\n        BYTE* op2 = opStart2;\n        BYTE* op3 = opStart3;\n        BYTE* op4 = opStart4;\n        U32 endSignal;\n\n        length4 = cSrcSize - (length1 + length2 + length3 + 6);\n        if (length4 > cSrcSize) return ERROR(corruption_detected);   /* overflow */\n        errorCode = BIT_initDStream(&bitD1, istart1, length1);\n        if (HUF_isError(errorCode)) return errorCode;\n        errorCode = BIT_initDStream(&bitD2, istart2, length2);\n        if (HUF_isError(errorCode)) return errorCode;\n        errorCode = BIT_initDStream(&bitD3, istart3, length3);\n        if (HUF_isError(errorCode)) return errorCode;\n        errorCode = BIT_initDStream(&bitD4, istart4, length4);\n        if (HUF_isError(errorCode)) return errorCode;\n\n        /* 16-32 symbols per loop (4-8 symbols per stream) */\n        endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);\n        for ( ; (endSignal==BIT_DStream_unfinished) && (op4<(oend-7)) ; )\n        {\n            HUF_DECODE_SYMBOLX4_2(op1, &bitD1);\n            HUF_DECODE_SYMBOLX4_2(op2, &bitD2);\n            HUF_DECODE_SYMBOLX4_2(op3, &bitD3);\n            HUF_DECODE_SYMBOLX4_2(op4, &bitD4);\n            HUF_DECODE_SYMBOLX4_1(op1, &bitD1);\n            HUF_DECODE_SYMBOLX4_1(op2, &bitD2);\n            HUF_DECODE_SYMBOLX4_1(op3, &bitD3);\n            HUF_DECODE_SYMBOLX4_1(op4, &bitD4);\n            HUF_DECODE_SYMBOLX4_2(op1, &bitD1);\n            HUF_DECODE_SYMBOLX4_2(op2, &bitD2);\n            HUF_DECODE_SYMBOLX4_2(op3, &bitD3);\n            HUF_DECODE_SYMBOLX4_2(op4, &bitD4);\n            HUF_DECODE_SYMBOLX4_0(op1, &bitD1);\n            HUF_DECODE_SYMBOLX4_0(op2, &bitD2);\n            HUF_DECODE_SYMBOLX4_0(op3, &bitD3);\n            HUF_DECODE_SYMBOLX4_0(op4, &bitD4);\n\n            endSignal = BIT_reloadDStream(&bitD1) | BIT_reloadDStream(&bitD2) | BIT_reloadDStream(&bitD3) | BIT_reloadDStream(&bitD4);\n        }\n\n        /* check corruption */\n        if (op1 > opStart2) return ERROR(corruption_detected);\n        if (op2 > opStart3) return ERROR(corruption_detected);\n        if (op3 > opStart4) return ERROR(corruption_detected);\n        /* note : op4 supposed already verified within main loop */\n\n        /* finish bitStreams one by one */\n        HUF_decodeStreamX4(op1, &bitD1, opStart2, dt, dtLog);\n        HUF_decodeStreamX4(op2, &bitD2, opStart3, dt, dtLog);\n        HUF_decodeStreamX4(op3, &bitD3, opStart4, dt, dtLog);\n        HUF_decodeStreamX4(op4, &bitD4, oend,     dt, dtLog);\n\n        /* check */\n        endSignal = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);\n        if (!endSignal) return ERROR(corruption_detected);\n\n        /* decoded size */\n        return dstSize;\n    }\n}\n\n\nstatic size_t HUF_decompress4X4 (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)\n{\n    HUF_CREATE_STATIC_DTABLEX4(DTable, HUF_MAX_TABLELOG);\n    const BYTE* ip = (const BYTE*) cSrc;\n\n    size_t hSize = HUF_readDTableX4 (DTable, cSrc, cSrcSize);\n    if (HUF_isError(hSize)) return hSize;\n    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);\n    ip += hSize;\n    cSrcSize -= hSize;\n\n    return HUF_decompress4X4_usingDTable (dst, dstSize, ip, cSrcSize, DTable);\n}\n\n\n/**********************************/\n/* quad-symbol decoding           */\n/**********************************/\ntypedef struct { BYTE nbBits; BYTE nbBytes; } HUF_DDescX6;\ntypedef union { BYTE byte[4]; U32 sequence; } HUF_DSeqX6;\n\n/* recursive, up to level 3; may benefit from