diff --git a/CMakeLists.txt b/CMakeLists.txt index c8fdae37f..a336d6636 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -252,6 +252,7 @@ IF(ZLIB_FOUND) SET(ZLIB_LIBRARY_TYPE "zlib-ng") SET(ZLIB_LIBRARY_LIBS "zlibstatic") SET(ZLIB_LIBRARY_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/libs/zlibng") + INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_BINARY_DIR}/libs/zlibng") ELSE() SET(ZLIB_LIBRARY_TYPE " zlib") SET(ZLIB_LIBRARY_LIBS ${ZLIB_LIBRARY}) diff --git a/libs/zlibng/.github/workflows/analyze.yml b/libs/zlibng/.github/workflows/analyze.yml new file mode 100644 index 000000000..7c848ef02 --- /dev/null +++ b/libs/zlibng/.github/workflows/analyze.yml @@ -0,0 +1,39 @@ +name: CI Static Analysis +on: [push, pull_request] +jobs: + GCC-10: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v1 + - name: Install packages (Ubuntu) + run: | + sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y + sudo apt-get update + sudo apt-get install -y gcc-10 + - name: Generate project files + run: | + cmake . -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF -DWITH_FUZZERS=OFF -DWITH_CODE_COVERAGE=OFF -DWITH_MAINTAINER_WARNINGS=OFF + env: + CC: gcc-10 + CFLAGS: "-fanalyzer -Werror -Wanalyzer-double-fclose -Wanalyzer-double-free -Wanalyzer-exposure-through-output-file -Wanalyzer-file-leak -Wanalyzer-free-of-non-heap -Wanalyzer-malloc-leak -Wanalyzer-null-argument -Wanalyzer-null-dereference -Wanalyzer-possible-null-argument -Wanalyzer-possible-null-dereference -Wanalyzer-stale-setjmp-buffer -Wanalyzer-tainted-array-index -Wanalyzer-unsafe-call-within-signal-handler -Wanalyzer-use-after-free -Wanalyzer-use-of-pointer-in-stale-stack-frame" + CI: true + - name: Compile source code + run: | + cmake --build . --config Release > /dev/null + Clang-12: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v1 + - name: Install packages (Ubuntu) + run: | + wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key|sudo apt-key add - + sudo apt-add-repository "deb http://apt.llvm.org/bionic/ llvm-toolchain-bionic main" -y + sudo apt install clang-tools-12 -y + - name: Generate project files + run: | + scan-build-12 --status-bugs cmake . -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF -DWITH_FUZZERS=OFF -DWITH_CODE_COVERAGE=OFF -DWITH_MAINTAINER_WARNINGS=OFF + env: + CI: true + - name: Compile source code + run: | + scan-build-12 --status-bugs cmake --build . --config Release > /dev/null diff --git a/libs/zlibng/.github/workflows/cmake.yml b/libs/zlibng/.github/workflows/cmake.yml new file mode 100644 index 000000000..4eaec6c4b --- /dev/null +++ b/libs/zlibng/.github/workflows/cmake.yml @@ -0,0 +1,381 @@ +name: CI CMake +on: [push, pull_request] +jobs: + ci-cmake: + name: ${{ matrix.name }} + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: + - name: Ubuntu GCC + os: ubuntu-latest + compiler: gcc + cmake-args: -DWITH_SANITIZER=Address + codecov: ubuntu_gcc + + - name: Ubuntu GCC OSB -O1 No Unaligned64 + os: ubuntu-latest + compiler: gcc + cmake-args: -DWITH_UNALIGNED=ON -DUNALIGNED64_OK=OFF -DWITH_SANITIZER=Undefined + build-dir: ../build + build-src-dir: ../zlib-ng + codecov: ubuntu_gcc_osb + cflags: -O1 -g3 + + - name: Ubuntu GCC -O3 No Unaligned + os: ubuntu-latest + compiler: gcc + cmake-args: -DWITH_UNALIGNED=OFF + codecov: ubuntu_gcc_o3 + cflags: -O3 + + - name: Ubuntu GCC Link Zlib + os: ubuntu-latest + compiler: gcc + cmake-args: -DZLIB_DUAL_LINK=ON + + - name: Ubuntu GCC No AVX2 + os: ubuntu-latest + compiler: gcc + cmake-args: -DWITH_AVX2=OFF -DWITH_SANITIZER=Undefined + codecov: ubuntu_gcc_no_avx2 + + - name: Ubuntu GCC No SSE2 + os: ubuntu-latest + compiler: gcc + cmake-args: -DWITH_SSE2=OFF -DWITH_SANITIZER=Undefined + codecov: ubuntu_gcc_no_sse2 + + - name: Ubuntu GCC No SSE4 + os: ubuntu-latest + compiler: gcc + cmake-args: -DWITH_SSE4=OFF -DWITH_SANITIZER=Undefined + codecov: ubuntu_gcc_no_sse4 + + - name: Ubuntu GCC No PCLMULQDQ + os: ubuntu-latest + compiler: gcc + cmake-args: -DWITH_PCLMULQDQ=OFF -DWITH_SANITIZER=Undefined + codecov: ubuntu_gcc_no_pclmulqdq + + - name: Ubuntu GCC Compat No Opt + os: ubuntu-latest + compiler: gcc + cmake-args: -DZLIB_COMPAT=ON -DWITH_NEW_STRATEGIES=OFF -DWITH_OPTIM=OFF -DWITH_SANITIZER=Address + codecov: ubuntu_gcc_compat_no_opt + cflags: -DNOT_TWEAK_COMPILER + + - name: Ubuntu GCC ARM SF + os: ubuntu-latest + compiler: arm-linux-gnueabi-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-arm.cmake -DCMAKE_C_COMPILER_TARGET=arm-linux-gnueabi -DWITH_SANITIZER=Address + packages: qemu gcc-arm-linux-gnueabi libc-dev-armel-cross + codecov: ubuntu_gcc_armsf + + - name: Ubuntu GCC ARM SF Compat No Opt + os: ubuntu-latest + compiler: arm-linux-gnueabi-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-arm.cmake -DCMAKE_C_COMPILER_TARGET=arm-linux-gnueabi -DZLIB_COMPAT=ON -DWITH_NEW_STRATEGIES=OFF -DWITH_OPTIM=OFF -DWITH_SANITIZER=Undefined + packages: qemu gcc-arm-linux-gnueabi libc-dev-armel-cross + codecov: ubuntu_gcc_armsf_compat_no_opt + + - name: Ubuntu GCC ARM HF + os: ubuntu-latest + compiler: arm-linux-gnueabihf-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-arm.cmake -DCMAKE_C_COMPILER_TARGET=arm-linux-gnueabihf -DWITH_SANITIZER=Address + packages: qemu gcc-arm-linux-gnueabihf libc-dev-armel-cross + codecov: ubuntu_gcc_armhf + + - name: Ubuntu GCC ARM HF No ACLE + os: ubuntu-latest + compiler: arm-linux-gnueabihf-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-arm.cmake -DCMAKE_C_COMPILER_TARGET=arm-linux-gnueabihf -DWITH_ACLE=OFF -DWITH_SANITIZER=Address + packages: qemu gcc-arm-linux-gnueabihf libc-dev-armel-cross + codecov: ubuntu_gcc_armhf_no_acle + + - name: Ubuntu GCC ARM HF No NEON + os: ubuntu-latest + compiler: arm-linux-gnueabihf-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-arm.cmake -DCMAKE_C_COMPILER_TARGET=arm-linux-gnueabihf -DWITH_NEON=OFF -DWITH_SANITIZER=Address + packages: qemu gcc-arm-linux-gnueabihf libc-dev-armel-cross + codecov: ubuntu_gcc_armhf_no_neon + + - name: Ubuntu GCC ARM HF Compat No Opt + os: ubuntu-latest + compiler: arm-linux-gnueabihf-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-arm.cmake -DCMAKE_C_COMPILER_TARGET=arm-linux-gnueabihf -DZLIB_COMPAT=ON -DWITH_NEW_STRATEGIES=OFF -DWITH_OPTIM=OFF -DWITH_SANITIZER=Undefined + packages: qemu gcc-arm-linux-gnueabihf libc-dev-armel-cross + codecov: ubuntu_gcc_armhf_compat_no_opt + + - name: Ubuntu GCC AARCH64 + os: ubuntu-latest + compiler: aarch64-linux-gnu-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-aarch64.cmake -DWITH_SANITIZER=Address + asan-options: detect_leaks=0 + packages: qemu gcc-aarch64-linux-gnu libc-dev-arm64-cross + codecov: ubuntu_gcc_aarch64 + + - name: Ubuntu GCC AARCH64 No ACLE + os: ubuntu-latest + compiler: aarch64-linux-gnu-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-aarch64.cmake -DWITH_ACLE=OFF -DWITH_SANITIZER=Undefined + asan-options: detect_leaks=0 + packages: qemu gcc-aarch64-linux-gnu libc-dev-arm64-cross + codecov: ubuntu_gcc_aarch64_no_acle + + - name: Ubuntu GCC AARCH64 No NEON + os: ubuntu-latest + compiler: aarch64-linux-gnu-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-aarch64.cmake -DWITH_NEON=OFF -DWITH_SANITIZER=Undefined + asan-options: detect_leaks=0 + packages: qemu gcc-aarch64-linux-gnu libc-dev-arm64-cross + codecov: ubuntu_gcc_aarch64_no_neon + + - name: Ubuntu GCC AARCH64 Compat No Opt + os: ubuntu-latest + compiler: aarch64-linux-gnu-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-aarch64.cmake -DZLIB_COMPAT=ON -DWITH_NEW_STRATEGIES=OFF -DWITH_OPTIM=OFF -DWITH_SANITIZER=Undefined + asan-options: detect_leaks=0 + packages: qemu gcc-aarch64-linux-gnu libc-dev-arm64-cross + codecov: ubuntu_gcc_aarch64_compat_no_opt + + - name: Ubuntu GCC PPC + os: ubuntu-latest + compiler: powerpc-linux-gnu-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-powerpc.cmake + packages: qemu gcc-powerpc-linux-gnu libc-dev-powerpc-cross + ldflags: -static + codecov: ubuntu_gcc_ppc + + - name: Ubuntu GCC PPC64 + os: ubuntu-latest + compiler: powerpc64-linux-gnu-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-powerpc64.cmake + packages: qemu gcc-powerpc64-linux-gnu libc-dev-ppc64-cross + ldflags: -static + codecov: ubuntu_gcc_ppc64 + + - name: Ubuntu GCC PPC64LE + os: ubuntu-latest + compiler: powerpc64le-linux-gnu-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-powerpc64le.cmake + packages: qemu gcc-powerpc64le-linux-gnu libc-dev-ppc64el-cross + codecov: ubuntu_gcc_ppc64le + + - name: Ubuntu GCC SPARC64 + os: ubuntu-latest + compiler: sparc64-linux-gnu-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-sparc64.cmake + packages: qemu gcc-sparc64-linux-gnu libc-dev-sparc64-cross + ldflags: -static + codecov: ubuntu_gcc_sparc64 + + - name: Ubuntu GCC S390X + os: ubuntu-latest + compiler: s390x-linux-gnu-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-s390x.cmake -DWITH_SANITIZER=Address + packages: qemu gcc-s390x-linux-gnu libc-dev-s390x-cross + ldflags: -static + codecov: ubuntu_gcc_s390x + + - name: Ubuntu GCC S390X DFLTCC + os: ubuntu-latest + compiler: s390x-linux-gnu-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-s390x.cmake -DWITH_DFLTCC_DEFLATE=ON -DWITH_DFLTCC_INFLATE=ON -DWITH_SANITIZER=Address + packages: qemu gcc-s390x-linux-gnu libc-dev-s390x-cross + ldflags: -static + codecov: ubuntu_gcc_s390x + + - name: Ubuntu GCC S390X DFLTCC Compat + os: ubuntu-latest + compiler: s390x-linux-gnu-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-s390x.cmake -DZLIB_COMPAT=ON -DWITH_DFLTCC_DEFLATE=ON -DWITH_DFLTCC_INFLATE=ON -DWITH_SANITIZER=Undefined + packages: qemu gcc-s390x-linux-gnu libc-dev-s390x-cross + ldflags: -static + codecov: ubuntu_gcc_s390x + + - name: Ubuntu MinGW i686 + os: ubuntu-latest + compiler: i686-w64-mingw32-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-mingw-i686.cmake + packages: wine32 gcc-mingw-w64 + # Codecov disabled due to gcov locking issue error + + - name: Ubuntu MinGW x86_64 + os: ubuntu-latest + compiler: x86_64-w64-mingw32-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-mingw-x86_64.cmake + packages: wine-stable gcc-mingw-w64 + codecov: ubuntu_gcc_mingw_x86_64 + + - name: Ubuntu Clang + os: ubuntu-latest + compiler: clang + packages: llvm-6.0 + gcov-exec: llvm-cov-6.0 gcov + codecov: ubuntu_clang + + - name: Ubuntu Clang Inflate Strict + os: ubuntu-latest + compiler: clang + cmake-args: -DWITH_INFLATE_STRICT=ON + packages: llvm-6.0 + gcov-exec: llvm-cov-6.0 gcov + codecov: ubuntu_clang_inflate_strict + + - name: Ubuntu Clang Inflate Allow Invalid Dist + os: ubuntu-latest + compiler: clang + cmake-args: -DWITH_INFLATE_ALLOW_INVALID_DIST=ON + packages: llvm-6.0 + gcov-exec: llvm-cov-6.0 gcov + codecov: ubuntu_clang_inflate_allow_invalid_dist + + - name: Ubuntu Clang Memory Map + os: ubuntu-latest + compiler: clang + cflags: -DUSE_MMAP + packages: llvm-6.0 + gcov-exec: llvm-cov-6.0 gcov + codecov: ubuntu_clang_mmap + + - name: Ubuntu Clang Debug + os: ubuntu-latest + compiler: clang + packages: llvm-6.0 + gcov-exec: llvm-cov-6.0 gcov + codecov: ubuntu_clang_debug + build-config: Debug + + - name: Ubuntu Clang MSAN + os: ubuntu-latest + compiler: clang + cmake-args: -GNinja -DWITH_SANITIZER=Memory + packages: ninja-build llvm-6.0 + gcov-exec: llvm-cov-6.0 gcov + cflags: -g3 -fno-omit-frame-pointer -fno-optimize-sibling-calls -fsanitize-memory-track-origins + codecov: ubuntu_clang_msan + + - name: Windows MSVC Win32 + os: windows-latest + compiler: cl + cmake-args: -A Win32 + + - name: Windows MSVC Win64 + os: windows-latest + compiler: cl + cmake-args: -A x64 + + - name: Windows MSVC ARM No Test + os: windows-latest + compiler: cl + cmake-args: -A ARM + + - name: Windows MSVC ARM64 No Test + os: windows-latest + compiler: cl + cmake-args: -A ARM64 + + - name: Windows GCC + os: windows-latest + compiler: gcc + cmake-args: -G Ninja + codecov: win64_gcc + + - name: Windows GCC Compat No Opt + os: windows-latest + compiler: gcc + cmake-args: -G Ninja -DZLIB_COMPAT=ON -DWITH_NEW_STRATEGIES=OFF -DWITH_OPTIM=OFF + codecov: win64_gcc_compat_no_opt + + - name: macOS Clang + os: macos-latest + compiler: clang + cmake-args: -DWITH_SANITIZER=Address + codecov: macos_clang + + - name: macOS GCC + os: macos-latest + compiler: gcc-10 + cmake-args: -DWITH_SANITIZER=Undefined + packages: gcc@10 + gcov-exec: gcov-10 + codecov: macos_gcc + + steps: + - name: Checkout repository + uses: actions/checkout@v2 + + - name: Checkout test corpora + uses: actions/checkout@v2 + with: + repository: nmoinvaz/corpora + path: test/data/corpora + + - name: Install packages (Ubuntu) + if: runner.os == 'Linux' && matrix.packages + run: | + sudo dpkg --add-architecture i386 # Required for wine32 + sudo apt-get update + sudo apt-get install -y ${{ matrix.packages }} + + - name: Install packages (Windows) + if: runner.os == 'Windows' + run: | + choco install ninja ${{ matrix.packages }} --no-progress + + - name: Install packages (macOS) + if: runner.os == 'macOS' + run: | + brew install ninja ${{ matrix.packages }} + env: + HOMEBREW_NO_INSTALL_CLEANUP: 1 + + - name: Install codecov.io tools + if: matrix.codecov + run: | + python -u -m pip install codecov + + - name: Generate project files + # Shared libaries turned off for qemu ppc* and sparc & reduce code coverage sources + run: | + mkdir ${{ matrix.build-dir || '.not-used' }} + cd ${{ matrix.build-dir || '.' }} + cmake ${{ matrix.build-src-dir || '.' }} ${{ matrix.cmake-args }} -DCMAKE_BUILD_TYPE=${{ matrix.build-config || 'Release' }} -DBUILD_SHARED_LIBS=OFF -DWITH_FUZZERS=ON -DWITH_CODE_COVERAGE=ON -DWITH_MAINTAINER_WARNINGS=ON + env: + CC: ${{ matrix.compiler }} + CFLAGS: ${{ matrix.cflags }} + LDFLAGS: ${{ matrix.ldflags }} + CI: true + + - name: Compile source code + run: | + cd ${{ matrix.build-dir || '.' }} + cmake --build . --config ${{ matrix.build-config || 'Release' }} + + - name: Run test cases + # Don't run tests on Windows ARM + if: runner.os != 'Windows' || contains(matrix.name, 'ARM') == false + run: | + cd ${{ matrix.build-dir || '.' }} + ctest --verbose -C Release --output-on-failure --max-width 120 -j 6 + env: + ASAN_OPTIONS: ${{ matrix.asan-options || 'verbosity=0' }}:abort_on_error=1 + MSAN_OPTIONS: ${{ matrix.msan-options || 'verbosity=0' }}:abort_on_error=1 + TSAN_OPTIONS: ${{ matrix.tsan-options || 'verbosity=0' }}:abort_on_error=1 + LSAN_OPTIONS: ${{ matrix.lsan-options || 'verbosity=0' }}:abort_on_error=1 + + - name: Upload coverage report + if: matrix.codecov && ( env.CODECOV_TOKEN_SECRET != '' || github.repository == 'zlib-ng/zlib-ng' ) + shell: bash + run: | + bash tools/codecov-upload.sh + env: + # Codecov does not yet support GitHub Actions + CODECOV_TOKEN_SECRET: "${{secrets.CODECOV_TOKEN}}" + CODECOV_TOKEN: "${{ secrets.CODECOV_TOKEN || 'e4fdf847-f541-4ab1-9d50-3d27e5913906' }}" + CODECOV_FLAGS: "${{ matrix.codecov }}" + CODECOV_NAME: "${{ matrix.name }}" + CODECOV_EXEC: "${{ matrix.gcov-exec || 'gcov' }}" + CODECOV_DIR: "${{ matrix.build-dir || '.' }}" diff --git a/libs/zlibng/.github/workflows/configure.yml b/libs/zlibng/.github/workflows/configure.yml new file mode 100644 index 000000000..750f30d71 --- /dev/null +++ b/libs/zlibng/.github/workflows/configure.yml @@ -0,0 +1,185 @@ +name: CI Configure +on: [push, pull_request] +jobs: + ci-configure: + name: ${{ matrix.name }} + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: + - name: Ubuntu GCC + os: ubuntu-latest + compiler: gcc + configure-args: --warn + + - name: Ubuntu GCC OSB + os: ubuntu-latest + compiler: gcc + configure-args: --warn + build-dir: ../build + build-src-dir: ../zlib-ng + + - name: Ubuntu GCC Compat No Opt + os: ubuntu-latest + compiler: gcc + configure-args: --warn --zlib-compat --without-optimizations --without-new-strategies + + - name: Ubuntu GCC ARM SF + os: ubuntu-latest + compiler: arm-linux-gnueabi-gcc + configure-args: --warn + chost: arm-linux-gnueabi + packages: qemu gcc-arm-linux-gnueabi libc-dev-armel-cross + + - name: Ubuntu GCC ARM SF Compat No Opt + os: ubuntu-latest + compiler: arm-linux-gnueabi-gcc + configure-args: --warn --zlib-compat --without-optimizations --without-new-strategies + chost: arm-linux-gnueabi + packages: qemu gcc-arm-linux-gnueabi libc-dev-armel-cross + + - name: Ubuntu GCC ARM HF + os: ubuntu-latest + compiler: arm-linux-gnueabihf-gcc + configure-args: --warn + chost: arm-linux-gnueabihf + packages: qemu gcc-arm-linux-gnueabihf libc-dev-armel-cross + + - name: Ubuntu GCC ARM HF No ACLE + os: ubuntu-latest + compiler: arm-linux-gnueabihf-gcc + configure-args: --warn --without-acle + chost: arm-linux-gnueabihf + packages: qemu gcc-arm-linux-gnueabihf libc-dev-armel-cross + + - name: Ubuntu GCC ARM HF No NEON + os: ubuntu-latest + compiler: arm-linux-gnueabihf-gcc + configure-args: --warn --without-neon + chost: arm-linux-gnueabihf + packages: qemu gcc-arm-linux-gnueabihf libc-dev-armel-cross + + - name: Ubuntu GCC ARM HF Compat No Opt + os: ubuntu-latest + compiler: arm-linux-gnueabihf-gcc + configure-args: --warn --zlib-compat --without-optimizations --without-new-strategies + chost: arm-linux-gnueabihf + packages: qemu gcc-arm-linux-gnueabihf libc-dev-armel-cross + + - name: Ubuntu GCC AARCH64 + os: ubuntu-latest + compiler: aarch64-linux-gnu-gcc + configure-args: --warn + chost: aarch64-linux-gnu + packages: qemu gcc-aarch64-linux-gnu libc-dev-arm64-cross + + - name: Ubuntu GCC AARCH64 No ACLE + os: ubuntu-latest + compiler: aarch64-linux-gnu-gcc + configure-args: --warn --without-acle + chost: aarch64-linux-gnu + packages: qemu gcc-aarch64-linux-gnu libc-dev-arm64-cross + + - name: Ubuntu GCC AARCH64 No NEON + os: ubuntu-latest + compiler: aarch64-linux-gnu-gcc + configure-args: --warn --without-neon + chost: aarch64-linux-gnu + packages: qemu gcc-aarch64-linux-gnu libc-dev-arm64-cross + + - name: Ubuntu GCC AARCH64 Compat No Opt + os: ubuntu-latest + compiler: aarch64-linux-gnu-gcc + configure-args: --warn --zlib-compat --without-optimizations --without-new-strategies + chost: aarch64-linux-gnu + packages: qemu gcc-aarch64-linux-gnu libc-dev-arm64-cross + + - name: Ubuntu GCC PPC + os: ubuntu-latest + compiler: powerpc-linux-gnu-gcc + configure-args: --warn --static + chost: powerpc-linux-gnu + packages: qemu gcc-powerpc-linux-gnu libc-dev-powerpc-cross + cflags: -static + ldflags: -static + + - name: Ubuntu GCC PPC64 + os: ubuntu-latest + compiler: powerpc64-linux-gnu-gcc + configure-args: --warn --static + chost: powerpc-linux-gnu + packages: qemu gcc-powerpc64-linux-gnu libc-dev-ppc64-cross + cflags: -static + ldflags: -static + + - name: Ubuntu GCC PPC64LE + os: ubuntu-latest + compiler: powerpc64le-linux-gnu-gcc + configure-args: --warn + chost: powerpc64le-linux-gnu + packages: qemu gcc-powerpc64le-linux-gnu libc-dev-ppc64el-cross + + - name: Ubuntu GCC S390X + os: ubuntu-latest + compiler: s390x-linux-gnu-gcc + configure-args: --warn --static + chost: s390x-linux-gnu + packages: qemu gcc-s390x-linux-gnu libc-dev-s390x-cross + cflags: -static + ldflags: -static + + - name: Ubuntu GCC S390X DFLTCC + os: ubuntu-latest + compiler: s390x-linux-gnu-gcc + configure-args: --warn --static --with-dfltcc-deflate --with-dfltcc-inflate + chost: s390x-linux-gnu + packages: qemu gcc-s390x-linux-gnu libc-dev-s390x-cross + cflags: -static + ldflags: -static + + - name: Ubuntu GCC S390X DFLTCC Compat + os: ubuntu-latest + compiler: s390x-linux-gnu-gcc + configure-args: --warn --zlib-compat --static --with-dfltcc-deflate --with-dfltcc-inflate + chost: s390x-linux-gnu + packages: qemu gcc-s390x-linux-gnu libc-dev-s390x-cross + cflags: -static + ldflags: -static + + - name: macOS GCC + os: macOS-latest + compiler: gcc + configure-args: --warn + + steps: + - name: Checkout repository + uses: actions/checkout@v1 + + - name: Install packages (Ubuntu) + if: runner.os == 'Linux' && matrix.packages + run: | + sudo apt-get update + sudo apt-get install -y ${{ matrix.packages }} + + - name: Generate project files + run: | + mkdir ${{ matrix.build-dir || '.not-used' }} + cd ${{ matrix.build-dir || '.' }} + ${{ matrix.build-src-dir || '.' }}/configure ${{ matrix.configure-args }} + env: + CC: ${{ matrix.compiler }} + CFLAGS: ${{ matrix.cflags }} + LDFLAGS: ${{ matrix.ldflags }} + CHOST: ${{ matrix.chost }} + CI: true + + - name: Compile source code + run: | + cd ${{ matrix.build-dir || '.' }} + make -j2 + + - name: Run test cases + run: | + cd ${{ matrix.build-dir || '.' }} + make test diff --git a/libs/zlibng/.github/workflows/fuzz.yml b/libs/zlibng/.github/workflows/fuzz.yml new file mode 100644 index 000000000..e7ddaea5b --- /dev/null +++ b/libs/zlibng/.github/workflows/fuzz.yml @@ -0,0 +1,23 @@ +name: CI Fuzz +on: [pull_request] +jobs: + Fuzzing: + runs-on: ubuntu-latest + steps: + - name: Build Fuzzers + uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master + with: + oss-fuzz-project-name: 'zlib-ng' + dry-run: false + - name: Run Fuzzers + uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master + with: + oss-fuzz-project-name: 'zlib-ng' + fuzz-seconds: 600 + dry-run: false + - name: Upload Crash + uses: actions/upload-artifact@v1 + if: failure() + with: + name: artifacts + path: ./out/artifacts diff --git a/libs/zlibng/.github/workflows/libpng.yml b/libs/zlibng/.github/workflows/libpng.yml new file mode 100644 index 000000000..fe970dd15 --- /dev/null +++ b/libs/zlibng/.github/workflows/libpng.yml @@ -0,0 +1,46 @@ +name: CI Libpng +on: [pull_request] +jobs: + pngtest: + name: Ubuntu Clang + runs-on: ubuntu-latest + + steps: + - name: Checkout repository (zlib-ng) + uses: actions/checkout@v1 + + - name: Generate project files (zlib-ng) + run: | + cmake . -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF -DZLIB_COMPAT=ON -DZLIB_ENABLE_TESTS=OFF + env: + CC: clang + CFLAGS: -fPIC + CI: true + + - name: Compile source code (zlib-ng) + run: | + cmake --build . --config Release + + - name: Checkout repository (libpng) + uses: actions/checkout@v2 + with: + repository: glennrp/libpng + path: libpng + + - name: Generate project files (libpng) + run: | + cd libpng + cmake . -DCMAKE_BUILD_TYPE=Release -DPNG_TESTS=ON -DPNG_STATIC=OFF -DZLIB_INCLUDE_DIR=.. -DZLIB_LIBRARY=$PWD/../libz.a + env: + CC: clang + CI: true + + - name: Compile source code (libpng) + run: | + cd libpng + cmake --build . --config Release + + - name: Run test cases (libpng) + run: | + cd libpng + ctest -C Release --output-on-failure --max-width 120 diff --git a/libs/zlibng/.github/workflows/nmake.yml b/libs/zlibng/.github/workflows/nmake.yml new file mode 100644 index 000000000..38c0b42eb --- /dev/null +++ b/libs/zlibng/.github/workflows/nmake.yml @@ -0,0 +1,48 @@ +name: CI NMake +on: [push, pull_request] +jobs: + ci-cmake: + name: ${{ matrix.name }} + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: + - name: Windows NMake x86 + os: windows-latest + makefile: win32/Makefile.msc + vc-vars: x86 + + - name: Windows NMake x64 + os: windows-latest + makefile: win32/Makefile.msc + vc-vars: x86_amd64 + + - name: Windows NMake ARM No Test + os: windows-latest + makefile: win32/Makefile.arm + vc-vars: x86_arm + + - name: Windows NMake ARM64 No Test + os: windows-latest + makefile: win32/Makefile.a64 + vc-vars: x86_arm64 + + steps: + - name: Checkout repository + uses: actions/checkout@v1 + + - name: Compile source code + shell: cmd + run: | + call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{ matrix.vc-vars }} + nmake -f ${{ matrix.makefile }} + + - name: Run test cases + shell: cmd + # Don't run tests on Windows ARM + if: contains(matrix.vc-vars, 'arm') == false + run: | + call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{ matrix.vc-vars }} + nmake -f ${{ matrix.makefile }} test + nmake -f ${{ matrix.makefile }} testdll diff --git a/libs/zlibng/.github/workflows/pkgcheck.yml b/libs/zlibng/.github/workflows/pkgcheck.yml new file mode 100644 index 000000000..a34ad94f3 --- /dev/null +++ b/libs/zlibng/.github/workflows/pkgcheck.yml @@ -0,0 +1,121 @@ +name: CI Pkgcheck +on: [push, pull_request] +jobs: + ci-pkgcheck: + name: ${{ matrix.name }} + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: + - name: Ubuntu GCC + os: ubuntu-latest + compiler: gcc + + - name: Ubuntu GCC -m32 + os: ubuntu-latest + compiler: gcc + packages: gcc-multilib + cmake-args: -DCMAKE_C_FLAGS=-m32 + cflags: -m32 + ldflags: -m32 + + - name: Ubuntu GCC ARM HF + os: ubuntu-latest + chost: arm-linux-gnueabihf + compiler: arm-linux-gnueabihf-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-arm.cmake -DCMAKE_C_COMPILER_TARGET=arm-linux-gnueabihf + packages: qemu gcc-arm-linux-gnueabihf libc6-dev-armhf-cross + + - name: Ubuntu GCC AARCH64 + os: ubuntu-latest + chost: aarch64-linux-gnu + compiler: aarch64-linux-gnu-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-aarch64.cmake + packages: qemu gcc-aarch64-linux-gnu libc6-dev-arm64-cross + + - name: Ubuntu GCC PPC + os: ubuntu-latest + chost: powerpc-linux-gnu + compiler: powerpc-linux-gnu-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-powerpc.cmake + packages: qemu gcc-powerpc-linux-gnu libc6-dev-powerpc-cross + + - name: Ubuntu GCC PPC64LE + os: ubuntu-latest + chost: powerpc64le-linux-gnu + compiler: powerpc64le-linux-gnu-gcc + cmake-args: -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-powerpc64le.cmake + packages: qemu gcc-powerpc64le-linux-gnu libc6-dev-ppc64el-cross + + - name: macOS Clang + os: macOS-latest + compiler: clang + + steps: + - name: Checkout repository + uses: actions/checkout@v1 + + - name: Install packages (Ubuntu) + if: runner.os == 'Linux' + run: | + sudo apt-get update + sudo apt-get install -y --no-install-recommends abigail-tools ninja-build diffoscope ${{ matrix.packages }} + + - name: Install packages (macOS) + if: runner.os == 'macOS' + run: | + brew install ninja diffoscope ${{ matrix.packages }} + env: + HOMEBREW_NO_INSTALL_CLEANUP: 1 + + - name: Select Xcode version (macOS) + # Use a version of Xcode that supports ZERO_AR_DATE until CMake supports + # AppleClang linking with libtool using -D argument + # https://gitlab.kitware.com/cmake/cmake/-/issues/19852 + if: runner.os == 'macOS' + uses: maxim-lobanov/setup-xcode@v1 + with: + xcode-version: '12.1.1' + + - name: Compare builds + run: | + sh test/pkgcheck.sh + env: + CC: ${{ matrix.compiler }} + CFLAGS: ${{ matrix.cflags }} + CHOST: ${{ matrix.chost }} + CMAKE_ARGS: ${{ matrix.cmake-args }} + LDFLAGS: ${{ matrix.ldflags }} + + - name: Compare builds (compat) + run: | + sh test/pkgcheck.sh --zlib-compat + env: + CC: ${{ matrix.compiler }} + CFLAGS: ${{ matrix.cflags }} + CHOST: ${{ matrix.chost }} + CMAKE_ARGS: ${{ matrix.cmake-args }} + LDFLAGS: ${{ matrix.ldflags }} + + - name: Check ABI + # macOS runner does not contain abigail + if: runner.os != 'macOS' + run: | + sh test/abicheck.sh --refresh_if + env: + CC: ${{ matrix.compiler }} + CFLAGS: ${{ matrix.cflags }} + CHOST: ${{ matrix.chost }} + LDFLAGS: ${{ matrix.ldflags }} + + - name: Check ABI (compat) + # macOS runner does not contain abigail + if: runner.os != 'macOS' + run: | + sh test/abicheck.sh --zlib-compat --refresh_if + env: + CC: ${{ matrix.compiler }} + CFLAGS: ${{ matrix.cflags }} + CHOST: ${{ matrix.chost }} + LDFLAGS: ${{ matrix.ldflags }} diff --git a/libs/zlibng/.github/workflows/release.yml b/libs/zlibng/.github/workflows/release.yml new file mode 100644 index 000000000..c2a306172 --- /dev/null +++ b/libs/zlibng/.github/workflows/release.yml @@ -0,0 +1,73 @@ +name: CI Release +on: + push: + tags: + - '*' +jobs: + ci-cmake: + name: ${{ matrix.name }} + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: + - name: Windows MSVC Win32 + os: windows-latest + compiler: cl + cmake-args: -A Win32 + deploy-name: win32 + + - name: Windows MSVC Win32 Compat + os: windows-latest + compiler: cl + cmake-args: -A Win32 -DZLIB_COMPAT=ON + deploy-name: win32-compat + + - name: Windows MSVC Win64 + os: windows-latest + compiler: cl + cmake-args: -A x64 + deploy-name: win64 + + - name: Windows MSVC Win64 Compat + os: windows-latest + compiler: cl + cmake-args: -A x64 -DZLIB_COMPAT=ON + deploy-name: win64-compat + + steps: + - name: Checkout repository + uses: actions/checkout@v1 + + - name: Set environment variables + shell: bash + run: echo "tag=${GITHUB_REF/refs\/tags\//}" >> $GITHUB_ENV + + - name: Generate project files + run: | + cmake . ${{ matrix.cmake-args }} -DCMAKE_BUILD_TYPE=Release -DZLIB_ENABLE_TESTS=ON -DCMAKE_INSTALL_PREFIX=out -DINSTALL_UTILS=ON + env: + CC: ${{ matrix.compiler }} + CI: true + + - name: Compile source code + run: | + cmake --build . --config Release --target install + + - name: Package release (Windows) + if: runner.os == 'Windows' + run: | + cd out + 7z a -tzip ../zlib-ng-${{ matrix.deploy-name }}.zip bin include lib ../LICENSE.md ../README.md + + - name: Upload release (Windows) + uses: svenstaro/upload-release-action@v1-release + if: runner.os == 'Windows' + with: + asset_name: zlib-ng-${{ matrix.deploy-name }}.zip + file: zlib-ng-${{ matrix.deploy-name }}.zip + tag: ${{env.tag}} + repo_token: ${{ secrets.GITHUB_TOKEN }} + overwrite: true + env: + GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}" diff --git a/libs/zlibng/.gitignore b/libs/zlibng/.gitignore index 50e5ee6fa..23f9fd159 100644 --- a/libs/zlibng/.gitignore +++ b/libs/zlibng/.gitignore @@ -13,14 +13,18 @@ *.gcno *.gcov +/adler32_test +/adler32_testsh /example /example64 /examplesh /libz.so* /libz-ng.so* +/makefixed /minigzip /minigzip64 /minigzipsh +/switchlevels /zlib.pc /zlib-ng.pc /CVE-2003-0107 @@ -46,8 +50,9 @@ foo.gz CMakeCache.txt CMakeFiles Testing -*.cmake +/*.cmake *.stackdump +*._h zconf.h zconf.h.cmakein zconf.h.included @@ -61,6 +66,7 @@ a.out /Makefile /arch/arm/Makefile /arch/generic/Makefile +/arch/power/Makefile /arch/x86/Makefile .kdev4 *.kdev4 @@ -71,6 +77,10 @@ a.out /zlib.dir /zlibstatic.dir /win32/Debug +/build/ +/build[.-]*/ +/btmp[12]/ +/pkgtmp[12]/ /.idea /cmake-build-debug diff --git a/libs/zlibng/.shellcheckrc b/libs/zlibng/.shellcheckrc new file mode 100644 index 000000000..89a1625ff --- /dev/null +++ b/libs/zlibng/.shellcheckrc @@ -0,0 +1 @@ +disable=SC2140,SC2086,SC2046,SC2015,SC1097,SC1035,SC1036,SC1007,SC2154,SC2155,SC2000,SC2034,SC2016,SC1091,SC1090,SC2212,SC2143,SC2129,SC2102,SC2069,SC1041,SC1042,SC1044,SC1046,SC1119,SC1110,SC1111,SC1112,SC1102,SC1105,SC1101,SC1004,SC1003,SC1012,SC2068,SC2065,SC2064,SC2063,SC2059,SC2053,SC2048,SC2044,SC2032,SC2031,SC2030,SC2029,SC2025,SC2024,SC2022,SC2018,SC2019,SC2017,SC2014,SC2013,SC2012,SC2009,SC2001,SC2098,SC2096,SC2094,SC2091,SC2092,SC2088,SC2087,SC2076,SC2072,SC2071,SC2223,SC2221,SC2222,SC2217,SC2207,SC2206,SC2205,SC2190,SC2188,SC2187,SC2185,SC2179,SC2178,SC2174,SC2168,SC2167,SC2163,SC2161,SC2160,SC2153,SC2150,SC2148,SC2147,SC2146,SC2142,SC2139,SC2126,SC2123,SC2120,SC2119,SC2117,SC2114,SC1117,SC2164,SC1083,SC2004,SC2125,SC2128,SC2011,SC1008,SC1019,SC2093,SC1132,SC1129,SC2236,SC2237,SC2231,SC2230,SC2229,SC2106,SC2102,SC2243,SC2244,SC2245,SC2247,SC2248,SC2249,SC2250,SC2251,SC2252,SC2181 diff --git a/libs/zlibng/.travis.yml b/libs/zlibng/.travis.yml deleted file mode 100644 index a27e41472..000000000 --- a/libs/zlibng/.travis.yml +++ /dev/null @@ -1,283 +0,0 @@ -language: c -cache: ccache -dist: xenial - -env: - global: - - BUILDDIR=. - - MAKER="make -j2" - - TESTER="make test" - -matrix: - include: - - os: windows - compiler: clang - env: - - GENERATOR="cmake . " - - MAKER="cmake --build . --config Release" - - TESTER="ctest --verbose -C Release" - - os: windows - compiler: clang - env: - - GENERATOR="cmake ..\\zlib-ng -DZLIB_COMPAT=ON" - - MAKER="cmake --build . --config Release" - - TESTER="ctest --verbose -C Release" - - BUILDDIR=..\\build - - os: windows - compiler: gcc - env: - - GENERATOR="cmake ." - - MAKER="cmake --build . --config Release" - - TESTER="ctest --verbose -C Release" - - - os: linux - compiler: gcc - env: GENERATOR="./configure --warn" - - os: linux - compiler: gcc - env: GENERATOR="cmake . -DZLIB_COMPAT=OFF -DWITH_GZFILEOP=ON -DWITH_NEW_STRATEGIES=YES -DWITH_OPTIM=ON" - - os: linux - compiler: gcc - env: - - GENERATOR="../zlib-ng/configure --warn --zlib-compat" - - BUILDDIR=../build - - os: linux - compiler: gcc - env: GENERATOR="./configure --warn --zlib-compat --without-optimizations --without-new-strategies" - - os: linux - compiler: gcc - env: GENERATOR="cmake ." - - os: linux - compiler: gcc - env: - - GENERATOR="cmake ../zlib-ng" - - BUILDDIR=../build - - - os: linux - compiler: clang - env: GENERATOR="./configure --warn --zlib-compat" - - os: linux - compiler: clang - env: - - GENERATOR="cmake ../zlib-ng" - - BUILDDIR=../build - - os: linux - compiler: clang - env: - - GENERATOR="scan-build -v --status-bugs cmake ../zlib-ng" - - MAKER="scan-build -v --status-bugs make" - - BUILDDIR=../build - - - os: osx - compiler: gcc - env: GENERATOR="./configure --warn --zlib-compat" - - os: osx - compiler: gcc - env: - - GENERATOR="../zlib-ng/configure --warn --zlib-compat" - - BUILDDIR=../build - - os: osx - compiler: gcc - env: GENERATOR="cmake ." - - - os: osx - compiler: clang - env: GENERATOR="./configure --warn --zlib-compat" - - os: osx - compiler: clang - env: - - GENERATOR="cmake ../zlib-ng" - - BUILDDIR=../build - - # compiling for linux-ppc64le variants - - os: linux-ppc64le - compiler: gcc - env: GENERATOR="cmake ." - - os: linux-ppc64le - compiler: gcc - env: - - GENERATOR="cmake ../zlib-ng" - - BUILDDIR=../build - - - os: linux-ppc64le - compiler: clang - env: GENERATOR="./configure --warn --zlib-compat" - - os: linux-ppc64le - compiler: clang - env: - - GENERATOR="cmake ../zlib-ng" - - BUILDDIR=../build - - # Cross compiling for arm variants - - os: linux - compiler: aarch64-linux-gnu-gcc - addons: - apt: - packages: - - qemu - - gcc-aarch64-linux-gnu - - libc-dev-arm64-cross - # For all aarch64 implementations NEON is mandatory, while crypto/crc are not. - env: - - GENERATOR="./configure --warn --zlib-compat" - - CHOST=aarch64-linux-gnu - - os: linux - compiler: aarch64-linux-gnu-gcc - addons: - apt: - packages: - - qemu - - gcc-aarch64-linux-gnu - - libc-dev-arm64-cross - # For all aarch64 implementations NEON is mandatory, while crypto/crc are not. - env: - - GENERATOR="cmake -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-aarch64.cmake . -DZLIB_COMPAT=ON" - - MAKER="cmake --build . --config Release" - - TESTER="ctest --verbose -C Release" - - os: linux - compiler: aarch64-linux-gnu-gcc - addons: - apt: - packages: - - qemu - - gcc-aarch64-linux-gnu - - libc-dev-arm64-cross - env: - - GENERATOR="./configure --warn --zlib-compat" - - CHOST=aarch64-linux-gnu - - os: linux - compiler: aarch64-linux-gnu-gcc - addons: - apt: - packages: - - qemu - - gcc-aarch64-linux-gnu - - libc-dev-arm64-cross - env: - - GENERATOR="cmake -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-aarch64.cmake ." - - MAKER="cmake --build . --config Release" - - TESTER="ctest --verbose -C Release" - # Hard-float subsets - - os: linux - compiler: arm-linux-gnueabihf-gcc - addons: - apt: - packages: - - qemu - - gcc-arm-linux-gnueabihf - - libc-dev-armhf-cross - env: - - GENERATOR="./configure --warn" - - CHOST=arm-linux-gnueabihf - - os: linux - compiler: arm-linux-gnueabihf-gcc - addons: - apt: - packages: - - qemu - - gcc-arm-linux-gnueabihf - - libc-dev-armhf-cross - env: - - GENERATOR="cmake -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-arm.cmake . -DCMAKE_C_COMPILER_TARGET=arm-linux-gnueabihf" - - MAKER="cmake --build . --config Release" - - TESTER="ctest --verbose -C Release" - - os: linux - compiler: arm-linux-gnueabihf-gcc - addons: - apt: - packages: - - qemu - - gcc-arm-linux-gnueabihf - - libc-dev-armhf-cross - env: - - GENERATOR="./configure --warn --zlib-compat --without-neon" - - CHOST=arm-linux-gnueabihf - - os: linux - compiler: arm-linux-gnueabihf-gcc - addons: - apt: - packages: - - qemu - - gcc-arm-linux-gnueabihf - - libc-dev-armhf-cross - env: - - GENERATOR="cmake -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-arm.cmake . -DZLIB_COMPAT=ON -DWITH_NEON=OFF -DCMAKE_C_COMPILER_TARGET=arm-linux-gnueabihf" - - MAKER="cmake --build . --config Release" - - TESTER="ctest --verbose -C Release" - - os: linux - compiler: arm-linux-gnueabihf-gcc - addons: - apt: - packages: - - qemu - - gcc-arm-linux-gnueabihf - - libc-dev-armhf-cross - env: - - GENERATOR="./configure --warn --zlib-compat" - - CHOST=arm-linux-gnueabihf - - os: linux - compiler: arm-linux-gnueabihf-gcc - addons: - apt: - packages: - - qemu - - gcc-arm-linux-gnueabihf - - libc-dev-armhf-cross - env: - - GENERATOR="cmake -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-arm.cmake . -DZLIB_COMPAT=ON -DCMAKE_C_COMPILER_TARGET=arm-linux-gnueabihf" - - MAKER="cmake --build . --config Release" - - TESTER="ctest --verbose -C Release" - # Soft-float subset - - os: linux - compiler: arm-linux-gnueabi-gcc - addons: - apt: - packages: - - qemu - - gcc-arm-linux-gnueabi - - libc-dev-armel-cross - env: - - GENERATOR="./configure" - - CHOST=arm-linux-gnueabi - - os: linux - compiler: arm-linux-gnueabi-gcc - addons: - apt: - packages: - - qemu - - gcc-arm-linux-gnueabi - - libc-dev-armel-cross - env: - - GENERATOR="cmake -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-arm.cmake . -DCMAKE_C_COMPILER_TARGET=arm-linux-gnueabi" - - MAKER="cmake --build . --config Release" - - TESTER="ctest --verbose -C Release" - - os: linux - compiler: arm-linux-gnueabi-gcc - addons: - apt: - packages: - - qemu - - gcc-arm-linux-gnueabi - - libc-dev-armel-cross - env: - - GENERATOR="./configure --zlib-compat" - - CHOST=arm-linux-gnueabi - - os: linux - compiler: arm-linux-gnueabi-gcc - addons: - apt: - packages: - - qemu - - gcc-arm-linux-gnueabi - - libc-dev-armel-cross - env: - - GENERATOR="cmake -DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-arm.cmake . -DZLIB_COMPAT=ON -DCMAKE_C_COMPILER_TARGET=arm-linux-gnueabi" - - MAKER="cmake --build . --config Release" - - TESTER="ctest --verbose -C Release" - -script: - - mkdir -p $BUILDDIR - - cd $BUILDDIR - - $GENERATOR - - $MAKER - - $TESTER diff --git a/libs/zlibng/CMakeLists.txt b/libs/zlibng/CMakeLists.txt index 9767a00c8..05087781e 100644 --- a/libs/zlibng/CMakeLists.txt +++ b/libs/zlibng/CMakeLists.txt @@ -1,9 +1,10 @@ cmake_minimum_required(VERSION 3.5.1) if(CMAKE_VERSION VERSION_LESS 3.12) - cmake_policy(VERSION ${CMAKE_VERSION}) + cmake_policy(VERSION ${CMAKE_VERSION}) else() - cmake_policy(VERSION 3.5.1...3.13.2) + cmake_policy(VERSION 3.5.1...3.13.2) endif() +message(STATUS "Using CMake version ${CMAKE_VERSION}") set(CMAKE_MACOSX_RPATH 1) @@ -11,17 +12,17 @@ set(CMAKE_MACOSX_RPATH 1) # Configuration items that affect the global compiler envirionment standards # should be issued before the "project" command. if(NOT CMAKE_C_STANDARD) - set (CMAKE_C_STANDARD 99) # The C standard whose features are requested to build this target + set(CMAKE_C_STANDARD 99) # The C standard whose features are requested to build this target endif() if(NOT CMAKE_C_STANDARD_REQUIRED) - set (CMAKE_C_STANDARD_REQUIRED ON) # Boolean describing whether the value of C_STANDARD is a requirement + set(CMAKE_C_STANDARD_REQUIRED ON) # Boolean describing whether the value of C_STANDARD is a requirement endif() if(NOT CMAKE_C_EXTENSIONS) - set (CMAKE_C_EXTENSIONS OFF) # Boolean specifying whether compiler specific extensions are requested + set(CMAKE_C_EXTENSIONS OFF) # Boolean specifying whether compiler specific extensions are requested endif() set(VALID_C_STANDARDS "99" "11") -if(NOT CMAKE_C_STANDARD IN_LIST VALID_C_STANDARDS ) - MESSAGE(FATAL_ERROR "CMAKE_C_STANDARD:STRING=${CMAKE_C_STANDARD} not in know standards list\n ${VALID_C_STANDARDS}") +if(NOT CMAKE_C_STANDARD IN_LIST VALID_C_STANDARDS) + MESSAGE(FATAL_ERROR "CMAKE_C_STANDARD:STRING=${CMAKE_C_STANDARD} not in know standards list\n ${VALID_C_STANDARDS}") endif() # Parse the full version number from zlib.h and include in ZLIB_FULL_VERSION @@ -33,15 +34,13 @@ string(REGEX REPLACE ".*#define[ \t]+ZLIBNG_VERSION[ \t]+\"([-0-9A-Za-z.]+)\".*" message(STATUS "ZLIB_HEADER_VERSION: ${ZLIB_HEADER_VERSION}") message(STATUS "ZLIBNG_HEADER_VERSION: ${ZLIBNG_HEADER_VERSION}") -project(zlib - VERSION ${ZLIB_HEADER_VERSION} - LANGUAGES C) +project(zlib VERSION ${ZLIB_HEADER_VERSION} LANGUAGES C) -set(INSTALL_BIN_DIR "${CMAKE_INSTALL_PREFIX}/bin" CACHE PATH "Installation directory for executables") -set(INSTALL_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib" CACHE PATH "Installation directory for libraries") -set(INSTALL_INC_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE PATH "Installation directory for headers") -set(INSTALL_MAN_DIR "${CMAKE_INSTALL_PREFIX}/share/man" CACHE PATH "Installation directory for manual pages") -set(INSTALL_PKGCONFIG_DIR "${CMAKE_INSTALL_PREFIX}/share/pkgconfig" CACHE PATH "Installation directory for pkgconfig (.pc) files") +set(BIN_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/bin" CACHE PATH "Installation directory for executables") +set(LIB_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/lib" CACHE PATH "Installation directory for libraries") +set(INC_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE PATH "Installation directory for headers") +set(MAN_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/share/man" CACHE PATH "Installation directory for manual pages") +set(PKGCONFIG_INSTALL_DIR "${LIB_INSTALL_DIR}/pkgconfig" CACHE PATH "Installation directory for pkgconfig (.pc) files") include(CheckTypeSize) include(CheckSymbolExists) @@ -52,6 +51,13 @@ include(CheckCSourceRuns) include(CMakeDependentOption) include(FeatureSummary) +include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/detect-arch.cmake) +include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/detect-sanitizer.cmake) + +if(CMAKE_TOOLCHAIN_FILE) + message(STATUS "Using CMake toolchain: ${CMAKE_TOOLCHAIN_FILE}") +endif() + # Make sure we use an appropriate BUILD_TYPE by default, "Release" to be exact # this should select the maximum generic optimisation on the current platform (i.e. -O3 for gcc/clang) if(NOT CMAKE_BUILD_TYPE) @@ -63,64 +69,67 @@ else() add_feature_info(CMAKE_BUILD_TYPE 1 "Build type: ${CMAKE_BUILD_TYPE} (selected)") endif() -check_include_file(sys/types.h HAVE_SYS_TYPES_H) -check_include_file(stdint.h HAVE_STDINT_H) -check_include_file(stddef.h HAVE_STDDEF_H) -check_include_file(sys/sdt.h HAVE_SYS_SDT_H) - -if(CMAKE_OSX_ARCHITECTURES) - # If multiple architectures are requested (universal build), pick only the first - list(GET CMAKE_OSX_ARCHITECTURES 0 ARCH) -else() - set(ARCH ${CMAKE_SYSTEM_PROCESSOR}) -endif() -message(STATUS "Architecture: ${ARCH}") -if(CMAKE_TOOLCHAIN_FILE) - message(STATUS "Using cmake toolchain: ${CMAKE_TOOLCHAIN_FILE}") -endif() - # # Options parsing # -option(WITH_GZFILEOP "Compile with support for gzFile related functions" OFF) -option(ZLIB_COMPAT "Compile with zlib compatible API" OFF) -option(ZLIB_ENABLE_TESTS "Build test binaries" ON) -option(WITH_SANITIZERS "Build with address sanitizer and all supported sanitizers other than memory sanitizer" OFF) -option(WITH_MSAN "Build with memory sanitizer" OFF) -option(WITH_FUZZERS "Build test/fuzz" OFF) -option(WITH_OPTIM "Build with optimisation" ON) -option(WITH_NEW_STRATEGIES "Use new strategies" ON) -option(WITH_NATIVE_INSTRUCTIONS +macro(add_option name description value) + option(${name} ${description} ${value}) + add_feature_info(${name} ${name} ${description}) +endmacro() + +add_option(WITH_GZFILEOP "Compile with support for gzFile related functions" ON) +add_option(ZLIB_COMPAT "Compile with zlib compatible API" OFF) +add_option(ZLIB_ENABLE_TESTS "Build test binaries" ON) +add_option(ZLIB_DUAL_LINK "Dual link tests against system zlib" OFF) +add_option(WITH_SANITIZER "Build with sanitizer (Memory, Address, Undefined)" OFF) +add_option(WITH_FUZZERS "Build test/fuzz" OFF) +add_option(WITH_OPTIM "Build with optimisation" ON) +add_option(WITH_NEW_STRATEGIES "Use new strategies" ON) +add_option(WITH_NATIVE_INSTRUCTIONS "Instruct the compiler to use the full instruction set on this host (gcc/clang -march=native)" OFF) -if("${ARCH}" MATCHES "arm" OR "${ARCH}" MATCHES "aarch64") - option(WITH_ACLE "Build with ACLE CRC" ON) - option(WITH_NEON "Build with NEON intrinsics" ON) -elseif("${ARCH}" MATCHES "s390x") - option(WITH_DFLTCC_DEFLATE "Use DEFLATE CONVERSION CALL instruction for compression on IBM Z" OFF) - option(WITH_DFLTCC_INFLATE "Use DEFLATE CONVERSION CALL instruction for decompression on IBM Z" OFF) -endif() +add_option(WITH_MAINTAINER_WARNINGS "Build with project maintainer warnings" OFF) +add_option(WITH_CODE_COVERAGE "Enable code coverage reporting" OFF) +add_option(WITH_INFLATE_STRICT "Build with strict inflate distance checking" OFF) +add_option(WITH_INFLATE_ALLOW_INVALID_DIST "Build with zero fill for inflate invalid distances" OFF) +add_option(WITH_UNALIGNED "Support unaligned reads on platforms that support it" ON) -add_feature_info(ZLIB_COMPAT ZLIB_COMPAT "Provide a zlib-compatible API") -add_feature_info(WITH_GZFILEOP WITH_GZFILEOP "Compile with support for gzFile-related functions") -add_feature_info(WITH_OPTIM WITH_OPTIM "Build with optimisation") -add_feature_info(WITH_SANITIZERS WITH_SANITIZERS "Build with address sanitizer and all supported sanitizers other than memory sanitizer") -add_feature_info(WITH_MSAN WITH_MSAN "Build with memory sanitizer") -add_feature_info(WITH_FUZZERS WITH_FUZZERS "Build test/fuzz") -add_feature_info(WITH_NEW_STRATEGIES WITH_NEW_STRATEGIES "Use new strategies") -if("${ARCH}" MATCHES "arm" OR "${ARCH}" MATCHES "aarch64") - add_feature_info(WITH_ACLE WITH_ACLE "Build with ACLE CRC") - add_feature_info(WITH_NEON WITH_NEON "Build with NEON intrinsics") +if(BASEARCH_ARM_FOUND) + add_option(WITH_ACLE "Build with ACLE" ON) + add_option(WITH_NEON "Build with NEON intrinsics" ON) +elseif(BASEARCH_PPC_FOUND) + add_option(WITH_POWER8 "Build with optimisations for POWER8" ON) +elseif(BASEARCH_S360_FOUND) + add_option(WITH_DFLTCC_DEFLATE "Use DEFLATE CONVERSION CALL instruction for compression on IBM Z" OFF) + add_option(WITH_DFLTCC_INFLATE "Use DEFLATE CONVERSION CALL instruction for decompression on IBM Z" OFF) +elseif(BASEARCH_X86_FOUND) + add_option(WITH_AVX2 "Build with AVX2" ON) + add_option(WITH_SSE2 "Build with SSE2" ON) + add_option(WITH_SSSE3 "Build with SSSE3" ON) + add_option(WITH_SSE4 "Build with SSE4" ON) + add_option(WITH_PCLMULQDQ "Build with PCLMULQDQ" ON) endif() +add_option(INSTALL_UTILS "Copy minigzip and minideflate during install" OFF) -if (ZLIB_COMPAT) +mark_as_advanced(FORCE + ZLIB_DUAL_LINK + WITH_ACLE WITH_NEON + WITH_DFLTCC_DEFLATE + WITH_DFLTCC_INFLATE + WITH_AVX2 WITH_SSE2 + WITH_SSSE3 WITH_SSE4 + WITH_PCLMULQDQ + WITH_POWER8 + WITH_INFLATE_STRICT + WITH_INFLATE_ALLOW_INVALID_DIST + WITH_UNALIGNED + INSTALL_UTILS + ) + +if(ZLIB_COMPAT) add_definitions(-DZLIB_COMPAT) set(WITH_GZFILEOP ON) - set(LIBNAME1 libz) - set(LIBNAME2 zlib) - set(SUFFIX "") + set(SUFFIX "-ng") else() - set(LIBNAME1 libz-ng) - set(LIBNAME2 zlib-ng) set(SUFFIX "-ng") endif() @@ -128,36 +137,48 @@ if(WITH_GZFILEOP) add_definitions(-DWITH_GZFILEOP) endif() -if(${CMAKE_C_COMPILER} MATCHES "icc" OR ${CMAKE_C_COMPILER} MATCHES "icpc" OR ${CMAKE_C_COMPILER} MATCHES "icl") - if(WITH_NATIVE_INSTRUCTIONS) - message(STATUS "Ignoring WITH_NATIVE_INSTRUCTIONS; not supported on this configuration") - endif() - if(CMAKE_HOST_UNIX) - if(NOT SSE2FLAG) +if("${CMAKE_C_COMPILER}" MATCHES "icc" OR "${CMAKE_C_COMPILER}" MATCHES "icpc" OR "${CMAKE_C_COMPILER}" MATCHES "icl") + if(CMAKE_HOST_UNIX OR APPLE) + set(WARNFLAGS "-w3") + set(WARNFLAGS_MAINTAINER "-w3 -Wcheck -Wremarks") + set(WARNFLAGS_DISABLE "") + if(BASEARCH_X86_FOUND) + set(AVX2FLAG "-mavx2") set(SSE2FLAG "-msse2") - endif() - if(NOT SSE4FLAG) + set(SSSE3FLAG "-mssse3") set(SSE4FLAG "-msse4.2") endif() else() - if(NOT SSE2FLAG) + set(WARNFLAGS "/W3") + set(WARNFLAGS_MAINTAINER "/W5") + set(WARNFLAGS_DISABLE "") + if(BASEARCH_X86_FOUND) + set(AVX2FLAG "/arch:AVX2") set(SSE2FLAG "/arch:SSE2") - endif() - if(NOT SSE4FLAG) + set(SSSE3FLAG "/arch:SSSE3") set(SSE4FLAG "/arch:SSE4.2") endif() endif() + if(WITH_NATIVE_INSTRUCTIONS) + message(STATUS "Ignoring WITH_NATIVE_INSTRUCTIONS; not supported on this configuration") + endif() elseif(MSVC) # TODO. ICC can be used through MSVC. I'm not sure if we'd ever see that combination # (who'd use cmake from an IDE...) but checking for ICC before checking for MSVC should # avoid mistakes. # /Oi ? - if(NOT ${ARCH} MATCHES "AMD64") - set(SSE2FLAG "/arch:SSE2") - endif() - if("${ARCH}" MATCHES "arm") - add_definitions("-D_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE=1") - set(NEONFLAG "/arch:VFPv4") + set(WARNFLAGS "/W3") + set(WARNFLAGS_MAINTAINER "/W4") + set(WARNFLAGS_DISABLE "") + if(BASEARCH_ARM_FOUND) + add_definitions(-D_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE) + if(NOT "${ARCH}" MATCHES "aarch64") + set(NEONFLAG "/arch:VFPv4") + endif() + elseif(BASEARCH_X86_FOUND) + if(NOT "${ARCH}" MATCHES "x86_64") + set(SSE2FLAG "/arch:SSE2") + endif() endif() if(WITH_NATIVE_INSTRUCTIONS) message(STATUS "Ignoring WITH_NATIVE_INSTRUCTIONS; not supported on this configuration") @@ -167,85 +188,160 @@ else() if(CMAKE_C_COMPILER_ID MATCHES "GNU" OR CMAKE_C_COMPILER_ID MATCHES "Clang") set(__GNUC__ ON) endif() + # Enable warnings in GCC and Clang + if(__GNUC__) + set(WARNFLAGS "-Wall") + set(WARNFLAGS_MAINTAINER "-Wextra -Wpedantic") + set(WARNFLAGS_DISABLE "-Wno-implicit-fallthrough") + endif() if(WITH_NATIVE_INSTRUCTIONS) if(__GNUC__) - set(NATIVEFLAG "-march=native") + if(BASEARCH_PPC_FOUND) + set(NATIVEFLAG "-mcpu=native") + else() + set(NATIVEFLAG "-march=native") + endif() else() message(STATUS "Ignoring WITH_NATIVE_INSTRUCTIONS; not implemented yet on this configuration") endif() endif() - if(__GNUC__ AND "${ARCH}" MATCHES "arm") - execute_process(COMMAND ${CMAKE_C_COMPILER} "-dumpmachine" - OUTPUT_VARIABLE GCC_MACHINE) - if ("${GCC_MACHINE}" MATCHES "eabihf") - set(FLOATABI "-mfloat-abi=hard") - else() - set(FLOATABI "-mfloat-abi=softfp") - endif() - endif() if(NOT NATIVEFLAG) - if(NOT SSE2FLAG) - if(__GNUC__) + if(__GNUC__) + if(BASEARCH_ARM_FOUND) + if(NOT CMAKE_C_FLAGS MATCHES "-mfloat-abi") + # Check support for ARM floating point + execute_process(COMMAND ${CMAKE_C_COMPILER} "-dumpmachine" + OUTPUT_VARIABLE GCC_MACHINE) + if("${GCC_MACHINE}" MATCHES "gnueabihf") + set(FLOATABI "-mfloat-abi=hard") + elseif("${GCC_MACHINE}" MATCHES ".*gnueabi") + set(FLOATABI "-mfloat-abi=softfp") + endif() + message(STATUS "ARM floating point arch: ${FLOATABI}") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${FLOATABI}") + endif() + # NEON + if("${ARCH}" MATCHES "aarch64") + set(NEONFLAG "-march=armv8-a+simd") + else() + # Check whether -mfpu=neon is available + set(CMAKE_REQUIRED_FLAGS "-mfpu=neon") + check_c_source_compiles( + "int main() { return 0; }" + MFPU_NEON_AVAILABLE FAIL_REGEX "not supported") + set(CMAKE_REQUIRED_FLAGS) + if(MFPU_NEON_AVAILABLE) + set(NEONFLAG "-mfpu=neon") + endif() + endif() + # ACLE + set(ACLEFLAG "-march=armv8-a+crc") + elseif(BASEARCH_PPC_FOUND) + set(POWER8FLAG "-mcpu=power8") + elseif(BASEARCH_X86_FOUND) + set(AVX2FLAG "-mavx2") set(SSE2FLAG "-msse2") - endif() - endif() - if(NOT SSE4FLAG) - if(__GNUC__) + set(SSSE3FLAG "-mssse3") set(SSE4FLAG "-msse4") - endif() - endif() - if(NOT PCLMULFLAG) - if(__GNUC__) set(PCLMULFLAG "-mpclmul") endif() endif() - if("${ARCH}" MATCHES "arm") - set(ACLEFLAG "-march=armv8-a+crc") - set(NEONFLAG "${FLOATABI} -mfpu=neon") - elseif("${ARCH}" MATCHES "aarch64") - set(ACLEFLAG "-march=armv8-a+crc") - set(NEONFLAG "-march=armv8-a+crc+simd") - endif() - else() - set(SSE2FLAG ${NATIVEFLAG}) - set(SSE4FLAG ${NATIVEFLAG}) - set(PCLMULFLAG ${NATIVEFLAG}) - if("${ARCH}" MATCHES "arm") - set(ACLEFLAG "${NATIVEFLAG}") - set(NEONFLAG "${FLOATABI} -mfpu=neon") - elseif("${ARCH}" MATCHES "aarch64") - set(ACLEFLAG "${NATIVEFLAG}") - set(NEONFLAG "${NATIVEFLAG}") - endif() endif() endif() +# Replace optimization level 3 added by default with level 2 +if(NOT MSVC AND NOT CMAKE_C_FLAGS MATCHES "([\\/\\-]O)3") + string(REGEX REPLACE "([\\/\\-]O)3" "\\12" + CMAKE_C_FLAGS_RELEASE ${CMAKE_C_FLAGS_RELEASE}) +endif() + +# Set architecture alignment requirements +if(WITH_UNALIGNED) + if(BASEARCH_ARM_FOUND OR (BASEARCH_PPC_FOUND AND "${ARCH}" MATCHES "powerpc64le") OR BASEARCH_X86_FOUND) + if(NOT DEFINED UNALIGNED_OK) + set(UNALIGNED_OK TRUE) + endif() + endif() + if(UNALIGNED_OK) + add_definitions(-DUNALIGNED_OK) + message(STATUS "Architecture supports unaligned reads") + endif() + if(BASEARCH_ARM_FOUND) + if(NOT DEFINED UNALIGNED64_OK) + if("${ARCH}" MATCHES "(arm(v[8-9])?|aarch64)") + set(UNALIGNED64_OK TRUE) + endif() + endif() + endif() + if(BASEARCH_PPC_FOUND) + if(NOT DEFINED UNALIGNED64_OK) + if("${ARCH}" MATCHES "powerpc64le") + set(UNALIGNED64_OK TRUE) + endif() + endif() + endif() + if(BASEARCH_X86_FOUND) + if(NOT DEFINED UNALIGNED64_OK) + set(UNALIGNED64_OK TRUE) + endif() + endif() + if(UNALIGNED64_OK) + add_definitions(-DUNALIGNED64_OK) + message(STATUS "Architecture supports unaligned reads of > 4 bytes") + endif() +else() + message(STATUS "Unaligned reads manually disabled") +endif() + +# Apply warning compiler flags +if(WITH_MAINTAINER_WARNINGS) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNFLAGS} ${WARNFLAGS_MAINTAINER} ${WARNFLAGS_DISABLE}") +else() + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNFLAGS} ${WARNFLAGS_DISABLE}") +endif() + +# Set code coverage compiler flags +if(WITH_CODE_COVERAGE) + if(CMAKE_C_COMPILER_ID MATCHES "Clang") + set(CMAKE_C_FLAGS "-O0 ${CMAKE_C_FLAGS} -coverage") + elseif(__GNUC__) + # Some versions of GCC don't support -coverage shorthand + set(CMAKE_C_FLAGS "-O0 ${CMAKE_C_FLAGS} -ftest-coverage -fprofile-arcs -fprofile-values") + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lgcov -fprofile-arcs") + set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -lgcov -fprofile-arcs") + endif() +endif() + +# Set native instruction set compiler flag +if(WITH_NATIVE_INSTRUCTIONS AND DEFINED NATIVEFLAG) + # Apply flag to all source files and compilation checks + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${NATIVEFLAG}") +endif() + +# +# Check for stndard/system includes +# +check_include_file(sys/types.h HAVE_SYS_TYPES_H) +check_include_file(stdarg.h HAVE_STDARG_H) +check_include_file(stdint.h HAVE_STDINT_H) +check_include_file(stddef.h HAVE_STDDEF_H) +check_include_file(sys/sdt.h HAVE_SYS_SDT_H) +check_include_file(unistd.h HAVE_UNISTD_H) + # # Check to see if we have large file support # set(CMAKE_REQUIRED_DEFINITIONS -D_LARGEFILE64_SOURCE=1 -D__USE_LARGEFILE64) -# We add these other definitions here because CheckTypeSize.cmake -# in CMake 2.4.x does not automatically do so and we want -# compatibility with CMake 2.4.x. -if(HAVE_SYS_TYPES_H) - list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_SYS_TYPES_H) -endif() -if(HAVE_STDINT_H) - list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDINT_H) -endif() -if(HAVE_STDDEF_H) - list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDDEF_H) -endif() check_type_size(off64_t OFF64_T) if(HAVE_OFF64_T) - add_definitions(-D_LARGEFILE64_SOURCE=1 -D__USE_LARGEFILE64) + add_definitions(-D_LARGEFILE64_SOURCE=1 -D__USE_LARGEFILE64) else() - check_type_size(_off64_t _OFF64_T) - if(HAVE__OFF64_T) - add_definitions(-D_LARGEFILE64_SOURCE=1 -D__USE_LARGEFILE64) - else() - check_type_size(__off64_t __OFF64_T) - endif() + check_type_size(_off64_t _OFF64_T) + if(HAVE__OFF64_T) + add_definitions(-D_LARGEFILE64_SOURCE=1 -D__USE_LARGEFILE64) + else() + check_type_size(__off64_t __OFF64_T) + endif() endif() set(CMAKE_REQUIRED_DEFINITIONS) # clear variable @@ -261,104 +357,81 @@ if(NOT HAVE_STRERROR) add_definitions(-DNO_STRERROR) endif() +if(WITH_SANITIZER STREQUAL "Address") + add_address_sanitizer() +elseif(WITH_SANITIZER STREQUAL "Memory") + add_memory_sanitizer() +elseif(WITH_SANITIZER STREQUAL "Undefined") + add_undefined_sanitizer() +endif() + # -# Check for unistd.h and stdarg.h +# Check whether compiler supports -fno-semantic-interposition parameter # -check_include_file(unistd.h Z_HAVE_UNISTD_H) - -if(WITH_SANITIZERS AND WITH_MSAN) - message(FATAL_ERROR "Memory sanitizer is incompatible with address sanitizer") -endif() - -if(WITH_MSAN) - set(CMAKE_REQUIRED_FLAGS "-fsanitize=memory") - check_c_source_compiles("int main() { return 0; }" HAS_MSAN FAIL_REGEX "not supported") - if(${HAS_MSAN}) - set(SANITIZERS_FLAGS "-fsanitize=memory") - message(STATUS "Adding memory sanitizer flag: ${SANITIZERS_FLAGS}") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SANITIZERS_FLAGS}") - endif() -endif() - -if(WITH_SANITIZERS) - set(_sanitize_flags - bool - address - array-bounds - float-divide-by-zero - function - integer-divide-by-zero - return - shift - signed-integer-overflow - undefined - unsigned-integer-overflow - vla-bound - vptr - ) - set(SANITIZERS_FLAGS "") - foreach(_flag ${_sanitize_flags}) - set(CMAKE_REQUIRED_FLAGS "-fsanitize=${_flag}") - check_c_source_compiles("int main() { return 0; }" - HAS_SANITIZER_${_flag} FAIL_REGEX "not supported") - if(${HAS_SANITIZER_${_flag}}) - if("${SANITIZERS_FLAGS}" STREQUAL "") - set(SANITIZERS_FLAGS "-fsanitize=${_flag}") - else() - set(SANITIZERS_FLAGS "${SANITIZERS_FLAGS},${_flag}") - endif() - endif() - set(CMAKE_REQUIRED_FLAGS) - endforeach() - message(STATUS "Adding sanitizers flags: ${SANITIZERS_FLAGS}") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SANITIZERS_FLAGS}") -endif() +set(CMAKE_REQUIRED_FLAGS "-fno-semantic-interposition") +check_c_source_compiles( + "int main() { return 0; }" + HAVE_NO_INTERPOSITION +) +set(CMAKE_REQUIRED_FLAGS) # # Check if we can hide zlib internal symbols that are linked between separate source files using hidden # check_c_source_compiles( - "#define ZLIB_INTERNAL __attribute__((visibility (\"hidden\"))) - int ZLIB_INTERNAL foo; - int main() - { - return 0; + "#define Z_INTERNAL __attribute__((visibility (\"hidden\"))) + int Z_INTERNAL foo; + int main() { + return 0; }" HAVE_ATTRIBUTE_VISIBILITY_HIDDEN FAIL_REGEX "not supported") if(HAVE_ATTRIBUTE_VISIBILITY_HIDDEN) - add_definitions(-DHAVE_HIDDEN) + add_definitions(-DHAVE_VISIBILITY_HIDDEN) endif() # # Check if we can hide zlib internal symbols that are linked between separate source files using internal # check_c_source_compiles( - "#define ZLIB_INTERNAL __attribute__((visibility (\"internal\"))) - int ZLIB_INTERNAL foo; - int main() - { - return 0; + "#define Z_INTERNAL __attribute__((visibility (\"internal\"))) + int Z_INTERNAL foo; + int main() { + return 0; }" HAVE_ATTRIBUTE_VISIBILITY_INTERNAL FAIL_REGEX "not supported") if(HAVE_ATTRIBUTE_VISIBILITY_INTERNAL) - add_definitions(-DHAVE_INTERNAL) + add_definitions(-DHAVE_VISIBILITY_INTERNAL) endif() # -# check for __builtin_ctzl() support in the compiler +# check for __builtin_ctz() support in the compiler # check_c_source_compiles( - "int main(void) - { + "int main(void) { unsigned int zero = 0; - long test = __builtin_ctzl(zero); + long test = __builtin_ctz(zero); (void)test; return 0; }" - HAVE_BUILTIN_CTZL + HAVE_BUILTIN_CTZ ) -if(HAVE_BUILTIN_CTZL) - add_definitions(-DHAVE_BUILTIN_CTZL) +if(HAVE_BUILTIN_CTZ) + add_definitions(-DHAVE_BUILTIN_CTZ) +endif() +# +# check for __builtin_ctzll() support in the compiler +# +check_c_source_compiles( + "int main(void) { + unsigned int zero = 0; + long test = __builtin_ctzll(zero); + (void)test; + return 0; + }" + HAVE_BUILTIN_CTZLL +) +if(HAVE_BUILTIN_CTZLL) + add_definitions(-DHAVE_BUILTIN_CTZLL) endif() # @@ -366,28 +439,32 @@ endif() # check_c_source_compiles( "#include - int main() { ptrdiff_t *a; return 0; }" + int main() { + ptrdiff_t *a; + (void)a; + return 0; + }" HAVE_PTRDIFF_T ) if(NOT HAVE_PTRDIFF_T) - set(NEED_PTRDIFF_T 1) + set(NEED_PTRDIFF_T 1) - check_type_size("void *" SIZEOF_DATA_PTR) - message(STATUS "sizeof(void *) is ${SIZEOF_DATA_PTR} bytes") + check_type_size("void *" SIZEOF_DATA_PTR) + message(STATUS "sizeof(void *) is ${SIZEOF_DATA_PTR} bytes") - if(${SIZEOF_DATA_PTR} MATCHES "4") - set(PTRDIFF_TYPE "uint32_t") - elseif(${SIZEOF_DATA_PTR} MATCHES "8") - set(PTRDIFF_TYPE "uint64_t") - else() - message(FATAL_ERROR "sizeof(void *) is neither 32 nor 64 bit") - endif() + if(${SIZEOF_DATA_PTR} MATCHES "4") + set(PTRDIFF_TYPE "uint32_t") + elseif(${SIZEOF_DATA_PTR} MATCHES "8") + set(PTRDIFF_TYPE "uint64_t") + else() + message(FATAL_ERROR "sizeof(void *) is neither 32 nor 64 bit") + endif() endif() -# Macro to check if source compiles when cross-compiling -# or runs when compiling natively +# Macro to check if source compiles +# (and, when compiling very natively, also runs). macro(check_c_source_compile_or_run source flag) - if(CMAKE_CROSSCOMPILING) + if(CMAKE_CROSSCOMPILING OR NOT WITH_NATIVE_INSTRUCTIONS) check_c_source_compiles("${source}" ${flag}) else() check_c_source_runs("${source}" ${flag}) @@ -400,67 +477,95 @@ if(MSVC) set(CMAKE_DEBUG_POSTFIX "d") add_definitions(-D_CRT_SECURE_NO_DEPRECATE) add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE) -else() - # - # Not MSVC, so we need to check if we have the MS-style SSE etc. intrinsics - # - if(WITH_NATIVE_INSTRUCTIONS) - set(CMAKE_REQUIRED_FLAGS "${NATIVEFLAG}") - else() - set(CMAKE_REQUIRED_FLAGS "${SSE2FLAG}") - endif() +endif() + +if(BASEARCH_PPC_FOUND) + # Check if we have what we need for POWER8 optimizations + set(CMAKE_REQUIRED_FLAGS "${POWER8FLAG}") + check_c_source_compiles( + "#include + int main() { + return (getauxval(AT_HWCAP2) & PPC_FEATURE2_ARCH_2_07); + }" + HAVE_POWER8 + ) + set(CMAKE_REQUIRED_FLAGS) +elseif(BASEARCH_X86_FOUND) + # Check whether compiler supports SSE2 instrinics + set(CMAKE_REQUIRED_FLAGS "${SSE2FLAG}") check_c_source_compile_or_run( "#include - int main(void) - { + int main(void) { __m128i zero = _mm_setzero_si128(); (void)zero; return 0; }" HAVE_SSE2_INTRIN ) - set(CMAKE_REQUIRED_FLAGS) - - if(WITH_NATIVE_INSTRUCTIONS) - set(CMAKE_REQUIRED_FLAGS "${NATIVEFLAG}") - else() - # Use the generic SSE4 enabler option to check for the SSE4.2 instruction we require: - set(CMAKE_REQUIRED_FLAGS "${SSE4FLAG}") - endif() + # Check whether compiler supports SSSE3 intrinsics + set(CMAKE_REQUIRED_FLAGS "${SSSE3FLAG}") check_c_source_compile_or_run( - "int main(void) - { - unsigned val = 0, h = 0; - __asm__ __volatile__ ( \"crc32 %1,%0\" : \"+r\" (h) : \"r\" (val) ); - return (int) h; + "#include + int main(void) { + __m128i u, v, w; + u = _mm_set1_epi32(1); + v = _mm_set1_epi32(2); + w = _mm_hadd_epi32(u, v); + (void)w; + return 0; }" - HAVE_SSE42_INTRIN + HAVE_SSSE3_INTRIN ) + # Check whether compiler supports SSE4 CRC inline asm + set(CMAKE_REQUIRED_FLAGS "${SSE4FLAG}") check_c_source_compile_or_run( - "int main(void) - { + "int main(void) { + unsigned val = 0, h = 0; + #if defined(_MSC_VER) + { __asm mov edx, h __asm mov eax, val __asm crc32 eax, edx __asm mov val, eax } + #else + __asm__ __volatile__ ( \"crc32 %1,%0\" : \"+r\" (h) : \"r\" (val) ); + #endif + return (int)h; + }" + HAVE_SSE42CRC_INLINE_ASM + ) + # Check whether compiler supports SSE4 CRC intrinsics + check_c_source_compile_or_run( + "#include + int main(void) { unsigned crc = 0; char c = 'c'; + #if defined(_MSC_VER) + crc = _mm_crc32_u32(crc, c); + #else crc = __builtin_ia32_crc32qi(crc, c); + #endif (void)crc; return 0; }" HAVE_SSE42CRC_INTRIN ) - set(CMAKE_REQUIRED_FLAGS) - - if(WITH_NATIVE_INSTRUCTIONS) - set(CMAKE_REQUIRED_FLAGS "${NATIVEFLAG}") - else() - set(CMAKE_REQUIRED_FLAGS "${PCLMULFLAG}") - endif() - if(NOT (APPLE AND ${ARCH} MATCHES "i386")) + # Check whether compiler supports SSE4.2 compare string instrinics + check_c_source_compile_or_run( + "#include + int main(void) { + unsigned char a[64] = { 0 }; + unsigned char b[64] = { 0 }; + __m128i xmm_src0, xmm_src1; + xmm_src0 = _mm_loadu_si128((__m128i *)(char *)a); + xmm_src1 = _mm_loadu_si128((__m128i *)(char *)b); + return _mm_cmpestri(xmm_src0, 16, xmm_src1, 16, 0); + }" + HAVE_SSE42CMPSTR_INTRIN + ) + # Check whether compiler supports PCLMULQDQ intrinsics + set(CMAKE_REQUIRED_FLAGS "${PCLMULFLAG}") + if(NOT (APPLE AND "${ARCH}" MATCHES "i386")) # The pclmul code currently crashes on Mac in 32bit mode. Avoid for now. check_c_source_compile_or_run( "#include - #include - int main(void) - { + int main(void) { __m128i a = _mm_setzero_si128(); __m128i b = _mm_setzero_si128(); __m128i c = _mm_clmulepi64_si128(a, b, 0x10); @@ -472,150 +577,180 @@ else() else() set(HAVE_PCLMULQDQ_INTRIN NO) endif() + # Check whether compiler supports AVX2 intrinics + set(CMAKE_REQUIRED_FLAGS "${AVX2FLAG}") + check_c_source_compile_or_run( + "#include + int main(void) { + __m256i x = _mm256_set1_epi16(2); + const __m256i y = _mm256_set1_epi16(1); + x = _mm256_subs_epu16(x, y); + (void)x; + return 0; + }" + HAVE_AVX2_INTRIN + ) set(CMAKE_REQUIRED_FLAGS) + + # FORCE_SSE2 option will only be shown if HAVE_SSE2_INTRIN is true + if("${ARCH}" MATCHES "i[3-6]86") + cmake_dependent_option(FORCE_SSE2 "Always assume CPU is SSE2 capable" OFF "HAVE_SSE2_INTRIN" OFF) + endif() endif() -# Check whether -mfpu=neon is available -set(CMAKE_REQUIRED_FLAGS "-mfpu=neon") -check_c_source_compiles( - "int main() - { - return 0; - }" - MFPU_NEON_AVAILABLE FAIL_REGEX "not supported") -set(CMAKE_REQUIRED_FLAGS) - -# FORCE_SSE2 option will only be shown if HAVE_SSE2_INTRIN is true -if("${ARCH}" MATCHES "i[3-6]86") - cmake_dependent_option(FORCE_SSE2 "Always assume CPU is SSE2 capable" OFF "HAVE_SSE2_INTRIN" OFF) +# +# Enable deflate_quick at level 1 +# +if(NOT WITH_NEW_STRATEGIES) + add_definitions(-DNO_QUICK_STRATEGY) endif() - # # Enable deflate_medium at level 4-6 # if(NOT WITH_NEW_STRATEGIES) add_definitions(-DNO_MEDIUM_STRATEGY) endif() +# +# Enable inflate compilation options +# +if(WITH_INFLATE_STRICT) + add_definitions(-DINFLATE_STRICT) + message(STATUS "Inflate strict distance checking enabled") +endif() +if(WITH_INFLATE_ALLOW_INVALID_DIST) + add_definitions(-DINFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR) + message(STATUS "Inflate zero data for invalid distances enabled") +endif() -# -# Macro to add either the given intrinsics option to the global compiler options, -# or ${NATIVEFLAG} (-march=native) if that is appropriate and possible. -# An alternative version of this macro would take a file argument, and set ${flag} -# only for that file as opposed to ${NATIVEFLAG} globally, to limit side-effect of -# using ${flag} globally. -# -macro(add_intrinsics_option flag) - if(WITH_NATIVE_INSTRUCTIONS AND NATIVEFLAG) - if (NOT "${CMAKE_C_FLAGS} " MATCHES ".*${NATIVEFLAG} .*") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${NATIVEFLAG}") - endif() - else() - if (NOT "${CMAKE_C_FLAGS} " MATCHES ".*${flag} .*") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}") - endif() - endif() -endmacro() set(ZLIB_ARCH_SRCS) +set(ZLIB_ARCH_HDRS) set(ARCHDIR "arch/generic") -if("${ARCH}" MATCHES "x86_64" OR "${ARCH}" MATCHES "AMD64" OR "${ARCH}" MATCHES "i[3-6]86") - set(ARCHDIR "arch/x86") - add_definitions(-DUNALIGNED_OK) - add_feature_info(SSE2 1 "Support the SSE2 instruction set, using \"${SSE2FLAG}\"") -elseif("${ARCH}" MATCHES "arm" OR "${ARCH}" MATCHES "aarch64") +if(BASEARCH_ARM_FOUND) set(ARCHDIR "arch/arm") - add_definitions(-DUNALIGNED_OK) -elseif("${ARCH}" MATCHES "s390x") +elseif(BASEARCH_PPC_FOUND) + set(ARCHDIR "arch/power") +elseif(BASEARCH_S360_FOUND) set(ARCHDIR "arch/s390") +elseif(BASEARCH_X86_FOUND) + set(ARCHDIR "arch/x86") + if(NOT ${ARCH} MATCHES "x86_64") + add_feature_info(SSE2 1 "Support the SSE2 instruction set, using \"${SSE2FLAG}\"") + endif() else() message(STATUS "No optimized architecture: using ${ARCHDIR}") endif() -if("${ARCH}" MATCHES "arm" OR "${ARCH}" MATCHES "aarch64") - set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/armfeature.c ${ARCHDIR}/fill_window_arm.c) -endif() + if(WITH_OPTIM) - if("${ARCH}" MATCHES "arm") - if(WITH_ACLE) - set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/crc32_acle.c ${ARCHDIR}/insert_string_acle.c) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ACLEFLAG}") - add_definitions("-DARM_ACLE_CRC_HASH") - add_feature_info(ACLE_CRC 1 "Support CRC hash generation using the ACLE instruction set, using \"${ACLEFLAG}\"") + if(BASEARCH_ARM_FOUND) + add_definitions(-DARM_FEATURES) + list(APPEND ZLIB_ARCH_HDRS ${ARCHDIR}/arm.h) + list(APPEND ZLIB_ARCH_SRCS ${ARCHDIR}/armfeature.c) + if(WITH_ACLE AND NOT MSVC) + add_definitions(-DARM_ACLE_CRC_HASH) + set(ACLE_SRCS ${ARCHDIR}/crc32_acle.c ${ARCHDIR}/insert_string_acle.c) + set_property(SOURCE ${ACLE_SRCS} PROPERTY COMPILE_FLAGS "${ACLEFLAG}") + list(APPEND ZLIB_ARCH_SRCS ${ACLE_SRCS}) + add_feature_info(ACLE_CRC 1 "Support ACLE optimized CRC hash generation, using \"${ACLEFLAG}\"") endif() if(WITH_NEON) - if(MFPU_NEON_AVAILABLE) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${NEONFLAG}") - endif() - add_definitions("-DARM_NEON_ADLER32") + add_definitions(-DARM_NEON_ADLER32 -DARM_NEON_CHUNKSET -DARM_NEON_SLIDEHASH) + set(NEON_SRCS ${ARCHDIR}/adler32_neon.c ${ARCHDIR}/chunkset_neon.c ${ARCHDIR}/slide_neon.c) + list(APPEND ZLIB_ARCH_SRCS ${NEON_SRCS}) + set_property(SOURCE ${NEON_SRCS} PROPERTY COMPILE_FLAGS "${NEONFLAG}") if(MSVC) - add_definitions("-D__ARM_NEON__=1") - endif(MSVC) - set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/adler32_neon.c) - add_feature_info(NEON_FILLWINDOW 1 "Support NEON instructions in fill_window_arm, using \"${NEONFLAG}\"") + add_definitions(-D__ARM_NEON__) + endif() + add_feature_info(NEON_ADLER32 1 "Support NEON instructions in adler32, using \"${NEONFLAG}\"") + add_feature_info(NEON_SLIDEHASH 1 "Support NEON instructions in slide_hash, using \"${NEONFLAG}\"") endif() - elseif("${ARCH}" MATCHES "aarch64") - if(WITH_ACLE) - set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/crc32_acle.c ${ARCHDIR}/insert_string_acle.c) - add_definitions("-DARM_ACLE_CRC_HASH") - add_feature_info(ACLE_CRC 1 "Support CRC hash generation using the ACLE instruction set, using \"${ACLEFLAG}\"") + elseif(BASEARCH_PPC_FOUND) + if(WITH_POWER8 AND HAVE_POWER8) + add_definitions(-DPOWER8) + add_definitions(-DPOWER_FEATURES) + add_definitions(-DPOWER8_VSX_ADLER32) + add_definitions(-DPOWER8_VSX_SLIDEHASH) + list(APPEND ZLIB_ARCH_HDRS ${ARCHDIR}/power.h) + list(APPEND ZLIB_ARCH_SRCS ${ARCHDIR}/power.c) + set(POWER8_SRCS ${ARCHDIR}/adler32_power8.c ${ARCHDIR}/slide_hash_power8.c) + list(APPEND ZLIB_ARCH_SRCS ${POWER8_SRCS}) + set_property(SOURCE ${POWER8_SRCS} PROPERTY COMPILE_FLAGS "${POWER8FLAG}") endif() - # We need to check WITH_NEON first - if(WITH_NEON) - add_definitions("-DARM_NEON_ADLER32") - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${NEONFLAG}") - set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/adler32_neon.c) - add_feature_info(NEON_FILLWINDOW 1 "Support NEON instructions in fill_window_arm, using \"${NEONFLAG}\"") - elseif(WITH_ACLE) - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ACLEFLAG}") + elseif(BASEARCH_S360_FOUND) + if(WITH_DFLTCC_DEFLATE OR WITH_DFLTCC_INFLATE) + list(APPEND ZLIB_ARCH_SRCS ${ARCHDIR}/dfltcc_common.c) + add_definitions(-DGZBUFSIZE=262144) endif() - elseif("${ARCHDIR}" MATCHES "arch/x86") - add_definitions("-DX86_CPUID") - set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/x86.c) - if(HAVE_SSE42_INTRIN) - add_definitions(-DX86_SSE4_2_CRC_HASH) - set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/insert_string_sse.c) - add_feature_info(SSE4_CRC 1 "Support CRC hash generation using the SSE4.2 instruction set, using \"${SSE4FLAG}\"") - add_intrinsics_option("${SSE4FLAG}") + if(WITH_DFLTCC_DEFLATE) + add_definitions(-DS390_DFLTCC_DEFLATE) + list(APPEND ZLIB_ARCH_SRCS ${ARCHDIR}/dfltcc_deflate.c) + endif() + if(WITH_DFLTCC_INFLATE) + add_definitions(-DS390_DFLTCC_INFLATE) + list(APPEND ZLIB_ARCH_SRCS ${ARCHDIR}/dfltcc_inflate.c) + endif() + elseif(BASEARCH_X86_FOUND) + add_definitions(-DX86_FEATURES) + list(APPEND ZLIB_ARCH_HDRS ${ARCHDIR}/x86.h) + list(APPEND ZLIB_ARCH_SRCS ${ARCHDIR}/x86.c) + if(MSVC) + list(APPEND ZLIB_ARCH_HDRS fallback_builtins.h) + endif() + if(WITH_AVX2 AND HAVE_AVX2_INTRIN) + add_definitions(-DX86_AVX2 -DX86_AVX2_ADLER32 -DX86_AVX_CHUNKSET) + set(AVX2_SRCS ${ARCHDIR}/slide_avx.c) + add_feature_info(AVX2_SLIDEHASH 1 "Support AVX2 optimized slide_hash, using \"${AVX2FLAG}\"") + list(APPEND AVX2_SRCS ${ARCHDIR}/chunkset_avx.c) + add_feature_info(AVX_CHUNKSET 1 "Support AVX optimized chunkset, using \"${AVX2FLAG}\"") + list(APPEND AVX2_SRCS ${ARCHDIR}/compare258_avx.c) + add_feature_info(AVX2_COMPARE258 1 "Support AVX2 optimized compare258, using \"${AVX2FLAG}\"") + list(APPEND AVX2_SRCS ${ARCHDIR}/adler32_avx.c) + add_feature_info(AVX2_ADLER32 1 "Support AVX2-accelerated adler32, using \"${AVX2FLAG}\"") + list(APPEND ZLIB_ARCH_SRCS ${AVX2_SRCS}) + set_property(SOURCE ${AVX2_SRCS} PROPERTY COMPILE_FLAGS "${AVX2FLAG}") + endif() + if(WITH_SSE4 AND (HAVE_SSE42CRC_INLINE_ASM OR HAVE_SSE42CRC_INTRIN)) + add_definitions(-DX86_SSE42_CRC_HASH) + set(SSE42_SRCS ${ARCHDIR}/insert_string_sse.c) + add_feature_info(SSE42_CRC 1 "Support SSE4.2 optimized CRC hash generation, using \"${SSE4FLAG}\"") + list(APPEND ZLIB_ARCH_SRCS ${SSE42_SRCS}) + set_property(SOURCE ${SSE42_SRCS} PROPERTY COMPILE_FLAGS "${SSE4FLAG}") if(HAVE_SSE42CRC_INTRIN) - add_definitions(-DX86_SSE4_2_CRC_INTRIN) - endif() - if(WITH_NEW_STRATEGIES) - add_definitions(-DX86_QUICK_STRATEGY) - set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/deflate_quick.c) - add_feature_info(SSE4DEFLATE 1 "Support SSE4.2-accelerated quick compression") + add_definitions(-DX86_SSE42_CRC_INTRIN) endif() endif() - if(HAVE_SSE2_INTRIN) - add_definitions(-DX86_SSE2) - set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/fill_window_sse.c) + if(HAVE_SSE42CMPSTR_INTRIN) + add_definitions(-DX86_SSE42_CMP_STR) + set(SSE42_SRCS ${ARCHDIR}/compare258_sse.c) + add_feature_info(SSE42_COMPARE258 1 "Support SSE4.2 optimized compare258, using \"${SSE4FLAG}\"") + list(APPEND ZLIB_ARCH_SRCS ${SSE42_SRCS}) + set_property(SOURCE ${SSE42_SRCS} PROPERTY COMPILE_FLAGS "${SSE4FLAG}") + endif() + if(WITH_SSE2 AND HAVE_SSE2_INTRIN) + add_definitions(-DX86_SSE2 -DX86_SSE2_CHUNKSET -DX86_SSE2_SLIDEHASH) + set(SSE2_SRCS ${ARCHDIR}/chunkset_sse.c ${ARCHDIR}/slide_sse.c) + list(APPEND ZLIB_ARCH_SRCS ${SSE2_SRCS}) if(NOT ${ARCH} MATCHES "x86_64") - add_intrinsics_option("${SSE2FLAG}") + set_property(SOURCE ${SSE2_SRCS} PROPERTY COMPILE_FLAGS "${SSE2FLAG}") add_feature_info(FORCE_SSE2 FORCE_SSE2 "Assume CPU is SSE2 capable") if(FORCE_SSE2) add_definitions(-DX86_NOCHECK_SSE2) endif() endif() endif() - if(HAVE_PCLMULQDQ_INTRIN) + if(WITH_SSSE3 AND HAVE_SSSE3_INTRIN) + add_definitions(-DX86_SSSE3 -DX86_SSSE3_ADLER32) + set(SSSE3_SRCS ${ARCHDIR}/adler32_ssse3.c) + add_feature_info(SSSE3_ADLER32 1 "Support SSSE3-accelerated adler32, using \"${SSSE3FLAG}\"") + list(APPEND ZLIB_ARCH_SRCS ${SSSE3_SRCS}) + set_property(SOURCE ${SSSE3_SRCS} PROPERTY COMPILE_FLAGS "${SSSE3FLAG}") + endif() + if(WITH_PCLMULQDQ AND HAVE_PCLMULQDQ_INTRIN AND WITH_SSSE3 AND WITH_SSE4) add_definitions(-DX86_PCLMULQDQ_CRC) - set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/crc_folding.c) - add_intrinsics_option("${PCLMULFLAG}") - if(HAVE_SSE42_INTRIN) - add_feature_info(PCLMUL_CRC 1 "Support CRC hash generation using PCLMULQDQ, using \"${PCLMULFLAG}\"") - else() - add_feature_info(PCLMUL_CRC 1 "Support CRC hash generation using PCLMULQDQ, using \"${PCLMULFLAG} ${SSE4FLAG}\"") - endif() - endif() - elseif("${ARCH}" MATCHES "s390x") - if(WITH_DFLTCC_DEFLATE OR WITH_DFLTCC_INFLATE) - set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/dfltcc_common.c) - endif() - if(WITH_DFLTCC_DEFLATE) - add_definitions(-DS390_DFLTCC_DEFLATE) - set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/dfltcc_deflate.c) - endif() - if(WITH_DFLTCC_INFLATE) - add_definitions(-DS390_DFLTCC_INFLATE) - set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/dfltcc_inflate.c) + set(PCLMULQDQ_SRCS ${ARCHDIR}/crc_folding.c) + add_feature_info(PCLMUL_CRC 1 "Support CRC hash generation using PCLMULQDQ, using \"${SSSE3FLAG} ${SSE4FLAG} ${PCLMULFLAG}\"") + list(APPEND ZLIB_ARCH_SRCS ${PCLMULQDQ_SRCS}) + set_property(SOURCE ${PCLMULQDQ_SRCS} PROPERTY COMPILE_FLAGS "${SSSE3FLAG} ${SSE4FLAG} ${PCLMULFLAG}") endif() endif() endif() @@ -629,15 +764,13 @@ macro(generate_cmakein input output) file(REMOVE ${output}) file(STRINGS ${input} _lines) foreach(_line IN LISTS _lines) - file(APPEND ${output} "${_line}\n") - - if (_line STREQUAL "#define ZCONF_H" OR _line STREQUAL "#define ZCONFNG_H") - file(APPEND ${output} "#cmakedefine Z_HAVE_UNISTD_H\n") - if(NOT HAVE_PTRDIFF_T) - file(APPEND ${output} "#cmakedefine NEED_PTRDIFF_T\n") - file(APPEND ${output} "#cmakedefine PTRDIFF_TYPE ${PTRDIFF_TYPE}\n") - endif() + string(REGEX REPLACE "#ifdef HAVE_UNISTD_H.*" "@ZCONF_UNISTD_LINE@" _line "${_line}") + string(REGEX REPLACE "#ifdef HAVE_STDARG_H.*" "@ZCONF_STDARG_LINE@" _line "${_line}") + string(REGEX REPLACE "#ifdef NEED_PTRDIFF_T.*" "@ZCONF_PTRDIFF_LINE@" _line "${_line}") + if(NEED_PTRDIFF_T) + string(REGEX REPLACE "typedef PTRDIFF_TYPE" "typedef @PTRDIFF_TYPE@" _line "${_line}") endif() + file(APPEND ${output} "${_line}\n") endforeach() endmacro(generate_cmakein) @@ -665,12 +798,18 @@ if(NOT CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR) endif() endif() -set(ZLIB_PC ${CMAKE_CURRENT_BINARY_DIR}/${LIBNAME2}.pc) -configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/zlib.pc.cmakein - ${ZLIB_PC} @ONLY) -configure_file(${CMAKE_CURRENT_BINARY_DIR}/zconf${SUFFIX}.h.cmakein - ${CMAKE_CURRENT_BINARY_DIR}/zconf${SUFFIX}.h @ONLY) - +# Refer to prefix symbolically to ease relocation by end user, +# as Makefile-generated .pc file does. +if(INC_INSTALL_DIR STREQUAL "${CMAKE_INSTALL_PREFIX}/include") + set(PC_INC_INSTALL_DIR "\${prefix}/include") +else() + set(PC_INC_INSTALL_DIR "${INSTALL_INC_DIR}") +endif() +if(LIB_INSTALL_DIR STREQUAL "${CMAKE_INSTALL_PREFIX}/lib") + set(PC_LIB_INSTALL_DIR "\${exec_prefix}/lib") +else() + set(PC_LIB_INSTALL_DIR "${INSTALL_LIB_DIR}") +endif() #============================================================================ # zlib @@ -681,37 +820,55 @@ set(ZLIB_PUBLIC_HDRS zlib${SUFFIX}.h ) set(ZLIB_PRIVATE_HDRS - crc32.h + adler32_p.h + chunkset_tpl.h + crc32_p.h + crc32_tbl.h + crc32_comb_tbl.h deflate.h + deflate_p.h functable.h - gzguts.h inffast.h - inffixed.h + inffixed_tbl.h inflate.h + inflate_p.h inftrees.h + insert_string_tpl.h + match_tpl.h trees.h + trees_emit.h + trees_tbl.h + zbuild.h + zendian.h zutil.h ) set(ZLIB_SRCS adler32.c + chunkset.c + compare258.c compress.c crc32.c + crc32_comb.c deflate.c deflate_fast.c deflate_medium.c + deflate_quick.c deflate_slow.c functable.c - inflate.c infback.c - inftrees.c inffast.c + inflate.c + inftrees.c + insert_string.c trees.c uncompr.c zutil.c ) +set(ZLIB_GZFILE_PRIVATE_HDRS + gzguts.h +) set(ZLIB_GZFILE_SRCS - gzclose.c gzlib.c gzread.c gzwrite.c @@ -739,65 +896,120 @@ if(MINGW OR MSYS) set(ZLIB_DLL_SRCS ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj) endif() -add_library(zlib SHARED ${ZLIB_SRCS} ${ZLIB_ARCH_SRCS} ${ZLIB_ASMS} ${ZLIB_DLL_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS}) -target_include_directories(zlib PUBLIC ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) -add_library(zlibstatic STATIC ${ZLIB_SRCS} ${ZLIB_ARCH_SRCS} ${ZLIB_ASMS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS}) -target_include_directories(zlibstatic PUBLIC ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) - +set(ZLIB_ALL_SRCS ${ZLIB_SRCS} ${ZLIB_ARCH_HDRS} ${ZLIB_ARCH_SRCS} ${ZLIB_DLL_SRCS} + ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS}) if(WITH_GZFILEOP) - target_sources(zlib PRIVATE ${ZLIB_GZFILE_SRCS}) - target_sources(zlibstatic PRIVATE ${ZLIB_GZFILE_SRCS}) + list(APPEND ZLIB_ALL_SRCS ${ZLIB_GZFILE_PRIVATE_HDRS} ${ZLIB_GZFILE_SRCS}) endif() -set_target_properties(zlib PROPERTIES DEFINE_SYMBOL ZLIB_DLL) -set_target_properties(zlib PROPERTIES SOVERSION 1) +if(NOT DEFINED BUILD_SHARED_LIBS) + add_library(zlib SHARED ${ZLIB_ALL_SRCS}) + add_library(zlibstatic STATIC ${ZLIB_ALL_SRCS}) -if (ZLIB_COMPAT) - set(ZLIB_FULL_VERSION ${ZLIB_HEADER_VERSION}) + set(ZLIB_INSTALL_LIBRARIES zlib zlibstatic) else() - set(ZLIB_FULL_VERSION ${ZLIBNG_HEADER_VERSION}) -endif() -if(NOT CYGWIN) - # This property causes shared libraries on Linux to have the full version - # encoded into their final filename. We disable this on Cygwin because - # it causes cygz-${ZLIB_FULL_VERSION}.dll to be created when cygz.dll - # seems to be the default. - # - # This has no effect with MSVC, on that platform the version info for - # the DLL comes from the resource file win32/zlib1.rc - set_target_properties(zlib PROPERTIES VERSION ${ZLIB_FULL_VERSION}) + add_library(zlib ${ZLIB_ALL_SRCS}) + + set(ZLIB_INSTALL_LIBRARIES zlib) endif() +foreach(ZLIB_INSTALL_LIBRARY ${ZLIB_INSTALL_LIBRARIES}) + target_include_directories(${ZLIB_INSTALL_LIBRARY} PUBLIC + ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) +endforeach() -if(UNIX) +if(WIN32) + set_target_properties(${ZLIB_INSTALL_LIBRARIES} PROPERTIES OUTPUT_NAME zlib${SUFFIX}) +else() # On unix-like platforms the library is almost always called libz - set_target_properties(zlib zlibstatic PROPERTIES OUTPUT_NAME z${SUFFIX}) - if(NOT APPLE) - set_target_properties(zlib PROPERTIES LINK_FLAGS "-Wl,--version-script,\"${CMAKE_CURRENT_SOURCE_DIR}/${LIBNAME2}.map\"") - endif() -elseif(MSYS) - # Suppress version number from shared library name - set(CMAKE_SHARED_LIBRARY_NAME_WITH_VERSION 0) -elseif(BUILD_SHARED_LIBS AND WIN32) - # Creates zlib1.dll when building shared library version - set_target_properties(zlib PROPERTIES SUFFIX "1.dll") + set_target_properties(${ZLIB_INSTALL_LIBRARIES} PROPERTIES OUTPUT_NAME z${SUFFIX}) endif() -if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL ) - install(TARGETS zlib zlibstatic - RUNTIME DESTINATION "${INSTALL_BIN_DIR}" - ARCHIVE DESTINATION "${INSTALL_LIB_DIR}" - LIBRARY DESTINATION "${INSTALL_LIB_DIR}" ) +if(NOT DEFINED BUILD_SHARED_LIBS OR BUILD_SHARED_LIBS) + set_target_properties(zlib PROPERTIES DEFINE_SYMBOL ZLIB_DLL) + + if(ZLIB_COMPAT) + set(ZLIB_FULL_VERSION ${ZLIB_HEADER_VERSION}.zlib-ng) + set_target_properties(zlib PROPERTIES SOVERSION 1) + else() + set(ZLIB_FULL_VERSION ${ZLIBNG_HEADER_VERSION}) + set_target_properties(zlib PROPERTIES SOVERSION 2) + endif() + + if(NOT CYGWIN) + # This property causes shared libraries on Linux to have the full version + # encoded into their final filename. We disable this on Cygwin because + # it causes cygz-${ZLIB_FULL_VERSION}.dll to be created when cygz.dll + # seems to be the default. + # + # This has no effect with MSVC, on that platform the version info for + # the DLL comes from the resource file win32/zlib1.rc + set_target_properties(zlib PROPERTIES VERSION ${ZLIB_FULL_VERSION}) + endif() + + if(UNIX) + if(HAVE_NO_INTERPOSITION) + set_target_properties(zlib PROPERTIES COMPILE_FLAGS "-fno-semantic-interposition") + endif() + if(NOT APPLE) + set_target_properties(zlib PROPERTIES LINK_FLAGS + "-Wl,--version-script,\"${CMAKE_CURRENT_SOURCE_DIR}/zlib${SUFFIX}.map\"") + else() + # Match configure/make's behavior (i.e. don't use @rpath on mac). + set_target_properties(zlib PROPERTIES INSTALL_NAME_DIR "${LIB_INSTALL_DIR}") + endif() + elseif(MSYS) + # Suppress version number from shared library name + set(CMAKE_SHARED_LIBRARY_NAME_WITH_VERSION 0) + elseif(WIN32) + # Creates zlib1.dll when building shared library version + if(ZLIB_COMPAT) + set_target_properties(zlib PROPERTIES SUFFIX "1.dll") + else() + set_target_properties(zlib PROPERTIES SUFFIX "2.dll") + endif() + endif() endif() -if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL ) - install(FILES zlib${SUFFIX}.h DESTINATION "${INSTALL_INC_DIR}" RENAME zlib${SUFFIX}.h) - install(FILES ${CMAKE_CURRENT_BINARY_DIR}/zconf${SUFFIX}.h DESTINATION "${INSTALL_INC_DIR}" RENAME zconf${SUFFIX}.h) + +if(HAVE_STDARG_H) + SET(ZCONF_STDARG_LINE "#if 1 /* was set to #if 1 by configure/cmake/etc */") +else() + SET(ZCONF_STDARG_LINE "#ifdef HAVE_STDARG_H /* may be set to #if 1 by configure/cmake/etc */") endif() -if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL ) - install(FILES zlib.3 DESTINATION "${INSTALL_MAN_DIR}/man3" RENAME zlib${SUFFIX}.3) +if(HAVE_UNISTD_H) + SET(ZCONF_UNISTD_LINE "#if 1 /* was set to #if 1 by configure/cmake/etc */") +else() + SET(ZCONF_UNISTD_LINE "#ifdef HAVE_UNISTD_H /* may be set to #if 1 by configure/cmake/etc */") endif() -if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL ) - install(FILES ${ZLIB_PC} DESTINATION "${INSTALL_PKGCONFIG_DIR}") +if(NEED_PTRDIFF_T) + SET(ZCONF_PTRDIFF_LINE "#if 1 /* was set to #if 1 by configure/cmake/etc */") +else() + SET(ZCONF_PTRDIFF_LINE "#ifdef NEED_PTRDIFF_T /* may be set to #if 1 by configure/cmake/etc */") +endif() + +set(ZLIB_PC ${CMAKE_CURRENT_BINARY_DIR}/zlib${SUFFIX}.pc) +configure_file(${CMAKE_CURRENT_SOURCE_DIR}/zlib.pc.cmakein + ${ZLIB_PC} @ONLY) +configure_file(${CMAKE_CURRENT_BINARY_DIR}/zconf${SUFFIX}.h.cmakein + ${CMAKE_CURRENT_BINARY_DIR}/zconf${SUFFIX}.h @ONLY) + +if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL) + install(TARGETS ${ZLIB_INSTALL_LIBRARIES} + RUNTIME DESTINATION "${BIN_INSTALL_DIR}" + ARCHIVE DESTINATION "${LIB_INSTALL_DIR}" + LIBRARY DESTINATION "${LIB_INSTALL_DIR}") +endif() +if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL) + install(FILES zlib${SUFFIX}.h + DESTINATION "${INC_INSTALL_DIR}" RENAME zlib${SUFFIX}.h) + install(FILES ${CMAKE_CURRENT_BINARY_DIR}/zconf${SUFFIX}.h + DESTINATION "${INC_INSTALL_DIR}" RENAME zconf${SUFFIX}.h) +endif() +if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL) + install(FILES zlib.3 DESTINATION "${MAN_INSTALL_DIR}/man3" RENAME zlib${SUFFIX}.3) +endif() +if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL) + install(FILES ${ZLIB_PC} DESTINATION "${PKGCONFIG_INSTALL_DIR}") endif() #============================================================================ @@ -805,33 +1017,115 @@ endif() #============================================================================ option(ZLIB_ENABLE_TESTS "Build test binaries" ON) -if (ZLIB_ENABLE_TESTS) +if(ZLIB_ENABLE_TESTS) enable_testing() macro(configure_test_executable target) - target_link_libraries(${target} zlib) + target_include_directories(${target} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) if(NOT WITH_GZFILEOP) target_compile_definitions(${target} PUBLIC -DWITH_GZFILEOP) - target_sources(${target} PRIVATE ${ZLIB_GZFILE_SRCS}) + target_sources(${target} PRIVATE ${ZLIB_GZFILE_PRIVATE_HDRS} ${ZLIB_GZFILE_SRCS}) + endif() + if(ZLIB_DUAL_LINK) + find_package(ZLIB) + if(ZLIB_FOUND) + target_link_libraries(${target} ${ZLIB_LIBRARIES}) + endif() endif() endmacro() + add_executable(adler32_test test/adler32_test.c) + configure_test_executable(adler32_test) + target_link_libraries(adler32_test zlib) + + set(ADLER32TEST_COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $) + add_test(NAME adler32_test COMMAND ${ADLER32TEST_COMMAND}) + add_executable(example test/example.c) configure_test_executable(example) - add_test(NAME example COMMAND example${CMAKE_EXECUTABLE_SUFFIX}) + target_link_libraries(example zlib) + set(EXAMPLE_COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $) + add_test(NAME example COMMAND ${EXAMPLE_COMMAND}) + + set(MINIGZIP_COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $) add_executable(minigzip test/minigzip.c) configure_test_executable(minigzip) - - if(HAVE_OFF64_T) - add_executable(example64 test/example.c) - configure_test_executable(example64) - set_target_properties(example64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64") - add_test(NAME example64 COMMAND example64${CMAKE_EXECUTABLE_SUFFIX}) - - add_executable(minigzip64 test/minigzip.c) - configure_test_executable(minigzip64) - set_target_properties(minigzip64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64") + if(NOT DEFINED BUILD_SHARED_LIBS) + target_link_libraries(minigzip zlibstatic) + else() + target_link_libraries(minigzip zlib) endif() + if(BASEARCH_S360_FOUND) + if(WITH_DFLTCC_DEFLATE OR WITH_DFLTCC_INFLATE) + set_source_files_properties(test/minigzip.c PROPERTIES COMPILE_DEFINITIONS BUFLEN=262144) + endif() + endif() + + set(MINIDEFLATE_COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $) + add_executable(minideflate test/minideflate.c) + configure_test_executable(minideflate) + target_link_libraries(minideflate zlib) + + if(INSTALL_UTILS) + install(TARGETS minigzip minideflate + RUNTIME DESTINATION "${BIN_INSTALL_DIR}" + ARCHIVE DESTINATION "${LIB_INSTALL_DIR}" + LIBRARY DESTINATION "${LIB_INSTALL_DIR}") + endif() + + set(SWITCHLEVELS_COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $) + add_executable(switchlevels test/switchlevels.c) + configure_test_executable(switchlevels) + target_link_libraries(switchlevels zlib) + + add_executable(infcover test/infcover.c inftrees.c) + configure_test_executable(infcover) + target_link_libraries(infcover zlib) + + add_executable(makefixed tools/makefixed.c inftrees.c) + target_include_directories(makefixed PUBLIC ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) + + set(MAKEFIXED_COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $) + add_test(NAME makefixed + COMMAND ${CMAKE_COMMAND} + "-DCOMMAND=${MAKEFIXED_COMMAND}" + -DOUTPUT=${CMAKE_CURRENT_SOURCE_DIR}/inffixed_tbl._h + -DCOMPARE=${CMAKE_CURRENT_SOURCE_DIR}/inffixed_tbl.h + -DIGNORE_LINE_ENDINGS=ON + -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/run-and-compare.cmake) + + add_executable(maketrees tools/maketrees.c trees.c zutil.c) + target_include_directories(maketrees PUBLIC ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) + + set(MAKETREES_COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $) + add_test(NAME maketrees + COMMAND ${CMAKE_COMMAND} + "-DCOMMAND=${MAKETREES_COMMAND}" + -DOUTPUT=${CMAKE_CURRENT_SOURCE_DIR}/trees_tbl._h + -DCOMPARE=${CMAKE_CURRENT_SOURCE_DIR}/trees_tbl.h + -DIGNORE_LINE_ENDINGS=ON + -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/run-and-compare.cmake) + + add_executable(makecrct tools/makecrct.c) + target_include_directories(makecrct PUBLIC ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) + + set(MAKECRCT_COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $) + add_test(NAME makecrct-crc32 + COMMAND ${CMAKE_COMMAND} + "-DCOMMAND=${MAKECRCT_COMMAND}" + -DOUTPUT=${CMAKE_CURRENT_SOURCE_DIR}/crc32_tbl._h + -DCOMPARE=${CMAKE_CURRENT_SOURCE_DIR}/crc32_tbl.h + -DIGNORE_LINE_ENDINGS=ON + -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/run-and-compare.cmake) + + set(MAKECRCT_COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $ -c) + add_test(NAME makecrct-crc32-combine + COMMAND ${CMAKE_COMMAND} + "-DCOMMAND=${MAKECRCT_COMMAND}" + -DOUTPUT=${CMAKE_CURRENT_SOURCE_DIR}/crc32_comb_tbl._h + -DCOMPARE=${CMAKE_CURRENT_SOURCE_DIR}/crc32_comb_tbl.h + -DIGNORE_LINE_ENDINGS=ON + -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/run-and-compare.cmake) if(WITH_FUZZERS) set(FUZZERS checksum compress example_small example_large example_flush example_dict minigzip) @@ -839,10 +1133,73 @@ if (ZLIB_ENABLE_TESTS) foreach(FUZZER ${FUZZERS}) add_executable(${FUZZER}_fuzzer test/fuzz/${FUZZER}_fuzzer.c test/fuzz/standalone_fuzz_target_runner.c) configure_test_executable(${FUZZER}_fuzzer) - add_test(${FUZZER}_fuzzer ${FUZZER}_fuzzer${CMAKE_EXECUTABLE_SUFFIX} ${ALL_SRC_FILES}) + target_link_libraries(${FUZZER}_fuzzer zlib) + set(FUZZER_COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $ ${ALL_SRC_FILES}) + add_test(NAME ${FUZZER}_fuzzer COMMAND ${FUZZER_COMMAND}) endforeach() endif() + macro(test_minigzip name path) + # Construct compression arguments for minigzip + set(compress_args -k -c) + foreach(extra_arg IN ITEMS "${ARGN}") + list(APPEND compress_args ${extra_arg}) + endforeach() + + # Create unique friendly string for test + string(REPLACE ";" "" arg_list "${ARGN}") + string(REPLACE " " "" arg_list "${arg_list}") + string(REPLACE "-" "" arg_list "${arg_list}") + + set(test_id minigzip-${name}-${arg_list}) + + if(NOT TEST ${test_id}) + add_test(NAME ${test_id} + COMMAND ${CMAKE_COMMAND} + "-DTARGET=${MINIGZIP_COMMAND}" + "-DCOMPRESS_ARGS=${compress_args}" + "-DDECOMPRESS_ARGS=-d;-c" + -DINPUT=${CMAKE_CURRENT_SOURCE_DIR}/${path} + -DOUTPUT=${CMAKE_CURRENT_SOURCE_DIR}/${path}-${test_id}.gz + -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/test-compress.cmake) + endif() + endmacro() + + set(TEST_CONFIGS + -R # Z_RLE + -h # Z_HUFFMAN_ONLY + -T # Direct store + -0 # No compression + -1 # Deflate quick + -4 # Deflate medium (lazy matches) + "-5;-F" # Deflate medium (Z_FIXED) + -6 # Deflate medium + -9 # Deflate slow + "-9;-f" # Deflate slow (Z_FILTERED) + ) + + file(GLOB_RECURSE TEST_FILE_PATHS + LIST_DIRECTORIES false + RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/test/data/*) + + foreach(TEST_FILE_PATH ${TEST_FILE_PATHS}) + if("${TEST_FILE_PATH}" MATCHES ".gz$" OR "${TEST_FILE_PATH}" MATCHES ".out$" OR + "${TEST_FILE_PATH}" MATCHES "/.git/" OR "${TEST_FILE_PATH}" MATCHES ".md$") + continue() + endif() + foreach(TEST_CONFIG ${TEST_CONFIGS}) + get_filename_component(TEST_NAME ${TEST_FILE_PATH} NAME_WE) + if (TEST_NAME STREQUAL "") + continue() + endif() + test_minigzip(${TEST_NAME} ${TEST_FILE_PATH} ${TEST_CONFIG}) + endforeach() + endforeach() + + test_minigzip("detect-text" "test/data/lcet10.txt" -A) + test_minigzip("detect-binary" "test/data/paper-100k.pdf" -A) + set(CVES CVE-2002-0059 CVE-2004-0797 CVE-2005-1849 CVE-2005-2096) foreach(CVE ${CVES}) set(CVE_COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $ -d) @@ -857,9 +1214,72 @@ if (ZLIB_ENABLE_TESTS) if(NOT WIN32 AND ZLIB_COMPAT) add_executable(CVE-2003-0107 test/CVE-2003-0107.c) target_link_libraries(CVE-2003-0107 zlib) - add_test(NAME CVE-2003-0107 COMMAND CVE-2003-0107) + set(CVE20030107_COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $) + add_test(NAME CVE-2003-0107 COMMAND ${CVE20030107_COMMAND}) endif() + + set(INFCOVER_COMMAND ${CMAKE_CROSSCOMPILING_EMULATOR} $) + add_test(NAME infcover COMMAND ${INFCOVER_COMMAND}) + + add_test(NAME GH-361 + COMMAND ${CMAKE_COMMAND} + "-DTARGET=${MINIGZIP_COMMAND}" + "-DCOMPRESS_ARGS=-c;-k;-4" + -DINPUT=${CMAKE_CURRENT_SOURCE_DIR}/test/GH-361/test.txt + -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/test-compress.cmake) + + add_test(NAME GH-364 + COMMAND ${CMAKE_COMMAND} + "-DCOMPRESS_TARGET=${SWITCHLEVELS_COMMAND}" + "-DCOMPRESS_ARGS=1;5;9;3" + "-DDECOMPRESS_TARGET=${MINIGZIP_COMMAND}" + -DINPUT=${CMAKE_CURRENT_SOURCE_DIR}/test/GH-364/test.bin + -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/test-compress.cmake) + + add_test(NAME GH-382 + COMMAND ${CMAKE_COMMAND} + "-DTARGET=${MINIDEFLATE_COMMAND}" + "-DCOMPRESS_ARGS=-c;-m;1;-w;-15;-1;-s;4" + "-DDECOMPRESS_ARGS=-c;-d;-m;1;-w;-15" + -DGZIP_VERIFY=OFF + -DINPUT=${CMAKE_CURRENT_SOURCE_DIR}/test/GH-382/defneg3.dat + -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/test-compress.cmake) + + add_test(NAME GH-536-segfault + COMMAND ${CMAKE_COMMAND} + "-DCOMPRESS_TARGET=${SWITCHLEVELS_COMMAND}" + "-DCOMPRESS_ARGS=6;9744;1;91207" + "-DDECOMPRESS_TARGET=${MINIGZIP_COMMAND}" + -DCOMPARE=OFF + -DGZIP_VERIFY=OFF + -DINPUT=${CMAKE_CURRENT_SOURCE_DIR}/test/data/lcet10.txt + -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/test-compress.cmake) + + add_test(NAME GH-536-incomplete-read + COMMAND ${CMAKE_COMMAND} + "-DCOMPRESS_TARGET=${SWITCHLEVELS_COMMAND}" + "-DCOMPRESS_ARGS=6;88933;1;195840;2;45761" + "-DDECOMPRESS_TARGET=${MINIGZIP_COMMAND}" + -DCOMPARE=OFF + -DGZIP_VERIFY=OFF + -DINPUT=${CMAKE_CURRENT_SOURCE_DIR}/test/data/lcet10.txt + -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/test-compress.cmake) + + add_test(NAME GH-536-zero-stored-block + COMMAND ${CMAKE_COMMAND} + "-DCOMPRESS_TARGET=${SWITCHLEVELS_COMMAND}" + "-DCOMPRESS_ARGS=6;15248;1;1050;2;25217" + "-DDECOMPRESS_TARGET=${MINIGZIP_COMMAND}" + -DCOMPARE=OFF + -DGZIP_VERIFY=OFF + -DINPUT=${CMAKE_CURRENT_SOURCE_DIR}/test/data/lcet10.txt + -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/test-compress.cmake) + + add_test(NAME GH-751 + COMMAND ${CMAKE_COMMAND} + "-DTARGET=${MINIGZIP_COMMAND}" + -DINPUT=${CMAKE_CURRENT_SOURCE_DIR}/test/GH-751/test.txt + -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/test-compress.cmake) endif() -# FEATURE_SUMMARY(WHAT ALL INCLUDE_QUIET_PACKAGES) - +FEATURE_SUMMARY(WHAT ALL INCLUDE_QUIET_PACKAGES) diff --git a/libs/zlibng/ChangeLog.zlib b/libs/zlibng/ChangeLog.zlib deleted file mode 100644 index d38c0a842..000000000 --- a/libs/zlibng/ChangeLog.zlib +++ /dev/null @@ -1,1521 +0,0 @@ -## -# THIS IS AN UNMAINTAINED COPY OF THE ORIGINAL FILE DISTRIBUTED WITH ZLIB 1.2.9 -## - - - - - ChangeLog file for zlib - -Changes in 1.2.11 (15 Jan 2017) -- Fix deflate stored bug when pulling last block from window -- Permit immediate deflateParams changes before any deflate input - -Changes in 1.2.10 (2 Jan 2017) -- Avoid warnings on snprintf() return value -- Fix bug in deflate_stored() for zero-length input -- Fix bug in gzwrite.c that produced corrupt gzip files -- Remove files to be installed before copying them in Makefile.in -- Add warnings when compiling with assembler code - -Changes in 1.2.9 (31 Dec 2016) -- Fix contrib/minizip to permit unzipping with desktop API [Zouzou] -- Improve contrib/blast to return unused bytes -- Assure that gzoffset() is correct when appending -- Improve compress() and uncompress() to support large lengths -- Fix bug in test/example.c where error code not saved -- Remedy Coverity warning [Randers-Pehrson] -- Improve speed of gzprintf() in transparent mode -- Fix inflateInit2() bug when windowBits is 16 or 32 -- Change DEBUG macro to ZLIB_DEBUG -- Avoid uninitialized access by gzclose_w() -- Allow building zlib outside of the source directory -- Fix bug that accepted invalid zlib header when windowBits is zero -- Fix gzseek() problem on MinGW due to buggy _lseeki64 there -- Loop on write() calls in gzwrite.c in case of non-blocking I/O -- Add --warn (-w) option to ./configure for more compiler warnings -- Reject a window size of 256 bytes if not using the zlib wrapper -- Fix bug when level 0 used with Z_HUFFMAN or Z_RLE -- Add --debug (-d) option to ./configure to define ZLIB_DEBUG -- Fix bugs in creating a very large gzip header -- Add uncompress2() function, which returns the input size used -- Assure that deflateParams() will not switch functions mid-block -- Dramatically speed up deflation for level 0 (storing) -- Add gzfread(), duplicating the interface of fread() -- Add gzfwrite(), duplicating the interface of fwrite() -- Add deflateGetDictionary() function -- Use snprintf() for later versions of Microsoft C -- Fix *Init macros to use z_ prefix when requested -- Replace as400 with os400 for OS/400 support [Monnerat] -- Add crc32_z() and adler32_z() functions with size_t lengths -- Update Visual Studio project files [AraHaan] - -Changes in 1.2.8 (28 Apr 2013) -- Update contrib/minizip/iowin32.c for Windows RT [Vollant] -- Do not force Z_CONST for C++ -- Clean up contrib/vstudio [Roß] -- Correct spelling error in zlib.h -- Fix mixed line endings in contrib/vstudio - -Changes in 1.2.7.3 (13 Apr 2013) -- Fix version numbers and DLL names in contrib/vstudio/*/zlib.rc - -Changes in 1.2.7.2 (13 Apr 2013) -- Change check for a four-byte type back to hexadecimal -- Fix typo in win32/Makefile.msc -- Add casts in gzwrite.c for pointer differences - -Changes in 1.2.7.1 (24 Mar 2013) -- Replace use of unsafe string functions with snprintf if available -- Avoid including stddef.h on Windows for Z_SOLO compile [Niessink] -- Fix gzgetc undefine when Z_PREFIX set [Turk] -- Eliminate use of mktemp in Makefile (not always available) -- Fix bug in 'F' mode for gzopen() -- Add inflateGetDictionary() function -- Correct comment in deflate.h -- Use _snprintf for snprintf in Microsoft C -- On Darwin, only use /usr/bin/libtool if libtool is not Apple -- Delete "--version" file if created by "ar --version" [Richard G.] -- Fix configure check for veracity of compiler error return codes -- Fix CMake compilation of static lib for MSVC2010 x64 -- Remove unused variable in infback9.c -- Fix argument checks in gzlog_compress() and gzlog_write() -- Clean up the usage of z_const and respect const usage within zlib -- Clean up examples/gzlog.[ch] comparisons of different types -- Avoid shift equal to bits in type (caused endless loop) -- Fix uninitialized value bug in gzputc() introduced by const patches -- Fix memory allocation error in examples/zran.c [Nor] -- Fix bug where gzopen(), gzclose() would write an empty file -- Fix bug in gzclose() when gzwrite() runs out of memory -- Check for input buffer malloc failure in examples/gzappend.c -- Add note to contrib/blast to use binary mode in stdio -- Fix comparisons of differently signed integers in contrib/blast -- Check for invalid code length codes in contrib/puff -- Fix serious but very rare decompression bug in inftrees.c -- Update inflateBack() comments, since inflate() can be faster -- Use underscored I/O function names for WINAPI_FAMILY -- Add _tr_flush_bits to the external symbols prefixed by --zprefix -- Add contrib/vstudio/vc10 pre-build step for static only -- Quote --version-script argument in CMakeLists.txt -- Don't specify --version-script on Apple platforms in CMakeLists.txt -- Fix casting error in contrib/testzlib/testzlib.c -- Fix types in contrib/minizip to match result of get_crc_table() -- Simplify contrib/vstudio/vc10 with 'd' suffix -- Add TOP support to win32/Makefile.msc -- Suport i686 and amd64 assembler builds in CMakeLists.txt -- Fix typos in the use of _LARGEFILE64_SOURCE in zconf.h -- Add vc11 and vc12 build files to contrib/vstudio -- Add gzvprintf() as an undocumented function in zlib -- Fix configure for Sun shell -- Remove runtime check in configure for four-byte integer type -- Add casts and consts to ease user conversion to C++ -- Add man pages for minizip and miniunzip -- In Makefile uninstall, don't rm if preceding cd fails -- Do not return Z_BUF_ERROR if deflateParam() has nothing to write - -Changes in 1.2.7 (2 May 2012) -- Replace use of memmove() with a simple copy for portability -- Test for existence of strerror -- Restore gzgetc_ for backward compatibility with 1.2.6 -- Fix build with non-GNU make on Solaris -- Require gcc 4.0 or later on Mac OS X to use the hidden attribute -- Include unistd.h for Watcom C -- Use __WATCOMC__ instead of __WATCOM__ -- Do not use the visibility attribute if NO_VIZ defined -- Improve the detection of no hidden visibility attribute -- Avoid using __int64 for gcc or solo compilation -- Cast to char * in gzprintf to avoid warnings [Zinser] -- Fix make_vms.com for VAX [Zinser] -- Don't use library or built-in byte swaps -- Simplify test and use of gcc hidden attribute -- Fix bug in gzclose_w() when gzwrite() fails to allocate memory -- Add "x" (O_EXCL) and "e" (O_CLOEXEC) modes support to gzopen() -- Fix bug in test/minigzip.c for configure --solo -- Fix contrib/vstudio project link errors [Mohanathas] -- Add ability to choose the builder in make_vms.com [Schweda] -- Add DESTDIR support to mingw32 win32/Makefile.gcc -- Fix comments in win32/Makefile.gcc for proper usage -- Allow overriding the default install locations for cmake -- Generate and install the pkg-config file with cmake -- Build both a static and a shared version of zlib with cmake -- Include version symbols for cmake builds -- If using cmake with MSVC, add the source directory to the includes -- Remove unneeded EXTRA_CFLAGS from win32/Makefile.gcc [Truta] -- Move obsolete emx makefile to old [Truta] -- Allow the use of -Wundef when compiling or using zlib -- Avoid the use of the -u option with mktemp -- Improve inflate() documentation on the use of Z_FINISH -- Recognize clang as gcc -- Add gzopen_w() in Windows for wide character path names -- Rename zconf.h in CMakeLists.txt to move it out of the way -- Add source directory in CMakeLists.txt for building examples -- Look in build directory for zlib.pc in CMakeLists.txt -- Remove gzflags from zlibvc.def in vc9 and vc10 -- Fix contrib/minizip compilation in the MinGW environment -- Update ./configure for Solaris, support --64 [Mooney] -- Remove -R. from Solaris shared build (possible security issue) -- Avoid race condition for parallel make (-j) running example -- Fix type mismatch between get_crc_table() and crc_table -- Fix parsing of version with "-" in CMakeLists.txt [Snider, Ziegler] -- Fix the path to zlib.map in CMakeLists.txt -- Force the native libtool in Mac OS X to avoid GNU libtool [Beebe] -- Add instructions to win32/Makefile.gcc for shared install [Torri] - -Changes in 1.2.6.1 (12 Feb 2012) -- Avoid the use of the Objective-C reserved name "id" -- Include io.h in gzguts.h for Microsoft compilers -- Fix problem with ./configure --prefix and gzgetc macro -- Include gz_header definition when compiling zlib solo -- Put gzflags() functionality back in zutil.c -- Avoid library header include in crc32.c for Z_SOLO -- Use name in GCC_CLASSIC as C compiler for coverage testing, if set -- Minor cleanup in contrib/minizip/zip.c [Vollant] -- Update make_vms.com [Zinser] -- Remove unnecessary gzgetc_ function -- Use optimized byte swap operations for Microsoft and GNU [Snyder] -- Fix minor typo in zlib.h comments [Rzesniowiecki] - -Changes in 1.2.6 (29 Jan 2012) -- Update the Pascal interface in contrib/pascal -- Fix function numbers for gzgetc_ in zlibvc.def files -- Fix configure.ac for contrib/minizip [Schiffer] -- Fix large-entry detection in minizip on 64-bit systems [Schiffer] -- Have ./configure use the compiler return code for error indication -- Fix CMakeLists.txt for cross compilation [McClure] -- Fix contrib/minizip/zip.c for 64-bit architectures [Dalsnes] -- Fix compilation of contrib/minizip on FreeBSD [Marquez] -- Correct suggested usages in win32/Makefile.msc [Shachar, Horvath] -- Include io.h for Turbo C / Borland C on all platforms [Truta] -- Make version explicit in contrib/minizip/configure.ac [Bosmans] -- Avoid warning for no encryption in contrib/minizip/zip.c [Vollant] -- Minor cleanup up contrib/minizip/unzip.c [Vollant] -- Fix bug when compiling minizip with C++ [Vollant] -- Protect for long name and extra fields in contrib/minizip [Vollant] -- Avoid some warnings in contrib/minizip [Vollant] -- Add -I../.. -L../.. to CFLAGS for minizip and miniunzip -- Add missing libs to minizip linker command -- Add support for VPATH builds in contrib/minizip -- Add an --enable-demos option to contrib/minizip/configure -- Add the generation of configure.log by ./configure -- Exit when required parameters not provided to win32/Makefile.gcc -- Have gzputc return the character written instead of the argument -- Use the -m option on ldconfig for BSD systems [Tobias] -- Correct in zlib.map when deflateResetKeep was added - -Changes in 1.2.5.3 (15 Jan 2012) -- Restore gzgetc function for binary compatibility -- Do not use _lseeki64 under Borland C++ [Truta] -- Update win32/Makefile.msc to build test/*.c [Truta] -- Remove old/visualc6 given CMakefile and other alternatives -- Update AS400 build files and documentation [Monnerat] -- Update win32/Makefile.gcc to build test/*.c [Truta] -- Permit stronger flushes after Z_BLOCK flushes -- Avoid extraneous empty blocks when doing empty flushes -- Permit Z_NULL arguments to deflatePending -- Allow deflatePrime() to insert bits in the middle of a stream -- Remove second empty static block for Z_PARTIAL_FLUSH -- Write out all of the available bits when using Z_BLOCK -- Insert the first two strings in the hash table after a flush - -Changes in 1.2.5.2 (17 Dec 2011) -- fix ld error: unable to find version dependency 'ZLIB_1.2.5' -- use relative symlinks for shared libs -- Avoid searching past window for Z_RLE strategy -- Assure that high-water mark initialization is always applied in deflate -- Add assertions to fill_window() in deflate.c to match comments -- Update python link in README -- Correct spelling error in gzread.c -- Fix bug in gzgets() for a concatenated empty gzip stream -- Correct error in comment for gz_make() -- Change gzread() and related to ignore junk after gzip streams -- Allow gzread() and related to continue after gzclearerr() -- Allow gzrewind() and gzseek() after a premature end-of-file -- Simplify gzseek() now that raw after gzip is ignored -- Change gzgetc() to a macro for speed (~40% speedup in testing) -- Fix gzclose() to return the actual error last encountered -- Always add large file support for windows -- Include zconf.h for windows large file support -- Include zconf.h.cmakein for windows large file support -- Update zconf.h.cmakein on make distclean -- Merge vestigial vsnprintf determination from zutil.h to gzguts.h -- Clarify how gzopen() appends in zlib.h comments -- Correct documentation of gzdirect() since junk at end now ignored -- Add a transparent write mode to gzopen() when 'T' is in the mode -- Update python link in zlib man page -- Get inffixed.h and MAKEFIXED result to match -- Add a ./config --solo option to make zlib subset with no library use -- Add undocumented inflateResetKeep() function for CAB file decoding -- Add --cover option to ./configure for gcc coverage testing -- Add #define ZLIB_CONST option to use const in the z_stream interface -- Add comment to gzdopen() in zlib.h to use dup() when using fileno() -- Note behavior of uncompress() to provide as much data as it can -- Add files in contrib/minizip to aid in building libminizip -- Split off AR options in Makefile.in and configure -- Change ON macro to Z_ARG to avoid application conflicts -- Facilitate compilation with Borland C++ for pragmas and vsnprintf -- Include io.h for Turbo C / Borland C++ -- Move example.c and minigzip.c to test/ -- Simplify incomplete code table filling in inflate_table() -- Remove code from inflate.c and infback.c that is impossible to execute -- Test the inflate code with full coverage -- Allow deflateSetDictionary, inflateSetDictionary at any time (in raw) -- Add deflateResetKeep and fix inflateResetKeep to retain dictionary -- Fix gzwrite.c to accommodate reduced memory zlib compilation -- Have inflate() with Z_FINISH avoid the allocation of a window -- Do not set strm->adler when doing raw inflate -- Fix gzeof() to behave just like feof() when read is not past end of file -- Fix bug in gzread.c when end-of-file is reached -- Avoid use of Z_BUF_ERROR in gz* functions except for premature EOF -- Document gzread() capability to read concurrently written files -- Remove hard-coding of resource compiler in CMakeLists.txt [Blammo] - -Changes in 1.2.5.1 (10 Sep 2011) -- Update FAQ entry on shared builds (#13) -- Avoid symbolic argument to chmod in Makefile.in -- Fix bug and add consts in contrib/puff [Oberhumer] -- Update contrib/puff/zeros.raw test file to have all block types -- Add full coverage test for puff in contrib/puff/Makefile -- Fix static-only-build install in Makefile.in -- Fix bug in unzGetCurrentFileInfo() in contrib/minizip [Kuno] -- Add libz.a dependency to shared in Makefile.in for parallel builds -- Spell out "number" (instead of "nb") in zlib.h for total_in, total_out -- Replace $(...) with `...` in configure for non-bash sh [Bowler] -- Add darwin* to Darwin* and solaris* to SunOS\ 5* in configure [Groffen] -- Add solaris* to Linux* in configure to allow gcc use [Groffen] -- Add *bsd* to Linux* case in configure [Bar-Lev] -- Add inffast.obj to dependencies in win32/Makefile.msc -- Correct spelling error in deflate.h [Kohler] -- Change libzdll.a again to libz.dll.a (!) in win32/Makefile.gcc -- Add test to configure for GNU C looking for gcc in output of $cc -v -- Add zlib.pc generation to win32/Makefile.gcc [Weigelt] -- Fix bug in zlib.h for _FILE_OFFSET_BITS set and _LARGEFILE64_SOURCE not -- Add comment in zlib.h that adler32_combine with len2 < 0 makes no sense -- Make NO_DIVIDE option in adler32.c much faster (thanks to John Reiser) -- Make stronger test in zconf.h to include unistd.h for LFS -- Apply Darwin patches for 64-bit file offsets to contrib/minizip [Slack] -- Fix zlib.h LFS support when Z_PREFIX used -- Add updated as400 support (removed from old) [Monnerat] -- Avoid deflate sensitivity to volatile input data -- Avoid division in adler32_combine for NO_DIVIDE -- Clarify the use of Z_FINISH with deflateBound() amount of space -- Set binary for output file in puff.c -- Use u4 type for crc_table to avoid conversion warnings -- Apply casts in zlib.h to avoid conversion warnings -- Add OF to prototypes for adler32_combine_ and crc32_combine_ [Miller] -- Improve inflateSync() documentation to note indeterminancy -- Add deflatePending() function to return the amount of pending output -- Correct the spelling of "specification" in FAQ [Randers-Pehrson] -- Add a check in configure for stdarg.h, use for gzprintf() -- Check that pointers fit in ints when gzprint() compiled old style -- Add dummy name before $(SHAREDLIBV) in Makefile [Bar-Lev, Bowler] -- Delete line in configure that adds -L. libz.a to LDFLAGS [Weigelt] -- Add debug records in assmebler code [Londer] -- Update RFC references to use http://tools.ietf.org/html/... [Li] -- Add --archs option, use of libtool to configure for Mac OS X [Borstel] - -Changes in 1.2.5 (19 Apr 2010) -- Disable visibility attribute in win32/Makefile.gcc [Bar-Lev] -- Default to libdir as sharedlibdir in configure [Nieder] -- Update copyright dates on modified source files -- Update trees.c to be able to generate modified trees.h -- Exit configure for MinGW, suggesting win32/Makefile.gcc -- Check for NULL path in gz_open [Homurlu] - -Changes in 1.2.4.5 (18 Apr 2010) -- Set sharedlibdir in configure [Torok] -- Set LDFLAGS in Makefile.in [Bar-Lev] -- Avoid mkdir objs race condition in Makefile.in [Bowler] -- Add ZLIB_INTERNAL in front of internal inter-module functions and arrays -- Define ZLIB_INTERNAL to hide internal functions and arrays for GNU C -- Don't use hidden attribute when it is a warning generator (e.g. Solaris) - -Changes in 1.2.4.4 (18 Apr 2010) -- Fix CROSS_PREFIX executable testing, CHOST extract, mingw* [Torok] -- Undefine _LARGEFILE64_SOURCE in zconf.h if it is zero, but not if empty -- Try to use bash or ksh regardless of functionality of /bin/sh -- Fix configure incompatibility with NetBSD sh -- Remove attempt to run under bash or ksh since have better NetBSD fix -- Fix win32/Makefile.gcc for MinGW [Bar-Lev] -- Add diagnostic messages when using CROSS_PREFIX in configure -- Added --sharedlibdir option to configure [Weigelt] -- Use hidden visibility attribute when available [Frysinger] - -Changes in 1.2.4.3 (10 Apr 2010) -- Only use CROSS_PREFIX in configure for ar and ranlib if they exist -- Use CROSS_PREFIX for nm [Bar-Lev] -- Assume _LARGEFILE64_SOURCE defined is equivalent to true -- Avoid use of undefined symbols in #if with && and || -- Make *64 prototypes in gzguts.h consistent with functions -- Add -shared load option for MinGW in configure [Bowler] -- Move z_off64_t to public interface, use instead of off64_t -- Remove ! from shell test in configure (not portable to Solaris) -- Change +0 macro tests to -0 for possibly increased portability - -Changes in 1.2.4.2 (9 Apr 2010) -- Add consistent carriage returns to readme.txt's in masmx86 and masmx64 -- Really provide prototypes for *64 functions when building without LFS -- Only define unlink() in minigzip.c if unistd.h not included -- Update README to point to contrib/vstudio project files -- Move projects/vc6 to old/ and remove projects/ -- Include stdlib.h in minigzip.c for setmode() definition under WinCE -- Clean up assembler builds in win32/Makefile.msc [Rowe] -- Include sys/types.h for Microsoft for off_t definition -- Fix memory leak on error in gz_open() -- Symbolize nm as $NM in configure [Weigelt] -- Use TEST_LDSHARED instead of LDSHARED to link test programs [Weigelt] -- Add +0 to _FILE_OFFSET_BITS and _LFS64_LARGEFILE in case not defined -- Fix bug in gzeof() to take into account unused input data -- Avoid initialization of structures with variables in puff.c -- Updated win32/README-WIN32.txt [Rowe] - -Changes in 1.2.4.1 (28 Mar 2010) -- Remove the use of [a-z] constructs for sed in configure [gentoo 310225] -- Remove $(SHAREDLIB) from LIBS in Makefile.in [Creech] -- Restore "for debugging" comment on sprintf() in gzlib.c -- Remove fdopen for MVS from gzguts.h -- Put new README-WIN32.txt in win32 [Rowe] -- Add check for shell to configure and invoke another shell if needed -- Fix big fat stinking bug in gzseek() on uncompressed files -- Remove vestigial F_OPEN64 define in zutil.h -- Set and check the value of _LARGEFILE_SOURCE and _LARGEFILE64_SOURCE -- Avoid errors on non-LFS systems when applications define LFS macros -- Set EXE to ".exe" in configure for MINGW [Kahle] -- Match crc32() in crc32.c exactly to the prototype in zlib.h [Sherrill] -- Add prefix for cross-compilation in win32/makefile.gcc [Bar-Lev] -- Add DLL install in win32/makefile.gcc [Bar-Lev] -- Allow Linux* or linux* from uname in configure [Bar-Lev] -- Allow ldconfig to be redefined in configure and Makefile.in [Bar-Lev] -- Add cross-compilation prefixes to configure [Bar-Lev] -- Match type exactly in gz_load() invocation in gzread.c -- Match type exactly of zcalloc() in zutil.c to zlib.h alloc_func -- Provide prototypes for *64 functions when building zlib without LFS -- Don't use -lc when linking shared library on MinGW -- Remove errno.h check in configure and vestigial errno code in zutil.h - -Changes in 1.2.4 (14 Mar 2010) -- Fix VER3 extraction in configure for no fourth subversion -- Update zlib.3, add docs to Makefile.in to make .pdf out of it -- Add zlib.3.pdf to distribution -- Don't set error code in gzerror() if passed pointer is NULL -- Apply destination directory fixes to CMakeLists.txt [Lowman] -- Move #cmakedefine's to a new zconf.in.cmakein -- Restore zconf.h for builds that don't use configure or cmake -- Add distclean to dummy Makefile for convenience -- Update and improve INDEX, README, and FAQ -- Update CMakeLists.txt for the return of zconf.h [Lowman] -- Update contrib/vstudio/vc9 and vc10 [Vollant] -- Change libz.dll.a back to libzdll.a in win32/Makefile.gcc -- Apply license and readme changes to contrib/asm686 [Raiter] -- Check file name lengths and add -c option in minigzip.c [Li] -- Update contrib/amd64 and contrib/masmx86/ [Vollant] -- Avoid use of "eof" parameter in trees.c to not shadow library variable -- Update make_vms.com for removal of zlibdefs.h [Zinser] -- Update assembler code and vstudio projects in contrib [Vollant] -- Remove outdated assembler code contrib/masm686 and contrib/asm586 -- Remove old vc7 and vc8 from contrib/vstudio -- Update win32/Makefile.msc, add ZLIB_VER_SUBREVISION [Rowe] -- Fix memory leaks in gzclose_r() and gzclose_w(), file leak in gz_open() -- Add contrib/gcc_gvmat64 for longest_match and inflate_fast [Vollant] -- Remove *64 functions from win32/zlib.def (they're not 64-bit yet) -- Fix bug in void-returning vsprintf() case in gzwrite.c -- Fix name change from inflate.h in contrib/inflate86/inffas86.c -- Check if temporary file exists before removing in make_vms.com [Zinser] -- Fix make install and uninstall for --static option -- Fix usage of _MSC_VER in gzguts.h and zutil.h [Truta] -- Update readme.txt in contrib/masmx64 and masmx86 to assemble - -Changes in 1.2.3.9 (21 Feb 2010) -- Expunge gzio.c -- Move as400 build information to old -- Fix updates in contrib/minizip and contrib/vstudio -- Add const to vsnprintf test in configure to avoid warnings [Weigelt] -- Delete zconf.h (made by configure) [Weigelt] -- Change zconf.in.h to zconf.h.in per convention [Weigelt] -- Check for NULL buf in gzgets() -- Return empty string for gzgets() with len == 1 (like fgets()) -- Fix description of gzgets() in zlib.h for end-of-file, NULL return -- Update minizip to 1.1 [Vollant] -- Avoid MSVC loss of data warnings in gzread.c, gzwrite.c -- Note in zlib.h that gzerror() should be used to distinguish from EOF -- Remove use of snprintf() from gzlib.c -- Fix bug in gzseek() -- Update contrib/vstudio, adding vc9 and vc10 [Kuno, Vollant] -- Fix zconf.h generation in CMakeLists.txt [Lowman] -- Improve comments in zconf.h where modified by configure - -Changes in 1.2.3.8 (13 Feb 2010) -- Clean up text files (tabs, trailing whitespace, etc.) [Oberhumer] -- Use z_off64_t in gz_zero() and gz_skip() to match state->skip -- Avoid comparison problem when sizeof(int) == sizeof(z_off64_t) -- Revert to Makefile.in from 1.2.3.6 (live with the clutter) -- Fix missing error return in gzflush(), add zlib.h note -- Add *64 functions to zlib.map [Levin] -- Fix signed/unsigned comparison in gz_comp() -- Use SFLAGS when testing shared linking in configure -- Add --64 option to ./configure to use -m64 with gcc -- Fix ./configure --help to correctly name options -- Have make fail if a test fails [Levin] -- Avoid buffer overrun in contrib/masmx64/gvmat64.asm [Simpson] -- Remove assembler object files from contrib - -Changes in 1.2.3.7 (24 Jan 2010) -- Always gzopen() with O_LARGEFILE if available -- Fix gzdirect() to work immediately after gzopen() or gzdopen() -- Make gzdirect() more precise when the state changes while reading -- Improve zlib.h documentation in many places -- Catch memory allocation failure in gz_open() -- Complete close operation if seek forward in gzclose_w() fails -- Return Z_ERRNO from gzclose_r() if close() fails -- Return Z_STREAM_ERROR instead of EOF for gzclose() being passed NULL -- Return zero for gzwrite() errors to match zlib.h description -- Return -1 on gzputs() error to match zlib.h description -- Add zconf.in.h to allow recovery from configure modification [Weigelt] -- Fix static library permissions in Makefile.in [Weigelt] -- Avoid warnings in configure tests that hide functionality [Weigelt] -- Add *BSD and DragonFly to Linux case in configure [gentoo 123571] -- Change libzdll.a to libz.dll.a in win32/Makefile.gcc [gentoo 288212] -- Avoid access of uninitialized data for first inflateReset2 call [Gomes] -- Keep object files in subdirectories to reduce the clutter somewhat -- Remove default Makefile and zlibdefs.h, add dummy Makefile -- Add new external functions to Z_PREFIX, remove duplicates, z_z_ -> z_ -- Remove zlibdefs.h completely -- modify zconf.h instead - -Changes in 1.2.3.6 (17 Jan 2010) -- Avoid void * arithmetic in gzread.c and gzwrite.c -- Make compilers happier with const char * for gz_error message -- Avoid unused parameter warning in inflate.c -- Avoid signed-unsigned comparison warning in inflate.c -- Indent #pragma's for traditional C -- Fix usage of strwinerror() in glib.c, change to gz_strwinerror() -- Correct email address in configure for system options -- Update make_vms.com and add make_vms.com to contrib/minizip [Zinser] -- Update zlib.map [Brown] -- Fix Makefile.in for Solaris 10 make of example64 and minizip64 [Torok] -- Apply various fixes to CMakeLists.txt [Lowman] -- Add checks on len in gzread() and gzwrite() -- Add error message for no more room for gzungetc() -- Remove zlib version check in gzwrite() -- Defer compression of gzprintf() result until need to -- Use snprintf() in gzdopen() if available -- Remove USE_MMAP configuration determination (only used by minigzip) -- Remove examples/pigz.c (available separately) -- Update examples/gun.c to 1.6 - -Changes in 1.2.3.5 (8 Jan 2010) -- Add space after #if in zutil.h for some compilers -- Fix relatively harmless bug in deflate_fast() [Exarevsky] -- Fix same problem in deflate_slow() -- Add $(SHAREDLIBV) to LIBS in Makefile.in [Brown] -- Add deflate_rle() for faster Z_RLE strategy run-length encoding -- Add deflate_huff() for faster Z_HUFFMAN_ONLY encoding -- Change name of "write" variable in inffast.c to avoid library collisions -- Fix premature EOF from gzread() in gzio.c [Brown] -- Use zlib header window size if windowBits is 0 in inflateInit2() -- Remove compressBound() call in deflate.c to avoid linking compress.o -- Replace use of errno in gz* with functions, support WinCE [Alves] -- Provide alternative to perror() in minigzip.c for WinCE [Alves] -- Don't use _vsnprintf on later versions of MSVC [Lowman] -- Add CMake build script and input file [Lowman] -- Update contrib/minizip to 1.1 [Svensson, Vollant] -- Moved nintendods directory from contrib to . -- Replace gzio.c with a new set of routines with the same functionality -- Add gzbuffer(), gzoffset(), gzclose_r(), gzclose_w() as part of above -- Update contrib/minizip to 1.1b -- Change gzeof() to return 0 on error instead of -1 to agree with zlib.h - -Changes in 1.2.3.4 (21 Dec 2009) -- Use old school .SUFFIXES in Makefile.in for FreeBSD compatibility -- Update comments in configure and Makefile.in for default --shared -- Fix test -z's in configure [Marquess] -- Build examplesh and minigzipsh when not testing -- Change NULL's to Z_NULL's in deflate.c and in comments in zlib.h -- Import LDFLAGS from the environment in configure -- Fix configure to populate SFLAGS with discovered CFLAGS options -- Adapt make_vms.com to the new Makefile.in [Zinser] -- Add zlib2ansi script for C++ compilation [Marquess] -- Add _FILE_OFFSET_BITS=64 test to make test (when applicable) -- Add AMD64 assembler code for longest match to contrib [Teterin] -- Include options from $SFLAGS when doing $LDSHARED -- Simplify 64-bit file support by introducing z_off64_t type -- Make shared object files in objs directory to work around old Sun cc -- Use only three-part version number for Darwin shared compiles -- Add rc option to ar in Makefile.in for when ./configure not run -- Add -WI,-rpath,. to LDFLAGS for OSF 1 V4* -- Set LD_LIBRARYN32_PATH for SGI IRIX shared compile -- Protect against _FILE_OFFSET_BITS being defined when compiling zlib -- Rename Makefile.in targets allstatic to static and allshared to shared -- Fix static and shared Makefile.in targets to be independent -- Correct error return bug in gz_open() by setting state [Brown] -- Put spaces before ;;'s in configure for better sh compatibility -- Add pigz.c (parallel implementation of gzip) to examples/ -- Correct constant in crc32.c to UL [Leventhal] -- Reject negative lengths in crc32_combine() -- Add inflateReset2() function to work like inflateEnd()/inflateInit2() -- Include sys/types.h for _LARGEFILE64_SOURCE [Brown] -- Correct typo in doc/algorithm.txt [Janik] -- Fix bug in adler32_combine() [Zhu] -- Catch missing-end-of-block-code error in all inflates and in puff - Assures that random input to inflate eventually results in an error -- Added enough.c (calculation of ENOUGH for inftrees.h) to examples/ -- Update ENOUGH and its usage to reflect discovered bounds -- Fix gzerror() error report on empty input file [Brown] -- Add ush casts in trees.c to avoid pedantic runtime errors -- Fix typo in zlib.h uncompress() description [Reiss] -- Correct inflate() comments with regard to automatic header detection -- Remove deprecation comment on Z_PARTIAL_FLUSH (it stays) -- Put new version of gzlog (2.0) in examples with interruption recovery -- Add puff compile option to permit invalid distance-too-far streams -- Add puff TEST command options, ability to read piped input -- Prototype the *64 functions in zlib.h when _FILE_OFFSET_BITS == 64, but - _LARGEFILE64_SOURCE not defined -- Fix Z_FULL_FLUSH to truly erase the past by resetting s->strstart -- Fix deflateSetDictionary() to use all 32K for output consistency -- Remove extraneous #define MIN_LOOKAHEAD in deflate.c (in deflate.h) -- Clear bytes after deflate lookahead to avoid use of uninitialized data -- Change a limit in inftrees.c to be more transparent to Coverity Prevent -- Update win32/zlib.def with exported symbols from zlib.h -- Correct spelling errors in zlib.h [Willem, Sobrado] -- Allow Z_BLOCK for deflate() to force a new block -- Allow negative bits in inflatePrime() to delete existing bit buffer -- Add Z_TREES flush option to inflate() to return at end of trees -- Add inflateMark() to return current state information for random access -- Add Makefile for NintendoDS to contrib [Costa] -- Add -w in configure compile tests to avoid spurious warnings [Beucler] -- Fix typos in zlib.h comments for deflateSetDictionary() -- Fix EOF detection in transparent gzread() [Maier] - -Changes in 1.2.3.3 (2 October 2006) -- Make --shared the default for configure, add a --static option -- Add compile option to permit invalid distance-too-far streams -- Add inflateUndermine() function which is required to enable above -- Remove use of "this" variable name for C++ compatibility [Marquess] -- Add testing of shared library in make test, if shared library built -- Use ftello() and fseeko() if available instead of ftell() and fseek() -- Provide two versions of all functions that use the z_off_t type for - binary compatibility -- a normal version and a 64-bit offset version, - per the Large File Support Extension when _LARGEFILE64_SOURCE is - defined; use the 64-bit versions by default when _FILE_OFFSET_BITS - is defined to be 64 -- Add a --uname= option to configure to perhaps help with cross-compiling - -Changes in 1.2.3.2 (3 September 2006) -- Turn off silly Borland warnings [Hay] -- Use off64_t and define _LARGEFILE64_SOURCE when present -- Fix missing dependency on inffixed.h in Makefile.in -- Rig configure --shared to build both shared and static [Teredesai, Truta] -- Remove zconf.in.h and instead create a new zlibdefs.h file -- Fix contrib/minizip/unzip.c non-encrypted after encrypted [Vollant] -- Add treebuild.xml (see http://treebuild.metux.de/) [Weigelt] - -Changes in 1.2.3.1 (16 August 2006) -- Add watcom directory with OpenWatcom make files [Daniel] -- Remove #undef of FAR in zconf.in.h for MVS [Fedtke] -- Update make_vms.com [Zinser] -- Use -fPIC for shared build in configure [Teredesai, Nicholson] -- Use only major version number for libz.so on IRIX and OSF1 [Reinholdtsen] -- Use fdopen() (not _fdopen()) for Interix in zutil.h [Bäck] -- Add some FAQ entries about the contrib directory -- Update the MVS question in the FAQ -- Avoid extraneous reads after EOF in gzio.c [Brown] -- Correct spelling of "successfully" in gzio.c [Randers-Pehrson] -- Add comments to zlib.h about gzerror() usage [Brown] -- Set extra flags in gzip header in gzopen() like deflate() does -- Make configure options more compatible with double-dash conventions - [Weigelt] -- Clean up compilation under Solaris SunStudio cc [Rowe, Reinholdtsen] -- Fix uninstall target in Makefile.in [Truta] -- Add pkgconfig support [Weigelt] -- Use $(DESTDIR) macro in Makefile.in [Reinholdtsen, Weigelt] -- Replace set_data_type() with a more accurate detect_data_type() in - trees.c, according to the txtvsbin.txt document [Truta] -- Swap the order of #include and #include "zlib.h" in - gzio.c, example.c and minigzip.c [Truta] -- Shut up annoying VS2005 warnings about standard C deprecation [Rowe, - Truta] (where?) -- Fix target "clean" from win32/Makefile.bor [Truta] -- Create .pdb and .manifest files in win32/makefile.msc [Ziegler, Rowe] -- Update zlib www home address in win32/DLL_FAQ.txt [Truta] -- Update contrib/masmx86/inffas32.asm for VS2005 [Vollant, Van Wassenhove] -- Enable browse info in the "Debug" and "ASM Debug" configurations in - the Visual C++ 6 project, and set (non-ASM) "Debug" as default [Truta] -- Add pkgconfig support [Weigelt] -- Add ZLIB_VER_MAJOR, ZLIB_VER_MINOR and ZLIB_VER_REVISION in zlib.h, - for use in win32/zlib1.rc [Polushin, Rowe, Truta] -- Add a document that explains the new text detection scheme to - doc/txtvsbin.txt [Truta] -- Add rfc1950.txt, rfc1951.txt and rfc1952.txt to doc/ [Truta] -- Move algorithm.txt into doc/ [Truta] -- Synchronize FAQ with website -- Fix compressBound(), was low for some pathological cases [Fearnley] -- Take into account wrapper variations in deflateBound() -- Set examples/zpipe.c input and output to binary mode for Windows -- Update examples/zlib_how.html with new zpipe.c (also web site) -- Fix some warnings in examples/gzlog.c and examples/zran.c (it seems - that gcc became pickier in 4.0) -- Add zlib.map for Linux: "All symbols from zlib-1.1.4 remain - un-versioned, the patch adds versioning only for symbols introduced in - zlib-1.2.0 or later. It also declares as local those symbols which are - not designed to be exported." [Levin] -- Update Z_PREFIX list in zconf.in.h, add --zprefix option to configure -- Do not initialize global static by default in trees.c, add a response - NO_INIT_GLOBAL_POINTERS to initialize them if needed [Marquess] -- Don't use strerror() in gzio.c under WinCE [Yakimov] -- Don't use errno.h in zutil.h under WinCE [Yakimov] -- Move arguments for AR to its usage to allow replacing ar [Marot] -- Add HAVE_VISIBILITY_PRAGMA in zconf.in.h for Mozilla [Randers-Pehrson] -- Improve inflateInit() and inflateInit2() documentation -- Fix structure size comment in inflate.h -- Change configure help option from --h* to --help [Santos] - -Changes in 1.2.3 (18 July 2005) -- Apply security vulnerability fixes to contrib/infback9 as well -- Clean up some text files (carriage returns, trailing space) -- Update testzlib, vstudio, masmx64, and masmx86 in contrib [Vollant] - -Changes in 1.2.2.4 (11 July 2005) -- Add inflatePrime() function for starting inflation at bit boundary -- Avoid some Visual C warnings in deflate.c -- Avoid more silly Visual C warnings in inflate.c and inftrees.c for 64-bit - compile -- Fix some spelling errors in comments [Betts] -- Correct inflateInit2() error return documentation in zlib.h -- Add zran.c example of compressed data random access to examples - directory, shows use of inflatePrime() -- Fix cast for assignments to strm->state in inflate.c and infback.c -- Fix zlibCompileFlags() in zutil.c to use 1L for long shifts [Oberhumer] -- Move declarations of gf2 functions to right place in crc32.c [Oberhumer] -- Add cast in trees.c t avoid a warning [Oberhumer] -- Avoid some warnings in fitblk.c, gun.c, gzjoin.c in examples [Oberhumer] -- Update make_vms.com [Zinser] -- Initialize state->write in inflateReset() since copied in inflate_fast() -- Be more strict on incomplete code sets in inflate_table() and increase - ENOUGH and MAXD -- this repairs a possible security vulnerability for - invalid inflate input. Thanks to Tavis Ormandy and Markus Oberhumer for - discovering the vulnerability and providing test cases. -- Add ia64 support to configure for HP-UX [Smith] -- Add error return to gzread() for format or i/o error [Levin] -- Use malloc.h for OS/2 [Necasek] - -Changes in 1.2.2.3 (27 May 2005) -- Replace 1U constants in inflate.c and inftrees.c for 64-bit compile -- Typecast fread() return values in gzio.c [Vollant] -- Remove trailing space in minigzip.c outmode (VC++ can't deal with it) -- Fix crc check bug in gzread() after gzungetc() [Heiner] -- Add the deflateTune() function to adjust internal compression parameters -- Add a fast gzip decompressor, gun.c, to examples (use of inflateBack) -- Remove an incorrect assertion in examples/zpipe.c -- Add C++ wrapper in infback9.h [Donais] -- Fix bug in inflateCopy() when decoding fixed codes -- Note in zlib.h how much deflateSetDictionary() actually uses -- Remove USE_DICT_HEAD in deflate.c (would mess up inflate if used) -- Add _WIN32_WCE to define WIN32 in zconf.in.h [Spencer] -- Don't include stderr.h or errno.h for _WIN32_WCE in zutil.h [Spencer] -- Add gzdirect() function to indicate transparent reads -- Update contrib/minizip [Vollant] -- Fix compilation of deflate.c when both ASMV and FASTEST [Oberhumer] -- Add casts in crc32.c to avoid warnings [Oberhumer] -- Add contrib/masmx64 [Vollant] -- Update contrib/asm586, asm686, masmx86, testzlib, vstudio [Vollant] - -Changes in 1.2.2.2 (30 December 2004) -- Replace structure assignments in deflate.c and inflate.c with zmemcpy to - avoid implicit memcpy calls (portability for no-library compilation) -- Increase sprintf() buffer size in gzdopen() to allow for large numbers -- Add INFLATE_STRICT to check distances against zlib header -- Improve WinCE errno handling and comments [Chang] -- Remove comment about no gzip header processing in FAQ -- Add Z_FIXED strategy option to deflateInit2() to force fixed trees -- Add updated make_vms.com [Coghlan], update README -- Create a new "examples" directory, move gzappend.c there, add zpipe.c, - fitblk.c, gzlog.[ch], gzjoin.c, and zlib_how.html. -- Add FAQ entry and comments in deflate.c on uninitialized memory access -- Add Solaris 9 make options in configure [Gilbert] -- Allow strerror() usage in gzio.c for STDC -- Fix DecompressBuf in contrib/delphi/ZLib.pas [ManChesTer] -- Update contrib/masmx86/inffas32.asm and gvmat32.asm [Vollant] -- Use z_off_t for adler32_combine() and crc32_combine() lengths -- Make adler32() much faster for small len -- Use OS_CODE in deflate() default gzip header - -Changes in 1.2.2.1 (31 October 2004) -- Allow inflateSetDictionary() call for raw inflate -- Fix inflate header crc check bug for file names and comments -- Add deflateSetHeader() and gz_header structure for custom gzip headers -- Add inflateGetheader() to retrieve gzip headers -- Add crc32_combine() and adler32_combine() functions -- Add alloc_func, free_func, in_func, out_func to Z_PREFIX list -- Use zstreamp consistently in zlib.h (inflate_back functions) -- Remove GUNZIP condition from definition of inflate_mode in inflate.h - and in contrib/inflate86/inffast.S [Truta, Anderson] -- Add support for AMD64 in contrib/inflate86/inffas86.c [Anderson] -- Update projects/README.projects and projects/visualc6 [Truta] -- Update win32/DLL_FAQ.txt [Truta] -- Avoid warning under NO_GZCOMPRESS in gzio.c; fix typo [Truta] -- Deprecate Z_ASCII; use Z_TEXT instead [Truta] -- Use a new algorithm for setting strm->data_type in trees.c [Truta] -- Do not define an exit() prototype in zutil.c unless DEBUG defined -- Remove prototype of exit() from zutil.c, example.c, minigzip.c [Truta] -- Add comment in zlib.h for Z_NO_FLUSH parameter to deflate() -- Fix Darwin build version identification [Peterson] - -Changes in 1.2.2 (3 October 2004) -- Update zlib.h comments on gzip in-memory processing -- Set adler to 1 in inflateReset() to support Java test suite [Walles] -- Add contrib/dotzlib [Ravn] -- Update win32/DLL_FAQ.txt [Truta] -- Update contrib/minizip [Vollant] -- Move contrib/visual-basic.txt to old/ [Truta] -- Fix assembler builds in projects/visualc6/ [Truta] - -Changes in 1.2.1.2 (9 September 2004) -- Update INDEX file -- Fix trees.c to update strm->data_type (no one ever noticed!) -- Fix bug in error case in inflate.c, infback.c, and infback9.c [Brown] -- Add "volatile" to crc table flag declaration (for DYNAMIC_CRC_TABLE) -- Add limited multitasking protection to DYNAMIC_CRC_TABLE -- Add NO_vsnprintf for VMS in zutil.h [Mozilla] -- Don't declare strerror() under VMS [Mozilla] -- Add comment to DYNAMIC_CRC_TABLE to use get_crc_table() to initialize -- Update contrib/ada [Anisimkov] -- Update contrib/minizip [Vollant] -- Fix configure to not hardcode directories for Darwin [Peterson] -- Fix gzio.c to not return error on empty files [Brown] -- Fix indentation; update version in contrib/delphi/ZLib.pas and - contrib/pascal/zlibpas.pas [Truta] -- Update mkasm.bat in contrib/masmx86 [Truta] -- Update contrib/untgz [Truta] -- Add projects/README.projects [Truta] -- Add project for MS Visual C++ 6.0 in projects/visualc6 [Cadieux, Truta] -- Update win32/DLL_FAQ.txt [Truta] -- Update list of Z_PREFIX symbols in zconf.h [Randers-Pehrson, Truta] -- Remove an unnecessary assignment to curr in inftrees.c [Truta] -- Add OS/2 to exe builds in configure [Poltorak] -- Remove err dummy parameter in zlib.h [Kientzle] - -Changes in 1.2.1.1 (9 January 2004) -- Update email address in README -- Several FAQ updates -- Fix a big fat bug in inftrees.c that prevented decoding valid - dynamic blocks with only literals and no distance codes -- - Thanks to "Hot Emu" for the bug report and sample file -- Add a note to puff.c on no distance codes case. - -Changes in 1.2.1 (17 November 2003) -- Remove a tab in contrib/gzappend/gzappend.c -- Update some interfaces in contrib for new zlib functions -- Update zlib version number in some contrib entries -- Add Windows CE definition for ptrdiff_t in zutil.h [Mai, Truta] -- Support shared libraries on Hurd and KFreeBSD [Brown] -- Fix error in NO_DIVIDE option of adler32.c - -Changes in 1.2.0.8 (4 November 2003) -- Update version in contrib/delphi/ZLib.pas and contrib/pascal/zlibpas.pas -- Add experimental NO_DIVIDE #define in adler32.c - - Possibly faster on some processors (let me know if it is) -- Correct Z_BLOCK to not return on first inflate call if no wrap -- Fix strm->data_type on inflate() return to correctly indicate EOB -- Add deflatePrime() function for appending in the middle of a byte -- Add contrib/gzappend for an example of appending to a stream -- Update win32/DLL_FAQ.txt [Truta] -- Delete Turbo C comment in README [Truta] -- Improve some indentation in zconf.h [Truta] -- Fix infinite loop on bad input in configure script [Church] -- Fix gzeof() for concatenated gzip files [Johnson] -- Add example to contrib/visual-basic.txt [Michael B.] -- Add -p to mkdir's in Makefile.in [vda] -- Fix configure to properly detect presence or lack of printf functions -- Add AS400 support [Monnerat] -- Add a little Cygwin support [Wilson] - -Changes in 1.2.0.7 (21 September 2003) -- Correct some debug formats in contrib/infback9 -- Cast a type in a debug statement in trees.c -- Change search and replace delimiter in configure from % to # [Beebe] -- Update contrib/untgz to 0.2 with various fixes [Truta] -- Add build support for Amiga [Nikl] -- Remove some directories in old that have been updated to 1.2 -- Add dylib building for Mac OS X in configure and Makefile.in -- Remove old distribution stuff from Makefile -- Update README to point to DLL_FAQ.txt, and add comment on Mac OS X -- Update links in README - -Changes in 1.2.0.6 (13 September 2003) -- Minor FAQ updates -- Update contrib/minizip to 1.00 [Vollant] -- Remove test of gz functions in example.c when GZ_COMPRESS defined [Truta] -- Update POSTINC comment for 68060 [Nikl] -- Add contrib/infback9 with deflate64 decoding (unsupported) -- For MVS define NO_vsnprintf and undefine FAR [van Burik] -- Add pragma for fdopen on MVS [van Burik] - -Changes in 1.2.0.5 (8 September 2003) -- Add OF to inflateBackEnd() declaration in zlib.h -- Remember start when using gzdopen in the middle of a file -- Use internal off_t counters in gz* functions to properly handle seeks -- Perform more rigorous check for distance-too-far in inffast.c -- Add Z_BLOCK flush option to return from inflate at block boundary -- Set strm->data_type on return from inflate - - Indicate bits unused, if at block boundary, and if in last block -- Replace size_t with ptrdiff_t in crc32.c, and check for correct size -- Add condition so old NO_DEFLATE define still works for compatibility -- FAQ update regarding the Windows DLL [Truta] -- INDEX update: add qnx entry, remove aix entry [Truta] -- Install zlib.3 into mandir [Wilson] -- Move contrib/zlib_dll_FAQ.txt to win32/DLL_FAQ.txt; update [Truta] -- Adapt the zlib interface to the new DLL convention guidelines [Truta] -- Introduce ZLIB_WINAPI macro to allow the export of functions using - the WINAPI calling convention, for Visual Basic [Vollant, Truta] -- Update msdos and win32 scripts and makefiles [Truta] -- Export symbols by name, not by ordinal, in win32/zlib.def [Truta] -- Add contrib/ada [Anisimkov] -- Move asm files from contrib/vstudio/vc70_32 to contrib/asm386 [Truta] -- Rename contrib/asm386 to contrib/masmx86 [Truta, Vollant] -- Add contrib/masm686 [Truta] -- Fix offsets in contrib/inflate86 and contrib/masmx86/inffas32.asm - [Truta, Vollant] -- Update contrib/delphi; rename to contrib/pascal; add example [Truta] -- Remove contrib/delphi2; add a new contrib/delphi [Truta] -- Avoid inclusion of the nonstandard in contrib/iostream, - and fix some method prototypes [Truta] -- Fix the ZCR_SEED2 constant to avoid warnings in contrib/minizip - [Truta] -- Avoid the use of backslash (\) in contrib/minizip [Vollant] -- Fix file time handling in contrib/untgz; update makefiles [Truta] -- Update contrib/vstudio/vc70_32 to comply with the new DLL guidelines - [Vollant] -- Remove contrib/vstudio/vc15_16 [Vollant] -- Rename contrib/vstudio/vc70_32 to contrib/vstudio/vc7 [Truta] -- Update README.contrib [Truta] -- Invert the assignment order of match_head and s->prev[...] in - INSERT_STRING [Truta] -- Compare TOO_FAR with 32767 instead of 32768, to avoid 16-bit warnings - [Truta] -- Compare function pointers with 0, not with NULL or Z_NULL [Truta] -- Fix prototype of syncsearch in inflate.c [Truta] -- Introduce ASMINF macro to be enabled when using an ASM implementation - of inflate_fast [Truta] -- Change NO_DEFLATE to NO_GZCOMPRESS [Truta] -- Modify test_gzio in example.c to take a single file name as a - parameter [Truta] -- Exit the example.c program if gzopen fails [Truta] -- Add type casts around strlen in example.c [Truta] -- Remove casting to sizeof in minigzip.c; give a proper type - to the variable compared with SUFFIX_LEN [Truta] -- Update definitions of STDC and STDC99 in zconf.h [Truta] -- Synchronize zconf.h with the new Windows DLL interface [Truta] -- Use SYS16BIT instead of __32BIT__ to distinguish between - 16- and 32-bit platforms [Truta] -- Use far memory allocators in small 16-bit memory models for - Turbo C [Truta] -- Add info about the use of ASMV, ASMINF and ZLIB_WINAPI in - zlibCompileFlags [Truta] -- Cygwin has vsnprintf [Wilson] -- In Windows16, OS_CODE is 0, as in MSDOS [Truta] -- In Cygwin, OS_CODE is 3 (Unix), not 11 (Windows32) [Wilson] - -Changes in 1.2.0.4 (10 August 2003) -- Minor FAQ updates -- Be more strict when checking inflateInit2's windowBits parameter -- Change NO_GUNZIP compile option to NO_GZIP to cover deflate as well -- Add gzip wrapper option to deflateInit2 using windowBits -- Add updated QNX rule in configure and qnx directory [Bonnefoy] -- Make inflate distance-too-far checks more rigorous -- Clean up FAR usage in inflate -- Add casting to sizeof() in gzio.c and minigzip.c - -Changes in 1.2.0.3 (19 July 2003) -- Fix silly error in gzungetc() implementation [Vollant] -- Update contrib/minizip and contrib/vstudio [Vollant] -- Fix printf format in example.c -- Correct cdecl support in zconf.in.h [Anisimkov] -- Minor FAQ updates - -Changes in 1.2.0.2 (13 July 2003) -- Add ZLIB_VERNUM in zlib.h for numerical preprocessor comparisons -- Attempt to avoid warnings in crc32.c for pointer-int conversion -- Add AIX to configure, remove aix directory [Bakker] -- Add some casts to minigzip.c -- Improve checking after insecure sprintf() or vsprintf() calls -- Remove #elif's from crc32.c -- Change leave label to inf_leave in inflate.c and infback.c to avoid - library conflicts -- Remove inflate gzip decoding by default--only enable gzip decoding by - special request for stricter backward compatibility -- Add zlibCompileFlags() function to return compilation information -- More typecasting in deflate.c to avoid warnings -- Remove leading underscore from _Capital #defines [Truta] -- Fix configure to link shared library when testing -- Add some Windows CE target adjustments [Mai] -- Remove #define ZLIB_DLL in zconf.h [Vollant] -- Add zlib.3 [Rodgers] -- Update RFC URL in deflate.c and algorithm.txt [Mai] -- Add zlib_dll_FAQ.txt to contrib [Truta] -- Add UL to some constants [Truta] -- Update minizip and vstudio [Vollant] -- Remove vestigial NEED_DUMMY_RETURN from zconf.in.h -- Expand use of NO_DUMMY_DECL to avoid all dummy structures -- Added iostream3 to contrib [Schwardt] -- Replace rewind() with fseek() for WinCE [Truta] -- Improve setting of zlib format compression level flags - - Report 0 for huffman and rle strategies and for level == 0 or 1 - - Report 2 only for level == 6 -- Only deal with 64K limit when necessary at compile time [Truta] -- Allow TOO_FAR check to be turned off at compile time [Truta] -- Add gzclearerr() function [Souza] -- Add gzungetc() function - -Changes in 1.2.0.1 (17 March 2003) -- Add Z_RLE strategy for run-length encoding [Truta] - - When Z_RLE requested, restrict matches to distance one - - Update zlib.h, minigzip.c, gzopen(), gzdopen() for Z_RLE -- Correct FASTEST compilation to allow level == 0 -- Clean up what gets compiled for FASTEST -- Incorporate changes to zconf.in.h [Vollant] - - Refine detection of Turbo C need for dummy returns - - Refine ZLIB_DLL compilation - - Include additional header file on VMS for off_t typedef -- Try to use _vsnprintf where it supplants vsprintf [Vollant] -- Add some casts in inffast.c -- Enchance comments in zlib.h on what happens if gzprintf() tries to - write more than 4095 bytes before compression -- Remove unused state from inflateBackEnd() -- Remove exit(0) from minigzip.c, example.c -- Get rid of all those darn tabs -- Add "check" target to Makefile.in that does the same thing as "test" -- Add "mostlyclean" and "maintainer-clean" targets to Makefile.in -- Update contrib/inflate86 [Anderson] -- Update contrib/testzlib, contrib/vstudio, contrib/minizip [Vollant] -- Add msdos and win32 directories with makefiles [Truta] -- More additions and improvements to the FAQ - -Changes in 1.2.0 (9 March 2003) -- New and improved inflate code - - About 20% faster - - Does not allocate 32K window unless and until needed - - Automatically detects and decompresses gzip streams - - Raw inflate no longer needs an extra dummy byte at end - - Added inflateBack functions using a callback interface--even faster - than inflate, useful for file utilities (gzip, zip) - - Added inflateCopy() function to record state for random access on - externally generated deflate streams (e.g. in gzip files) - - More readable code (I hope) -- New and improved crc32() - - About 50% faster, thanks to suggestions from Rodney Brown -- Add deflateBound() and compressBound() functions -- Fix memory leak in deflateInit2() -- Permit setting dictionary for raw deflate (for parallel deflate) -- Fix const declaration for gzwrite() -- Check for some malloc() failures in gzio.c -- Fix bug in gzopen() on single-byte file 0x1f -- Fix bug in gzread() on concatenated file with 0x1f at end of buffer - and next buffer doesn't start with 0x8b -- Fix uncompress() to return Z_DATA_ERROR on truncated input -- Free memory at end of example.c -- Remove MAX #define in trees.c (conflicted with some libraries) -- Fix static const's in deflate.c, gzio.c, and zutil.[ch] -- Declare malloc() and free() in gzio.c if STDC not defined -- Use malloc() instead of calloc() in zutil.c if int big enough -- Define STDC for AIX -- Add aix/ with approach for compiling shared library on AIX -- Add HP-UX support for shared libraries in configure -- Add OpenUNIX support for shared libraries in configure -- Use $cc instead of gcc to build shared library -- Make prefix directory if needed when installing -- Correct Macintosh avoidance of typedef Byte in zconf.h -- Correct Turbo C memory allocation when under Linux -- Use libz.a instead of -lz in Makefile (assure use of compiled library) -- Update configure to check for snprintf or vsnprintf functions and their - return value, warn during make if using an insecure function -- Fix configure problem with compile-time knowledge of HAVE_UNISTD_H that - is lost when library is used--resolution is to build new zconf.h -- Documentation improvements (in zlib.h): - - Document raw deflate and inflate - - Update RFCs URL - - Point out that zlib and gzip formats are different - - Note that Z_BUF_ERROR is not fatal - - Document string limit for gzprintf() and possible buffer overflow - - Note requirement on avail_out when flushing - - Note permitted values of flush parameter of inflate() -- Add some FAQs (and even answers) to the FAQ -- Add contrib/inflate86/ for x86 faster inflate -- Add contrib/blast/ for PKWare Data Compression Library decompression -- Add contrib/puff/ simple inflate for deflate format description - -Changes in 1.1.4 (11 March 2002) -- ZFREE was repeated on same allocation on some error conditions. - This creates a security problem described in - http://www.zlib.org/advisory-2002-03-11.txt -- Returned incorrect error (Z_MEM_ERROR) on some invalid data -- Avoid accesses before window for invalid distances with inflate window - less than 32K. -- force windowBits > 8 to avoid a bug in the encoder for a window size - of 256 bytes. (A complete fix will be available in 1.1.5). - -Changes in 1.1.3 (9 July 1998) -- fix "an inflate input buffer bug that shows up on rare but persistent - occasions" (Mark) -- fix gzread and gztell for concatenated .gz files (Didier Le Botlan) -- fix gzseek(..., SEEK_SET) in write mode -- fix crc check after a gzeek (Frank Faubert) -- fix miniunzip when the last entry in a zip file is itself a zip file - (J Lillge) -- add contrib/asm586 and contrib/asm686 (Brian Raiter) - See http://www.muppetlabs.com/~breadbox/software/assembly.html -- add support for Delphi 3 in contrib/delphi (Bob Dellaca) -- add support for C++Builder 3 and Delphi 3 in contrib/delphi2 (Davide Moretti) -- do not exit prematurely in untgz if 0 at start of block (Magnus Holmgren) -- use macro EXTERN instead of extern to support DLL for BeOS (Sander Stoks) -- added a FAQ file - -- Support gzdopen on Mac with Metrowerks (Jason Linhart) -- Do not redefine Byte on Mac (Brad Pettit & Jason Linhart) -- define SEEK_END too if SEEK_SET is not defined (Albert Chin-A-Young) -- avoid some warnings with Borland C (Tom Tanner) -- fix a problem in contrib/minizip/zip.c for 16-bit MSDOS (Gilles Vollant) -- emulate utime() for WIN32 in contrib/untgz (Gilles Vollant) -- allow several arguments to configure (Tim Mooney, Frodo Looijaard) -- use libdir and includedir in Makefile.in (Tim Mooney) -- support shared libraries on OSF1 V4 (Tim Mooney) -- remove so_locations in "make clean" (Tim Mooney) -- fix maketree.c compilation error (Glenn, Mark) -- Python interface to zlib now in Python 1.5 (Jeremy Hylton) -- new Makefile.riscos (Rich Walker) -- initialize static descriptors in trees.c for embedded targets (Nick Smith) -- use "foo-gz" in example.c for RISCOS and VMS (Nick Smith) -- add the OS/2 files in Makefile.in too (Andrew Zabolotny) -- fix fdopen and halloc macros for Microsoft C 6.0 (Tom Lane) -- fix maketree.c to allow clean compilation of inffixed.h (Mark) -- fix parameter check in deflateCopy (Gunther Nikl) -- cleanup trees.c, use compressed_len only in debug mode (Christian Spieler) -- Many portability patches by Christian Spieler: - . zutil.c, zutil.h: added "const" for zmem* - . Make_vms.com: fixed some typos - . Make_vms.com: msdos/Makefile.*: removed zutil.h from some dependency lists - . msdos/Makefile.msc: remove "default rtl link library" info from obj files - . msdos/Makefile.*: use model-dependent name for the built zlib library - . msdos/Makefile.emx, nt/Makefile.emx, nt/Makefile.gcc: - new makefiles, for emx (DOS/OS2), emx&rsxnt and mingw32 (Windows 9x / NT) -- use define instead of typedef for Bytef also for MSC small/medium (Tom Lane) -- replace __far with _far for better portability (Christian Spieler, Tom Lane) -- fix test for errno.h in configure (Tim Newsham) - -Changes in 1.1.2 (19 March 98) -- added contrib/minzip, mini zip and unzip based on zlib (Gilles Vollant) - See http://www.winimage.com/zLibDll/unzip.html -- preinitialize the inflate tables for fixed codes, to make the code - completely thread safe (Mark) -- some simplifications and slight speed-up to the inflate code (Mark) -- fix gzeof on non-compressed files (Allan Schrum) -- add -std1 option in configure for OSF1 to fix gzprintf (Martin Mokrejs) -- use default value of 4K for Z_BUFSIZE for 16-bit MSDOS (Tim Wegner + Glenn) -- added os2/Makefile.def and os2/zlib.def (Andrew Zabolotny) -- add shared lib support for UNIX_SV4.2MP (MATSUURA Takanori) -- do not wrap extern "C" around system includes (Tom Lane) -- mention zlib binding for TCL in README (Andreas Kupries) -- added amiga/Makefile.pup for Amiga powerUP SAS/C PPC (Andreas Kleinert) -- allow "make install prefix=..." even after configure (Glenn Randers-Pehrson) -- allow "configure --prefix $HOME" (Tim Mooney) -- remove warnings in example.c and gzio.c (Glenn Randers-Pehrson) -- move Makefile.sas to amiga/Makefile.sas - -Changes in 1.1.1 (27 Feb 98) -- fix macros _tr_tally_* in deflate.h for debug mode (Glenn Randers-Pehrson) -- remove block truncation heuristic which had very marginal effect for zlib - (smaller lit_bufsize than in gzip 1.2.4) and degraded a little the - compression ratio on some files. This also allows inlining _tr_tally for - matches in deflate_slow. -- added msdos/Makefile.w32 for WIN32 Microsoft Visual C++ (Bob Frazier) - -Changes in 1.1.0 (24 Feb 98) -- do not return STREAM_END prematurely in inflate (John Bowler) -- revert to the zlib 1.0.8 inflate to avoid the gcc 2.8.0 bug (Jeremy Buhler) -- compile with -DFASTEST to get compression code optimized for speed only -- in minigzip, try mmap'ing the input file first (Miguel Albrecht) -- increase size of I/O buffers in minigzip.c and gzio.c (not a big gain - on Sun but significant on HP) - -- add a pointer to experimental unzip library in README (Gilles Vollant) -- initialize variable gcc in configure (Chris Herborth) - -Changes in 1.0.9 (17 Feb 1998) -- added gzputs and gzgets functions -- do not clear eof flag in gzseek (Mark Diekhans) -- fix gzseek for files in transparent mode (Mark Diekhans) -- do not assume that vsprintf returns the number of bytes written (Jens Krinke) -- replace EXPORT with ZEXPORT to avoid conflict with other programs -- added compress2 in zconf.h, zlib.def, zlib.dnt -- new asm code from Gilles Vollant in contrib/asm386 -- simplify the inflate code (Mark): - . Replace ZALLOC's in huft_build() with single ZALLOC in inflate_blocks_new() - . ZALLOC the length list in inflate_trees_fixed() instead of using stack - . ZALLOC the value area for huft_build() instead of using stack - . Simplify Z_FINISH check in inflate() - -- Avoid gcc 2.8.0 comparison bug a little differently than zlib 1.0.8 -- in inftrees.c, avoid cc -O bug on HP (Farshid Elahi) -- in zconf.h move the ZLIB_DLL stuff earlier to avoid problems with - the declaration of FAR (Gilles VOllant) -- install libz.so* with mode 755 (executable) instead of 644 (Marc Lehmann) -- read_buf buf parameter of type Bytef* instead of charf* -- zmemcpy parameters are of type Bytef*, not charf* (Joseph Strout) -- do not redeclare unlink in minigzip.c for WIN32 (John Bowler) -- fix check for presence of directories in "make install" (Ian Willis) - -Changes in 1.0.8 (27 Jan 1998) -- fixed offsets in contrib/asm386/gvmat32.asm (Gilles Vollant) -- fix gzgetc and gzputc for big endian systems (Markus Oberhumer) -- added compress2() to allow setting the compression level -- include sys/types.h to get off_t on some systems (Marc Lehmann & QingLong) -- use constant arrays for the static trees in trees.c instead of computing - them at run time (thanks to Ken Raeburn for this suggestion). To create - trees.h, compile with GEN_TREES_H and run "make test". -- check return code of example in "make test" and display result -- pass minigzip command line options to file_compress -- simplifying code of inflateSync to avoid gcc 2.8 bug - -- support CC="gcc -Wall" in configure -s (QingLong) -- avoid a flush caused by ftell in gzopen for write mode (Ken Raeburn) -- fix test for shared library support to avoid compiler warnings -- zlib.lib -> zlib.dll in msdos/zlib.rc (Gilles Vollant) -- check for TARGET_OS_MAC in addition to MACOS (Brad Pettit) -- do not use fdopen for Metrowerks on Mac (Brad Pettit)) -- add checks for gzputc and gzputc in example.c -- avoid warnings in gzio.c and deflate.c (Andreas Kleinert) -- use const for the CRC table (Ken Raeburn) -- fixed "make uninstall" for shared libraries -- use Tracev instead of Trace in infblock.c -- in example.c use correct compressed length for test_sync -- suppress +vnocompatwarnings in configure for HPUX (not always supported) - -Changes in 1.0.7 (20 Jan 1998) -- fix gzseek which was broken in write mode -- return error for gzseek to negative absolute position -- fix configure for Linux (Chun-Chung Chen) -- increase stack space for MSC (Tim Wegner) -- get_crc_table and inflateSyncPoint are EXPORTed (Gilles Vollant) -- define EXPORTVA for gzprintf (Gilles Vollant) -- added man page zlib.3 (Rick Rodgers) -- for contrib/untgz, fix makedir() and improve Makefile - -- check gzseek in write mode in example.c -- allocate extra buffer for seeks only if gzseek is actually called -- avoid signed/unsigned comparisons (Tim Wegner, Gilles Vollant) -- add inflateSyncPoint in zconf.h -- fix list of exported functions in nt/zlib.dnt and mdsos/zlib.def - -Changes in 1.0.6 (19 Jan 1998) -- add functions gzprintf, gzputc, gzgetc, gztell, gzeof, gzseek, gzrewind and - gzsetparams (thanks to Roland Giersig and Kevin Ruland for some of this code) -- Fix a deflate bug occurring only with compression level 0 (thanks to - Andy Buckler for finding this one). -- In minigzip, pass transparently also the first byte for .Z files. -- return Z_BUF_ERROR instead of Z_OK if output buffer full in uncompress() -- check Z_FINISH in inflate (thanks to Marc Schluper) -- Implement deflateCopy (thanks to Adam Costello) -- make static libraries by default in configure, add --shared option. -- move MSDOS or Windows specific files to directory msdos -- suppress the notion of partial flush to simplify the interface - (but the symbol Z_PARTIAL_FLUSH is kept for compatibility with 1.0.4) -- suppress history buffer provided by application to simplify the interface - (this feature was not implemented anyway in 1.0.4) -- next_in and avail_in must be initialized before calling inflateInit or - inflateInit2 -- add EXPORT in all exported functions (for Windows DLL) -- added Makefile.nt (thanks to Stephen Williams) -- added the unsupported "contrib" directory: - contrib/asm386/ by Gilles Vollant - 386 asm code replacing longest_match(). - contrib/iostream/ by Kevin Ruland - A C++ I/O streams interface to the zlib gz* functions - contrib/iostream2/ by Tyge Løvset - Another C++ I/O streams interface - contrib/untgz/ by "Pedro A. Aranda Guti\irrez" - A very simple tar.gz file extractor using zlib - contrib/visual-basic.txt by Carlos Rios - How to use compress(), uncompress() and the gz* functions from VB. -- pass params -f (filtered data), -h (huffman only), -1 to -9 (compression - level) in minigzip (thanks to Tom Lane) - -- use const for rommable constants in deflate -- added test for gzseek and gztell in example.c -- add undocumented function inflateSyncPoint() (hack for Paul Mackerras) -- add undocumented function zError to convert error code to string - (for Tim Smithers) -- Allow compilation of gzio with -DNO_DEFLATE to avoid the compression code. -- Use default memcpy for Symantec MSDOS compiler. -- Add EXPORT keyword for check_func (needed for Windows DLL) -- add current directory to LD_LIBRARY_PATH for "make test" -- create also a link for libz.so.1 -- added support for FUJITSU UXP/DS (thanks to Toshiaki Nomura) -- use $(SHAREDLIB) instead of libz.so in Makefile.in (for HPUX) -- added -soname for Linux in configure (Chun-Chung Chen, -- assign numbers to the exported functions in zlib.def (for Windows DLL) -- add advice in zlib.h for best usage of deflateSetDictionary -- work around compiler bug on Atari (cast Z_NULL in call of s->checkfn) -- allow compilation with ANSI keywords only enabled for TurboC in large model -- avoid "versionString"[0] (Borland bug) -- add NEED_DUMMY_RETURN for Borland -- use variable z_verbose for tracing in debug mode (L. Peter Deutsch). -- allow compilation with CC -- defined STDC for OS/2 (David Charlap) -- limit external names to 8 chars for MVS (Thomas Lund) -- in minigzip.c, use static buffers only for 16-bit systems -- fix suffix check for "minigzip -d foo.gz" -- do not return an error for the 2nd of two consecutive gzflush() (Felix Lee) -- use _fdopen instead of fdopen for MSC >= 6.0 (Thomas Fanslau) -- added makelcc.bat for lcc-win32 (Tom St Denis) -- in Makefile.dj2, use copy and del instead of install and rm (Frank Donahoe) -- Avoid expanded $Id$. Use "rcs -kb" or "cvs admin -kb" to avoid Id expansion. -- check for unistd.h in configure (for off_t) -- remove useless check parameter in inflate_blocks_free -- avoid useless assignment of s->check to itself in inflate_blocks_new -- do not flush twice in gzclose (thanks to Ken Raeburn) -- rename FOPEN as F_OPEN to avoid clash with /usr/include/sys/file.h -- use NO_ERRNO_H instead of enumeration of operating systems with errno.h -- work around buggy fclose on pipes for HP/UX -- support zlib DLL with BORLAND C++ 5.0 (thanks to Glenn Randers-Pehrson) -- fix configure if CC is already equal to gcc - -Changes in 1.0.5 (3 Jan 98) -- Fix inflate to terminate gracefully when fed corrupted or invalid data -- Use const for rommable constants in inflate -- Eliminate memory leaks on error conditions in inflate -- Removed some vestigial code in inflate -- Update web address in README - -Changes in 1.0.4 (24 Jul 96) -- In very rare conditions, deflate(s, Z_FINISH) could fail to produce an EOF - bit, so the decompressor could decompress all the correct data but went - on to attempt decompressing extra garbage data. This affected minigzip too. -- zlibVersion and gzerror return const char* (needed for DLL) -- port to RISCOS (no fdopen, no multiple dots, no unlink, no fileno) -- use z_error only for DEBUG (avoid problem with DLLs) - -Changes in 1.0.3 (2 Jul 96) -- use z_streamp instead of z_stream *, which is now a far pointer in MSDOS - small and medium models; this makes the library incompatible with previous - versions for these models. (No effect in large model or on other systems.) -- return OK instead of BUF_ERROR if previous deflate call returned with - avail_out as zero but there is nothing to do -- added memcmp for non STDC compilers -- define NO_DUMMY_DECL for more Mac compilers (.h files merged incorrectly) -- define __32BIT__ if __386__ or i386 is defined (pb. with Watcom and SCO) -- better check for 16-bit mode MSC (avoids problem with Symantec) - -Changes in 1.0.2 (23 May 96) -- added Windows DLL support -- added a function zlibVersion (for the DLL support) -- fixed declarations using Bytef in infutil.c (pb with MSDOS medium model) -- Bytef is define's instead of typedef'd only for Borland C -- avoid reading uninitialized memory in example.c -- mention in README that the zlib format is now RFC1950 -- updated Makefile.dj2 -- added algorithm.doc - -Changes in 1.0.1 (20 May 96) [1.0 skipped to avoid confusion] -- fix array overlay in deflate.c which sometimes caused bad compressed data -- fix inflate bug with empty stored block -- fix MSDOS medium model which was broken in 0.99 -- fix deflateParams() which could generate bad compressed data. -- Bytef is define'd instead of typedef'ed (work around Borland bug) -- added an INDEX file -- new makefiles for DJGPP (Makefile.dj2), 32-bit Borland (Makefile.b32), - Watcom (Makefile.wat), Amiga SAS/C (Makefile.sas) -- speed up adler32 for modern machines without auto-increment -- added -ansi for IRIX in configure -- static_init_done in trees.c is an int -- define unlink as delete for VMS -- fix configure for QNX -- add configure branch for SCO and HPUX -- avoid many warnings (unused variables, dead assignments, etc...) -- no fdopen for BeOS -- fix the Watcom fix for 32 bit mode (define FAR as empty) -- removed redefinition of Byte for MKWERKS -- work around an MWKERKS bug (incorrect merge of all .h files) - -Changes in 0.99 (27 Jan 96) -- allow preset dictionary shared between compressor and decompressor -- allow compression level 0 (no compression) -- add deflateParams in zlib.h: allow dynamic change of compression level - and compression strategy. -- test large buffers and deflateParams in example.c -- add optional "configure" to build zlib as a shared library -- suppress Makefile.qnx, use configure instead -- fixed deflate for 64-bit systems (detected on Cray) -- fixed inflate_blocks for 64-bit systems (detected on Alpha) -- declare Z_DEFLATED in zlib.h (possible parameter for deflateInit2) -- always return Z_BUF_ERROR when deflate() has nothing to do -- deflateInit and inflateInit are now macros to allow version checking -- prefix all global functions and types with z_ with -DZ_PREFIX -- make falloc completely reentrant (inftrees.c) -- fixed very unlikely race condition in ct_static_init -- free in reverse order of allocation to help memory manager -- use zlib-1.0/* instead of zlib/* inside the tar.gz -- make zlib warning-free with "gcc -O3 -Wall -Wwrite-strings -Wpointer-arith - -Wconversion -Wstrict-prototypes -Wmissing-prototypes" -- allow gzread on concatenated .gz files -- deflateEnd now returns Z_DATA_ERROR if it was premature -- deflate is finally (?) fully deterministic (no matches beyond end of input) -- Document Z_SYNC_FLUSH -- add uninstall in Makefile -- Check for __cpluplus in zlib.h -- Better test in ct_align for partial flush -- avoid harmless warnings for Borland C++ -- initialize hash_head in deflate.c -- avoid warning on fdopen (gzio.c) for HP cc -Aa -- include stdlib.h for STDC compilers -- include errno.h for Cray -- ignore error if ranlib doesn't exist -- call ranlib twice for NeXTSTEP -- use exec_prefix instead of prefix for libz.a -- renamed ct_* as _tr_* to avoid conflict with applications -- clear z->msg in inflateInit2 before any error return -- initialize opaque in example.c, gzio.c, deflate.c and inflate.c -- fixed typo in zconf.h (_GNUC__ => __GNUC__) -- check for WIN32 in zconf.h and zutil.c (avoid farmalloc in 32-bit mode) -- fix typo in Make_vms.com (f$trnlnm -> f$getsyi) -- in fcalloc, normalize pointer if size > 65520 bytes -- don't use special fcalloc for 32 bit Borland C++ -- use STDC instead of __GO32__ to avoid redeclaring exit, calloc, etc... -- use Z_BINARY instead of BINARY -- document that gzclose after gzdopen will close the file -- allow "a" as mode in gzopen. -- fix error checking in gzread -- allow skipping .gz extra-field on pipes -- added reference to Perl interface in README -- put the crc table in FAR data (I dislike more and more the medium model :) -- added get_crc_table -- added a dimension to all arrays (Borland C can't count). -- workaround Borland C bug in declaration of inflate_codes_new & inflate_fast -- guard against multiple inclusion of *.h (for precompiled header on Mac) -- Watcom C pretends to be Microsoft C small model even in 32 bit mode. -- don't use unsized arrays to avoid silly warnings by Visual C++: - warning C4746: 'inflate_mask' : unsized array treated as '__far' - (what's wrong with far data in far model?). -- define enum out of inflate_blocks_state to allow compilation with C++ - -Changes in 0.95 (16 Aug 95) -- fix MSDOS small and medium model (now easier to adapt to any compiler) -- inlined send_bits -- fix the final (:-) bug for deflate with flush (output was correct but - not completely flushed in rare occasions). -- default window size is same for compression and decompression - (it's now sufficient to set MAX_WBITS in zconf.h). -- voidp -> voidpf and voidnp -> voidp (for consistency with other - typedefs and because voidnp was not near in large model). - -Changes in 0.94 (13 Aug 95) -- support MSDOS medium model -- fix deflate with flush (could sometimes generate bad output) -- fix deflateReset (zlib header was incorrectly suppressed) -- added support for VMS -- allow a compression level in gzopen() -- gzflush now calls fflush -- For deflate with flush, flush even if no more input is provided. -- rename libgz.a as libz.a -- avoid complex expression in infcodes.c triggering Turbo C bug -- work around a problem with gcc on Alpha (in INSERT_STRING) -- don't use inline functions (problem with some gcc versions) -- allow renaming of Byte, uInt, etc... with #define. -- avoid warning about (unused) pointer before start of array in deflate.c -- avoid various warnings in gzio.c, example.c, infblock.c, adler32.c, zutil.c -- avoid reserved word 'new' in trees.c - -Changes in 0.93 (25 June 95) -- temporarily disable inline functions -- make deflate deterministic -- give enough lookahead for PARTIAL_FLUSH -- Set binary mode for stdin/stdout in minigzip.c for OS/2 -- don't even use signed char in inflate (not portable enough) -- fix inflate memory leak for segmented architectures - -Changes in 0.92 (3 May 95) -- don't assume that char is signed (problem on SGI) -- Clear bit buffer when starting a stored block -- no memcpy on Pyramid -- suppressed inftest.c -- optimized fill_window, put longest_match inline for gcc -- optimized inflate on stored blocks. -- untabify all sources to simplify patches - -Changes in 0.91 (2 May 95) -- Default MEM_LEVEL is 8 (not 9 for Unix) as documented in zlib.h -- Document the memory requirements in zconf.h -- added "make install" -- fix sync search logic in inflateSync -- deflate(Z_FULL_FLUSH) now works even if output buffer too short -- after inflateSync, don't scare people with just "lo world" -- added support for DJGPP - -Changes in 0.9 (1 May 95) -- don't assume that zalloc clears the allocated memory (the TurboC bug - was Mark's bug after all :) -- let again gzread copy uncompressed data unchanged (was working in 0.71) -- deflate(Z_FULL_FLUSH), inflateReset and inflateSync are now fully implemented -- added a test of inflateSync in example.c -- moved MAX_WBITS to zconf.h because users might want to change that. -- document explicitly that zalloc(64K) on MSDOS must return a normalized - pointer (zero offset) -- added Makefiles for Microsoft C, Turbo C, Borland C++ -- faster crc32() - -Changes in 0.8 (29 April 95) -- added fast inflate (inffast.c) -- deflate(Z_FINISH) now returns Z_STREAM_END when done. Warning: this - is incompatible with previous versions of zlib which returned Z_OK. -- work around a TurboC compiler bug (bad code for b << 0, see infutil.h) - (actually that was not a compiler bug, see 0.81 above) -- gzread no longer reads one extra byte in certain cases -- In gzio destroy(), don't reference a freed structure -- avoid many warnings for MSDOS -- avoid the ERROR symbol which is used by MS Windows - -Changes in 0.71 (14 April 95) -- Fixed more MSDOS compilation problems :( There is still a bug with - TurboC large model. - -Changes in 0.7 (14 April 95) -- Added full inflate support. -- Simplified the crc32() interface. The pre- and post-conditioning - (one's complement) is now done inside crc32(). WARNING: this is - incompatible with previous versions; see zlib.h for the new usage. - -Changes in 0.61 (12 April 95) -- workaround for a bug in TurboC. example and minigzip now work on MSDOS. - -Changes in 0.6 (11 April 95) -- added minigzip.c -- added gzdopen to reopen a file descriptor as gzFile -- added transparent reading of non-gziped files in gzread. -- fixed bug in gzread (don't read crc as data) -- fixed bug in destroy (gzio.c) (don't return Z_STREAM_END for gzclose). -- don't allocate big arrays in the stack (for MSDOS) -- fix some MSDOS compilation problems - -Changes in 0.5: -- do real compression in deflate.c. Z_PARTIAL_FLUSH is supported but - not yet Z_FULL_FLUSH. -- support decompression but only in a single step (forced Z_FINISH) -- added opaque object for zalloc and zfree. -- added deflateReset and inflateReset -- added a variable zlib_version for consistency checking. -- renamed the 'filter' parameter of deflateInit2 as 'strategy'. - Added Z_FILTERED and Z_HUFFMAN_ONLY constants. - -Changes in 0.4: -- avoid "zip" everywhere, use zlib instead of ziplib. -- suppress Z_BLOCK_FLUSH, interpret Z_PARTIAL_FLUSH as block flush - if compression method == 8. -- added adler32 and crc32 -- renamed deflateOptions as deflateInit2, call one or the other but not both -- added the method parameter for deflateInit2. -- added inflateInit2 -- simplied considerably deflateInit and inflateInit by not supporting - user-provided history buffer. This is supported only in deflateInit2 - and inflateInit2. - -Changes in 0.3: -- prefix all macro names with Z_ -- use Z_FINISH instead of deflateEnd to finish compression. -- added Z_HUFFMAN_ONLY -- added gzerror() diff --git a/libs/zlibng/INDEX b/libs/zlibng/INDEX deleted file mode 100644 index 34c80ad9e..000000000 --- a/libs/zlibng/INDEX +++ /dev/null @@ -1,55 +0,0 @@ -CMakeLists.txt cmake build file -ChangeLog.zlib history of changes up to the fork from zlib 1.2.11 -FAQ.zlib Frequently Asked Questions about zlib, as distributed in zlib 1.2.11 -INDEX this file -Makefile dummy Makefile that tells you to ./configure -Makefile.in template for Unix Makefile -README guess what -README.zlib Copy of the original README file distributed in zlib 1.2.11 -configure configure script for Unix -test/example.c zlib usages examples for build testing -test/minigzip.c minimal gzip-like functionality for build testing -test/infcover.c inf*.c code coverage for build coverage testing -treebuild.xml XML description of source file dependencies -zconf.h.cmakein zconf.h template for cmake -zconf.h.in zconf.h template for configure -zlib.3 Man page for zlib -zlib.3.pdf Man page in PDF format -zlib.map Linux symbol information -zlib.pc.in Template for pkg-config descriptor -zlib.pc.cmakein zlib.pc template for cmake -zlib2ansi perl script to convert source files for C++ compilation - -arch/ architecture-specific code -doc/ documentation for formats and algorithms -win32/ makefiles for Windows - - zlib public header files (required for library use): -zconf.h -zlib.h - - private source files used to build the zlib library: -adler32.c -compress.c -crc32.c -crc32.h -deflate.c -deflate.h -gzclose.c -gzguts.h -gzlib.c -gzread.c -gzwrite.c -infback.c -inffast.c -inffast.h -inffixed.h -inflate.c -inflate.h -inftrees.c -inftrees.h -trees.c -trees.h -uncompr.c -zutil.c -zutil.h diff --git a/libs/zlibng/INDEX.md b/libs/zlibng/INDEX.md new file mode 100644 index 000000000..5be081c4e --- /dev/null +++ b/libs/zlibng/INDEX.md @@ -0,0 +1,37 @@ +Contents +-------- + +| Name | Description | +|:-----------------|:---------------------------------------------------------------| +| arch/ | Architecture-specific code | +| doc/ | Documentation for formats and algorithms | +| test/example.c | Zlib usages examples for build testing | +| test/minigzip.c | Minimal gzip-like functionality for build testing | +| test/infcover.c | Inflate code coverage for build testing | +| win32/ | Shared library version resources for Windows | +| CMakeLists.txt | Cmake build script | +| configure | Bash configure/build script | +| adler32.c | Compute the Adler-32 checksum of a data stream | +| chunkset.* | Inline functions to copy small data chunks | +| compress.c | Compress a memory buffer | +| deflate.* | Compress data using the deflate algorithm | +| deflate_fast.c | Compress data using the deflate algorithm with fast strategy | +| deflate_medium.c | Compress data using the deflate algorithm with medium strategy | +| deflate_slow.c | Compress data using the deflate algorithm with slow strategy | +| functable.* | Struct containing function pointers to optimized functions | +| gzguts.h | Internal definitions for gzip operations | +| gzlib.c | Functions common to reading and writing gzip files | +| gzread.c | Read gzip files | +| gzwrite.c | Write gzip files | +| infback.* | Inflate using a callback interface | +| inflate.* | Decompress data | +| inffast.* | Decompress data with speed optimizations | +| inffixed_tbl.h | Table for decoding fixed codes | +| inftrees.h | Generate Huffman trees for efficient decoding | +| trees.* | Output deflated data using Huffman coding | +| uncompr.c | Decompress a memory buffer | +| zconf.h.cmakein | zconf.h template for cmake | +| zendian.h | BYTE_ORDER for endian tests | +| zlib.3 | Man page for zlib | +| zlib.map | Linux symbol information | +| zlib.pc.in | Pkg-config template | diff --git a/libs/zlibng/INSTALL b/libs/zlibng/INSTALL deleted file mode 100644 index 7aa87a50d..000000000 --- a/libs/zlibng/INSTALL +++ /dev/null @@ -1,64 +0,0 @@ -Overview -======== - -There are several methods for compiling and installing zlib-ng, depending -on your favorite operating system and development toolkits. -This document will attempt to give a general overview of some of them. - -PS: We do not recommend running 'make install' unless you know what you - are doing, as this can override the system default zlib library, and - any wrong configuration or incompatability of zlib-ng can make the - whole system unusable. - -On linux distros, an alternative way to use zlib-ng instead of zlib -for specific programs exist, use LD_PRELOAD. -If the program is dynamically linked with zlib, then zlib-ng can take -its place without risking system-wide instability. Ex: -LD_PRELOAD=/opt/zlib-ng/libz.so.1.2.11.zlib-ng /usr/bin/program - - -Configure -========= - -Using the configure script is currently the main method of setting up the -makefiles and preparing for compilation. Configure will attempt to detect -the specifics of your system, and enable some of the relevant options for you. - -Configure accepts several command-line options, some of the most important -ones are detailed below. - ---zlib-compat - This enables options that will ensure that zlib-ng is compiled with all the - functions that a standard zlib library contains, you will need to use this - if you are going to be using zlib-ng as a drop-in replacement for zlib. - ---without-optimizations - This will disable zlib-ng specific optimizations (does not disable strategies). - ---without-new-strategies - This will disable specially optimized strategies, such as deflate_quick and - deflate_medium. - -Run configure like this: -./configure --zlib-compat - -Then you can compile using make: -make -make test - - -Cmake -===== - -Cmake is an alternative to configure, basically letting you do the same thing, -but with different tools and user interfaces. - -Start by initializing cmake: -cmake . - -Then you can start the configuration tui to set the wanted options -ccmake . - -You can now compile using make: -make -make test diff --git a/libs/zlibng/Makefile.in b/libs/zlibng/Makefile.in index 69fe01165..8de3192c9 100644 --- a/libs/zlibng/Makefile.in +++ b/libs/zlibng/Makefile.in @@ -29,8 +29,8 @@ TEST_LIBS=$(LIBNAME1).a LDSHARED=$(CC) LDSHAREDFLAGS=-shared -VER=1.9.9 -VER1=1 +VER=2.0.0-RC2 +VER1=2 STATICLIB=$(LIBNAME1).a SHAREDLIB=$(LIBNAME1).so @@ -51,7 +51,7 @@ RCOBJS= STRIP= RANLIB=ranlib LDCONFIG=ldconfig -LDSHAREDLIBC=-lc +LDSHAREDLIBC= EXE= SRCDIR=. @@ -71,12 +71,64 @@ mandir = ${prefix}/share/man man3dir = ${mandir}/man3 pkgconfigdir = ${libdir}/pkgconfig -OBJZ = adler32.o compress.o crc32.o deflate.o deflate_fast.o deflate_medium.o deflate_slow.o functable.o infback.o inffast.o inflate.o inftrees.o trees.o uncompr.o zutil.o $(ARCH_STATIC_OBJS) -OBJG = gzclose.o gzlib.o gzread.o gzwrite.o +OBJZ = \ + adler32.o \ + chunkset.o \ + compare258.o \ + compress.o \ + crc32.o \ + crc32_comb.o \ + deflate.o \ + deflate_fast.o \ + deflate_medium.o \ + deflate_quick.o \ + deflate_slow.o \ + functable.o \ + infback.o \ + inffast.o \ + inflate.o \ + inftrees.o \ + insert_string.o \ + trees.o \ + uncompr.o \ + zutil.o \ + $(ARCH_STATIC_OBJS) + +OBJG = \ + gzlib.o \ + gzread.o \ + gzwrite.o + OBJC = $(OBJZ) $(OBJG) -PIC_OBJZ = adler32.lo compress.lo crc32.lo deflate.lo deflate_fast.lo deflate_medium.lo deflate_slow.lo functable.lo infback.lo inffast.lo inflate.lo inftrees.lo trees.lo uncompr.lo zutil.lo $(ARCH_SHARED_OBJS) -PIC_OBJG = gzclose.lo gzlib.lo gzread.lo gzwrite.lo +PIC_OBJZ = \ + adler32.lo \ + chunkset.lo \ + compare258.lo \ + compress.lo \ + crc32.lo \ + crc32_comb.lo \ + deflate.lo \ + deflate_fast.lo \ + deflate_medium.lo \ + deflate_quick.lo \ + deflate_slow.lo \ + functable.lo \ + infback.lo \ + inffast.lo \ + inflate.lo \ + inftrees.lo \ + insert_string.lo \ + trees.lo \ + uncompr.lo \ + zutil.lo \ + $(ARCH_SHARED_OBJS) + +PIC_OBJG = \ + gzlib.lo \ + gzread.lo \ + gzwrite.lo + PIC_OBJC = $(PIC_OBJZ) $(PIC_OBJG) OBJS = $(OBJC) @@ -85,11 +137,9 @@ PIC_OBJS = $(PIC_OBJC) all: static shared -static: example$(EXE) minigzip$(EXE) fuzzers +static: adler32_test$(EXE) example$(EXE) minigzip$(EXE) fuzzers makefixed$(EXE) maketrees$(EXE) makecrct$(EXE) -shared: examplesh$(EXE) minigzipsh$(EXE) - -all64: example64$(EXE) minigzip64$(EXE) +shared: adler32_testsh$(EXE) examplesh$(EXE) minigzipsh$(EXE) check: test @@ -181,17 +231,23 @@ $(STATICLIB): $(OBJS) $(AR) $(ARFLAGS) $@ $(OBJS) -@ ($(RANLIB) $@ || true) >/dev/null 2>&1 +adler32_test.o: + $(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/test/adler32_test.c + example.o: $(CC) $(CFLAGS) -DWITH_GZFILEOP $(INCLUDES) -c -o $@ $(SRCDIR)/test/example.c minigzip.o: $(CC) $(CFLAGS) -DWITH_GZFILEOP $(INCLUDES) -c -o $@ $(SRCDIR)/test/minigzip.c -example64.o: - $(CC) $(CFLAGS) -DWITH_GZFILEOP -D_FILE_OFFSET_BITS=64 $(INCLUDES) -c -o $@ $(SRCDIR)/test/example.c +makefixed.o: + $(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/tools/makefixed.c -minigzip64.o: - $(CC) $(CFLAGS) -DWITH_GZFILEOP -D_FILE_OFFSET_BITS=64 $(INCLUDES) -c -o $@ $(SRCDIR)/test/minigzip.c +maketrees.o: + $(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/tools/maketrees.c + +makecrct.o: + $(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/tools/makecrct.c zlibrc.o: win32/zlib$(SUFFIX)1.rc $(RC) $(RCFLAGS) -o $@ win32/zlib$(SUFFIX)1.rc @@ -209,7 +265,7 @@ $(OBJG): %.o: $(SRCDIR)/%.c $(SHAREDTARGET): $(PIC_OBJS) $(DEFFILE) $(RCOBJS) ifneq ($(SHAREDTARGET),) - $(LDSHARED) $(LDSHAREDFLAGS) $(LDFLAGS) -o $@ $(DEFFILE) $(PIC_OBJS) $(RCOBJS) $(LDSHAREDLIBC) + $(LDSHARED) $(CFLAGS) $(LDSHAREDFLAGS) $(LDFLAGS) -o $@ $(DEFFILE) $(PIC_OBJS) $(RCOBJS) $(LDSHAREDLIBC) ifneq ($(STRIP),) $(STRIP) $@ endif @@ -220,38 +276,56 @@ ifneq ($(SHAREDLIB),$(SHAREDTARGET)) endif endif +adler32_test$(EXE): adler32_test.o $(OBJG) $(STATICLIB) + $(CC) $(CFLAGS) $(LDFLAGS) -o $@ adler32_test.o $(OBJG) $(TEST_LIBS) $(LDSHAREDLIBC) +ifneq ($(STRIP),) + $(STRIP) $@ +endif + example$(EXE): example.o $(OBJG) $(STATICLIB) - $(CC) $(LDFLAGS) -o $@ example.o $(OBJG) $(TEST_LIBS) $(LDSHAREDLIBC) + $(CC) $(CFLAGS) $(LDFLAGS) -o $@ example.o $(OBJG) $(TEST_LIBS) $(LDSHAREDLIBC) ifneq ($(STRIP),) $(STRIP) $@ endif minigzip$(EXE): minigzip.o $(OBJG) $(STATICLIB) - $(CC) $(LDFLAGS) -o $@ minigzip.o $(OBJG) $(TEST_LIBS) $(LDSHAREDLIBC) + $(CC) $(CFLAGS) $(LDFLAGS) -o $@ minigzip.o $(OBJG) $(TEST_LIBS) $(LDSHAREDLIBC) +ifneq ($(STRIP),) + $(STRIP) $@ +endif + +adler32_testsh$(EXE): adler32_test.o $(OBJG) $(SHAREDTARGET) + $(CC) $(CFLAGS) $(LDFLAGS) -o $@ adler32_test.o $(OBJG) $(SHAREDTARGET) $(LDSHAREDLIBC) ifneq ($(STRIP),) $(STRIP) $@ endif examplesh$(EXE): example.o $(OBJG) $(SHAREDTARGET) - $(CC) $(LDFLAGS) -o $@ example.o $(OBJG) $(SHAREDTARGET) $(LDSHAREDLIBC) + $(CC) $(CFLAGS) $(LDFLAGS) -o $@ example.o $(OBJG) $(SHAREDTARGET) $(LDSHAREDLIBC) ifneq ($(STRIP),) $(STRIP) $@ endif minigzipsh$(EXE): minigzip.o $(OBJG) $(SHAREDTARGET) - $(CC) $(LDFLAGS) -o $@ minigzip.o $(OBJG) $(SHAREDTARGET) $(LDSHAREDLIBC) + $(CC) $(CFLAGS) $(LDFLAGS) -o $@ minigzip.o $(OBJG) $(SHAREDTARGET) $(LDSHAREDLIBC) ifneq ($(STRIP),) $(STRIP) $@ endif -example64$(EXE): example64.o $(OBJG) $(STATICLIB) - $(CC) $(LDFLAGS) -o $@ example64.o $(OBJG) $(TEST_LIBS) $(LDSHAREDLIBC) +makefixed$(EXE): makefixed.o $(OBJG) $(STATICLIB) + $(CC) $(CFLAGS) $(LDFLAGS) -o $@ makefixed.o $(OBJG) $(TEST_LIBS) $(LDSHAREDLIBC) ifneq ($(STRIP),) $(STRIP) $@ endif -minigzip64$(EXE): minigzip64.o $(OBJG) $(STATICLIB) - $(CC) $(LDFLAGS) -o $@ minigzip64.o $(OBJG) $(TEST_LIBS) $(LDSHAREDLIBC) +maketrees$(EXE): maketrees.o $(OBJG) $(STATICLIB) + $(CC) $(CFLAGS) $(LDFLAGS) -o $@ maketrees.o $(OBJG) $(TEST_LIBS) $(LDSHAREDLIBC) +ifneq ($(STRIP),) + $(STRIP) $@ +endif + +makecrct$(EXE): makecrct.o $(OBJG) $(STATICLIB) + $(CC) $(CFLAGS) $(LDFLAGS) -o $@ makecrct.o $(OBJG) $(TEST_LIBS) $(LDSHAREDLIBC) ifneq ($(STRIP),) $(STRIP) $@ endif @@ -326,11 +400,11 @@ clean: @if [ -f $(ARCHDIR)/Makefile ]; then $(MAKE) -C $(ARCHDIR) clean; fi @if [ -f test/Makefile ]; then $(MAKE) -C test clean; fi rm -f *.o *.lo *~ \ - example$(EXE) minigzip$(EXE) examplesh$(EXE) minigzipsh$(EXE) \ - example64$(EXE) minigzip64$(EXE) \ + adler32_test$(EXE) example$(EXE) minigzip$(EXE) \ + adler32_testsh$(EXE) examplesh$(EXE) minigzipsh$(EXE) \ checksum_fuzzer$(EXE) compress_fuzzer$(EXE) example_small_fuzzer$(EXE) example_large_fuzzer$(EXE) \ example_flush_fuzzer$(EXE) example_dict_fuzzer$(EXE) minigzip_fuzzer$(EXE) \ - infcover \ + infcover makefixed$(EXE) maketrees$(EXE) makecrct$(EXE) \ $(STATICLIB) $(IMPORTLIB) $(SHAREDLIB) $(SHAREDLIBV) $(SHAREDLIBM) \ foo.gz so_locations \ _match.s maketree @@ -338,6 +412,8 @@ clean: rm -f *.gcda *.gcno *.gcov rm -f a.out a.exe rm -f *.pc + rm -f *._h + rm -rf btmp1 btmp2 pkgtmp1 pkgtmp2 maintainer-clean: distclean distclean: clean diff --git a/libs/zlibng/README.md b/libs/zlibng/README.md index b2be6e59f..ad14c3ff4 100644 --- a/libs/zlibng/README.md +++ b/libs/zlibng/README.md @@ -1,10 +1,41 @@ -zlib-ng - zlib for the next generation systems +## zlib-ng +*zlib data compression library for the next generation systems* Maintained by Hans Kristian Rosbach aka Dead2 (zlib-ng àt circlestorm dót org) +|CI|Status| +|:-|-| +|GitHub Actions|[![Master Branch Status](https://github.com/zlib-ng/zlib-ng/workflows/CI%20CMake/badge.svg)](https://github.com/zlib-ng/zlib-ng/actions) [![Master Branch Status](https://github.com/zlib-ng/zlib-ng/workflows/CI%20Configure/badge.svg)](https://github.com/zlib-ng/zlib-ng/actions) [![Master Branch Status](https://github.com/zlib-ng/zlib-ng/workflows/CI%20NMake/badge.svg)](https://github.com/zlib-ng/zlib-ng/actions)| +|Buildkite|[![Build status](https://badge.buildkite.com/7bb1ef84356d3baee26202706cc053ee1de871c0c712b65d26.svg?branch=develop)](https://buildkite.com/circlestorm-productions/zlib-ng)| +|CodeFactor|[![CodeFactor](https://www.codefactor.io/repository/github/zlib-ng/zlib-ng/badge)](https://www.codefactor.io/repository/github/zlib-ng/zlib-ng)| +|OSS-Fuzz|[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/zlib-ng.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:zlib-ng) +|Codecov|[![codecov.io](https://codecov.io/github/zlib-ng/zlib-ng/coverage.svg?branch=develop)](https://codecov.io/github/zlib-ng/zlib-ng/)| -Fork Motivation and History +Features +-------- + +* Zlib compatible API with support for dual-linking +* Modernized native API based on zlib API for ease of porting +* Modern C99 syntax and a clean code layout +* Deflate medium and quick algorithms based on Intels zlib fork +* Support for CPU intrinsics when available + * Adler32 implementation using SSSE3, AVX2, Neon & VSX + * CRC32-B implementation using PCLMULQDQ & ACLE + * Hash table implementation using CRC32-C intrinsics on x86 and ARM + * Slide hash implementations using SSE2, AVX2, Neon & VSX + * Compare256/258 implementations using SSE4.2 & AVX2 + * Inflate chunk copying using SSE2, AVX2 & Neon + * Support for hardware-accelerated deflate using IBM Z DFLTCC +* Unaligned memory read/writes and large bit buffer improvements +* Includes improvements from Cloudflare and Intel forks +* Configure, CMake, and NMake build system support +* Comprehensive set of CMake unit tests +* Code sanitizers, fuzzing, and coverage +* GitHub Actions continuous integration on Windows, macOS, and Linux + * Emulated CI for ARM, AARCH64, PPC, PPC64, SPARC64, S390x using qemu + +Fork Motivation --------------------------- The motivation for this fork was due to seeing several 3rd party @@ -38,17 +69,97 @@ various dead code, all contrib and example code as there is little point in having those in this fork for various reasons. A lot of improvements have gone into zlib-ng since its start, and -numerous people have contributed both small and big improvements, -or valuable testing. +numerous people and companies have contributed both small and big +improvements, or valuable testing. Please read LICENSE.md, it is very simple and very liberal. +Build +----- + +There are two ways to build zlib-ng: + +### Cmake + +To build zlib-ng using the cross-platform makefile generator cmake. + +``` +cmake . +cmake --build . --config Release +ctest --verbose -C Release +``` + +Alternatively, you can use the cmake configuration GUI tool ccmake: + +``` +ccmake . +``` + +### Configure + +To build zlib-ng using the bash configure script: + +``` +./configure +make +make test +``` + +Build Options +------------- +| CMake | configure | Description | Default | +|:-------------------------|:-------------------------|:--------------------------------------------------------------------------------------|---------| +| ZLIB_COMPAT | --zlib-compat | Compile with zlib compatible API | OFF | +| ZLIB_ENABLE_TESTS | | Build test binaries | ON | +| WITH_GZFILEOP | --without-gzfileops | Compile with support for gzFile related functions | ON | +| WITH_OPTIM | --without-optimizations | Build with optimisations | ON | +| WITH_NEW_STRATEGIES | --without-new-strategies | Use new strategies | ON | +| WITH_NATIVE_INSTRUCTIONS | --native | Compiles with full instruction set supported on this host (gcc/clang -march=native) | OFF | +| WITH_SANITIZER | --with-sanitizer | Build with sanitizer (memory, address, undefined) | OFF | +| WITH_FUZZERS | --with-fuzzers | Build test/fuzz | OFF | +| WITH_MAINTAINER_WARNINGS | | Build with project maintainer warnings | OFF | +| WITH_CODE_COVERAGE | | Enable code coverage reporting | OFF | + +Install +------- + +WARNING: We do not recommend manually installing unless you really +know what you are doing, because this can potentially override the system +default zlib library, and any incompatibility or wrong configuration of +zlib-ng can make the whole system unusable, requiring recovery or reinstall. +If you still want a manual install, we recommend using the /opt/ path prefix. + +For Linux distros, an alternative way to use zlib-ng (if compiled in +zlib-compat mode) instead of zlib, is through the use of the +_LD_PRELOAD_ environment variable. If the program is dynamically linked +with zlib, then zlib-ng will temporarily be used instead by the program, +without risking system-wide instability. + +``` +LD_PRELOAD=/opt/zlib-ng/libz.so.1.2.11.zlib-ng /usr/bin/program +``` + +### Cmake + +To install zlib-ng system-wide using cmake: + +``` +cmake --build . --target install +``` + +### Configure + +To install zlib-ng system-wide using the configure script: + +``` +make install +``` Contributing ------------ -Zlib-ng is a young project, and we aim to be open to contributions, -and we would be delighted to receive pull requests on github. +Zlib-ng is a aiming to be open to contributions, and we would be +delighted to receive pull requests on github. Just remember that any code you submit must be your own and it must be zlib licensed. Help with testing and reviewing of pull requests etc is also very @@ -73,9 +184,23 @@ The deflate and zlib specifications were written by L. Peter Deutsch. zlib was originally created by Jean-loup Gailly (compression) and Mark Adler (decompression). +Advanced Build Options +---------------------- -Build Status ------------- - -Travis CI: [![build status](https://api.travis-ci.org/zlib-ng/zlib-ng.svg)](https://travis-ci.org/zlib-ng/zlib-ng/) -Buildkite: [![Build status](https://badge.buildkite.com/7bb1ef84356d3baee26202706cc053ee1de871c0c712b65d26.svg?branch=develop)](https://buildkite.com/circlestorm-productions/zlib-ng) +| CMake | configure | Description | Default | +|:--------------------------------|:----------------------|:--------------------------------------------------------------------|------------------------| +| ZLIB_DUAL_LINK | | Dual link tests with system zlib | OFF | +| | --force-sse2 | Assume SSE2 instructions are always available | ON (x86), OFF (x86_64) | +| WITH_AVX2 | | Build with AVX2 intrinsics | ON | +| WITH_SSE2 | | Build with SSE2 intrinsics | ON | +| WITH_SSE4 | | Build with SSE4 intrinsics | ON | +| WITH_PCLMULQDQ | | Build with PCLMULQDQ intrinsics | ON | +| WITH_ACLE | --without-acle | Build with ACLE intrinsics | ON | +| WITH_NEON | --without-neon | Build with NEON intrinsics | ON | +| WITH_POWER8 | | Build with POWER8 optimisations | ON | +| WITH_DFLTCC_DEFLATE | --with-dfltcc-deflate | Use DEFLATE COMPRESSION CALL instruction for compression on IBM Z | OFF | +| WITH_DFLTCC_INFLATE | --with-dfltcc-inflate | Use DEFLATE COMPRESSION CALL instruction for decompression on IBM Z | OFF | +| WITH_UNALIGNED | | Allow optimizations that use unaligned reads if safe on current arch| ON | +| WITH_INFLATE_STRICT | | Build with strict inflate distance checking | OFF | +| WITH_INFLATE_ALLOW_INVALID_DIST | | Build with zero fill for inflate invalid distances | OFF | +| INSTALL_UTILS | | Copy minigzip and minideflate during install | OFF | diff --git a/libs/zlibng/README.zlib b/libs/zlibng/README.zlib deleted file mode 100644 index edaad58bc..000000000 --- a/libs/zlibng/README.zlib +++ /dev/null @@ -1,118 +0,0 @@ -ZLIB DATA COMPRESSION LIBRARY - -zlib 1.2.11 is a general purpose data compression library. All the code is -thread safe. The data format used by the zlib library is described by RFCs -(Request for Comments) 1950 to 1952 in the files -http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and -rfc1952 (gzip format). - -All functions of the compression library are documented in the file zlib.h -(volunteer to write man pages welcome, contact zlib@gzip.org). A usage example -of the library is given in the file test/example.c which also tests that -the library is working correctly. Another example is given in the file -test/minigzip.c. The compression library itself is composed of all source -files in the root directory. - -To compile all files and run the test program, follow the instructions given at -the top of Makefile.in. In short "./configure; make test", and if that goes -well, "make install" should work for most flavors of Unix. For Windows, use -one of the special makefiles in win32/ or contrib/vstudio/ . For VMS, use -make_vms.com. - -Questions about zlib should be sent to , or to Gilles Vollant - for the Windows DLL version. The zlib home page is -http://zlib.net/ . Before reporting a problem, please check this site to -verify that you have the latest version of zlib; otherwise get the latest -version and check whether the problem still exists or not. - -PLEASE read the zlib FAQ http://zlib.net/zlib_faq.html before asking for help. - -Mark Nelson wrote an article about zlib for the Jan. 1997 -issue of Dr. Dobb's Journal; a copy of the article is available at -http://marknelson.us/1997/01/01/zlib-engine/ . - -The changes made in version 1.2.11 are documented in the file ChangeLog. - -Unsupported third party contributions are provided in directory contrib/ . - -zlib is available in Java using the java.util.zip package, documented at -http://java.sun.com/developer/technicalArticles/Programming/compression/ . - -A Perl interface to zlib written by Paul Marquess is available -at CPAN (Comprehensive Perl Archive Network) sites, including -http://search.cpan.org/~pmqs/IO-Compress-Zlib/ . - -A Python interface to zlib written by A.M. Kuchling is -available in Python 1.5 and later versions, see -http://docs.python.org/library/zlib.html . - -zlib is built into tcl: http://wiki.tcl.tk/4610 . - -An experimental package to read and write files in .zip format, written on top -of zlib by Gilles Vollant , is available in the -contrib/minizip directory of zlib. - - -Notes for some targets: - -- For Windows DLL versions, please see win32/DLL_FAQ.txt - -- For 64-bit Irix, deflate.c must be compiled without any optimization. With - -O, one libpng test fails. The test works in 32 bit mode (with the -n32 - compiler flag). The compiler bug has been reported to SGI. - -- zlib doesn't work with gcc 2.6.3 on a DEC 3000/300LX under OSF/1 2.1 it works - when compiled with cc. - -- On Digital Unix 4.0D (formely OSF/1) on AlphaServer, the cc option -std1 is - necessary to get gzprintf working correctly. This is done by configure. - -- zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works with - other compilers. Use "make test" to check your compiler. - -- gzdopen is not supported on RISCOS or BEOS. - -- For PalmOs, see http://palmzlib.sourceforge.net/ - - -Acknowledgments: - - The deflate format used by zlib was defined by Phil Katz. The deflate and - zlib specifications were written by L. Peter Deutsch. Thanks to all the - people who reported problems and suggested various improvements in zlib; they - are too numerous to cite here. - -Copyright notice: - - (C) 1995-2017 Jean-loup Gailly and Mark Adler - - This software is provided 'as-is', without any express or implied - warranty. In no event will the authors be held liable for any damages - arising from the use of this software. - - Permission is granted to anyone to use this software for any purpose, - including commercial applications, and to alter it and redistribute it - freely, subject to the following restrictions: - - 1. The origin of this software must not be misrepresented; you must not - claim that you wrote the original software. If you use this software - in a product, an acknowledgment in the product documentation would be - appreciated but is not required. - 2. Altered source versions must be plainly marked as such, and must not be - misrepresented as being the original software. - 3. This notice may not be removed or altered from any source distribution. - - Jean-loup Gailly Mark Adler - jloup@gzip.org madler@alumni.caltech.edu - -If you use the zlib library in a product, we would appreciate *not* receiving -lengthy legal documents to sign. The sources are provided for free but without -warranty of any kind. The library has been entirely written by Jean-loup -Gailly and Mark Adler; it does not include third-party code. We make all -contributions to and distributions of this project solely in our personal -capacity, and are not conveying any rights to any intellectual property of -any third parties. - -If you redistribute modified sources, we would appreciate that you include in -the file ChangeLog history information documenting your changes. Please read -the FAQ for more information on the distribution of modified source versions. diff --git a/libs/zlibng/adler32.c b/libs/zlibng/adler32.c index af4104778..7b245fc84 100644 --- a/libs/zlibng/adler32.c +++ b/libs/zlibng/adler32.c @@ -3,24 +3,13 @@ * For conditions of distribution and use, see copyright notice in zlib.h */ -/* @(#) $Id$ */ - #include "zbuild.h" #include "zutil.h" #include "functable.h" #include "adler32_p.h" -uint32_t adler32_c(uint32_t adler, const unsigned char *buf, size_t len); -static uint32_t adler32_combine_(uint32_t adler1, uint32_t adler2, z_off64_t len2); - -#define DO1(buf, i) {adler += (buf)[i]; sum2 += adler;} -#define DO2(buf, i) DO1(buf, i); DO1(buf, i+1); -#define DO4(buf, i) DO2(buf, i); DO2(buf, i+2); -#define DO8(buf, i) DO4(buf, i); DO4(buf, i+4); -#define DO16(buf) DO8(buf, 0); DO8(buf, 8); - /* ========================================================================= */ -uint32_t adler32_c(uint32_t adler, const unsigned char *buf, size_t len) { +Z_INTERNAL uint32_t adler32_c(uint32_t adler, const unsigned char *buf, size_t len) { uint32_t sum2; unsigned n; @@ -29,15 +18,15 @@ uint32_t adler32_c(uint32_t adler, const unsigned char *buf, size_t len) { adler &= 0xffff; /* in case user likes doing a byte at a time, keep it fast */ - if (len == 1) + if (UNLIKELY(len == 1)) return adler32_len_1(adler, buf, sum2); /* initial Adler-32 value (deferred check for len == 1 speed) */ - if (buf == NULL) + if (UNLIKELY(buf == NULL)) return 1L; /* in case short lengths are provided, keep it somewhat fast */ - if (len < 16) + if (UNLIKELY(len < 16)) return adler32_len_16(adler, buf, len, sum2); /* do length NMAX blocks -- requires just one modulo operation */ @@ -50,15 +39,15 @@ uint32_t adler32_c(uint32_t adler, const unsigned char *buf, size_t len) { #endif do { #ifdef UNROLL_MORE - DO16(buf); /* 16 sums unrolled */ + DO16(adler, sum2, buf); /* 16 sums unrolled */ buf += 16; #else - DO8(buf, 0); /* 8 sums unrolled */ + DO8(adler, sum2, buf, 0); /* 8 sums unrolled */ buf += 8; #endif } while (--n); - MOD(adler); - MOD(sum2); + adler %= BASE; + sum2 %= BASE; } /* do remaining bytes (less than NMAX, still just one modulo) */ @@ -66,12 +55,12 @@ uint32_t adler32_c(uint32_t adler, const unsigned char *buf, size_t len) { #ifdef UNROLL_MORE while (len >= 16) { len -= 16; - DO16(buf); + DO16(adler, sum2, buf); buf += 16; #else while (len >= 8) { len -= 8; - DO8(buf, 0); + DO8(adler, sum2, buf, 0); buf += 8; #endif } @@ -80,22 +69,34 @@ uint32_t adler32_c(uint32_t adler, const unsigned char *buf, size_t len) { adler += *buf++; sum2 += adler; } - MOD(adler); - MOD(sum2); + adler %= BASE; + sum2 %= BASE; } /* return recombined sums */ return adler | (sum2 << 16); } -uint32_t ZEXPORT PREFIX(adler32_z)(uint32_t adler, const unsigned char *buf, size_t len) { +#ifdef ZLIB_COMPAT +unsigned long Z_EXPORT PREFIX(adler32_z)(unsigned long adler, const unsigned char *buf, size_t len) { + return (unsigned long)functable.adler32((uint32_t)adler, buf, len); +} +#else +uint32_t Z_EXPORT PREFIX(adler32_z)(uint32_t adler, const unsigned char *buf, size_t len) { return functable.adler32(adler, buf, len); } +#endif /* ========================================================================= */ -uint32_t ZEXPORT PREFIX(adler32)(uint32_t adler, const unsigned char *buf, uint32_t len) { +#ifdef ZLIB_COMPAT +unsigned long Z_EXPORT PREFIX(adler32)(unsigned long adler, const unsigned char *buf, unsigned int len) { + return (unsigned long)functable.adler32((uint32_t)adler, buf, len); +} +#else +uint32_t Z_EXPORT PREFIX(adler32)(uint32_t adler, const unsigned char *buf, uint32_t len) { return functable.adler32(adler, buf, len); } +#endif /* ========================================================================= */ static uint32_t adler32_combine_(uint32_t adler1, uint32_t adler2, z_off64_t len2) { @@ -108,11 +109,11 @@ static uint32_t adler32_combine_(uint32_t adler1, uint32_t adler2, z_off64_t len return 0xffffffff; /* the derivation of this formula is left as an exercise for the reader */ - MOD63(len2); /* assumes len2 >= 0 */ + len2 %= BASE; /* assumes len2 >= 0 */ rem = (unsigned)len2; sum1 = adler1 & 0xffff; sum2 = rem * sum1; - MOD(sum2); + sum2 %= BASE; sum1 += (adler2 & 0xffff) + BASE - 1; sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem; if (sum1 >= BASE) sum1 -= BASE; @@ -123,10 +124,16 @@ static uint32_t adler32_combine_(uint32_t adler1, uint32_t adler2, z_off64_t len } /* ========================================================================= */ -uint32_t ZEXPORT PREFIX(adler32_combine)(uint32_t adler1, uint32_t adler2, z_off_t len2) { - return adler32_combine_(adler1, adler2, len2); +#ifdef ZLIB_COMPAT +unsigned long Z_EXPORT PREFIX(adler32_combine)(unsigned long adler1, unsigned long adler2, z_off_t len2) { + return (unsigned long)adler32_combine_((uint32_t)adler1, (uint32_t)adler2, len2); } -uint32_t ZEXPORT PREFIX(adler32_combine64)(uint32_t adler1, uint32_t adler2, z_off64_t len2) { +unsigned long Z_EXPORT PREFIX4(adler32_combine)(unsigned long adler1, unsigned long adler2, z_off64_t len2) { + return (unsigned long)adler32_combine_((uint32_t)adler1, (uint32_t)adler2, len2); +} +#else +uint32_t Z_EXPORT PREFIX4(adler32_combine)(uint32_t adler1, uint32_t adler2, z_off64_t len2) { return adler32_combine_(adler1, adler2, len2); } +#endif diff --git a/libs/zlibng/adler32_p.h b/libs/zlibng/adler32_p.h index 676653040..7f75c71e2 100644 --- a/libs/zlibng/adler32_p.h +++ b/libs/zlibng/adler32_p.h @@ -12,45 +12,11 @@ #define NMAX 5552 /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ -/* use NO_DIVIDE if your processor does not do division in hardware -- - try it both ways to see which is faster */ -#ifdef NO_DIVIDE -/* note that this assumes BASE is 65521, where 65536 % 65521 == 15 - (thank you to John Reiser for pointing this out) */ -# define CHOP(a) \ - do { \ - uint32_t tmp = a >> 16; \ - a &= 0xffff; \ - a += (tmp << 4) - tmp; \ - } while (0) -# define MOD28(a) \ - do { \ - CHOP(a); \ - if (a >= BASE) a -= BASE; \ - } while (0) -# define MOD(a) \ - do { \ - CHOP(a); \ - MOD28(a); \ - } while (0) -# define MOD63(a) \ - do { /* this assumes a is not negative */ \ - z_off64_t tmp = a >> 32; \ - a &= 0xffffffffL; \ - a += (tmp << 8) - (tmp << 5) + tmp; \ - tmp = a >> 16; \ - a &= 0xffffL; \ - a += (tmp << 4) - tmp; \ - tmp = a >> 16; \ - a &= 0xffffL; \ - a += (tmp << 4) - tmp; \ - if (a >= BASE) a -= BASE; \ - } while (0) -#else -# define MOD(a) a %= BASE -# define MOD28(a) a %= BASE -# define MOD63(a) a %= BASE -#endif +#define DO1(sum1, sum2, buf, i) {(sum1) += buf[(i)]; (sum2) += (sum1);} +#define DO2(sum1, sum2, buf, i) {DO1(sum1, sum2, buf, i); DO1(sum1, sum2, buf, i+1);} +#define DO4(sum1, sum2, buf, i) {DO2(sum1, sum2, buf, i); DO2(sum1, sum2, buf, i+2);} +#define DO8(sum1, sum2, buf, i) {DO4(sum1, sum2, buf, i); DO4(sum1, sum2, buf, i+4);} +#define DO16(sum1, sum2, buf) {DO8(sum1, sum2, buf, 0); DO8(sum1, sum2, buf, 8);} static inline uint32_t adler32_len_1(uint32_t adler, const unsigned char *buf, uint32_t sum2) { adler += buf[0]; @@ -70,8 +36,18 @@ static inline uint32_t adler32_len_16(uint32_t adler, const unsigned char *buf, } if (adler >= BASE) adler -= BASE; - MOD28(sum2); /* only added so many BASE's */ + sum2 %= BASE; /* only added so many BASE's */ return adler | (sum2 << 16); } +static inline uint32_t adler32_len_64(uint32_t adler, const unsigned char *buf, size_t len, uint32_t sum2) { + while (len >= 16) { + len -= 16; + DO16(adler, sum2, buf); + buf += 16; + } + /* Process tail (len < 16). */ + return adler32_len_16(adler, buf, len, sum2); +} + #endif /* ADLER32_P_H */ diff --git a/libs/zlibng/arch/arm/Makefile.in b/libs/zlibng/arch/arm/Makefile.in index a64d591e5..a728d5ab2 100644 --- a/libs/zlibng/arch/arm/Makefile.in +++ b/libs/zlibng/arch/arm/Makefile.in @@ -6,19 +6,27 @@ CC= CFLAGS= SFLAGS= INCLUDES= +ACLEFLAG= +NEONFLAG= SUFFIX= SRCDIR=. SRCTOP=../.. TOPDIR=$(SRCTOP) -all: adler32_neon.o adler32_neon.lo armfeature.o armfeature.lo crc32_acle.o crc32_acle.lo fill_window_arm.o fill_window_arm.lo insert_string_acle.o insert_string_acle.lo +all: \ + adler32_neon.o adler32_neon.lo \ + armfeature.o armfeature.lo \ + chunkset_neon.o chunkset_neon.lo \ + crc32_acle.o crc32_acle.lo \ + slide_neon.o slide_neon.lo \ + insert_string_acle.o insert_string_acle.lo adler32_neon.o: - $(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/adler32_neon.c + $(CC) $(CFLAGS) $(NEONFLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/adler32_neon.c adler32_neon.lo: - $(CC) $(SFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/adler32_neon.c + $(CC) $(SFLAGS) $(NEONFLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/adler32_neon.c armfeature.o: $(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/armfeature.c @@ -26,23 +34,29 @@ armfeature.o: armfeature.lo: $(CC) $(SFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/armfeature.c +chunkset_neon.o: + $(CC) $(CFLAGS) $(NEONFLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/chunkset_neon.c + +chunkset_neon.lo: + $(CC) $(SFLAGS) $(NEONFLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/chunkset_neon.c + crc32_acle.o: - $(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/crc32_acle.c + $(CC) $(CFLAGS) $(ACLEFLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/crc32_acle.c crc32_acle.lo: - $(CC) $(SFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/crc32_acle.c + $(CC) $(SFLAGS) $(ACLEFLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/crc32_acle.c -fill_window_arm.o: - $(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/fill_window_arm.c +slide_neon.o: + $(CC) $(CFLAGS) $(NEONFLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/slide_neon.c -fill_window_arm.lo: - $(CC) $(SFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/fill_window_arm.c +slide_neon.lo: + $(CC) $(SFLAGS) $(NEONFLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/slide_neon.c insert_string_acle.o: - $(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/insert_string_acle.c + $(CC) $(CFLAGS) $(ACLEFLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/insert_string_acle.c insert_string_acle.lo: - $(CC) $(SFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/insert_string_acle.c + $(CC) $(SFLAGS) $(ACLEFLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/insert_string_acle.c mostlyclean: clean clean: diff --git a/libs/zlibng/arch/arm/adler32_neon.c b/libs/zlibng/arch/arm/adler32_neon.c index 3e0ee4dd8..adda6f61d 100644 --- a/libs/zlibng/arch/arm/adler32_neon.c +++ b/libs/zlibng/arch/arm/adler32_neon.c @@ -2,24 +2,16 @@ * Copyright (C) 2017 ARM Holdings Inc. * Author: Adenilson Cavalcanti * - * This software is provided 'as-is', without any express or implied - * warranty. In no event will the authors be held liable for any damages - * arising from the use of this software. - * Permission is granted to anyone to use this software for any purpose, - * including commercial applications, and to alter it and redistribute it - * freely, subject to the following restrictions: - * 1. The origin of this software must not be misrepresented; you must not - * claim that you wrote the original software. If you use this software - * in a product, an acknowledgment in the product documentation would be - * appreciated but is not required. - * 2. Altered source versions must be plainly marked as such, and must not be - * misrepresented as being the original software. - * 3. This notice may not be removed or altered from any source distribution. + * For conditions of distribution and use, see copyright notice in zlib.h */ -#include "adler32_neon.h" -#if defined(__ARM_NEON__) || defined(__ARM_NEON) -#include -#include "adler32_p.h" +#ifdef ARM_NEON_ADLER32 +#ifdef _M_ARM64 +# include +#else +# include +#endif +#include "../../zutil.h" +#include "../../adler32_p.h" static void NEON_accum32(uint32_t *s, const unsigned char *buf, size_t len) { static const uint8_t taps[32] = { @@ -109,7 +101,7 @@ uint32_t adler32_neon(uint32_t adler, const unsigned char *buf, size_t len) { for (i = 0; i < len; i += n) { if ((i + n) > len) - n = len - i; + n = (int)(len - i); if (n < 16) break; diff --git a/libs/zlibng/arch/arm/adler32_neon.h b/libs/zlibng/arch/arm/adler32_neon.h deleted file mode 100644 index 1cb278c7c..000000000 --- a/libs/zlibng/arch/arm/adler32_neon.h +++ /dev/null @@ -1,29 +0,0 @@ -/* Copyright (C) 1995-2011, 2016 Mark Adler - * Copyright (C) 2017 ARM Holdings Inc. - * Author: Adenilson Cavalcanti - * - * This software is provided 'as-is', without any express or implied - * warranty. In no event will the authors be held liable for any damages - * arising from the use of this software. - * Permission is granted to anyone to use this software for any purpose, - * including commercial applications, and to alter it and redistribute it - * freely, subject to the following restrictions: - * 1. The origin of this software must not be misrepresented; you must not - * claim that you wrote the original software. If you use this software - * in a product, an acknowledgment in the product documentation would be - * appreciated but is not required. - * 2. Altered source versions must be plainly marked as such, and must not be - * misrepresented as being the original software. - * 3. This notice may not be removed or altered from any source distribution. - */ -#ifndef __ADLER32_NEON__ -#define __ADLER32_NEON__ - -#if defined(__ARM_NEON__) || defined(__ARM_NEON) -// Depending on the compiler flavor, size_t may be defined in one or the other header. See: -// http://stackoverflow.com/questions/26410466/gcc-linaro-compiler-throws-error-unknown-type-name-size-t -#include -#include -uint32_t adler32_neon(uint32_t adler, const unsigned char *buf, size_t len); -#endif -#endif diff --git a/libs/zlibng/arch/arm/arm.h b/libs/zlibng/arch/arm/arm.h index baee87f18..378006efb 100644 --- a/libs/zlibng/arch/arm/arm.h +++ b/libs/zlibng/arch/arm/arm.h @@ -8,6 +8,6 @@ extern int arm_cpu_has_neon; extern int arm_cpu_has_crc32; -void ZLIB_INTERNAL arm_check_features(void); +void Z_INTERNAL arm_check_features(void); #endif /* ARM_H_ */ diff --git a/libs/zlibng/arch/arm/armfeature.c b/libs/zlibng/arch/arm/armfeature.c index f7ccdc460..cf31a48f0 100644 --- a/libs/zlibng/arch/arm/armfeature.c +++ b/libs/zlibng/arch/arm/armfeature.c @@ -1,50 +1,69 @@ -#include "zutil.h" +#include "../../zutil.h" #if defined(__linux__) -# include -# include +# include +# include +#elif defined(__FreeBSD__) && defined(__aarch64__) +# include +# ifndef ID_AA64ISAR0_CRC32_VAL +# define ID_AA64ISAR0_CRC32_VAL ID_AA64ISAR0_CRC32 +# endif +#elif defined(__APPLE__) +# include #elif defined(_WIN32) -# include +# include #endif static int arm_has_crc32() { #if defined(__linux__) && defined(HWCAP2_CRC32) - return (getauxval(AT_HWCAP2) & HWCAP2_CRC32) != 0 ? 1 : 0; + return (getauxval(AT_HWCAP2) & HWCAP2_CRC32) != 0 ? 1 : 0; +#elif defined(__FreeBSD__) && defined(__aarch64__) + return getenv("QEMU_EMULATING") == NULL + && ID_AA64ISAR0_CRC32_VAL(READ_SPECIALREG(id_aa64isar0_el1)) >= ID_AA64ISAR0_CRC32_BASE; +#elif defined(__APPLE__) + int hascrc32; + size_t size = sizeof(hascrc32); + return sysctlbyname("hw.optional.armv8_crc32", &hascrc32, &size, NULL, 0) == 0 + && hascrc32 == 1; #elif defined(ARM_NOCHECK_ACLE) - return 1; + return 1; #else - return 0; + return 0; #endif } /* AArch64 has neon. */ -#if !defined(__aarch64__) -static inline int arm_has_neon() -{ - #if defined(__linux__) && defined(HWCAP_NEON) +#if !defined(__aarch64__) && !defined(_M_ARM64) +static inline int arm_has_neon() { +#if defined(__linux__) && defined(HWCAP_NEON) return (getauxval(AT_HWCAP) & HWCAP_NEON) != 0 ? 1 : 0; - #elif defined(_M_ARM) && defined(WINAPI_FAMILY_PARTITION) - #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP) +#elif defined(__APPLE__) + int hasneon; + size_t size = sizeof(hasneon); + return sysctlbyname("hw.optional.neon", &hasneon, &size, NULL, 0) == 0 + && hasneon == 1; +#elif defined(_M_ARM) && defined(WINAPI_FAMILY_PARTITION) +# if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP) return 1; /* Always supported */ - #endif - #endif +# endif +#endif - #if defined(ARM_NOCHECK_NEON) +#if defined(ARM_NOCHECK_NEON) return 1; - #else - return 0; - #endif -} -#endif - -ZLIB_INTERNAL int arm_cpu_has_neon; -ZLIB_INTERNAL int arm_cpu_has_crc32; - -void ZLIB_INTERNAL arm_check_features(void) { -#if defined(__aarch64__) - arm_cpu_has_neon = 1; /* always available */ #else - arm_cpu_has_neon = arm_has_neon(); + return 0; #endif - arm_cpu_has_crc32 = arm_has_crc32(); +} +#endif + +Z_INTERNAL int arm_cpu_has_neon; +Z_INTERNAL int arm_cpu_has_crc32; + +void Z_INTERNAL arm_check_features(void) { +#if defined(__aarch64__) || defined(_M_ARM64) + arm_cpu_has_neon = 1; /* always available */ +#else + arm_cpu_has_neon = arm_has_neon(); +#endif + arm_cpu_has_crc32 = arm_has_crc32(); } diff --git a/libs/zlibng/arch/arm/chunkset_neon.c b/libs/zlibng/arch/arm/chunkset_neon.c new file mode 100644 index 000000000..e9cbcb1ba --- /dev/null +++ b/libs/zlibng/arch/arm/chunkset_neon.c @@ -0,0 +1,54 @@ +/* chunkset_neon.c -- NEON inline functions to copy small data chunks. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#ifdef ARM_NEON_CHUNKSET +#ifdef _M_ARM64 +# include +#else +# include +#endif +#include "../../zbuild.h" +#include "../../zutil.h" + +typedef uint8x16_t chunk_t; + +#define HAVE_CHUNKMEMSET_1 +#define HAVE_CHUNKMEMSET_2 +#define HAVE_CHUNKMEMSET_4 +#define HAVE_CHUNKMEMSET_8 + +static inline void chunkmemset_1(uint8_t *from, chunk_t *chunk) { + *chunk = vld1q_dup_u8(from); +} + +static inline void chunkmemset_2(uint8_t *from, chunk_t *chunk) { + *chunk = vreinterpretq_u8_s16(vdupq_n_s16(*(int16_t *)from)); +} + +static inline void chunkmemset_4(uint8_t *from, chunk_t *chunk) { + *chunk = vreinterpretq_u8_s32(vdupq_n_s32(*(int32_t *)from)); +} + +static inline void chunkmemset_8(uint8_t *from, chunk_t *chunk) { + *chunk = vcombine_u8(vld1_u8(from), vld1_u8(from)); +} + +#define CHUNKSIZE chunksize_neon +#define CHUNKCOPY chunkcopy_neon +#define CHUNKCOPY_SAFE chunkcopy_safe_neon +#define CHUNKUNROLL chunkunroll_neon +#define CHUNKMEMSET chunkmemset_neon +#define CHUNKMEMSET_SAFE chunkmemset_safe_neon + +static inline void loadchunk(uint8_t const *s, chunk_t *chunk) { + *chunk = vld1q_u8(s); +} + +static inline void storechunk(uint8_t *out, chunk_t *chunk) { + vst1q_u8(out, *chunk); +} + +#include "chunkset_tpl.h" + +#endif diff --git a/libs/zlibng/arch/arm/crc32_acle.c b/libs/zlibng/arch/arm/crc32_acle.c index 540603545..88ba6c38c 100644 --- a/libs/zlibng/arch/arm/crc32_acle.c +++ b/libs/zlibng/arch/arm/crc32_acle.c @@ -5,21 +5,16 @@ * */ -#ifdef __ARM_FEATURE_CRC32 -# include -# ifdef ZLIB_COMPAT -# include -# else -# include -# endif -# ifdef __linux__ -# include -# endif +#ifdef ARM_ACLE_CRC_HASH +#ifndef _MSC_VER +# include +#endif +#include "../../zutil.h" uint32_t crc32_acle(uint32_t crc, const unsigned char *buf, uint64_t len) { - register uint32_t c; - register const uint16_t *buf2; - register const uint32_t *buf4; + Z_REGISTER uint32_t c; + Z_REGISTER const uint16_t *buf2; + Z_REGISTER const uint32_t *buf4; c = ~crc; if (len && ((ptrdiff_t)buf & 1)) { @@ -36,7 +31,7 @@ uint32_t crc32_acle(uint32_t crc, const unsigned char *buf, uint64_t len) { buf4 = (const uint32_t *) buf; } -# if defined(__aarch64__) +#if defined(__aarch64__) if ((len > sizeof(uint32_t)) && ((ptrdiff_t)buf & sizeof(uint32_t))) { c = __crc32w(c, *buf4++); len -= sizeof(uint32_t); @@ -44,7 +39,7 @@ uint32_t crc32_acle(uint32_t crc, const unsigned char *buf, uint64_t len) { const uint64_t *buf8 = (const uint64_t *) buf4; -# ifdef UNROLL_MORE +#ifdef UNROLL_MORE while (len >= 4 * sizeof(uint64_t)) { c = __crc32d(c, *buf8++); c = __crc32d(c, *buf8++); @@ -52,7 +47,7 @@ uint32_t crc32_acle(uint32_t crc, const unsigned char *buf, uint64_t len) { c = __crc32d(c, *buf8++); len -= 4 * sizeof(uint64_t); } -# endif +#endif while (len >= sizeof(uint64_t)) { c = __crc32d(c, *buf8++); @@ -74,7 +69,7 @@ uint32_t crc32_acle(uint32_t crc, const unsigned char *buf, uint64_t len) { } buf = (const unsigned char *) buf2; -# else /* __aarch64__ */ +#else /* __aarch64__ */ # ifdef UNROLL_MORE while (len >= 8 * sizeof(uint32_t)) { @@ -103,7 +98,7 @@ uint32_t crc32_acle(uint32_t crc, const unsigned char *buf, uint64_t len) { } else { buf = (const unsigned char *) buf4; } -# endif /* __aarch64__ */ +#endif /* __aarch64__ */ if (len) { c = __crc32b(c, *buf); @@ -112,4 +107,4 @@ uint32_t crc32_acle(uint32_t crc, const unsigned char *buf, uint64_t len) { c = ~c; return c; } -#endif /* __ARM_FEATURE_CRC32 */ +#endif diff --git a/libs/zlibng/arch/arm/ctzl.h b/libs/zlibng/arch/arm/ctzl.h index 5ebbde456..77218deec 100644 --- a/libs/zlibng/arch/arm/ctzl.h +++ b/libs/zlibng/arch/arm/ctzl.h @@ -5,7 +5,7 @@ #if defined(_MSC_VER) && !defined(__clang__) static __forceinline unsigned long __builtin_ctzl(unsigned long value) { - return _arm_clz(_arm_rbit(value)); + return _arm_clz(_arm_rbit(value)); } #endif diff --git a/libs/zlibng/arch/arm/fill_window_arm.c b/libs/zlibng/arch/arm/fill_window_arm.c deleted file mode 100644 index c9f042a0d..000000000 --- a/libs/zlibng/arch/arm/fill_window_arm.c +++ /dev/null @@ -1,169 +0,0 @@ -/* fill_window_arm.c -- Optimized hash table shifting for ARM with support for NEON instructions - * Copyright (C) 2017 Mika T. Lindqvist - * - * Authors: - * Mika T. Lindqvist - * Jun He - * - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -/* @(#) $Id$ */ - -#include "zbuild.h" -#include "deflate.h" -#include "deflate_p.h" -#include "functable.h" - -extern ZLIB_INTERNAL int read_buf(PREFIX3(stream) *strm, unsigned char *buf, unsigned size); - -#if defined(__ARM_NEON__) || defined(__ARM_NEON) -#include - -/* SIMD version of hash_chain rebase */ -static inline void slide_hash_chain(Pos *table, unsigned int entries, uint16_t window_size) { - register uint16x8_t v, *p; - register size_t n; - - size_t size = entries*sizeof(table[0]); - Assert((size % sizeof(uint16x8_t) * 8 == 0), "hash table size err"); - - Assert(sizeof(Pos) == 2, "Wrong Pos size"); - v = vdupq_n_u16(window_size); - - p = (uint16x8_t *)table; - n = size / (sizeof(uint16x8_t) * 8); - do { - p[0] = vqsubq_u16(p[0], v); - p[1] = vqsubq_u16(p[1], v); - p[2] = vqsubq_u16(p[2], v); - p[3] = vqsubq_u16(p[3], v); - p[4] = vqsubq_u16(p[4], v); - p[5] = vqsubq_u16(p[5], v); - p[6] = vqsubq_u16(p[6], v); - p[7] = vqsubq_u16(p[7], v); - p += 8; - } while (--n); -} -#else -/* generic version for hash rebase */ -static inline void slide_hash_chain(Pos *table, unsigned int entries, uint16_t window_size) { - unsigned int i; - for (i = 0; i < entries; i++) { - table[i] = (table[i] >= window_size) ? (table[i] - window_size) : NIL; - } -} -#endif - -void fill_window_arm(deflate_state *s) { - register unsigned n; - unsigned long more; /* Amount of free space at the end of the window. */ - unsigned int wsize = s->w_size; - - Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead"); - - do { - more = s->window_size - s->lookahead - s->strstart; - - /* If the window is almost full and there is insufficient lookahead, - * move the upper half to the lower one to make room in the upper half. - */ - if (s->strstart >= wsize+MAX_DIST(s)) { - memcpy(s->window, s->window+wsize, wsize); - s->match_start -= wsize; - s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ - s->block_start -= wsize; - - /* Slide the hash table (could be avoided with 32 bit values - at the expense of memory usage). We slide even when level == 0 - to keep the hash table consistent if we switch back to level > 0 - later. (Using level 0 permanently is not an optimal usage of - zlib, so we don't care about this pathological case.) - */ - - slide_hash_chain(s->head, s->hash_size, wsize); - slide_hash_chain(s->prev, wsize, wsize); - more += wsize; - } - if (s->strm->avail_in == 0) - break; - - /* If there was no sliding: - * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && - * more == window_size - lookahead - strstart - * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) - * => more >= window_size - 2*WSIZE + 2 - * In the BIG_MEM or MMAP case (not yet supported), - * window_size == input_size + MIN_LOOKAHEAD && - * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. - * Otherwise, window_size == 2*WSIZE so more >= 2. - * If there was sliding, more >= WSIZE. So in all cases, more >= 2. - */ - Assert(more >= 2, "more < 2"); - - n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); - s->lookahead += n; - - /* Initialize the hash value now that we have some input: */ - if (s->lookahead + s->insert >= MIN_MATCH) { - unsigned int str = s->strstart - s->insert; - unsigned int insert_cnt = s->insert; - unsigned int slen; - - s->ins_h = s->window[str]; - - if (unlikely(s->lookahead < MIN_MATCH)) - insert_cnt += s->lookahead - MIN_MATCH; - slen = insert_cnt; - if (str >= (MIN_MATCH - 2)) - { - str += 2 - MIN_MATCH; - insert_cnt += MIN_MATCH - 2; - } - if (insert_cnt > 0) - { - functable.insert_string(s, str, insert_cnt); - s->insert -= slen; - } - } - /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, - * but this is not important since only literal bytes will be emitted. - */ - } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); - - /* If the WIN_INIT bytes after the end of the current data have never been - * written, then zero those bytes in order to avoid memory check reports of - * the use of uninitialized (or uninitialised as Julian writes) bytes by - * the longest match routines. Update the high water mark for the next - * time through here. WIN_INIT is set to MAX_MATCH since the longest match - * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. - */ - if (s->high_water < s->window_size) { - unsigned long curr = s->strstart + (unsigned long)s->lookahead; - unsigned long init; - - if (s->high_water < curr) { - /* Previous high water mark below current data -- zero WIN_INIT - * bytes or up to end of window, whichever is less. - */ - init = s->window_size - curr; - if (init > WIN_INIT) - init = WIN_INIT; - memset(s->window + curr, 0, init); - s->high_water = curr + init; - } else if (s->high_water < curr + WIN_INIT) { - /* High water mark at or above current data, but below current data - * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up - * to end of window, whichever is less. - */ - init = curr + WIN_INIT; - if (init > s->window_size) - init = s->window_size; - init -= s->high_water; - memset(s->window + s->high_water, 0, init); - s->high_water += init; - } - } - - Assert((unsigned long)s->strstart <= s->window_size - MIN_LOOKAHEAD, "not enough room for search"); -} diff --git a/libs/zlibng/arch/arm/insert_string_acle.c b/libs/zlibng/arch/arm/insert_string_acle.c index 081b936ce..2daf9ba3e 100644 --- a/libs/zlibng/arch/arm/insert_string_acle.c +++ b/libs/zlibng/arch/arm/insert_string_acle.c @@ -5,49 +5,18 @@ * */ -#if defined(__ARM_FEATURE_CRC32) && defined(ARM_ACLE_CRC_HASH) -#include -#include "zbuild.h" -#include "deflate.h" - -/* =========================================================================== - * Insert string str in the dictionary and set match_head to the previous head - * of the hash chain (the most recent string with same hash key). Return - * the previous length of the hash chain. - * IN assertion: all calls to to INSERT_STRING are made with consecutive - * input characters and the first MIN_MATCH bytes of str are valid - * (except for the last MIN_MATCH-1 bytes of the input file). - */ -Pos insert_string_acle(deflate_state *const s, const Pos str, unsigned int count) { - Pos p, lp, ret; - - if (unlikely(count == 0)) { - return s->prev[str & s->w_mask]; - } - - ret = 0; - lp = str + count - 1; /* last position */ - - for (p = str; p <= lp; p++) { - uint32_t val, h, hm; - memcpy(&val, &s->window[p], sizeof(val)); - - if (s->level >= TRIGGER_LEVEL) - val &= 0xFFFFFF; - - h = __crc32w(0, val); - hm = h & s->hash_mask; - - Pos head = s->head[hm]; - if (head != p) { - s->prev[p & s->w_mask] = head; - s->head[hm] = p; - if (p == lp) - ret = head; - } else if (p == lp) { - ret = p; - } - } - return ret; -} +#ifdef ARM_ACLE_CRC_HASH +#ifndef _MSC_VER +# include +#endif +#include "../../zbuild.h" +#include "../../deflate.h" + +#define UPDATE_HASH(s, h, val) \ + h = __crc32w(0, val) + +#define INSERT_STRING insert_string_acle +#define QUICK_INSERT_STRING quick_insert_string_acle + +#include "../../insert_string_tpl.h" #endif diff --git a/libs/zlibng/arch/arm/slide_neon.c b/libs/zlibng/arch/arm/slide_neon.c new file mode 100644 index 000000000..f64fa5b5b --- /dev/null +++ b/libs/zlibng/arch/arm/slide_neon.c @@ -0,0 +1,52 @@ +/* slide_neon.c -- Optimized hash table shifting for ARM with support for NEON instructions + * Copyright (C) 2017-2020 Mika T. Lindqvist + * + * Authors: + * Mika T. Lindqvist + * Jun He + * + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#if defined(ARM_NEON_SLIDEHASH) +#ifdef _M_ARM64 +# include +#else +# include +#endif +#include "../../zbuild.h" +#include "../../deflate.h" + +/* SIMD version of hash_chain rebase */ +static inline void slide_hash_chain(Pos *table, unsigned int entries, uint16_t window_size) { + Z_REGISTER uint16x8_t v, *p; + Z_REGISTER size_t n; + + size_t size = entries*sizeof(table[0]); + Assert((size % sizeof(uint16x8_t) * 8 == 0), "hash table size err"); + + Assert(sizeof(Pos) == 2, "Wrong Pos size"); + v = vdupq_n_u16(window_size); + + p = (uint16x8_t *)table; + n = size / (sizeof(uint16x8_t) * 8); + do { + p[0] = vqsubq_u16(p[0], v); + p[1] = vqsubq_u16(p[1], v); + p[2] = vqsubq_u16(p[2], v); + p[3] = vqsubq_u16(p[3], v); + p[4] = vqsubq_u16(p[4], v); + p[5] = vqsubq_u16(p[5], v); + p[6] = vqsubq_u16(p[6], v); + p[7] = vqsubq_u16(p[7], v); + p += 8; + } while (--n); +} + +Z_INTERNAL void slide_hash_neon(deflate_state *s) { + unsigned int wsize = s->w_size; + + slide_hash_chain(s->head, HASH_SIZE, wsize); + slide_hash_chain(s->prev, wsize, wsize); +} +#endif diff --git a/libs/zlibng/arch/power/Makefile.in b/libs/zlibng/arch/power/Makefile.in new file mode 100644 index 000000000..25ebc9d1d --- /dev/null +++ b/libs/zlibng/arch/power/Makefile.in @@ -0,0 +1,49 @@ +# Makefile for POWER-specific files +# Copyright (C) 2020 Matheus Castanho , IBM +# For conditions of distribution and use, see copyright notice in zlib.h + +CC= +CFLAGS= +SFLAGS= +INCLUDES= +SUFFIX= + +SRCDIR=. +SRCTOP=../.. +TOPDIR=$(SRCTOP) + +P8FLAGS=-mcpu=power8 + +all: power.o \ + power.lo \ + adler32_power8.o \ + adler32_power8.lo \ + slide_hash_power8.o \ + slide_hash_power8.lo + +power.o: + $(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/power.c + +power.lo: + $(CC) $(SFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/power.c + +adler32_power8.o: + $(CC) $(CFLAGS) $(P8FLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/adler32_power8.c + +adler32_power8.lo: + $(CC) $(SFLAGS) $(P8FLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/adler32_power8.c + +slide_hash_power8.o: + $(CC) $(CFLAGS) $(P8FLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/slide_hash_power8.c + +slide_hash_power8.lo: + $(CC) $(SFLAGS) $(P8FLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/slide_hash_power8.c + +mostlyclean: clean +clean: + rm -f *.o *.lo *~ + rm -rf objs + rm -f *.gcda *.gcno *.gcov + +distclean: + rm -f Makefile diff --git a/libs/zlibng/arch/power/adler32_power8.c b/libs/zlibng/arch/power/adler32_power8.c new file mode 100644 index 000000000..cda51aa80 --- /dev/null +++ b/libs/zlibng/arch/power/adler32_power8.c @@ -0,0 +1,154 @@ +/* Adler32 for POWER8 using VSX instructions. + * Copyright (C) 2020 IBM Corporation + * Author: Rogerio Alves + * For conditions of distribution and use, see copyright notice in zlib.h + * + * Calculate adler32 checksum for 16 bytes at once using POWER8+ VSX (vector) + * instructions. + * + * If adler32 do 1 byte at time on the first iteration s1 is s1_0 (_n means + * iteration n) is the initial value of adler - at start _0 is 1 unless + * adler initial value is different than 1. So s1_1 = s1_0 + c[0] after + * the first calculation. For the iteration s1_2 = s1_1 + c[1] and so on. + * Hence, for iteration N, s1_N = s1_(N-1) + c[N] is the value of s1 on + * after iteration N. + * + * Therefore, for s2 and iteration N, s2_N = s2_0 + N*s1_N + N*c[0] + + * N-1*c[1] + ... + c[N] + * + * In a more general way: + * + * s1_N = s1_0 + sum(i=1 to N)c[i] + * s2_N = s2_0 + N*s1 + sum (i=1 to N)(N-i+1)*c[i] + * + * Where s1_N, s2_N are the values for s1, s2 after N iterations. So if we + * can process N-bit at time we can do this at once. + * + * Since VSX can support 16-bit vector instructions, we can process + * 16-bit at time using N = 16 we have: + * + * s1 = s1_16 = s1_(16-1) + c[16] = s1_0 + sum(i=1 to 16)c[i] + * s2 = s2_16 = s2_0 + 16*s1 + sum(i=1 to 16)(16-i+1)*c[i] + * + * After the first iteration we calculate the adler32 checksum for 16 bytes. + * + * For more background about adler32 please check the RFC: + * https://www.ietf.org/rfc/rfc1950.txt + */ + +#ifdef POWER8_VSX_ADLER32 + +#include +#include "zbuild.h" +#include "zutil.h" +#include "adler32_p.h" + +/* Vector across sum unsigned int (saturate). */ +inline vector unsigned int vec_sumsu(vector unsigned int __a, vector unsigned int __b) { + __b = vec_sld(__a, __a, 8); + __b = vec_add(__b, __a); + __a = vec_sld(__b, __b, 4); + __a = vec_add(__a, __b); + + return __a; +} + +uint32_t adler32_power8(uint32_t adler, const unsigned char* buf, size_t len) { + uint32_t s1 = adler & 0xffff; + uint32_t s2 = (adler >> 16) & 0xffff; + + /* in case user likes doing a byte at a time, keep it fast */ + if (UNLIKELY(len == 1)) + return adler32_len_1(s1, buf, s2); + + /* If buffer is empty or len=0 we need to return adler initial value. */ + if (UNLIKELY(buf == NULL)) + return 1; + + /* This is faster than VSX code for len < 64. */ + if (len < 64) + return adler32_len_64(s1, buf, len, s2); + + /* Use POWER VSX instructions for len >= 64. */ + const vector unsigned int v_zeros = { 0 }; + const vector unsigned char v_mul = {16, 15, 14, 13, 12, 11, 10, 9, 8, 7, + 6, 5, 4, 3, 2, 1}; + const vector unsigned char vsh = vec_splat_u8(4); + const vector unsigned int vmask = {0xffffffff, 0x0, 0x0, 0x0}; + vector unsigned int vs1 = { 0 }; + vector unsigned int vs2 = { 0 }; + vector unsigned int vs1_save = { 0 }; + vector unsigned int vsum1, vsum2; + vector unsigned char vbuf; + int n; + + vs1[0] = s1; + vs2[0] = s2; + + /* Do length bigger than NMAX in blocks of NMAX size. */ + while (len >= NMAX) { + len -= NMAX; + n = NMAX / 16; + do { + vbuf = vec_xl(0, (unsigned char *) buf); + vsum1 = vec_sum4s(vbuf, v_zeros); /* sum(i=1 to 16) buf[i]. */ + /* sum(i=1 to 16) buf[i]*(16-i+1). */ + vsum2 = vec_msum(vbuf, v_mul, v_zeros); + /* Save vs1. */ + vs1_save = vec_add(vs1_save, vs1); + /* Accumulate the sums. */ + vs1 = vec_add(vsum1, vs1); + vs2 = vec_add(vsum2, vs2); + + buf += 16; + } while (--n); + /* Once each block of NMAX size. */ + vs1 = vec_sumsu(vs1, vsum1); + vs1_save = vec_sll(vs1_save, vsh); /* 16*vs1_save. */ + vs2 = vec_add(vs1_save, vs2); + vs2 = vec_sumsu(vs2, vsum2); + + /* vs1[0] = (s1_i + sum(i=1 to 16)buf[i]) mod 65521. */ + vs1[0] = vs1[0] % BASE; + /* vs2[0] = s2_i + 16*s1_save + + sum(i=1 to 16)(16-i+1)*buf[i] mod 65521. */ + vs2[0] = vs2[0] % BASE; + + vs1 = vec_and(vs1, vmask); + vs2 = vec_and(vs2, vmask); + vs1_save = v_zeros; + } + + /* len is less than NMAX one modulo is needed. */ + if (len >= 16) { + while (len >= 16) { + len -= 16; + + vbuf = vec_xl(0, (unsigned char *) buf); + + vsum1 = vec_sum4s(vbuf, v_zeros); /* sum(i=1 to 16) buf[i]. */ + /* sum(i=1 to 16) buf[i]*(16-i+1). */ + vsum2 = vec_msum(vbuf, v_mul, v_zeros); + /* Save vs1. */ + vs1_save = vec_add(vs1_save, vs1); + /* Accumulate the sums. */ + vs1 = vec_add(vsum1, vs1); + vs2 = vec_add(vsum2, vs2); + + buf += 16; + } + /* Since the size will be always less than NMAX we do this once. */ + vs1 = vec_sumsu(vs1, vsum1); + vs1_save = vec_sll(vs1_save, vsh); /* 16*vs1_save. */ + vs2 = vec_add(vs1_save, vs2); + vs2 = vec_sumsu(vs2, vsum2); + } + /* Copy result back to s1, s2 (mod 65521). */ + s1 = vs1[0] % BASE; + s2 = vs2[0] % BASE; + + /* Process tail (len < 16).and return */ + return adler32_len_16(s1, buf, len, s2); +} + +#endif /* POWER8_VSX_ADLER32 */ diff --git a/libs/zlibng/arch/power/power.c b/libs/zlibng/arch/power/power.c new file mode 100644 index 000000000..f93b586d5 --- /dev/null +++ b/libs/zlibng/arch/power/power.c @@ -0,0 +1,19 @@ +/* POWER feature check + * Copyright (C) 2020 Matheus Castanho , IBM + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include +#include "../../zutil.h" + +Z_INTERNAL int power_cpu_has_arch_2_07; + +void Z_INTERNAL power_check_features(void) { + unsigned long hwcap2; + hwcap2 = getauxval(AT_HWCAP2); + +#ifdef POWER8 + if (hwcap2 & PPC_FEATURE2_ARCH_2_07) + power_cpu_has_arch_2_07 = 1; +#endif +} diff --git a/libs/zlibng/arch/power/power.h b/libs/zlibng/arch/power/power.h new file mode 100644 index 000000000..b36c26141 --- /dev/null +++ b/libs/zlibng/arch/power/power.h @@ -0,0 +1,13 @@ +/* power.h -- check for POWER CPU features + * Copyright (C) 2020 Matheus Castanho , IBM + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#ifndef POWER_H_ +#define POWER_H_ + +extern int power_cpu_has_arch_2_07; + +void Z_INTERNAL power_check_features(void); + +#endif /* POWER_H_ */ diff --git a/libs/zlibng/arch/power/slide_hash_power8.c b/libs/zlibng/arch/power/slide_hash_power8.c new file mode 100644 index 000000000..b1e30cea0 --- /dev/null +++ b/libs/zlibng/arch/power/slide_hash_power8.c @@ -0,0 +1,60 @@ +/* Optimized slide_hash for POWER processors + * Copyright (C) 2019-2020 IBM Corporation + * Author: Matheus Castanho + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#ifdef POWER8_VSX_SLIDEHASH + +#include +#include "zbuild.h" +#include "deflate.h" + +static inline void slide_hash_power8_loop(deflate_state *s, unsigned n_elems, Pos *table_end) { + vector unsigned short vw, vm, *vp; + unsigned chunks; + + /* Each vector register (chunk) corresponds to 128 bits == 8 Posf, + * so instead of processing each of the n_elems in the hash table + * individually, we can do it in chunks of 8 with vector instructions. + * + * This function is only called from slide_hash_power8(), and both calls + * pass n_elems as a power of 2 higher than 2^7, as defined by + * deflateInit2_(), so n_elems will always be a multiple of 8. */ + chunks = n_elems >> 3; + Assert(n_elems % 8 == 0, "Weird hash table size!"); + + /* This type casting is safe since s->w_size is always <= 64KB + * as defined by deflateInit2_() and Posf == unsigned short */ + vw[0] = (Pos) s->w_size; + vw = vec_splat(vw,0); + + vp = (vector unsigned short *) table_end; + + do { + /* Processing 8 elements at a time */ + vp--; + vm = *vp; + + /* This is equivalent to: m >= w_size ? m - w_size : 0 + * Since we are using a saturated unsigned subtraction, any + * values that are > w_size will be set to 0, while the others + * will be subtracted by w_size. */ + *vp = vec_subs(vm,vw); + } while (--chunks); +} + +void Z_INTERNAL slide_hash_power8(deflate_state *s) { + unsigned int n; + Pos *p; + + n = HASH_SIZE; + p = &s->head[n]; + slide_hash_power8_loop(s,n,p); + + n = s->w_size; + p = &s->prev[n]; + slide_hash_power8_loop(s,n,p); +} + +#endif /* POWER8_VSX_SLIDEHASH */ diff --git a/libs/zlibng/arch/s390/README.md b/libs/zlibng/arch/s390/README.md index 6995b106e..641c63a83 100644 --- a/libs/zlibng/arch/s390/README.md +++ b/libs/zlibng/arch/s390/README.md @@ -1,6 +1,7 @@ -This directory contains IBM Z DEFLATE CONVERSION CALL support for -zlib-ng. In order to enable it, the following build commands should be -used: +# Introduction + +This directory contains SystemZ deflate hardware acceleration support. +It can be enabled using the following build commands: $ ./configure --with-dfltcc-deflate --with-dfltcc-inflate $ make @@ -10,60 +11,206 @@ or $ cmake -DWITH_DFLTCC_DEFLATE=1 -DWITH_DFLTCC_INFLATE=1 . $ make -When built like this, zlib-ng would compress in hardware on level 1, -and in software on all other levels. Decompression will always happen -in hardware. In order to enable DFLTCC compression for levels 1-6 (i.e. -to make it used by default) one could add -DDFLTCC_LEVEL_MASK=0x7e to -CFLAGS when building zlib-ng. +When built like this, zlib-ng would compress using hardware on level 1, +and using software on all other levels. Decompression will always happen +in hardware. In order to enable hardware compression for levels 1-6 +(i.e. to make it used by default) one could add +`-DDFLTCC_LEVEL_MASK=0x7e` to CFLAGS when building zlib-ng. -Two DFLTCC compression calls produce the same results only when they -both are made on machines of the same generation, and when the -respective buffers have the same offset relative to the start of the -page. Therefore care should be taken when using hardware compression -when reproducible results are desired. +SystemZ deflate hardware acceleration is available on [IBM z15]( +https://www.ibm.com/products/z15) and newer machines under the name [ +"Integrated Accelerator for zEnterprise Data Compression"]( +https://www.ibm.com/support/z-content-solutions/compression/). The +programming interface to it is a machine instruction called DEFLATE +CONVERSION CALL (DFLTCC). It is documented in Chapter 26 of [Principles +of Operation](http://publibfp.dhe.ibm.com/epubs/pdf/a227832c.pdf). Both +the code and the rest of this document refer to this feature simply as +"DFLTCC". + +# Performance + +Performance figures are published [here]( +https://github.com/iii-i/zlib-ng/wiki/Performance-with-dfltcc-patch-applied-and-dfltcc-support-built-on-dfltcc-enabled-machine +). The compression speed-up can be as high as 110x and the decompression +speed-up can be as high as 15x. + +# Limitations + +Two DFLTCC compression calls with identical inputs are not guaranteed to +produce identical outputs. Therefore care should be taken when using +hardware compression when reproducible results are desired. In +particular, zlib-ng-specific `zng_deflateSetParams` call allows setting +`Z_DEFLATE_REPRODUCIBLE` parameter, which disables DFLTCC support for a +particular stream. DFLTCC does not support every single zlib-ng feature, in particular: -* inflate(Z_BLOCK) and inflate(Z_TREES) -* inflateMark() -* inflatePrime() -* deflateParams() after the first deflate() call +* `inflate(Z_BLOCK)` and `inflate(Z_TREES)` +* `inflateMark()` +* `inflatePrime()` +* `inflateSyncPoint()` When used, these functions will either switch to software, or, in case this is not possible, gracefully fail. -All SystemZ-specific code lives in a separate file and is integrated -with the rest of zlib-ng using hook macros, which are explained below. +# Code structure + +All SystemZ-specific code lives in `arch/s390` directory and is +integrated with the rest of zlib-ng using hook macros. + +## Hook macros DFLTCC takes as arguments a parameter block, an input buffer, an output -buffer and a window. ZALLOC_STATE, ZFREE_STATE, ZCOPY_STATE, -ZALLOC_WINDOW and TRY_FREE_WINDOW macros encapsulate allocation details -for the parameter block (which is allocated alongside zlib-ng state) -and the window (which must be page-aligned). +buffer and a window. `ZALLOC_STATE()`, `ZFREE_STATE()`, `ZCOPY_STATE()`, +`ZALLOC_WINDOW()` and `TRY_FREE_WINDOW()` macros encapsulate allocation +details for the parameter block (which is allocated alongside zlib-ng +state) and the window (which must be page-aligned). -While for inflate software and hardware window formats match, this is -not the case for deflate. Therefore, deflateSetDictionary and -deflateGetDictionary need special handling, which is triggered using -the DEFLATE_SET_DICTIONARY_HOOK and DEFLATE_GET_DICTIONARY_HOOK macros. +While inflate software and hardware window formats match, this is not +the case for deflate. Therefore, `deflateSetDictionary()` and +`deflateGetDictionary()` need special handling, which is triggered using +`DEFLATE_SET_DICTIONARY_HOOK()` and `DEFLATE_GET_DICTIONARY_HOOK()` +macros. -deflateResetKeep() and inflateResetKeep() update the DFLTCC parameter -block using DEFLATE_RESET_KEEP_HOOK and INFLATE_RESET_KEEP_HOOK macros. +`deflateResetKeep()` and `inflateResetKeep()` update the DFLTCC +parameter block using `DEFLATE_RESET_KEEP_HOOK()` and +`INFLATE_RESET_KEEP_HOOK()` macros. -DEFLATE_PARAMS_HOOK, INFLATE_PRIME_HOOK and INFLATE_MARK_HOOK macros -make the unsupported deflateParams(), inflatePrime() and inflateMark() -calls fail gracefully. +`INFLATE_PRIME_HOOK()`, `INFLATE_MARK_HOOK()` and +`INFLATE_SYNC_POINT_HOOK()` macros make the respective unsupported +calls gracefully fail. + +`DEFLATE_PARAMS_HOOK()` implements switching between hardware and +software compression mid-stream using `deflateParams()`. Switching +normally entails flushing the current block, which might not be possible +in low memory situations. `deflateParams()` uses `DEFLATE_DONE()` hook +in order to detect and gracefully handle such situations. The algorithm implemented in hardware has different compression ratio -than the one implemented in software. DEFLATE_BOUND_ADJUST_COMPLEN and -DEFLATE_NEED_CONSERVATIVE_BOUND macros make deflateBound() return the -correct results for the hardware implementation. +than the one implemented in software. `DEFLATE_BOUND_ADJUST_COMPLEN()` +and `DEFLATE_NEED_CONSERVATIVE_BOUND()` macros make `deflateBound()` +return the correct results for the hardware implementation. -Actual compression and decompression are handled by DEFLATE_HOOK and -INFLATE_TYPEDO_HOOK macros. Since inflation with DFLTCC manages the -window on its own, calling updatewindow() is suppressed using -INFLATE_NEED_UPDATEWINDOW() macro. +Actual compression and decompression are handled by `DEFLATE_HOOK()` and +`INFLATE_TYPEDO_HOOK()` macros. Since inflation with DFLTCC manages the +window on its own, calling `updatewindow()` is suppressed using +`INFLATE_NEED_UPDATEWINDOW()` macro. In addition to compression, DFLTCC computes CRC-32 and Adler-32 checksums, therefore, whenever it's used, software checksumming is -suppressed using DEFLATE_NEED_CHECKSUM and INFLATE_NEED_CHECKSUM +suppressed using `DEFLATE_NEED_CHECKSUM()` and `INFLATE_NEED_CHECKSUM()` macros. + +While software always produces reproducible compression results, this +is not the case for DFLTCC. Therefore, zlib-ng users are given the +ability to specify whether or not reproducible compression results +are required. While it is always possible to specify this setting +before the compression begins, it is not always possible to do so in +the middle of a deflate stream - the exact conditions for that are +determined by `DEFLATE_CAN_SET_REPRODUCIBLE()` macro. + +## SystemZ-specific code + +When zlib-ng is built with DFLTCC, the hooks described above are +converted to calls to functions, which are implemented in +`arch/s390/dfltcc_*` files. The functions can be grouped in three broad +categories: + +* Base DFLTCC support, e.g. wrapping the machine instruction - + `dfltcc()` and allocating aligned memory - `dfltcc_alloc_state()`. +* Translating between software and hardware data formats, e.g. + `dfltcc_deflate_set_dictionary()`. +* Translating between software and hardware state machines, e.g. + `dfltcc_deflate()` and `dfltcc_inflate()`. + +The functions from the first two categories are fairly simple, however, +various quirks in both software and hardware state machines make the +functions from the third category quite complicated. + +### `dfltcc_deflate()` function + +This function is called by `deflate()` and has the following +responsibilities: + +* Checking whether DFLTCC can be used with the current stream. If this + is not the case, then it returns `0`, making `deflate()` use some + other function in order to compress in software. Otherwise it returns + `1`. +* Block management and Huffman table generation. DFLTCC ends blocks only + when explicitly instructed to do so by the software. Furthermore, + whether to use fixed or dynamic Huffman tables must also be determined + by the software. Since looking at data in order to gather statistics + would negate performance benefits, the following approach is used: the + first `DFLTCC_FIRST_FHT_BLOCK_SIZE` bytes are placed into a fixed + block, and every next `DFLTCC_BLOCK_SIZE` bytes are placed into + dynamic blocks. +* Writing EOBS. Block Closing Control bit in the parameter block + instructs DFLTCC to write EOBS, however, certain conditions need to be + met: input data length must be non-zero or Continuation Flag must be + set. To put this in simpler terms, DFLTCC will silently refuse to + write EOBS if this is the only thing that it is asked to do. Since the + code has to be able to emit EOBS in software anyway, in order to avoid + tricky corner cases Block Closing Control is never used. Whether to + write EOBS is instead controlled by `soft_bcc` variable. +* Triggering block post-processing. Depending on flush mode, `deflate()` + must perform various additional actions when a block or a stream ends. + `dfltcc_deflate()` informs `deflate()` about this using + `block_state *result` parameter. +* Converting software state fields into hardware parameter block fields, + and vice versa. For example, `wrap` and Check Value Type or `bi_valid` + and Sub-Byte Boundary. Certain fields cannot be translated and must + persist untouched in the parameter block between calls, for example, + Continuation Flag or Continuation State Buffer. +* Handling flush modes and low-memory situations. These aspects are + quite intertwined and pervasive. The general idea here is that the + code must not do anything in software - whether explicitly by e.g. + calling `send_eobs()`, or implicitly - by returning to `deflate()` + with certain return and `*result` values, when Continuation Flag is + set. +* Ending streams. When a new block is started and flush mode is + `Z_FINISH`, Block Header Final parameter block bit is used to mark + this block as final. However, sometimes an empty final block is + needed, and, unfortunately, just like with EOBS, DFLTCC will silently + refuse to do this. The general idea of DFLTCC implementation is to + rely as much as possible on the existing code. Here in order to do + this, the code pretends that it does not support DFLTCC, which makes + `deflate()` call a software compression function, which writes an + empty final block. Whether this is required is controlled by + `need_empty_block` variable. +* Error handling. This is simply converting + Operation-Ending-Supplemental Code to string. Errors can only happen + due to things like memory corruption, and therefore they don't affect + the `deflate()` return code. + +### `dfltcc_inflate()` function + +This function is called by `inflate()` from the `TYPEDO` state (that is, +when all the metadata is parsed and the stream is positioned at the type +bits of deflate block header) and it's responsible for the following: + +* Falling back to software when flush mode is `Z_BLOCK` or `Z_TREES`. + Unfortunately, there is no way to ask DFLTCC to stop decompressing on + block or tree boundary. +* `inflate()` decompression loop management. This is controlled using + the return value, which can be either `DFLTCC_INFLATE_BREAK` or + `DFLTCC_INFLATE_CONTINUE`. +* Converting software state fields into hardware parameter block fields, + and vice versa. For example, `whave` and History Length or `wnext` and + History Offset. +* Ending streams. This instructs `inflate()` to return `Z_STREAM_END` + and is controlled by `last` state field. +* Error handling. Like deflate, error handling comprises + Operation-Ending-Supplemental Code to string conversion. Unlike + deflate, errors may happen due to bad inputs, therefore they are + propagated to `inflate()` by setting `mode` field to `MEM` or `BAD`. + +# Testing + +Given complexity of DFLTCC machine instruction, it is not clear whether +QEMU TCG will ever support it. At the time of writing, one has to have +access to an IBM z15+ VM or LPAR in order to test DFLTCC support. Since +DFLTCC is a non-privileged instruction, neither special VM/LPAR +configuration nor root are required. + +Still, zlib-ng CI has a few QEMU TCG-based configurations that check +whether fallback to software is working. diff --git a/libs/zlibng/arch/s390/dfltcc_common.c b/libs/zlibng/arch/s390/dfltcc_common.c index 2f2e22fd0..c82c3b220 100644 --- a/libs/zlibng/arch/s390/dfltcc_common.c +++ b/libs/zlibng/arch/s390/dfltcc_common.c @@ -1,6 +1,6 @@ /* dfltcc_deflate.c - IBM Z DEFLATE CONVERSION CALL general support. */ -#include "zbuild.h" +#include "../../zbuild.h" #include "dfltcc_common.h" #include "dfltcc_detail.h" @@ -12,20 +12,31 @@ `posix_memalign' is not an option. Thus, we overallocate and take the aligned portion of the buffer. */ -static inline int is_dfltcc_enabled(void) -{ +static inline int is_dfltcc_enabled(void) { uint64_t facilities[(DFLTCC_FACILITY / 64) + 1]; - register uint8_t r0 __asm__("r0"); + Z_REGISTER uint8_t r0 __asm__("r0"); memset(facilities, 0, sizeof(facilities)); r0 = sizeof(facilities) / sizeof(facilities[0]) - 1; - __asm__ volatile("stfle %[facilities]\n" : [facilities] "=Q" (facilities), [r0] "+r" (r0) :: "cc"); + /* STFLE is supported since z9-109 and only in z/Architecture mode. When + * compiling with -m31, gcc defaults to ESA mode, however, since the kernel + * is 64-bit, it's always z/Architecture mode at runtime. + */ + __asm__ volatile( +#ifndef __clang__ + ".machinemode push\n" + ".machinemode zarch\n" +#endif + "stfle %[facilities]\n" +#ifndef __clang__ + ".machinemode pop\n" +#endif + : [facilities] "=Q" (facilities), [r0] "+r" (r0) :: "cc"); return is_bit_set((const char *)facilities, DFLTCC_FACILITY); } -void ZLIB_INTERNAL dfltcc_reset(PREFIX3(streamp) strm, uInt size) -{ - struct dfltcc_state *dfltcc_state = (struct dfltcc_state *)((char *)strm->state + size); +void Z_INTERNAL dfltcc_reset(PREFIX3(streamp) strm, uInt size) { + struct dfltcc_state *dfltcc_state = (struct dfltcc_state *)((char *)strm->state + ALIGN_UP(size, 8)); struct dfltcc_qaf_param *param = (struct dfltcc_qaf_param *)&dfltcc_state->param; /* Initialize available functions */ @@ -47,24 +58,17 @@ void ZLIB_INTERNAL dfltcc_reset(PREFIX3(streamp) strm, uInt size) dfltcc_state->param.ribm = DFLTCC_RIBM; } -void ZLIB_INTERNAL *dfltcc_alloc_state(PREFIX3(streamp) strm, uInt items, uInt size) -{ - Assert((items * size) % 8 == 0, - "The size of zlib-ng state must be a multiple of 8"); - return ZALLOC(strm, items * size + sizeof(struct dfltcc_state), sizeof(unsigned char)); +void Z_INTERNAL *dfltcc_alloc_state(PREFIX3(streamp) strm, uInt items, uInt size) { + return ZALLOC(strm, ALIGN_UP(items * size, 8) + sizeof(struct dfltcc_state), sizeof(unsigned char)); } -void ZLIB_INTERNAL dfltcc_copy_state(void *dst, const void *src, uInt size) -{ - memcpy(dst, src, size + sizeof(struct dfltcc_state)); +void Z_INTERNAL dfltcc_copy_state(void *dst, const void *src, uInt size) { + memcpy(dst, src, ALIGN_UP(size, 8) + sizeof(struct dfltcc_state)); } static const int PAGE_ALIGN = 0x1000; -#define ALIGN_UP(p, size) (__typeof__(p))(((uintptr_t)(p) + ((size) - 1)) & ~((size) - 1)) - -void ZLIB_INTERNAL *dfltcc_alloc_window(PREFIX3(streamp) strm, uInt items, uInt size) -{ +void Z_INTERNAL *dfltcc_alloc_window(PREFIX3(streamp) strm, uInt items, uInt size) { void *p; void *w; @@ -79,8 +83,7 @@ void ZLIB_INTERNAL *dfltcc_alloc_window(PREFIX3(streamp) strm, uInt items, uInt return w; } -void ZLIB_INTERNAL dfltcc_free_window(PREFIX3(streamp) strm, void *w) -{ +void Z_INTERNAL dfltcc_free_window(PREFIX3(streamp) strm, void *w) { if (w) ZFREE(strm, *(void **)((unsigned char *)w - sizeof(void *))); } diff --git a/libs/zlibng/arch/s390/dfltcc_common.h b/libs/zlibng/arch/s390/dfltcc_common.h index e206e0431..5c3be91b9 100644 --- a/libs/zlibng/arch/s390/dfltcc_common.h +++ b/libs/zlibng/arch/s390/dfltcc_common.h @@ -2,17 +2,17 @@ #define DFLTCC_COMMON_H #ifdef ZLIB_COMPAT -#include "zlib.h" +#include "../../zlib.h" #else -#include "zlib-ng.h" +#include "../../zlib-ng.h" #endif -#include "zutil.h" +#include "../../zutil.h" -void ZLIB_INTERNAL *dfltcc_alloc_state(PREFIX3(streamp) strm, uInt items, uInt size); -void ZLIB_INTERNAL dfltcc_copy_state(void *dst, const void *src, uInt size); -void ZLIB_INTERNAL dfltcc_reset(PREFIX3(streamp) strm, uInt size); -void ZLIB_INTERNAL *dfltcc_alloc_window(PREFIX3(streamp) strm, uInt items, uInt size); -void ZLIB_INTERNAL dfltcc_free_window(PREFIX3(streamp) strm, void *w); +void Z_INTERNAL *dfltcc_alloc_state(PREFIX3(streamp) strm, uInt items, uInt size); +void Z_INTERNAL dfltcc_copy_state(void *dst, const void *src, uInt size); +void Z_INTERNAL dfltcc_reset(PREFIX3(streamp) strm, uInt size); +void Z_INTERNAL *dfltcc_alloc_window(PREFIX3(streamp) strm, uInt items, uInt size); +void Z_INTERNAL dfltcc_free_window(PREFIX3(streamp) strm, void *w); #define ZALLOC_STATE dfltcc_alloc_state diff --git a/libs/zlibng/arch/s390/dfltcc_deflate.c b/libs/zlibng/arch/s390/dfltcc_deflate.c index adab3e000..187865667 100644 --- a/libs/zlibng/arch/s390/dfltcc_deflate.c +++ b/libs/zlibng/arch/s390/dfltcc_deflate.c @@ -13,27 +13,26 @@ $ make */ -#include "zbuild.h" -#include "zutil.h" -#include "deflate.h" +#include "../../zbuild.h" +#include "../../zutil.h" +#include "../../deflate.h" +#include "../../trees_emit.h" #include "dfltcc_deflate.h" #include "dfltcc_detail.h" -static inline int dfltcc_are_params_ok(int level, uInt window_bits, int strategy, uint16_t level_mask) -{ - return (level_mask & ((uint16_t)1 << level)) != 0 && - (window_bits == HB_BITS) && - (strategy == Z_FIXED || strategy == Z_DEFAULT_STRATEGY); -} - - -int ZLIB_INTERNAL dfltcc_can_deflate(PREFIX3(streamp) strm) -{ +static inline int dfltcc_can_deflate_with_params(PREFIX3(streamp) strm, int level, uInt window_bits, int strategy, + int reproducible) { deflate_state *state = (deflate_state *)strm->state; struct dfltcc_state *dfltcc_state = GET_DFLTCC_STATE(state); /* Unsupported compression settings */ - if (!dfltcc_are_params_ok(state->level, state->w_bits, state->strategy, dfltcc_state->level_mask)) + if ((dfltcc_state->level_mask & (1 << level)) == 0) + return 0; + if (window_bits != HB_BITS) + return 0; + if (strategy != Z_FIXED && strategy != Z_DEFAULT_STRATEGY) + return 0; + if (reproducible) return 0; /* Unsupported hardware */ @@ -45,8 +44,13 @@ int ZLIB_INTERNAL dfltcc_can_deflate(PREFIX3(streamp) strm) return 1; } -static inline void dfltcc_gdht(PREFIX3(streamp) strm) -{ +int Z_INTERNAL dfltcc_can_deflate(PREFIX3(streamp) strm) { + deflate_state *state = (deflate_state *)strm->state; + + return dfltcc_can_deflate_with_params(strm, state->level, state->w_bits, state->strategy, state->reproducible); +} + +static inline void dfltcc_gdht(PREFIX3(streamp) strm) { deflate_state *state = (deflate_state *)strm->state; struct dfltcc_param_v0 *param = &GET_DFLTCC_STATE(state)->param; size_t avail_in = strm->avail_in; @@ -54,8 +58,7 @@ static inline void dfltcc_gdht(PREFIX3(streamp) strm) dfltcc(DFLTCC_GDHT, param, NULL, NULL, &strm->next_in, &avail_in, NULL); } -static inline dfltcc_cc dfltcc_cmpr(PREFIX3(streamp) strm) -{ +static inline dfltcc_cc dfltcc_cmpr(PREFIX3(streamp) strm) { deflate_state *state = (deflate_state *)strm->state; struct dfltcc_param_v0 *param = &GET_DFLTCC_STATE(state)->param; size_t avail_in = strm->avail_in; @@ -72,11 +75,10 @@ static inline dfltcc_cc dfltcc_cmpr(PREFIX3(streamp) strm) return cc; } -static inline void send_eobs(PREFIX3(streamp) strm, const struct dfltcc_param_v0 *param) -{ +static inline void send_eobs(PREFIX3(streamp) strm, const struct dfltcc_param_v0 *param) { deflate_state *state = (deflate_state *)strm->state; - send_bits(state, bi_reverse(param->eobs >> (15 - param->eobl), param->eobl), param->eobl); + send_bits(state, bi_reverse(param->eobs >> (15 - param->eobl), param->eobl), param->eobl, state->bi_buf, state->bi_valid); flush_pending(strm); if (state->pending != 0) { /* The remaining data is located in pending_out[0:pending]. If someone @@ -93,8 +95,7 @@ static inline void send_eobs(PREFIX3(streamp) strm, const struct dfltcc_param_v0 #endif } -int ZLIB_INTERNAL dfltcc_deflate(PREFIX3(streamp) strm, int flush, block_state *result) -{ +int Z_INTERNAL dfltcc_deflate(PREFIX3(streamp) strm, int flush, block_state *result) { deflate_state *state = (deflate_state *)strm->state; struct dfltcc_state *dfltcc_state = GET_DFLTCC_STATE(state); struct dfltcc_param_v0 *param = &dfltcc_state->param; @@ -104,31 +105,38 @@ int ZLIB_INTERNAL dfltcc_deflate(PREFIX3(streamp) strm, int flush, block_state * int soft_bcc; int no_flush; - if (!dfltcc_can_deflate(strm)) + if (!dfltcc_can_deflate(strm)) { + /* Clear history. */ + if (flush == Z_FULL_FLUSH) + param->hl = 0; return 0; + } again: masked_avail_in = 0; soft_bcc = 0; no_flush = flush == Z_NO_FLUSH; - /* Trailing empty block. Switch to software, except when Continuation Flag - * is set, which means that DFLTCC has buffered some output in the - * parameter block and needs to be called again in order to flush it. + /* No input data. Return, except when Continuation Flag is set, which means + * that DFLTCC has buffered some output in the parameter block and needs to + * be called again in order to flush it. */ - if (flush == Z_FINISH && strm->avail_in == 0 && !param->cf) { - if (param->bcf) { - /* A block is still open, and the hardware does not support closing - * blocks without adding data. Thus, close it manually. - */ + if (strm->avail_in == 0 && !param->cf) { + /* A block is still open, and the hardware does not support closing + * blocks without adding data. Thus, close it manually. + */ + if (!no_flush && param->bcf) { send_eobs(strm, param); param->bcf = 0; } - return 0; - } - - if (strm->avail_in == 0 && !param->cf) { - *result = need_more; + /* Let one of deflate_* functions write a trailing empty block. */ + if (flush == Z_FINISH) + return 0; + /* Clear history. */ + if (flush == Z_FULL_FLUSH) + param->hl = 0; + /* Trigger block post-processing if necessary. */ + *result = no_flush ? need_more : block_done; return 1; } @@ -154,13 +162,18 @@ again: send_eobs(strm, param); param->bcf = 0; dfltcc_state->block_threshold = strm->total_in + dfltcc_state->block_size; - if (strm->avail_out == 0) { - *result = need_more; - return 1; - } } } + /* No space for compressed data. If we proceed, dfltcc_cmpr() will return + * DFLTCC_CC_OP1_TOO_SHORT without buffering header bits, but we will still + * set BCF=1, which is wrong. Avoid complications and return early. + */ + if (strm->avail_out == 0) { + *result = need_more; + return 1; + } + /* The caller gave us too much data. Pass only one block worth of * uncompressed data to DFLTCC and mask the rest, so that on the next * iteration we start a new block. @@ -180,7 +193,7 @@ again: param->cvt = state->wrap == 2 ? CVT_CRC32 : CVT_ADLER32; if (!no_flush) /* We need to close a block. Always do this in software - when there is - * no input data, the hardware will not nohor BCC. */ + * no input data, the hardware will not honor BCC. */ soft_bcc = 1; if (flush == Z_FINISH && !param->bcf) /* We are about to open a BFINAL block, set Block Header Final bit @@ -195,8 +208,8 @@ again: param->sbb = (unsigned int)state->bi_valid; if (param->sbb > 0) *strm->next_out = (unsigned char)state->bi_buf; - if (param->hl) - param->nt = 0; /* Honor history */ + /* Honor history and check value */ + param->nt = 0; param->cv = state->wrap == 2 ? ZSWAP32(strm->adler) : strm->adler; /* When opening a block, choose a Huffman-Table Type */ @@ -277,31 +290,60 @@ again: fly with deflateParams, we need to convert between hardware and software window formats. */ -int ZLIB_INTERNAL dfltcc_deflate_params(PREFIX3(streamp) strm, int level, int strategy) -{ +static int dfltcc_was_deflate_used(PREFIX3(streamp) strm) { + deflate_state *state = (deflate_state *)strm->state; + struct dfltcc_param_v0 *param = &GET_DFLTCC_STATE(state)->param; + + return strm->total_in > 0 || param->nt == 0 || param->hl > 0; +} + +int Z_INTERNAL dfltcc_deflate_params(PREFIX3(streamp) strm, int level, int strategy, int *flush) { deflate_state *state = (deflate_state *)strm->state; - struct dfltcc_state *dfltcc_state = GET_DFLTCC_STATE(state); - struct dfltcc_param_v0 *param = &dfltcc_state->param; int could_deflate = dfltcc_can_deflate(strm); - int can_deflate = dfltcc_are_params_ok(level, state->w_bits, strategy, dfltcc_state->level_mask); + int can_deflate = dfltcc_can_deflate_with_params(strm, level, state->w_bits, strategy, state->reproducible); if (can_deflate == could_deflate) /* We continue to work in the same mode - no changes needed */ return Z_OK; - if (strm->total_in == 0 && param->nt == 1 && param->hl == 0) + if (!dfltcc_was_deflate_used(strm)) /* DFLTCC was not used yet - no changes needed */ return Z_OK; - /* Switching between hardware and software is not implemented */ - return Z_STREAM_ERROR; + /* For now, do not convert between window formats - simply get rid of the old data instead */ + *flush = Z_FULL_FLUSH; + return Z_OK; +} + +int Z_INTERNAL dfltcc_deflate_done(PREFIX3(streamp) strm, int flush) { + deflate_state *state = (deflate_state *)strm->state; + struct dfltcc_state *dfltcc_state = GET_DFLTCC_STATE(state); + struct dfltcc_param_v0 *param = &dfltcc_state->param; + + /* When deflate(Z_FULL_FLUSH) is called with small avail_out, it might + * close the block without resetting the compression state. Detect this + * situation and return that deflation is not done. + */ + if (flush == Z_FULL_FLUSH && strm->avail_out == 0) + return 0; + + /* Return that deflation is not done if DFLTCC is used and either it + * buffered some data (Continuation Flag is set), or has not written EOBS + * yet (Block-Continuation Flag is set). + */ + return !dfltcc_can_deflate(strm) || (!param->cf && !param->bcf); +} + +int Z_INTERNAL dfltcc_can_set_reproducible(PREFIX3(streamp) strm, int reproducible) { + deflate_state *state = (deflate_state *)strm->state; + + return reproducible != state->reproducible && !dfltcc_was_deflate_used(strm); } /* Preloading history. */ -static void append_history(struct dfltcc_param_v0 *param, unsigned char *history, const unsigned char *buf, uInt count) -{ +static void append_history(struct dfltcc_param_v0 *param, unsigned char *history, const unsigned char *buf, uInt count) { size_t offset; size_t n; @@ -331,20 +373,19 @@ static void append_history(struct dfltcc_param_v0 *param, unsigned char *history } } -int ZLIB_INTERNAL dfltcc_deflate_set_dictionary(PREFIX3(streamp) strm, - const unsigned char *dictionary, uInt dict_length) -{ +int Z_INTERNAL dfltcc_deflate_set_dictionary(PREFIX3(streamp) strm, + const unsigned char *dictionary, uInt dict_length) { deflate_state *state = (deflate_state *)strm->state; struct dfltcc_state *dfltcc_state = GET_DFLTCC_STATE(state); struct dfltcc_param_v0 *param = &dfltcc_state->param; append_history(param, state->window, dictionary, dict_length); state->strstart = 1; /* Add FDICT to zlib header */ + state->block_start = state->strstart; /* Make deflate_stored happy */ return Z_OK; } -int ZLIB_INTERNAL dfltcc_deflate_get_dictionary(PREFIX3(streamp) strm, unsigned char *dictionary, uInt *dict_length) -{ +int Z_INTERNAL dfltcc_deflate_get_dictionary(PREFIX3(streamp) strm, unsigned char *dictionary, uInt *dict_length) { deflate_state *state = (deflate_state *)strm->state; struct dfltcc_state *dfltcc_state = GET_DFLTCC_STATE(state); struct dfltcc_param_v0 *param = &dfltcc_state->param; diff --git a/libs/zlibng/arch/s390/dfltcc_deflate.h b/libs/zlibng/arch/s390/dfltcc_deflate.h index 93945f0a0..7e32380bd 100644 --- a/libs/zlibng/arch/s390/dfltcc_deflate.h +++ b/libs/zlibng/arch/s390/dfltcc_deflate.h @@ -3,12 +3,14 @@ #include "dfltcc_common.h" -int ZLIB_INTERNAL dfltcc_can_deflate(PREFIX3(streamp) strm); -int ZLIB_INTERNAL dfltcc_deflate(PREFIX3(streamp) strm, int flush, block_state *result); -int ZLIB_INTERNAL dfltcc_deflate_params(PREFIX3(streamp) strm, int level, int strategy); -int ZLIB_INTERNAL dfltcc_deflate_set_dictionary(PREFIX3(streamp) strm, +int Z_INTERNAL dfltcc_can_deflate(PREFIX3(streamp) strm); +int Z_INTERNAL dfltcc_deflate(PREFIX3(streamp) strm, int flush, block_state *result); +int Z_INTERNAL dfltcc_deflate_params(PREFIX3(streamp) strm, int level, int strategy, int *flush); +int Z_INTERNAL dfltcc_deflate_done(PREFIX3(streamp) strm, int flush); +int Z_INTERNAL dfltcc_can_set_reproducible(PREFIX3(streamp) strm, int reproducible); +int Z_INTERNAL dfltcc_deflate_set_dictionary(PREFIX3(streamp) strm, const unsigned char *dictionary, uInt dict_length); -int ZLIB_INTERNAL dfltcc_deflate_get_dictionary(PREFIX3(streamp) strm, unsigned char *dictionary, uInt* dict_length); +int Z_INTERNAL dfltcc_deflate_get_dictionary(PREFIX3(streamp) strm, unsigned char *dictionary, uInt* dict_length); #define DEFLATE_SET_DICTIONARY_HOOK(strm, dict, dict_len) \ do { \ @@ -25,15 +27,17 @@ int ZLIB_INTERNAL dfltcc_deflate_get_dictionary(PREFIX3(streamp) strm, unsigned #define DEFLATE_RESET_KEEP_HOOK(strm) \ dfltcc_reset((strm), sizeof(deflate_state)) -#define DEFLATE_PARAMS_HOOK(strm, level, strategy) \ +#define DEFLATE_PARAMS_HOOK(strm, level, strategy, hook_flush) \ do { \ int err; \ \ - err = dfltcc_deflate_params((strm), (level), (strategy)); \ + err = dfltcc_deflate_params((strm), (level), (strategy), (hook_flush)); \ if (err == Z_STREAM_ERROR) \ return err; \ } while (0) +#define DEFLATE_DONE dfltcc_deflate_done + #define DEFLATE_BOUND_ADJUST_COMPLEN(strm, complen, source_len) \ do { \ if (dfltcc_can_deflate((strm))) \ @@ -47,4 +51,6 @@ int ZLIB_INTERNAL dfltcc_deflate_get_dictionary(PREFIX3(streamp) strm, unsigned #define DEFLATE_NEED_CHECKSUM(strm) (!dfltcc_can_deflate((strm))) +#define DEFLATE_CAN_SET_REPRODUCIBLE dfltcc_can_set_reproducible + #endif diff --git a/libs/zlibng/arch/s390/dfltcc_detail.h b/libs/zlibng/arch/s390/dfltcc_detail.h index 156b2a289..4ec03f809 100644 --- a/libs/zlibng/arch/s390/dfltcc_detail.h +++ b/libs/zlibng/arch/s390/dfltcc_detail.h @@ -46,18 +46,17 @@ typedef enum { #define DFLTCC_FACILITY 151 static inline dfltcc_cc dfltcc(int fn, void *param, - unsigned char **op1, size_t *len1, const unsigned char **op2, size_t *len2, void *hist) -{ + unsigned char **op1, size_t *len1, z_const unsigned char **op2, size_t *len2, void *hist) { unsigned char *t2 = op1 ? *op1 : NULL; size_t t3 = len1 ? *len1 : 0; - const unsigned char *t4 = op2 ? *op2 : NULL; + z_const unsigned char *t4 = op2 ? *op2 : NULL; size_t t5 = len2 ? *len2 : 0; - register int r0 __asm__("r0") = fn; - register void *r1 __asm__("r1") = param; - register unsigned char *r2 __asm__("r2") = t2; - register size_t r3 __asm__("r3") = t3; - register const unsigned char *r4 __asm__("r4") = t4; - register size_t r5 __asm__("r5") = t5; + Z_REGISTER int r0 __asm__("r0") = fn; + Z_REGISTER void *r1 __asm__("r1") = param; + Z_REGISTER unsigned char *r2 __asm__("r2") = t2; + Z_REGISTER size_t r3 __asm__("r3") = t3; + Z_REGISTER z_const unsigned char *r4 __asm__("r4") = t4; + Z_REGISTER size_t r5 __asm__("r5") = t5; int cc; __asm__ volatile( @@ -108,13 +107,11 @@ struct dfltcc_qaf_param { static_assert(sizeof(struct dfltcc_qaf_param) == 32, sizeof_struct_dfltcc_qaf_param_is_32); -static inline int is_bit_set(const char *bits, int n) -{ +static inline int is_bit_set(const char *bits, int n) { return bits[n / 8] & (1 << (7 - (n % 8))); } -static inline void clear_bit(char *bits, int n) -{ +static inline void clear_bit(char *bits, int n) { bits[n / 8] &= ~(1 << (7 - (n % 8))); } @@ -175,8 +172,7 @@ struct dfltcc_param_v0 { static_assert(sizeof(struct dfltcc_param_v0) == 1536, sizeof_struct_dfltcc_param_v0_is_1536); -static inline const char *oesc_msg(char *buf, int oesc) -{ +static inline z_const char *oesc_msg(char *buf, int oesc) { if (oesc == 0x00) return NULL; /* Successful completion */ else { @@ -198,4 +194,6 @@ struct dfltcc_state { char msg[64]; /* Buffer for strm->msg */ }; -#define GET_DFLTCC_STATE(state) ((struct dfltcc_state *)((state) + 1)) +#define ALIGN_UP(p, size) (__typeof__(p))(((uintptr_t)(p) + ((size) - 1)) & ~((size) - 1)) + +#define GET_DFLTCC_STATE(state) ((struct dfltcc_state *)((char *)(state) + ALIGN_UP(sizeof(*state), 8))) diff --git a/libs/zlibng/arch/s390/dfltcc_inflate.c b/libs/zlibng/arch/s390/dfltcc_inflate.c index cec25f41f..f6a7e8f86 100644 --- a/libs/zlibng/arch/s390/dfltcc_inflate.c +++ b/libs/zlibng/arch/s390/dfltcc_inflate.c @@ -13,15 +13,14 @@ $ make */ -#include "zbuild.h" -#include "zutil.h" -#include "inftrees.h" -#include "inflate.h" +#include "../../zbuild.h" +#include "../../zutil.h" +#include "../../inftrees.h" +#include "../../inflate.h" #include "dfltcc_inflate.h" #include "dfltcc_detail.h" -int ZLIB_INTERNAL dfltcc_can_inflate(PREFIX3(streamp) strm) -{ +int Z_INTERNAL dfltcc_can_inflate(PREFIX3(streamp) strm) { struct inflate_state *state = (struct inflate_state *)strm->state; struct dfltcc_state *dfltcc_state = GET_DFLTCC_STATE(state); @@ -33,8 +32,7 @@ int ZLIB_INTERNAL dfltcc_can_inflate(PREFIX3(streamp) strm) return is_bit_set(dfltcc_state->af.fns, DFLTCC_XPND) && is_bit_set(dfltcc_state->af.fmts, DFLTCC_FMT0); } -static inline dfltcc_cc dfltcc_xpnd(PREFIX3(streamp) strm) -{ +static inline dfltcc_cc dfltcc_xpnd(PREFIX3(streamp) strm) { struct inflate_state *state = (struct inflate_state *)strm->state; struct dfltcc_param_v0 *param = &GET_DFLTCC_STATE(state)->param; size_t avail_in = strm->avail_in; @@ -49,8 +47,7 @@ static inline dfltcc_cc dfltcc_xpnd(PREFIX3(streamp) strm) return cc; } -dfltcc_inflate_action ZLIB_INTERNAL dfltcc_inflate(PREFIX3(streamp) strm, int flush, int *ret) -{ +dfltcc_inflate_action Z_INTERNAL dfltcc_inflate(PREFIX3(streamp) strm, int flush, int *ret) { struct inflate_state *state = (struct inflate_state *)strm->state; struct dfltcc_state *dfltcc_state = GET_DFLTCC_STATE(state); struct dfltcc_param_v0 *param = &dfltcc_state->param; @@ -115,16 +112,14 @@ dfltcc_inflate_action ZLIB_INTERNAL dfltcc_inflate(PREFIX3(streamp) strm, int fl DFLTCC_INFLATE_BREAK : DFLTCC_INFLATE_CONTINUE; } -int ZLIB_INTERNAL dfltcc_was_inflate_used(PREFIX3(streamp) strm) -{ +int Z_INTERNAL dfltcc_was_inflate_used(PREFIX3(streamp) strm) { struct inflate_state *state = (struct inflate_state *)strm->state; struct dfltcc_param_v0 *param = &GET_DFLTCC_STATE(state)->param; return !param->nt; } -int ZLIB_INTERNAL dfltcc_inflate_disable(PREFIX3(streamp) strm) -{ +int Z_INTERNAL dfltcc_inflate_disable(PREFIX3(streamp) strm) { struct inflate_state *state = (struct inflate_state *)strm->state; struct dfltcc_state *dfltcc_state = GET_DFLTCC_STATE(state); diff --git a/libs/zlibng/arch/s390/dfltcc_inflate.h b/libs/zlibng/arch/s390/dfltcc_inflate.h index aea2bbb73..fc8a000f7 100644 --- a/libs/zlibng/arch/s390/dfltcc_inflate.h +++ b/libs/zlibng/arch/s390/dfltcc_inflate.h @@ -3,15 +3,15 @@ #include "dfltcc_common.h" -int ZLIB_INTERNAL dfltcc_can_inflate(PREFIX3(streamp) strm); +int Z_INTERNAL dfltcc_can_inflate(PREFIX3(streamp) strm); typedef enum { DFLTCC_INFLATE_CONTINUE, DFLTCC_INFLATE_BREAK, DFLTCC_INFLATE_SOFTWARE, } dfltcc_inflate_action; -dfltcc_inflate_action ZLIB_INTERNAL dfltcc_inflate(PREFIX3(streamp) strm, int flush, int *ret); -int ZLIB_INTERNAL dfltcc_was_inflate_used(PREFIX3(streamp) strm); -int ZLIB_INTERNAL dfltcc_inflate_disable(PREFIX3(streamp) strm); +dfltcc_inflate_action Z_INTERNAL dfltcc_inflate(PREFIX3(streamp) strm, int flush, int *ret); +int Z_INTERNAL dfltcc_was_inflate_used(PREFIX3(streamp) strm); +int Z_INTERNAL dfltcc_inflate_disable(PREFIX3(streamp) strm); #define INFLATE_RESET_KEEP_HOOK(strm) \ dfltcc_reset((strm), sizeof(struct inflate_state)) @@ -41,4 +41,9 @@ int ZLIB_INTERNAL dfltcc_inflate_disable(PREFIX3(streamp) strm); if (dfltcc_was_inflate_used((strm))) return -(1L << 16); \ } while (0) +#define INFLATE_SYNC_POINT_HOOK(strm) \ + do { \ + if (dfltcc_was_inflate_used((strm))) return Z_STREAM_ERROR; \ + } while (0) + #endif diff --git a/libs/zlibng/arch/x86/INDEX b/libs/zlibng/arch/x86/INDEX deleted file mode 100644 index 9ee3802a2..000000000 --- a/libs/zlibng/arch/x86/INDEX +++ /dev/null @@ -1,3 +0,0 @@ -fill_window_sse.c SSE2 optimized fill_window -deflate_quick.c SSE4 optimized deflate strategy for use as level 1 -crc_folding.c SSE4 + PCLMULQDQ optimized CRC folding implementation diff --git a/libs/zlibng/arch/x86/INDEX.md b/libs/zlibng/arch/x86/INDEX.md new file mode 100644 index 000000000..8bf6d08e5 --- /dev/null +++ b/libs/zlibng/arch/x86/INDEX.md @@ -0,0 +1,8 @@ +Contents +-------- + +|Name|Description| +|:-|:-| +|deflate_quick.c|SSE4 optimized deflate strategy for use as level 1| +|crc_folding.c|SSE4 + PCLMULQDQ optimized CRC folding implementation| +|slide_sse2.c|SSE2 optimized slide_hash| diff --git a/libs/zlibng/arch/x86/Makefile.in b/libs/zlibng/arch/x86/Makefile.in index 2e473c626..4f6594e6d 100644 --- a/libs/zlibng/arch/x86/Makefile.in +++ b/libs/zlibng/arch/x86/Makefile.in @@ -8,7 +8,9 @@ SFLAGS= INCLUDES= SUFFIX= +AVX2FLAG=-mavx2 SSE2FLAG=-msse2 +SSSE3FLAG=-mssse3 SSE4FLAG=-msse4 PCLMULFLAG=-mpclmul @@ -16,7 +18,18 @@ SRCDIR=. SRCTOP=../.. TOPDIR=$(SRCTOP) -all: x86.o x86.lo fill_window_sse.o fill_window_sse.lo deflate_quick.o deflate_quick.lo insert_string_sse.o insert_string_sse.lo crc_folding.o crc_folding.lo +all: \ + x86.o x86.lo \ + adler32_avx.o adler32.lo \ + adler32_ssse3.o adler32_ssse3.lo \ + chunkset_avx.o chunkset_avx.lo \ + chunkset_sse.o chunkset_sse.lo \ + compare258_avx.o compare258_avx.lo \ + compare258_sse.o compare258_sse.lo \ + insert_string_sse.o insert_string_sse.lo \ + crc_folding.o crc_folding.lo \ + slide_avx.o slide_avx.lo \ + slide_sse.o slide_sse.lo x86.o: $(CC) $(CFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/x86.c @@ -24,17 +37,29 @@ x86.o: x86.lo: $(CC) $(SFLAGS) $(INCLUDES) -c -o $@ $(SRCDIR)/x86.c -fill_window_sse.o: - $(CC) $(CFLAGS) $(SSE2FLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/fill_window_sse.c +chunkset_avx.o: + $(CC) $(CFLAGS) $(AVX2FLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/chunkset_avx.c -fill_window_sse.lo: - $(CC) $(SFLAGS) $(SSE2FLAG) -DPIC $(INCLUDES) -c -o $@ $(SRCDIR)/fill_window_sse.c +chunkset_avx.lo: + $(CC) $(SFLAGS) $(AVX2FLAG) -DPIC $(INCLUDES) -c -o $@ $(SRCDIR)/chunkset_avx.c -deflate_quick.o: - $(CC) $(CFLAGS) $(SSE4FLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/deflate_quick.c +chunkset_sse.o: + $(CC) $(CFLAGS) $(SSE2FLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/chunkset_sse.c -deflate_quick.lo: - $(CC) $(SFLAGS) $(SSE4FLAG) -DPIC $(INCLUDES) -c -o $@ $(SRCDIR)/deflate_quick.c +chunkset_sse.lo: + $(CC) $(SFLAGS) $(SSE2FLAG) -DPIC $(INCLUDES) -c -o $@ $(SRCDIR)/chunkset_sse.c + +compare258_avx.o: + $(CC) $(CFLAGS) $(AVX2FLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/compare258_avx.c + +compare258_avx.lo: + $(CC) $(SFLAGS) $(AVX2FLAG) -DPIC $(INCLUDES) -c -o $@ $(SRCDIR)/compare258_avx.c + +compare258_sse.o: + $(CC) $(CFLAGS) $(SSE4FLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/compare258_sse.c + +compare258_sse.lo: + $(CC) $(SFLAGS) $(SSE4FLAG) -DPIC $(INCLUDES) -c -o $@ $(SRCDIR)/compare258_sse.c insert_string_sse.o: $(CC) $(CFLAGS) $(SSE4FLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/insert_string_sse.c @@ -48,6 +73,30 @@ crc_folding.o: crc_folding.lo: $(CC) $(SFLAGS) $(PCLMULFLAG) $(SSE4FLAG) -DPIC $(INCLUDES) -c -o $@ $(SRCDIR)/crc_folding.c +slide_avx.o: + $(CC) $(CFLAGS) $(AVX2FLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/slide_avx.c + +slide_avx.lo: + $(CC) $(SFLAGS) $(AVX2FLAG) -DPIC $(INCLUDES) -c -o $@ $(SRCDIR)/slide_avx.c + +slide_sse.o: + $(CC) $(CFLAGS) $(SSE2FLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/slide_sse.c + +slide_sse.lo: + $(CC) $(SFLAGS) $(SSE2FLAG) -DPIC $(INCLUDES) -c -o $@ $(SRCDIR)/slide_sse.c + +adler32_avx.o: $(SRCDIR)/adler32_avx.c + $(CC) $(CFLAGS) $(AVX2FLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/adler32_avx.c + +adler32_avx.lo: $(SRCDIR)/adler32_avx.c + $(CC) $(SFLAGS) $(AVX2FLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/adler32_avx.c + +adler32_ssse3.o: $(SRCDIR)/adler32_ssse3.c + $(CC) $(CFLAGS) $(SSSE3FLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/adler32_ssse3.c + +adler32_ssse3.lo: $(SRCDIR)/adler32_ssse3.c + $(CC) $(SFLAGS) $(SSSE3FLAG) $(INCLUDES) -c -o $@ $(SRCDIR)/adler32_ssse3.c + mostlyclean: clean clean: rm -f *.o *.lo *~ diff --git a/libs/zlibng/arch/x86/adler32_avx.c b/libs/zlibng/arch/x86/adler32_avx.c new file mode 100644 index 000000000..106324654 --- /dev/null +++ b/libs/zlibng/arch/x86/adler32_avx.c @@ -0,0 +1,117 @@ +/* adler32.c -- compute the Adler-32 checksum of a data stream + * Copyright (C) 1995-2011 Mark Adler + * Authors: + * Brian Bockelman + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "../../zbuild.h" +#include "../../zutil.h" + +#include "../../adler32_p.h" + +#include + +#ifdef X86_AVX2_ADLER32 + +Z_INTERNAL uint32_t adler32_avx2(uint32_t adler, const unsigned char *buf, size_t len) { + uint32_t sum2; + + /* split Adler-32 into component sums */ + sum2 = (adler >> 16) & 0xffff; + adler &= 0xffff; + + /* in case user likes doing a byte at a time, keep it fast */ + if (UNLIKELY(len == 1)) + return adler32_len_1(adler, buf, sum2); + + /* initial Adler-32 value (deferred check for len == 1 speed) */ + if (UNLIKELY(buf == NULL)) + return 1L; + + /* in case short lengths are provided, keep it somewhat fast */ + if (UNLIKELY(len < 16)) + return adler32_len_16(adler, buf, len, sum2); + + uint32_t ALIGNED_(32) s1[8], s2[8]; + + memset(s1, 0, sizeof(s1)); s1[7] = adler; // TODO: would a masked load be faster? + memset(s2, 0, sizeof(s2)); s2[7] = sum2; + + char ALIGNED_(32) dot1[32] = \ + {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; + __m256i dot1v = _mm256_load_si256((__m256i*)dot1); + char ALIGNED_(32) dot2[32] = \ + {32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, + 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; + __m256i dot2v = _mm256_load_si256((__m256i*)dot2); + short ALIGNED_(32) dot3[16] = \ + {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; + __m256i dot3v = _mm256_load_si256((__m256i*)dot3); + + // We will need to multiply by + char ALIGNED_(32) shift[16] = {5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + __m128i shiftv = _mm_load_si128((__m128i*)shift); + + while (len >= 32) { + __m256i vs1 = _mm256_load_si256((__m256i*)s1); + __m256i vs2 = _mm256_load_si256((__m256i*)s2); + __m256i vs1_0 = vs1; + + int k = (len < NMAX ? (int)len : NMAX); + k -= k % 32; + len -= k; + + while (k >= 32) { + /* + vs1 = adler + sum(c[i]) + vs2 = sum2 + 16 vs1 + sum( (16-i+1) c[i] ) + */ + __m256i vbuf = _mm256_loadu_si256((__m256i*)buf); + buf += 32; + k -= 32; + + __m256i v_short_sum1 = _mm256_maddubs_epi16(vbuf, dot1v); // multiply-add, resulting in 8 shorts. + __m256i vsum1 = _mm256_madd_epi16(v_short_sum1, dot3v); // sum 8 shorts to 4 int32_t; + __m256i v_short_sum2 = _mm256_maddubs_epi16(vbuf, dot2v); + vs1 = _mm256_add_epi32(vsum1, vs1); + __m256i vsum2 = _mm256_madd_epi16(v_short_sum2, dot3v); + vs1_0 = _mm256_sll_epi32(vs1_0, shiftv); + vsum2 = _mm256_add_epi32(vsum2, vs2); + vs2 = _mm256_add_epi32(vsum2, vs1_0); + vs1_0 = vs1; + } + + // At this point, we have partial sums stored in vs1 and vs2. There are AVX512 instructions that + // would allow us to sum these quickly (VP4DPWSSD). For now, just unpack and move on. + uint32_t ALIGNED_(32) s1_unpack[8]; + uint32_t ALIGNED_(32) s2_unpack[8]; + + _mm256_store_si256((__m256i*)s1_unpack, vs1); + _mm256_store_si256((__m256i*)s2_unpack, vs2); + + adler = (s1_unpack[0] % BASE) + (s1_unpack[1] % BASE) + (s1_unpack[2] % BASE) + (s1_unpack[3] % BASE) + + (s1_unpack[4] % BASE) + (s1_unpack[5] % BASE) + (s1_unpack[6] % BASE) + (s1_unpack[7] % BASE); + adler %= BASE; + s1[7] = adler; + + sum2 = (s2_unpack[0] % BASE) + (s2_unpack[1] % BASE) + (s2_unpack[2] % BASE) + (s2_unpack[3] % BASE) + + (s2_unpack[4] % BASE) + (s2_unpack[5] % BASE) + (s2_unpack[6] % BASE) + (s2_unpack[7] % BASE); + sum2 %= BASE; + s2[7] = sum2; + } + + while (len) { + len--; + adler += *buf++; + sum2 += adler; + } + adler %= BASE; + sum2 %= BASE; + + /* return recombined sums */ + return adler | (sum2 << 16); +} + +#endif diff --git a/libs/zlibng/arch/x86/adler32_ssse3.c b/libs/zlibng/arch/x86/adler32_ssse3.c new file mode 100644 index 000000000..101df4fe4 --- /dev/null +++ b/libs/zlibng/arch/x86/adler32_ssse3.c @@ -0,0 +1,118 @@ +/* adler32.c -- compute the Adler-32 checksum of a data stream + * Copyright (C) 1995-2011 Mark Adler + * Authors: + * Brian Bockelman + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "../../zbuild.h" +#include "../../zutil.h" + +#include "../../adler32_p.h" + +#ifdef X86_SSSE3_ADLER32 + +#include + +Z_INTERNAL uint32_t adler32_ssse3(uint32_t adler, const unsigned char *buf, size_t len) { + uint32_t sum2; + + /* split Adler-32 into component sums */ + sum2 = (adler >> 16) & 0xffff; + adler &= 0xffff; + + /* in case user likes doing a byte at a time, keep it fast */ + if (UNLIKELY(len == 1)) + return adler32_len_1(adler, buf, sum2); + + /* initial Adler-32 value (deferred check for len == 1 speed) */ + if (UNLIKELY(buf == NULL)) + return 1L; + + /* in case short lengths are provided, keep it somewhat fast */ + if (UNLIKELY(len < 16)) + return adler32_len_16(adler, buf, len, sum2); + + uint32_t ALIGNED_(16) s1[4], s2[4]; + + s1[0] = s1[1] = s1[2] = 0; s1[3] = adler; + s2[0] = s2[1] = s2[2] = 0; s2[3] = sum2; + + char ALIGNED_(16) dot1[16] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; + __m128i dot1v = _mm_load_si128((__m128i*)dot1); + char ALIGNED_(16) dot2[16] = {16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; + __m128i dot2v = _mm_load_si128((__m128i*)dot2); + short ALIGNED_(16) dot3[8] = {1, 1, 1, 1, 1, 1, 1, 1}; + __m128i dot3v = _mm_load_si128((__m128i*)dot3); + + // We will need to multiply by + //char ALIGNED_(16) shift[4] = {0, 0, 0, 4}; //{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4}; + + char ALIGNED_(16) shift[16] = {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + __m128i shiftv = _mm_load_si128((__m128i*)shift); + + while (len >= 16) { + __m128i vs1 = _mm_load_si128((__m128i*)s1); + __m128i vs2 = _mm_load_si128((__m128i*)s2); + __m128i vs1_0 = vs1; + + int k = (len < NMAX ? (int)len : NMAX); + k -= k % 16; + len -= k; + + while (k >= 16) { + /* + vs1 = adler + sum(c[i]) + vs2 = sum2 + 16 vs1 + sum( (16-i+1) c[i] ) + + NOTE: 256-bit equivalents are: + _mm256_maddubs_epi16 <- operates on 32 bytes to 16 shorts + _mm256_madd_epi16 <- Sums 16 shorts to 8 int32_t. + We could rewrite the below to use 256-bit instructions instead of 128-bit. + */ + __m128i vbuf = _mm_loadu_si128((__m128i*)buf); + buf += 16; + k -= 16; + + __m128i v_short_sum1 = _mm_maddubs_epi16(vbuf, dot1v); // multiply-add, resulting in 8 shorts. + __m128i vsum1 = _mm_madd_epi16(v_short_sum1, dot3v); // sum 8 shorts to 4 int32_t; + __m128i v_short_sum2 = _mm_maddubs_epi16(vbuf, dot2v); + vs1 = _mm_add_epi32(vsum1, vs1); + __m128i vsum2 = _mm_madd_epi16(v_short_sum2, dot3v); + vs1_0 = _mm_sll_epi32(vs1_0, shiftv); + vsum2 = _mm_add_epi32(vsum2, vs2); + vs2 = _mm_add_epi32(vsum2, vs1_0); + vs1_0 = vs1; + } + + // At this point, we have partial sums stored in vs1 and vs2. There are AVX512 instructions that + // would allow us to sum these quickly (VP4DPWSSD). For now, just unpack and move on. + + uint32_t ALIGNED_(16) s1_unpack[4]; + uint32_t ALIGNED_(16) s2_unpack[4]; + + _mm_store_si128((__m128i*)s1_unpack, vs1); + _mm_store_si128((__m128i*)s2_unpack, vs2); + + adler = (s1_unpack[0] % BASE) + (s1_unpack[1] % BASE) + (s1_unpack[2] % BASE) + (s1_unpack[3] % BASE); + adler %= BASE; + s1[3] = adler; + + sum2 = (s2_unpack[0] % BASE) + (s2_unpack[1] % BASE) + (s2_unpack[2] % BASE) + (s2_unpack[3] % BASE); + sum2 %= BASE; + s2[3] = sum2; + } + + while (len) { + len--; + adler += *buf++; + sum2 += adler; + } + adler %= BASE; + sum2 %= BASE; + + /* return recombined sums */ + return adler | (sum2 << 16); +} + +#endif diff --git a/libs/zlibng/arch/x86/chunkset_avx.c b/libs/zlibng/arch/x86/chunkset_avx.c new file mode 100644 index 000000000..eb76c0db9 --- /dev/null +++ b/libs/zlibng/arch/x86/chunkset_avx.c @@ -0,0 +1,50 @@ +/* chunkset_avx.c -- AVX inline functions to copy small data chunks. + * For conditions of distribution and use, see copyright notice in zlib.h + */ +#include "zbuild.h" +#include "zutil.h" + +#ifdef X86_AVX_CHUNKSET +#include + +typedef __m256i chunk_t; + +#define HAVE_CHUNKMEMSET_1 +#define HAVE_CHUNKMEMSET_2 +#define HAVE_CHUNKMEMSET_4 +#define HAVE_CHUNKMEMSET_8 + +static inline void chunkmemset_1(uint8_t *from, chunk_t *chunk) { + *chunk = _mm256_set1_epi8(*(int8_t *)from); +} + +static inline void chunkmemset_2(uint8_t *from, chunk_t *chunk) { + *chunk = _mm256_set1_epi16(*(int16_t *)from); +} + +static inline void chunkmemset_4(uint8_t *from, chunk_t *chunk) { + *chunk = _mm256_set1_epi32(*(int32_t *)from); +} + +static inline void chunkmemset_8(uint8_t *from, chunk_t *chunk) { + *chunk = _mm256_set1_epi64x(*(int64_t *)from); +} + +static inline void loadchunk(uint8_t const *s, chunk_t *chunk) { + *chunk = _mm256_loadu_si256((__m256i *)s); +} + +static inline void storechunk(uint8_t *out, chunk_t *chunk) { + _mm256_storeu_si256((__m256i *)out, *chunk); +} + +#define CHUNKSIZE chunksize_avx +#define CHUNKCOPY chunkcopy_avx +#define CHUNKCOPY_SAFE chunkcopy_safe_avx +#define CHUNKUNROLL chunkunroll_avx +#define CHUNKMEMSET chunkmemset_avx +#define CHUNKMEMSET_SAFE chunkmemset_safe_avx + +#include "chunkset_tpl.h" + +#endif diff --git a/libs/zlibng/arch/x86/chunkset_sse.c b/libs/zlibng/arch/x86/chunkset_sse.c new file mode 100644 index 000000000..1d5a0faa9 --- /dev/null +++ b/libs/zlibng/arch/x86/chunkset_sse.c @@ -0,0 +1,51 @@ +/* chunkset_sse.c -- SSE inline functions to copy small data chunks. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "zbuild.h" +#include "zutil.h" + +#ifdef X86_SSE2 +#include + +typedef __m128i chunk_t; + +#define HAVE_CHUNKMEMSET_1 +#define HAVE_CHUNKMEMSET_2 +#define HAVE_CHUNKMEMSET_4 +#define HAVE_CHUNKMEMSET_8 + +static inline void chunkmemset_1(uint8_t *from, chunk_t *chunk) { + *chunk = _mm_set1_epi8(*(int8_t *)from); +} + +static inline void chunkmemset_2(uint8_t *from, chunk_t *chunk) { + *chunk = _mm_set1_epi16(*(int16_t *)from); +} + +static inline void chunkmemset_4(uint8_t *from, chunk_t *chunk) { + *chunk = _mm_set1_epi32(*(int32_t *)from); +} + +static inline void chunkmemset_8(uint8_t *from, chunk_t *chunk) { + *chunk = _mm_set1_epi64x(*(int64_t *)from); +} + +static inline void loadchunk(uint8_t const *s, chunk_t *chunk) { + *chunk = _mm_loadu_si128((__m128i *)s); +} + +static inline void storechunk(uint8_t *out, chunk_t *chunk) { + _mm_storeu_si128((__m128i *)out, *chunk); +} + +#define CHUNKSIZE chunksize_sse2 +#define CHUNKCOPY chunkcopy_sse2 +#define CHUNKCOPY_SAFE chunkcopy_safe_sse2 +#define CHUNKUNROLL chunkunroll_sse2 +#define CHUNKMEMSET chunkmemset_sse2 +#define CHUNKMEMSET_SAFE chunkmemset_safe_sse2 + +#include "chunkset_tpl.h" + +#endif diff --git a/libs/zlibng/arch/x86/compare258_avx.c b/libs/zlibng/arch/x86/compare258_avx.c new file mode 100644 index 000000000..d9108fdeb --- /dev/null +++ b/libs/zlibng/arch/x86/compare258_avx.c @@ -0,0 +1,67 @@ +/* compare258_avx.c -- AVX2 version of compare258 + * Copyright Mika T. Lindqvist + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "../../zbuild.h" +#include "../../zutil.h" + +#include "fallback_builtins.h" + +#if defined(X86_AVX2) && defined(HAVE_BUILTIN_CTZ) + +#include +#ifdef _MSC_VER +# include +#endif + +/* UNALIGNED_OK, AVX2 intrinsic comparison */ +static inline uint32_t compare256_unaligned_avx2_static(const unsigned char *src0, const unsigned char *src1) { + uint32_t len = 0; + + do { + __m256i ymm_src0, ymm_src1, ymm_cmp; + ymm_src0 = _mm256_loadu_si256((__m256i*)src0); + ymm_src1 = _mm256_loadu_si256((__m256i*)src1); + ymm_cmp = _mm256_cmpeq_epi8(ymm_src0, ymm_src1); /* non-identical bytes = 00, identical bytes = FF */ + unsigned mask = (unsigned)_mm256_movemask_epi8(ymm_cmp); + if (mask != 0xFFFFFFFF) { + uint32_t match_byte = (uint32_t)__builtin_ctz(~mask); /* Invert bits so identical = 0 */ + return len + match_byte; + } + + src0 += 32, src1 += 32, len += 32; + + ymm_src0 = _mm256_loadu_si256((__m256i*)src0); + ymm_src1 = _mm256_loadu_si256((__m256i*)src1); + ymm_cmp = _mm256_cmpeq_epi8(ymm_src0, ymm_src1); + mask = (unsigned)_mm256_movemask_epi8(ymm_cmp); + if (mask != 0xFFFFFFFF) { + uint32_t match_byte = (uint32_t)__builtin_ctz(~mask); + return len + match_byte; + } + + src0 += 32, src1 += 32, len += 32; + } while (len < 256); + + return 256; +} + +static inline uint32_t compare258_unaligned_avx2_static(const unsigned char *src0, const unsigned char *src1) { + if (*(uint16_t *)src0 != *(uint16_t *)src1) + return (*src0 == *src1); + + return compare256_unaligned_avx2_static(src0+2, src1+2) + 2; +} + +Z_INTERNAL uint32_t compare258_unaligned_avx2(const unsigned char *src0, const unsigned char *src1) { + return compare258_unaligned_avx2_static(src0, src1); +} + +#define LONGEST_MATCH longest_match_unaligned_avx2 +#define COMPARE256 compare256_unaligned_avx2_static +#define COMPARE258 compare258_unaligned_avx2_static + +#include "match_tpl.h" + +#endif diff --git a/libs/zlibng/arch/x86/compare258_sse.c b/libs/zlibng/arch/x86/compare258_sse.c new file mode 100644 index 000000000..17534c051 --- /dev/null +++ b/libs/zlibng/arch/x86/compare258_sse.c @@ -0,0 +1,74 @@ +/* compare258_sse.c -- SSE4.2 version of compare258 + * + * Copyright (C) 2013 Intel Corporation. All rights reserved. + * Authors: + * Wajdi Feghali + * Jim Guilford + * Vinodh Gopal + * Erdinc Ozturk + * Jim Kukunas + * + * Portions are Copyright (C) 2016 12Sided Technology, LLC. + * Author: + * Phil Vachon + * + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "../../zbuild.h" +#include "../../zutil.h" + +#ifdef X86_SSE42_CMP_STR + +#include +#ifdef _MSC_VER +# include +#endif + +/* UNALIGNED_OK, SSE4.2 intrinsic comparison */ +static inline uint32_t compare256_unaligned_sse4_static(const unsigned char *src0, const unsigned char *src1) { + uint32_t len = 0; + + do { + #define mode _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_NEGATIVE_POLARITY + __m128i xmm_src0, xmm_src1; + uint32_t ret; + + xmm_src0 = _mm_loadu_si128((__m128i *)src0); + xmm_src1 = _mm_loadu_si128((__m128i *)src1); + ret = (uint32_t)_mm_cmpestri(xmm_src0, 16, xmm_src1, 16, mode); + if (_mm_cmpestrc(xmm_src0, 16, xmm_src1, 16, mode)) { + return len + ret; + } + src0 += 16, src1 += 16, len += 16; + + xmm_src0 = _mm_loadu_si128((__m128i *)src0); + xmm_src1 = _mm_loadu_si128((__m128i *)src1); + ret = (uint32_t)_mm_cmpestri(xmm_src0, 16, xmm_src1, 16, mode); + if (_mm_cmpestrc(xmm_src0, 16, xmm_src1, 16, mode)) { + return len + ret; + } + src0 += 16, src1 += 16, len += 16; + } while (len < 256); + + return 256; +} + +static inline uint32_t compare258_unaligned_sse4_static(const unsigned char *src0, const unsigned char *src1) { + if (*(uint16_t *)src0 != *(uint16_t *)src1) + return (*src0 == *src1); + + return compare256_unaligned_sse4_static(src0+2, src1+2) + 2; +} + +Z_INTERNAL uint32_t compare258_unaligned_sse4(const unsigned char *src0, const unsigned char *src1) { + return compare258_unaligned_sse4_static(src0, src1); +} + +#define LONGEST_MATCH longest_match_unaligned_sse4 +#define COMPARE256 compare256_unaligned_sse4_static +#define COMPARE258 compare258_unaligned_sse4_static + +#include "match_tpl.h" + +#endif diff --git a/libs/zlibng/arch/x86/crc_folding.c b/libs/zlibng/arch/x86/crc_folding.c index eb178f55c..918bd9468 100644 --- a/libs/zlibng/arch/x86/crc_folding.c +++ b/libs/zlibng/arch/x86/crc_folding.c @@ -1,5 +1,5 @@ /* - * Compute the CRC32 using a parallelized folding approach with the PCLMULQDQ + * Compute the CRC32 using a parallelized folding approach with the PCLMULQDQ * instruction. * * A white paper describing this algorithm can be found at: @@ -18,14 +18,14 @@ #ifdef X86_PCLMULQDQ_CRC -#include "zbuild.h" +#include "../../zbuild.h" #include #include #include #include "crc_folding.h" -ZLIB_INTERNAL void crc_fold_init(deflate_state *const s) { +Z_INTERNAL void crc_fold_init(deflate_state *const s) { /* CRC_SAVE */ _mm_storeu_si128((__m128i *)s->crc0 + 0, _mm_cvtsi32_si128(0x9db42487)); _mm_storeu_si128((__m128i *)s->crc0 + 1, _mm_setzero_si128()); @@ -227,9 +227,10 @@ static void partial_fold(const size_t len, __m128i *xmm_crc0, __m128i *xmm_crc1, *xmm_crc3 = _mm_castps_si128(ps_res); } -ZLIB_INTERNAL void crc_fold_copy(deflate_state *const s, unsigned char *dst, const unsigned char *src, long len) { +Z_INTERNAL void crc_fold_copy(deflate_state *const s, unsigned char *dst, const unsigned char *src, long len) { unsigned long algn_diff; __m128i xmm_t0, xmm_t1, xmm_t2, xmm_t3; + char ALIGNED_(16) partial_buf[16] = { 0 }; /* CRC_LOAD */ __m128i xmm_crc0 = _mm_loadu_si128((__m128i *)s->crc0 + 0); @@ -241,11 +242,14 @@ ZLIB_INTERNAL void crc_fold_copy(deflate_state *const s, unsigned char *dst, con if (len < 16) { if (len == 0) return; - xmm_crc_part = _mm_loadu_si128((__m128i *)src); + + memcpy(partial_buf, src, len); + xmm_crc_part = _mm_loadu_si128((const __m128i *)partial_buf); + memcpy(dst, partial_buf, len); goto partial; } - algn_diff = (0 - (uintptr_t)src) & 0xF; + algn_diff = ((uintptr_t)16 - ((uintptr_t)src & 0xF)) & 0xF; if (algn_diff) { xmm_crc_part = _mm_loadu_si128((__m128i *)src); _mm_storeu_si128((__m128i *)dst, xmm_crc_part); @@ -255,6 +259,8 @@ ZLIB_INTERNAL void crc_fold_copy(deflate_state *const s, unsigned char *dst, con len -= algn_diff; partial_fold(algn_diff, &xmm_crc0, &xmm_crc1, &xmm_crc2, &xmm_crc3, &xmm_crc_part); + } else { + xmm_crc_part = _mm_setzero_si128(); } while ((len -= 64) >= 0) { @@ -305,7 +311,7 @@ ZLIB_INTERNAL void crc_fold_copy(deflate_state *const s, unsigned char *dst, con goto done; dst += 48; - xmm_crc_part = _mm_load_si128((__m128i *)src + 3); + memcpy(&xmm_crc_part, (__m128i *)src + 3, len); } else if (len + 32 >= 0) { len += 32; @@ -324,7 +330,7 @@ ZLIB_INTERNAL void crc_fold_copy(deflate_state *const s, unsigned char *dst, con goto done; dst += 32; - xmm_crc_part = _mm_load_si128((__m128i *)src + 2); + memcpy(&xmm_crc_part, (__m128i *)src + 2, len); } else if (len + 48 >= 0) { len += 48; @@ -340,16 +346,18 @@ ZLIB_INTERNAL void crc_fold_copy(deflate_state *const s, unsigned char *dst, con goto done; dst += 16; - xmm_crc_part = _mm_load_si128((__m128i *)src + 1); + memcpy(&xmm_crc_part, (__m128i *)src + 1, len); } else { len += 64; if (len == 0) goto done; - xmm_crc_part = _mm_load_si128((__m128i *)src); + memcpy(&xmm_crc_part, src, len); } + _mm_storeu_si128((__m128i *)partial_buf, xmm_crc_part); + memcpy(dst, partial_buf, len); + partial: - _mm_storeu_si128((__m128i *)dst, xmm_crc_part); partial_fold(len, &xmm_crc0, &xmm_crc1, &xmm_crc2, &xmm_crc3, &xmm_crc_part); done: /* CRC_SAVE */ @@ -377,7 +385,7 @@ static const unsigned ALIGNED_(16) crc_mask2[4] = { 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF }; -uint32_t ZLIB_INTERNAL crc_fold_512to32(deflate_state *const s) { +uint32_t Z_INTERNAL crc_fold_512to32(deflate_state *const s) { const __m128i xmm_mask = _mm_load_si128((__m128i *)crc_mask); const __m128i xmm_mask2 = _mm_load_si128((__m128i *)crc_mask2); @@ -447,4 +455,3 @@ uint32_t ZLIB_INTERNAL crc_fold_512to32(deflate_state *const s) { } #endif - diff --git a/libs/zlibng/arch/x86/crc_folding.h b/libs/zlibng/arch/x86/crc_folding.h index 22bfa9864..0d3c24b29 100644 --- a/libs/zlibng/arch/x86/crc_folding.h +++ b/libs/zlibng/arch/x86/crc_folding.h @@ -10,10 +10,10 @@ #ifndef CRC_FOLDING_H_ #define CRC_FOLDING_H_ -#include "deflate.h" +#include "../../deflate.h" -ZLIB_INTERNAL void crc_fold_init(deflate_state *const); -ZLIB_INTERNAL uint32_t crc_fold_512to32(deflate_state *const); -ZLIB_INTERNAL void crc_fold_copy(deflate_state *const, unsigned char *, const unsigned char *, long); +Z_INTERNAL void crc_fold_init(deflate_state *const); +Z_INTERNAL uint32_t crc_fold_512to32(deflate_state *const); +Z_INTERNAL void crc_fold_copy(deflate_state *const, unsigned char *, const unsigned char *, long); #endif diff --git a/libs/zlibng/arch/x86/ctzl.h b/libs/zlibng/arch/x86/ctzl.h deleted file mode 100644 index bc9e9bd5b..000000000 --- a/libs/zlibng/arch/x86/ctzl.h +++ /dev/null @@ -1,25 +0,0 @@ -#ifndef X86_CTZL_H -#define X86_CTZL_H - -#include -#ifdef X86_CPUID -# include "x86.h" -#endif - -#if defined(_MSC_VER) && !defined(__clang__) -/* This is not a general purpose replacement for __builtin_ctzl. The function expects that value is != 0 - * Because of that assumption trailing_zero is not initialized and the return value of _BitScanForward is not checked - */ -static __forceinline unsigned long __builtin_ctzl(unsigned long value) -{ -#ifdef X86_CPUID - if (x86_cpu_has_tzcnt) - return _tzcnt_u32(value); -#endif - unsigned long trailing_zero; - _BitScanForward(&trailing_zero, value); - return trailing_zero; -} -#endif - -#endif diff --git a/libs/zlibng/arch/x86/deflate_quick.c b/libs/zlibng/arch/x86/deflate_quick.c deleted file mode 100644 index 0c5196926..000000000 --- a/libs/zlibng/arch/x86/deflate_quick.c +++ /dev/null @@ -1,2405 +0,0 @@ -/* - * The deflate_quick deflate strategy, designed to be used when cycles are - * at a premium. - * - * Copyright (C) 2013 Intel Corporation. All rights reserved. - * Authors: - * Wajdi Feghali - * Jim Guilford - * Vinodh Gopal - * Erdinc Ozturk - * Jim Kukunas - * - * Portions are Copyright (C) 2016 12Sided Technology, LLC. - * Author: - * Phil Vachon - * - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -#include "zbuild.h" -#include -#ifdef _MSC_VER -# include -#endif -#include "deflate.h" -#include "memcopy.h" - -#ifdef ZLIB_DEBUG -#include -#endif - -extern void fill_window_sse(deflate_state *s); -extern void flush_pending(PREFIX3(stream) *strm); - -static inline long compare258(const unsigned char *const src0, const unsigned char *const src1) { -#ifdef _MSC_VER - long cnt; - - cnt = 0; - do { -#define mode _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_NEGATIVE_POLARITY - - int ret; - __m128i xmm_src0, xmm_src1; - - xmm_src0 = _mm_loadu_si128((__m128i *)(src0 + cnt)); - xmm_src1 = _mm_loadu_si128((__m128i *)(src1 + cnt)); - ret = _mm_cmpestri(xmm_src0, 16, xmm_src1, 16, mode); - if (_mm_cmpestrc(xmm_src0, 16, xmm_src1, 16, mode)) { - cnt += ret; - break; - } - cnt += 16; - - xmm_src0 = _mm_loadu_si128((__m128i *)(src0 + cnt)); - xmm_src1 = _mm_loadu_si128((__m128i *)(src1 + cnt)); - ret = _mm_cmpestri(xmm_src0, 16, xmm_src1, 16, mode); - if (_mm_cmpestrc(xmm_src0, 16, xmm_src1, 16, mode)) { - cnt += ret; - break; - } - cnt += 16; - } while (cnt < 256); - - if (*(unsigned short *)(src0 + cnt) == *(unsigned short *)(src1 + cnt)) { - cnt += 2; - } else if (*(src0 + cnt) == *(src1 + cnt)) { - cnt++; - } - return cnt; -#else - uintptr_t ax, dx, cx; - __m128i xmm_src0; - - ax = 16; - dx = 16; - /* set cx to something, otherwise gcc thinks it's used - uninitalised */ - cx = 0; - - __asm__ __volatile__ ( - "1:" - "movdqu -16(%[src0], %[ax]), %[xmm_src0]\n\t" - "pcmpestri $0x18, -16(%[src1], %[ax]), %[xmm_src0]\n\t" - "jc 2f\n\t" - "add $16, %[ax]\n\t" - - "movdqu -16(%[src0], %[ax]), %[xmm_src0]\n\t" - "pcmpestri $0x18, -16(%[src1], %[ax]), %[xmm_src0]\n\t" - "jc 2f\n\t" - "add $16, %[ax]\n\t" - - "cmp $256 + 16, %[ax]\n\t" - "jb 1b\n\t" - -# if !defined(__x86_64__) - "movzwl -16(%[src0], %[ax]), %[dx]\n\t" -# else - "movzwq -16(%[src0], %[ax]), %[dx]\n\t" -# endif - "xorw -16(%[src1], %[ax]), %%dx\n\t" - "jnz 3f\n\t" - - "add $2, %[ax]\n\t" - "jmp 4f\n\t" - "3:\n\t" - "rep; bsf %[dx], %[cx]\n\t" - "shr $3, %[cx]\n\t" - "2:" - "add %[cx], %[ax]\n\t" - "4:" - : [ax] "+a" (ax), - [cx] "+c" (cx), - [dx] "+d" (dx), - [xmm_src0] "=x" (xmm_src0) - : [src0] "r" (src0), - [src1] "r" (src1) - : "cc" - ); - return ax - 16; -#endif -} - -static const unsigned quick_len_codes[MAX_MATCH-MIN_MATCH+1]; -static const unsigned quick_dist_codes[8192]; - -static inline void quick_send_bits(deflate_state *const s, - const int value1, const int length1, - const int value2, const int length2) { - unsigned offset2 = s->bi_valid + length1; - unsigned width = s->bi_valid + length1 + length2; - unsigned bytes_out = width / 8; - - /* Concatenate the new bits with the bits currently in the buffer */ - unsigned out = s->bi_buf | (value1 << s->bi_valid); - if (width < 32) { - out |= (value2 << offset2); - /* Shift out the valid LSBs written out. */ - s->bi_buf = out >> (bytes_out * 8); - } else /* width => 32 */ { - unsigned bits_that_fit = 32 - offset2; - unsigned mask = (1 << bits_that_fit) - 1; - /* Zero out the high bits of value2 such that the shift by offset2 will - not cause undefined behavior. */ - out |= ((value2 & mask) << offset2); - - /* Save in s->bi_buf the bits of value2 that do not fit: they will be - written in a next full byte. */ - s->bi_buf = (width == 32) ? 0 : value2 >> bits_that_fit; - } - - s->bi_valid = width - (bytes_out * 8); - - /* Taking advantage of the fact that LSB comes first, write to output buffer */ - memcpy(s->pending_buf + s->pending, &out, sizeof(out)); - - s->pending += bytes_out; -} - -static inline void static_emit_ptr(deflate_state *const s, const int lc, const unsigned dist) { - unsigned code1 = quick_len_codes[lc] >> 8; - unsigned len1 = quick_len_codes[lc] & 0xFF; - unsigned code2 = quick_dist_codes[dist-1] >> 8; - unsigned len2 = quick_dist_codes[dist-1] & 0xFF; - quick_send_bits(s, code1, len1, code2, len2); -} - -const ct_data static_ltree[L_CODES+2]; - -static inline void static_emit_lit(deflate_state *const s, const int lit) { - quick_send_bits(s, static_ltree[lit].Code, static_ltree[lit].Len, 0, 0); - Tracecv(isgraph(lit), (stderr, " '%c' ", lit)); -} - -static void static_emit_tree(deflate_state *const s, const int flush) { - unsigned last; - - last = flush == Z_FINISH ? 1 : 0; - Tracev((stderr, "\n--- Emit Tree: Last: %u\n", last)); - send_bits(s, (STATIC_TREES << 1)+ last, 3); -#ifdef ZLIB_DEBUG - s->compressed_len += 3; -#endif -} - -static void static_emit_end_block(deflate_state *const s, int last) { - send_code(s, END_BLOCK, static_ltree); -#ifdef ZLIB_DEBUG - s->compressed_len += 7; /* 7 bits for EOB */ -#endif - Tracev((stderr, "\n+++ Emit End Block: Last: %u Pending: %u Total Out: %zu\n", last, s->pending, s->strm->total_out)); - - if (last) - bi_windup(s); - - s->block_start = s->strstart; - flush_pending(s->strm); - s->block_open = 0; -} - -static inline Pos quick_insert_string(deflate_state *const s, const Pos str) { - Pos ret; - unsigned h = 0; - -#ifdef _MSC_VER - h = _mm_crc32_u32(h, *(unsigned *)(s->window + str)); -#else - __asm__ __volatile__ ( - "crc32l (%[window], %[str], 1), %0\n\t" - : "+r" (h) - : [window] "r" (s->window), - [str] "r" ((uintptr_t)str) - ); -#endif - - ret = s->head[h & s->hash_mask]; - s->head[h & s->hash_mask] = str; - return ret; -} - -ZLIB_INTERNAL block_state deflate_quick(deflate_state *s, int flush) { - IPos hash_head; - unsigned dist, match_len; - - if (s->block_open == 0) { - static_emit_tree(s, flush); - s->block_open = 1; - } - - do { - if (s->pending + 4 >= s->pending_buf_size) { - flush_pending(s->strm); - return need_more; - } - - if (s->lookahead < MIN_LOOKAHEAD) { - fill_window_sse(s); - if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { - static_emit_end_block(s, 0); - return need_more; - } - if (s->lookahead == 0) - break; - } - - if (s->lookahead >= MIN_MATCH) { - hash_head = quick_insert_string(s, s->strstart); - dist = s->strstart - hash_head; - - if (dist > 0 && (dist-1) < (s->w_size - 1)) { - match_len = compare258(s->window + s->strstart, s->window + s->strstart - dist); - - if (match_len >= MIN_MATCH) { - if (match_len > s->lookahead) - match_len = s->lookahead; - - if (match_len > MAX_MATCH) - match_len = MAX_MATCH; - - static_emit_ptr(s, match_len - MIN_MATCH, s->strstart - hash_head); - s->lookahead -= match_len; - s->strstart += match_len; - continue; - } - } - } - - static_emit_lit(s, s->window[s->strstart]); - s->strstart++; - s->lookahead--; - } while (s->strm->avail_out != 0); - - if (s->strm->avail_out == 0 && flush != Z_FINISH) - return need_more; - - s->insert = s->strstart < MIN_MATCH - 1 ? s->strstart : MIN_MATCH-1; - if (flush == Z_FINISH) { - static_emit_end_block(s, 1); - if (s->strm->avail_out == 0) - return s->strm->avail_in == 0 ? finish_started : need_more; - else - return finish_done; - } - - static_emit_end_block(s, 0); - return block_done; -} - -static const unsigned quick_len_codes[MAX_MATCH-MIN_MATCH+1] = { - 0x00004007, 0x00002007, 0x00006007, 0x00001007, - 0x00005007, 0x00003007, 0x00007007, 0x00000807, - 0x00004808, 0x0000c808, 0x00002808, 0x0000a808, - 0x00006808, 0x0000e808, 0x00001808, 0x00009808, - 0x00005809, 0x0000d809, 0x00015809, 0x0001d809, - 0x00003809, 0x0000b809, 0x00013809, 0x0001b809, - 0x00007809, 0x0000f809, 0x00017809, 0x0001f809, - 0x00000409, 0x00008409, 0x00010409, 0x00018409, - 0x0000440a, 0x0000c40a, 0x0001440a, 0x0001c40a, - 0x0002440a, 0x0002c40a, 0x0003440a, 0x0003c40a, - 0x0000240a, 0x0000a40a, 0x0001240a, 0x0001a40a, - 0x0002240a, 0x0002a40a, 0x0003240a, 0x0003a40a, - 0x0000640a, 0x0000e40a, 0x0001640a, 0x0001e40a, - 0x0002640a, 0x0002e40a, 0x0003640a, 0x0003e40a, - 0x0000140a, 0x0000940a, 0x0001140a, 0x0001940a, - 0x0002140a, 0x0002940a, 0x0003140a, 0x0003940a, - 0x0000540b, 0x0000d40b, 0x0001540b, 0x0001d40b, - 0x0002540b, 0x0002d40b, 0x0003540b, 0x0003d40b, - 0x0004540b, 0x0004d40b, 0x0005540b, 0x0005d40b, - 0x0006540b, 0x0006d40b, 0x0007540b, 0x0007d40b, - 0x0000340b, 0x0000b40b, 0x0001340b, 0x0001b40b, - 0x0002340b, 0x0002b40b, 0x0003340b, 0x0003b40b, - 0x0004340b, 0x0004b40b, 0x0005340b, 0x0005b40b, - 0x0006340b, 0x0006b40b, 0x0007340b, 0x0007b40b, - 0x0000740b, 0x0000f40b, 0x0001740b, 0x0001f40b, - 0x0002740b, 0x0002f40b, 0x0003740b, 0x0003f40b, - 0x0004740b, 0x0004f40b, 0x0005740b, 0x0005f40b, - 0x0006740b, 0x0006f40b, 0x0007740b, 0x0007f40b, - 0x0000030c, 0x0001030c, 0x0002030c, 0x0003030c, - 0x0004030c, 0x0005030c, 0x0006030c, 0x0007030c, - 0x0008030c, 0x0009030c, 0x000a030c, 0x000b030c, - 0x000c030c, 0x000d030c, 0x000e030c, 0x000f030c, - 0x0000830d, 0x0001830d, 0x0002830d, 0x0003830d, - 0x0004830d, 0x0005830d, 0x0006830d, 0x0007830d, - 0x0008830d, 0x0009830d, 0x000a830d, 0x000b830d, - 0x000c830d, 0x000d830d, 0x000e830d, 0x000f830d, - 0x0010830d, 0x0011830d, 0x0012830d, 0x0013830d, - 0x0014830d, 0x0015830d, 0x0016830d, 0x0017830d, - 0x0018830d, 0x0019830d, 0x001a830d, 0x001b830d, - 0x001c830d, 0x001d830d, 0x001e830d, 0x001f830d, - 0x0000430d, 0x0001430d, 0x0002430d, 0x0003430d, - 0x0004430d, 0x0005430d, 0x0006430d, 0x0007430d, - 0x0008430d, 0x0009430d, 0x000a430d, 0x000b430d, - 0x000c430d, 0x000d430d, 0x000e430d, 0x000f430d, - 0x0010430d, 0x0011430d, 0x0012430d, 0x0013430d, - 0x0014430d, 0x0015430d, 0x0016430d, 0x0017430d, - 0x0018430d, 0x0019430d, 0x001a430d, 0x001b430d, - 0x001c430d, 0x001d430d, 0x001e430d, 0x001f430d, - 0x0000c30d, 0x0001c30d, 0x0002c30d, 0x0003c30d, - 0x0004c30d, 0x0005c30d, 0x0006c30d, 0x0007c30d, - 0x0008c30d, 0x0009c30d, 0x000ac30d, 0x000bc30d, - 0x000cc30d, 0x000dc30d, 0x000ec30d, 0x000fc30d, - 0x0010c30d, 0x0011c30d, 0x0012c30d, 0x0013c30d, - 0x0014c30d, 0x0015c30d, 0x0016c30d, 0x0017c30d, - 0x0018c30d, 0x0019c30d, 0x001ac30d, 0x001bc30d, - 0x001cc30d, 0x001dc30d, 0x001ec30d, 0x001fc30d, - 0x0000230d, 0x0001230d, 0x0002230d, 0x0003230d, - 0x0004230d, 0x0005230d, 0x0006230d, 0x0007230d, - 0x0008230d, 0x0009230d, 0x000a230d, 0x000b230d, - 0x000c230d, 0x000d230d, 0x000e230d, 0x000f230d, - 0x0010230d, 0x0011230d, 0x0012230d, 0x0013230d, - 0x0014230d, 0x0015230d, 0x0016230d, 0x0017230d, - 0x0018230d, 0x0019230d, 0x001a230d, 0x001b230d, - 0x001c230d, 0x001d230d, 0x001e230d, 0x0000a308, -}; - -static const unsigned quick_dist_codes[8192] = { - 0x00000005, 0x00001005, 0x00000805, 0x00001805, - 0x00000406, 0x00002406, 0x00001406, 0x00003406, - 0x00000c07, 0x00002c07, 0x00004c07, 0x00006c07, - 0x00001c07, 0x00003c07, 0x00005c07, 0x00007c07, - 0x00000208, 0x00002208, 0x00004208, 0x00006208, - 0x00008208, 0x0000a208, 0x0000c208, 0x0000e208, - 0x00001208, 0x00003208, 0x00005208, 0x00007208, - 0x00009208, 0x0000b208, 0x0000d208, 0x0000f208, - 0x00000a09, 0x00002a09, 0x00004a09, 0x00006a09, - 0x00008a09, 0x0000aa09, 0x0000ca09, 0x0000ea09, - 0x00010a09, 0x00012a09, 0x00014a09, 0x00016a09, - 0x00018a09, 0x0001aa09, 0x0001ca09, 0x0001ea09, - 0x00001a09, 0x00003a09, 0x00005a09, 0x00007a09, - 0x00009a09, 0x0000ba09, 0x0000da09, 0x0000fa09, - 0x00011a09, 0x00013a09, 0x00015a09, 0x00017a09, - 0x00019a09, 0x0001ba09, 0x0001da09, 0x0001fa09, - 0x0000060a, 0x0000260a, 0x0000460a, 0x0000660a, - 0x0000860a, 0x0000a60a, 0x0000c60a, 0x0000e60a, - 0x0001060a, 0x0001260a, 0x0001460a, 0x0001660a, - 0x0001860a, 0x0001a60a, 0x0001c60a, 0x0001e60a, - 0x0002060a, 0x0002260a, 0x0002460a, 0x0002660a, - 0x0002860a, 0x0002a60a, 0x0002c60a, 0x0002e60a, - 0x0003060a, 0x0003260a, 0x0003460a, 0x0003660a, - 0x0003860a, 0x0003a60a, 0x0003c60a, 0x0003e60a, - 0x0000160a, 0x0000360a, 0x0000560a, 0x0000760a, - 0x0000960a, 0x0000b60a, 0x0000d60a, 0x0000f60a, - 0x0001160a, 0x0001360a, 0x0001560a, 0x0001760a, - 0x0001960a, 0x0001b60a, 0x0001d60a, 0x0001f60a, - 0x0002160a, 0x0002360a, 0x0002560a, 0x0002760a, - 0x0002960a, 0x0002b60a, 0x0002d60a, 0x0002f60a, - 0x0003160a, 0x0003360a, 0x0003560a, 0x0003760a, - 0x0003960a, 0x0003b60a, 0x0003d60a, 0x0003f60a, - 0x00000e0b, 0x00002e0b, 0x00004e0b, 0x00006e0b, - 0x00008e0b, 0x0000ae0b, 0x0000ce0b, 0x0000ee0b, - 0x00010e0b, 0x00012e0b, 0x00014e0b, 0x00016e0b, - 0x00018e0b, 0x0001ae0b, 0x0001ce0b, 0x0001ee0b, - 0x00020e0b, 0x00022e0b, 0x00024e0b, 0x00026e0b, - 0x00028e0b, 0x0002ae0b, 0x0002ce0b, 0x0002ee0b, - 0x00030e0b, 0x00032e0b, 0x00034e0b, 0x00036e0b, - 0x00038e0b, 0x0003ae0b, 0x0003ce0b, 0x0003ee0b, - 0x00040e0b, 0x00042e0b, 0x00044e0b, 0x00046e0b, - 0x00048e0b, 0x0004ae0b, 0x0004ce0b, 0x0004ee0b, - 0x00050e0b, 0x00052e0b, 0x00054e0b, 0x00056e0b, - 0x00058e0b, 0x0005ae0b, 0x0005ce0b, 0x0005ee0b, - 0x00060e0b, 0x00062e0b, 0x00064e0b, 0x00066e0b, - 0x00068e0b, 0x0006ae0b, 0x0006ce0b, 0x0006ee0b, - 0x00070e0b, 0x00072e0b, 0x00074e0b, 0x00076e0b, - 0x00078e0b, 0x0007ae0b, 0x0007ce0b, 0x0007ee0b, - 0x00001e0b, 0x00003e0b, 0x00005e0b, 0x00007e0b, - 0x00009e0b, 0x0000be0b, 0x0000de0b, 0x0000fe0b, - 0x00011e0b, 0x00013e0b, 0x00015e0b, 0x00017e0b, - 0x00019e0b, 0x0001be0b, 0x0001de0b, 0x0001fe0b, - 0x00021e0b, 0x00023e0b, 0x00025e0b, 0x00027e0b, - 0x00029e0b, 0x0002be0b, 0x0002de0b, 0x0002fe0b, - 0x00031e0b, 0x00033e0b, 0x00035e0b, 0x00037e0b, - 0x00039e0b, 0x0003be0b, 0x0003de0b, 0x0003fe0b, - 0x00041e0b, 0x00043e0b, 0x00045e0b, 0x00047e0b, - 0x00049e0b, 0x0004be0b, 0x0004de0b, 0x0004fe0b, - 0x00051e0b, 0x00053e0b, 0x00055e0b, 0x00057e0b, - 0x00059e0b, 0x0005be0b, 0x0005de0b, 0x0005fe0b, - 0x00061e0b, 0x00063e0b, 0x00065e0b, 0x00067e0b, - 0x00069e0b, 0x0006be0b, 0x0006de0b, 0x0006fe0b, - 0x00071e0b, 0x00073e0b, 0x00075e0b, 0x00077e0b, - 0x00079e0b, 0x0007be0b, 0x0007de0b, 0x0007fe0b, - 0x0000010c, 0x0000210c, 0x0000410c, 0x0000610c, - 0x0000810c, 0x0000a10c, 0x0000c10c, 0x0000e10c, - 0x0001010c, 0x0001210c, 0x0001410c, 0x0001610c, - 0x0001810c, 0x0001a10c, 0x0001c10c, 0x0001e10c, - 0x0002010c, 0x0002210c, 0x0002410c, 0x0002610c, - 0x0002810c, 0x0002a10c, 0x0002c10c, 0x0002e10c, - 0x0003010c, 0x0003210c, 0x0003410c, 0x0003610c, - 0x0003810c, 0x0003a10c, 0x0003c10c, 0x0003e10c, - 0x0004010c, 0x0004210c, 0x0004410c, 0x0004610c, - 0x0004810c, 0x0004a10c, 0x0004c10c, 0x0004e10c, - 0x0005010c, 0x0005210c, 0x0005410c, 0x0005610c, - 0x0005810c, 0x0005a10c, 0x0005c10c, 0x0005e10c, - 0x0006010c, 0x0006210c, 0x0006410c, 0x0006610c, - 0x0006810c, 0x0006a10c, 0x0006c10c, 0x0006e10c, - 0x0007010c, 0x0007210c, 0x0007410c, 0x0007610c, - 0x0007810c, 0x0007a10c, 0x0007c10c, 0x0007e10c, - 0x0008010c, 0x0008210c, 0x0008410c, 0x0008610c, - 0x0008810c, 0x0008a10c, 0x0008c10c, 0x0008e10c, - 0x0009010c, 0x0009210c, 0x0009410c, 0x0009610c, - 0x0009810c, 0x0009a10c, 0x0009c10c, 0x0009e10c, - 0x000a010c, 0x000a210c, 0x000a410c, 0x000a610c, - 0x000a810c, 0x000aa10c, 0x000ac10c, 0x000ae10c, - 0x000b010c, 0x000b210c, 0x000b410c, 0x000b610c, - 0x000b810c, 0x000ba10c, 0x000bc10c, 0x000be10c, - 0x000c010c, 0x000c210c, 0x000c410c, 0x000c610c, - 0x000c810c, 0x000ca10c, 0x000cc10c, 0x000ce10c, - 0x000d010c, 0x000d210c, 0x000d410c, 0x000d610c, - 0x000d810c, 0x000da10c, 0x000dc10c, 0x000de10c, - 0x000e010c, 0x000e210c, 0x000e410c, 0x000e610c, - 0x000e810c, 0x000ea10c, 0x000ec10c, 0x000ee10c, - 0x000f010c, 0x000f210c, 0x000f410c, 0x000f610c, - 0x000f810c, 0x000fa10c, 0x000fc10c, 0x000fe10c, - 0x0000110c, 0x0000310c, 0x0000510c, 0x0000710c, - 0x0000910c, 0x0000b10c, 0x0000d10c, 0x0000f10c, - 0x0001110c, 0x0001310c, 0x0001510c, 0x0001710c, - 0x0001910c, 0x0001b10c, 0x0001d10c, 0x0001f10c, - 0x0002110c, 0x0002310c, 0x0002510c, 0x0002710c, - 0x0002910c, 0x0002b10c, 0x0002d10c, 0x0002f10c, - 0x0003110c, 0x0003310c, 0x0003510c, 0x0003710c, - 0x0003910c, 0x0003b10c, 0x0003d10c, 0x0003f10c, - 0x0004110c, 0x0004310c, 0x0004510c, 0x0004710c, - 0x0004910c, 0x0004b10c, 0x0004d10c, 0x0004f10c, - 0x0005110c, 0x0005310c, 0x0005510c, 0x0005710c, - 0x0005910c, 0x0005b10c, 0x0005d10c, 0x0005f10c, - 0x0006110c, 0x0006310c, 0x0006510c, 0x0006710c, - 0x0006910c, 0x0006b10c, 0x0006d10c, 0x0006f10c, - 0x0007110c, 0x0007310c, 0x0007510c, 0x0007710c, - 0x0007910c, 0x0007b10c, 0x0007d10c, 0x0007f10c, - 0x0008110c, 0x0008310c, 0x0008510c, 0x0008710c, - 0x0008910c, 0x0008b10c, 0x0008d10c, 0x0008f10c, - 0x0009110c, 0x0009310c, 0x0009510c, 0x0009710c, - 0x0009910c, 0x0009b10c, 0x0009d10c, 0x0009f10c, - 0x000a110c, 0x000a310c, 0x000a510c, 0x000a710c, - 0x000a910c, 0x000ab10c, 0x000ad10c, 0x000af10c, - 0x000b110c, 0x000b310c, 0x000b510c, 0x000b710c, - 0x000b910c, 0x000bb10c, 0x000bd10c, 0x000bf10c, - 0x000c110c, 0x000c310c, 0x000c510c, 0x000c710c, - 0x000c910c, 0x000cb10c, 0x000cd10c, 0x000cf10c, - 0x000d110c, 0x000d310c, 0x000d510c, 0x000d710c, - 0x000d910c, 0x000db10c, 0x000dd10c, 0x000df10c, - 0x000e110c, 0x000e310c, 0x000e510c, 0x000e710c, - 0x000e910c, 0x000eb10c, 0x000ed10c, 0x000ef10c, - 0x000f110c, 0x000f310c, 0x000f510c, 0x000f710c, - 0x000f910c, 0x000fb10c, 0x000fd10c, 0x000ff10c, - 0x0000090d, 0x0000290d, 0x0000490d, 0x0000690d, - 0x0000890d, 0x0000a90d, 0x0000c90d, 0x0000e90d, - 0x0001090d, 0x0001290d, 0x0001490d, 0x0001690d, - 0x0001890d, 0x0001a90d, 0x0001c90d, 0x0001e90d, - 0x0002090d, 0x0002290d, 0x0002490d, 0x0002690d, - 0x0002890d, 0x0002a90d, 0x0002c90d, 0x0002e90d, - 0x0003090d, 0x0003290d, 0x0003490d, 0x0003690d, - 0x0003890d, 0x0003a90d, 0x0003c90d, 0x0003e90d, - 0x0004090d, 0x0004290d, 0x0004490d, 0x0004690d, - 0x0004890d, 0x0004a90d, 0x0004c90d, 0x0004e90d, - 0x0005090d, 0x0005290d, 0x0005490d, 0x0005690d, - 0x0005890d, 0x0005a90d, 0x0005c90d, 0x0005e90d, - 0x0006090d, 0x0006290d, 0x0006490d, 0x0006690d, - 0x0006890d, 0x0006a90d, 0x0006c90d, 0x0006e90d, - 0x0007090d, 0x0007290d, 0x0007490d, 0x0007690d, - 0x0007890d, 0x0007a90d, 0x0007c90d, 0x0007e90d, - 0x0008090d, 0x0008290d, 0x0008490d, 0x0008690d, - 0x0008890d, 0x0008a90d, 0x0008c90d, 0x0008e90d, - 0x0009090d, 0x0009290d, 0x0009490d, 0x0009690d, - 0x0009890d, 0x0009a90d, 0x0009c90d, 0x0009e90d, - 0x000a090d, 0x000a290d, 0x000a490d, 0x000a690d, - 0x000a890d, 0x000aa90d, 0x000ac90d, 0x000ae90d, - 0x000b090d, 0x000b290d, 0x000b490d, 0x000b690d, - 0x000b890d, 0x000ba90d, 0x000bc90d, 0x000be90d, - 0x000c090d, 0x000c290d, 0x000c490d, 0x000c690d, - 0x000c890d, 0x000ca90d, 0x000cc90d, 0x000ce90d, - 0x000d090d, 0x000d290d, 0x000d490d, 0x000d690d, - 0x000d890d, 0x000da90d, 0x000dc90d, 0x000de90d, - 0x000e090d, 0x000e290d, 0x000e490d, 0x000e690d, - 0x000e890d, 0x000ea90d, 0x000ec90d, 0x000ee90d, - 0x000f090d, 0x000f290d, 0x000f490d, 0x000f690d, - 0x000f890d, 0x000fa90d, 0x000fc90d, 0x000fe90d, - 0x0010090d, 0x0010290d, 0x0010490d, 0x0010690d, - 0x0010890d, 0x0010a90d, 0x0010c90d, 0x0010e90d, - 0x0011090d, 0x0011290d, 0x0011490d, 0x0011690d, - 0x0011890d, 0x0011a90d, 0x0011c90d, 0x0011e90d, - 0x0012090d, 0x0012290d, 0x0012490d, 0x0012690d, - 0x0012890d, 0x0012a90d, 0x0012c90d, 0x0012e90d, - 0x0013090d, 0x0013290d, 0x0013490d, 0x0013690d, - 0x0013890d, 0x0013a90d, 0x0013c90d, 0x0013e90d, - 0x0014090d, 0x0014290d, 0x0014490d, 0x0014690d, - 0x0014890d, 0x0014a90d, 0x0014c90d, 0x0014e90d, - 0x0015090d, 0x0015290d, 0x0015490d, 0x0015690d, - 0x0015890d, 0x0015a90d, 0x0015c90d, 0x0015e90d, - 0x0016090d, 0x0016290d, 0x0016490d, 0x0016690d, - 0x0016890d, 0x0016a90d, 0x0016c90d, 0x0016e90d, - 0x0017090d, 0x0017290d, 0x0017490d, 0x0017690d, - 0x0017890d, 0x0017a90d, 0x0017c90d, 0x0017e90d, - 0x0018090d, 0x0018290d, 0x0018490d, 0x0018690d, - 0x0018890d, 0x0018a90d, 0x0018c90d, 0x0018e90d, - 0x0019090d, 0x0019290d, 0x0019490d, 0x0019690d, - 0x0019890d, 0x0019a90d, 0x0019c90d, 0x0019e90d, - 0x001a090d, 0x001a290d, 0x001a490d, 0x001a690d, - 0x001a890d, 0x001aa90d, 0x001ac90d, 0x001ae90d, - 0x001b090d, 0x001b290d, 0x001b490d, 0x001b690d, - 0x001b890d, 0x001ba90d, 0x001bc90d, 0x001be90d, - 0x001c090d, 0x001c290d, 0x001c490d, 0x001c690d, - 0x001c890d, 0x001ca90d, 0x001cc90d, 0x001ce90d, - 0x001d090d, 0x001d290d, 0x001d490d, 0x001d690d, - 0x001d890d, 0x001da90d, 0x001dc90d, 0x001de90d, - 0x001e090d, 0x001e290d, 0x001e490d, 0x001e690d, - 0x001e890d, 0x001ea90d, 0x001ec90d, 0x001ee90d, - 0x001f090d, 0x001f290d, 0x001f490d, 0x001f690d, - 0x001f890d, 0x001fa90d, 0x001fc90d, 0x001fe90d, - 0x0000190d, 0x0000390d, 0x0000590d, 0x0000790d, - 0x0000990d, 0x0000b90d, 0x0000d90d, 0x0000f90d, - 0x0001190d, 0x0001390d, 0x0001590d, 0x0001790d, - 0x0001990d, 0x0001b90d, 0x0001d90d, 0x0001f90d, - 0x0002190d, 0x0002390d, 0x0002590d, 0x0002790d, - 0x0002990d, 0x0002b90d, 0x0002d90d, 0x0002f90d, - 0x0003190d, 0x0003390d, 0x0003590d, 0x0003790d, - 0x0003990d, 0x0003b90d, 0x0003d90d, 0x0003f90d, - 0x0004190d, 0x0004390d, 0x0004590d, 0x0004790d, - 0x0004990d, 0x0004b90d, 0x0004d90d, 0x0004f90d, - 0x0005190d, 0x0005390d, 0x0005590d, 0x0005790d, - 0x0005990d, 0x0005b90d, 0x0005d90d, 0x0005f90d, - 0x0006190d, 0x0006390d, 0x0006590d, 0x0006790d, - 0x0006990d, 0x0006b90d, 0x0006d90d, 0x0006f90d, - 0x0007190d, 0x0007390d, 0x0007590d, 0x0007790d, - 0x0007990d, 0x0007b90d, 0x0007d90d, 0x0007f90d, - 0x0008190d, 0x0008390d, 0x0008590d, 0x0008790d, - 0x0008990d, 0x0008b90d, 0x0008d90d, 0x0008f90d, - 0x0009190d, 0x0009390d, 0x0009590d, 0x0009790d, - 0x0009990d, 0x0009b90d, 0x0009d90d, 0x0009f90d, - 0x000a190d, 0x000a390d, 0x000a590d, 0x000a790d, - 0x000a990d, 0x000ab90d, 0x000ad90d, 0x000af90d, - 0x000b190d, 0x000b390d, 0x000b590d, 0x000b790d, - 0x000b990d, 0x000bb90d, 0x000bd90d, 0x000bf90d, - 0x000c190d, 0x000c390d, 0x000c590d, 0x000c790d, - 0x000c990d, 0x000cb90d, 0x000cd90d, 0x000cf90d, - 0x000d190d, 0x000d390d, 0x000d590d, 0x000d790d, - 0x000d990d, 0x000db90d, 0x000dd90d, 0x000df90d, - 0x000e190d, 0x000e390d, 0x000e590d, 0x000e790d, - 0x000e990d, 0x000eb90d, 0x000ed90d, 0x000ef90d, - 0x000f190d, 0x000f390d, 0x000f590d, 0x000f790d, - 0x000f990d, 0x000fb90d, 0x000fd90d, 0x000ff90d, - 0x0010190d, 0x0010390d, 0x0010590d, 0x0010790d, - 0x0010990d, 0x0010b90d, 0x0010d90d, 0x0010f90d, - 0x0011190d, 0x0011390d, 0x0011590d, 0x0011790d, - 0x0011990d, 0x0011b90d, 0x0011d90d, 0x0011f90d, - 0x0012190d, 0x0012390d, 0x0012590d, 0x0012790d, - 0x0012990d, 0x0012b90d, 0x0012d90d, 0x0012f90d, - 0x0013190d, 0x0013390d, 0x0013590d, 0x0013790d, - 0x0013990d, 0x0013b90d, 0x0013d90d, 0x0013f90d, - 0x0014190d, 0x0014390d, 0x0014590d, 0x0014790d, - 0x0014990d, 0x0014b90d, 0x0014d90d, 0x0014f90d, - 0x0015190d, 0x0015390d, 0x0015590d, 0x0015790d, - 0x0015990d, 0x0015b90d, 0x0015d90d, 0x0015f90d, - 0x0016190d, 0x0016390d, 0x0016590d, 0x0016790d, - 0x0016990d, 0x0016b90d, 0x0016d90d, 0x0016f90d, - 0x0017190d, 0x0017390d, 0x0017590d, 0x0017790d, - 0x0017990d, 0x0017b90d, 0x0017d90d, 0x0017f90d, - 0x0018190d, 0x0018390d, 0x0018590d, 0x0018790d, - 0x0018990d, 0x0018b90d, 0x0018d90d, 0x0018f90d, - 0x0019190d, 0x0019390d, 0x0019590d, 0x0019790d, - 0x0019990d, 0x0019b90d, 0x0019d90d, 0x0019f90d, - 0x001a190d, 0x001a390d, 0x001a590d, 0x001a790d, - 0x001a990d, 0x001ab90d, 0x001ad90d, 0x001af90d, - 0x001b190d, 0x001b390d, 0x001b590d, 0x001b790d, - 0x001b990d, 0x001bb90d, 0x001bd90d, 0x001bf90d, - 0x001c190d, 0x001c390d, 0x001c590d, 0x001c790d, - 0x001c990d, 0x001cb90d, 0x001cd90d, 0x001cf90d, - 0x001d190d, 0x001d390d, 0x001d590d, 0x001d790d, - 0x001d990d, 0x001db90d, 0x001dd90d, 0x001df90d, - 0x001e190d, 0x001e390d, 0x001e590d, 0x001e790d, - 0x001e990d, 0x001eb90d, 0x001ed90d, 0x001ef90d, - 0x001f190d, 0x001f390d, 0x001f590d, 0x001f790d, - 0x001f990d, 0x001fb90d, 0x001fd90d, 0x001ff90d, - 0x0000050e, 0x0000250e, 0x0000450e, 0x0000650e, - 0x0000850e, 0x0000a50e, 0x0000c50e, 0x0000e50e, - 0x0001050e, 0x0001250e, 0x0001450e, 0x0001650e, - 0x0001850e, 0x0001a50e, 0x0001c50e, 0x0001e50e, - 0x0002050e, 0x0002250e, 0x0002450e, 0x0002650e, - 0x0002850e, 0x0002a50e, 0x0002c50e, 0x0002e50e, - 0x0003050e, 0x0003250e, 0x0003450e, 0x0003650e, - 0x0003850e, 0x0003a50e, 0x0003c50e, 0x0003e50e, - 0x0004050e, 0x0004250e, 0x0004450e, 0x0004650e, - 0x0004850e, 0x0004a50e, 0x0004c50e, 0x0004e50e, - 0x0005050e, 0x0005250e, 0x0005450e, 0x0005650e, - 0x0005850e, 0x0005a50e, 0x0005c50e, 0x0005e50e, - 0x0006050e, 0x0006250e, 0x0006450e, 0x0006650e, - 0x0006850e, 0x0006a50e, 0x0006c50e, 0x0006e50e, - 0x0007050e, 0x0007250e, 0x0007450e, 0x0007650e, - 0x0007850e, 0x0007a50e, 0x0007c50e, 0x0007e50e, - 0x0008050e, 0x0008250e, 0x0008450e, 0x0008650e, - 0x0008850e, 0x0008a50e, 0x0008c50e, 0x0008e50e, - 0x0009050e, 0x0009250e, 0x0009450e, 0x0009650e, - 0x0009850e, 0x0009a50e, 0x0009c50e, 0x0009e50e, - 0x000a050e, 0x000a250e, 0x000a450e, 0x000a650e, - 0x000a850e, 0x000aa50e, 0x000ac50e, 0x000ae50e, - 0x000b050e, 0x000b250e, 0x000b450e, 0x000b650e, - 0x000b850e, 0x000ba50e, 0x000bc50e, 0x000be50e, - 0x000c050e, 0x000c250e, 0x000c450e, 0x000c650e, - 0x000c850e, 0x000ca50e, 0x000cc50e, 0x000ce50e, - 0x000d050e, 0x000d250e, 0x000d450e, 0x000d650e, - 0x000d850e, 0x000da50e, 0x000dc50e, 0x000de50e, - 0x000e050e, 0x000e250e, 0x000e450e, 0x000e650e, - 0x000e850e, 0x000ea50e, 0x000ec50e, 0x000ee50e, - 0x000f050e, 0x000f250e, 0x000f450e, 0x000f650e, - 0x000f850e, 0x000fa50e, 0x000fc50e, 0x000fe50e, - 0x0010050e, 0x0010250e, 0x0010450e, 0x0010650e, - 0x0010850e, 0x0010a50e, 0x0010c50e, 0x0010e50e, - 0x0011050e, 0x0011250e, 0x0011450e, 0x0011650e, - 0x0011850e, 0x0011a50e, 0x0011c50e, 0x0011e50e, - 0x0012050e, 0x0012250e, 0x0012450e, 0x0012650e, - 0x0012850e, 0x0012a50e, 0x0012c50e, 0x0012e50e, - 0x0013050e, 0x0013250e, 0x0013450e, 0x0013650e, - 0x0013850e, 0x0013a50e, 0x0013c50e, 0x0013e50e, - 0x0014050e, 0x0014250e, 0x0014450e, 0x0014650e, - 0x0014850e, 0x0014a50e, 0x0014c50e, 0x0014e50e, - 0x0015050e, 0x0015250e, 0x0015450e, 0x0015650e, - 0x0015850e, 0x0015a50e, 0x0015c50e, 0x0015e50e, - 0x0016050e, 0x0016250e, 0x0016450e, 0x0016650e, - 0x0016850e, 0x0016a50e, 0x0016c50e, 0x0016e50e, - 0x0017050e, 0x0017250e, 0x0017450e, 0x0017650e, - 0x0017850e, 0x0017a50e, 0x0017c50e, 0x0017e50e, - 0x0018050e, 0x0018250e, 0x0018450e, 0x0018650e, - 0x0018850e, 0x0018a50e, 0x0018c50e, 0x0018e50e, - 0x0019050e, 0x0019250e, 0x0019450e, 0x0019650e, - 0x0019850e, 0x0019a50e, 0x0019c50e, 0x0019e50e, - 0x001a050e, 0x001a250e, 0x001a450e, 0x001a650e, - 0x001a850e, 0x001aa50e, 0x001ac50e, 0x001ae50e, - 0x001b050e, 0x001b250e, 0x001b450e, 0x001b650e, - 0x001b850e, 0x001ba50e, 0x001bc50e, 0x001be50e, - 0x001c050e, 0x001c250e, 0x001c450e, 0x001c650e, - 0x001c850e, 0x001ca50e, 0x001cc50e, 0x001ce50e, - 0x001d050e, 0x001d250e, 0x001d450e, 0x001d650e, - 0x001d850e, 0x001da50e, 0x001dc50e, 0x001de50e, - 0x001e050e, 0x001e250e, 0x001e450e, 0x001e650e, - 0x001e850e, 0x001ea50e, 0x001ec50e, 0x001ee50e, - 0x001f050e, 0x001f250e, 0x001f450e, 0x001f650e, - 0x001f850e, 0x001fa50e, 0x001fc50e, 0x001fe50e, - 0x0020050e, 0x0020250e, 0x0020450e, 0x0020650e, - 0x0020850e, 0x0020a50e, 0x0020c50e, 0x0020e50e, - 0x0021050e, 0x0021250e, 0x0021450e, 0x0021650e, - 0x0021850e, 0x0021a50e, 0x0021c50e, 0x0021e50e, - 0x0022050e, 0x0022250e, 0x0022450e, 0x0022650e, - 0x0022850e, 0x0022a50e, 0x0022c50e, 0x0022e50e, - 0x0023050e, 0x0023250e, 0x0023450e, 0x0023650e, - 0x0023850e, 0x0023a50e, 0x0023c50e, 0x0023e50e, - 0x0024050e, 0x0024250e, 0x0024450e, 0x0024650e, - 0x0024850e, 0x0024a50e, 0x0024c50e, 0x0024e50e, - 0x0025050e, 0x0025250e, 0x0025450e, 0x0025650e, - 0x0025850e, 0x0025a50e, 0x0025c50e, 0x0025e50e, - 0x0026050e, 0x0026250e, 0x0026450e, 0x0026650e, - 0x0026850e, 0x0026a50e, 0x0026c50e, 0x0026e50e, - 0x0027050e, 0x0027250e, 0x0027450e, 0x0027650e, - 0x0027850e, 0x0027a50e, 0x0027c50e, 0x0027e50e, - 0x0028050e, 0x0028250e, 0x0028450e, 0x0028650e, - 0x0028850e, 0x0028a50e, 0x0028c50e, 0x0028e50e, - 0x0029050e, 0x0029250e, 0x0029450e, 0x0029650e, - 0x0029850e, 0x0029a50e, 0x0029c50e, 0x0029e50e, - 0x002a050e, 0x002a250e, 0x002a450e, 0x002a650e, - 0x002a850e, 0x002aa50e, 0x002ac50e, 0x002ae50e, - 0x002b050e, 0x002b250e, 0x002b450e, 0x002b650e, - 0x002b850e, 0x002ba50e, 0x002bc50e, 0x002be50e, - 0x002c050e, 0x002c250e, 0x002c450e, 0x002c650e, - 0x002c850e, 0x002ca50e, 0x002cc50e, 0x002ce50e, - 0x002d050e, 0x002d250e, 0x002d450e, 0x002d650e, - 0x002d850e, 0x002da50e, 0x002dc50e, 0x002de50e, - 0x002e050e, 0x002e250e, 0x002e450e, 0x002e650e, - 0x002e850e, 0x002ea50e, 0x002ec50e, 0x002ee50e, - 0x002f050e, 0x002f250e, 0x002f450e, 0x002f650e, - 0x002f850e, 0x002fa50e, 0x002fc50e, 0x002fe50e, - 0x0030050e, 0x0030250e, 0x0030450e, 0x0030650e, - 0x0030850e, 0x0030a50e, 0x0030c50e, 0x0030e50e, - 0x0031050e, 0x0031250e, 0x0031450e, 0x0031650e, - 0x0031850e, 0x0031a50e, 0x0031c50e, 0x0031e50e, - 0x0032050e, 0x0032250e, 0x0032450e, 0x0032650e, - 0x0032850e, 0x0032a50e, 0x0032c50e, 0x0032e50e, - 0x0033050e, 0x0033250e, 0x0033450e, 0x0033650e, - 0x0033850e, 0x0033a50e, 0x0033c50e, 0x0033e50e, - 0x0034050e, 0x0034250e, 0x0034450e, 0x0034650e, - 0x0034850e, 0x0034a50e, 0x0034c50e, 0x0034e50e, - 0x0035050e, 0x0035250e, 0x0035450e, 0x0035650e, - 0x0035850e, 0x0035a50e, 0x0035c50e, 0x0035e50e, - 0x0036050e, 0x0036250e, 0x0036450e, 0x0036650e, - 0x0036850e, 0x0036a50e, 0x0036c50e, 0x0036e50e, - 0x0037050e, 0x0037250e, 0x0037450e, 0x0037650e, - 0x0037850e, 0x0037a50e, 0x0037c50e, 0x0037e50e, - 0x0038050e, 0x0038250e, 0x0038450e, 0x0038650e, - 0x0038850e, 0x0038a50e, 0x0038c50e, 0x0038e50e, - 0x0039050e, 0x0039250e, 0x0039450e, 0x0039650e, - 0x0039850e, 0x0039a50e, 0x0039c50e, 0x0039e50e, - 0x003a050e, 0x003a250e, 0x003a450e, 0x003a650e, - 0x003a850e, 0x003aa50e, 0x003ac50e, 0x003ae50e, - 0x003b050e, 0x003b250e, 0x003b450e, 0x003b650e, - 0x003b850e, 0x003ba50e, 0x003bc50e, 0x003be50e, - 0x003c050e, 0x003c250e, 0x003c450e, 0x003c650e, - 0x003c850e, 0x003ca50e, 0x003cc50e, 0x003ce50e, - 0x003d050e, 0x003d250e, 0x003d450e, 0x003d650e, - 0x003d850e, 0x003da50e, 0x003dc50e, 0x003de50e, - 0x003e050e, 0x003e250e, 0x003e450e, 0x003e650e, - 0x003e850e, 0x003ea50e, 0x003ec50e, 0x003ee50e, - 0x003f050e, 0x003f250e, 0x003f450e, 0x003f650e, - 0x003f850e, 0x003fa50e, 0x003fc50e, 0x003fe50e, - 0x0000150e, 0x0000350e, 0x0000550e, 0x0000750e, - 0x0000950e, 0x0000b50e, 0x0000d50e, 0x0000f50e, - 0x0001150e, 0x0001350e, 0x0001550e, 0x0001750e, - 0x0001950e, 0x0001b50e, 0x0001d50e, 0x0001f50e, - 0x0002150e, 0x0002350e, 0x0002550e, 0x0002750e, - 0x0002950e, 0x0002b50e, 0x0002d50e, 0x0002f50e, - 0x0003150e, 0x0003350e, 0x0003550e, 0x0003750e, - 0x0003950e, 0x0003b50e, 0x0003d50e, 0x0003f50e, - 0x0004150e, 0x0004350e, 0x0004550e, 0x0004750e, - 0x0004950e, 0x0004b50e, 0x0004d50e, 0x0004f50e, - 0x0005150e, 0x0005350e, 0x0005550e, 0x0005750e, - 0x0005950e, 0x0005b50e, 0x0005d50e, 0x0005f50e, - 0x0006150e, 0x0006350e, 0x0006550e, 0x0006750e, - 0x0006950e, 0x0006b50e, 0x0006d50e, 0x0006f50e, - 0x0007150e, 0x0007350e, 0x0007550e, 0x0007750e, - 0x0007950e, 0x0007b50e, 0x0007d50e, 0x0007f50e, - 0x0008150e, 0x0008350e, 0x0008550e, 0x0008750e, - 0x0008950e, 0x0008b50e, 0x0008d50e, 0x0008f50e, - 0x0009150e, 0x0009350e, 0x0009550e, 0x0009750e, - 0x0009950e, 0x0009b50e, 0x0009d50e, 0x0009f50e, - 0x000a150e, 0x000a350e, 0x000a550e, 0x000a750e, - 0x000a950e, 0x000ab50e, 0x000ad50e, 0x000af50e, - 0x000b150e, 0x000b350e, 0x000b550e, 0x000b750e, - 0x000b950e, 0x000bb50e, 0x000bd50e, 0x000bf50e, - 0x000c150e, 0x000c350e, 0x000c550e, 0x000c750e, - 0x000c950e, 0x000cb50e, 0x000cd50e, 0x000cf50e, - 0x000d150e, 0x000d350e, 0x000d550e, 0x000d750e, - 0x000d950e, 0x000db50e, 0x000dd50e, 0x000df50e, - 0x000e150e, 0x000e350e, 0x000e550e, 0x000e750e, - 0x000e950e, 0x000eb50e, 0x000ed50e, 0x000ef50e, - 0x000f150e, 0x000f350e, 0x000f550e, 0x000f750e, - 0x000f950e, 0x000fb50e, 0x000fd50e, 0x000ff50e, - 0x0010150e, 0x0010350e, 0x0010550e, 0x0010750e, - 0x0010950e, 0x0010b50e, 0x0010d50e, 0x0010f50e, - 0x0011150e, 0x0011350e, 0x0011550e, 0x0011750e, - 0x0011950e, 0x0011b50e, 0x0011d50e, 0x0011f50e, - 0x0012150e, 0x0012350e, 0x0012550e, 0x0012750e, - 0x0012950e, 0x0012b50e, 0x0012d50e, 0x0012f50e, - 0x0013150e, 0x0013350e, 0x0013550e, 0x0013750e, - 0x0013950e, 0x0013b50e, 0x0013d50e, 0x0013f50e, - 0x0014150e, 0x0014350e, 0x0014550e, 0x0014750e, - 0x0014950e, 0x0014b50e, 0x0014d50e, 0x0014f50e, - 0x0015150e, 0x0015350e, 0x0015550e, 0x0015750e, - 0x0015950e, 0x0015b50e, 0x0015d50e, 0x0015f50e, - 0x0016150e, 0x0016350e, 0x0016550e, 0x0016750e, - 0x0016950e, 0x0016b50e, 0x0016d50e, 0x0016f50e, - 0x0017150e, 0x0017350e, 0x0017550e, 0x0017750e, - 0x0017950e, 0x0017b50e, 0x0017d50e, 0x0017f50e, - 0x0018150e, 0x0018350e, 0x0018550e, 0x0018750e, - 0x0018950e, 0x0018b50e, 0x0018d50e, 0x0018f50e, - 0x0019150e, 0x0019350e, 0x0019550e, 0x0019750e, - 0x0019950e, 0x0019b50e, 0x0019d50e, 0x0019f50e, - 0x001a150e, 0x001a350e, 0x001a550e, 0x001a750e, - 0x001a950e, 0x001ab50e, 0x001ad50e, 0x001af50e, - 0x001b150e, 0x001b350e, 0x001b550e, 0x001b750e, - 0x001b950e, 0x001bb50e, 0x001bd50e, 0x001bf50e, - 0x001c150e, 0x001c350e, 0x001c550e, 0x001c750e, - 0x001c950e, 0x001cb50e, 0x001cd50e, 0x001cf50e, - 0x001d150e, 0x001d350e, 0x001d550e, 0x001d750e, - 0x001d950e, 0x001db50e, 0x001dd50e, 0x001df50e, - 0x001e150e, 0x001e350e, 0x001e550e, 0x001e750e, - 0x001e950e, 0x001eb50e, 0x001ed50e, 0x001ef50e, - 0x001f150e, 0x001f350e, 0x001f550e, 0x001f750e, - 0x001f950e, 0x001fb50e, 0x001fd50e, 0x001ff50e, - 0x0020150e, 0x0020350e, 0x0020550e, 0x0020750e, - 0x0020950e, 0x0020b50e, 0x0020d50e, 0x0020f50e, - 0x0021150e, 0x0021350e, 0x0021550e, 0x0021750e, - 0x0021950e, 0x0021b50e, 0x0021d50e, 0x0021f50e, - 0x0022150e, 0x0022350e, 0x0022550e, 0x0022750e, - 0x0022950e, 0x0022b50e, 0x0022d50e, 0x0022f50e, - 0x0023150e, 0x0023350e, 0x0023550e, 0x0023750e, - 0x0023950e, 0x0023b50e, 0x0023d50e, 0x0023f50e, - 0x0024150e, 0x0024350e, 0x0024550e, 0x0024750e, - 0x0024950e, 0x0024b50e, 0x0024d50e, 0x0024f50e, - 0x0025150e, 0x0025350e, 0x0025550e, 0x0025750e, - 0x0025950e, 0x0025b50e, 0x0025d50e, 0x0025f50e, - 0x0026150e, 0x0026350e, 0x0026550e, 0x0026750e, - 0x0026950e, 0x0026b50e, 0x0026d50e, 0x0026f50e, - 0x0027150e, 0x0027350e, 0x0027550e, 0x0027750e, - 0x0027950e, 0x0027b50e, 0x0027d50e, 0x0027f50e, - 0x0028150e, 0x0028350e, 0x0028550e, 0x0028750e, - 0x0028950e, 0x0028b50e, 0x0028d50e, 0x0028f50e, - 0x0029150e, 0x0029350e, 0x0029550e, 0x0029750e, - 0x0029950e, 0x0029b50e, 0x0029d50e, 0x0029f50e, - 0x002a150e, 0x002a350e, 0x002a550e, 0x002a750e, - 0x002a950e, 0x002ab50e, 0x002ad50e, 0x002af50e, - 0x002b150e, 0x002b350e, 0x002b550e, 0x002b750e, - 0x002b950e, 0x002bb50e, 0x002bd50e, 0x002bf50e, - 0x002c150e, 0x002c350e, 0x002c550e, 0x002c750e, - 0x002c950e, 0x002cb50e, 0x002cd50e, 0x002cf50e, - 0x002d150e, 0x002d350e, 0x002d550e, 0x002d750e, - 0x002d950e, 0x002db50e, 0x002dd50e, 0x002df50e, - 0x002e150e, 0x002e350e, 0x002e550e, 0x002e750e, - 0x002e950e, 0x002eb50e, 0x002ed50e, 0x002ef50e, - 0x002f150e, 0x002f350e, 0x002f550e, 0x002f750e, - 0x002f950e, 0x002fb50e, 0x002fd50e, 0x002ff50e, - 0x0030150e, 0x0030350e, 0x0030550e, 0x0030750e, - 0x0030950e, 0x0030b50e, 0x0030d50e, 0x0030f50e, - 0x0031150e, 0x0031350e, 0x0031550e, 0x0031750e, - 0x0031950e, 0x0031b50e, 0x0031d50e, 0x0031f50e, - 0x0032150e, 0x0032350e, 0x0032550e, 0x0032750e, - 0x0032950e, 0x0032b50e, 0x0032d50e, 0x0032f50e, - 0x0033150e, 0x0033350e, 0x0033550e, 0x0033750e, - 0x0033950e, 0x0033b50e, 0x0033d50e, 0x0033f50e, - 0x0034150e, 0x0034350e, 0x0034550e, 0x0034750e, - 0x0034950e, 0x0034b50e, 0x0034d50e, 0x0034f50e, - 0x0035150e, 0x0035350e, 0x0035550e, 0x0035750e, - 0x0035950e, 0x0035b50e, 0x0035d50e, 0x0035f50e, - 0x0036150e, 0x0036350e, 0x0036550e, 0x0036750e, - 0x0036950e, 0x0036b50e, 0x0036d50e, 0x0036f50e, - 0x0037150e, 0x0037350e, 0x0037550e, 0x0037750e, - 0x0037950e, 0x0037b50e, 0x0037d50e, 0x0037f50e, - 0x0038150e, 0x0038350e, 0x0038550e, 0x0038750e, - 0x0038950e, 0x0038b50e, 0x0038d50e, 0x0038f50e, - 0x0039150e, 0x0039350e, 0x0039550e, 0x0039750e, - 0x0039950e, 0x0039b50e, 0x0039d50e, 0x0039f50e, - 0x003a150e, 0x003a350e, 0x003a550e, 0x003a750e, - 0x003a950e, 0x003ab50e, 0x003ad50e, 0x003af50e, - 0x003b150e, 0x003b350e, 0x003b550e, 0x003b750e, - 0x003b950e, 0x003bb50e, 0x003bd50e, 0x003bf50e, - 0x003c150e, 0x003c350e, 0x003c550e, 0x003c750e, - 0x003c950e, 0x003cb50e, 0x003cd50e, 0x003cf50e, - 0x003d150e, 0x003d350e, 0x003d550e, 0x003d750e, - 0x003d950e, 0x003db50e, 0x003dd50e, 0x003df50e, - 0x003e150e, 0x003e350e, 0x003e550e, 0x003e750e, - 0x003e950e, 0x003eb50e, 0x003ed50e, 0x003ef50e, - 0x003f150e, 0x003f350e, 0x003f550e, 0x003f750e, - 0x003f950e, 0x003fb50e, 0x003fd50e, 0x003ff50e, - 0x00000d0f, 0x00002d0f, 0x00004d0f, 0x00006d0f, - 0x00008d0f, 0x0000ad0f, 0x0000cd0f, 0x0000ed0f, - 0x00010d0f, 0x00012d0f, 0x00014d0f, 0x00016d0f, - 0x00018d0f, 0x0001ad0f, 0x0001cd0f, 0x0001ed0f, - 0x00020d0f, 0x00022d0f, 0x00024d0f, 0x00026d0f, - 0x00028d0f, 0x0002ad0f, 0x0002cd0f, 0x0002ed0f, - 0x00030d0f, 0x00032d0f, 0x00034d0f, 0x00036d0f, - 0x00038d0f, 0x0003ad0f, 0x0003cd0f, 0x0003ed0f, - 0x00040d0f, 0x00042d0f, 0x00044d0f, 0x00046d0f, - 0x00048d0f, 0x0004ad0f, 0x0004cd0f, 0x0004ed0f, - 0x00050d0f, 0x00052d0f, 0x00054d0f, 0x00056d0f, - 0x00058d0f, 0x0005ad0f, 0x0005cd0f, 0x0005ed0f, - 0x00060d0f, 0x00062d0f, 0x00064d0f, 0x00066d0f, - 0x00068d0f, 0x0006ad0f, 0x0006cd0f, 0x0006ed0f, - 0x00070d0f, 0x00072d0f, 0x00074d0f, 0x00076d0f, - 0x00078d0f, 0x0007ad0f, 0x0007cd0f, 0x0007ed0f, - 0x00080d0f, 0x00082d0f, 0x00084d0f, 0x00086d0f, - 0x00088d0f, 0x0008ad0f, 0x0008cd0f, 0x0008ed0f, - 0x00090d0f, 0x00092d0f, 0x00094d0f, 0x00096d0f, - 0x00098d0f, 0x0009ad0f, 0x0009cd0f, 0x0009ed0f, - 0x000a0d0f, 0x000a2d0f, 0x000a4d0f, 0x000a6d0f, - 0x000a8d0f, 0x000aad0f, 0x000acd0f, 0x000aed0f, - 0x000b0d0f, 0x000b2d0f, 0x000b4d0f, 0x000b6d0f, - 0x000b8d0f, 0x000bad0f, 0x000bcd0f, 0x000bed0f, - 0x000c0d0f, 0x000c2d0f, 0x000c4d0f, 0x000c6d0f, - 0x000c8d0f, 0x000cad0f, 0x000ccd0f, 0x000ced0f, - 0x000d0d0f, 0x000d2d0f, 0x000d4d0f, 0x000d6d0f, - 0x000d8d0f, 0x000dad0f, 0x000dcd0f, 0x000ded0f, - 0x000e0d0f, 0x000e2d0f, 0x000e4d0f, 0x000e6d0f, - 0x000e8d0f, 0x000ead0f, 0x000ecd0f, 0x000eed0f, - 0x000f0d0f, 0x000f2d0f, 0x000f4d0f, 0x000f6d0f, - 0x000f8d0f, 0x000fad0f, 0x000fcd0f, 0x000fed0f, - 0x00100d0f, 0x00102d0f, 0x00104d0f, 0x00106d0f, - 0x00108d0f, 0x0010ad0f, 0x0010cd0f, 0x0010ed0f, - 0x00110d0f, 0x00112d0f, 0x00114d0f, 0x00116d0f, - 0x00118d0f, 0x0011ad0f, 0x0011cd0f, 0x0011ed0f, - 0x00120d0f, 0x00122d0f, 0x00124d0f, 0x00126d0f, - 0x00128d0f, 0x0012ad0f, 0x0012cd0f, 0x0012ed0f, - 0x00130d0f, 0x00132d0f, 0x00134d0f, 0x00136d0f, - 0x00138d0f, 0x0013ad0f, 0x0013cd0f, 0x0013ed0f, - 0x00140d0f, 0x00142d0f, 0x00144d0f, 0x00146d0f, - 0x00148d0f, 0x0014ad0f, 0x0014cd0f, 0x0014ed0f, - 0x00150d0f, 0x00152d0f, 0x00154d0f, 0x00156d0f, - 0x00158d0f, 0x0015ad0f, 0x0015cd0f, 0x0015ed0f, - 0x00160d0f, 0x00162d0f, 0x00164d0f, 0x00166d0f, - 0x00168d0f, 0x0016ad0f, 0x0016cd0f, 0x0016ed0f, - 0x00170d0f, 0x00172d0f, 0x00174d0f, 0x00176d0f, - 0x00178d0f, 0x0017ad0f, 0x0017cd0f, 0x0017ed0f, - 0x00180d0f, 0x00182d0f, 0x00184d0f, 0x00186d0f, - 0x00188d0f, 0x0018ad0f, 0x0018cd0f, 0x0018ed0f, - 0x00190d0f, 0x00192d0f, 0x00194d0f, 0x00196d0f, - 0x00198d0f, 0x0019ad0f, 0x0019cd0f, 0x0019ed0f, - 0x001a0d0f, 0x001a2d0f, 0x001a4d0f, 0x001a6d0f, - 0x001a8d0f, 0x001aad0f, 0x001acd0f, 0x001aed0f, - 0x001b0d0f, 0x001b2d0f, 0x001b4d0f, 0x001b6d0f, - 0x001b8d0f, 0x001bad0f, 0x001bcd0f, 0x001bed0f, - 0x001c0d0f, 0x001c2d0f, 0x001c4d0f, 0x001c6d0f, - 0x001c8d0f, 0x001cad0f, 0x001ccd0f, 0x001ced0f, - 0x001d0d0f, 0x001d2d0f, 0x001d4d0f, 0x001d6d0f, - 0x001d8d0f, 0x001dad0f, 0x001dcd0f, 0x001ded0f, - 0x001e0d0f, 0x001e2d0f, 0x001e4d0f, 0x001e6d0f, - 0x001e8d0f, 0x001ead0f, 0x001ecd0f, 0x001eed0f, - 0x001f0d0f, 0x001f2d0f, 0x001f4d0f, 0x001f6d0f, - 0x001f8d0f, 0x001fad0f, 0x001fcd0f, 0x001fed0f, - 0x00200d0f, 0x00202d0f, 0x00204d0f, 0x00206d0f, - 0x00208d0f, 0x0020ad0f, 0x0020cd0f, 0x0020ed0f, - 0x00210d0f, 0x00212d0f, 0x00214d0f, 0x00216d0f, - 0x00218d0f, 0x0021ad0f, 0x0021cd0f, 0x0021ed0f, - 0x00220d0f, 0x00222d0f, 0x00224d0f, 0x00226d0f, - 0x00228d0f, 0x0022ad0f, 0x0022cd0f, 0x0022ed0f, - 0x00230d0f, 0x00232d0f, 0x00234d0f, 0x00236d0f, - 0x00238d0f, 0x0023ad0f, 0x0023cd0f, 0x0023ed0f, - 0x00240d0f, 0x00242d0f, 0x00244d0f, 0x00246d0f, - 0x00248d0f, 0x0024ad0f, 0x0024cd0f, 0x0024ed0f, - 0x00250d0f, 0x00252d0f, 0x00254d0f, 0x00256d0f, - 0x00258d0f, 0x0025ad0f, 0x0025cd0f, 0x0025ed0f, - 0x00260d0f, 0x00262d0f, 0x00264d0f, 0x00266d0f, - 0x00268d0f, 0x0026ad0f, 0x0026cd0f, 0x0026ed0f, - 0x00270d0f, 0x00272d0f, 0x00274d0f, 0x00276d0f, - 0x00278d0f, 0x0027ad0f, 0x0027cd0f, 0x0027ed0f, - 0x00280d0f, 0x00282d0f, 0x00284d0f, 0x00286d0f, - 0x00288d0f, 0x0028ad0f, 0x0028cd0f, 0x0028ed0f, - 0x00290d0f, 0x00292d0f, 0x00294d0f, 0x00296d0f, - 0x00298d0f, 0x0029ad0f, 0x0029cd0f, 0x0029ed0f, - 0x002a0d0f, 0x002a2d0f, 0x002a4d0f, 0x002a6d0f, - 0x002a8d0f, 0x002aad0f, 0x002acd0f, 0x002aed0f, - 0x002b0d0f, 0x002b2d0f, 0x002b4d0f, 0x002b6d0f, - 0x002b8d0f, 0x002bad0f, 0x002bcd0f, 0x002bed0f, - 0x002c0d0f, 0x002c2d0f, 0x002c4d0f, 0x002c6d0f, - 0x002c8d0f, 0x002cad0f, 0x002ccd0f, 0x002ced0f, - 0x002d0d0f, 0x002d2d0f, 0x002d4d0f, 0x002d6d0f, - 0x002d8d0f, 0x002dad0f, 0x002dcd0f, 0x002ded0f, - 0x002e0d0f, 0x002e2d0f, 0x002e4d0f, 0x002e6d0f, - 0x002e8d0f, 0x002ead0f, 0x002ecd0f, 0x002eed0f, - 0x002f0d0f, 0x002f2d0f, 0x002f4d0f, 0x002f6d0f, - 0x002f8d0f, 0x002fad0f, 0x002fcd0f, 0x002fed0f, - 0x00300d0f, 0x00302d0f, 0x00304d0f, 0x00306d0f, - 0x00308d0f, 0x0030ad0f, 0x0030cd0f, 0x0030ed0f, - 0x00310d0f, 0x00312d0f, 0x00314d0f, 0x00316d0f, - 0x00318d0f, 0x0031ad0f, 0x0031cd0f, 0x0031ed0f, - 0x00320d0f, 0x00322d0f, 0x00324d0f, 0x00326d0f, - 0x00328d0f, 0x0032ad0f, 0x0032cd0f, 0x0032ed0f, - 0x00330d0f, 0x00332d0f, 0x00334d0f, 0x00336d0f, - 0x00338d0f, 0x0033ad0f, 0x0033cd0f, 0x0033ed0f, - 0x00340d0f, 0x00342d0f, 0x00344d0f, 0x00346d0f, - 0x00348d0f, 0x0034ad0f, 0x0034cd0f, 0x0034ed0f, - 0x00350d0f, 0x00352d0f, 0x00354d0f, 0x00356d0f, - 0x00358d0f, 0x0035ad0f, 0x0035cd0f, 0x0035ed0f, - 0x00360d0f, 0x00362d0f, 0x00364d0f, 0x00366d0f, - 0x00368d0f, 0x0036ad0f, 0x0036cd0f, 0x0036ed0f, - 0x00370d0f, 0x00372d0f, 0x00374d0f, 0x00376d0f, - 0x00378d0f, 0x0037ad0f, 0x0037cd0f, 0x0037ed0f, - 0x00380d0f, 0x00382d0f, 0x00384d0f, 0x00386d0f, - 0x00388d0f, 0x0038ad0f, 0x0038cd0f, 0x0038ed0f, - 0x00390d0f, 0x00392d0f, 0x00394d0f, 0x00396d0f, - 0x00398d0f, 0x0039ad0f, 0x0039cd0f, 0x0039ed0f, - 0x003a0d0f, 0x003a2d0f, 0x003a4d0f, 0x003a6d0f, - 0x003a8d0f, 0x003aad0f, 0x003acd0f, 0x003aed0f, - 0x003b0d0f, 0x003b2d0f, 0x003b4d0f, 0x003b6d0f, - 0x003b8d0f, 0x003bad0f, 0x003bcd0f, 0x003bed0f, - 0x003c0d0f, 0x003c2d0f, 0x003c4d0f, 0x003c6d0f, - 0x003c8d0f, 0x003cad0f, 0x003ccd0f, 0x003ced0f, - 0x003d0d0f, 0x003d2d0f, 0x003d4d0f, 0x003d6d0f, - 0x003d8d0f, 0x003dad0f, 0x003dcd0f, 0x003ded0f, - 0x003e0d0f, 0x003e2d0f, 0x003e4d0f, 0x003e6d0f, - 0x003e8d0f, 0x003ead0f, 0x003ecd0f, 0x003eed0f, - 0x003f0d0f, 0x003f2d0f, 0x003f4d0f, 0x003f6d0f, - 0x003f8d0f, 0x003fad0f, 0x003fcd0f, 0x003fed0f, - 0x00400d0f, 0x00402d0f, 0x00404d0f, 0x00406d0f, - 0x00408d0f, 0x0040ad0f, 0x0040cd0f, 0x0040ed0f, - 0x00410d0f, 0x00412d0f, 0x00414d0f, 0x00416d0f, - 0x00418d0f, 0x0041ad0f, 0x0041cd0f, 0x0041ed0f, - 0x00420d0f, 0x00422d0f, 0x00424d0f, 0x00426d0f, - 0x00428d0f, 0x0042ad0f, 0x0042cd0f, 0x0042ed0f, - 0x00430d0f, 0x00432d0f, 0x00434d0f, 0x00436d0f, - 0x00438d0f, 0x0043ad0f, 0x0043cd0f, 0x0043ed0f, - 0x00440d0f, 0x00442d0f, 0x00444d0f, 0x00446d0f, - 0x00448d0f, 0x0044ad0f, 0x0044cd0f, 0x0044ed0f, - 0x00450d0f, 0x00452d0f, 0x00454d0f, 0x00456d0f, - 0x00458d0f, 0x0045ad0f, 0x0045cd0f, 0x0045ed0f, - 0x00460d0f, 0x00462d0f, 0x00464d0f, 0x00466d0f, - 0x00468d0f, 0x0046ad0f, 0x0046cd0f, 0x0046ed0f, - 0x00470d0f, 0x00472d0f, 0x00474d0f, 0x00476d0f, - 0x00478d0f, 0x0047ad0f, 0x0047cd0f, 0x0047ed0f, - 0x00480d0f, 0x00482d0f, 0x00484d0f, 0x00486d0f, - 0x00488d0f, 0x0048ad0f, 0x0048cd0f, 0x0048ed0f, - 0x00490d0f, 0x00492d0f, 0x00494d0f, 0x00496d0f, - 0x00498d0f, 0x0049ad0f, 0x0049cd0f, 0x0049ed0f, - 0x004a0d0f, 0x004a2d0f, 0x004a4d0f, 0x004a6d0f, - 0x004a8d0f, 0x004aad0f, 0x004acd0f, 0x004aed0f, - 0x004b0d0f, 0x004b2d0f, 0x004b4d0f, 0x004b6d0f, - 0x004b8d0f, 0x004bad0f, 0x004bcd0f, 0x004bed0f, - 0x004c0d0f, 0x004c2d0f, 0x004c4d0f, 0x004c6d0f, - 0x004c8d0f, 0x004cad0f, 0x004ccd0f, 0x004ced0f, - 0x004d0d0f, 0x004d2d0f, 0x004d4d0f, 0x004d6d0f, - 0x004d8d0f, 0x004dad0f, 0x004dcd0f, 0x004ded0f, - 0x004e0d0f, 0x004e2d0f, 0x004e4d0f, 0x004e6d0f, - 0x004e8d0f, 0x004ead0f, 0x004ecd0f, 0x004eed0f, - 0x004f0d0f, 0x004f2d0f, 0x004f4d0f, 0x004f6d0f, - 0x004f8d0f, 0x004fad0f, 0x004fcd0f, 0x004fed0f, - 0x00500d0f, 0x00502d0f, 0x00504d0f, 0x00506d0f, - 0x00508d0f, 0x0050ad0f, 0x0050cd0f, 0x0050ed0f, - 0x00510d0f, 0x00512d0f, 0x00514d0f, 0x00516d0f, - 0x00518d0f, 0x0051ad0f, 0x0051cd0f, 0x0051ed0f, - 0x00520d0f, 0x00522d0f, 0x00524d0f, 0x00526d0f, - 0x00528d0f, 0x0052ad0f, 0x0052cd0f, 0x0052ed0f, - 0x00530d0f, 0x00532d0f, 0x00534d0f, 0x00536d0f, - 0x00538d0f, 0x0053ad0f, 0x0053cd0f, 0x0053ed0f, - 0x00540d0f, 0x00542d0f, 0x00544d0f, 0x00546d0f, - 0x00548d0f, 0x0054ad0f, 0x0054cd0f, 0x0054ed0f, - 0x00550d0f, 0x00552d0f, 0x00554d0f, 0x00556d0f, - 0x00558d0f, 0x0055ad0f, 0x0055cd0f, 0x0055ed0f, - 0x00560d0f, 0x00562d0f, 0x00564d0f, 0x00566d0f, - 0x00568d0f, 0x0056ad0f, 0x0056cd0f, 0x0056ed0f, - 0x00570d0f, 0x00572d0f, 0x00574d0f, 0x00576d0f, - 0x00578d0f, 0x0057ad0f, 0x0057cd0f, 0x0057ed0f, - 0x00580d0f, 0x00582d0f, 0x00584d0f, 0x00586d0f, - 0x00588d0f, 0x0058ad0f, 0x0058cd0f, 0x0058ed0f, - 0x00590d0f, 0x00592d0f, 0x00594d0f, 0x00596d0f, - 0x00598d0f, 0x0059ad0f, 0x0059cd0f, 0x0059ed0f, - 0x005a0d0f, 0x005a2d0f, 0x005a4d0f, 0x005a6d0f, - 0x005a8d0f, 0x005aad0f, 0x005acd0f, 0x005aed0f, - 0x005b0d0f, 0x005b2d0f, 0x005b4d0f, 0x005b6d0f, - 0x005b8d0f, 0x005bad0f, 0x005bcd0f, 0x005bed0f, - 0x005c0d0f, 0x005c2d0f, 0x005c4d0f, 0x005c6d0f, - 0x005c8d0f, 0x005cad0f, 0x005ccd0f, 0x005ced0f, - 0x005d0d0f, 0x005d2d0f, 0x005d4d0f, 0x005d6d0f, - 0x005d8d0f, 0x005dad0f, 0x005dcd0f, 0x005ded0f, - 0x005e0d0f, 0x005e2d0f, 0x005e4d0f, 0x005e6d0f, - 0x005e8d0f, 0x005ead0f, 0x005ecd0f, 0x005eed0f, - 0x005f0d0f, 0x005f2d0f, 0x005f4d0f, 0x005f6d0f, - 0x005f8d0f, 0x005fad0f, 0x005fcd0f, 0x005fed0f, - 0x00600d0f, 0x00602d0f, 0x00604d0f, 0x00606d0f, - 0x00608d0f, 0x0060ad0f, 0x0060cd0f, 0x0060ed0f, - 0x00610d0f, 0x00612d0f, 0x00614d0f, 0x00616d0f, - 0x00618d0f, 0x0061ad0f, 0x0061cd0f, 0x0061ed0f, - 0x00620d0f, 0x00622d0f, 0x00624d0f, 0x00626d0f, - 0x00628d0f, 0x0062ad0f, 0x0062cd0f, 0x0062ed0f, - 0x00630d0f, 0x00632d0f, 0x00634d0f, 0x00636d0f, - 0x00638d0f, 0x0063ad0f, 0x0063cd0f, 0x0063ed0f, - 0x00640d0f, 0x00642d0f, 0x00644d0f, 0x00646d0f, - 0x00648d0f, 0x0064ad0f, 0x0064cd0f, 0x0064ed0f, - 0x00650d0f, 0x00652d0f, 0x00654d0f, 0x00656d0f, - 0x00658d0f, 0x0065ad0f, 0x0065cd0f, 0x0065ed0f, - 0x00660d0f, 0x00662d0f, 0x00664d0f, 0x00666d0f, - 0x00668d0f, 0x0066ad0f, 0x0066cd0f, 0x0066ed0f, - 0x00670d0f, 0x00672d0f, 0x00674d0f, 0x00676d0f, - 0x00678d0f, 0x0067ad0f, 0x0067cd0f, 0x0067ed0f, - 0x00680d0f, 0x00682d0f, 0x00684d0f, 0x00686d0f, - 0x00688d0f, 0x0068ad0f, 0x0068cd0f, 0x0068ed0f, - 0x00690d0f, 0x00692d0f, 0x00694d0f, 0x00696d0f, - 0x00698d0f, 0x0069ad0f, 0x0069cd0f, 0x0069ed0f, - 0x006a0d0f, 0x006a2d0f, 0x006a4d0f, 0x006a6d0f, - 0x006a8d0f, 0x006aad0f, 0x006acd0f, 0x006aed0f, - 0x006b0d0f, 0x006b2d0f, 0x006b4d0f, 0x006b6d0f, - 0x006b8d0f, 0x006bad0f, 0x006bcd0f, 0x006bed0f, - 0x006c0d0f, 0x006c2d0f, 0x006c4d0f, 0x006c6d0f, - 0x006c8d0f, 0x006cad0f, 0x006ccd0f, 0x006ced0f, - 0x006d0d0f, 0x006d2d0f, 0x006d4d0f, 0x006d6d0f, - 0x006d8d0f, 0x006dad0f, 0x006dcd0f, 0x006ded0f, - 0x006e0d0f, 0x006e2d0f, 0x006e4d0f, 0x006e6d0f, - 0x006e8d0f, 0x006ead0f, 0x006ecd0f, 0x006eed0f, - 0x006f0d0f, 0x006f2d0f, 0x006f4d0f, 0x006f6d0f, - 0x006f8d0f, 0x006fad0f, 0x006fcd0f, 0x006fed0f, - 0x00700d0f, 0x00702d0f, 0x00704d0f, 0x00706d0f, - 0x00708d0f, 0x0070ad0f, 0x0070cd0f, 0x0070ed0f, - 0x00710d0f, 0x00712d0f, 0x00714d0f, 0x00716d0f, - 0x00718d0f, 0x0071ad0f, 0x0071cd0f, 0x0071ed0f, - 0x00720d0f, 0x00722d0f, 0x00724d0f, 0x00726d0f, - 0x00728d0f, 0x0072ad0f, 0x0072cd0f, 0x0072ed0f, - 0x00730d0f, 0x00732d0f, 0x00734d0f, 0x00736d0f, - 0x00738d0f, 0x0073ad0f, 0x0073cd0f, 0x0073ed0f, - 0x00740d0f, 0x00742d0f, 0x00744d0f, 0x00746d0f, - 0x00748d0f, 0x0074ad0f, 0x0074cd0f, 0x0074ed0f, - 0x00750d0f, 0x00752d0f, 0x00754d0f, 0x00756d0f, - 0x00758d0f, 0x0075ad0f, 0x0075cd0f, 0x0075ed0f, - 0x00760d0f, 0x00762d0f, 0x00764d0f, 0x00766d0f, - 0x00768d0f, 0x0076ad0f, 0x0076cd0f, 0x0076ed0f, - 0x00770d0f, 0x00772d0f, 0x00774d0f, 0x00776d0f, - 0x00778d0f, 0x0077ad0f, 0x0077cd0f, 0x0077ed0f, - 0x00780d0f, 0x00782d0f, 0x00784d0f, 0x00786d0f, - 0x00788d0f, 0x0078ad0f, 0x0078cd0f, 0x0078ed0f, - 0x00790d0f, 0x00792d0f, 0x00794d0f, 0x00796d0f, - 0x00798d0f, 0x0079ad0f, 0x0079cd0f, 0x0079ed0f, - 0x007a0d0f, 0x007a2d0f, 0x007a4d0f, 0x007a6d0f, - 0x007a8d0f, 0x007aad0f, 0x007acd0f, 0x007aed0f, - 0x007b0d0f, 0x007b2d0f, 0x007b4d0f, 0x007b6d0f, - 0x007b8d0f, 0x007bad0f, 0x007bcd0f, 0x007bed0f, - 0x007c0d0f, 0x007c2d0f, 0x007c4d0f, 0x007c6d0f, - 0x007c8d0f, 0x007cad0f, 0x007ccd0f, 0x007ced0f, - 0x007d0d0f, 0x007d2d0f, 0x007d4d0f, 0x007d6d0f, - 0x007d8d0f, 0x007dad0f, 0x007dcd0f, 0x007ded0f, - 0x007e0d0f, 0x007e2d0f, 0x007e4d0f, 0x007e6d0f, - 0x007e8d0f, 0x007ead0f, 0x007ecd0f, 0x007eed0f, - 0x007f0d0f, 0x007f2d0f, 0x007f4d0f, 0x007f6d0f, - 0x007f8d0f, 0x007fad0f, 0x007fcd0f, 0x007fed0f, - 0x00001d0f, 0x00003d0f, 0x00005d0f, 0x00007d0f, - 0x00009d0f, 0x0000bd0f, 0x0000dd0f, 0x0000fd0f, - 0x00011d0f, 0x00013d0f, 0x00015d0f, 0x00017d0f, - 0x00019d0f, 0x0001bd0f, 0x0001dd0f, 0x0001fd0f, - 0x00021d0f, 0x00023d0f, 0x00025d0f, 0x00027d0f, - 0x00029d0f, 0x0002bd0f, 0x0002dd0f, 0x0002fd0f, - 0x00031d0f, 0x00033d0f, 0x00035d0f, 0x00037d0f, - 0x00039d0f, 0x0003bd0f, 0x0003dd0f, 0x0003fd0f, - 0x00041d0f, 0x00043d0f, 0x00045d0f, 0x00047d0f, - 0x00049d0f, 0x0004bd0f, 0x0004dd0f, 0x0004fd0f, - 0x00051d0f, 0x00053d0f, 0x00055d0f, 0x00057d0f, - 0x00059d0f, 0x0005bd0f, 0x0005dd0f, 0x0005fd0f, - 0x00061d0f, 0x00063d0f, 0x00065d0f, 0x00067d0f, - 0x00069d0f, 0x0006bd0f, 0x0006dd0f, 0x0006fd0f, - 0x00071d0f, 0x00073d0f, 0x00075d0f, 0x00077d0f, - 0x00079d0f, 0x0007bd0f, 0x0007dd0f, 0x0007fd0f, - 0x00081d0f, 0x00083d0f, 0x00085d0f, 0x00087d0f, - 0x00089d0f, 0x0008bd0f, 0x0008dd0f, 0x0008fd0f, - 0x00091d0f, 0x00093d0f, 0x00095d0f, 0x00097d0f, - 0x00099d0f, 0x0009bd0f, 0x0009dd0f, 0x0009fd0f, - 0x000a1d0f, 0x000a3d0f, 0x000a5d0f, 0x000a7d0f, - 0x000a9d0f, 0x000abd0f, 0x000add0f, 0x000afd0f, - 0x000b1d0f, 0x000b3d0f, 0x000b5d0f, 0x000b7d0f, - 0x000b9d0f, 0x000bbd0f, 0x000bdd0f, 0x000bfd0f, - 0x000c1d0f, 0x000c3d0f, 0x000c5d0f, 0x000c7d0f, - 0x000c9d0f, 0x000cbd0f, 0x000cdd0f, 0x000cfd0f, - 0x000d1d0f, 0x000d3d0f, 0x000d5d0f, 0x000d7d0f, - 0x000d9d0f, 0x000dbd0f, 0x000ddd0f, 0x000dfd0f, - 0x000e1d0f, 0x000e3d0f, 0x000e5d0f, 0x000e7d0f, - 0x000e9d0f, 0x000ebd0f, 0x000edd0f, 0x000efd0f, - 0x000f1d0f, 0x000f3d0f, 0x000f5d0f, 0x000f7d0f, - 0x000f9d0f, 0x000fbd0f, 0x000fdd0f, 0x000ffd0f, - 0x00101d0f, 0x00103d0f, 0x00105d0f, 0x00107d0f, - 0x00109d0f, 0x0010bd0f, 0x0010dd0f, 0x0010fd0f, - 0x00111d0f, 0x00113d0f, 0x00115d0f, 0x00117d0f, - 0x00119d0f, 0x0011bd0f, 0x0011dd0f, 0x0011fd0f, - 0x00121d0f, 0x00123d0f, 0x00125d0f, 0x00127d0f, - 0x00129d0f, 0x0012bd0f, 0x0012dd0f, 0x0012fd0f, - 0x00131d0f, 0x00133d0f, 0x00135d0f, 0x00137d0f, - 0x00139d0f, 0x0013bd0f, 0x0013dd0f, 0x0013fd0f, - 0x00141d0f, 0x00143d0f, 0x00145d0f, 0x00147d0f, - 0x00149d0f, 0x0014bd0f, 0x0014dd0f, 0x0014fd0f, - 0x00151d0f, 0x00153d0f, 0x00155d0f, 0x00157d0f, - 0x00159d0f, 0x0015bd0f, 0x0015dd0f, 0x0015fd0f, - 0x00161d0f, 0x00163d0f, 0x00165d0f, 0x00167d0f, - 0x00169d0f, 0x0016bd0f, 0x0016dd0f, 0x0016fd0f, - 0x00171d0f, 0x00173d0f, 0x00175d0f, 0x00177d0f, - 0x00179d0f, 0x0017bd0f, 0x0017dd0f, 0x0017fd0f, - 0x00181d0f, 0x00183d0f, 0x00185d0f, 0x00187d0f, - 0x00189d0f, 0x0018bd0f, 0x0018dd0f, 0x0018fd0f, - 0x00191d0f, 0x00193d0f, 0x00195d0f, 0x00197d0f, - 0x00199d0f, 0x0019bd0f, 0x0019dd0f, 0x0019fd0f, - 0x001a1d0f, 0x001a3d0f, 0x001a5d0f, 0x001a7d0f, - 0x001a9d0f, 0x001abd0f, 0x001add0f, 0x001afd0f, - 0x001b1d0f, 0x001b3d0f, 0x001b5d0f, 0x001b7d0f, - 0x001b9d0f, 0x001bbd0f, 0x001bdd0f, 0x001bfd0f, - 0x001c1d0f, 0x001c3d0f, 0x001c5d0f, 0x001c7d0f, - 0x001c9d0f, 0x001cbd0f, 0x001cdd0f, 0x001cfd0f, - 0x001d1d0f, 0x001d3d0f, 0x001d5d0f, 0x001d7d0f, - 0x001d9d0f, 0x001dbd0f, 0x001ddd0f, 0x001dfd0f, - 0x001e1d0f, 0x001e3d0f, 0x001e5d0f, 0x001e7d0f, - 0x001e9d0f, 0x001ebd0f, 0x001edd0f, 0x001efd0f, - 0x001f1d0f, 0x001f3d0f, 0x001f5d0f, 0x001f7d0f, - 0x001f9d0f, 0x001fbd0f, 0x001fdd0f, 0x001ffd0f, - 0x00201d0f, 0x00203d0f, 0x00205d0f, 0x00207d0f, - 0x00209d0f, 0x0020bd0f, 0x0020dd0f, 0x0020fd0f, - 0x00211d0f, 0x00213d0f, 0x00215d0f, 0x00217d0f, - 0x00219d0f, 0x0021bd0f, 0x0021dd0f, 0x0021fd0f, - 0x00221d0f, 0x00223d0f, 0x00225d0f, 0x00227d0f, - 0x00229d0f, 0x0022bd0f, 0x0022dd0f, 0x0022fd0f, - 0x00231d0f, 0x00233d0f, 0x00235d0f, 0x00237d0f, - 0x00239d0f, 0x0023bd0f, 0x0023dd0f, 0x0023fd0f, - 0x00241d0f, 0x00243d0f, 0x00245d0f, 0x00247d0f, - 0x00249d0f, 0x0024bd0f, 0x0024dd0f, 0x0024fd0f, - 0x00251d0f, 0x00253d0f, 0x00255d0f, 0x00257d0f, - 0x00259d0f, 0x0025bd0f, 0x0025dd0f, 0x0025fd0f, - 0x00261d0f, 0x00263d0f, 0x00265d0f, 0x00267d0f, - 0x00269d0f, 0x0026bd0f, 0x0026dd0f, 0x0026fd0f, - 0x00271d0f, 0x00273d0f, 0x00275d0f, 0x00277d0f, - 0x00279d0f, 0x0027bd0f, 0x0027dd0f, 0x0027fd0f, - 0x00281d0f, 0x00283d0f, 0x00285d0f, 0x00287d0f, - 0x00289d0f, 0x0028bd0f, 0x0028dd0f, 0x0028fd0f, - 0x00291d0f, 0x00293d0f, 0x00295d0f, 0x00297d0f, - 0x00299d0f, 0x0029bd0f, 0x0029dd0f, 0x0029fd0f, - 0x002a1d0f, 0x002a3d0f, 0x002a5d0f, 0x002a7d0f, - 0x002a9d0f, 0x002abd0f, 0x002add0f, 0x002afd0f, - 0x002b1d0f, 0x002b3d0f, 0x002b5d0f, 0x002b7d0f, - 0x002b9d0f, 0x002bbd0f, 0x002bdd0f, 0x002bfd0f, - 0x002c1d0f, 0x002c3d0f, 0x002c5d0f, 0x002c7d0f, - 0x002c9d0f, 0x002cbd0f, 0x002cdd0f, 0x002cfd0f, - 0x002d1d0f, 0x002d3d0f, 0x002d5d0f, 0x002d7d0f, - 0x002d9d0f, 0x002dbd0f, 0x002ddd0f, 0x002dfd0f, - 0x002e1d0f, 0x002e3d0f, 0x002e5d0f, 0x002e7d0f, - 0x002e9d0f, 0x002ebd0f, 0x002edd0f, 0x002efd0f, - 0x002f1d0f, 0x002f3d0f, 0x002f5d0f, 0x002f7d0f, - 0x002f9d0f, 0x002fbd0f, 0x002fdd0f, 0x002ffd0f, - 0x00301d0f, 0x00303d0f, 0x00305d0f, 0x00307d0f, - 0x00309d0f, 0x0030bd0f, 0x0030dd0f, 0x0030fd0f, - 0x00311d0f, 0x00313d0f, 0x00315d0f, 0x00317d0f, - 0x00319d0f, 0x0031bd0f, 0x0031dd0f, 0x0031fd0f, - 0x00321d0f, 0x00323d0f, 0x00325d0f, 0x00327d0f, - 0x00329d0f, 0x0032bd0f, 0x0032dd0f, 0x0032fd0f, - 0x00331d0f, 0x00333d0f, 0x00335d0f, 0x00337d0f, - 0x00339d0f, 0x0033bd0f, 0x0033dd0f, 0x0033fd0f, - 0x00341d0f, 0x00343d0f, 0x00345d0f, 0x00347d0f, - 0x00349d0f, 0x0034bd0f, 0x0034dd0f, 0x0034fd0f, - 0x00351d0f, 0x00353d0f, 0x00355d0f, 0x00357d0f, - 0x00359d0f, 0x0035bd0f, 0x0035dd0f, 0x0035fd0f, - 0x00361d0f, 0x00363d0f, 0x00365d0f, 0x00367d0f, - 0x00369d0f, 0x0036bd0f, 0x0036dd0f, 0x0036fd0f, - 0x00371d0f, 0x00373d0f, 0x00375d0f, 0x00377d0f, - 0x00379d0f, 0x0037bd0f, 0x0037dd0f, 0x0037fd0f, - 0x00381d0f, 0x00383d0f, 0x00385d0f, 0x00387d0f, - 0x00389d0f, 0x0038bd0f, 0x0038dd0f, 0x0038fd0f, - 0x00391d0f, 0x00393d0f, 0x00395d0f, 0x00397d0f, - 0x00399d0f, 0x0039bd0f, 0x0039dd0f, 0x0039fd0f, - 0x003a1d0f, 0x003a3d0f, 0x003a5d0f, 0x003a7d0f, - 0x003a9d0f, 0x003abd0f, 0x003add0f, 0x003afd0f, - 0x003b1d0f, 0x003b3d0f, 0x003b5d0f, 0x003b7d0f, - 0x003b9d0f, 0x003bbd0f, 0x003bdd0f, 0x003bfd0f, - 0x003c1d0f, 0x003c3d0f, 0x003c5d0f, 0x003c7d0f, - 0x003c9d0f, 0x003cbd0f, 0x003cdd0f, 0x003cfd0f, - 0x003d1d0f, 0x003d3d0f, 0x003d5d0f, 0x003d7d0f, - 0x003d9d0f, 0x003dbd0f, 0x003ddd0f, 0x003dfd0f, - 0x003e1d0f, 0x003e3d0f, 0x003e5d0f, 0x003e7d0f, - 0x003e9d0f, 0x003ebd0f, 0x003edd0f, 0x003efd0f, - 0x003f1d0f, 0x003f3d0f, 0x003f5d0f, 0x003f7d0f, - 0x003f9d0f, 0x003fbd0f, 0x003fdd0f, 0x003ffd0f, - 0x00401d0f, 0x00403d0f, 0x00405d0f, 0x00407d0f, - 0x00409d0f, 0x0040bd0f, 0x0040dd0f, 0x0040fd0f, - 0x00411d0f, 0x00413d0f, 0x00415d0f, 0x00417d0f, - 0x00419d0f, 0x0041bd0f, 0x0041dd0f, 0x0041fd0f, - 0x00421d0f, 0x00423d0f, 0x00425d0f, 0x00427d0f, - 0x00429d0f, 0x0042bd0f, 0x0042dd0f, 0x0042fd0f, - 0x00431d0f, 0x00433d0f, 0x00435d0f, 0x00437d0f, - 0x00439d0f, 0x0043bd0f, 0x0043dd0f, 0x0043fd0f, - 0x00441d0f, 0x00443d0f, 0x00445d0f, 0x00447d0f, - 0x00449d0f, 0x0044bd0f, 0x0044dd0f, 0x0044fd0f, - 0x00451d0f, 0x00453d0f, 0x00455d0f, 0x00457d0f, - 0x00459d0f, 0x0045bd0f, 0x0045dd0f, 0x0045fd0f, - 0x00461d0f, 0x00463d0f, 0x00465d0f, 0x00467d0f, - 0x00469d0f, 0x0046bd0f, 0x0046dd0f, 0x0046fd0f, - 0x00471d0f, 0x00473d0f, 0x00475d0f, 0x00477d0f, - 0x00479d0f, 0x0047bd0f, 0x0047dd0f, 0x0047fd0f, - 0x00481d0f, 0x00483d0f, 0x00485d0f, 0x00487d0f, - 0x00489d0f, 0x0048bd0f, 0x0048dd0f, 0x0048fd0f, - 0x00491d0f, 0x00493d0f, 0x00495d0f, 0x00497d0f, - 0x00499d0f, 0x0049bd0f, 0x0049dd0f, 0x0049fd0f, - 0x004a1d0f, 0x004a3d0f, 0x004a5d0f, 0x004a7d0f, - 0x004a9d0f, 0x004abd0f, 0x004add0f, 0x004afd0f, - 0x004b1d0f, 0x004b3d0f, 0x004b5d0f, 0x004b7d0f, - 0x004b9d0f, 0x004bbd0f, 0x004bdd0f, 0x004bfd0f, - 0x004c1d0f, 0x004c3d0f, 0x004c5d0f, 0x004c7d0f, - 0x004c9d0f, 0x004cbd0f, 0x004cdd0f, 0x004cfd0f, - 0x004d1d0f, 0x004d3d0f, 0x004d5d0f, 0x004d7d0f, - 0x004d9d0f, 0x004dbd0f, 0x004ddd0f, 0x004dfd0f, - 0x004e1d0f, 0x004e3d0f, 0x004e5d0f, 0x004e7d0f, - 0x004e9d0f, 0x004ebd0f, 0x004edd0f, 0x004efd0f, - 0x004f1d0f, 0x004f3d0f, 0x004f5d0f, 0x004f7d0f, - 0x004f9d0f, 0x004fbd0f, 0x004fdd0f, 0x004ffd0f, - 0x00501d0f, 0x00503d0f, 0x00505d0f, 0x00507d0f, - 0x00509d0f, 0x0050bd0f, 0x0050dd0f, 0x0050fd0f, - 0x00511d0f, 0x00513d0f, 0x00515d0f, 0x00517d0f, - 0x00519d0f, 0x0051bd0f, 0x0051dd0f, 0x0051fd0f, - 0x00521d0f, 0x00523d0f, 0x00525d0f, 0x00527d0f, - 0x00529d0f, 0x0052bd0f, 0x0052dd0f, 0x0052fd0f, - 0x00531d0f, 0x00533d0f, 0x00535d0f, 0x00537d0f, - 0x00539d0f, 0x0053bd0f, 0x0053dd0f, 0x0053fd0f, - 0x00541d0f, 0x00543d0f, 0x00545d0f, 0x00547d0f, - 0x00549d0f, 0x0054bd0f, 0x0054dd0f, 0x0054fd0f, - 0x00551d0f, 0x00553d0f, 0x00555d0f, 0x00557d0f, - 0x00559d0f, 0x0055bd0f, 0x0055dd0f, 0x0055fd0f, - 0x00561d0f, 0x00563d0f, 0x00565d0f, 0x00567d0f, - 0x00569d0f, 0x0056bd0f, 0x0056dd0f, 0x0056fd0f, - 0x00571d0f, 0x00573d0f, 0x00575d0f, 0x00577d0f, - 0x00579d0f, 0x0057bd0f, 0x0057dd0f, 0x0057fd0f, - 0x00581d0f, 0x00583d0f, 0x00585d0f, 0x00587d0f, - 0x00589d0f, 0x0058bd0f, 0x0058dd0f, 0x0058fd0f, - 0x00591d0f, 0x00593d0f, 0x00595d0f, 0x00597d0f, - 0x00599d0f, 0x0059bd0f, 0x0059dd0f, 0x0059fd0f, - 0x005a1d0f, 0x005a3d0f, 0x005a5d0f, 0x005a7d0f, - 0x005a9d0f, 0x005abd0f, 0x005add0f, 0x005afd0f, - 0x005b1d0f, 0x005b3d0f, 0x005b5d0f, 0x005b7d0f, - 0x005b9d0f, 0x005bbd0f, 0x005bdd0f, 0x005bfd0f, - 0x005c1d0f, 0x005c3d0f, 0x005c5d0f, 0x005c7d0f, - 0x005c9d0f, 0x005cbd0f, 0x005cdd0f, 0x005cfd0f, - 0x005d1d0f, 0x005d3d0f, 0x005d5d0f, 0x005d7d0f, - 0x005d9d0f, 0x005dbd0f, 0x005ddd0f, 0x005dfd0f, - 0x005e1d0f, 0x005e3d0f, 0x005e5d0f, 0x005e7d0f, - 0x005e9d0f, 0x005ebd0f, 0x005edd0f, 0x005efd0f, - 0x005f1d0f, 0x005f3d0f, 0x005f5d0f, 0x005f7d0f, - 0x005f9d0f, 0x005fbd0f, 0x005fdd0f, 0x005ffd0f, - 0x00601d0f, 0x00603d0f, 0x00605d0f, 0x00607d0f, - 0x00609d0f, 0x0060bd0f, 0x0060dd0f, 0x0060fd0f, - 0x00611d0f, 0x00613d0f, 0x00615d0f, 0x00617d0f, - 0x00619d0f, 0x0061bd0f, 0x0061dd0f, 0x0061fd0f, - 0x00621d0f, 0x00623d0f, 0x00625d0f, 0x00627d0f, - 0x00629d0f, 0x0062bd0f, 0x0062dd0f, 0x0062fd0f, - 0x00631d0f, 0x00633d0f, 0x00635d0f, 0x00637d0f, - 0x00639d0f, 0x0063bd0f, 0x0063dd0f, 0x0063fd0f, - 0x00641d0f, 0x00643d0f, 0x00645d0f, 0x00647d0f, - 0x00649d0f, 0x0064bd0f, 0x0064dd0f, 0x0064fd0f, - 0x00651d0f, 0x00653d0f, 0x00655d0f, 0x00657d0f, - 0x00659d0f, 0x0065bd0f, 0x0065dd0f, 0x0065fd0f, - 0x00661d0f, 0x00663d0f, 0x00665d0f, 0x00667d0f, - 0x00669d0f, 0x0066bd0f, 0x0066dd0f, 0x0066fd0f, - 0x00671d0f, 0x00673d0f, 0x00675d0f, 0x00677d0f, - 0x00679d0f, 0x0067bd0f, 0x0067dd0f, 0x0067fd0f, - 0x00681d0f, 0x00683d0f, 0x00685d0f, 0x00687d0f, - 0x00689d0f, 0x0068bd0f, 0x0068dd0f, 0x0068fd0f, - 0x00691d0f, 0x00693d0f, 0x00695d0f, 0x00697d0f, - 0x00699d0f, 0x0069bd0f, 0x0069dd0f, 0x0069fd0f, - 0x006a1d0f, 0x006a3d0f, 0x006a5d0f, 0x006a7d0f, - 0x006a9d0f, 0x006abd0f, 0x006add0f, 0x006afd0f, - 0x006b1d0f, 0x006b3d0f, 0x006b5d0f, 0x006b7d0f, - 0x006b9d0f, 0x006bbd0f, 0x006bdd0f, 0x006bfd0f, - 0x006c1d0f, 0x006c3d0f, 0x006c5d0f, 0x006c7d0f, - 0x006c9d0f, 0x006cbd0f, 0x006cdd0f, 0x006cfd0f, - 0x006d1d0f, 0x006d3d0f, 0x006d5d0f, 0x006d7d0f, - 0x006d9d0f, 0x006dbd0f, 0x006ddd0f, 0x006dfd0f, - 0x006e1d0f, 0x006e3d0f, 0x006e5d0f, 0x006e7d0f, - 0x006e9d0f, 0x006ebd0f, 0x006edd0f, 0x006efd0f, - 0x006f1d0f, 0x006f3d0f, 0x006f5d0f, 0x006f7d0f, - 0x006f9d0f, 0x006fbd0f, 0x006fdd0f, 0x006ffd0f, - 0x00701d0f, 0x00703d0f, 0x00705d0f, 0x00707d0f, - 0x00709d0f, 0x0070bd0f, 0x0070dd0f, 0x0070fd0f, - 0x00711d0f, 0x00713d0f, 0x00715d0f, 0x00717d0f, - 0x00719d0f, 0x0071bd0f, 0x0071dd0f, 0x0071fd0f, - 0x00721d0f, 0x00723d0f, 0x00725d0f, 0x00727d0f, - 0x00729d0f, 0x0072bd0f, 0x0072dd0f, 0x0072fd0f, - 0x00731d0f, 0x00733d0f, 0x00735d0f, 0x00737d0f, - 0x00739d0f, 0x0073bd0f, 0x0073dd0f, 0x0073fd0f, - 0x00741d0f, 0x00743d0f, 0x00745d0f, 0x00747d0f, - 0x00749d0f, 0x0074bd0f, 0x0074dd0f, 0x0074fd0f, - 0x00751d0f, 0x00753d0f, 0x00755d0f, 0x00757d0f, - 0x00759d0f, 0x0075bd0f, 0x0075dd0f, 0x0075fd0f, - 0x00761d0f, 0x00763d0f, 0x00765d0f, 0x00767d0f, - 0x00769d0f, 0x0076bd0f, 0x0076dd0f, 0x0076fd0f, - 0x00771d0f, 0x00773d0f, 0x00775d0f, 0x00777d0f, - 0x00779d0f, 0x0077bd0f, 0x0077dd0f, 0x0077fd0f, - 0x00781d0f, 0x00783d0f, 0x00785d0f, 0x00787d0f, - 0x00789d0f, 0x0078bd0f, 0x0078dd0f, 0x0078fd0f, - 0x00791d0f, 0x00793d0f, 0x00795d0f, 0x00797d0f, - 0x00799d0f, 0x0079bd0f, 0x0079dd0f, 0x0079fd0f, - 0x007a1d0f, 0x007a3d0f, 0x007a5d0f, 0x007a7d0f, - 0x007a9d0f, 0x007abd0f, 0x007add0f, 0x007afd0f, - 0x007b1d0f, 0x007b3d0f, 0x007b5d0f, 0x007b7d0f, - 0x007b9d0f, 0x007bbd0f, 0x007bdd0f, 0x007bfd0f, - 0x007c1d0f, 0x007c3d0f, 0x007c5d0f, 0x007c7d0f, - 0x007c9d0f, 0x007cbd0f, 0x007cdd0f, 0x007cfd0f, - 0x007d1d0f, 0x007d3d0f, 0x007d5d0f, 0x007d7d0f, - 0x007d9d0f, 0x007dbd0f, 0x007ddd0f, 0x007dfd0f, - 0x007e1d0f, 0x007e3d0f, 0x007e5d0f, 0x007e7d0f, - 0x007e9d0f, 0x007ebd0f, 0x007edd0f, 0x007efd0f, - 0x007f1d0f, 0x007f3d0f, 0x007f5d0f, 0x007f7d0f, - 0x007f9d0f, 0x007fbd0f, 0x007fdd0f, 0x007ffd0f, - 0x00000310, 0x00002310, 0x00004310, 0x00006310, - 0x00008310, 0x0000a310, 0x0000c310, 0x0000e310, - 0x00010310, 0x00012310, 0x00014310, 0x00016310, - 0x00018310, 0x0001a310, 0x0001c310, 0x0001e310, - 0x00020310, 0x00022310, 0x00024310, 0x00026310, - 0x00028310, 0x0002a310, 0x0002c310, 0x0002e310, - 0x00030310, 0x00032310, 0x00034310, 0x00036310, - 0x00038310, 0x0003a310, 0x0003c310, 0x0003e310, - 0x00040310, 0x00042310, 0x00044310, 0x00046310, - 0x00048310, 0x0004a310, 0x0004c310, 0x0004e310, - 0x00050310, 0x00052310, 0x00054310, 0x00056310, - 0x00058310, 0x0005a310, 0x0005c310, 0x0005e310, - 0x00060310, 0x00062310, 0x00064310, 0x00066310, - 0x00068310, 0x0006a310, 0x0006c310, 0x0006e310, - 0x00070310, 0x00072310, 0x00074310, 0x00076310, - 0x00078310, 0x0007a310, 0x0007c310, 0x0007e310, - 0x00080310, 0x00082310, 0x00084310, 0x00086310, - 0x00088310, 0x0008a310, 0x0008c310, 0x0008e310, - 0x00090310, 0x00092310, 0x00094310, 0x00096310, - 0x00098310, 0x0009a310, 0x0009c310, 0x0009e310, - 0x000a0310, 0x000a2310, 0x000a4310, 0x000a6310, - 0x000a8310, 0x000aa310, 0x000ac310, 0x000ae310, - 0x000b0310, 0x000b2310, 0x000b4310, 0x000b6310, - 0x000b8310, 0x000ba310, 0x000bc310, 0x000be310, - 0x000c0310, 0x000c2310, 0x000c4310, 0x000c6310, - 0x000c8310, 0x000ca310, 0x000cc310, 0x000ce310, - 0x000d0310, 0x000d2310, 0x000d4310, 0x000d6310, - 0x000d8310, 0x000da310, 0x000dc310, 0x000de310, - 0x000e0310, 0x000e2310, 0x000e4310, 0x000e6310, - 0x000e8310, 0x000ea310, 0x000ec310, 0x000ee310, - 0x000f0310, 0x000f2310, 0x000f4310, 0x000f6310, - 0x000f8310, 0x000fa310, 0x000fc310, 0x000fe310, - 0x00100310, 0x00102310, 0x00104310, 0x00106310, - 0x00108310, 0x0010a310, 0x0010c310, 0x0010e310, - 0x00110310, 0x00112310, 0x00114310, 0x00116310, - 0x00118310, 0x0011a310, 0x0011c310, 0x0011e310, - 0x00120310, 0x00122310, 0x00124310, 0x00126310, - 0x00128310, 0x0012a310, 0x0012c310, 0x0012e310, - 0x00130310, 0x00132310, 0x00134310, 0x00136310, - 0x00138310, 0x0013a310, 0x0013c310, 0x0013e310, - 0x00140310, 0x00142310, 0x00144310, 0x00146310, - 0x00148310, 0x0014a310, 0x0014c310, 0x0014e310, - 0x00150310, 0x00152310, 0x00154310, 0x00156310, - 0x00158310, 0x0015a310, 0x0015c310, 0x0015e310, - 0x00160310, 0x00162310, 0x00164310, 0x00166310, - 0x00168310, 0x0016a310, 0x0016c310, 0x0016e310, - 0x00170310, 0x00172310, 0x00174310, 0x00176310, - 0x00178310, 0x0017a310, 0x0017c310, 0x0017e310, - 0x00180310, 0x00182310, 0x00184310, 0x00186310, - 0x00188310, 0x0018a310, 0x0018c310, 0x0018e310, - 0x00190310, 0x00192310, 0x00194310, 0x00196310, - 0x00198310, 0x0019a310, 0x0019c310, 0x0019e310, - 0x001a0310, 0x001a2310, 0x001a4310, 0x001a6310, - 0x001a8310, 0x001aa310, 0x001ac310, 0x001ae310, - 0x001b0310, 0x001b2310, 0x001b4310, 0x001b6310, - 0x001b8310, 0x001ba310, 0x001bc310, 0x001be310, - 0x001c0310, 0x001c2310, 0x001c4310, 0x001c6310, - 0x001c8310, 0x001ca310, 0x001cc310, 0x001ce310, - 0x001d0310, 0x001d2310, 0x001d4310, 0x001d6310, - 0x001d8310, 0x001da310, 0x001dc310, 0x001de310, - 0x001e0310, 0x001e2310, 0x001e4310, 0x001e6310, - 0x001e8310, 0x001ea310, 0x001ec310, 0x001ee310, - 0x001f0310, 0x001f2310, 0x001f4310, 0x001f6310, - 0x001f8310, 0x001fa310, 0x001fc310, 0x001fe310, - 0x00200310, 0x00202310, 0x00204310, 0x00206310, - 0x00208310, 0x0020a310, 0x0020c310, 0x0020e310, - 0x00210310, 0x00212310, 0x00214310, 0x00216310, - 0x00218310, 0x0021a310, 0x0021c310, 0x0021e310, - 0x00220310, 0x00222310, 0x00224310, 0x00226310, - 0x00228310, 0x0022a310, 0x0022c310, 0x0022e310, - 0x00230310, 0x00232310, 0x00234310, 0x00236310, - 0x00238310, 0x0023a310, 0x0023c310, 0x0023e310, - 0x00240310, 0x00242310, 0x00244310, 0x00246310, - 0x00248310, 0x0024a310, 0x0024c310, 0x0024e310, - 0x00250310, 0x00252310, 0x00254310, 0x00256310, - 0x00258310, 0x0025a310, 0x0025c310, 0x0025e310, - 0x00260310, 0x00262310, 0x00264310, 0x00266310, - 0x00268310, 0x0026a310, 0x0026c310, 0x0026e310, - 0x00270310, 0x00272310, 0x00274310, 0x00276310, - 0x00278310, 0x0027a310, 0x0027c310, 0x0027e310, - 0x00280310, 0x00282310, 0x00284310, 0x00286310, - 0x00288310, 0x0028a310, 0x0028c310, 0x0028e310, - 0x00290310, 0x00292310, 0x00294310, 0x00296310, - 0x00298310, 0x0029a310, 0x0029c310, 0x0029e310, - 0x002a0310, 0x002a2310, 0x002a4310, 0x002a6310, - 0x002a8310, 0x002aa310, 0x002ac310, 0x002ae310, - 0x002b0310, 0x002b2310, 0x002b4310, 0x002b6310, - 0x002b8310, 0x002ba310, 0x002bc310, 0x002be310, - 0x002c0310, 0x002c2310, 0x002c4310, 0x002c6310, - 0x002c8310, 0x002ca310, 0x002cc310, 0x002ce310, - 0x002d0310, 0x002d2310, 0x002d4310, 0x002d6310, - 0x002d8310, 0x002da310, 0x002dc310, 0x002de310, - 0x002e0310, 0x002e2310, 0x002e4310, 0x002e6310, - 0x002e8310, 0x002ea310, 0x002ec310, 0x002ee310, - 0x002f0310, 0x002f2310, 0x002f4310, 0x002f6310, - 0x002f8310, 0x002fa310, 0x002fc310, 0x002fe310, - 0x00300310, 0x00302310, 0x00304310, 0x00306310, - 0x00308310, 0x0030a310, 0x0030c310, 0x0030e310, - 0x00310310, 0x00312310, 0x00314310, 0x00316310, - 0x00318310, 0x0031a310, 0x0031c310, 0x0031e310, - 0x00320310, 0x00322310, 0x00324310, 0x00326310, - 0x00328310, 0x0032a310, 0x0032c310, 0x0032e310, - 0x00330310, 0x00332310, 0x00334310, 0x00336310, - 0x00338310, 0x0033a310, 0x0033c310, 0x0033e310, - 0x00340310, 0x00342310, 0x00344310, 0x00346310, - 0x00348310, 0x0034a310, 0x0034c310, 0x0034e310, - 0x00350310, 0x00352310, 0x00354310, 0x00356310, - 0x00358310, 0x0035a310, 0x0035c310, 0x0035e310, - 0x00360310, 0x00362310, 0x00364310, 0x00366310, - 0x00368310, 0x0036a310, 0x0036c310, 0x0036e310, - 0x00370310, 0x00372310, 0x00374310, 0x00376310, - 0x00378310, 0x0037a310, 0x0037c310, 0x0037e310, - 0x00380310, 0x00382310, 0x00384310, 0x00386310, - 0x00388310, 0x0038a310, 0x0038c310, 0x0038e310, - 0x00390310, 0x00392310, 0x00394310, 0x00396310, - 0x00398310, 0x0039a310, 0x0039c310, 0x0039e310, - 0x003a0310, 0x003a2310, 0x003a4310, 0x003a6310, - 0x003a8310, 0x003aa310, 0x003ac310, 0x003ae310, - 0x003b0310, 0x003b2310, 0x003b4310, 0x003b6310, - 0x003b8310, 0x003ba310, 0x003bc310, 0x003be310, - 0x003c0310, 0x003c2310, 0x003c4310, 0x003c6310, - 0x003c8310, 0x003ca310, 0x003cc310, 0x003ce310, - 0x003d0310, 0x003d2310, 0x003d4310, 0x003d6310, - 0x003d8310, 0x003da310, 0x003dc310, 0x003de310, - 0x003e0310, 0x003e2310, 0x003e4310, 0x003e6310, - 0x003e8310, 0x003ea310, 0x003ec310, 0x003ee310, - 0x003f0310, 0x003f2310, 0x003f4310, 0x003f6310, - 0x003f8310, 0x003fa310, 0x003fc310, 0x003fe310, - 0x00400310, 0x00402310, 0x00404310, 0x00406310, - 0x00408310, 0x0040a310, 0x0040c310, 0x0040e310, - 0x00410310, 0x00412310, 0x00414310, 0x00416310, - 0x00418310, 0x0041a310, 0x0041c310, 0x0041e310, - 0x00420310, 0x00422310, 0x00424310, 0x00426310, - 0x00428310, 0x0042a310, 0x0042c310, 0x0042e310, - 0x00430310, 0x00432310, 0x00434310, 0x00436310, - 0x00438310, 0x0043a310, 0x0043c310, 0x0043e310, - 0x00440310, 0x00442310, 0x00444310, 0x00446310, - 0x00448310, 0x0044a310, 0x0044c310, 0x0044e310, - 0x00450310, 0x00452310, 0x00454310, 0x00456310, - 0x00458310, 0x0045a310, 0x0045c310, 0x0045e310, - 0x00460310, 0x00462310, 0x00464310, 0x00466310, - 0x00468310, 0x0046a310, 0x0046c310, 0x0046e310, - 0x00470310, 0x00472310, 0x00474310, 0x00476310, - 0x00478310, 0x0047a310, 0x0047c310, 0x0047e310, - 0x00480310, 0x00482310, 0x00484310, 0x00486310, - 0x00488310, 0x0048a310, 0x0048c310, 0x0048e310, - 0x00490310, 0x00492310, 0x00494310, 0x00496310, - 0x00498310, 0x0049a310, 0x0049c310, 0x0049e310, - 0x004a0310, 0x004a2310, 0x004a4310, 0x004a6310, - 0x004a8310, 0x004aa310, 0x004ac310, 0x004ae310, - 0x004b0310, 0x004b2310, 0x004b4310, 0x004b6310, - 0x004b8310, 0x004ba310, 0x004bc310, 0x004be310, - 0x004c0310, 0x004c2310, 0x004c4310, 0x004c6310, - 0x004c8310, 0x004ca310, 0x004cc310, 0x004ce310, - 0x004d0310, 0x004d2310, 0x004d4310, 0x004d6310, - 0x004d8310, 0x004da310, 0x004dc310, 0x004de310, - 0x004e0310, 0x004e2310, 0x004e4310, 0x004e6310, - 0x004e8310, 0x004ea310, 0x004ec310, 0x004ee310, - 0x004f0310, 0x004f2310, 0x004f4310, 0x004f6310, - 0x004f8310, 0x004fa310, 0x004fc310, 0x004fe310, - 0x00500310, 0x00502310, 0x00504310, 0x00506310, - 0x00508310, 0x0050a310, 0x0050c310, 0x0050e310, - 0x00510310, 0x00512310, 0x00514310, 0x00516310, - 0x00518310, 0x0051a310, 0x0051c310, 0x0051e310, - 0x00520310, 0x00522310, 0x00524310, 0x00526310, - 0x00528310, 0x0052a310, 0x0052c310, 0x0052e310, - 0x00530310, 0x00532310, 0x00534310, 0x00536310, - 0x00538310, 0x0053a310, 0x0053c310, 0x0053e310, - 0x00540310, 0x00542310, 0x00544310, 0x00546310, - 0x00548310, 0x0054a310, 0x0054c310, 0x0054e310, - 0x00550310, 0x00552310, 0x00554310, 0x00556310, - 0x00558310, 0x0055a310, 0x0055c310, 0x0055e310, - 0x00560310, 0x00562310, 0x00564310, 0x00566310, - 0x00568310, 0x0056a310, 0x0056c310, 0x0056e310, - 0x00570310, 0x00572310, 0x00574310, 0x00576310, - 0x00578310, 0x0057a310, 0x0057c310, 0x0057e310, - 0x00580310, 0x00582310, 0x00584310, 0x00586310, - 0x00588310, 0x0058a310, 0x0058c310, 0x0058e310, - 0x00590310, 0x00592310, 0x00594310, 0x00596310, - 0x00598310, 0x0059a310, 0x0059c310, 0x0059e310, - 0x005a0310, 0x005a2310, 0x005a4310, 0x005a6310, - 0x005a8310, 0x005aa310, 0x005ac310, 0x005ae310, - 0x005b0310, 0x005b2310, 0x005b4310, 0x005b6310, - 0x005b8310, 0x005ba310, 0x005bc310, 0x005be310, - 0x005c0310, 0x005c2310, 0x005c4310, 0x005c6310, - 0x005c8310, 0x005ca310, 0x005cc310, 0x005ce310, - 0x005d0310, 0x005d2310, 0x005d4310, 0x005d6310, - 0x005d8310, 0x005da310, 0x005dc310, 0x005de310, - 0x005e0310, 0x005e2310, 0x005e4310, 0x005e6310, - 0x005e8310, 0x005ea310, 0x005ec310, 0x005ee310, - 0x005f0310, 0x005f2310, 0x005f4310, 0x005f6310, - 0x005f8310, 0x005fa310, 0x005fc310, 0x005fe310, - 0x00600310, 0x00602310, 0x00604310, 0x00606310, - 0x00608310, 0x0060a310, 0x0060c310, 0x0060e310, - 0x00610310, 0x00612310, 0x00614310, 0x00616310, - 0x00618310, 0x0061a310, 0x0061c310, 0x0061e310, - 0x00620310, 0x00622310, 0x00624310, 0x00626310, - 0x00628310, 0x0062a310, 0x0062c310, 0x0062e310, - 0x00630310, 0x00632310, 0x00634310, 0x00636310, - 0x00638310, 0x0063a310, 0x0063c310, 0x0063e310, - 0x00640310, 0x00642310, 0x00644310, 0x00646310, - 0x00648310, 0x0064a310, 0x0064c310, 0x0064e310, - 0x00650310, 0x00652310, 0x00654310, 0x00656310, - 0x00658310, 0x0065a310, 0x0065c310, 0x0065e310, - 0x00660310, 0x00662310, 0x00664310, 0x00666310, - 0x00668310, 0x0066a310, 0x0066c310, 0x0066e310, - 0x00670310, 0x00672310, 0x00674310, 0x00676310, - 0x00678310, 0x0067a310, 0x0067c310, 0x0067e310, - 0x00680310, 0x00682310, 0x00684310, 0x00686310, - 0x00688310, 0x0068a310, 0x0068c310, 0x0068e310, - 0x00690310, 0x00692310, 0x00694310, 0x00696310, - 0x00698310, 0x0069a310, 0x0069c310, 0x0069e310, - 0x006a0310, 0x006a2310, 0x006a4310, 0x006a6310, - 0x006a8310, 0x006aa310, 0x006ac310, 0x006ae310, - 0x006b0310, 0x006b2310, 0x006b4310, 0x006b6310, - 0x006b8310, 0x006ba310, 0x006bc310, 0x006be310, - 0x006c0310, 0x006c2310, 0x006c4310, 0x006c6310, - 0x006c8310, 0x006ca310, 0x006cc310, 0x006ce310, - 0x006d0310, 0x006d2310, 0x006d4310, 0x006d6310, - 0x006d8310, 0x006da310, 0x006dc310, 0x006de310, - 0x006e0310, 0x006e2310, 0x006e4310, 0x006e6310, - 0x006e8310, 0x006ea310, 0x006ec310, 0x006ee310, - 0x006f0310, 0x006f2310, 0x006f4310, 0x006f6310, - 0x006f8310, 0x006fa310, 0x006fc310, 0x006fe310, - 0x00700310, 0x00702310, 0x00704310, 0x00706310, - 0x00708310, 0x0070a310, 0x0070c310, 0x0070e310, - 0x00710310, 0x00712310, 0x00714310, 0x00716310, - 0x00718310, 0x0071a310, 0x0071c310, 0x0071e310, - 0x00720310, 0x00722310, 0x00724310, 0x00726310, - 0x00728310, 0x0072a310, 0x0072c310, 0x0072e310, - 0x00730310, 0x00732310, 0x00734310, 0x00736310, - 0x00738310, 0x0073a310, 0x0073c310, 0x0073e310, - 0x00740310, 0x00742310, 0x00744310, 0x00746310, - 0x00748310, 0x0074a310, 0x0074c310, 0x0074e310, - 0x00750310, 0x00752310, 0x00754310, 0x00756310, - 0x00758310, 0x0075a310, 0x0075c310, 0x0075e310, - 0x00760310, 0x00762310, 0x00764310, 0x00766310, - 0x00768310, 0x0076a310, 0x0076c310, 0x0076e310, - 0x00770310, 0x00772310, 0x00774310, 0x00776310, - 0x00778310, 0x0077a310, 0x0077c310, 0x0077e310, - 0x00780310, 0x00782310, 0x00784310, 0x00786310, - 0x00788310, 0x0078a310, 0x0078c310, 0x0078e310, - 0x00790310, 0x00792310, 0x00794310, 0x00796310, - 0x00798310, 0x0079a310, 0x0079c310, 0x0079e310, - 0x007a0310, 0x007a2310, 0x007a4310, 0x007a6310, - 0x007a8310, 0x007aa310, 0x007ac310, 0x007ae310, - 0x007b0310, 0x007b2310, 0x007b4310, 0x007b6310, - 0x007b8310, 0x007ba310, 0x007bc310, 0x007be310, - 0x007c0310, 0x007c2310, 0x007c4310, 0x007c6310, - 0x007c8310, 0x007ca310, 0x007cc310, 0x007ce310, - 0x007d0310, 0x007d2310, 0x007d4310, 0x007d6310, - 0x007d8310, 0x007da310, 0x007dc310, 0x007de310, - 0x007e0310, 0x007e2310, 0x007e4310, 0x007e6310, - 0x007e8310, 0x007ea310, 0x007ec310, 0x007ee310, - 0x007f0310, 0x007f2310, 0x007f4310, 0x007f6310, - 0x007f8310, 0x007fa310, 0x007fc310, 0x007fe310, - 0x00800310, 0x00802310, 0x00804310, 0x00806310, - 0x00808310, 0x0080a310, 0x0080c310, 0x0080e310, - 0x00810310, 0x00812310, 0x00814310, 0x00816310, - 0x00818310, 0x0081a310, 0x0081c310, 0x0081e310, - 0x00820310, 0x00822310, 0x00824310, 0x00826310, - 0x00828310, 0x0082a310, 0x0082c310, 0x0082e310, - 0x00830310, 0x00832310, 0x00834310, 0x00836310, - 0x00838310, 0x0083a310, 0x0083c310, 0x0083e310, - 0x00840310, 0x00842310, 0x00844310, 0x00846310, - 0x00848310, 0x0084a310, 0x0084c310, 0x0084e310, - 0x00850310, 0x00852310, 0x00854310, 0x00856310, - 0x00858310, 0x0085a310, 0x0085c310, 0x0085e310, - 0x00860310, 0x00862310, 0x00864310, 0x00866310, - 0x00868310, 0x0086a310, 0x0086c310, 0x0086e310, - 0x00870310, 0x00872310, 0x00874310, 0x00876310, - 0x00878310, 0x0087a310, 0x0087c310, 0x0087e310, - 0x00880310, 0x00882310, 0x00884310, 0x00886310, - 0x00888310, 0x0088a310, 0x0088c310, 0x0088e310, - 0x00890310, 0x00892310, 0x00894310, 0x00896310, - 0x00898310, 0x0089a310, 0x0089c310, 0x0089e310, - 0x008a0310, 0x008a2310, 0x008a4310, 0x008a6310, - 0x008a8310, 0x008aa310, 0x008ac310, 0x008ae310, - 0x008b0310, 0x008b2310, 0x008b4310, 0x008b6310, - 0x008b8310, 0x008ba310, 0x008bc310, 0x008be310, - 0x008c0310, 0x008c2310, 0x008c4310, 0x008c6310, - 0x008c8310, 0x008ca310, 0x008cc310, 0x008ce310, - 0x008d0310, 0x008d2310, 0x008d4310, 0x008d6310, - 0x008d8310, 0x008da310, 0x008dc310, 0x008de310, - 0x008e0310, 0x008e2310, 0x008e4310, 0x008e6310, - 0x008e8310, 0x008ea310, 0x008ec310, 0x008ee310, - 0x008f0310, 0x008f2310, 0x008f4310, 0x008f6310, - 0x008f8310, 0x008fa310, 0x008fc310, 0x008fe310, - 0x00900310, 0x00902310, 0x00904310, 0x00906310, - 0x00908310, 0x0090a310, 0x0090c310, 0x0090e310, - 0x00910310, 0x00912310, 0x00914310, 0x00916310, - 0x00918310, 0x0091a310, 0x0091c310, 0x0091e310, - 0x00920310, 0x00922310, 0x00924310, 0x00926310, - 0x00928310, 0x0092a310, 0x0092c310, 0x0092e310, - 0x00930310, 0x00932310, 0x00934310, 0x00936310, - 0x00938310, 0x0093a310, 0x0093c310, 0x0093e310, - 0x00940310, 0x00942310, 0x00944310, 0x00946310, - 0x00948310, 0x0094a310, 0x0094c310, 0x0094e310, - 0x00950310, 0x00952310, 0x00954310, 0x00956310, - 0x00958310, 0x0095a310, 0x0095c310, 0x0095e310, - 0x00960310, 0x00962310, 0x00964310, 0x00966310, - 0x00968310, 0x0096a310, 0x0096c310, 0x0096e310, - 0x00970310, 0x00972310, 0x00974310, 0x00976310, - 0x00978310, 0x0097a310, 0x0097c310, 0x0097e310, - 0x00980310, 0x00982310, 0x00984310, 0x00986310, - 0x00988310, 0x0098a310, 0x0098c310, 0x0098e310, - 0x00990310, 0x00992310, 0x00994310, 0x00996310, - 0x00998310, 0x0099a310, 0x0099c310, 0x0099e310, - 0x009a0310, 0x009a2310, 0x009a4310, 0x009a6310, - 0x009a8310, 0x009aa310, 0x009ac310, 0x009ae310, - 0x009b0310, 0x009b2310, 0x009b4310, 0x009b6310, - 0x009b8310, 0x009ba310, 0x009bc310, 0x009be310, - 0x009c0310, 0x009c2310, 0x009c4310, 0x009c6310, - 0x009c8310, 0x009ca310, 0x009cc310, 0x009ce310, - 0x009d0310, 0x009d2310, 0x009d4310, 0x009d6310, - 0x009d8310, 0x009da310, 0x009dc310, 0x009de310, - 0x009e0310, 0x009e2310, 0x009e4310, 0x009e6310, - 0x009e8310, 0x009ea310, 0x009ec310, 0x009ee310, - 0x009f0310, 0x009f2310, 0x009f4310, 0x009f6310, - 0x009f8310, 0x009fa310, 0x009fc310, 0x009fe310, - 0x00a00310, 0x00a02310, 0x00a04310, 0x00a06310, - 0x00a08310, 0x00a0a310, 0x00a0c310, 0x00a0e310, - 0x00a10310, 0x00a12310, 0x00a14310, 0x00a16310, - 0x00a18310, 0x00a1a310, 0x00a1c310, 0x00a1e310, - 0x00a20310, 0x00a22310, 0x00a24310, 0x00a26310, - 0x00a28310, 0x00a2a310, 0x00a2c310, 0x00a2e310, - 0x00a30310, 0x00a32310, 0x00a34310, 0x00a36310, - 0x00a38310, 0x00a3a310, 0x00a3c310, 0x00a3e310, - 0x00a40310, 0x00a42310, 0x00a44310, 0x00a46310, - 0x00a48310, 0x00a4a310, 0x00a4c310, 0x00a4e310, - 0x00a50310, 0x00a52310, 0x00a54310, 0x00a56310, - 0x00a58310, 0x00a5a310, 0x00a5c310, 0x00a5e310, - 0x00a60310, 0x00a62310, 0x00a64310, 0x00a66310, - 0x00a68310, 0x00a6a310, 0x00a6c310, 0x00a6e310, - 0x00a70310, 0x00a72310, 0x00a74310, 0x00a76310, - 0x00a78310, 0x00a7a310, 0x00a7c310, 0x00a7e310, - 0x00a80310, 0x00a82310, 0x00a84310, 0x00a86310, - 0x00a88310, 0x00a8a310, 0x00a8c310, 0x00a8e310, - 0x00a90310, 0x00a92310, 0x00a94310, 0x00a96310, - 0x00a98310, 0x00a9a310, 0x00a9c310, 0x00a9e310, - 0x00aa0310, 0x00aa2310, 0x00aa4310, 0x00aa6310, - 0x00aa8310, 0x00aaa310, 0x00aac310, 0x00aae310, - 0x00ab0310, 0x00ab2310, 0x00ab4310, 0x00ab6310, - 0x00ab8310, 0x00aba310, 0x00abc310, 0x00abe310, - 0x00ac0310, 0x00ac2310, 0x00ac4310, 0x00ac6310, - 0x00ac8310, 0x00aca310, 0x00acc310, 0x00ace310, - 0x00ad0310, 0x00ad2310, 0x00ad4310, 0x00ad6310, - 0x00ad8310, 0x00ada310, 0x00adc310, 0x00ade310, - 0x00ae0310, 0x00ae2310, 0x00ae4310, 0x00ae6310, - 0x00ae8310, 0x00aea310, 0x00aec310, 0x00aee310, - 0x00af0310, 0x00af2310, 0x00af4310, 0x00af6310, - 0x00af8310, 0x00afa310, 0x00afc310, 0x00afe310, - 0x00b00310, 0x00b02310, 0x00b04310, 0x00b06310, - 0x00b08310, 0x00b0a310, 0x00b0c310, 0x00b0e310, - 0x00b10310, 0x00b12310, 0x00b14310, 0x00b16310, - 0x00b18310, 0x00b1a310, 0x00b1c310, 0x00b1e310, - 0x00b20310, 0x00b22310, 0x00b24310, 0x00b26310, - 0x00b28310, 0x00b2a310, 0x00b2c310, 0x00b2e310, - 0x00b30310, 0x00b32310, 0x00b34310, 0x00b36310, - 0x00b38310, 0x00b3a310, 0x00b3c310, 0x00b3e310, - 0x00b40310, 0x00b42310, 0x00b44310, 0x00b46310, - 0x00b48310, 0x00b4a310, 0x00b4c310, 0x00b4e310, - 0x00b50310, 0x00b52310, 0x00b54310, 0x00b56310, - 0x00b58310, 0x00b5a310, 0x00b5c310, 0x00b5e310, - 0x00b60310, 0x00b62310, 0x00b64310, 0x00b66310, - 0x00b68310, 0x00b6a310, 0x00b6c310, 0x00b6e310, - 0x00b70310, 0x00b72310, 0x00b74310, 0x00b76310, - 0x00b78310, 0x00b7a310, 0x00b7c310, 0x00b7e310, - 0x00b80310, 0x00b82310, 0x00b84310, 0x00b86310, - 0x00b88310, 0x00b8a310, 0x00b8c310, 0x00b8e310, - 0x00b90310, 0x00b92310, 0x00b94310, 0x00b96310, - 0x00b98310, 0x00b9a310, 0x00b9c310, 0x00b9e310, - 0x00ba0310, 0x00ba2310, 0x00ba4310, 0x00ba6310, - 0x00ba8310, 0x00baa310, 0x00bac310, 0x00bae310, - 0x00bb0310, 0x00bb2310, 0x00bb4310, 0x00bb6310, - 0x00bb8310, 0x00bba310, 0x00bbc310, 0x00bbe310, - 0x00bc0310, 0x00bc2310, 0x00bc4310, 0x00bc6310, - 0x00bc8310, 0x00bca310, 0x00bcc310, 0x00bce310, - 0x00bd0310, 0x00bd2310, 0x00bd4310, 0x00bd6310, - 0x00bd8310, 0x00bda310, 0x00bdc310, 0x00bde310, - 0x00be0310, 0x00be2310, 0x00be4310, 0x00be6310, - 0x00be8310, 0x00bea310, 0x00bec310, 0x00bee310, - 0x00bf0310, 0x00bf2310, 0x00bf4310, 0x00bf6310, - 0x00bf8310, 0x00bfa310, 0x00bfc310, 0x00bfe310, - 0x00c00310, 0x00c02310, 0x00c04310, 0x00c06310, - 0x00c08310, 0x00c0a310, 0x00c0c310, 0x00c0e310, - 0x00c10310, 0x00c12310, 0x00c14310, 0x00c16310, - 0x00c18310, 0x00c1a310, 0x00c1c310, 0x00c1e310, - 0x00c20310, 0x00c22310, 0x00c24310, 0x00c26310, - 0x00c28310, 0x00c2a310, 0x00c2c310, 0x00c2e310, - 0x00c30310, 0x00c32310, 0x00c34310, 0x00c36310, - 0x00c38310, 0x00c3a310, 0x00c3c310, 0x00c3e310, - 0x00c40310, 0x00c42310, 0x00c44310, 0x00c46310, - 0x00c48310, 0x00c4a310, 0x00c4c310, 0x00c4e310, - 0x00c50310, 0x00c52310, 0x00c54310, 0x00c56310, - 0x00c58310, 0x00c5a310, 0x00c5c310, 0x00c5e310, - 0x00c60310, 0x00c62310, 0x00c64310, 0x00c66310, - 0x00c68310, 0x00c6a310, 0x00c6c310, 0x00c6e310, - 0x00c70310, 0x00c72310, 0x00c74310, 0x00c76310, - 0x00c78310, 0x00c7a310, 0x00c7c310, 0x00c7e310, - 0x00c80310, 0x00c82310, 0x00c84310, 0x00c86310, - 0x00c88310, 0x00c8a310, 0x00c8c310, 0x00c8e310, - 0x00c90310, 0x00c92310, 0x00c94310, 0x00c96310, - 0x00c98310, 0x00c9a310, 0x00c9c310, 0x00c9e310, - 0x00ca0310, 0x00ca2310, 0x00ca4310, 0x00ca6310, - 0x00ca8310, 0x00caa310, 0x00cac310, 0x00cae310, - 0x00cb0310, 0x00cb2310, 0x00cb4310, 0x00cb6310, - 0x00cb8310, 0x00cba310, 0x00cbc310, 0x00cbe310, - 0x00cc0310, 0x00cc2310, 0x00cc4310, 0x00cc6310, - 0x00cc8310, 0x00cca310, 0x00ccc310, 0x00cce310, - 0x00cd0310, 0x00cd2310, 0x00cd4310, 0x00cd6310, - 0x00cd8310, 0x00cda310, 0x00cdc310, 0x00cde310, - 0x00ce0310, 0x00ce2310, 0x00ce4310, 0x00ce6310, - 0x00ce8310, 0x00cea310, 0x00cec310, 0x00cee310, - 0x00cf0310, 0x00cf2310, 0x00cf4310, 0x00cf6310, - 0x00cf8310, 0x00cfa310, 0x00cfc310, 0x00cfe310, - 0x00d00310, 0x00d02310, 0x00d04310, 0x00d06310, - 0x00d08310, 0x00d0a310, 0x00d0c310, 0x00d0e310, - 0x00d10310, 0x00d12310, 0x00d14310, 0x00d16310, - 0x00d18310, 0x00d1a310, 0x00d1c310, 0x00d1e310, - 0x00d20310, 0x00d22310, 0x00d24310, 0x00d26310, - 0x00d28310, 0x00d2a310, 0x00d2c310, 0x00d2e310, - 0x00d30310, 0x00d32310, 0x00d34310, 0x00d36310, - 0x00d38310, 0x00d3a310, 0x00d3c310, 0x00d3e310, - 0x00d40310, 0x00d42310, 0x00d44310, 0x00d46310, - 0x00d48310, 0x00d4a310, 0x00d4c310, 0x00d4e310, - 0x00d50310, 0x00d52310, 0x00d54310, 0x00d56310, - 0x00d58310, 0x00d5a310, 0x00d5c310, 0x00d5e310, - 0x00d60310, 0x00d62310, 0x00d64310, 0x00d66310, - 0x00d68310, 0x00d6a310, 0x00d6c310, 0x00d6e310, - 0x00d70310, 0x00d72310, 0x00d74310, 0x00d76310, - 0x00d78310, 0x00d7a310, 0x00d7c310, 0x00d7e310, - 0x00d80310, 0x00d82310, 0x00d84310, 0x00d86310, - 0x00d88310, 0x00d8a310, 0x00d8c310, 0x00d8e310, - 0x00d90310, 0x00d92310, 0x00d94310, 0x00d96310, - 0x00d98310, 0x00d9a310, 0x00d9c310, 0x00d9e310, - 0x00da0310, 0x00da2310, 0x00da4310, 0x00da6310, - 0x00da8310, 0x00daa310, 0x00dac310, 0x00dae310, - 0x00db0310, 0x00db2310, 0x00db4310, 0x00db6310, - 0x00db8310, 0x00dba310, 0x00dbc310, 0x00dbe310, - 0x00dc0310, 0x00dc2310, 0x00dc4310, 0x00dc6310, - 0x00dc8310, 0x00dca310, 0x00dcc310, 0x00dce310, - 0x00dd0310, 0x00dd2310, 0x00dd4310, 0x00dd6310, - 0x00dd8310, 0x00dda310, 0x00ddc310, 0x00dde310, - 0x00de0310, 0x00de2310, 0x00de4310, 0x00de6310, - 0x00de8310, 0x00dea310, 0x00dec310, 0x00dee310, - 0x00df0310, 0x00df2310, 0x00df4310, 0x00df6310, - 0x00df8310, 0x00dfa310, 0x00dfc310, 0x00dfe310, - 0x00e00310, 0x00e02310, 0x00e04310, 0x00e06310, - 0x00e08310, 0x00e0a310, 0x00e0c310, 0x00e0e310, - 0x00e10310, 0x00e12310, 0x00e14310, 0x00e16310, - 0x00e18310, 0x00e1a310, 0x00e1c310, 0x00e1e310, - 0x00e20310, 0x00e22310, 0x00e24310, 0x00e26310, - 0x00e28310, 0x00e2a310, 0x00e2c310, 0x00e2e310, - 0x00e30310, 0x00e32310, 0x00e34310, 0x00e36310, - 0x00e38310, 0x00e3a310, 0x00e3c310, 0x00e3e310, - 0x00e40310, 0x00e42310, 0x00e44310, 0x00e46310, - 0x00e48310, 0x00e4a310, 0x00e4c310, 0x00e4e310, - 0x00e50310, 0x00e52310, 0x00e54310, 0x00e56310, - 0x00e58310, 0x00e5a310, 0x00e5c310, 0x00e5e310, - 0x00e60310, 0x00e62310, 0x00e64310, 0x00e66310, - 0x00e68310, 0x00e6a310, 0x00e6c310, 0x00e6e310, - 0x00e70310, 0x00e72310, 0x00e74310, 0x00e76310, - 0x00e78310, 0x00e7a310, 0x00e7c310, 0x00e7e310, - 0x00e80310, 0x00e82310, 0x00e84310, 0x00e86310, - 0x00e88310, 0x00e8a310, 0x00e8c310, 0x00e8e310, - 0x00e90310, 0x00e92310, 0x00e94310, 0x00e96310, - 0x00e98310, 0x00e9a310, 0x00e9c310, 0x00e9e310, - 0x00ea0310, 0x00ea2310, 0x00ea4310, 0x00ea6310, - 0x00ea8310, 0x00eaa310, 0x00eac310, 0x00eae310, - 0x00eb0310, 0x00eb2310, 0x00eb4310, 0x00eb6310, - 0x00eb8310, 0x00eba310, 0x00ebc310, 0x00ebe310, - 0x00ec0310, 0x00ec2310, 0x00ec4310, 0x00ec6310, - 0x00ec8310, 0x00eca310, 0x00ecc310, 0x00ece310, - 0x00ed0310, 0x00ed2310, 0x00ed4310, 0x00ed6310, - 0x00ed8310, 0x00eda310, 0x00edc310, 0x00ede310, - 0x00ee0310, 0x00ee2310, 0x00ee4310, 0x00ee6310, - 0x00ee8310, 0x00eea310, 0x00eec310, 0x00eee310, - 0x00ef0310, 0x00ef2310, 0x00ef4310, 0x00ef6310, - 0x00ef8310, 0x00efa310, 0x00efc310, 0x00efe310, - 0x00f00310, 0x00f02310, 0x00f04310, 0x00f06310, - 0x00f08310, 0x00f0a310, 0x00f0c310, 0x00f0e310, - 0x00f10310, 0x00f12310, 0x00f14310, 0x00f16310, - 0x00f18310, 0x00f1a310, 0x00f1c310, 0x00f1e310, - 0x00f20310, 0x00f22310, 0x00f24310, 0x00f26310, - 0x00f28310, 0x00f2a310, 0x00f2c310, 0x00f2e310, - 0x00f30310, 0x00f32310, 0x00f34310, 0x00f36310, - 0x00f38310, 0x00f3a310, 0x00f3c310, 0x00f3e310, - 0x00f40310, 0x00f42310, 0x00f44310, 0x00f46310, - 0x00f48310, 0x00f4a310, 0x00f4c310, 0x00f4e310, - 0x00f50310, 0x00f52310, 0x00f54310, 0x00f56310, - 0x00f58310, 0x00f5a310, 0x00f5c310, 0x00f5e310, - 0x00f60310, 0x00f62310, 0x00f64310, 0x00f66310, - 0x00f68310, 0x00f6a310, 0x00f6c310, 0x00f6e310, - 0x00f70310, 0x00f72310, 0x00f74310, 0x00f76310, - 0x00f78310, 0x00f7a310, 0x00f7c310, 0x00f7e310, - 0x00f80310, 0x00f82310, 0x00f84310, 0x00f86310, - 0x00f88310, 0x00f8a310, 0x00f8c310, 0x00f8e310, - 0x00f90310, 0x00f92310, 0x00f94310, 0x00f96310, - 0x00f98310, 0x00f9a310, 0x00f9c310, 0x00f9e310, - 0x00fa0310, 0x00fa2310, 0x00fa4310, 0x00fa6310, - 0x00fa8310, 0x00faa310, 0x00fac310, 0x00fae310, - 0x00fb0310, 0x00fb2310, 0x00fb4310, 0x00fb6310, - 0x00fb8310, 0x00fba310, 0x00fbc310, 0x00fbe310, - 0x00fc0310, 0x00fc2310, 0x00fc4310, 0x00fc6310, - 0x00fc8310, 0x00fca310, 0x00fcc310, 0x00fce310, - 0x00fd0310, 0x00fd2310, 0x00fd4310, 0x00fd6310, - 0x00fd8310, 0x00fda310, 0x00fdc310, 0x00fde310, - 0x00fe0310, 0x00fe2310, 0x00fe4310, 0x00fe6310, - 0x00fe8310, 0x00fea310, 0x00fec310, 0x00fee310, - 0x00ff0310, 0x00ff2310, 0x00ff4310, 0x00ff6310, - 0x00ff8310, 0x00ffa310, 0x00ffc310, 0x00ffe310, - 0x00001310, 0x00003310, 0x00005310, 0x00007310, - 0x00009310, 0x0000b310, 0x0000d310, 0x0000f310, - 0x00011310, 0x00013310, 0x00015310, 0x00017310, - 0x00019310, 0x0001b310, 0x0001d310, 0x0001f310, - 0x00021310, 0x00023310, 0x00025310, 0x00027310, - 0x00029310, 0x0002b310, 0x0002d310, 0x0002f310, - 0x00031310, 0x00033310, 0x00035310, 0x00037310, - 0x00039310, 0x0003b310, 0x0003d310, 0x0003f310, - 0x00041310, 0x00043310, 0x00045310, 0x00047310, - 0x00049310, 0x0004b310, 0x0004d310, 0x0004f310, - 0x00051310, 0x00053310, 0x00055310, 0x00057310, - 0x00059310, 0x0005b310, 0x0005d310, 0x0005f310, - 0x00061310, 0x00063310, 0x00065310, 0x00067310, - 0x00069310, 0x0006b310, 0x0006d310, 0x0006f310, - 0x00071310, 0x00073310, 0x00075310, 0x00077310, - 0x00079310, 0x0007b310, 0x0007d310, 0x0007f310, - 0x00081310, 0x00083310, 0x00085310, 0x00087310, - 0x00089310, 0x0008b310, 0x0008d310, 0x0008f310, - 0x00091310, 0x00093310, 0x00095310, 0x00097310, - 0x00099310, 0x0009b310, 0x0009d310, 0x0009f310, - 0x000a1310, 0x000a3310, 0x000a5310, 0x000a7310, - 0x000a9310, 0x000ab310, 0x000ad310, 0x000af310, - 0x000b1310, 0x000b3310, 0x000b5310, 0x000b7310, - 0x000b9310, 0x000bb310, 0x000bd310, 0x000bf310, - 0x000c1310, 0x000c3310, 0x000c5310, 0x000c7310, - 0x000c9310, 0x000cb310, 0x000cd310, 0x000cf310, - 0x000d1310, 0x000d3310, 0x000d5310, 0x000d7310, - 0x000d9310, 0x000db310, 0x000dd310, 0x000df310, - 0x000e1310, 0x000e3310, 0x000e5310, 0x000e7310, - 0x000e9310, 0x000eb310, 0x000ed310, 0x000ef310, - 0x000f1310, 0x000f3310, 0x000f5310, 0x000f7310, - 0x000f9310, 0x000fb310, 0x000fd310, 0x000ff310, - 0x00101310, 0x00103310, 0x00105310, 0x00107310, - 0x00109310, 0x0010b310, 0x0010d310, 0x0010f310, - 0x00111310, 0x00113310, 0x00115310, 0x00117310, - 0x00119310, 0x0011b310, 0x0011d310, 0x0011f310, - 0x00121310, 0x00123310, 0x00125310, 0x00127310, - 0x00129310, 0x0012b310, 0x0012d310, 0x0012f310, - 0x00131310, 0x00133310, 0x00135310, 0x00137310, - 0x00139310, 0x0013b310, 0x0013d310, 0x0013f310, - 0x00141310, 0x00143310, 0x00145310, 0x00147310, - 0x00149310, 0x0014b310, 0x0014d310, 0x0014f310, - 0x00151310, 0x00153310, 0x00155310, 0x00157310, - 0x00159310, 0x0015b310, 0x0015d310, 0x0015f310, - 0x00161310, 0x00163310, 0x00165310, 0x00167310, - 0x00169310, 0x0016b310, 0x0016d310, 0x0016f310, - 0x00171310, 0x00173310, 0x00175310, 0x00177310, - 0x00179310, 0x0017b310, 0x0017d310, 0x0017f310, - 0x00181310, 0x00183310, 0x00185310, 0x00187310, - 0x00189310, 0x0018b310, 0x0018d310, 0x0018f310, - 0x00191310, 0x00193310, 0x00195310, 0x00197310, - 0x00199310, 0x0019b310, 0x0019d310, 0x0019f310, - 0x001a1310, 0x001a3310, 0x001a5310, 0x001a7310, - 0x001a9310, 0x001ab310, 0x001ad310, 0x001af310, - 0x001b1310, 0x001b3310, 0x001b5310, 0x001b7310, - 0x001b9310, 0x001bb310, 0x001bd310, 0x001bf310, - 0x001c1310, 0x001c3310, 0x001c5310, 0x001c7310, - 0x001c9310, 0x001cb310, 0x001cd310, 0x001cf310, - 0x001d1310, 0x001d3310, 0x001d5310, 0x001d7310, - 0x001d9310, 0x001db310, 0x001dd310, 0x001df310, - 0x001e1310, 0x001e3310, 0x001e5310, 0x001e7310, - 0x001e9310, 0x001eb310, 0x001ed310, 0x001ef310, - 0x001f1310, 0x001f3310, 0x001f5310, 0x001f7310, - 0x001f9310, 0x001fb310, 0x001fd310, 0x001ff310, - 0x00201310, 0x00203310, 0x00205310, 0x00207310, - 0x00209310, 0x0020b310, 0x0020d310, 0x0020f310, - 0x00211310, 0x00213310, 0x00215310, 0x00217310, - 0x00219310, 0x0021b310, 0x0021d310, 0x0021f310, - 0x00221310, 0x00223310, 0x00225310, 0x00227310, - 0x00229310, 0x0022b310, 0x0022d310, 0x0022f310, - 0x00231310, 0x00233310, 0x00235310, 0x00237310, - 0x00239310, 0x0023b310, 0x0023d310, 0x0023f310, - 0x00241310, 0x00243310, 0x00245310, 0x00247310, - 0x00249310, 0x0024b310, 0x0024d310, 0x0024f310, - 0x00251310, 0x00253310, 0x00255310, 0x00257310, - 0x00259310, 0x0025b310, 0x0025d310, 0x0025f310, - 0x00261310, 0x00263310, 0x00265310, 0x00267310, - 0x00269310, 0x0026b310, 0x0026d310, 0x0026f310, - 0x00271310, 0x00273310, 0x00275310, 0x00277310, - 0x00279310, 0x0027b310, 0x0027d310, 0x0027f310, - 0x00281310, 0x00283310, 0x00285310, 0x00287310, - 0x00289310, 0x0028b310, 0x0028d310, 0x0028f310, - 0x00291310, 0x00293310, 0x00295310, 0x00297310, - 0x00299310, 0x0029b310, 0x0029d310, 0x0029f310, - 0x002a1310, 0x002a3310, 0x002a5310, 0x002a7310, - 0x002a9310, 0x002ab310, 0x002ad310, 0x002af310, - 0x002b1310, 0x002b3310, 0x002b5310, 0x002b7310, - 0x002b9310, 0x002bb310, 0x002bd310, 0x002bf310, - 0x002c1310, 0x002c3310, 0x002c5310, 0x002c7310, - 0x002c9310, 0x002cb310, 0x002cd310, 0x002cf310, - 0x002d1310, 0x002d3310, 0x002d5310, 0x002d7310, - 0x002d9310, 0x002db310, 0x002dd310, 0x002df310, - 0x002e1310, 0x002e3310, 0x002e5310, 0x002e7310, - 0x002e9310, 0x002eb310, 0x002ed310, 0x002ef310, - 0x002f1310, 0x002f3310, 0x002f5310, 0x002f7310, - 0x002f9310, 0x002fb310, 0x002fd310, 0x002ff310, - 0x00301310, 0x00303310, 0x00305310, 0x00307310, - 0x00309310, 0x0030b310, 0x0030d310, 0x0030f310, - 0x00311310, 0x00313310, 0x00315310, 0x00317310, - 0x00319310, 0x0031b310, 0x0031d310, 0x0031f310, - 0x00321310, 0x00323310, 0x00325310, 0x00327310, - 0x00329310, 0x0032b310, 0x0032d310, 0x0032f310, - 0x00331310, 0x00333310, 0x00335310, 0x00337310, - 0x00339310, 0x0033b310, 0x0033d310, 0x0033f310, - 0x00341310, 0x00343310, 0x00345310, 0x00347310, - 0x00349310, 0x0034b310, 0x0034d310, 0x0034f310, - 0x00351310, 0x00353310, 0x00355310, 0x00357310, - 0x00359310, 0x0035b310, 0x0035d310, 0x0035f310, - 0x00361310, 0x00363310, 0x00365310, 0x00367310, - 0x00369310, 0x0036b310, 0x0036d310, 0x0036f310, - 0x00371310, 0x00373310, 0x00375310, 0x00377310, - 0x00379310, 0x0037b310, 0x0037d310, 0x0037f310, - 0x00381310, 0x00383310, 0x00385310, 0x00387310, - 0x00389310, 0x0038b310, 0x0038d310, 0x0038f310, - 0x00391310, 0x00393310, 0x00395310, 0x00397310, - 0x00399310, 0x0039b310, 0x0039d310, 0x0039f310, - 0x003a1310, 0x003a3310, 0x003a5310, 0x003a7310, - 0x003a9310, 0x003ab310, 0x003ad310, 0x003af310, - 0x003b1310, 0x003b3310, 0x003b5310, 0x003b7310, - 0x003b9310, 0x003bb310, 0x003bd310, 0x003bf310, - 0x003c1310, 0x003c3310, 0x003c5310, 0x003c7310, - 0x003c9310, 0x003cb310, 0x003cd310, 0x003cf310, - 0x003d1310, 0x003d3310, 0x003d5310, 0x003d7310, - 0x003d9310, 0x003db310, 0x003dd310, 0x003df310, - 0x003e1310, 0x003e3310, 0x003e5310, 0x003e7310, - 0x003e9310, 0x003eb310, 0x003ed310, 0x003ef310, - 0x003f1310, 0x003f3310, 0x003f5310, 0x003f7310, - 0x003f9310, 0x003fb310, 0x003fd310, 0x003ff310, - 0x00401310, 0x00403310, 0x00405310, 0x00407310, - 0x00409310, 0x0040b310, 0x0040d310, 0x0040f310, - 0x00411310, 0x00413310, 0x00415310, 0x00417310, - 0x00419310, 0x0041b310, 0x0041d310, 0x0041f310, - 0x00421310, 0x00423310, 0x00425310, 0x00427310, - 0x00429310, 0x0042b310, 0x0042d310, 0x0042f310, - 0x00431310, 0x00433310, 0x00435310, 0x00437310, - 0x00439310, 0x0043b310, 0x0043d310, 0x0043f310, - 0x00441310, 0x00443310, 0x00445310, 0x00447310, - 0x00449310, 0x0044b310, 0x0044d310, 0x0044f310, - 0x00451310, 0x00453310, 0x00455310, 0x00457310, - 0x00459310, 0x0045b310, 0x0045d310, 0x0045f310, - 0x00461310, 0x00463310, 0x00465310, 0x00467310, - 0x00469310, 0x0046b310, 0x0046d310, 0x0046f310, - 0x00471310, 0x00473310, 0x00475310, 0x00477310, - 0x00479310, 0x0047b310, 0x0047d310, 0x0047f310, - 0x00481310, 0x00483310, 0x00485310, 0x00487310, - 0x00489310, 0x0048b310, 0x0048d310, 0x0048f310, - 0x00491310, 0x00493310, 0x00495310, 0x00497310, - 0x00499310, 0x0049b310, 0x0049d310, 0x0049f310, - 0x004a1310, 0x004a3310, 0x004a5310, 0x004a7310, - 0x004a9310, 0x004ab310, 0x004ad310, 0x004af310, - 0x004b1310, 0x004b3310, 0x004b5310, 0x004b7310, - 0x004b9310, 0x004bb310, 0x004bd310, 0x004bf310, - 0x004c1310, 0x004c3310, 0x004c5310, 0x004c7310, - 0x004c9310, 0x004cb310, 0x004cd310, 0x004cf310, - 0x004d1310, 0x004d3310, 0x004d5310, 0x004d7310, - 0x004d9310, 0x004db310, 0x004dd310, 0x004df310, - 0x004e1310, 0x004e3310, 0x004e5310, 0x004e7310, - 0x004e9310, 0x004eb310, 0x004ed310, 0x004ef310, - 0x004f1310, 0x004f3310, 0x004f5310, 0x004f7310, - 0x004f9310, 0x004fb310, 0x004fd310, 0x004ff310, - 0x00501310, 0x00503310, 0x00505310, 0x00507310, - 0x00509310, 0x0050b310, 0x0050d310, 0x0050f310, - 0x00511310, 0x00513310, 0x00515310, 0x00517310, - 0x00519310, 0x0051b310, 0x0051d310, 0x0051f310, - 0x00521310, 0x00523310, 0x00525310, 0x00527310, - 0x00529310, 0x0052b310, 0x0052d310, 0x0052f310, - 0x00531310, 0x00533310, 0x00535310, 0x00537310, - 0x00539310, 0x0053b310, 0x0053d310, 0x0053f310, - 0x00541310, 0x00543310, 0x00545310, 0x00547310, - 0x00549310, 0x0054b310, 0x0054d310, 0x0054f310, - 0x00551310, 0x00553310, 0x00555310, 0x00557310, - 0x00559310, 0x0055b310, 0x0055d310, 0x0055f310, - 0x00561310, 0x00563310, 0x00565310, 0x00567310, - 0x00569310, 0x0056b310, 0x0056d310, 0x0056f310, - 0x00571310, 0x00573310, 0x00575310, 0x00577310, - 0x00579310, 0x0057b310, 0x0057d310, 0x0057f310, - 0x00581310, 0x00583310, 0x00585310, 0x00587310, - 0x00589310, 0x0058b310, 0x0058d310, 0x0058f310, - 0x00591310, 0x00593310, 0x00595310, 0x00597310, - 0x00599310, 0x0059b310, 0x0059d310, 0x0059f310, - 0x005a1310, 0x005a3310, 0x005a5310, 0x005a7310, - 0x005a9310, 0x005ab310, 0x005ad310, 0x005af310, - 0x005b1310, 0x005b3310, 0x005b5310, 0x005b7310, - 0x005b9310, 0x005bb310, 0x005bd310, 0x005bf310, - 0x005c1310, 0x005c3310, 0x005c5310, 0x005c7310, - 0x005c9310, 0x005cb310, 0x005cd310, 0x005cf310, - 0x005d1310, 0x005d3310, 0x005d5310, 0x005d7310, - 0x005d9310, 0x005db310, 0x005dd310, 0x005df310, - 0x005e1310, 0x005e3310, 0x005e5310, 0x005e7310, - 0x005e9310, 0x005eb310, 0x005ed310, 0x005ef310, - 0x005f1310, 0x005f3310, 0x005f5310, 0x005f7310, - 0x005f9310, 0x005fb310, 0x005fd310, 0x005ff310, - 0x00601310, 0x00603310, 0x00605310, 0x00607310, - 0x00609310, 0x0060b310, 0x0060d310, 0x0060f310, - 0x00611310, 0x00613310, 0x00615310, 0x00617310, - 0x00619310, 0x0061b310, 0x0061d310, 0x0061f310, - 0x00621310, 0x00623310, 0x00625310, 0x00627310, - 0x00629310, 0x0062b310, 0x0062d310, 0x0062f310, - 0x00631310, 0x00633310, 0x00635310, 0x00637310, - 0x00639310, 0x0063b310, 0x0063d310, 0x0063f310, - 0x00641310, 0x00643310, 0x00645310, 0x00647310, - 0x00649310, 0x0064b310, 0x0064d310, 0x0064f310, - 0x00651310, 0x00653310, 0x00655310, 0x00657310, - 0x00659310, 0x0065b310, 0x0065d310, 0x0065f310, - 0x00661310, 0x00663310, 0x00665310, 0x00667310, - 0x00669310, 0x0066b310, 0x0066d310, 0x0066f310, - 0x00671310, 0x00673310, 0x00675310, 0x00677310, - 0x00679310, 0x0067b310, 0x0067d310, 0x0067f310, - 0x00681310, 0x00683310, 0x00685310, 0x00687310, - 0x00689310, 0x0068b310, 0x0068d310, 0x0068f310, - 0x00691310, 0x00693310, 0x00695310, 0x00697310, - 0x00699310, 0x0069b310, 0x0069d310, 0x0069f310, - 0x006a1310, 0x006a3310, 0x006a5310, 0x006a7310, - 0x006a9310, 0x006ab310, 0x006ad310, 0x006af310, - 0x006b1310, 0x006b3310, 0x006b5310, 0x006b7310, - 0x006b9310, 0x006bb310, 0x006bd310, 0x006bf310, - 0x006c1310, 0x006c3310, 0x006c5310, 0x006c7310, - 0x006c9310, 0x006cb310, 0x006cd310, 0x006cf310, - 0x006d1310, 0x006d3310, 0x006d5310, 0x006d7310, - 0x006d9310, 0x006db310, 0x006dd310, 0x006df310, - 0x006e1310, 0x006e3310, 0x006e5310, 0x006e7310, - 0x006e9310, 0x006eb310, 0x006ed310, 0x006ef310, - 0x006f1310, 0x006f3310, 0x006f5310, 0x006f7310, - 0x006f9310, 0x006fb310, 0x006fd310, 0x006ff310, - 0x00701310, 0x00703310, 0x00705310, 0x00707310, - 0x00709310, 0x0070b310, 0x0070d310, 0x0070f310, - 0x00711310, 0x00713310, 0x00715310, 0x00717310, - 0x00719310, 0x0071b310, 0x0071d310, 0x0071f310, - 0x00721310, 0x00723310, 0x00725310, 0x00727310, - 0x00729310, 0x0072b310, 0x0072d310, 0x0072f310, - 0x00731310, 0x00733310, 0x00735310, 0x00737310, - 0x00739310, 0x0073b310, 0x0073d310, 0x0073f310, - 0x00741310, 0x00743310, 0x00745310, 0x00747310, - 0x00749310, 0x0074b310, 0x0074d310, 0x0074f310, - 0x00751310, 0x00753310, 0x00755310, 0x00757310, - 0x00759310, 0x0075b310, 0x0075d310, 0x0075f310, - 0x00761310, 0x00763310, 0x00765310, 0x00767310, - 0x00769310, 0x0076b310, 0x0076d310, 0x0076f310, - 0x00771310, 0x00773310, 0x00775310, 0x00777310, - 0x00779310, 0x0077b310, 0x0077d310, 0x0077f310, - 0x00781310, 0x00783310, 0x00785310, 0x00787310, - 0x00789310, 0x0078b310, 0x0078d310, 0x0078f310, - 0x00791310, 0x00793310, 0x00795310, 0x00797310, - 0x00799310, 0x0079b310, 0x0079d310, 0x0079f310, - 0x007a1310, 0x007a3310, 0x007a5310, 0x007a7310, - 0x007a9310, 0x007ab310, 0x007ad310, 0x007af310, - 0x007b1310, 0x007b3310, 0x007b5310, 0x007b7310, - 0x007b9310, 0x007bb310, 0x007bd310, 0x007bf310, - 0x007c1310, 0x007c3310, 0x007c5310, 0x007c7310, - 0x007c9310, 0x007cb310, 0x007cd310, 0x007cf310, - 0x007d1310, 0x007d3310, 0x007d5310, 0x007d7310, - 0x007d9310, 0x007db310, 0x007dd310, 0x007df310, - 0x007e1310, 0x007e3310, 0x007e5310, 0x007e7310, - 0x007e9310, 0x007eb310, 0x007ed310, 0x007ef310, - 0x007f1310, 0x007f3310, 0x007f5310, 0x007f7310, - 0x007f9310, 0x007fb310, 0x007fd310, 0x007ff310, - 0x00801310, 0x00803310, 0x00805310, 0x00807310, - 0x00809310, 0x0080b310, 0x0080d310, 0x0080f310, - 0x00811310, 0x00813310, 0x00815310, 0x00817310, - 0x00819310, 0x0081b310, 0x0081d310, 0x0081f310, - 0x00821310, 0x00823310, 0x00825310, 0x00827310, - 0x00829310, 0x0082b310, 0x0082d310, 0x0082f310, - 0x00831310, 0x00833310, 0x00835310, 0x00837310, - 0x00839310, 0x0083b310, 0x0083d310, 0x0083f310, - 0x00841310, 0x00843310, 0x00845310, 0x00847310, - 0x00849310, 0x0084b310, 0x0084d310, 0x0084f310, - 0x00851310, 0x00853310, 0x00855310, 0x00857310, - 0x00859310, 0x0085b310, 0x0085d310, 0x0085f310, - 0x00861310, 0x00863310, 0x00865310, 0x00867310, - 0x00869310, 0x0086b310, 0x0086d310, 0x0086f310, - 0x00871310, 0x00873310, 0x00875310, 0x00877310, - 0x00879310, 0x0087b310, 0x0087d310, 0x0087f310, - 0x00881310, 0x00883310, 0x00885310, 0x00887310, - 0x00889310, 0x0088b310, 0x0088d310, 0x0088f310, - 0x00891310, 0x00893310, 0x00895310, 0x00897310, - 0x00899310, 0x0089b310, 0x0089d310, 0x0089f310, - 0x008a1310, 0x008a3310, 0x008a5310, 0x008a7310, - 0x008a9310, 0x008ab310, 0x008ad310, 0x008af310, - 0x008b1310, 0x008b3310, 0x008b5310, 0x008b7310, - 0x008b9310, 0x008bb310, 0x008bd310, 0x008bf310, - 0x008c1310, 0x008c3310, 0x008c5310, 0x008c7310, - 0x008c9310, 0x008cb310, 0x008cd310, 0x008cf310, - 0x008d1310, 0x008d3310, 0x008d5310, 0x008d7310, - 0x008d9310, 0x008db310, 0x008dd310, 0x008df310, - 0x008e1310, 0x008e3310, 0x008e5310, 0x008e7310, - 0x008e9310, 0x008eb310, 0x008ed310, 0x008ef310, - 0x008f1310, 0x008f3310, 0x008f5310, 0x008f7310, - 0x008f9310, 0x008fb310, 0x008fd310, 0x008ff310, - 0x00901310, 0x00903310, 0x00905310, 0x00907310, - 0x00909310, 0x0090b310, 0x0090d310, 0x0090f310, - 0x00911310, 0x00913310, 0x00915310, 0x00917310, - 0x00919310, 0x0091b310, 0x0091d310, 0x0091f310, - 0x00921310, 0x00923310, 0x00925310, 0x00927310, - 0x00929310, 0x0092b310, 0x0092d310, 0x0092f310, - 0x00931310, 0x00933310, 0x00935310, 0x00937310, - 0x00939310, 0x0093b310, 0x0093d310, 0x0093f310, - 0x00941310, 0x00943310, 0x00945310, 0x00947310, - 0x00949310, 0x0094b310, 0x0094d310, 0x0094f310, - 0x00951310, 0x00953310, 0x00955310, 0x00957310, - 0x00959310, 0x0095b310, 0x0095d310, 0x0095f310, - 0x00961310, 0x00963310, 0x00965310, 0x00967310, - 0x00969310, 0x0096b310, 0x0096d310, 0x0096f310, - 0x00971310, 0x00973310, 0x00975310, 0x00977310, - 0x00979310, 0x0097b310, 0x0097d310, 0x0097f310, - 0x00981310, 0x00983310, 0x00985310, 0x00987310, - 0x00989310, 0x0098b310, 0x0098d310, 0x0098f310, - 0x00991310, 0x00993310, 0x00995310, 0x00997310, - 0x00999310, 0x0099b310, 0x0099d310, 0x0099f310, - 0x009a1310, 0x009a3310, 0x009a5310, 0x009a7310, - 0x009a9310, 0x009ab310, 0x009ad310, 0x009af310, - 0x009b1310, 0x009b3310, 0x009b5310, 0x009b7310, - 0x009b9310, 0x009bb310, 0x009bd310, 0x009bf310, - 0x009c1310, 0x009c3310, 0x009c5310, 0x009c7310, - 0x009c9310, 0x009cb310, 0x009cd310, 0x009cf310, - 0x009d1310, 0x009d3310, 0x009d5310, 0x009d7310, - 0x009d9310, 0x009db310, 0x009dd310, 0x009df310, - 0x009e1310, 0x009e3310, 0x009e5310, 0x009e7310, - 0x009e9310, 0x009eb310, 0x009ed310, 0x009ef310, - 0x009f1310, 0x009f3310, 0x009f5310, 0x009f7310, - 0x009f9310, 0x009fb310, 0x009fd310, 0x009ff310, - 0x00a01310, 0x00a03310, 0x00a05310, 0x00a07310, - 0x00a09310, 0x00a0b310, 0x00a0d310, 0x00a0f310, - 0x00a11310, 0x00a13310, 0x00a15310, 0x00a17310, - 0x00a19310, 0x00a1b310, 0x00a1d310, 0x00a1f310, - 0x00a21310, 0x00a23310, 0x00a25310, 0x00a27310, - 0x00a29310, 0x00a2b310, 0x00a2d310, 0x00a2f310, - 0x00a31310, 0x00a33310, 0x00a35310, 0x00a37310, - 0x00a39310, 0x00a3b310, 0x00a3d310, 0x00a3f310, - 0x00a41310, 0x00a43310, 0x00a45310, 0x00a47310, - 0x00a49310, 0x00a4b310, 0x00a4d310, 0x00a4f310, - 0x00a51310, 0x00a53310, 0x00a55310, 0x00a57310, - 0x00a59310, 0x00a5b310, 0x00a5d310, 0x00a5f310, - 0x00a61310, 0x00a63310, 0x00a65310, 0x00a67310, - 0x00a69310, 0x00a6b310, 0x00a6d310, 0x00a6f310, - 0x00a71310, 0x00a73310, 0x00a75310, 0x00a77310, - 0x00a79310, 0x00a7b310, 0x00a7d310, 0x00a7f310, - 0x00a81310, 0x00a83310, 0x00a85310, 0x00a87310, - 0x00a89310, 0x00a8b310, 0x00a8d310, 0x00a8f310, - 0x00a91310, 0x00a93310, 0x00a95310, 0x00a97310, - 0x00a99310, 0x00a9b310, 0x00a9d310, 0x00a9f310, - 0x00aa1310, 0x00aa3310, 0x00aa5310, 0x00aa7310, - 0x00aa9310, 0x00aab310, 0x00aad310, 0x00aaf310, - 0x00ab1310, 0x00ab3310, 0x00ab5310, 0x00ab7310, - 0x00ab9310, 0x00abb310, 0x00abd310, 0x00abf310, - 0x00ac1310, 0x00ac3310, 0x00ac5310, 0x00ac7310, - 0x00ac9310, 0x00acb310, 0x00acd310, 0x00acf310, - 0x00ad1310, 0x00ad3310, 0x00ad5310, 0x00ad7310, - 0x00ad9310, 0x00adb310, 0x00add310, 0x00adf310, - 0x00ae1310, 0x00ae3310, 0x00ae5310, 0x00ae7310, - 0x00ae9310, 0x00aeb310, 0x00aed310, 0x00aef310, - 0x00af1310, 0x00af3310, 0x00af5310, 0x00af7310, - 0x00af9310, 0x00afb310, 0x00afd310, 0x00aff310, - 0x00b01310, 0x00b03310, 0x00b05310, 0x00b07310, - 0x00b09310, 0x00b0b310, 0x00b0d310, 0x00b0f310, - 0x00b11310, 0x00b13310, 0x00b15310, 0x00b17310, - 0x00b19310, 0x00b1b310, 0x00b1d310, 0x00b1f310, - 0x00b21310, 0x00b23310, 0x00b25310, 0x00b27310, - 0x00b29310, 0x00b2b310, 0x00b2d310, 0x00b2f310, - 0x00b31310, 0x00b33310, 0x00b35310, 0x00b37310, - 0x00b39310, 0x00b3b310, 0x00b3d310, 0x00b3f310, - 0x00b41310, 0x00b43310, 0x00b45310, 0x00b47310, - 0x00b49310, 0x00b4b310, 0x00b4d310, 0x00b4f310, - 0x00b51310, 0x00b53310, 0x00b55310, 0x00b57310, - 0x00b59310, 0x00b5b310, 0x00b5d310, 0x00b5f310, - 0x00b61310, 0x00b63310, 0x00b65310, 0x00b67310, - 0x00b69310, 0x00b6b310, 0x00b6d310, 0x00b6f310, - 0x00b71310, 0x00b73310, 0x00b75310, 0x00b77310, - 0x00b79310, 0x00b7b310, 0x00b7d310, 0x00b7f310, - 0x00b81310, 0x00b83310, 0x00b85310, 0x00b87310, - 0x00b89310, 0x00b8b310, 0x00b8d310, 0x00b8f310, - 0x00b91310, 0x00b93310, 0x00b95310, 0x00b97310, - 0x00b99310, 0x00b9b310, 0x00b9d310, 0x00b9f310, - 0x00ba1310, 0x00ba3310, 0x00ba5310, 0x00ba7310, - 0x00ba9310, 0x00bab310, 0x00bad310, 0x00baf310, - 0x00bb1310, 0x00bb3310, 0x00bb5310, 0x00bb7310, - 0x00bb9310, 0x00bbb310, 0x00bbd310, 0x00bbf310, - 0x00bc1310, 0x00bc3310, 0x00bc5310, 0x00bc7310, - 0x00bc9310, 0x00bcb310, 0x00bcd310, 0x00bcf310, - 0x00bd1310, 0x00bd3310, 0x00bd5310, 0x00bd7310, - 0x00bd9310, 0x00bdb310, 0x00bdd310, 0x00bdf310, - 0x00be1310, 0x00be3310, 0x00be5310, 0x00be7310, - 0x00be9310, 0x00beb310, 0x00bed310, 0x00bef310, - 0x00bf1310, 0x00bf3310, 0x00bf5310, 0x00bf7310, - 0x00bf9310, 0x00bfb310, 0x00bfd310, 0x00bff310, - 0x00c01310, 0x00c03310, 0x00c05310, 0x00c07310, - 0x00c09310, 0x00c0b310, 0x00c0d310, 0x00c0f310, - 0x00c11310, 0x00c13310, 0x00c15310, 0x00c17310, - 0x00c19310, 0x00c1b310, 0x00c1d310, 0x00c1f310, - 0x00c21310, 0x00c23310, 0x00c25310, 0x00c27310, - 0x00c29310, 0x00c2b310, 0x00c2d310, 0x00c2f310, - 0x00c31310, 0x00c33310, 0x00c35310, 0x00c37310, - 0x00c39310, 0x00c3b310, 0x00c3d310, 0x00c3f310, - 0x00c41310, 0x00c43310, 0x00c45310, 0x00c47310, - 0x00c49310, 0x00c4b310, 0x00c4d310, 0x00c4f310, - 0x00c51310, 0x00c53310, 0x00c55310, 0x00c57310, - 0x00c59310, 0x00c5b310, 0x00c5d310, 0x00c5f310, - 0x00c61310, 0x00c63310, 0x00c65310, 0x00c67310, - 0x00c69310, 0x00c6b310, 0x00c6d310, 0x00c6f310, - 0x00c71310, 0x00c73310, 0x00c75310, 0x00c77310, - 0x00c79310, 0x00c7b310, 0x00c7d310, 0x00c7f310, - 0x00c81310, 0x00c83310, 0x00c85310, 0x00c87310, - 0x00c89310, 0x00c8b310, 0x00c8d310, 0x00c8f310, - 0x00c91310, 0x00c93310, 0x00c95310, 0x00c97310, - 0x00c99310, 0x00c9b310, 0x00c9d310, 0x00c9f310, - 0x00ca1310, 0x00ca3310, 0x00ca5310, 0x00ca7310, - 0x00ca9310, 0x00cab310, 0x00cad310, 0x00caf310, - 0x00cb1310, 0x00cb3310, 0x00cb5310, 0x00cb7310, - 0x00cb9310, 0x00cbb310, 0x00cbd310, 0x00cbf310, - 0x00cc1310, 0x00cc3310, 0x00cc5310, 0x00cc7310, - 0x00cc9310, 0x00ccb310, 0x00ccd310, 0x00ccf310, - 0x00cd1310, 0x00cd3310, 0x00cd5310, 0x00cd7310, - 0x00cd9310, 0x00cdb310, 0x00cdd310, 0x00cdf310, - 0x00ce1310, 0x00ce3310, 0x00ce5310, 0x00ce7310, - 0x00ce9310, 0x00ceb310, 0x00ced310, 0x00cef310, - 0x00cf1310, 0x00cf3310, 0x00cf5310, 0x00cf7310, - 0x00cf9310, 0x00cfb310, 0x00cfd310, 0x00cff310, - 0x00d01310, 0x00d03310, 0x00d05310, 0x00d07310, - 0x00d09310, 0x00d0b310, 0x00d0d310, 0x00d0f310, - 0x00d11310, 0x00d13310, 0x00d15310, 0x00d17310, - 0x00d19310, 0x00d1b310, 0x00d1d310, 0x00d1f310, - 0x00d21310, 0x00d23310, 0x00d25310, 0x00d27310, - 0x00d29310, 0x00d2b310, 0x00d2d310, 0x00d2f310, - 0x00d31310, 0x00d33310, 0x00d35310, 0x00d37310, - 0x00d39310, 0x00d3b310, 0x00d3d310, 0x00d3f310, - 0x00d41310, 0x00d43310, 0x00d45310, 0x00d47310, - 0x00d49310, 0x00d4b310, 0x00d4d310, 0x00d4f310, - 0x00d51310, 0x00d53310, 0x00d55310, 0x00d57310, - 0x00d59310, 0x00d5b310, 0x00d5d310, 0x00d5f310, - 0x00d61310, 0x00d63310, 0x00d65310, 0x00d67310, - 0x00d69310, 0x00d6b310, 0x00d6d310, 0x00d6f310, - 0x00d71310, 0x00d73310, 0x00d75310, 0x00d77310, - 0x00d79310, 0x00d7b310, 0x00d7d310, 0x00d7f310, - 0x00d81310, 0x00d83310, 0x00d85310, 0x00d87310, - 0x00d89310, 0x00d8b310, 0x00d8d310, 0x00d8f310, - 0x00d91310, 0x00d93310, 0x00d95310, 0x00d97310, - 0x00d99310, 0x00d9b310, 0x00d9d310, 0x00d9f310, - 0x00da1310, 0x00da3310, 0x00da5310, 0x00da7310, - 0x00da9310, 0x00dab310, 0x00dad310, 0x00daf310, - 0x00db1310, 0x00db3310, 0x00db5310, 0x00db7310, - 0x00db9310, 0x00dbb310, 0x00dbd310, 0x00dbf310, - 0x00dc1310, 0x00dc3310, 0x00dc5310, 0x00dc7310, - 0x00dc9310, 0x00dcb310, 0x00dcd310, 0x00dcf310, - 0x00dd1310, 0x00dd3310, 0x00dd5310, 0x00dd7310, - 0x00dd9310, 0x00ddb310, 0x00ddd310, 0x00ddf310, - 0x00de1310, 0x00de3310, 0x00de5310, 0x00de7310, - 0x00de9310, 0x00deb310, 0x00ded310, 0x00def310, - 0x00df1310, 0x00df3310, 0x00df5310, 0x00df7310, - 0x00df9310, 0x00dfb310, 0x00dfd310, 0x00dff310, - 0x00e01310, 0x00e03310, 0x00e05310, 0x00e07310, - 0x00e09310, 0x00e0b310, 0x00e0d310, 0x00e0f310, - 0x00e11310, 0x00e13310, 0x00e15310, 0x00e17310, - 0x00e19310, 0x00e1b310, 0x00e1d310, 0x00e1f310, - 0x00e21310, 0x00e23310, 0x00e25310, 0x00e27310, - 0x00e29310, 0x00e2b310, 0x00e2d310, 0x00e2f310, - 0x00e31310, 0x00e33310, 0x00e35310, 0x00e37310, - 0x00e39310, 0x00e3b310, 0x00e3d310, 0x00e3f310, - 0x00e41310, 0x00e43310, 0x00e45310, 0x00e47310, - 0x00e49310, 0x00e4b310, 0x00e4d310, 0x00e4f310, - 0x00e51310, 0x00e53310, 0x00e55310, 0x00e57310, - 0x00e59310, 0x00e5b310, 0x00e5d310, 0x00e5f310, - 0x00e61310, 0x00e63310, 0x00e65310, 0x00e67310, - 0x00e69310, 0x00e6b310, 0x00e6d310, 0x00e6f310, - 0x00e71310, 0x00e73310, 0x00e75310, 0x00e77310, - 0x00e79310, 0x00e7b310, 0x00e7d310, 0x00e7f310, - 0x00e81310, 0x00e83310, 0x00e85310, 0x00e87310, - 0x00e89310, 0x00e8b310, 0x00e8d310, 0x00e8f310, - 0x00e91310, 0x00e93310, 0x00e95310, 0x00e97310, - 0x00e99310, 0x00e9b310, 0x00e9d310, 0x00e9f310, - 0x00ea1310, 0x00ea3310, 0x00ea5310, 0x00ea7310, - 0x00ea9310, 0x00eab310, 0x00ead310, 0x00eaf310, - 0x00eb1310, 0x00eb3310, 0x00eb5310, 0x00eb7310, - 0x00eb9310, 0x00ebb310, 0x00ebd310, 0x00ebf310, - 0x00ec1310, 0x00ec3310, 0x00ec5310, 0x00ec7310, - 0x00ec9310, 0x00ecb310, 0x00ecd310, 0x00ecf310, - 0x00ed1310, 0x00ed3310, 0x00ed5310, 0x00ed7310, - 0x00ed9310, 0x00edb310, 0x00edd310, 0x00edf310, - 0x00ee1310, 0x00ee3310, 0x00ee5310, 0x00ee7310, - 0x00ee9310, 0x00eeb310, 0x00eed310, 0x00eef310, - 0x00ef1310, 0x00ef3310, 0x00ef5310, 0x00ef7310, - 0x00ef9310, 0x00efb310, 0x00efd310, 0x00eff310, - 0x00f01310, 0x00f03310, 0x00f05310, 0x00f07310, - 0x00f09310, 0x00f0b310, 0x00f0d310, 0x00f0f310, - 0x00f11310, 0x00f13310, 0x00f15310, 0x00f17310, - 0x00f19310, 0x00f1b310, 0x00f1d310, 0x00f1f310, - 0x00f21310, 0x00f23310, 0x00f25310, 0x00f27310, - 0x00f29310, 0x00f2b310, 0x00f2d310, 0x00f2f310, - 0x00f31310, 0x00f33310, 0x00f35310, 0x00f37310, - 0x00f39310, 0x00f3b310, 0x00f3d310, 0x00f3f310, - 0x00f41310, 0x00f43310, 0x00f45310, 0x00f47310, - 0x00f49310, 0x00f4b310, 0x00f4d310, 0x00f4f310, - 0x00f51310, 0x00f53310, 0x00f55310, 0x00f57310, - 0x00f59310, 0x00f5b310, 0x00f5d310, 0x00f5f310, - 0x00f61310, 0x00f63310, 0x00f65310, 0x00f67310, - 0x00f69310, 0x00f6b310, 0x00f6d310, 0x00f6f310, - 0x00f71310, 0x00f73310, 0x00f75310, 0x00f77310, - 0x00f79310, 0x00f7b310, 0x00f7d310, 0x00f7f310, - 0x00f81310, 0x00f83310, 0x00f85310, 0x00f87310, - 0x00f89310, 0x00f8b310, 0x00f8d310, 0x00f8f310, - 0x00f91310, 0x00f93310, 0x00f95310, 0x00f97310, - 0x00f99310, 0x00f9b310, 0x00f9d310, 0x00f9f310, - 0x00fa1310, 0x00fa3310, 0x00fa5310, 0x00fa7310, - 0x00fa9310, 0x00fab310, 0x00fad310, 0x00faf310, - 0x00fb1310, 0x00fb3310, 0x00fb5310, 0x00fb7310, - 0x00fb9310, 0x00fbb310, 0x00fbd310, 0x00fbf310, - 0x00fc1310, 0x00fc3310, 0x00fc5310, 0x00fc7310, - 0x00fc9310, 0x00fcb310, 0x00fcd310, 0x00fcf310, - 0x00fd1310, 0x00fd3310, 0x00fd5310, 0x00fd7310, - 0x00fd9310, 0x00fdb310, 0x00fdd310, 0x00fdf310, - 0x00fe1310, 0x00fe3310, 0x00fe5310, 0x00fe7310, - 0x00fe9310, 0x00feb310, 0x00fed310, 0x00fef310, - 0x00ff1310, 0x00ff3310, 0x00ff5310, 0x00ff7310, - 0x00ff9310, 0x00ffb310, 0x00ffd310, 0x00fff310, -}; diff --git a/libs/zlibng/arch/x86/fill_window_sse.c b/libs/zlibng/arch/x86/fill_window_sse.c deleted file mode 100644 index 1c0f863bd..000000000 --- a/libs/zlibng/arch/x86/fill_window_sse.c +++ /dev/null @@ -1,175 +0,0 @@ -/* - * Fill Window with SSE2-optimized hash shifting - * - * Copyright (C) 2013 Intel Corporation - * Authors: - * Arjan van de Ven - * Jim Kukunas - * - * For conditions of distribution and use, see copyright notice in zlib.h - */ -#ifdef X86_SSE2 - -#include "zbuild.h" -#include -#include "deflate.h" -#include "deflate_p.h" -#include "functable.h" - -extern int read_buf(PREFIX3(stream) *strm, unsigned char *buf, unsigned size); - -ZLIB_INTERNAL void fill_window_sse(deflate_state *s) { - const __m128i xmm_wsize = _mm_set1_epi16(s->w_size); - - register unsigned n; - register Pos *p; - unsigned more; /* Amount of free space at the end of the window. */ - unsigned int wsize = s->w_size; - - Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead"); - - do { - more = (unsigned)(s->window_size -(unsigned long)s->lookahead -(unsigned long)s->strstart); - - /* Deal with !@#$% 64K limit: */ - if (sizeof(int) <= 2) { - if (more == 0 && s->strstart == 0 && s->lookahead == 0) { - more = wsize; - - } else if (more == (unsigned)(-1)) { - /* Very unlikely, but possible on 16 bit machine if - * strstart == 0 && lookahead == 1 (input done a byte at time) - */ - more--; - } - } - - /* If the window is almost full and there is insufficient lookahead, - * move the upper half to the lower one to make room in the upper half. - */ - if (s->strstart >= wsize+MAX_DIST(s)) { - memcpy(s->window, s->window+wsize, (unsigned)wsize); - s->match_start = (s->match_start >= wsize) ? s->match_start - wsize : 0; - s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ - s->block_start -= (long) wsize; - - /* Slide the hash table (could be avoided with 32 bit values - at the expense of memory usage). We slide even when level == 0 - to keep the hash table consistent if we switch back to level > 0 - later. (Using level 0 permanently is not an optimal usage of - zlib, so we don't care about this pathological case.) - */ - n = s->hash_size; - p = &s->head[n]; - p -= 8; - do { - __m128i value, result; - - value = _mm_loadu_si128((__m128i *)p); - result = _mm_subs_epu16(value, xmm_wsize); - _mm_storeu_si128((__m128i *)p, result); - - p -= 8; - n -= 8; - } while (n > 0); - - n = wsize; - p = &s->prev[n]; - p -= 8; - do { - __m128i value, result; - - value = _mm_loadu_si128((__m128i *)p); - result = _mm_subs_epu16(value, xmm_wsize); - _mm_storeu_si128((__m128i *)p, result); - - p -= 8; - n -= 8; - } while (n > 0); - more += wsize; - } - if (s->strm->avail_in == 0) break; - - /* If there was no sliding: - * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && - * more == window_size - lookahead - strstart - * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) - * => more >= window_size - 2*WSIZE + 2 - * In the BIG_MEM or MMAP case (not yet supported), - * window_size == input_size + MIN_LOOKAHEAD && - * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. - * Otherwise, window_size == 2*WSIZE so more >= 2. - * If there was sliding, more >= WSIZE. So in all cases, more >= 2. - */ - Assert(more >= 2, "more < 2"); - - n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); - s->lookahead += n; - - /* Initialize the hash value now that we have some input: */ - if (s->lookahead + s->insert >= MIN_MATCH) { - unsigned int str = s->strstart - s->insert; - s->ins_h = s->window[str]; - if (str >= 1) - functable.insert_string(s, str + 2 - MIN_MATCH, 1); -#if MIN_MATCH != 3 -#error Call insert_string() MIN_MATCH-3 more times - while (s->insert) { - functable.insert_string(s, str, 1); - str++; - s->insert--; - if (s->lookahead + s->insert < MIN_MATCH) - break; - } -#else - unsigned int count; - if (unlikely(s->lookahead == 1)){ - count = s->insert - 1; - }else{ - count = s->insert; - } - functable.insert_string(s, str, count); - s->insert -= count; -#endif - } - /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, - * but this is not important since only literal bytes will be emitted. - */ - } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); - - /* If the WIN_INIT bytes after the end of the current data have never been - * written, then zero those bytes in order to avoid memory check reports of - * the use of uninitialized (or uninitialised as Julian writes) bytes by - * the longest match routines. Update the high water mark for the next - * time through here. WIN_INIT is set to MAX_MATCH since the longest match - * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. - */ - if (s->high_water < s->window_size) { - unsigned long curr = s->strstart + (unsigned long)(s->lookahead); - unsigned long init; - - if (s->high_water < curr) { - /* Previous high water mark below current data -- zero WIN_INIT - * bytes or up to end of window, whichever is less. - */ - init = s->window_size - curr; - if (init > WIN_INIT) - init = WIN_INIT; - memset(s->window + curr, 0, (unsigned)init); - s->high_water = curr + init; - } else if (s->high_water < (unsigned long)curr + WIN_INIT) { - /* High water mark at or above current data, but below current data - * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up - * to end of window, whichever is less. - */ - init = (unsigned long)curr + WIN_INIT - s->high_water; - if (init > s->window_size - s->high_water) - init = s->window_size - s->high_water; - memset(s->window + s->high_water, 0, (unsigned)init); - s->high_water += init; - } - } - - Assert((unsigned long)s->strstart <= s->window_size - MIN_LOOKAHEAD, "not enough room for search"); -} -#endif diff --git a/libs/zlibng/arch/x86/insert_string_sse.c b/libs/zlibng/arch/x86/insert_string_sse.c index 394e50937..d0c316b19 100644 --- a/libs/zlibng/arch/x86/insert_string_sse.c +++ b/libs/zlibng/arch/x86/insert_string_sse.c @@ -5,52 +5,42 @@ * */ -#include "zbuild.h" -#include "deflate.h" - -/* =========================================================================== - * Insert string str in the dictionary and set match_head to the previous head - * of the hash chain (the most recent string with same hash key). Return - * the previous length of the hash chain. - * IN assertion: all calls to to INSERT_STRING are made with consecutive - * input characters and the first MIN_MATCH bytes of str are valid - * (except for the last MIN_MATCH-1 bytes of the input file). - */ -#ifdef X86_SSE4_2_CRC_HASH -ZLIB_INTERNAL Pos insert_string_sse(deflate_state *const s, const Pos str, unsigned int count) { - Pos ret = 0; - unsigned int idx; - unsigned int *ip, val, h; - - for (idx = 0; idx < count; idx++) { - ip = (unsigned *)&s->window[str+idx]; - memcpy(&val, ip, sizeof(val)); - h = 0; - - if (s->level >= TRIGGER_LEVEL) - val &= 0xFFFFFF; - +#include "../../zbuild.h" +#include #ifdef _MSC_VER - h = _mm_crc32_u32(h, val); -#elif defined(X86_SSE4_2_CRC_INTRIN) - h = __builtin_ia32_crc32si(h, val); +# include +#endif +#include "../../deflate.h" + +#ifdef X86_SSE42_CRC_INTRIN +# ifdef _MSC_VER +# define UPDATE_HASH(s, h, val)\ + h = _mm_crc32_u32(h, val) +# else +# define UPDATE_HASH(s, h, val)\ + h = __builtin_ia32_crc32si(h, val) +# endif #else - __asm__ __volatile__ ( - "crc32 %1,%0\n\t" - : "+r" (h) - : "r" (val) - ); -#endif - Pos head = s->head[h & s->hash_mask]; - if (head != str+idx) { - s->prev[(str+idx) & s->w_mask] = head; - s->head[h & s->hash_mask] = str+idx; - if (idx == count-1) - ret = head; - } else if (idx == count - 1) { - ret = str + idx; - } +# ifdef _MSC_VER +# define UPDATE_HASH(s, h, val) {\ + __asm mov edx, h\ + __asm mov eax, val\ + __asm crc32 eax, edx\ + __asm mov val, eax\ } - return ret; -} +# else +# define UPDATE_HASH(s, h, val) \ + __asm__ __volatile__ (\ + "crc32 %1,%0\n\t"\ + : "+r" (h)\ + : "r" (val)\ + ); +# endif +#endif + +#define INSERT_STRING insert_string_sse4 +#define QUICK_INSERT_STRING quick_insert_string_sse4 + +#ifdef X86_SSE42_CRC_HASH +# include "../../insert_string_tpl.h" #endif diff --git a/libs/zlibng/arch/x86/slide_avx.c b/libs/zlibng/arch/x86/slide_avx.c new file mode 100644 index 000000000..be9a9b7ea --- /dev/null +++ b/libs/zlibng/arch/x86/slide_avx.c @@ -0,0 +1,47 @@ +/* + * AVX2 optimized hash slide, based on Intel's slide_sse implementation + * + * Copyright (C) 2017 Intel Corporation + * Authors: + * Arjan van de Ven + * Jim Kukunas + * Mika T. Lindqvist + * + * For conditions of distribution and use, see copyright notice in zlib.h + */ +#include "../../zbuild.h" +#include "../../deflate.h" + +#include + +Z_INTERNAL void slide_hash_avx2(deflate_state *s) { + Pos *p; + unsigned n; + uint16_t wsize = (uint16_t)s->w_size; + const __m256i ymm_wsize = _mm256_set1_epi16((short)wsize); + + n = HASH_SIZE; + p = &s->head[n] - 16; + do { + __m256i value, result; + + value = _mm256_loadu_si256((__m256i *)p); + result= _mm256_subs_epu16(value, ymm_wsize); + _mm256_storeu_si256((__m256i *)p, result); + p -= 16; + n -= 16; + } while (n > 0); + + n = wsize; + p = &s->prev[n] - 16; + do { + __m256i value, result; + + value = _mm256_loadu_si256((__m256i *)p); + result= _mm256_subs_epu16(value, ymm_wsize); + _mm256_storeu_si256((__m256i *)p, result); + + p -= 16; + n -= 16; + } while (n > 0); +} diff --git a/libs/zlibng/arch/x86/slide_sse.c b/libs/zlibng/arch/x86/slide_sse.c new file mode 100644 index 000000000..abf447475 --- /dev/null +++ b/libs/zlibng/arch/x86/slide_sse.c @@ -0,0 +1,46 @@ +/* + * SSE optimized hash slide + * + * Copyright (C) 2017 Intel Corporation + * Authors: + * Arjan van de Ven + * Jim Kukunas + * + * For conditions of distribution and use, see copyright notice in zlib.h + */ +#include "../../zbuild.h" +#include "../../deflate.h" + +#include + +Z_INTERNAL void slide_hash_sse2(deflate_state *s) { + Pos *p; + unsigned n; + uint16_t wsize = (uint16_t)s->w_size; + const __m128i xmm_wsize = _mm_set1_epi16((short)wsize); + + n = HASH_SIZE; + p = &s->head[n] - 8; + do { + __m128i value, result; + + value = _mm_loadu_si128((__m128i *)p); + result= _mm_subs_epu16(value, xmm_wsize); + _mm_storeu_si128((__m128i *)p, result); + p -= 8; + n -= 8; + } while (n > 0); + + n = wsize; + p = &s->prev[n] - 8; + do { + __m128i value, result; + + value = _mm_loadu_si128((__m128i *)p); + result= _mm_subs_epu16(value, xmm_wsize); + _mm_storeu_si128((__m128i *)p, result); + + p -= 8; + n -= 8; + } while (n > 0); +} diff --git a/libs/zlibng/arch/x86/x86.c b/libs/zlibng/arch/x86/x86.c index 382f72a2b..e782cb8ee 100644 --- a/libs/zlibng/arch/x86/x86.c +++ b/libs/zlibng/arch/x86/x86.c @@ -8,61 +8,73 @@ * For conditions of distribution and use, see copyright notice in zlib.h */ -#include "zutil.h" +#include "../../zutil.h" #ifdef _MSC_VER -#include +# include #else // Newer versions of GCC and clang come with cpuid.h -#include +# include #endif -ZLIB_INTERNAL int x86_cpu_has_sse2; -ZLIB_INTERNAL int x86_cpu_has_sse42; -ZLIB_INTERNAL int x86_cpu_has_pclmulqdq; -ZLIB_INTERNAL int x86_cpu_has_tzcnt; +Z_INTERNAL int x86_cpu_has_avx2; +Z_INTERNAL int x86_cpu_has_sse2; +Z_INTERNAL int x86_cpu_has_ssse3; +Z_INTERNAL int x86_cpu_has_sse42; +Z_INTERNAL int x86_cpu_has_pclmulqdq; +Z_INTERNAL int x86_cpu_has_tzcnt; static void cpuid(int info, unsigned* eax, unsigned* ebx, unsigned* ecx, unsigned* edx) { #ifdef _MSC_VER - unsigned int registers[4]; - __cpuid(registers, info); + unsigned int registers[4]; + __cpuid((int *)registers, info); - *eax = registers[0]; - *ebx = registers[1]; - *ecx = registers[2]; - *edx = registers[3]; + *eax = registers[0]; + *ebx = registers[1]; + *ecx = registers[2]; + *edx = registers[3]; #else - unsigned int _eax; - unsigned int _ebx; - unsigned int _ecx; - unsigned int _edx; - __cpuid(info, _eax, _ebx, _ecx, _edx); - *eax = _eax; - *ebx = _ebx; - *ecx = _ecx; - *edx = _edx; + __cpuid(info, *eax, *ebx, *ecx, *edx); #endif } -void ZLIB_INTERNAL x86_check_features(void) { - unsigned eax, ebx, ecx, edx; - unsigned maxbasic; +static void cpuidex(int info, int subinfo, unsigned* eax, unsigned* ebx, unsigned* ecx, unsigned* edx) { +#ifdef _MSC_VER + unsigned int registers[4]; + __cpuidex((int *)registers, info, subinfo); - cpuid(0, &maxbasic, &ebx, &ecx, &edx); - - cpuid(1 /*CPU_PROCINFO_AND_FEATUREBITS*/, &eax, &ebx, &ecx, &edx); - - x86_cpu_has_sse2 = edx & 0x4000000; - x86_cpu_has_sse42 = ecx & 0x100000; - x86_cpu_has_pclmulqdq = ecx & 0x2; - - if (maxbasic >= 7) { - cpuid(7, &eax, &ebx, &ecx, &edx); - - // check BMI1 bit - // Reference: https://software.intel.com/sites/default/files/article/405250/how-to-detect-new-instruction-support-in-the-4th-generation-intel-core-processor-family.pdf - x86_cpu_has_tzcnt = ebx & 0x8; - } else { - x86_cpu_has_tzcnt = 0; - } + *eax = registers[0]; + *ebx = registers[1]; + *ecx = registers[2]; + *edx = registers[3]; +#else + __cpuid_count(info, subinfo, *eax, *ebx, *ecx, *edx); +#endif +} + +void Z_INTERNAL x86_check_features(void) { + unsigned eax, ebx, ecx, edx; + unsigned maxbasic; + + cpuid(0, &maxbasic, &ebx, &ecx, &edx); + + cpuid(1 /*CPU_PROCINFO_AND_FEATUREBITS*/, &eax, &ebx, &ecx, &edx); + + x86_cpu_has_sse2 = edx & 0x4000000; + x86_cpu_has_ssse3 = ecx & 0x200; + x86_cpu_has_sse42 = ecx & 0x100000; + x86_cpu_has_pclmulqdq = ecx & 0x2; + + if (maxbasic >= 7) { + cpuidex(7, 0, &eax, &ebx, &ecx, &edx); + + // check BMI1 bit + // Reference: https://software.intel.com/sites/default/files/article/405250/how-to-detect-new-instruction-support-in-the-4th-generation-intel-core-processor-family.pdf + x86_cpu_has_tzcnt = ebx & 0x8; + // check AVX2 bit + x86_cpu_has_avx2 = ebx & 0x20; + } else { + x86_cpu_has_tzcnt = 0; + x86_cpu_has_avx2 = 0; + } } diff --git a/libs/zlibng/arch/x86/x86.h b/libs/zlibng/arch/x86/x86.h index 860e64154..8471e155c 100644 --- a/libs/zlibng/arch/x86/x86.h +++ b/libs/zlibng/arch/x86/x86.h @@ -1,16 +1,18 @@ - /* cpu.h -- check for CPU features - * Copyright (C) 2013 Intel Corporation Jim Kukunas - * For conditions of distribution and use, see copyright notice in zlib.h - */ +/* cpu.h -- check for CPU features +* Copyright (C) 2013 Intel Corporation Jim Kukunas +* For conditions of distribution and use, see copyright notice in zlib.h +*/ #ifndef CPU_H_ #define CPU_H_ +extern int x86_cpu_has_avx2; extern int x86_cpu_has_sse2; +extern int x86_cpu_has_ssse3; extern int x86_cpu_has_sse42; extern int x86_cpu_has_pclmulqdq; extern int x86_cpu_has_tzcnt; -void ZLIB_INTERNAL x86_check_features(void); +void Z_INTERNAL x86_check_features(void); #endif /* CPU_H_ */ diff --git a/libs/zlibng/chunkset.c b/libs/zlibng/chunkset.c new file mode 100644 index 000000000..2aa8d4e47 --- /dev/null +++ b/libs/zlibng/chunkset.c @@ -0,0 +1,81 @@ +/* chunkset.c -- inline functions to copy small data chunks. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "zbuild.h" +#include "zutil.h" + +// We need sizeof(chunk_t) to be 8, no matter what. +#if defined(UNALIGNED64_OK) +typedef uint64_t chunk_t; +#elif defined(UNALIGNED_OK) +typedef struct chunk_t { uint32_t u32[2]; } chunk_t; +#else +typedef struct chunk_t { uint8_t u8[8]; } chunk_t; +#endif + +#define HAVE_CHUNKMEMSET_1 +#define HAVE_CHUNKMEMSET_4 +#define HAVE_CHUNKMEMSET_8 + +static inline void chunkmemset_1(uint8_t *from, chunk_t *chunk) { +#if defined(UNALIGNED64_OK) + *chunk = 0x0101010101010101 * (uint8_t)*from; +#elif defined(UNALIGNED_OK) + chunk->u32[0] = 0x01010101 * (uint8_t)*from; + chunk->u32[1] = chunk->u32[0]; +#else + memset(chunk, *from, sizeof(chunk_t)); +#endif +} + +static inline void chunkmemset_4(uint8_t *from, chunk_t *chunk) { +#if defined(UNALIGNED64_OK) + uint32_t half_chunk; + half_chunk = *(uint32_t *)from; + *chunk = 0x0000000100000001 * (uint64_t)half_chunk; +#elif defined(UNALIGNED_OK) + chunk->u32[0] = *(uint32_t *)from; + chunk->u32[1] = chunk->u32[0]; +#else + uint8_t *chunkptr = (uint8_t *)chunk; + memcpy(chunkptr, from, 4); + memcpy(chunkptr+4, from, 4); +#endif +} + +static inline void chunkmemset_8(uint8_t *from, chunk_t *chunk) { +#if defined(UNALIGNED64_OK) + *chunk = *(uint64_t *)from; +#elif defined(UNALIGNED_OK) + uint32_t* p = (uint32_t *)from; + chunk->u32[0] = p[0]; + chunk->u32[1] = p[1]; +#else + memcpy(chunk, from, sizeof(chunk_t)); +#endif +} + +static inline void loadchunk(uint8_t const *s, chunk_t *chunk) { + chunkmemset_8((uint8_t *)s, chunk); +} + +static inline void storechunk(uint8_t *out, chunk_t *chunk) { +#if defined(UNALIGNED64_OK) + *(uint64_t *)out = *chunk; +#elif defined(UNALIGNED_OK) + ((uint32_t *)out)[0] = chunk->u32[0]; + ((uint32_t *)out)[1] = chunk->u32[1]; +#else + memcpy(out, chunk, sizeof(chunk_t)); +#endif +} + +#define CHUNKSIZE chunksize_c +#define CHUNKCOPY chunkcopy_c +#define CHUNKCOPY_SAFE chunkcopy_safe_c +#define CHUNKUNROLL chunkunroll_c +#define CHUNKMEMSET chunkmemset_c +#define CHUNKMEMSET_SAFE chunkmemset_safe_c + +#include "chunkset_tpl.h" diff --git a/libs/zlibng/chunkset_tpl.h b/libs/zlibng/chunkset_tpl.h new file mode 100644 index 000000000..9e8ede559 --- /dev/null +++ b/libs/zlibng/chunkset_tpl.h @@ -0,0 +1,172 @@ +/* chunkset_tpl.h -- inline functions to copy small data chunks. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* Returns the chunk size */ +Z_INTERNAL uint32_t CHUNKSIZE(void) { + return sizeof(chunk_t); +} + +/* Behave like memcpy, but assume that it's OK to overwrite at least + chunk_t bytes of output even if the length is shorter than this, + that the length is non-zero, and that `from` lags `out` by at least + sizeof chunk_t bytes (or that they don't overlap at all or simply that + the distance is less than the length of the copy). + + Aside from better memory bus utilisation, this means that short copies + (chunk_t bytes or fewer) will fall straight through the loop + without iteration, which will hopefully make the branch prediction more + reliable. */ +Z_INTERNAL uint8_t* CHUNKCOPY(uint8_t *out, uint8_t const *from, unsigned len) { + chunk_t chunk; + --len; + loadchunk(from, &chunk); + storechunk(out, &chunk); + out += (len % sizeof(chunk_t)) + 1; + from += (len % sizeof(chunk_t)) + 1; + len /= sizeof(chunk_t); + while (len > 0) { + loadchunk(from, &chunk); + storechunk(out, &chunk); + out += sizeof(chunk_t); + from += sizeof(chunk_t); + --len; + } + return out; +} + +/* Behave like chunkcopy, but avoid writing beyond of legal output. */ +Z_INTERNAL uint8_t* CHUNKCOPY_SAFE(uint8_t *out, uint8_t const *from, unsigned len, uint8_t *safe) { + if ((safe - out) < (ptrdiff_t)sizeof(chunk_t)) { + int32_t use_chunk16 = sizeof(chunk_t) > 16 && (len & 16); + if (use_chunk16) { + memcpy(out, from, 16); + out += 16; + from += 16; + } + if (len & 8) { + memcpy(out, from, 8); + out += 8; + from += 8; + } + if (len & 4) { + memcpy(out, from, 4); + out += 4; + from += 4; + } + if (len & 2) { + memcpy(out, from, 2); + out += 2; + from += 2; + } + if (len & 1) { + *out++ = *from++; + } + return out; + } + return CHUNKCOPY(out, from, len); +} + +/* Perform short copies until distance can be rewritten as being at least + sizeof chunk_t. + + This assumes that it's OK to overwrite at least the first + 2*sizeof(chunk_t) bytes of output even if the copy is shorter than this. + This assumption holds because inflate_fast() starts every iteration with at + least 258 bytes of output space available (258 being the maximum length + output from a single token; see inflate_fast()'s assumptions below). */ +Z_INTERNAL uint8_t* CHUNKUNROLL(uint8_t *out, unsigned *dist, unsigned *len) { + unsigned char const *from = out - *dist; + chunk_t chunk; + while (*dist < *len && *dist < sizeof(chunk_t)) { + loadchunk(from, &chunk); + storechunk(out, &chunk); + out += *dist; + *len -= *dist; + *dist += *dist; + } + return out; +} + +/* Copy DIST bytes from OUT - DIST into OUT + DIST * k, for 0 <= k < LEN/DIST. + Return OUT + LEN. */ +Z_INTERNAL uint8_t* CHUNKMEMSET(uint8_t *out, unsigned dist, unsigned len) { + /* Debug performance related issues when len < sizeof(uint64_t): + Assert(len >= sizeof(uint64_t), "chunkmemset should be called on larger chunks"); */ + Assert(dist > 0, "cannot have a distance 0"); + + unsigned char *from = out - dist; + chunk_t chunk; + unsigned sz = sizeof(chunk); + if (len < sz) { + do { + *out++ = *from++; + --len; + } while (len != 0); + return out; + } + +#ifdef HAVE_CHUNKMEMSET_1 + if (dist == 1) { + chunkmemset_1(from, &chunk); + } else +#endif +#ifdef HAVE_CHUNKMEMSET_2 + if (dist == 2) { + chunkmemset_2(from, &chunk); + } else +#endif +#ifdef HAVE_CHUNKMEMSET_4 + if (dist == 4) { + chunkmemset_4(from, &chunk); + } else +#endif +#ifdef HAVE_CHUNKMEMSET_8 + if (dist == 8) { + chunkmemset_8(from, &chunk); + } else +#endif + if (dist == sz) { + loadchunk(from, &chunk); + } else if (dist < sz) { + unsigned char *end = out + len - 1; + while (len > dist) { + out = CHUNKCOPY_SAFE(out, from, dist, end); + len -= dist; + } + if (len > 0) { + out = CHUNKCOPY_SAFE(out, from, len, end); + } + return out; + } else { + out = CHUNKUNROLL(out, &dist, &len); + return CHUNKCOPY(out, out - dist, len); + } + + unsigned rem = len % sz; + len -= rem; + while (len) { + storechunk(out, &chunk); + out += sz; + len -= sz; + } + + /* Last, deal with the case when LEN is not a multiple of SZ. */ + if (rem) + memcpy(out, from, rem); + out += rem; + + return out; +} + +Z_INTERNAL uint8_t* CHUNKMEMSET_SAFE(uint8_t *out, unsigned dist, unsigned len, unsigned left) { + if (left < (unsigned)(3 * sizeof(chunk_t))) { + while (len > 0) { + *out = *(out - dist); + out++; + --len; + } + return out; + } + return CHUNKMEMSET(out, dist, len); +} diff --git a/libs/zlibng/cmake/detect-arch.c b/libs/zlibng/cmake/detect-arch.c new file mode 100644 index 000000000..571553582 --- /dev/null +++ b/libs/zlibng/cmake/detect-arch.c @@ -0,0 +1,99 @@ +// archdetect.c -- Detect compiler architecture and raise preprocessor error +// containing a simple arch identifier. +// Copyright (C) 2019 Hans Kristian Rosbach +// Licensed under the Zlib license, see LICENSE.md for details + +// x86_64 +#if defined(__x86_64__) || defined(_M_X64) + #error archfound x86_64 + +// x86 +#elif defined(__i386) || defined(_M_IX86) + #error archfound i686 + +// ARM +#elif defined(__aarch64__) || defined(_M_ARM64) + #error archfound aarch64 +#elif defined(__arm__) || defined(__arm) || defined(_M_ARM) || defined(__TARGET_ARCH_ARM) + #if defined(__ARM64_ARCH_8__) || defined(__ARMv8__) || defined(__ARMv8_A__) + #error archfound armv8 + #elif defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) + #error archfound armv7 + #elif defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6T2__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6ZK__) || defined(__ARM_ARCH_6M__) + #error archfound armv6 + #elif defined(__ARM_ARCH_5T__) || defined(__ARM_ARCH_5TE__) || defined(__ARM_ARCH_5TEJ__) + #error archfound armv5 + #elif defined(__ARM_ARCH_4T__) || defined(__TARGET_ARCH_5E__) + #error archfound armv4 + #elif defined(__ARM_ARCH_3__) || defined(__TARGET_ARCH_3M__) + #error archfound armv3 + #elif defined(__ARM_ARCH_2__) + #error archfound armv2 + #endif + +// PowerPC +#elif defined(__powerpc__) || defined(_ppc__) || defined(__PPC__) + #if defined(__64BIT__) || defined(__powerpc64__) || defined(__ppc64__) + #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + #error archfound powerpc64le + #else + #error archfound powerpc64 + #endif + #else + #error archfound powerpc + #endif + +// --------------- Less common architectures alphabetically below --------------- + +// ALPHA +#elif defined(__alpha__) || defined(__alpha) + #error archfound alpha + +// Blackfin +#elif defined(__BFIN__) + #error archfound blackfin + +// Itanium +#elif defined(__ia64) || defined(_M_IA64) + #error archfound ia64 + +// MIPS +#elif defined(__mips__) || defined(__mips) + #error archfound mips + +// Motorola 68000-series +#elif defined(__m68k__) + #error archfound m68k + +// SuperH +#elif defined(__sh__) + #error archfound sh + +// SPARC +#elif defined(__sparc__) || defined(__sparc) + #if defined(__sparcv9) || defined(__sparc_v9__) + #error archfound sparc9 + #elif defined(__sparcv8) || defined(__sparc_v8__) + #error archfound sparc8 + #endif + +// SystemZ +#elif defined(__370__) + #error archfound s370 +#elif defined(__s390__) + #error archfound s390 +#elif defined(__s390x) || defined(__zarch__) + #error archfound s390x + +// PARISC +#elif defined(__hppa__) + #error archfound parisc + +// RS-6000 +#elif defined(__THW_RS6000) + #error archfound rs6000 + +// return 'unrecognized' if we do not know what architecture this is +#else + #error archfound unrecognized +#endif diff --git a/libs/zlibng/cmake/detect-arch.cmake b/libs/zlibng/cmake/detect-arch.cmake new file mode 100644 index 000000000..b80d6666f --- /dev/null +++ b/libs/zlibng/cmake/detect-arch.cmake @@ -0,0 +1,93 @@ +# detect-arch.cmake -- Detect compiler architecture and set ARCH and BASEARCH +# Copyright (C) 2019 Hans Kristian Rosbach +# Licensed under the Zlib license, see LICENSE.md for details +set(ARCHDETECT_FOUND TRUE) + +if(CMAKE_OSX_ARCHITECTURES) + # If multiple architectures are requested (universal build), pick only the first + list(GET CMAKE_OSX_ARCHITECTURES 0 ARCH) +elseif(MSVC) + if("${MSVC_C_ARCHITECTURE_ID}" STREQUAL "X86") + set(ARCH "i686") + elseif("${MSVC_C_ARCHITECTURE_ID}" STREQUAL "x64") + set(ARCH "x86_64") + elseif("${MSVC_C_ARCHITECTURE_ID}" STREQUAL "ARM" OR "${MSVC_C_ARCHITECTURE_ID}" STREQUAL "ARMV7") + set(ARCH "arm") + elseif ("${MSVC_C_ARCHITECTURE_ID}" STREQUAL "ARM64") + set(ARCH "aarch64") + endif() +elseif(CMAKE_CROSSCOMPILING) + set(ARCH ${CMAKE_C_COMPILER_TARGET}) +else() + # Let preprocessor parse archdetect.c and raise an error containing the arch identifier + enable_language(C) + try_run( + run_result_unused + compile_result_unused + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/cmake/detect-arch.c + COMPILE_OUTPUT_VARIABLE RAWOUTPUT + CMAKE_FLAGS CMAKE_OSX_ARCHITECTURES=${CMAKE_OSX_ARCHITECTURES} + ) + + # Find basearch tag, and extract the arch word into BASEARCH variable + string(REGEX REPLACE ".*archfound ([a-zA-Z0-9_]+).*" "\\1" ARCH "${RAWOUTPUT}") + if(NOT ARCH) + set(ARCH unknown) + endif() +endif() + +# Make sure we have ARCH set +if(NOT ARCH OR ARCH STREQUAL "unknown") + set(ARCH ${CMAKE_SYSTEM_PROCESSOR}) + message(STATUS "Arch not recognized, falling back to cmake arch: '${ARCH}'") +else() + message(STATUS "Arch detected: '${ARCH}'") +endif() + +# Base arch detection +if("${ARCH}" MATCHES "(x86_64|AMD64|i[3-6]86)") + set(BASEARCH "x86") + set(BASEARCH_X86_FOUND TRUE) +elseif("${ARCH}" MATCHES "(arm(v[0-9])?|aarch64)") + set(BASEARCH "arm") + set(BASEARCH_ARM_FOUND TRUE) +elseif("${ARCH}" MATCHES "ppc(64(le)?)?|powerpc(64(le)?)?") + set(BASEARCH "ppc") + set(BASEARCH_PPC_FOUND TRUE) +elseif("${ARCH}" MATCHES "alpha") + set(BASEARCH "alpha") + set(BASEARCH_ALPHA_FOUND TRUE) +elseif("${ARCH}" MATCHES "blackfin") + set(BASEARCH "blackfin") + set(BASEARCH_BLACKFIN_FOUND TRUE) +elseif("${ARCH}" MATCHES "ia64") + set(BASEARCH "ia64") + set(BASEARCH_IA64_FOUND TRUE) +elseif("${ARCH}" MATCHES "mips") + set(BASEARCH "mips") + set(BASEARCH_MIPS_FOUND TRUE) +elseif("${ARCH}" MATCHES "m68k") + set(BASEARCH "m68k") + set(BASEARCH_M68K_FOUND TRUE) +elseif("${ARCH}" MATCHES "sh") + set(BASEARCH "sh") + set(BASEARCH_SH_FOUND TRUE) +elseif("${ARCH}" MATCHES "sparc[89]?") + set(BASEARCH "sparc") + set(BASEARCH_SPARC_FOUND TRUE) +elseif("${ARCH}" MATCHES "s3[679]0x?") + set(BASEARCH "s360") + set(BASEARCH_S360_FOUND TRUE) +elseif("${ARCH}" MATCHES "parisc") + set(BASEARCH "parisc") + set(BASEARCH_PARISC_FOUND TRUE) +elseif("${ARCH}" MATCHES "rs6000") + set(BASEARCH "rs6000") + set(BASEARCH_RS6000_FOUND TRUE) +else() + set(BASEARCH "x86") + set(BASEARCH_X86_FOUND TRUE) + message(STATUS "Basearch '${ARCH}' not recognized, defaulting to 'x86'.") +endif() +message(STATUS "Basearch of '${ARCH}' has been detected as: '${BASEARCH}'") diff --git a/libs/zlibng/cmake/detect-sanitizer.cmake b/libs/zlibng/cmake/detect-sanitizer.cmake new file mode 100644 index 000000000..172a8d558 --- /dev/null +++ b/libs/zlibng/cmake/detect-sanitizer.cmake @@ -0,0 +1,123 @@ +# detect-sanitizer.cmake -- Detect supported compiler sanitizer flags +# Licensed under the Zlib license, see LICENSE.md for details + +macro(check_sanitizer_support known_checks supported_checks) + set(available_checks "") + + # Build list of supported sanitizer flags by incrementally trying compilation with + # known sanitizer checks + + foreach(check ${known_checks}) + if(available_checks STREQUAL "") + set(compile_checks "${check}") + else() + set(compile_checks "${available_checks},${check}") + endif() + + set(CMAKE_REQUIRED_FLAGS "-fsanitize=${compile_checks}") + + check_c_source_compiles("int main() { return 0; }" HAS_SANITIZER_${check} + FAIL_REGEX "not supported|unrecognized command|unknown option") + + set(CMAKE_REQUIRED_FLAGS) + + if(HAS_SANITIZER_${check}) + set(available_checks ${compile_checks}) + endif() + endforeach() + + set(${supported_checks} ${available_checks}) +endmacro() + +macro(add_address_sanitizer) + set(known_checks + address + pointer-compare + pointer-subtract + ) + + check_sanitizer_support("${known_checks}" supported_checks) + if(NOT ${supported_checks} STREQUAL "") + message(STATUS "Address sanitizer is enabled: ${supported_checks}") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=${supported_checks}") + else() + message(STATUS "Address sanitizer is not supported") + endif() + + if(CMAKE_CROSSCOMPILING_EMULATOR) + # Only check for leak sanitizer if not cross-compiling due to qemu crash + message(WARNING "Leak sanitizer is not supported when cross compiling") + else() + # Leak sanitizer requires address sanitizer + check_sanitizer_support("leak" supported_checks) + if(NOT ${supported_checks} STREQUAL "") + message(STATUS "Leak sanitizer is enabled: ${supported_checks}") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=${supported_checks}") + else() + message(STATUS "Leak sanitizer is not supported") + endif() + endif() +endmacro() + +macro(add_memory_sanitizer) + check_sanitizer_support("memory" supported_checks) + if(NOT ${supported_checks} STREQUAL "") + message(STATUS "Memory sanitizer is enabled: ${supported_checks}") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=${supported_checks}") + else() + message(STATUS "Memory sanitizer is not supported") + endif() +endmacro() + +macro(add_undefined_sanitizer) + set(known_checks + array-bounds + bool + bounds + builtin + enum + float-cast-overflow + float-divide-by-zero + function + integer-divide-by-zero + local-bounds + null + nonnull-attribute + pointer-overflow + return + returns-nonnull-attribute + shift + shift-base + shift-exponent + signed-integer-overflow + undefined + unsigned-integer-overflow + unsigned-shift-base + vla-bound + vptr + ) + + # Only check for alignment sanitizer flag if unaligned access is not supported + if(NOT UNALIGNED_OK) + list(APPEND known_checks alignment) + endif() + # Object size sanitizer has no effect at -O0 and produces compiler warning if enabled + if(NOT CMAKE_C_FLAGS MATCHES "-O0") + list(APPEND known_checks object-size) + endif() + + check_sanitizer_support("${known_checks}" supported_checks) + + if(NOT ${supported_checks} STREQUAL "") + message(STATUS "Undefined behavior sanitizer is enabled: ${supported_checks}") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=${supported_checks}") + + # Group sanitizer flag -fsanitize=undefined will automatically add alignment, even if + # it is not in our sanitize flag list, so we need to explicitly disable alignment sanitizing. + if(UNALIGNED_OK) + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fno-sanitize=alignment") + endif() + else() + message(STATUS "UNdefined behavior sanitizer is not supported") + endif() +endmacro() \ No newline at end of file diff --git a/libs/zlibng/cmake/run-and-compare.cmake b/libs/zlibng/cmake/run-and-compare.cmake new file mode 100644 index 000000000..0e9343373 --- /dev/null +++ b/libs/zlibng/cmake/run-and-compare.cmake @@ -0,0 +1,48 @@ +if(NOT DEFINED OUTPUT OR NOT DEFINED COMPARE OR NOT DEFINED COMMAND) + message(FATAL_ERROR "Run and compare arguments missing") +endif() + +if(INPUT) + # Run command with stdin input and redirect stdout to output + execute_process(COMMAND ${CMAKE_COMMAND} + "-DCOMMAND=${COMMAND}" + -DINPUT=${INPUT} + -DOUTPUT=${OUTPUT} + "-DSUCCESS_EXIT=${SUCCESS_EXIT}" + -P ${CMAKE_CURRENT_LIST_DIR}/run-and-redirect.cmake + RESULT_VARIABLE CMD_RESULT) +else() + # Run command and redirect stdout to output + execute_process(COMMAND ${CMAKE_COMMAND} + "-DCOMMAND=${COMMAND}" + -DOUTPUT=${OUTPUT} + "-DSUCCESS_EXIT=${SUCCESS_EXIT}" + -P ${CMAKE_CURRENT_LIST_DIR}/run-and-redirect.cmake + RESULT_VARIABLE CMD_RESULT) +endif() + +if(CMD_RESULT) + message(FATAL_ERROR "Run before compare failed: ${CMD_RESULT}") +endif() + +# Use configure_file to normalize line-endings +if(IGNORE_LINE_ENDINGS) + configure_file(${COMPARE} ${COMPARE}.cmp NEWLINE_STYLE LF) + set(COMPARE ${COMPARE}.cmp) + configure_file(${OUTPUT} ${OUTPUT}.cmp NEWLINE_STYLE LF) + set(OUTPUT ${OUTPUT}.cmp) +endif() + +# Compare that output is equal to specified file +execute_process(COMMAND ${CMAKE_COMMAND} + -E compare_files ${COMPARE} ${OUTPUT} + RESULT_VARIABLE CMD_RESULT) + +# Delete temporary files used to normalize line-endings +if(IGNORE_LINE_ENDINGS) + file(REMOVE ${COMPARE} ${OUTPUT}) +endif() + +if(CMD_RESULT) + message(FATAL_ERROR "Run compare failed: ${CMD_RESULT}") +endif() \ No newline at end of file diff --git a/libs/zlibng/cmake/run-and-redirect.cmake b/libs/zlibng/cmake/run-and-redirect.cmake new file mode 100644 index 000000000..30c574112 --- /dev/null +++ b/libs/zlibng/cmake/run-and-redirect.cmake @@ -0,0 +1,38 @@ +# If no output is specified, discard output +if(NOT DEFINED OUTPUT) + if(WIN32) + set(OUTPUT NUL) + else() + set(OUTPUT /dev/null) + endif() +endif() + +if(INPUT) + # Check to see that input file exists + if(NOT EXISTS ${INPUT}) + message(FATAL_ERROR "Cannot find input: ${INPUT}") + endif() + # Execute with both stdin and stdout file + execute_process(COMMAND ${COMMAND} + RESULT_VARIABLE CMD_RESULT + INPUT_FILE ${INPUT} + OUTPUT_FILE ${OUTPUT}) +else() + # Execute with only stdout file + execute_process(COMMAND ${COMMAND} + RESULT_VARIABLE CMD_RESULT + OUTPUT_FILE ${OUTPUT}) +endif() + +# Check if exit code is in list of successful exit codes +if(SUCCESS_EXIT) + list(FIND SUCCESS_EXIT ${CMD_RESULT} _INDEX) + if (${_INDEX} GREATER -1) + set(CMD_RESULT 0) + endif() +endif() + +# Check to see if successful +if(CMD_RESULT) + message(FATAL_ERROR "${COMMAND} failed: ${CMD_RESULT}") +endif() diff --git a/libs/zlibng/cmake/test-compress.cmake b/libs/zlibng/cmake/test-compress.cmake new file mode 100644 index 000000000..75355bc73 --- /dev/null +++ b/libs/zlibng/cmake/test-compress.cmake @@ -0,0 +1,188 @@ +if(TARGET) + set(COMPRESS_TARGET ${TARGET}) + set(DECOMPRESS_TARGET ${TARGET}) +endif() + +if(NOT DEFINED INPUT OR NOT DEFINED COMPRESS_TARGET OR NOT DEFINED DECOMPRESS_TARGET) + message(FATAL_ERROR "Compress test arguments missing") +endif() + +# Set default values +if(NOT DEFINED COMPARE) + set(COMPARE ON) +endif() +if(NOT DEFINED COMPRESS_ARGS) + set(COMPRESS_ARGS -c -k) +endif() +if(NOT DEFINED DECOMPRESS_ARGS) + set(DECOMPRESS_ARGS -d -c) +endif() +if(NOT DEFINED GZIP_VERIFY) + set(GZIP_VERIFY ON) +endif() +if(NOT DEFINED SUCCESS_EXIT) + set(SUCCESS_EXIT 0) +endif() + +# Generate unique output path so multiple tests can be executed at the same time +if(NOT OUTPUT) + # Output name based on input and unique id + string(RANDOM UNIQUE_ID) + set(OUTPUT ${INPUT}-${UNIQUE_ID}) +else() + # Output name appends unique id in case multiple tests with same output name + string(RANDOM LENGTH 6 UNIQUE_ID) + set(OUTPUT ${OUTPUT}-${UNIQUE_ID}) +endif() +string(REPLACE ".gz" "" OUTPUT "${OUTPUT}") + +macro(cleanup) + # Cleanup temporary mingizip files + file(REMOVE ${OUTPUT}.gz ${OUTPUT}.out) + # Cleanup temporary gzip files + file(REMOVE ${OUTPUT}.gzip.gz ${OUTPUT}.gzip.out) +endmacro() + +# Compress input file +if(NOT EXISTS ${INPUT}) + message(FATAL_ERROR "Cannot find compress input: ${INPUT}") +endif() + +set(COMPRESS_COMMAND ${COMPRESS_TARGET} ${COMPRESS_ARGS}) + +execute_process(COMMAND ${CMAKE_COMMAND} + "-DCOMMAND=${COMPRESS_COMMAND}" + -DINPUT=${INPUT} + -DOUTPUT=${OUTPUT}.gz + "-DSUCCESS_EXIT=${SUCCESS_EXIT}" + -P ${CMAKE_CURRENT_LIST_DIR}/run-and-redirect.cmake + RESULT_VARIABLE CMD_RESULT) + +if(CMD_RESULT) + cleanup() + message(FATAL_ERROR "Compress failed: ${CMD_RESULT}") +endif() + +# Decompress output +if(NOT EXISTS ${OUTPUT}.gz) + cleanup() + message(FATAL_ERROR "Cannot find decompress input: ${OUTPUT}.gz") +endif() + +set(DECOMPRESS_COMMAND ${DECOMPRESS_TARGET} ${DECOMPRESS_ARGS}) + +execute_process(COMMAND ${CMAKE_COMMAND} + "-DCOMMAND=${DECOMPRESS_COMMAND}" + -DINPUT=${OUTPUT}.gz + -DOUTPUT=${OUTPUT}.out + "-DSUCCESS_EXIT=${SUCCESS_EXIT}" + -P ${CMAKE_CURRENT_LIST_DIR}/run-and-redirect.cmake + RESULT_VARIABLE CMD_RESULT) + +if(CMD_RESULT) + cleanup() + message(FATAL_ERROR "Decompress failed: ${CMD_RESULT}") +endif() + +if(COMPARE) + # Compare decompressed output with original input file + execute_process(COMMAND ${CMAKE_COMMAND} + -E compare_files ${INPUT} ${OUTPUT}.out + RESULT_VARIABLE CMD_RESULT) + + if(CMD_RESULT) + cleanup() + message(FATAL_ERROR "Compare minigzip decompress failed: ${CMD_RESULT}") + endif() +endif() + +if(GZIP_VERIFY AND NOT "${COMPRESS_ARGS}" MATCHES "-T") + # Transparent writing does not use gzip format + find_program(GZIP gzip) + if(GZIP) + if(NOT EXISTS ${OUTPUT}.gz) + cleanup() + message(FATAL_ERROR "Cannot find gzip decompress input: ${OUTPUT}.gz") + endif() + + # Check gzip can decompress our compressed output + set(GZ_DECOMPRESS_COMMAND ${GZIP} --decompress) + + execute_process(COMMAND ${CMAKE_COMMAND} + "-DCOMMAND=${GZ_DECOMPRESS_COMMAND}" + -DINPUT=${OUTPUT}.gz + -DOUTPUT=${OUTPUT}.gzip.out + "-DSUCCESS_EXIT=${SUCCESS_EXIT}" + -P ${CMAKE_CURRENT_LIST_DIR}/run-and-redirect.cmake + RESULT_VARIABLE CMD_RESULT) + + if(CMD_RESULT) + cleanup() + message(FATAL_ERROR "Gzip decompress failed: ${CMD_RESULT}") + endif() + + # Compare gzip output with original input file + execute_process(COMMAND ${CMAKE_COMMAND} + -E compare_files ${INPUT} ${OUTPUT}.gzip.out + RESULT_VARIABLE CMD_RESULT) + + if(CMD_RESULT) + cleanup() + message(FATAL_ERROR "Compare gzip decompress failed: ${CMD_RESULT}") + endif() + + if(NOT EXISTS ${OUTPUT}.gz) + cleanup() + message(FATAL_ERROR "Cannot find gzip compress input: ${INPUT}") + endif() + + # Compress input file with gzip + set(GZ_COMPRESS_COMMAND ${GZIP} --stdout) + + execute_process(COMMAND ${CMAKE_COMMAND} + "-DCOMMAND=${GZ_COMPRESS_COMMAND}" + -DINPUT=${INPUT} + -DOUTPUT=${OUTPUT}.gzip.gz + "-DSUCCESS_EXIT=${SUCCESS_EXIT}" + -P ${CMAKE_CURRENT_LIST_DIR}/run-and-redirect.cmake + RESULT_VARIABLE CMD_RESULT) + + if(CMD_RESULT) + cleanup() + message(FATAL_ERROR "Gzip compress failed: ${CMD_RESULT}") + endif() + + if(NOT EXISTS ${OUTPUT}.gz) + cleanup() + message(FATAL_ERROR "Cannot find minigzip decompress input: ${OUTPUT}.gzip.gz") + endif() + + # Check minigzip can decompress gzip compressed output + execute_process(COMMAND ${CMAKE_COMMAND} + "-DCOMMAND=${DECOMPRESS_COMMAND}" + -DINPUT=${OUTPUT}.gzip.gz + -DOUTPUT=${OUTPUT}.gzip.out + "-DSUCCESS_EXIT=${SUCCESS_EXIT}" + -P ${CMAKE_CURRENT_LIST_DIR}/run-and-redirect.cmake + RESULT_VARIABLE CMD_RESULT) + + if(CMD_RESULT) + cleanup() + message(FATAL_ERROR "Minigzip decompress gzip failed: ${CMD_RESULT}") + endif() + + if(COMPARE) + # Compare original input file with gzip decompressed output + execute_process(COMMAND ${CMAKE_COMMAND} + -E compare_files ${INPUT} ${OUTPUT}.gzip.out + RESULT_VARIABLE CMD_RESULT) + + if(CMD_RESULT) + cleanup() + message(FATAL_ERROR "Compare minigzip decompress gzip failed: ${CMD_RESULT}") + endif() + endif() + endif() +endif() + +cleanup() \ No newline at end of file diff --git a/libs/zlibng/cmake/toolchain-aarch64.cmake b/libs/zlibng/cmake/toolchain-aarch64.cmake new file mode 100644 index 000000000..31894fdcd --- /dev/null +++ b/libs/zlibng/cmake/toolchain-aarch64.cmake @@ -0,0 +1,26 @@ +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_PROCESSOR aarch64) +set(CMAKE_SYSTEM_VERSION 1) + +message(STATUS "Using cross-compile toolchain: ${CROSS_COMPILE_TOOLCHAIN}") + +set(CMAKE_C_COMPILER_TARGET "aarch64-linux-gnu") +set(CMAKE_CXX_COMPILER_TARGET "aarch64-linux-gnu") + +set(CMAKE_CROSSCOMPILING TRUE) +set(CMAKE_CROSSCOMPILING_EMULATOR qemu-aarch64 -L /usr/${CMAKE_C_COMPILER_TARGET}/) + +SET(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +SET(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +SET(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) + +find_program(C_COMPILER_FULL_PATH ${CMAKE_C_COMPILER_TARGET}-gcc) +if(NOT C_COMPILER_FULL_PATH) + message(FATAL_ERROR "Cross-compiler ${CMAKE_C_COMPILER_TARGET}-gcc not found") +endif() +set(CMAKE_C_COMPILER ${C_COMPILER_FULL_PATH}) + +find_program(CXX_COMPILER_FULL_PATH ${CMAKE_C_COMPILER_TARGET}-g++) +if(CXX_COMPILER_FULL_PATH) + set(CMAKE_CXX_COMPILER ${CXX_COMPILER_FULL_PATH}) +endif() diff --git a/libs/zlibng/cmake/toolchain-arm.cmake b/libs/zlibng/cmake/toolchain-arm.cmake new file mode 100644 index 000000000..0e3c5c377 --- /dev/null +++ b/libs/zlibng/cmake/toolchain-arm.cmake @@ -0,0 +1,24 @@ +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_PROCESSOR arm) +set(CMAKE_SYSTEM_VERSION 1) + +message(STATUS "Using cross-compile toolchain: ${CMAKE_C_COMPILER_TARGET}") + +set(CMAKE_CROSSCOMPILING TRUE) +set(CMAKE_CROSSCOMPILING_EMULATOR qemu-arm -L /usr/${CMAKE_C_COMPILER_TARGET}/) + +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) + +find_program(C_COMPILER_FULL_PATH ${CMAKE_C_COMPILER_TARGET}-gcc) +if(NOT C_COMPILER_FULL_PATH) + message(FATAL_ERROR "Cross-compiler ${CMAKE_C_COMPILER_TARGET}-gcc not found") +endif() +set(CMAKE_C_COMPILER ${C_COMPILER_FULL_PATH}) + +find_program(CXX_COMPILER_FULL_PATH ${CMAKE_C_COMPILER_TARGET}-g++) +if(CXX_COMPILER_FULL_PATH) + set(CMAKE_CXX_COMPILER ${CXX_COMPILER_FULL_PATH}) +endif() diff --git a/libs/zlibng/cmake/toolchain-mingw-i686.cmake b/libs/zlibng/cmake/toolchain-mingw-i686.cmake new file mode 100644 index 000000000..588ec0ef9 --- /dev/null +++ b/libs/zlibng/cmake/toolchain-mingw-i686.cmake @@ -0,0 +1,16 @@ +set(CMAKE_SYSTEM_NAME Windows) + +set(CMAKE_C_COMPILER_TARGET i686) +set(CMAKE_CXX_COMPILER_TARGET i686) + +set(CMAKE_C_COMPILER i686-w64-mingw32-gcc) +set(CMAKE_CXX_COMPILER i686-w64-mingw32-g++) +set(CMAKE_RC_COMPILER i686-w64-mingw32-windres) + +set(CMAKE_CROSSCOMPILING TRUE) +set(CMAKE_CROSSCOMPILING_EMULATOR wine) + +set(CMAKE_FIND_ROOT_PATH /usr/i686-w64-mingw32) +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) diff --git a/libs/zlibng/cmake/toolchain-mingw-x86_64.cmake b/libs/zlibng/cmake/toolchain-mingw-x86_64.cmake new file mode 100644 index 000000000..c778b7222 --- /dev/null +++ b/libs/zlibng/cmake/toolchain-mingw-x86_64.cmake @@ -0,0 +1,16 @@ +set(CMAKE_SYSTEM_NAME Windows) + +set(CMAKE_C_COMPILER_TARGET x86_64) +set(CMAKE_CXX_COMPILER_TARGET x86_64) + +set(CMAKE_C_COMPILER x86_64-w64-mingw32-gcc) +set(CMAKE_CXX_COMPILER x86_64-w64-mingw32-g++) +set(CMAKE_RC_COMPILER x86_64-w64-mingw32-windres) + +set(CMAKE_CROSSCOMPILING TRUE) +set(CMAKE_CROSSCOMPILING_EMULATOR wine) + +set(CMAKE_FIND_ROOT_PATH /usr/x86_64-w64-mingw32) +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) diff --git a/libs/zlibng/cmake/toolchain-powerpc.cmake b/libs/zlibng/cmake/toolchain-powerpc.cmake new file mode 100644 index 000000000..4f7f8e92f --- /dev/null +++ b/libs/zlibng/cmake/toolchain-powerpc.cmake @@ -0,0 +1,25 @@ +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_PROCESSOR powerpc) +set(CMAKE_SYSTEM_VERSION 1) + +set(CMAKE_C_COMPILER_TARGET "powerpc-linux-gnu") +set(CMAKE_CXX_COMPILER_TARGET "powerpc-linux-gnu") + +set(CMAKE_CROSSCOMPILING TRUE) +set(CMAKE_CROSSCOMPILING_EMULATOR qemu-ppc -L /usr/${CMAKE_C_COMPILER_TARGET}/) + +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) + +find_program(C_COMPILER_FULL_PATH ${CMAKE_C_COMPILER_TARGET}-gcc) +if(NOT C_COMPILER_FULL_PATH) + message(FATAL_ERROR "Cross-compiler ${CMAKE_C_COMPILER_TARGET}-gcc not found") +endif() +set(CMAKE_C_COMPILER ${C_COMPILER_FULL_PATH}) + +find_program(CXX_COMPILER_FULL_PATH ${CMAKE_C_COMPILER_TARGET}-g++) +if(CXX_COMPILER_FULL_PATH) + set(CMAKE_CXX_COMPILER ${CXX_COMPILER_FULL_PATH}) +endif() diff --git a/libs/zlibng/cmake/toolchain-powerpc64.cmake b/libs/zlibng/cmake/toolchain-powerpc64.cmake new file mode 100644 index 000000000..4be3bbd59 --- /dev/null +++ b/libs/zlibng/cmake/toolchain-powerpc64.cmake @@ -0,0 +1,25 @@ +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_PROCESSOR ppc64) +set(CMAKE_SYSTEM_VERSION 1) + +set(CMAKE_C_COMPILER_TARGET "powerpc64-linux-gnu") +set(CMAKE_CXX_COMPILER_TARGET "powerpc64-linux-gnu") + +set(CMAKE_CROSSCOMPILING TRUE) +set(CMAKE_CROSSCOMPILING_EMULATOR qemu-ppc64 -L /usr/${CMAKE_C_COMPILER_TARGET}/) + +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) + +find_program(C_COMPILER_FULL_PATH ${CMAKE_C_COMPILER_TARGET}-gcc) +if(NOT C_COMPILER_FULL_PATH) + message(FATAL_ERROR "Cross-compiler ${CMAKE_C_COMPILER_TARGET}-gcc not found") +endif() +set(CMAKE_C_COMPILER ${C_COMPILER_FULL_PATH}) + +find_program(CXX_COMPILER_FULL_PATH ${CMAKE_C_COMPILER_TARGET}-g++) +if(CXX_COMPILER_FULL_PATH) + set(CMAKE_CXX_COMPILER ${CXX_COMPILER_FULL_PATH}) +endif() diff --git a/libs/zlibng/cmake/toolchain-powerpc64le.cmake b/libs/zlibng/cmake/toolchain-powerpc64le.cmake new file mode 100644 index 000000000..5535f616f --- /dev/null +++ b/libs/zlibng/cmake/toolchain-powerpc64le.cmake @@ -0,0 +1,25 @@ +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_PROCESSOR ppc64le) +set(CMAKE_SYSTEM_VERSION 1) + +set(CMAKE_C_COMPILER_TARGET "powerpc64le-linux-gnu") +set(CMAKE_CXX_COMPILER_TARGET "powerpc64le-linux-gnu") + +set(CMAKE_CROSSCOMPILING TRUE) +set(CMAKE_CROSSCOMPILING_EMULATOR qemu-ppc64le -L /usr/${CMAKE_C_COMPILER_TARGET}/) + +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) + +find_program(C_COMPILER_FULL_PATH ${CMAKE_C_COMPILER_TARGET}-gcc) +if(NOT C_COMPILER_FULL_PATH) + message(FATAL_ERROR "Cross-compiler ${CMAKE_C_COMPILER_TARGET}-gcc not found") +endif() +set(CMAKE_C_COMPILER ${C_COMPILER_FULL_PATH}) + +find_program(CXX_COMPILER_FULL_PATH ${CMAKE_C_COMPILER_TARGET}-g++) +if(CXX_COMPILER_FULL_PATH) + set(CMAKE_CXX_COMPILER ${CXX_COMPILER_FULL_PATH}) +endif() diff --git a/libs/zlibng/cmake/toolchain-s390x.cmake b/libs/zlibng/cmake/toolchain-s390x.cmake new file mode 100644 index 000000000..41bc0d101 --- /dev/null +++ b/libs/zlibng/cmake/toolchain-s390x.cmake @@ -0,0 +1,25 @@ +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_PROCESSOR s390x) +set(CMAKE_SYSTEM_VERSION 1) + +set(CMAKE_C_COMPILER_TARGET "s390x-linux-gnu") +set(CMAKE_CXX_COMPILER_TARGET "s390x-linux-gnu") + +set(CMAKE_CROSSCOMPILING TRUE) +set(CMAKE_CROSSCOMPILING_EMULATOR qemu-s390x -L /usr/${CMAKE_C_COMPILER_TARGET}/) + +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) + +find_program(C_COMPILER_FULL_PATH ${CMAKE_C_COMPILER_TARGET}-gcc) +if(NOT C_COMPILER_FULL_PATH) + message(FATAL_ERROR "Cross-compiler ${CMAKE_C_COMPILER_TARGET}-gcc not found") +endif() +set(CMAKE_C_COMPILER ${C_COMPILER_FULL_PATH}) + +find_program(CXX_COMPILER_FULL_PATH ${CMAKE_C_COMPILER_TARGET}-g++) +if(CXX_COMPILER_FULL_PATH) + set(CMAKE_CXX_COMPILER ${CXX_COMPILER_FULL_PATH}) +endif() diff --git a/libs/zlibng/cmake/toolchain-sparc64.cmake b/libs/zlibng/cmake/toolchain-sparc64.cmake new file mode 100644 index 000000000..f0cd99565 --- /dev/null +++ b/libs/zlibng/cmake/toolchain-sparc64.cmake @@ -0,0 +1,25 @@ +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_PROCESSOR sparc64) +set(CMAKE_SYSTEM_VERSION 1) + +set(CMAKE_C_COMPILER_TARGET "sparc64-linux-gnu") +set(CMAKE_CXX_COMPILER_TARGET "sparc64-linux-gnu") + +set(CMAKE_CROSSCOMPILING TRUE) +set(CMAKE_CROSSCOMPILING_EMULATOR qemu-sparc64 -L /usr/${CMAKE_C_COMPILER_TARGET}/) + +set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) + +find_program(C_COMPILER_FULL_PATH ${CMAKE_C_COMPILER_TARGET}-gcc) +if(NOT C_COMPILER_FULL_PATH) + message(FATAL_ERROR "Cross-compiler ${CMAKE_C_COMPILER_TARGET}-gcc not found") +endif() +set(CMAKE_C_COMPILER ${C_COMPILER_FULL_PATH}) + +find_program(CXX_COMPILER_FULL_PATH ${CMAKE_C_COMPILER_TARGET}-g++) +if(CXX_COMPILER_FULL_PATH) + set(CMAKE_CXX_COMPILER ${CXX_COMPILER_FULL_PATH}) +endif() diff --git a/libs/zlibng/compare258.c b/libs/zlibng/compare258.c new file mode 100644 index 000000000..bc41638ae --- /dev/null +++ b/libs/zlibng/compare258.c @@ -0,0 +1,186 @@ +/* compare258.c -- aligned and unaligned versions of compare258 + * Copyright (C) 2020 Nathan Moinvaziri + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "zbuild.h" +#include "zutil.h" + +#include "fallback_builtins.h" + +/* ALIGNED, byte comparison */ +static inline uint32_t compare256_c_static(const unsigned char *src0, const unsigned char *src1) { + uint32_t len = 0; + + do { + if (*src0 != *src1) + return len + (*src0 == *src1); + src0 += 1, src1 += 1, len += 1; + if (*src0 != *src1) + return len + (*src0 == *src1); + src0 += 1, src1 += 1, len += 1; + if (*src0 != *src1) + return len + (*src0 == *src1); + src0 += 1, src1 += 1, len += 1; + if (*src0 != *src1) + return len + (*src0 == *src1); + src0 += 1, src1 += 1, len += 1; + if (*src0 != *src1) + return len + (*src0 == *src1); + src0 += 1, src1 += 1, len += 1; + if (*src0 != *src1) + return len + (*src0 == *src1); + src0 += 1, src1 += 1, len += 1; + if (*src0 != *src1) + return len + (*src0 == *src1); + src0 += 1, src1 += 1, len += 1; + if (*src0 != *src1) + return len + (*src0 == *src1); + src0 += 1, src1 += 1, len += 1; + } while (len < 256); + + return 256; +} + +static inline uint32_t compare258_c_static(const unsigned char *src0, const unsigned char *src1) { + if (*src0 != *src1) + return 0; + src0 += 1, src1 += 1; + if (*src0 != *src1) + return 1; + src0 += 1, src1 += 1; + + return compare256_c_static(src0, src1) + 2; +} + +Z_INTERNAL uint32_t compare258_c(const unsigned char *src0, const unsigned char *src1) { + return compare258_c_static(src0, src1); +} + +#define LONGEST_MATCH longest_match_c +#define COMPARE256 compare256_c_static +#define COMPARE258 compare258_c_static + +#include "match_tpl.h" + +#ifdef UNALIGNED_OK +/* UNALIGNED_OK, 16-bit integer comparison */ +static inline uint32_t compare256_unaligned_16_static(const unsigned char *src0, const unsigned char *src1) { + uint32_t len = 0; + + do { + if (*(uint16_t *)src0 != *(uint16_t *)src1) + return len + (*src0 == *src1); + src0 += 2, src1 += 2, len += 2; + if (*(uint16_t *)src0 != *(uint16_t *)src1) + return len + (*src0 == *src1); + src0 += 2, src1 += 2, len += 2; + if (*(uint16_t *)src0 != *(uint16_t *)src1) + return len + (*src0 == *src1); + src0 += 2, src1 += 2, len += 2; + if (*(uint16_t *)src0 != *(uint16_t *)src1) + return len + (*src0 == *src1); + src0 += 2, src1 += 2, len += 2; + } while (len < 256); + + return 256; +} + +static inline uint32_t compare258_unaligned_16_static(const unsigned char *src0, const unsigned char *src1) { + if (*(uint16_t *)src0 != *(uint16_t *)src1) + return (*src0 == *src1); + + return compare256_unaligned_16_static(src0+2, src1+2) + 2; +} + +Z_INTERNAL uint32_t compare258_unaligned_16(const unsigned char *src0, const unsigned char *src1) { + return compare258_unaligned_16_static(src0, src1); +} + +#define LONGEST_MATCH longest_match_unaligned_16 +#define COMPARE256 compare256_unaligned_16_static +#define COMPARE258 compare258_unaligned_16_static + +#include "match_tpl.h" + +#ifdef HAVE_BUILTIN_CTZ +/* UNALIGNED_OK, 32-bit integer comparison */ +static inline uint32_t compare256_unaligned_32_static(const unsigned char *src0, const unsigned char *src1) { + uint32_t len = 0; + + do { + uint32_t sv = *(uint32_t *)src0; + uint32_t mv = *(uint32_t *)src1; + uint32_t diff = sv ^ mv; + + if (diff) { + uint32_t match_byte = __builtin_ctz(diff) / 8; + return len + match_byte; + } + + src0 += 4, src1 += 4, len += 4; + } while (len < 256); + + return 256; +} + +static inline uint32_t compare258_unaligned_32_static(const unsigned char *src0, const unsigned char *src1) { + if (*(uint16_t *)src0 != *(uint16_t *)src1) + return (*src0 == *src1); + + return compare256_unaligned_32_static(src0+2, src1+2) + 2; +} + +Z_INTERNAL uint32_t compare258_unaligned_32(const unsigned char *src0, const unsigned char *src1) { + return compare258_unaligned_32_static(src0, src1); +} + +#define LONGEST_MATCH longest_match_unaligned_32 +#define COMPARE256 compare256_unaligned_32_static +#define COMPARE258 compare258_unaligned_32_static + +#include "match_tpl.h" + +#endif + +#if defined(UNALIGNED64_OK) && defined(HAVE_BUILTIN_CTZLL) +/* UNALIGNED64_OK, 64-bit integer comparison */ +static inline uint32_t compare256_unaligned_64_static(const unsigned char *src0, const unsigned char *src1) { + uint32_t len = 0; + + do { + uint64_t sv = *(uint64_t *)src0; + uint64_t mv = *(uint64_t *)src1; + uint64_t diff = sv ^ mv; + + if (diff) { + uint64_t match_byte = __builtin_ctzll(diff) / 8; + return len + (uint32_t)match_byte; + } + + src0 += 8, src1 += 8, len += 8; + } while (len < 256); + + return 256; +} + +static inline uint32_t compare258_unaligned_64_static(const unsigned char *src0, const unsigned char *src1) { + if (*(uint16_t *)src0 != *(uint16_t *)src1) + return (*src0 == *src1); + + return compare256_unaligned_64_static(src0+2, src1+2) + 2; +} + +Z_INTERNAL uint32_t compare258_unaligned_64(const unsigned char *src0, const unsigned char *src1) { + return compare258_unaligned_64_static(src0, src1); +} + +#define LONGEST_MATCH longest_match_unaligned_64 +#define COMPARE256 compare256_unaligned_64_static +#define COMPARE258 compare258_unaligned_64_static + +#include "match_tpl.h" + +#endif + +#endif diff --git a/libs/zlibng/compress.c b/libs/zlibng/compress.c index 6b493fda5..d5379591d 100644 --- a/libs/zlibng/compress.c +++ b/libs/zlibng/compress.c @@ -3,14 +3,12 @@ * For conditions of distribution and use, see copyright notice in zlib.h */ -/* @(#) $Id$ */ - #define ZLIB_INTERNAL #include "zbuild.h" #if defined(ZLIB_COMPAT) -# include "zlib.h" +# include "zlib.h" #else -# include "zlib-ng.h" +# include "zlib-ng.h" #endif /* =========================================================================== @@ -24,7 +22,7 @@ memory, Z_BUF_ERROR if there was not enough room in the output buffer, Z_STREAM_ERROR if the level parameter is invalid. */ -int ZEXPORT PREFIX(compress2)(unsigned char *dest, z_size_t *destLen, const unsigned char *source, +int Z_EXPORT PREFIX(compress2)(unsigned char *dest, z_size_t *destLen, const unsigned char *source, z_size_t sourceLen, int level) { PREFIX3(stream) stream; int err; @@ -44,7 +42,7 @@ int ZEXPORT PREFIX(compress2)(unsigned char *dest, z_size_t *destLen, const unsi stream.next_out = dest; stream.avail_out = 0; - stream.next_in = (const unsigned char *)source; + stream.next_in = (z_const unsigned char *)source; stream.avail_in = 0; do { @@ -66,7 +64,7 @@ int ZEXPORT PREFIX(compress2)(unsigned char *dest, z_size_t *destLen, const unsi /* =========================================================================== */ -int ZEXPORT PREFIX(compress)(unsigned char *dest, z_size_t *destLen, const unsigned char *source, z_size_t sourceLen) { +int Z_EXPORT PREFIX(compress)(unsigned char *dest, z_size_t *destLen, const unsigned char *source, z_size_t sourceLen) { return PREFIX(compress2)(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION); } @@ -74,6 +72,12 @@ int ZEXPORT PREFIX(compress)(unsigned char *dest, z_size_t *destLen, const unsig If the default memLevel or windowBits for deflateInit() is changed, then this function needs to be updated. */ -z_size_t ZEXPORT PREFIX(compressBound)(z_size_t sourceLen) { +z_size_t Z_EXPORT PREFIX(compressBound)(z_size_t sourceLen) { +#ifndef NO_QUICK_STRATEGY + /* Quick deflate strategy worse case is 9 bits per literal, rounded to nearest byte, + plus the size of block & gzip headers and footers */ + return sourceLen + ((sourceLen + 13 + 7) >> 3) + 18; +#else return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + (sourceLen >> 25) + 13; +#endif } diff --git a/libs/zlibng/configure b/libs/zlibng/configure index 5f50a33cb..171a76876 100644 --- a/libs/zlibng/configure +++ b/libs/zlibng/configure @@ -23,9 +23,11 @@ BUILDDIR=$(pwd) # set command prefix for cross-compilation if [ -n "${CHOST}" ]; then - uname="`echo "${CHOST}" | sed -e 's/^[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)-.*$/\1/'`" + # normalize the chost before parsing it + NORM_CHOST=$(sh "$SRCDIR"/tools/config.sub $CHOST) + uname="$(echo "${NORM_CHOST}" | sed -e 's/^[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)-.*$/\1/')" CROSS_PREFIX="${CHOST}-" - ARCH="`echo "${CHOST}" | sed -e 's/-.*//'`" + ARCH="$(echo "${NORM_CHOST}" | sed -e 's/-.*//')" else ARCH="`uname -m`" fi @@ -68,8 +70,8 @@ fi # set defaults before processing command line options LDCONFIG=${LDCONFIG-"ldconfig"} -LDFLAGS=${LDFLAGS-"-L."} -LDSHAREDLIBC="${LDSHAREDLIBC--lc}" +LDFLAGS=${LDFLAGS} +LDSHAREDLIBC="${LDSHAREDLIBC}" DEFFILE= RC= RCFLAGS= @@ -85,7 +87,7 @@ includedir=${includedir-'${prefix}/include'} mandir=${mandir-'${prefix}/share/man'} shared_ext='.so' shared=1 -gzfileops=0 +gzfileops=1 compat=0 cover=0 build32=0 @@ -94,16 +96,19 @@ buildacle=1 buildneon=1 builddfltccdeflate=0 builddfltccinflate=0 -with_sanitizers=0 -with_msan=0 +with_sanitizer="" with_fuzzers=0 floatabi= native=0 forcesse2=0 +avx2flag="-mavx2" sse2flag="-msse2" +ssse3flag="-mssse3" sse4flag="-msse4" sse42flag="-msse4.2" pclmulflag="-mpclmul" +acleflag= +neonflag= without_optimizations=0 without_new_strategies=0 gcc=0 @@ -143,7 +148,7 @@ case "$1" in echo ' [--warn] Enables extra compiler warnings' | tee -a configure.log echo ' [--debug] Enables extra debug prints during operation' | tee -a configure.log echo ' [--zlib-compat] Compiles for zlib-compatible API instead of zlib-ng API' | tee -a configure.log - echo ' [--with-gzfileops] Compiles with the gzfile parts of the API enabled' | tee -a configure.log + echo ' [--without-gzfileops] Compiles with the gzfile parts of the API enabled' | tee -a configure.log echo ' [--without-optimizations] Compiles without support for optional instruction sets' | tee -a configure.log echo ' [--without-new-strategies] Compiles without using new additional deflate strategies' | tee -a configure.log echo ' [--without-acle] Compiles without ARM C Language Extensions' | tee -a configure.log @@ -151,9 +156,9 @@ case "$1" in echo ' [--with-dfltcc-deflate] Use DEFLATE CONVERSION CALL instruction for compression on IBM Z' | tee -a configure.log echo ' [--with-dfltcc-inflate] Use DEFLATE CONVERSION CALL instruction for decompression on IBM Z' | tee -a configure.log echo ' [--force-sse2] Assume SSE2 instructions are always available (disabled by default on x86, enabled on x86_64)' | tee -a configure.log - echo ' [--with-sanitizers] Build with address sanitizer and all supported sanitizers other than memory sanitizer (disabled by default)' | tee -a configure.log - echo ' [--with-msan] Build with memory sanitizer (disabled by default)' | tee -a configure.log + echo ' [--with-sanitizer] Build with sanitizer (memory, address, undefined)' | tee -a configure.log echo ' [--with-fuzzers] Build test/fuzz (disabled by default)' | tee -a configure.log + echo ' [--native] Compiles with full instruction set supported on this host' | tee -a configure.log exit 0 ;; -p*=* | --prefix=*) prefix=`echo $1 | sed 's/.*=//'`; shift ;; -e*=* | --eprefix=*) exec_prefix=`echo $1 | sed 's/.*=//'`; shift ;; @@ -168,7 +173,7 @@ case "$1" in -s* | --shared | --enable-shared) shared=1; shift ;; -t | --static) shared=0; shift ;; --zlib-compat) compat=1; shift ;; - --with-gzfileops) gzfileops=1; shift ;; + --without-gzfileops) gzfileops=0; shift ;; --cover) cover=1; shift ;; -3* | --32) build32=1; shift ;; -6* | --64) build64=1; shift ;; @@ -185,8 +190,7 @@ case "$1" in -oldstrat | --without-new-strategies) without_new_strategies=1; shift;; -w* | --warn) warn=1; shift ;; -d* | --debug) debug=1; shift ;; - --with-sanitizers) with_sanitizers=1; shift ;; - --with-msan) with_msan=1; shift ;; + --with-sanitizer=*) with_sanitizer=`echo $1 | sed 's/.*=//'`; shift ;; --with-fuzzers) with_fuzzers=1; shift ;; *) @@ -325,6 +329,12 @@ if test "$gcc" -eq 1 && ($cc $CFLAGS -c $test.c) >> configure.log 2>&1; then else ARCH=native fi ;; + powerpc | ppc) + ARCH=powerpc ;; + powerpc64 | ppc64) + ARCH=powerpc64 ;; + powerpc64le | ppc64le) + ARCH=powerpc64le ;; esac CFLAGS="-O2 ${CFLAGS}" if test -n "${ARCHS}"; then @@ -332,13 +342,19 @@ if test "$gcc" -eq 1 && ($cc $CFLAGS -c $test.c) >> configure.log 2>&1; then LDFLAGS="${LDFLAGS} ${ARCHS}" fi CFLAGS="${CFLAGS} -Wall" - SFLAGS="-O2 ${CFLAGS} -fPIC" + SFLAGS="${CFLAGS} -fPIC" if test $native -eq 1; then - CFLAGS="${CFLAGS} -march=native" - SFLAGS="${SFLAGS} -march=native" + case $ARCH in + powerpc*) + NATIVE_FLAG="-mcpu=native" ;; + *) + NATIVE_FLAG="-march=native" ;; + esac + CFLAGS="${CFLAGS} ${NATIVE_FLAG}" + SFLAGS="${SFLAGS} ${NATIVE_FLAG}" fi if test "$warn" -eq 1; then - CFLAGS="${CFLAGS} -Wextra -Wpedantic" + CFLAGS="${CFLAGS} -Wextra -Wpedantic -Wno-implicit-fallthrough" fi if test $debug -eq 1; then CFLAGS="${CFLAGS} -DZLIB_DEBUG" @@ -350,10 +366,10 @@ if test "$gcc" -eq 1 && ($cc $CFLAGS -c $test.c) >> configure.log 2>&1; then case "$uname" in Linux* | linux* | GNU | GNU/* | solaris*) LDSHARED=${LDSHARED-"$cc"} - LDSHAREDFLAGS="-shared -Wl,-soname,${LIBNAME}.so.1,--version-script,${SRCDIR}/${MAPNAME}" ;; + LDSHAREDFLAGS="-shared -Wl,-soname,${LIBNAME}.so.${VER1},--version-script,${SRCDIR}/${MAPNAME}" ;; *BSD | *bsd* | DragonFly) LDSHARED=${LDSHARED-"$cc"} - LDSHAREDFLAGS="-shared -Wl,-soname,${LIBNAME}.so.1,--version-script,${SRCDIR}/${MAPNAME}" + LDSHAREDFLAGS="-shared -Wl,-soname,${LIBNAME}.so.${VER1},--version-script,${SRCDIR}/${MAPNAME}" LDCONFIG="ldconfig -m" ;; CYGWIN* | Cygwin* | cygwin*) ARFLAGS="rcs" @@ -429,7 +445,7 @@ if test "$gcc" -eq 1 && ($cc $CFLAGS -c $test.c) >> configure.log 2>&1; then QNX*) # This is for QNX6. I suppose that the QNX rule below is for QNX2,QNX4 # (alain.bonnefoy@icbt.com) LDSHARED=${LDSHARED-"$cc"} - LDSHAREDFLAGS="-shared -Wl,-h${LIBNAME}.so.1" ;; + LDSHAREDFLAGS="-shared -Wl,-h${LIBNAME}.so.${VER1}" ;; HP-UX*) LDSHARED=${LDSHARED-"$cc"} LDSHAREDFLAGS="-shared" @@ -457,7 +473,7 @@ if test "$gcc" -eq 1 && ($cc $CFLAGS -c $test.c) >> configure.log 2>&1; then ARFLAGS="-o" ;; aarch64) LDSHARED=${LDSHARED-"$cc"} - LDSHAREDFLAGS="-shared -Wl,-soname,${LIBNAME}.so.1 -Wl,--version-script,${SRCDIR}/${MAPNAME}" + LDSHAREDFLAGS="-shared -Wl,-soname,${LIBNAME}.so.${VER1} -Wl,--version-script,${SRCDIR}/${MAPNAME}" LDSHAREDLIBC="-Wl,--start-group -lc -lrdimon -Wl,--end-group" ;; *) LDSHARED=${LDSHARED-"$cc"} @@ -555,14 +571,10 @@ fi echo >> configure.log -if test $with_sanitizers -eq 1; then - if test $with_msan -eq 1; then - echo "Error: --with-sanitizers and --with-msan cannot be used together" - exit 1 - fi - echo -n "Checking for sanitizers ASan/UBSan... " | tee -a configure.log +if test "$with_sanitizer" = "address"; then + echo -n "Checking for address sanitizer... " | tee -a configure.log sanitizers="" - for san in bool address array-bounds float-divide-by-zero function integer-divide-by-zero return shift signed-integer-overflow undefined unsigned-integer-overflow vla-bound vptr; do + for san in address pointer-compare pointer-subtract; do if try $CC -c $CFLAGS $test.c -fsanitize=$san ; then if test -n "$sanitizers"; then sanitizers="$sanitizers,$san" @@ -581,11 +593,21 @@ if test $with_sanitizers -eq 1; then echo No | tee -a configure.log fi + echo -n "Checking for leak sanitizer... " | tee -a configure.log + if try $CC -c $CFLAGS $test.c -fsanitize=leak; then + echo "-fsanitize=leak" | tee -a configure.log + CFLAGS="$CFLAGS -fsanitize=leak" + SFLAGS="$SFLAGS -fsanitize=leak" + LDFLAGS="$LDFLAGS -fsanitize=leak" + else + echo No | tee -a configure.log + fi + echo >> configure.log fi -if test $with_msan -eq 1; then - echo -n "Checking for MSan... " | tee -a configure.log +if test "$with_sanitizer" = "memory"; then + echo -n "Checking for memory sanitizer... " | tee -a configure.log if try $CC -c $CFLAGS $test.c -fsanitize=memory ; then echo "-fsanitize=memory" | tee -a configure.log CFLAGS="$CFLAGS -fsanitize=memory" @@ -598,6 +620,31 @@ if test $with_msan -eq 1; then echo >> configure.log fi +if test "$with_sanitizer" = "undefined"; then + echo -n "Checking for undefined behavior sanitizer... " | tee -a configure.log + sanitizers="" + for san in array-bounds bool bounds builtin enum float-cast-overflow float-divide-by-zero function integer-divide-by-zero local-bounds null nonnull-attribute object-size pointer-overflow return returns-nonnull-attribute shift shift-base shift-exponent signed-integer-overflow undefined unsigned-integer-overflow unsigned-shift-base vla-bound vptr; do + if try $CC -c $CFLAGS $test.c -fsanitize=$san; then + if test -n "$sanitizers"; then + sanitizers="$sanitizers,$san" + else + sanitizers="$san" + fi + fi + done + + if test -n "$sanitizers"; then + echo "-fsanitize=$sanitizers" | tee -a configure.log + CFLAGS="$CFLAGS -fsanitize=$sanitizers" + SFLAGS="$SFLAGS -fsanitize=$sanitizers" + LDFLAGS="$LDFLAGS -fsanitize=$sanitizers" + else + echo No | tee -a configure.log + fi + + echo >> configure.log +fi + # see if shared library build supported cat > $test.c < test.c + cat > $test.c <> configure.log 2>&1; then + echo "Checking for -no-semantic-interposition... Yes." | tee -a configure.log + SFLAGS="$SFLAGS -fno-semantic-interposition" +else + echo "Checking for -no-semantic-interposition... No." | tee -a configure.log +fi + # see if we can hide zlib internal symbols that are linked between separate source files using hidden if test "$gcc" -eq 1; then echo >> configure.log cat > $test.c <> configure.log echo "Checking for attribute(visibility(hidden)) support... Yes." | tee -a configure.log else @@ -836,13 +891,13 @@ fi if test "$gcc" -eq 1; then echo >> configure.log cat > $test.c <> configure.log echo "Checking for attribute(visibility(internal)) support... Yes." | tee -a configure.log else @@ -851,26 +906,43 @@ EOF fi fi -# Check for __builtin_ctzl() support in compiler +# Check for __builtin_ctz() support in compiler cat > $test.c << EOF int main(void) { unsigned int zero = 0; - long test = __builtin_ctzl(zero); + long test = __builtin_ctz(zero); (void)test; return 0; } EOF if try ${CC} ${CFLAGS} $test.c $LDSHAREDLIBC; then - echo "Checking for __builtin_ctzl ... Yes." | tee -a configure.log - CFLAGS="$CFLAGS -DHAVE_BUILTIN_CTZL" - SFLAGS="$SFLAGS -DHAVE_BUILTIN_CTZL" + echo "Checking for __builtin_ctz ... Yes." | tee -a configure.log + CFLAGS="$CFLAGS -DHAVE_BUILTIN_CTZ" + SFLAGS="$SFLAGS -DHAVE_BUILTIN_CTZ" else - echo "Checking for __builtin_ctzl ... No." | tee -a configure.log + echo "Checking for __builtin_ctz ... No." | tee -a configure.log +fi + +# Check for __builtin_ctzll() support in compiler +cat > $test.c << EOF +int main(void) { + unsigned long long zero = 0; + long test = __builtin_ctzll(zero); + (void)test; + return 0; +} +EOF +if try ${CC} ${CFLAGS} $test.c $LDSHAREDLIBC; then + echo "Checking for __builtin_ctzll ... Yes." | tee -a configure.log + CFLAGS="$CFLAGS -DHAVE_BUILTIN_CTZLL" + SFLAGS="$SFLAGS -DHAVE_BUILTIN_CTZLL" +else + echo "Checking for __builtin_ctzll ... No." | tee -a configure.log fi # Check for SSE2 intrinsics case "${ARCH}" in - i386 | i486 | i586 | i686) + i386 | i486 | i586 | i686 | x86_64) cat > $test.c << EOF #include int main(void) { @@ -889,6 +961,48 @@ EOF ;; esac +# Check for SSSE3 intrinsics + +cat > $test.c << EOF +#include +int main(void) +{ + __m128i u, v, w; + u = _mm_set1_epi32(1); + v = _mm_set1_epi32(2); + w = _mm_hadd_epi32(u, v); + (void)w; + return 0; +} +EOF +if try ${CC} ${CFLAGS} ${ssse3flag} $test.c; then + echo "Checking for SSSE3 intrinsics ... Yes." | tee -a configure.log + HAVE_SSSE3_INTRIN=1 +else + echo "Checking for SSSE3 intrinsics ... No." | tee -a configure.log + HAVE_SSSE3_INTRIN=0 +fi + +# Check for SSE4.2 CRC inline assembly +case "${ARCH}" in + i386 | i486 | i586 | i686 | x86_64) + cat > $test.c << EOF +int main(void) { + unsigned val = 0, h = 0; + __asm__ __volatile__ ( "crc32 %1,%0" : "+r" (h) : "r" (val) ); + return (int) h; +} +EOF + if try ${CC} ${CFLAGS} ${sse42flag} $test.c; then + echo "Checking for SSE4.2 CRC inline assembly ... Yes." | tee -a configure.log + HAVE_SSE42CRC_INLINE_ASM=1 + else + echo "Checking for SSE4.2 CRC inline assembly ... No." | tee -a configure.log + HAVE_SSE42CRC_INLINE_ASM=0 + fi + ;; +esac + # Check for SSE4.2 CRC intrinsics case "${ARCH}" in i386 | i486 | i586 | i686 | x86_64) @@ -911,6 +1025,31 @@ EOF ;; esac +# Check for SSE4.2 compare string intrinsics +case "${ARCH}" in + i386 | i486 | i586 | i686 | x86_64) + cat > $test.c << EOF +#include +int main(void) +{ + unsigned char a[64] = { 0 }; + unsigned char b[64] = { 0 }; + __m128i xmm_src0, xmm_src1; + xmm_src0 = _mm_loadu_si128((__m128i *)(char *)a); + xmm_src1 = _mm_loadu_si128((__m128i *)(char *)b); + return _mm_cmpestri(xmm_src0, 16, xmm_src1, 16, 0); +} +EOF + if try ${CC} ${CFLAGS} ${sse42flag} $test.c; then + echo "Checking for SSE4.2 compare string intrinsics ... Yes." | tee -a configure.log + HAVE_SSE42CMPSTR_INTRIN=1 + else + echo "Checking for SSE4.2 compare string intrinsics ... No." | tee -a configure.log + HAVE_SSE42CMPSTR_INTRIN=0 + fi + ;; +esac + # Check for PCLMULQDQ intrinsics case "${ARCH}" in i386 | i486 | i586 | i686 | x86_64) @@ -933,6 +1072,11 @@ EOF HAVE_PCLMULQDQ_INTRIN=0 fi + # Enable deflate_medium at level 1 + if test $without_new_strategies -eq 1; then + CFLAGS="${CFLAGS} -DNO_QUICK_STRATEGY" + SFLAGS="${SFLAGS} -DNO_QUICK_STRATEGY" + fi # Enable deflate_medium at level 4-6 if test $without_new_strategies -eq 1; then CFLAGS="${CFLAGS} -DNO_MEDIUM_STRATEGY" @@ -941,6 +1085,30 @@ EOF ;; esac +# Check for AVX2 intrinsics +case "${ARCH}" in + i386 | i486 | i586 | i686 | x86_64) + cat > $test.c << EOF +#include +int main(void) { + __m256i x = _mm256_set1_epi16(2); + const __m256i y = _mm256_set1_epi16(1); + x = _mm256_subs_epu16(x, y); + (void)x; + return 0; +} +EOF + if try ${CC} ${CFLAGS} ${avx2flag} $test.c; then + echo "Checking for AVX2 intrinsics ... Yes." | tee -a configure.log + HAVE_AVX2_INTRIN=1 + else + echo "Checking for AVX2 intrinsics ... No." | tee -a configure.log + HAVE_AVX2_INTRIN=0 + fi + ;; +esac + + # Check whether -mfpu=neon is available on ARM processors. case "${ARCH}" in arm*) @@ -957,6 +1125,22 @@ EOF ;; esac +# Check whether features needed by POWER optimisations are available +case "${ARCH}" in + powerpc*) + cat > $test.c << EOF +#include +int main() { return (getauxval(AT_HWCAP2) & PPC_FEATURE2_ARCH_2_07); } +EOF + if try $CC -c $CFLAGS -mcpu=power8 $test.c; then + HAVE_POWER8=1 + echo "Check whether POWER8 instructions are available ... Yes." | tee -a configure.log + else + HAVE_POWER8=0 + echo "Check whether POWER8 instructions are available ... No." | tee -a configure.log + fi +esac + # Check whether sys/sdt.h is available cat > $test.c << EOF #include @@ -976,81 +1160,66 @@ ARCH_SHARED_OBJS='' # Set ARCH specific FLAGS case "${ARCH}" in - # x86 specific optimizations - i386 | i486 | i586 | i686) + # x86/amd64 specific optimizations + i386 | i486 | i586 | i686 |x86_64) ARCHDIR=arch/x86 - CFLAGS="${CFLAGS} -DUNALIGNED_OK" - SFLAGS="${SFLAGS} -DUNALIGNED_OK" + CFLAGS="${CFLAGS} -DUNALIGNED_OK -DUNALIGNED64_OK" + SFLAGS="${SFLAGS} -DUNALIGNED_OK -DUNALIGNED64_OK" - # Enable arch-specific optimizations? + # Enable arch-specific optimizations if test $without_optimizations -eq 0; then - CFLAGS="${CFLAGS} -DX86_CPUID" - SFLAGS="${SFLAGS} -DX86_CPUID" + CFLAGS="${CFLAGS} -DX86_FEATURES" + SFLAGS="${SFLAGS} -DX86_FEATURES" ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} x86.o" ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} x86.lo" + if test ${HAVE_AVX2_INTRIN} -eq 1; then + CFLAGS="${CFLAGS} -DX86_AVX2 -DX86_AVX2_ADLER32 -DX86_AVX_CHUNKSET" + SFLAGS="${SFLAGS} -DX86_AVX2 -DX86_AVX2_ADLER32 -DX86_AVX_CHUNKSET" + ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} slide_avx.o chunkset_avx.o compare258_avx.o adler32_avx.o" + ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} slide_avx.lo chunkset_avx.lo compare258_avx.lo adler32_avx.lo" + fi + + if test ${HAVE_SSE42CRC_INTRIN} -eq 1 || test ${HAVE_SSE42CRC_INLINE_ASM} -eq 1; then + CFLAGS="${CFLAGS} -DX86_SSE42_CRC_HASH" + SFLAGS="${SFLAGS} -DX86_SSE42_CRC_HASH" + + if test ${HAVE_SSE42CRC_INTRIN} -eq 1; then + CFLAGS="${CFLAGS} -DX86_SSE42_CRC_INTRIN" + SFLAGS="${SFLAGS} -DX86_SSE42_CRC_INTRIN" + fi + + ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} insert_string_sse.o" + ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} insert_string_sse.lo" + fi + + if test ${HAVE_SSE42CMPSTR_INTRIN} -eq 1; then + CFLAGS="${CFLAGS} -DX86_SSE42_CMP_STR" + SFLAGS="${SFLAGS} -DX86_SSE42_CMP_STR" + + ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} compare258_sse.o" + ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} compare258_sse.lo" + fi + if test ${HAVE_SSE2_INTRIN} -eq 1; then - CFLAGS="${CFLAGS} -DX86_SSE2" - SFLAGS="${SFLAGS} -DX86_SSE2" - ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} fill_window_sse.o" - ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} fill_window_sse.lo" + CFLAGS="${CFLAGS} -DX86_SSE2 -DX86_SSE2_CHUNKSET" + SFLAGS="${SFLAGS} -DX86_SSE2 -DX86_SSE2_CHUNKSET" + ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} chunkset_sse.o slide_sse.o" + ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} chunkset_sse.lo slide_sse.lo" if test $forcesse2 -eq 1; then CFLAGS="${CFLAGS} -DX86_NOCHECK_SSE2" SFLAGS="${SFLAGS} -DX86_NOCHECK_SSE2" fi - - # Enable deflate_quick at level 1? - # requires SSE2: code uses fill_window_sse - if test $without_new_strategies -eq 0; then - CFLAGS="${CFLAGS} -DX86_QUICK_STRATEGY" - SFLAGS="${SFLAGS} -DX86_QUICK_STRATEGY" - - ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} deflate_quick.o" - ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} deflate_quick.lo" - fi fi - if test ${HAVE_SSE42CRC_INTRIN} -eq 1; then - CFLAGS="${CFLAGS} -DX86_SSE4_2_CRC_INTRIN" - SFLAGS="${SFLAGS} -DX86_SSE4_2_CRC_INTRIN" - fi - - CFLAGS="${CFLAGS} -DX86_SSE4_2_CRC_HASH" - SFLAGS="${SFLAGS} -DX86_SSE4_2_CRC_HASH" - ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} insert_string_sse.o" - ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} insert_string_sse.lo" - - if test ${HAVE_PCLMULQDQ_INTRIN} -eq 1; then - CFLAGS="${CFLAGS} -DX86_PCLMULQDQ_CRC" - SFLAGS="${SFLAGS} -DX86_PCLMULQDQ_CRC" - ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} crc_folding.o" - ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} crc_folding.lo" - fi - - fi - ;; - - # x86_64 specific optimizations - x86_64) - ARCHDIR=arch/x86 - - CFLAGS="${CFLAGS} -DUNALIGNED_OK" - SFLAGS="${SFLAGS} -DUNALIGNED_OK" - - # Enable arch-specific optimizations? - if test $without_optimizations -eq 0; then - CFLAGS="${CFLAGS} -DX86_CPUID -DX86_SSE2 -DX86_SSE4_2_CRC_HASH" - SFLAGS="${SFLAGS} -DX86_CPUID -DX86_SSE2 -DX86_SSE4_2_CRC_HASH" - - ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} x86.o fill_window_sse.o insert_string_sse.o" - ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} x86.lo fill_window_sse.lo insert_string_sse.lo" - - if test ${HAVE_SSE42CRC_INTRIN} -eq 1; then - CFLAGS="${CFLAGS} -DX86_SSE4_2_CRC_INTRIN" - SFLAGS="${SFLAGS} -DX86_SSE4_2_CRC_INTRIN" + if test ${HAVE_SSSE3_INTRIN} -eq 1; then + CFLAGS="${CFLAGS} -DX86_SSSE3 -DX86_SSSE3_ADLER32" + SFLAGS="${SFLAGS} -DX86_SSSE3 -DX86_SSSE3_ADLER32" + ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_ssse3.o" + ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_ssse3.lo" fi if test ${HAVE_PCLMULQDQ_INTRIN} -eq 1; then @@ -1059,24 +1228,20 @@ case "${ARCH}" in ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} crc_folding.o" ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} crc_folding.lo" fi - - # Enable deflate_quick at level 1? - if test $without_new_strategies -eq 0; then - CFLAGS="${CFLAGS} -DX86_QUICK_STRATEGY" - SFLAGS="${SFLAGS} -DX86_QUICK_STRATEGY" - - ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} deflate_quick.o" - ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} deflate_quick.lo" - fi fi ;; # ARM specific optimizations - arm | armv[3467]l | armv4b | armv4tl | armv5tel | armv5tejl | armv[67]hl | armv7hnl | armv[78]-a | armv8-a+* | armv8.[1234]-a | armv8.[1234]-a+*) + arm*) [ ! -z $CROSS_PREFIX ] && QEMU_ARCH=arm ARCHDIR=arch/arm - ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} armfeature.o fill_window_arm.o" - ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} armfeature.lo fill_window_arm.lo" + + if test $without_optimizations -eq 0; then + CFLAGS="${CFLAGS} -DARM_FEATURES" + SFLAGS="${SFLAGS} -DARM_FEATURES" + ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} armfeature.o" + ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} armfeature.lo" + fi GCC_MACHINE=$(${CC} -dumpmachine) case "${GCC_MACHINE}" in @@ -1085,90 +1250,103 @@ case "${ARCH}" in *gnueabi) floatabi="-mfloat-abi=softfp" ;; esac + CFLAGS="${CFLAGS} ${floatabi}" + SFLAGS="${SFLAGS} ${floatabi}" case "${ARCH}" in armv[345]*) - if test $buildacle -eq 1; then - echo ACLE support not available - fi + if test $without_optimizations -eq 0; then + if test $buildacle -eq 1; then + echo ACLE support not available + fi - if test $buildneon -eq 1; then - echo NEON support not available + if test $buildneon -eq 1; then + echo NEON support not available + fi fi ;; armv6l | armv6hl) CFLAGS="${CFLAGS} -DUNALIGNED_OK" SFLAGS="${SFLAGS} -DUNALIGNED_OK" - if test $buildacle -eq 1; then - echo ACLE support not available - fi + if test $without_optimizations -eq 0; then + if test $buildacle -eq 1; then + echo ACLE support not available + fi - if test $buildneon -eq 1; then - echo NEON support not available + if test $buildneon -eq 1; then + echo NEON support not available + fi fi ;; arm | armv7*) CFLAGS="${CFLAGS} -DUNALIGNED_OK" SFLAGS="${SFLAGS} -DUNALIGNED_OK" - if test $buildacle -eq 1; then - echo ACLE support not available - fi + if test $without_optimizations -eq 0; then + if test $buildacle -eq 1; then + echo ACLE support not available + fi - if test $buildneon -eq 1; then - CFLAGS="${CFLAGS} ${floatabi} -mfpu=neon -DARM_NEON_ADLER32" - SFLAGS="${SFLAGS} ${floatabi} -mfpu=neon -DARM_NEON_ADLER32" + if test $buildneon -eq 1; then + if test $MFPU_NEON_AVAILABLE -eq 1;then + neonflag="-mfpu=neon" + fi - ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_neon.o" - ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_neon.lo" + CFLAGS="${CFLAGS} -DARM_NEON_ADLER32 -DARM_NEON_CHUNKSET -DARM_NEON_SLIDEHASH" + SFLAGS="${SFLAGS} -DARM_NEON_ADLER32 -DARM_NEON_CHUNKSET -DARM_NEON_SLIDEHASH" + + ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_neon.o chunkset_neon.o slide_neon.o" + ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_neon.lo chunkset_neon.lo slide_neon.lo" + fi fi ;; armv8-a | armv8-a+simd) - CFLAGS="${CFLAGS} -DUNALIGNED_OK" - SFLAGS="${SFLAGS} -DUNALIGNED_OK" + CFLAGS="${CFLAGS} -DUNALIGNED_OK -DUNALIGNED64_OK" + SFLAGS="${SFLAGS} -DUNALIGNED_OK -DUNALIGNED64_OK" - if test $buildacle -eq 1; then - echo ACLE support not available - fi - - if test $buildneon -eq 1; then - CFLAGS="${CFLAGS} ${floatabi}" - SFLAGS="${SFLAGS} ${floatabi}" - - if test $MFPU_NEON_AVAILABLE -eq 1;then - CFLAGS="${CFLAGS} -mfpu=neon" - SFLAGS="${SFLAGS} -mfpu=neon" + if test $without_optimizations -eq 0; then + if test $buildacle -eq 1; then + echo ACLE support not available fi - CFLAGS="${CFLAGS} -DARM_NEON_ADLER32" - SFLAGS="${SFLAGS} -DARM_NEON_ADLER32" + if test $buildneon -eq 1; then + if test $MFPU_NEON_AVAILABLE -eq 1;then + neonflag="-mfpu=neon" + fi - ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_neon.o" - ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_neon.lo" + CFLAGS="${CFLAGS} -DARM_NEON_ADLER32 -DARM_NEON_CHUNKSET -DARM_NEON_SLIDEHASH" + SFLAGS="${SFLAGS} -DARM_NEON_ADLER32 -DARM_NEON_CHUNKSET -DARM_NEON_SLIDEHASH" + + ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_neon.o chunkset_neon.o slide_neon.o" + ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_neon.lo chunkset_neon.lo slide_neon.lo" + fi fi ;; armv8-a+crc | armv8-a+crc+simd | armv8.[1234]-a | armv8.[1234]-a+simd) - CFLAGS="-march=${ARCH} ${CFLAGS} -DARM_ACLE_CRC_HASH -DUNALIGNED_OK" - SFLAGS="-march=${ARCH} ${SFLAGS} -DARM_ACLE_CRC_HASH -DUNALIGNED_OK" + CFLAGS="${CFLAGS} -DUNALIGNED_OK -DUNALIGNED64_OK" + SFLAGS="${SFLAGS} -DUNALIGNED_OK -DUNALIGNED64_OK" - ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} crc32_acle.o insert_string_acle.o" - ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} crc32_acle.lo insert_string_acle.lo" + acleflag="-march=${ARCH}" - if test $buildneon -eq 1; then - CFLAGS="${CFLAGS} ${floatabi}" - SFLAGS="${SFLAGS} ${floatabi}" + if test $without_optimizations -eq 0; then + CFLAGS="${CFLAGS} -DARM_ACLE_CRC_HASH" + SFLAGS="${SFLAGS} -DARM_ACLE_CRC_HASH" - if test $MFPU_NEON_AVAILABLE -eq 1;then - CFLAGS="${CFLAGS} -mfpu=neon" - SFLAGS="${SFLAGS} -mfpu=neon" + ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} crc32_acle.o insert_string_acle.o" + ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} crc32_acle.lo insert_string_acle.lo" + + if test $buildneon -eq 1; then + if test $MFPU_NEON_AVAILABLE -eq 1;then + neonflag="-mfpu=neon" + fi + + CFLAGS="${CFLAGS} -DARM_NEON_ADLER32 -DARM_NEON_CHUNKSET -DARM_NEON_SLIDEHASH" + SFLAGS="${SFLAGS} -DARM_NEON_ADLER32 -DARM_NEON_CHUNKSET -DARM_NEON_SLIDEHASH" + + ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_neon.o chunkset_neon.o slide_neon.o" + ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_neon.lo chunkset_neon.lo slide_neon.lo" fi - - CFLAGS="${CFLAGS} -DARM_NEON_ADLER32" - SFLAGS="${SFLAGS} -DARM_NEON_ADLER32" - - ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_neon.o" - ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_neon.lo" fi ;; esac @@ -1178,61 +1356,98 @@ case "${ARCH}" in aarch64) [ ! -z $CROSS_PREFIX ] && QEMU_ARCH=aarch64 ARCHDIR=arch/arm - ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} armfeature.o fill_window_arm.o" - ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} armfeature.lo fill_window_arm.lo" if test $native -eq 0; then - ARCH="armv8-a" + ARCH="armv8-a" else - ARCH="native" + ARCH="native" fi - if test $buildacle -eq 1; then - if test $native -eq 0; then - ARCH="${ARCH}+crc" - fi - CFLAGS="${CFLAGS} -DARM_ACLE_CRC_HASH" - SFLAGS="${SFLAGS} -DARM_ACLE_CRC_HASH" - ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} crc32_acle.o insert_string_acle.o" - ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} crc32_acle.lo insert_string_acle.lo" - fi - if test $buildneon -eq 1; then - if test $native -eq 0; then - ARCH="${ARCH}+simd" + + if test $without_optimizations -eq 0; then + CFLAGS="${CFLAGS} -DARM_FEATURES" + SFLAGS="${SFLAGS} -DARM_FEATURES" + ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} armfeature.o" + ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} armfeature.lo" + + if test $buildacle -eq 1; then + if test $native -eq 0; then + ARCH="${ARCH}+crc" + fi + CFLAGS="${CFLAGS} -DARM_ACLE_CRC_HASH" + SFLAGS="${SFLAGS} -DARM_ACLE_CRC_HASH" + ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} crc32_acle.o insert_string_acle.o" + ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} crc32_acle.lo insert_string_acle.lo" + fi + + if test $buildneon -eq 1; then + if test $native -eq 0; then + ARCH="${ARCH}+simd" + fi + CFLAGS="${CFLAGS} -DARM_NEON_ADLER32 -DARM_NEON_CHUNKSET -DARM_NEON_SLIDEHASH" + SFLAGS="${SFLAGS} -DARM_NEON_ADLER32 -DARM_NEON_CHUNKSET -DARM_NEON_SLIDEHASH" + ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_neon.o chunkset_neon.o slide_neon.o" + ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_neon.lo chunkset_neon.lo slide_neon.lo" fi - CFLAGS="${CFLAGS} -DARM_NEON_ADLER32" - SFLAGS="${SFLAGS} -DARM_NEON_ADLER32" - ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} adler32_neon.o" - ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} adler32_neon.lo" fi - CFLAGS="-march=${ARCH} ${CFLAGS} -DUNALIGNED_OK" - SFLAGS="-march=${ARCH} ${SFLAGS} -DUNALIGNED_OK" + + neonflag="-march=${ARCH}" + acleflag="-march=${ARCH}" + + CFLAGS="${CFLAGS} -DUNALIGNED_OK -DUNALIGNED64_OK" + SFLAGS="${SFLAGS} -DUNALIGNED_OK -DUNALIGNED64_OK" ;; - powerpc) - [ ! -z $CROSS_PREFIX ] && QEMU_ARCH=ppc - ;; - powerpc64) - [ ! -z $CROSS_PREFIX ] && QEMU_ARCH=ppc64 + powerpc*) + case "${ARCH}" in + powerpc) + [ ! -z $CROSS_PREFIX ] && QEMU_ARCH=ppc + ;; + powerpc64) + [ ! -z $CROSS_PREFIX ] && QEMU_ARCH=ppc64 + ;; + powerpc64le) + [ ! -z $CROSS_PREFIX ] && QEMU_ARCH=ppc64le + CFLAGS="${CFLAGS} -DUNALIGNED_OK -DUNALIGNED64_OK" + SFLAGS="${SFLAGS} -DUNALIGNED_OK -DUNALIGNED64_OK" + ;; + esac + + ARCHDIR=arch/power + + if test $without_optimizations -eq 0; then + if test $HAVE_POWER8 -eq 1; then + CFLAGS="${CFLAGS} -DPOWER8 -DPOWER_FEATURES -DPOWER8_VSX_ADLER32 -DPOWER8_VSX_SLIDEHASH" + SFLAGS="${SFLAGS} -DPOWER8 -DPOWER_FEATURES -DPOWER8_VSX_ADLER32 -DPOWER8_VSX_SLIDEHASH" + + ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} power.o adler32_power8.o slide_hash_power8.o" + ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} power.lo adler32_power8.lo slide_hash_power8.lo" + fi + fi ;; s390x) [ ! -z $CROSS_PREFIX ] && QEMU_ARCH=s390x ARCHDIR=arch/s390 - if test $builddfltccdeflate -eq 1 -o $builddfltccinflate -eq 1; then - ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} dfltcc_common.o" - ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} dfltcc_common.lo" - fi - if test $builddfltccdeflate -eq 1; then - CFLAGS="${CFLAGS} -DS390_DFLTCC_DEFLATE" - SFLAGS="${SFLAGS} -DS390_DFLTCC_DEFLATE" - ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} dfltcc_deflate.o" - ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} dfltcc_deflate.lo" - ARCH="${ARCH}+dfltcc-deflate" - fi - if test $builddfltccinflate -eq 1; then - CFLAGS="${CFLAGS} -DS390_DFLTCC_INFLATE" - SFLAGS="${SFLAGS} -DS390_DFLTCC_INFLATE" - ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} dfltcc_inflate.o" - ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} dfltcc_inflate.lo" - ARCH="${ARCH}+dfltcc-inflate" + + if test $without_optimizations -eq 0; then + if test $builddfltccdeflate -eq 1 -o $builddfltccinflate -eq 1; then + ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} dfltcc_common.o" + ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} dfltcc_common.lo" + fi + + if test $builddfltccdeflate -eq 1; then + CFLAGS="${CFLAGS} -DS390_DFLTCC_DEFLATE" + SFLAGS="${SFLAGS} -DS390_DFLTCC_DEFLATE" + ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} dfltcc_deflate.o" + ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} dfltcc_deflate.lo" + ARCH="${ARCH}+dfltcc-deflate" + fi + + if test $builddfltccinflate -eq 1; then + CFLAGS="${CFLAGS} -DS390_DFLTCC_INFLATE" + SFLAGS="${SFLAGS} -DS390_DFLTCC_INFLATE" + ARCH_STATIC_OBJS="${ARCH_STATIC_OBJS} dfltcc_inflate.o" + ARCH_SHARED_OBJS="${ARCH_SHARED_OBJS} dfltcc_inflate.lo" + ARCH="${ARCH}+dfltcc-inflate" + fi fi ;; *) @@ -1286,12 +1501,24 @@ echo prefix = $prefix >> configure.log echo sharedlibdir = $sharedlibdir >> configure.log echo uname = $uname >> configure.log echo sse2flag = $sse2flag >> configure.log +echo ssse3flag = $ssse3flag >> configure.log echo sse4flag = $sse4flag >> configure.log echo pclmulflag = $pclmulflag >> configure.log +echo acleflag = $acleflag >> configure.log +echo neonflag = $neonflag >> configure.log echo ARCHDIR = ${ARCHDIR} >> configure.log echo ARCH_STATIC_OBJS = ${ARCH_STATIC_OBJS} >> configure.log echo ARCH_SHARED_OBJS = ${ARCH_SHARED_OBJS} >> configure.log +# Handle sed incompatibilities when using -i +replace_in_file() { + if [ "$OS" = 'Darwin' ]; then + sed -i '.tmp' -e "$1" "$2" + else + sed -i'.tmp' -e "$1" "$2" + fi +} + # update Makefile with the configure results INCLUDES="-I$SRCDIR" @@ -1347,7 +1574,7 @@ sed < $SRCDIR/Makefile.in " " > Makefile # Append header files dependences. -for file in $(ls -1 $SRCDIR/*.c $SRCDIR/test/*.c $SRCDIR/test/fuzz/*.c $SRCDIR/$ARCHDIR/*.c); do +for file in $(ls -1 $SRCDIR/*.c $SRCDIR/test/*.c $SRCDIR/test/fuzz/*.c $SRCDIR/$ARCHDIR/*.c $SRCDIR/tools/*.c); do short_name=$(echo $file | sed -e "s#$SRCDIR/##g") incs=$(grep -h include $file | sed -n 's/# *\include *"\(.*\.h\)".*/\1/p' | sort | uniq) includes=$(for i in $incs; do @@ -1366,17 +1593,7 @@ for file in $(ls -1 $SRCDIR/*.c $SRCDIR/test/*.c $SRCDIR/test/fuzz/*.c $SRCDIR/$ if grep -q "^$obj:" Makefile; then # Replace the existing line with a line with all dependences. - sed -i "s#$obj:.*#$obj: \$(SRCDIR)/$short_name $includes#g" Makefile - - # Special case example64 and minigzip64. - case "$obj" in - example.o) - sed -i "s#example64.o:.*#example64.o: \$(SRCDIR)/$short_name $includes#g" Makefile - ;; - minigzip.o) - sed -i "s#minigzip64.o:.*#minigzip64.o: \$(SRCDIR)/$short_name $includes#g" Makefile - ;; - esac + $(replace_in_file "s#$obj:.*#$obj: \$(SRCDIR)/$short_name $includes#g" Makefile) else # Append at the end of Makefile a new line with the header dependences. echo "$obj: \$(SRCDIR)/$short_name $includes" >> Makefile @@ -1391,7 +1608,7 @@ for file in $(ls -1 $SRCDIR/*.c $SRCDIR/test/*.c $SRCDIR/test/fuzz/*.c $SRCDIR/$ if grep -q "^$lobj:" Makefile; then # Replace the existing line with a line with all dependences. - sed -i "s#$lobj:.*#$lobj: \$(SRCDIR)/$short_name $includes#g" Makefile + $(replace_in_file "s#$lobj:.*#$lobj: \$(SRCDIR)/$short_name $includes#g" Makefile) else # Append at the end of Makefile a new line with the header dependences. echo "$lobj: \$(SRCDIR)/$short_name $includes" >> Makefile @@ -1414,9 +1631,13 @@ sed < $SRCDIR/$ARCHDIR/Makefile.in " /^SRCDIR *=/s#=.*#=$SRCDIR/$ARCHDIR# /^SRCTOP *=/s#=.*#=$SRCDIR# /^TOPDIR *=/s#=.*#=$BUILDDIR# +/^AVX2FLAG *=/s#=.*#=$avx2flag# /^SSE2FLAG *=/s#=.*#=$sse2flag# +/^SSSE3FLAG *=/s#=.*#=$ssse3flag# /^SSE4FLAG *=/s#=.*#=$sse4flag# /^PCLMULFLAG *=/s#=.*#=$pclmulflag# +/^ACLEFLAG *=/s#=.*#=$acleflag# +/^NEONFLAG *=/s#=.*#=$neonflag# " > $ARCHDIR/Makefile # Append header files dependences. @@ -1438,7 +1659,7 @@ for file in $(ls -1 $SRCDIR/$ARCHDIR/*.c); do short_name=$(basename $file) if grep -q "^$obj:" $ARCHDIR/Makefile; then # Replace the existing line with a line with all dependences. - sed -i "s#$obj:.*#$obj: \$(SRCDIR)/$short_name $includes#g" $ARCHDIR/Makefile + $(replace_in_file "s#$obj:.*#$obj: \$(SRCDIR)/$short_name $includes#g" $ARCHDIR/Makefile) else # Append at the end of Makefile a new line with the header dependences. echo "$obj: \$(SRCDIR)/$short_name $includes" >> $ARCHDIR/Makefile @@ -1446,7 +1667,7 @@ for file in $(ls -1 $SRCDIR/$ARCHDIR/*.c); do if grep -q "^$lobj:" $ARCHDIR/Makefile; then # Replace the existing line with a line with all dependences. - sed -i "s#$lobj:.*#$lobj: \$(SRCDIR)/$short_name $includes#g" $ARCHDIR/Makefile + $(replace_in_file "s#$lobj:.*#$lobj: \$(SRCDIR)/$short_name $includes#g" $ARCHDIR/Makefile) else # Append at the end of Makefile a new line with the header dependences. echo "$lobj: \$(SRCDIR)/$short_name $includes" >> $ARCHDIR/Makefile @@ -1468,6 +1689,7 @@ sed < $SRCDIR/test/Makefile.in " /^COMPATTESTS *=/s#=.*#=$COMPATTESTS# /^QEMU_RUN *=/s#=.*#=$QEMU_RUN# /^WITH_FUZZERS *=/s#=.*#=$with_fuzzers# +/^LIBNAME *=/s#=.*#=$LIBNAME# " > test/Makefile # create zlib.pc with the configure results diff --git a/libs/zlibng/crc32.c b/libs/zlibng/crc32.c index 6c495a57a..4b488e617 100644 --- a/libs/zlibng/crc32.c +++ b/libs/zlibng/crc32.c @@ -9,251 +9,40 @@ * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3. */ -/* @(#) $Id$ */ - -# include "zbuild.h" -# include "gzendian.h" -# include - -/* - Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore - protection on the static variables used to control the first-use generation - of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should - first call get_crc_table() to initialize the tables before allowing more than - one thread to use crc32(). - - DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h. A main() - routine is also produced, so that this one source file can be compiled to an - executable. - */ - -#ifdef MAKECRCH -# include -# ifndef DYNAMIC_CRC_TABLE -# define DYNAMIC_CRC_TABLE -# endif /* !DYNAMIC_CRC_TABLE */ -#endif /* MAKECRCH */ - +#include "zbuild.h" +#include "zendian.h" +#include #include "deflate.h" #include "functable.h" - - -/* Local functions for crc concatenation */ -#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */ -static uint32_t gf2_matrix_times(const uint32_t *mat, uint32_t vec); -static uint32_t crc32_combine_(uint32_t crc1, uint32_t crc2, z_off64_t len2); -static void crc32_combine_gen_(uint32_t *op, z_off64_t len2); - -/* ========================================================================= */ -static uint32_t gf2_matrix_times(const uint32_t *mat, uint32_t vec) { - uint32_t sum = 0; - while (vec) { - if (vec & 1) - sum ^= *mat; - vec >>= 1; - mat++; - } - return sum; -} - -#ifdef DYNAMIC_CRC_TABLE -volatile int crc_table_empty = 1; -static uint32_t crc_table[8][256]; -static uint32_t crc_comb[GF2_DIM][GF2_DIM]; -void make_crc_table(void); -static void gf2_matrix_square(uint32_t *square, const uint32_t *mat); -#ifdef MAKECRCH -static void write_table(FILE *, const uint32_t *, int); -#endif /* MAKECRCH */ - -/* ========================================================================= */ -static void gf2_matrix_square(uint32_t *square, const uint32_t *mat) { - int n; - - for (n = 0; n < GF2_DIM; n++) - square[n] = gf2_matrix_times(mat, mat[n]); -} - -/* - Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: - x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1. - - Polynomials over GF(2) are represented in binary, one bit per coefficient, - with the lowest powers in the most significant bit. Then adding polynomials - is just exclusive-or, and multiplying a polynomial by x is a right shift by - one. If we call the above polynomial p, and represent a byte as the - polynomial q, also with the lowest power in the most significant bit (so the - byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, - where a mod b means the remainder after dividing a by b. - - This calculation is done using the shift-register method of multiplying and - taking the remainder. The register is initialized to zero, and for each - incoming bit, x^32 is added mod p to the register if the bit is a one (where - x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by - x (which is shifting right by one and adding x^32 mod p if the bit shifted - out is a one). We start with the highest power (least significant bit) of - q and repeat for all eight bits of q. - - The first table is simply the CRC of all possible eight bit values. This is - all the information needed to generate CRCs on data a byte at a time for all - combinations of CRC register values and incoming bytes. The remaining tables - allow for word-at-a-time CRC calculation for both big-endian and little- - endian machines, where a word is four bytes. -*/ -void make_crc_table() { - uint32_t c; - int n, k; - uint32_t poly; /* polynomial exclusive-or pattern */ - /* terms of polynomial defining this crc (except x^32): */ - static volatile int first = 1; /* flag to limit concurrent making */ - static const unsigned char p[] = {0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26}; - - /* See if another task is already doing this (not thread-safe, but better - than nothing -- significantly reduces duration of vulnerability in - case the advice about DYNAMIC_CRC_TABLE is ignored) */ - if (first) { - first = 0; - - /* make exclusive-or pattern from polynomial (0xedb88320) */ - poly = 0; - for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++) - poly |= (uint32_t)1 << (31 - p[n]); - - /* generate a crc for every 8-bit value */ - for (n = 0; n < 256; n++) { - c = (uint32_t)n; - for (k = 0; k < 8; k++) - c = c & 1 ? poly ^ (c >> 1) : c >> 1; - crc_table[0][n] = c; - } - - /* generate crc for each value followed by one, two, and three zeros, - and then the byte reversal of those as well as the first table */ - for (n = 0; n < 256; n++) { - c = crc_table[0][n]; - crc_table[4][n] = ZSWAP32(c); - for (k = 1; k < 4; k++) { - c = crc_table[0][c & 0xff] ^ (c >> 8); - crc_table[k][n] = c; - crc_table[k + 4][n] = ZSWAP32(c); - } - } - - /* generate zero operators table for crc32_combine() */ - - /* generate the operator to apply a single zero bit to a CRC -- the - first row adds the polynomial if the low bit is a 1, and the - remaining rows shift the CRC right one bit */ - k = GF2_DIM - 3; - crc_comb[k][0] = 0xedb88320UL; /* CRC-32 polynomial */ - uint32_t row = 1; - for (n = 1; n < GF2_DIM; n++) { - crc_comb[k][n] = row; - row <<= 1; - } - - /* generate operators that apply 2, 4, and 8 zeros to a CRC, putting - the last one, the operator for one zero byte, at the 0 position */ - gf2_matrix_square(crc_comb[k + 1], crc_comb[k]); - gf2_matrix_square(crc_comb[k + 2], crc_comb[k + 1]); - gf2_matrix_square(crc_comb[0], crc_comb[k + 2]); - - /* generate operators for applying 2^n zero bytes to a CRC, filling out - the remainder of the table -- the operators repeat after GF2_DIM - values of n, so the table only needs GF2_DIM entries, regardless of - the size of the length being processed */ - for (n = 1; n < k; n++) - gf2_matrix_square(crc_comb[n], crc_comb[n - 1]); - - /* mark tables as complete, in case someone else is waiting */ - crc_table_empty = 0; - } else { /* not first */ - /* wait for the other guy to finish (not efficient, but rare) */ - while (crc_table_empty) - {} - } -#ifdef MAKECRCH - { - FILE *out; - - out = fopen("crc32.h", "w"); - if (out == NULL) return; - - /* write out CRC table to crc32.h */ - fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n"); - fprintf(out, " * Generated automatically by crc32.c\n */\n\n"); - fprintf(out, "static const uint32_t "); - fprintf(out, "crc_table[8][256] =\n{\n {\n"); - write_table(out, crc_table[0], 256); - for (k = 1; k < 8; k++) { - fprintf(out, " },\n {\n"); - write_table(out, crc_table[k], 256); - } - fprintf(out, " }\n};\n"); - - /* write out zero operator table to crc32.h */ - fprintf(out, "\nstatic const uint32_t "); - fprintf(out, "crc_comb[%d][%d] =\n{\n {\n", GF2_DIM, GF2_DIM); - write_table(out, crc_comb[0], GF2_DIM); - for (k = 1; k < GF2_DIM; k++) { - fprintf(out, " },\n {\n"); - write_table(out, crc_comb[k], GF2_DIM); - } - fprintf(out, " }\n};\n"); - fclose(out); - } -#endif /* MAKECRCH */ -} - -#ifdef MAKECRCH -static void write_table(FILE *out, const uint32_t *table, int k) { - int n; - - for (n = 0; n < k; n++) - fprintf(out, "%s0x%08" PRIx32 "%s", n % 5 ? "" : " ", - (uint32_t)(table[n]), - n == k - 1 ? "\n" : (n % 5 == 4 ? ",\n" : ", ")); -} - -int main() -{ - make_crc_table(); - return 0; -} -#endif /* MAKECRCH */ - -#else /* !DYNAMIC_CRC_TABLE */ -/* ======================================================================== - * Tables of CRC-32s of all single-byte values, made by make_crc_table(), - * and tables of zero operator matrices for crc32_combine(). - */ -#include "crc32.h" -#endif /* DYNAMIC_CRC_TABLE */ +#include "crc32_tbl.h" /* ========================================================================= * This function can be used by asm versions of crc32() */ -const uint32_t * ZEXPORT PREFIX(get_crc_table)(void) { -#ifdef DYNAMIC_CRC_TABLE - if (crc_table_empty) - make_crc_table(); -#endif /* DYNAMIC_CRC_TABLE */ +const uint32_t * Z_EXPORT PREFIX(get_crc_table)(void) { return (const uint32_t *)crc_table; } -uint32_t ZEXPORT PREFIX(crc32_z)(uint32_t crc, const unsigned char *buf, size_t len) { +#ifdef ZLIB_COMPAT +unsigned long Z_EXPORT PREFIX(crc32_z)(unsigned long crc, const unsigned char *buf, size_t len) { + if (buf == NULL) return 0; + + return (unsigned long)functable.crc32((uint32_t)crc, buf, len); +} +#else +uint32_t Z_EXPORT PREFIX(crc32_z)(uint32_t crc, const unsigned char *buf, size_t len) { if (buf == NULL) return 0; return functable.crc32(crc, buf, len); } +#endif /* ========================================================================= */ #define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8) #define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1 #define DO4 DO1; DO1; DO1; DO1 /* ========================================================================= */ -ZLIB_INTERNAL uint32_t crc32_generic(uint32_t crc, const unsigned char *buf, uint64_t len) -{ +Z_INTERNAL uint32_t crc32_generic(uint32_t crc, const unsigned char *buf, uint64_t len) { crc = crc ^ 0xffffffff; #ifdef UNROLL_MORE @@ -274,9 +63,15 @@ ZLIB_INTERNAL uint32_t crc32_generic(uint32_t crc, const unsigned char *buf, uin return crc ^ 0xffffffff; } -uint32_t ZEXPORT PREFIX(crc32)(uint32_t crc, const unsigned char *buf, uint32_t len) { +#ifdef ZLIB_COMPAT +unsigned long Z_EXPORT PREFIX(crc32)(unsigned long crc, const unsigned char *buf, unsigned int len) { + return (unsigned long)PREFIX(crc32_z)((uint32_t)crc, buf, len); +} +#else +uint32_t Z_EXPORT PREFIX(crc32)(uint32_t crc, const unsigned char *buf, uint32_t len) { return PREFIX(crc32_z)(crc, buf, len); } +#endif /* This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit @@ -298,9 +93,9 @@ uint32_t ZEXPORT PREFIX(crc32)(uint32_t crc, const unsigned char *buf, uint32_t #define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4 /* ========================================================================= */ -ZLIB_INTERNAL uint32_t crc32_little(uint32_t crc, const unsigned char *buf, uint64_t len) { - register uint32_t c; - register const uint32_t *buf4; +Z_INTERNAL uint32_t crc32_little(uint32_t crc, const unsigned char *buf, uint64_t len) { + Z_REGISTER uint32_t c; + Z_REGISTER const uint32_t *buf4; c = crc; c = ~c; @@ -340,9 +135,9 @@ ZLIB_INTERNAL uint32_t crc32_little(uint32_t crc, const unsigned char *buf, uint #define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4 /* ========================================================================= */ -ZLIB_INTERNAL uint32_t crc32_big(uint32_t crc, const unsigned char *buf, uint64_t len) { - register uint32_t c; - register const uint32_t *buf4; +Z_INTERNAL uint32_t crc32_big(uint32_t crc, const unsigned char *buf, uint64_t len) { + Z_REGISTER uint32_t c; + Z_REGISTER const uint32_t *buf4; c = ZSWAP32(crc); c = ~c; @@ -374,45 +169,19 @@ ZLIB_INTERNAL uint32_t crc32_big(uint32_t crc, const unsigned char *buf, uint64_ } #endif /* BYTE_ORDER == BIG_ENDIAN */ - -/* ========================================================================= */ -static uint32_t crc32_combine_(uint32_t crc1, uint32_t crc2, z_off64_t len2) { - int n; - -#ifdef DYNAMIC_CRC_TABLE - if (crc_table_empty) - make_crc_table(); -#endif /* DYNAMIC_CRC_TABLE */ - - if (len2 > 0) - /* operator for 2^n zeros repeats every GF2_DIM n values */ - for (n = 0; len2; n = (n + 1) % GF2_DIM, len2 >>= 1) - if (len2 & 1) - crc1 = gf2_matrix_times(crc_comb[n], crc1); - return crc1 ^ crc2; -} - -/* ========================================================================= */ -uint32_t ZEXPORT PREFIX(crc32_combine)(uint32_t crc1, uint32_t crc2, z_off_t len2) { - return crc32_combine_(crc1, crc2, len2); -} - -uint32_t ZEXPORT PREFIX(crc32_combine64)(uint32_t crc1, uint32_t crc2, z_off64_t len2) { - return crc32_combine_(crc1, crc2, len2); -} - #ifdef X86_PCLMULQDQ_CRC #include "arch/x86/x86.h" #include "arch/x86/crc_folding.h" -ZLIB_INTERNAL void crc_finalize(deflate_state *const s) { +Z_INTERNAL void crc_finalize(deflate_state *const s) { if (x86_cpu_has_pclmulqdq) s->strm->adler = crc_fold_512to32(s); } #endif -ZLIB_INTERNAL void crc_reset(deflate_state *const s) { +Z_INTERNAL void crc_reset(deflate_state *const s) { #ifdef X86_PCLMULQDQ_CRC + x86_check_features(); if (x86_cpu_has_pclmulqdq) { crc_fold_init(s); return; @@ -421,7 +190,7 @@ ZLIB_INTERNAL void crc_reset(deflate_state *const s) { s->strm->adler = PREFIX(crc32)(0L, NULL, 0); } -ZLIB_INTERNAL void copy_with_crc(PREFIX3(stream) *strm, unsigned char *dst, unsigned long size) { +Z_INTERNAL void copy_with_crc(PREFIX3(stream) *strm, unsigned char *dst, unsigned long size) { #ifdef X86_PCLMULQDQ_CRC if (x86_cpu_has_pclmulqdq) { crc_fold_copy(strm->state, dst, strm->next_in, size); @@ -431,68 +200,3 @@ ZLIB_INTERNAL void copy_with_crc(PREFIX3(stream) *strm, unsigned char *dst, unsi memcpy(dst, strm->next_in, size); strm->adler = PREFIX(crc32)(strm->adler, dst, size); } - -/* ========================================================================= */ -static void crc32_combine_gen_(uint32_t *op, z_off64_t len2) -{ - uint32_t row; - int j; - unsigned i; - -#ifdef DYNAMIC_CRC_TABLE - if (crc_table_empty) - make_crc_table(); -#endif /* DYNAMIC_CRC_TABLE */ - - /* if len2 is zero or negative, return the identity matrix */ - if (len2 <= 0) { - row = 1; - for (j = 0; j < GF2_DIM; j++) { - op[j] = row; - row <<= 1; - } - return; - } - - /* at least one bit in len2 is set -- find it, and copy the operator - corresponding to that position into op */ - i = 0; - for (;;) { - if (len2 & 1) { - for (j = 0; j < GF2_DIM; j++) - op[j] = crc_comb[i][j]; - break; - } - len2 >>= 1; - i = (i + 1) % GF2_DIM; - } - - /* for each remaining bit set in len2 (if any), multiply op by the operator - corresponding to that position */ - for (;;) { - len2 >>= 1; - i = (i + 1) % GF2_DIM; - if (len2 == 0) - break; - if (len2 & 1) - for (j = 0; j < GF2_DIM; j++) - op[j] = gf2_matrix_times(crc_comb[i], op[j]); - } -} - -/* ========================================================================= */ -void ZEXPORT PREFIX(crc32_combine_gen)(uint32_t *op, z_off_t len2) -{ - crc32_combine_gen_(op, len2); -} - -void ZEXPORT PREFIX(crc32_combine_gen64)(uint32_t *op, z_off64_t len2) -{ - crc32_combine_gen_(op, len2); -} - -/* ========================================================================= */ -uint32_t ZEXPORT PREFIX(crc32_combine_op)(uint32_t crc1, uint32_t crc2, const uint32_t *op) -{ - return gf2_matrix_times(op, crc1) ^ crc2; -} diff --git a/libs/zlibng/crc32_comb.c b/libs/zlibng/crc32_comb.c new file mode 100644 index 000000000..092c595d9 --- /dev/null +++ b/libs/zlibng/crc32_comb.c @@ -0,0 +1,108 @@ +/* crc32_comb.c -- compute the CRC-32 of a data stream + * Copyright (C) 1995-2006, 2010, 2011, 2012, 2016, 2018 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + * + * Thanks to Rodney Brown for his contribution of faster + * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing + * tables for updating the shift register in one step with three exclusive-ors + * instead of four steps with four exclusive-ors. This results in about a + * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3. + */ + +#include "zbuild.h" +#include +#include "deflate.h" +#include "crc32_p.h" +#include "crc32_comb_tbl.h" + + +/* Local functions for crc concatenation */ +static uint32_t crc32_combine_(uint32_t crc1, uint32_t crc2, z_off64_t len2); +static void crc32_combine_gen_(uint32_t *op, z_off64_t len2); + +/* ========================================================================= */ +static uint32_t crc32_combine_(uint32_t crc1, uint32_t crc2, z_off64_t len2) { + int n; + + if (len2 > 0) + /* operator for 2^n zeros repeats every GF2_DIM n values */ + for (n = 0; len2; n = (n + 1) % GF2_DIM, len2 >>= 1) + if (len2 & 1) + crc1 = gf2_matrix_times(crc_comb[n], crc1); + return crc1 ^ crc2; +} + +/* ========================================================================= */ +#ifdef ZLIB_COMPAT +unsigned long Z_EXPORT PREFIX(crc32_combine)(unsigned long crc1, unsigned long crc2, z_off_t len2) { + return (unsigned long)crc32_combine_((uint32_t)crc1, (uint32_t)crc2, len2); +} + +unsigned long Z_EXPORT PREFIX4(crc32_combine)(unsigned long crc1, unsigned long crc2, z_off64_t len2) { + return (unsigned long)crc32_combine_((uint32_t)crc1, (uint32_t)crc2, len2); +} +#else +uint32_t Z_EXPORT PREFIX4(crc32_combine)(uint32_t crc1, uint32_t crc2, z_off64_t len2) { + return crc32_combine_(crc1, crc2, len2); +} +#endif + +/* ========================================================================= */ + +static void crc32_combine_gen_(uint32_t *op, z_off64_t len2) { + uint32_t row; + int j; + unsigned i; + + /* if len2 is zero or negative, return the identity matrix */ + if (len2 <= 0) { + row = 1; + for (j = 0; j < GF2_DIM; j++) { + op[j] = row; + row <<= 1; + } + return; + } + + /* at least one bit in len2 is set -- find it, and copy the operator + corresponding to that position into op */ + i = 0; + for (;;) { + if (len2 & 1) { + for (j = 0; j < GF2_DIM; j++) + op[j] = crc_comb[i][j]; + break; + } + len2 >>= 1; + i = (i + 1) % GF2_DIM; + } + + /* for each remaining bit set in len2 (if any), multiply op by the operator + corresponding to that position */ + for (;;) { + len2 >>= 1; + i = (i + 1) % GF2_DIM; + if (len2 == 0) + break; + if (len2 & 1) + for (j = 0; j < GF2_DIM; j++) + op[j] = gf2_matrix_times(crc_comb[i], op[j]); + } +} + +/* ========================================================================= */ + +#ifdef ZLIB_COMPAT +void Z_EXPORT PREFIX(crc32_combine_gen)(uint32_t *op, z_off_t len2) { + crc32_combine_gen_(op, len2); +} +#endif + +void Z_EXPORT PREFIX4(crc32_combine_gen)(uint32_t *op, z_off64_t len2) { + crc32_combine_gen_(op, len2); +} + +/* ========================================================================= */ +uint32_t Z_EXPORT PREFIX(crc32_combine_op)(uint32_t crc1, uint32_t crc2, const uint32_t *op) { + return gf2_matrix_times(op, crc1) ^ crc2; +} diff --git a/libs/zlibng/crc32_comb_tbl.h b/libs/zlibng/crc32_comb_tbl.h new file mode 100644 index 000000000..43818c3e0 --- /dev/null +++ b/libs/zlibng/crc32_comb_tbl.h @@ -0,0 +1,300 @@ +#ifndef CRC32_COMB_TBL_H_ +#define CRC32_COMB_TBL_H_ + +/* crc32_comb_tbl.h -- zero operators table for CRC combine + * Generated automatically by makecrct.c + */ + +static const uint32_t crc_comb[32][32] = +{ + { + 0x77073096, 0xee0e612c, 0x076dc419, 0x0edb8832, 0x1db71064, + 0x3b6e20c8, 0x76dc4190, 0xedb88320, 0x00000001, 0x00000002, + 0x00000004, 0x00000008, 0x00000010, 0x00000020, 0x00000040, + 0x00000080, 0x00000100, 0x00000200, 0x00000400, 0x00000800, + 0x00001000, 0x00002000, 0x00004000, 0x00008000, 0x00010000, + 0x00020000, 0x00040000, 0x00080000, 0x00100000, 0x00200000, + 0x00400000, 0x00800000 + }, + { + 0x191b3141, 0x32366282, 0x646cc504, 0xc8d98a08, 0x4ac21251, + 0x958424a2, 0xf0794f05, 0x3b83984b, 0x77073096, 0xee0e612c, + 0x076dc419, 0x0edb8832, 0x1db71064, 0x3b6e20c8, 0x76dc4190, + 0xedb88320, 0x00000001, 0x00000002, 0x00000004, 0x00000008, + 0x00000010, 0x00000020, 0x00000040, 0x00000080, 0x00000100, + 0x00000200, 0x00000400, 0x00000800, 0x00001000, 0x00002000, + 0x00004000, 0x00008000 + }, + { + 0xb8bc6765, 0xaa09c88b, 0x8f629757, 0xc5b428ef, 0x5019579f, + 0xa032af3e, 0x9b14583d, 0xed59b63b, 0x01c26a37, 0x0384d46e, + 0x0709a8dc, 0x0e1351b8, 0x1c26a370, 0x384d46e0, 0x709a8dc0, + 0xe1351b80, 0x191b3141, 0x32366282, 0x646cc504, 0xc8d98a08, + 0x4ac21251, 0x958424a2, 0xf0794f05, 0x3b83984b, 0x77073096, + 0xee0e612c, 0x076dc419, 0x0edb8832, 0x1db71064, 0x3b6e20c8, + 0x76dc4190, 0xedb88320 + }, + { + 0xccaa009e, 0x4225077d, 0x844a0efa, 0xd3e51bb5, 0x7cbb312b, + 0xf9766256, 0x299dc2ed, 0x533b85da, 0xa6770bb4, 0x979f1129, + 0xf44f2413, 0x33ef4e67, 0x67de9cce, 0xcfbd399c, 0x440b7579, + 0x8816eaf2, 0xcb5cd3a5, 0x4dc8a10b, 0x9b914216, 0xec53826d, + 0x03d6029b, 0x07ac0536, 0x0f580a6c, 0x1eb014d8, 0x3d6029b0, + 0x7ac05360, 0xf580a6c0, 0x30704bc1, 0x60e09782, 0xc1c12f04, + 0x58f35849, 0xb1e6b092 + }, + { + 0xae689191, 0x87a02563, 0xd4314c87, 0x73139f4f, 0xe6273e9e, + 0x173f7b7d, 0x2e7ef6fa, 0x5cfdedf4, 0xb9fbdbe8, 0xa886b191, + 0x8a7c6563, 0xcf89cc87, 0x44629f4f, 0x88c53e9e, 0xcafb7b7d, + 0x4e87f0bb, 0x9d0fe176, 0xe16ec4ad, 0x19ac8f1b, 0x33591e36, + 0x66b23c6c, 0xcd6478d8, 0x41b9f7f1, 0x8373efe2, 0xdd96d985, + 0x605cb54b, 0xc0b96a96, 0x5a03d36d, 0xb407a6da, 0xb37e4bf5, + 0xbd8d91ab, 0xa06a2517 + }, + { + 0xf1da05aa, 0x38c50d15, 0x718a1a2a, 0xe3143454, 0x1d596ee9, + 0x3ab2ddd2, 0x7565bba4, 0xeacb7748, 0x0ee7e8d1, 0x1dcfd1a2, + 0x3b9fa344, 0x773f4688, 0xee7e8d10, 0x078c1c61, 0x0f1838c2, + 0x1e307184, 0x3c60e308, 0x78c1c610, 0xf1838c20, 0x38761e01, + 0x70ec3c02, 0xe1d87804, 0x18c1f649, 0x3183ec92, 0x6307d924, + 0xc60fb248, 0x576e62d1, 0xaedcc5a2, 0x86c88d05, 0xd6e01c4b, + 0x76b13ed7, 0xed627dae + }, + { + 0x8f352d95, 0xc51b5d6b, 0x5147bc97, 0xa28f792e, 0x9e6ff41d, + 0xe7aeee7b, 0x142cdab7, 0x2859b56e, 0x50b36adc, 0xa166d5b8, + 0x99bcad31, 0xe8085c23, 0x0b61be07, 0x16c37c0e, 0x2d86f81c, + 0x5b0df038, 0xb61be070, 0xb746c6a1, 0xb5fc8b03, 0xb0881047, + 0xba6126cf, 0xafb34bdf, 0x841791ff, 0xd35e25bf, 0x7dcd4d3f, + 0xfb9a9a7e, 0x2c4432bd, 0x5888657a, 0xb110caf4, 0xb95093a9, + 0xa9d02113, 0x88d14467 + }, + { + 0x33fff533, 0x67ffea66, 0xcfffd4cc, 0x448eafd9, 0x891d5fb2, + 0xc94bb925, 0x49e6740b, 0x93cce816, 0xfce8d66d, 0x22a0aa9b, + 0x45415536, 0x8a82aa6c, 0xce745299, 0x4799a373, 0x8f3346e6, + 0xc5178b8d, 0x515e115b, 0xa2bc22b6, 0x9e09432d, 0xe763801b, + 0x15b60677, 0x2b6c0cee, 0x56d819dc, 0xadb033b8, 0x80116131, + 0xdb53c423, 0x6dd68e07, 0xdbad1c0e, 0x6c2b3e5d, 0xd8567cba, + 0x6bddff35, 0xd7bbfe6a + }, + { + 0xce3371cb, 0x4717e5d7, 0x8e2fcbae, 0xc72e911d, 0x552c247b, + 0xaa5848f6, 0x8fc197ad, 0xc4f2291b, 0x52955477, 0xa52aa8ee, + 0x9124579d, 0xf939a97b, 0x290254b7, 0x5204a96e, 0xa40952dc, + 0x9363a3f9, 0xfdb641b3, 0x201d8527, 0x403b0a4e, 0x8076149c, + 0xdb9d2f79, 0x6c4b58b3, 0xd896b166, 0x6a5c648d, 0xd4b8c91a, + 0x72009475, 0xe40128ea, 0x13735795, 0x26e6af2a, 0x4dcd5e54, + 0x9b9abca8, 0xec447f11 + }, + { + 0x1072db28, 0x20e5b650, 0x41cb6ca0, 0x8396d940, 0xdc5cb4c1, + 0x63c86fc3, 0xc790df86, 0x5450b94d, 0xa8a1729a, 0x8a33e375, + 0xcf16c0ab, 0x455c8717, 0x8ab90e2e, 0xce031a1d, 0x4777327b, + 0x8eee64f6, 0xc6adcfad, 0x562a991b, 0xac553236, 0x83db622d, + 0xdcc7c21b, 0x62fe8277, 0xc5fd04ee, 0x508b0f9d, 0xa1161f3a, + 0x995d3835, 0xe9cb762b, 0x08e7ea17, 0x11cfd42e, 0x239fa85c, + 0x473f50b8, 0x8e7ea170 + }, + { + 0xf891f16f, 0x2a52e49f, 0x54a5c93e, 0xa94b927c, 0x89e622b9, + 0xc8bd4333, 0x4a0b8027, 0x9417004e, 0xf35f06dd, 0x3dcf0bfb, + 0x7b9e17f6, 0xf73c2fec, 0x35095999, 0x6a12b332, 0xd4256664, + 0x733bca89, 0xe6779512, 0x179e2c65, 0x2f3c58ca, 0x5e78b194, + 0xbcf16328, 0xa293c011, 0x9e568663, 0xe7dc0a87, 0x14c9134f, + 0x2992269e, 0x53244d3c, 0xa6489a78, 0x97e032b1, 0xf4b16323, + 0x3213c007, 0x6427800e + }, + { + 0x88b6ba63, 0xca1c7287, 0x4f49e34f, 0x9e93c69e, 0xe6568b7d, + 0x17dc10bb, 0x2fb82176, 0x5f7042ec, 0xbee085d8, 0xa6b00df1, + 0x96111da3, 0xf7533d07, 0x35d77c4f, 0x6baef89e, 0xd75df13c, + 0x75cae439, 0xeb95c872, 0x0c5a96a5, 0x18b52d4a, 0x316a5a94, + 0x62d4b528, 0xc5a96a50, 0x5023d2e1, 0xa047a5c2, 0x9bfe4dc5, + 0xec8d9dcb, 0x026a3dd7, 0x04d47bae, 0x09a8f75c, 0x1351eeb8, + 0x26a3dd70, 0x4d47bae0 + }, + { + 0x5ad8a92c, 0xb5b15258, 0xb013a2f1, 0xbb5643a3, 0xaddd8107, + 0x80ca044f, 0xdae50edf, 0x6ebb1bff, 0xdd7637fe, 0x619d69bd, + 0xc33ad37a, 0x5d04a0b5, 0xba09416a, 0xaf638495, 0x85b60f6b, + 0xd01d1897, 0x7b4b376f, 0xf6966ede, 0x365ddbfd, 0x6cbbb7fa, + 0xd9776ff4, 0x699fd9a9, 0xd33fb352, 0x7d0e60e5, 0xfa1cc1ca, + 0x2f4885d5, 0x5e910baa, 0xbd221754, 0xa13528e9, 0x991b5793, + 0xe947a967, 0x09fe548f + }, + { + 0xb566f6e2, 0xb1bceb85, 0xb808d14b, 0xab60a4d7, 0x8db04fef, + 0xc011999f, 0x5b52357f, 0xb6a46afe, 0xb639d3bd, 0xb702a13b, + 0xb5744437, 0xb1998e2f, 0xb8421a1f, 0xabf5327f, 0x8c9b62bf, + 0xc247c33f, 0x5ffe803f, 0xbffd007e, 0xa48b06bd, 0x92670b3b, + 0xffbf1037, 0x240f262f, 0x481e4c5e, 0x903c98bc, 0xfb083739, + 0x2d616833, 0x5ac2d066, 0xb585a0cc, 0xb07a47d9, 0xbb8589f3, + 0xac7a15a7, 0x83852d0f + }, + { + 0x9d9129bf, 0xe053553f, 0x1bd7ac3f, 0x37af587e, 0x6f5eb0fc, + 0xdebd61f8, 0x660bc5b1, 0xcc178b62, 0x435e1085, 0x86bc210a, + 0xd6094455, 0x77638eeb, 0xeec71dd6, 0x06ff3ded, 0x0dfe7bda, + 0x1bfcf7b4, 0x37f9ef68, 0x6ff3ded0, 0xdfe7bda0, 0x64be7d01, + 0xc97cfa02, 0x4988f245, 0x9311e48a, 0xfd52cf55, 0x21d498eb, + 0x43a931d6, 0x875263ac, 0xd5d5c119, 0x70da8473, 0xe1b508e6, + 0x181b178d, 0x30362f1a + }, + { + 0x2ee43a2c, 0x5dc87458, 0xbb90e8b0, 0xac50d721, 0x83d0a803, + 0xdcd05647, 0x62d1aacf, 0xc5a3559e, 0x5037ad7d, 0xa06f5afa, + 0x9bafb3b5, 0xec2e612b, 0x032dc417, 0x065b882e, 0x0cb7105c, + 0x196e20b8, 0x32dc4170, 0x65b882e0, 0xcb7105c0, 0x4d930dc1, + 0x9b261b82, 0xed3d3145, 0x010b64cb, 0x0216c996, 0x042d932c, + 0x085b2658, 0x10b64cb0, 0x216c9960, 0x42d932c0, 0x85b26580, + 0xd015cd41, 0x7b5a9cc3 + }, + { + 0x1b4511ee, 0x368a23dc, 0x6d1447b8, 0xda288f70, 0x6f2018a1, + 0xde403142, 0x67f164c5, 0xcfe2c98a, 0x44b49555, 0x89692aaa, + 0xc9a35315, 0x4837a06b, 0x906f40d6, 0xfbaf87ed, 0x2c2e099b, + 0x585c1336, 0xb0b8266c, 0xba014a99, 0xaf739373, 0x859620a7, + 0xd05d470f, 0x7bcb885f, 0xf79710be, 0x345f273d, 0x68be4e7a, + 0xd17c9cf4, 0x79883fa9, 0xf3107f52, 0x3d51f8e5, 0x7aa3f1ca, + 0xf547e394, 0x31fec169 + }, + { + 0xbce15202, 0xa2b3a245, 0x9e1642cb, 0xe75d83d7, 0x15ca01ef, + 0x2b9403de, 0x572807bc, 0xae500f78, 0x87d118b1, 0xd4d33723, + 0x72d76807, 0xe5aed00e, 0x102ca65d, 0x20594cba, 0x40b29974, + 0x816532e8, 0xd9bb6391, 0x6807c163, 0xd00f82c6, 0x7b6e03cd, + 0xf6dc079a, 0x36c90975, 0x6d9212ea, 0xdb2425d4, 0x6d394de9, + 0xda729bd2, 0x6f9431e5, 0xdf2863ca, 0x6521c1d5, 0xca4383aa, + 0x4ff60115, 0x9fec022a + }, + { + 0xff08e5ef, 0x2560cd9f, 0x4ac19b3e, 0x9583367c, 0xf0776ab9, + 0x3b9fd333, 0x773fa666, 0xee7f4ccc, 0x078f9fd9, 0x0f1f3fb2, + 0x1e3e7f64, 0x3c7cfec8, 0x78f9fd90, 0xf1f3fb20, 0x3896f001, + 0x712de002, 0xe25bc004, 0x1fc68649, 0x3f8d0c92, 0x7f1a1924, + 0xfe343248, 0x271962d1, 0x4e32c5a2, 0x9c658b44, 0xe3ba10c9, + 0x1c0527d3, 0x380a4fa6, 0x70149f4c, 0xe0293e98, 0x1b237b71, + 0x3646f6e2, 0x6c8dedc4 + }, + { + 0x6f76172e, 0xdeec2e5c, 0x66a95af9, 0xcd52b5f2, 0x41d46da5, + 0x83a8db4a, 0xdc20b0d5, 0x633067eb, 0xc660cfd6, 0x57b099ed, + 0xaf6133da, 0x85b361f5, 0xd017c5ab, 0x7b5e8d17, 0xf6bd1a2e, + 0x360b321d, 0x6c16643a, 0xd82cc874, 0x6b2896a9, 0xd6512d52, + 0x77d35ce5, 0xefa6b9ca, 0x043c75d5, 0x0878ebaa, 0x10f1d754, + 0x21e3aea8, 0x43c75d50, 0x878ebaa0, 0xd46c7301, 0x73a9e043, + 0xe753c086, 0x15d6874d + }, + { + 0x56f5cab9, 0xadeb9572, 0x80a62ca5, 0xda3d5f0b, 0x6f0bb857, + 0xde1770ae, 0x675fe71d, 0xcebfce3a, 0x460e9a35, 0x8c1d346a, + 0xc34b6e95, 0x5de7db6b, 0xbbcfb6d6, 0xacee6bed, 0x82add19b, + 0xde2aa577, 0x67244caf, 0xce48995e, 0x47e034fd, 0x8fc069fa, + 0xc4f1d5b5, 0x5292ad2b, 0xa5255a56, 0x913bb2ed, 0xf906639b, + 0x297dc177, 0x52fb82ee, 0xa5f705dc, 0x909f0df9, 0xfa4f1db3, + 0x2fef3d27, 0x5fde7a4e + }, + { + 0x385993ac, 0x70b32758, 0xe1664eb0, 0x19bd9b21, 0x337b3642, + 0x66f66c84, 0xcdecd908, 0x40a8b451, 0x815168a2, 0xd9d3d705, + 0x68d6a84b, 0xd1ad5096, 0x782ba76d, 0xf0574eda, 0x3bdf9bf5, + 0x77bf37ea, 0xef7e6fd4, 0x058dd9e9, 0x0b1bb3d2, 0x163767a4, + 0x2c6ecf48, 0x58dd9e90, 0xb1bb3d20, 0xb8077c01, 0xab7ffe43, + 0x8d8efac7, 0xc06cf3cf, 0x5ba8e1df, 0xb751c3be, 0xb5d2813d, + 0xb0d4043b, 0xbad90e37 + }, + { + 0xb4247b20, 0xb339f001, 0xbd02e643, 0xa174cac7, 0x999893cf, + 0xe84021df, 0x0bf145ff, 0x17e28bfe, 0x2fc517fc, 0x5f8a2ff8, + 0xbf145ff0, 0xa559b9a1, 0x91c27503, 0xf8f5ec47, 0x2a9adecf, + 0x5535bd9e, 0xaa6b7b3c, 0x8fa7f039, 0xc43ee633, 0x530cca27, + 0xa619944e, 0x97422edd, 0xf5f55bfb, 0x309bb1b7, 0x6137636e, + 0xc26ec6dc, 0x5fac8bf9, 0xbf5917f2, 0xa5c329a5, 0x90f7550b, + 0xfa9fac57, 0x2e4e5eef + }, + { + 0x695186a7, 0xd2a30d4e, 0x7e371cdd, 0xfc6e39ba, 0x23ad7535, + 0x475aea6a, 0x8eb5d4d4, 0xc61aafe9, 0x57445993, 0xae88b326, + 0x8660600d, 0xd7b1c65b, 0x74128af7, 0xe82515ee, 0x0b3b2d9d, + 0x16765b3a, 0x2cecb674, 0x59d96ce8, 0xb3b2d9d0, 0xbc14b5e1, + 0xa3586d83, 0x9dc1dd47, 0xe0f2bccf, 0x1a947fdf, 0x3528ffbe, + 0x6a51ff7c, 0xd4a3fef8, 0x7236fbb1, 0xe46df762, 0x13aae885, + 0x2755d10a, 0x4eaba214 + }, + { + 0x66bc001e, 0xcd78003c, 0x41810639, 0x83020c72, 0xdd751ea5, + 0x619b3b0b, 0xc3367616, 0x5d1dea6d, 0xba3bd4da, 0xaf06aff5, + 0x857c59ab, 0xd189b517, 0x78626c6f, 0xf0c4d8de, 0x3af8b7fd, + 0x75f16ffa, 0xebe2dff4, 0x0cb4b9a9, 0x19697352, 0x32d2e6a4, + 0x65a5cd48, 0xcb4b9a90, 0x4de63361, 0x9bcc66c2, 0xece9cbc5, + 0x02a291cb, 0x05452396, 0x0a8a472c, 0x15148e58, 0x2a291cb0, + 0x54523960, 0xa8a472c0 + }, + { + 0xb58b27b3, 0xb0674927, 0xbbbf940f, 0xac0e2e5f, 0x836d5aff, + 0xddabb3bf, 0x6026613f, 0xc04cc27e, 0x5be882bd, 0xb7d1057a, + 0xb4d30cb5, 0xb2d71f2b, 0xbedf3817, 0xa6cf766f, 0x96efea9f, + 0xf6aed37f, 0x362ca0bf, 0x6c59417e, 0xd8b282fc, 0x6a1403b9, + 0xd4280772, 0x732108a5, 0xe642114a, 0x17f524d5, 0x2fea49aa, + 0x5fd49354, 0xbfa926a8, 0xa4234b11, 0x93379063, 0xfd1e2687, + 0x214d4b4f, 0x429a969e + }, + { + 0xfe273162, 0x273f6485, 0x4e7ec90a, 0x9cfd9214, 0xe28a2269, + 0x1e654293, 0x3cca8526, 0x79950a4c, 0xf32a1498, 0x3d252f71, + 0x7a4a5ee2, 0xf494bdc4, 0x32587dc9, 0x64b0fb92, 0xc961f724, + 0x49b2e809, 0x9365d012, 0xfdbaa665, 0x20044a8b, 0x40089516, + 0x80112a2c, 0xdb535219, 0x6dd7a273, 0xdbaf44e6, 0x6c2f8f8d, + 0xd85f1f1a, 0x6bcf3875, 0xd79e70ea, 0x744de795, 0xe89bcf2a, + 0x0a469815, 0x148d302a + }, + { + 0xd3c98813, 0x7ce21667, 0xf9c42cce, 0x28f95fdd, 0x51f2bfba, + 0xa3e57f74, 0x9cbbf8a9, 0xe206f713, 0x1f7ce867, 0x3ef9d0ce, + 0x7df3a19c, 0xfbe74338, 0x2cbf8031, 0x597f0062, 0xb2fe00c4, + 0xbe8d07c9, 0xa66b09d3, 0x97a715e7, 0xf43f2d8f, 0x330f5d5f, + 0x661ebabe, 0xcc3d757c, 0x430becb9, 0x8617d972, 0xd75eb4a5, + 0x75cc6f0b, 0xeb98de16, 0x0c40ba6d, 0x188174da, 0x3102e9b4, + 0x6205d368, 0xc40ba6d0 + }, + { + 0xf7d6deb4, 0x34dcbb29, 0x69b97652, 0xd372eca4, 0x7d94df09, + 0xfb29be12, 0x2d227a65, 0x5a44f4ca, 0xb489e994, 0xb262d569, + 0xbfb4ac93, 0xa4185f67, 0x9341b88f, 0xfdf2775f, 0x2095e8ff, + 0x412bd1fe, 0x8257a3fc, 0xdfde41b9, 0x64cd8533, 0xc99b0a66, + 0x4847128d, 0x908e251a, 0xfa6d4c75, 0x2fab9eab, 0x5f573d56, + 0xbeae7aac, 0xa62df319, 0x972ae073, 0xf524c6a7, 0x31388b0f, + 0x6271161e, 0xc4e22c3c + }, + { + 0xedb88320, 0x00000001, 0x00000002, 0x00000004, 0x00000008, + 0x00000010, 0x00000020, 0x00000040, 0x00000080, 0x00000100, + 0x00000200, 0x00000400, 0x00000800, 0x00001000, 0x00002000, + 0x00004000, 0x00008000, 0x00010000, 0x00020000, 0x00040000, + 0x00080000, 0x00100000, 0x00200000, 0x00400000, 0x00800000, + 0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, + 0x20000000, 0x40000000 + }, + { + 0x76dc4190, 0xedb88320, 0x00000001, 0x00000002, 0x00000004, + 0x00000008, 0x00000010, 0x00000020, 0x00000040, 0x00000080, + 0x00000100, 0x00000200, 0x00000400, 0x00000800, 0x00001000, + 0x00002000, 0x00004000, 0x00008000, 0x00010000, 0x00020000, + 0x00040000, 0x00080000, 0x00100000, 0x00200000, 0x00400000, + 0x00800000, 0x01000000, 0x02000000, 0x04000000, 0x08000000, + 0x10000000, 0x20000000 + }, + { + 0x1db71064, 0x3b6e20c8, 0x76dc4190, 0xedb88320, 0x00000001, + 0x00000002, 0x00000004, 0x00000008, 0x00000010, 0x00000020, + 0x00000040, 0x00000080, 0x00000100, 0x00000200, 0x00000400, + 0x00000800, 0x00001000, 0x00002000, 0x00004000, 0x00008000, + 0x00010000, 0x00020000, 0x00040000, 0x00080000, 0x00100000, + 0x00200000, 0x00400000, 0x00800000, 0x01000000, 0x02000000, + 0x04000000, 0x08000000 + } +}; + +#endif /* CRC32_COMB_TBL_H_ */ diff --git a/libs/zlibng/crc32_p.h b/libs/zlibng/crc32_p.h new file mode 100644 index 000000000..47b4b3751 --- /dev/null +++ b/libs/zlibng/crc32_p.h @@ -0,0 +1,19 @@ +#ifndef CRC32_P_H_ +#define CRC32_P_H_ + +#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */ + + +static inline uint32_t gf2_matrix_times(const uint32_t *mat, uint32_t vec) { + uint32_t sum = 0; + while (vec) { + if (vec & 1) + sum ^= *mat; + vec >>= 1; + mat++; + } + return sum; +} + + +#endif /* CRC32_P_H_ */ diff --git a/libs/zlibng/crc32.h b/libs/zlibng/crc32_tbl.h similarity index 62% rename from libs/zlibng/crc32.h rename to libs/zlibng/crc32_tbl.h index 47ca7c068..ee2030c6c 100644 --- a/libs/zlibng/crc32.h +++ b/libs/zlibng/crc32_tbl.h @@ -1,8 +1,8 @@ -#ifndef CRC32_H_ -#define CRC32_H_ +#ifndef CRC32_TBL_H_ +#define CRC32_TBL_H_ -/* crc32.h -- tables for rapid CRC calculation - * Generated automatically by crc32.c +/* crc32_tbl.h -- tables for rapid CRC calculation + * Generated automatically by makecrct.c */ static const uint32_t crc_table[8][256] = @@ -441,295 +441,4 @@ static const uint32_t crc_table[8][256] = } }; -static const uint32_t crc_comb[32][32] = -{ - { - 0x77073096UL, 0xee0e612cUL, 0x076dc419UL, 0x0edb8832UL, 0x1db71064UL, - 0x3b6e20c8UL, 0x76dc4190UL, 0xedb88320UL, 0x00000001UL, 0x00000002UL, - 0x00000004UL, 0x00000008UL, 0x00000010UL, 0x00000020UL, 0x00000040UL, - 0x00000080UL, 0x00000100UL, 0x00000200UL, 0x00000400UL, 0x00000800UL, - 0x00001000UL, 0x00002000UL, 0x00004000UL, 0x00008000UL, 0x00010000UL, - 0x00020000UL, 0x00040000UL, 0x00080000UL, 0x00100000UL, 0x00200000UL, - 0x00400000UL, 0x00800000UL - }, - { - 0x191b3141UL, 0x32366282UL, 0x646cc504UL, 0xc8d98a08UL, 0x4ac21251UL, - 0x958424a2UL, 0xf0794f05UL, 0x3b83984bUL, 0x77073096UL, 0xee0e612cUL, - 0x076dc419UL, 0x0edb8832UL, 0x1db71064UL, 0x3b6e20c8UL, 0x76dc4190UL, - 0xedb88320UL, 0x00000001UL, 0x00000002UL, 0x00000004UL, 0x00000008UL, - 0x00000010UL, 0x00000020UL, 0x00000040UL, 0x00000080UL, 0x00000100UL, - 0x00000200UL, 0x00000400UL, 0x00000800UL, 0x00001000UL, 0x00002000UL, - 0x00004000UL, 0x00008000UL - }, - { - 0xb8bc6765UL, 0xaa09c88bUL, 0x8f629757UL, 0xc5b428efUL, 0x5019579fUL, - 0xa032af3eUL, 0x9b14583dUL, 0xed59b63bUL, 0x01c26a37UL, 0x0384d46eUL, - 0x0709a8dcUL, 0x0e1351b8UL, 0x1c26a370UL, 0x384d46e0UL, 0x709a8dc0UL, - 0xe1351b80UL, 0x191b3141UL, 0x32366282UL, 0x646cc504UL, 0xc8d98a08UL, - 0x4ac21251UL, 0x958424a2UL, 0xf0794f05UL, 0x3b83984bUL, 0x77073096UL, - 0xee0e612cUL, 0x076dc419UL, 0x0edb8832UL, 0x1db71064UL, 0x3b6e20c8UL, - 0x76dc4190UL, 0xedb88320UL - }, - { - 0xccaa009eUL, 0x4225077dUL, 0x844a0efaUL, 0xd3e51bb5UL, 0x7cbb312bUL, - 0xf9766256UL, 0x299dc2edUL, 0x533b85daUL, 0xa6770bb4UL, 0x979f1129UL, - 0xf44f2413UL, 0x33ef4e67UL, 0x67de9cceUL, 0xcfbd399cUL, 0x440b7579UL, - 0x8816eaf2UL, 0xcb5cd3a5UL, 0x4dc8a10bUL, 0x9b914216UL, 0xec53826dUL, - 0x03d6029bUL, 0x07ac0536UL, 0x0f580a6cUL, 0x1eb014d8UL, 0x3d6029b0UL, - 0x7ac05360UL, 0xf580a6c0UL, 0x30704bc1UL, 0x60e09782UL, 0xc1c12f04UL, - 0x58f35849UL, 0xb1e6b092UL - }, - { - 0xae689191UL, 0x87a02563UL, 0xd4314c87UL, 0x73139f4fUL, 0xe6273e9eUL, - 0x173f7b7dUL, 0x2e7ef6faUL, 0x5cfdedf4UL, 0xb9fbdbe8UL, 0xa886b191UL, - 0x8a7c6563UL, 0xcf89cc87UL, 0x44629f4fUL, 0x88c53e9eUL, 0xcafb7b7dUL, - 0x4e87f0bbUL, 0x9d0fe176UL, 0xe16ec4adUL, 0x19ac8f1bUL, 0x33591e36UL, - 0x66b23c6cUL, 0xcd6478d8UL, 0x41b9f7f1UL, 0x8373efe2UL, 0xdd96d985UL, - 0x605cb54bUL, 0xc0b96a96UL, 0x5a03d36dUL, 0xb407a6daUL, 0xb37e4bf5UL, - 0xbd8d91abUL, 0xa06a2517UL - }, - { - 0xf1da05aaUL, 0x38c50d15UL, 0x718a1a2aUL, 0xe3143454UL, 0x1d596ee9UL, - 0x3ab2ddd2UL, 0x7565bba4UL, 0xeacb7748UL, 0x0ee7e8d1UL, 0x1dcfd1a2UL, - 0x3b9fa344UL, 0x773f4688UL, 0xee7e8d10UL, 0x078c1c61UL, 0x0f1838c2UL, - 0x1e307184UL, 0x3c60e308UL, 0x78c1c610UL, 0xf1838c20UL, 0x38761e01UL, - 0x70ec3c02UL, 0xe1d87804UL, 0x18c1f649UL, 0x3183ec92UL, 0x6307d924UL, - 0xc60fb248UL, 0x576e62d1UL, 0xaedcc5a2UL, 0x86c88d05UL, 0xd6e01c4bUL, - 0x76b13ed7UL, 0xed627daeUL - }, - { - 0x8f352d95UL, 0xc51b5d6bUL, 0x5147bc97UL, 0xa28f792eUL, 0x9e6ff41dUL, - 0xe7aeee7bUL, 0x142cdab7UL, 0x2859b56eUL, 0x50b36adcUL, 0xa166d5b8UL, - 0x99bcad31UL, 0xe8085c23UL, 0x0b61be07UL, 0x16c37c0eUL, 0x2d86f81cUL, - 0x5b0df038UL, 0xb61be070UL, 0xb746c6a1UL, 0xb5fc8b03UL, 0xb0881047UL, - 0xba6126cfUL, 0xafb34bdfUL, 0x841791ffUL, 0xd35e25bfUL, 0x7dcd4d3fUL, - 0xfb9a9a7eUL, 0x2c4432bdUL, 0x5888657aUL, 0xb110caf4UL, 0xb95093a9UL, - 0xa9d02113UL, 0x88d14467UL - }, - { - 0x33fff533UL, 0x67ffea66UL, 0xcfffd4ccUL, 0x448eafd9UL, 0x891d5fb2UL, - 0xc94bb925UL, 0x49e6740bUL, 0x93cce816UL, 0xfce8d66dUL, 0x22a0aa9bUL, - 0x45415536UL, 0x8a82aa6cUL, 0xce745299UL, 0x4799a373UL, 0x8f3346e6UL, - 0xc5178b8dUL, 0x515e115bUL, 0xa2bc22b6UL, 0x9e09432dUL, 0xe763801bUL, - 0x15b60677UL, 0x2b6c0ceeUL, 0x56d819dcUL, 0xadb033b8UL, 0x80116131UL, - 0xdb53c423UL, 0x6dd68e07UL, 0xdbad1c0eUL, 0x6c2b3e5dUL, 0xd8567cbaUL, - 0x6bddff35UL, 0xd7bbfe6aUL - }, - { - 0xce3371cbUL, 0x4717e5d7UL, 0x8e2fcbaeUL, 0xc72e911dUL, 0x552c247bUL, - 0xaa5848f6UL, 0x8fc197adUL, 0xc4f2291bUL, 0x52955477UL, 0xa52aa8eeUL, - 0x9124579dUL, 0xf939a97bUL, 0x290254b7UL, 0x5204a96eUL, 0xa40952dcUL, - 0x9363a3f9UL, 0xfdb641b3UL, 0x201d8527UL, 0x403b0a4eUL, 0x8076149cUL, - 0xdb9d2f79UL, 0x6c4b58b3UL, 0xd896b166UL, 0x6a5c648dUL, 0xd4b8c91aUL, - 0x72009475UL, 0xe40128eaUL, 0x13735795UL, 0x26e6af2aUL, 0x4dcd5e54UL, - 0x9b9abca8UL, 0xec447f11UL - }, - { - 0x1072db28UL, 0x20e5b650UL, 0x41cb6ca0UL, 0x8396d940UL, 0xdc5cb4c1UL, - 0x63c86fc3UL, 0xc790df86UL, 0x5450b94dUL, 0xa8a1729aUL, 0x8a33e375UL, - 0xcf16c0abUL, 0x455c8717UL, 0x8ab90e2eUL, 0xce031a1dUL, 0x4777327bUL, - 0x8eee64f6UL, 0xc6adcfadUL, 0x562a991bUL, 0xac553236UL, 0x83db622dUL, - 0xdcc7c21bUL, 0x62fe8277UL, 0xc5fd04eeUL, 0x508b0f9dUL, 0xa1161f3aUL, - 0x995d3835UL, 0xe9cb762bUL, 0x08e7ea17UL, 0x11cfd42eUL, 0x239fa85cUL, - 0x473f50b8UL, 0x8e7ea170UL - }, - { - 0xf891f16fUL, 0x2a52e49fUL, 0x54a5c93eUL, 0xa94b927cUL, 0x89e622b9UL, - 0xc8bd4333UL, 0x4a0b8027UL, 0x9417004eUL, 0xf35f06ddUL, 0x3dcf0bfbUL, - 0x7b9e17f6UL, 0xf73c2fecUL, 0x35095999UL, 0x6a12b332UL, 0xd4256664UL, - 0x733bca89UL, 0xe6779512UL, 0x179e2c65UL, 0x2f3c58caUL, 0x5e78b194UL, - 0xbcf16328UL, 0xa293c011UL, 0x9e568663UL, 0xe7dc0a87UL, 0x14c9134fUL, - 0x2992269eUL, 0x53244d3cUL, 0xa6489a78UL, 0x97e032b1UL, 0xf4b16323UL, - 0x3213c007UL, 0x6427800eUL - }, - { - 0x88b6ba63UL, 0xca1c7287UL, 0x4f49e34fUL, 0x9e93c69eUL, 0xe6568b7dUL, - 0x17dc10bbUL, 0x2fb82176UL, 0x5f7042ecUL, 0xbee085d8UL, 0xa6b00df1UL, - 0x96111da3UL, 0xf7533d07UL, 0x35d77c4fUL, 0x6baef89eUL, 0xd75df13cUL, - 0x75cae439UL, 0xeb95c872UL, 0x0c5a96a5UL, 0x18b52d4aUL, 0x316a5a94UL, - 0x62d4b528UL, 0xc5a96a50UL, 0x5023d2e1UL, 0xa047a5c2UL, 0x9bfe4dc5UL, - 0xec8d9dcbUL, 0x026a3dd7UL, 0x04d47baeUL, 0x09a8f75cUL, 0x1351eeb8UL, - 0x26a3dd70UL, 0x4d47bae0UL - }, - { - 0x5ad8a92cUL, 0xb5b15258UL, 0xb013a2f1UL, 0xbb5643a3UL, 0xaddd8107UL, - 0x80ca044fUL, 0xdae50edfUL, 0x6ebb1bffUL, 0xdd7637feUL, 0x619d69bdUL, - 0xc33ad37aUL, 0x5d04a0b5UL, 0xba09416aUL, 0xaf638495UL, 0x85b60f6bUL, - 0xd01d1897UL, 0x7b4b376fUL, 0xf6966edeUL, 0x365ddbfdUL, 0x6cbbb7faUL, - 0xd9776ff4UL, 0x699fd9a9UL, 0xd33fb352UL, 0x7d0e60e5UL, 0xfa1cc1caUL, - 0x2f4885d5UL, 0x5e910baaUL, 0xbd221754UL, 0xa13528e9UL, 0x991b5793UL, - 0xe947a967UL, 0x09fe548fUL - }, - { - 0xb566f6e2UL, 0xb1bceb85UL, 0xb808d14bUL, 0xab60a4d7UL, 0x8db04fefUL, - 0xc011999fUL, 0x5b52357fUL, 0xb6a46afeUL, 0xb639d3bdUL, 0xb702a13bUL, - 0xb5744437UL, 0xb1998e2fUL, 0xb8421a1fUL, 0xabf5327fUL, 0x8c9b62bfUL, - 0xc247c33fUL, 0x5ffe803fUL, 0xbffd007eUL, 0xa48b06bdUL, 0x92670b3bUL, - 0xffbf1037UL, 0x240f262fUL, 0x481e4c5eUL, 0x903c98bcUL, 0xfb083739UL, - 0x2d616833UL, 0x5ac2d066UL, 0xb585a0ccUL, 0xb07a47d9UL, 0xbb8589f3UL, - 0xac7a15a7UL, 0x83852d0fUL - }, - { - 0x9d9129bfUL, 0xe053553fUL, 0x1bd7ac3fUL, 0x37af587eUL, 0x6f5eb0fcUL, - 0xdebd61f8UL, 0x660bc5b1UL, 0xcc178b62UL, 0x435e1085UL, 0x86bc210aUL, - 0xd6094455UL, 0x77638eebUL, 0xeec71dd6UL, 0x06ff3dedUL, 0x0dfe7bdaUL, - 0x1bfcf7b4UL, 0x37f9ef68UL, 0x6ff3ded0UL, 0xdfe7bda0UL, 0x64be7d01UL, - 0xc97cfa02UL, 0x4988f245UL, 0x9311e48aUL, 0xfd52cf55UL, 0x21d498ebUL, - 0x43a931d6UL, 0x875263acUL, 0xd5d5c119UL, 0x70da8473UL, 0xe1b508e6UL, - 0x181b178dUL, 0x30362f1aUL - }, - { - 0x2ee43a2cUL, 0x5dc87458UL, 0xbb90e8b0UL, 0xac50d721UL, 0x83d0a803UL, - 0xdcd05647UL, 0x62d1aacfUL, 0xc5a3559eUL, 0x5037ad7dUL, 0xa06f5afaUL, - 0x9bafb3b5UL, 0xec2e612bUL, 0x032dc417UL, 0x065b882eUL, 0x0cb7105cUL, - 0x196e20b8UL, 0x32dc4170UL, 0x65b882e0UL, 0xcb7105c0UL, 0x4d930dc1UL, - 0x9b261b82UL, 0xed3d3145UL, 0x010b64cbUL, 0x0216c996UL, 0x042d932cUL, - 0x085b2658UL, 0x10b64cb0UL, 0x216c9960UL, 0x42d932c0UL, 0x85b26580UL, - 0xd015cd41UL, 0x7b5a9cc3UL - }, - { - 0x1b4511eeUL, 0x368a23dcUL, 0x6d1447b8UL, 0xda288f70UL, 0x6f2018a1UL, - 0xde403142UL, 0x67f164c5UL, 0xcfe2c98aUL, 0x44b49555UL, 0x89692aaaUL, - 0xc9a35315UL, 0x4837a06bUL, 0x906f40d6UL, 0xfbaf87edUL, 0x2c2e099bUL, - 0x585c1336UL, 0xb0b8266cUL, 0xba014a99UL, 0xaf739373UL, 0x859620a7UL, - 0xd05d470fUL, 0x7bcb885fUL, 0xf79710beUL, 0x345f273dUL, 0x68be4e7aUL, - 0xd17c9cf4UL, 0x79883fa9UL, 0xf3107f52UL, 0x3d51f8e5UL, 0x7aa3f1caUL, - 0xf547e394UL, 0x31fec169UL - }, - { - 0xbce15202UL, 0xa2b3a245UL, 0x9e1642cbUL, 0xe75d83d7UL, 0x15ca01efUL, - 0x2b9403deUL, 0x572807bcUL, 0xae500f78UL, 0x87d118b1UL, 0xd4d33723UL, - 0x72d76807UL, 0xe5aed00eUL, 0x102ca65dUL, 0x20594cbaUL, 0x40b29974UL, - 0x816532e8UL, 0xd9bb6391UL, 0x6807c163UL, 0xd00f82c6UL, 0x7b6e03cdUL, - 0xf6dc079aUL, 0x36c90975UL, 0x6d9212eaUL, 0xdb2425d4UL, 0x6d394de9UL, - 0xda729bd2UL, 0x6f9431e5UL, 0xdf2863caUL, 0x6521c1d5UL, 0xca4383aaUL, - 0x4ff60115UL, 0x9fec022aUL - }, - { - 0xff08e5efUL, 0x2560cd9fUL, 0x4ac19b3eUL, 0x9583367cUL, 0xf0776ab9UL, - 0x3b9fd333UL, 0x773fa666UL, 0xee7f4cccUL, 0x078f9fd9UL, 0x0f1f3fb2UL, - 0x1e3e7f64UL, 0x3c7cfec8UL, 0x78f9fd90UL, 0xf1f3fb20UL, 0x3896f001UL, - 0x712de002UL, 0xe25bc004UL, 0x1fc68649UL, 0x3f8d0c92UL, 0x7f1a1924UL, - 0xfe343248UL, 0x271962d1UL, 0x4e32c5a2UL, 0x9c658b44UL, 0xe3ba10c9UL, - 0x1c0527d3UL, 0x380a4fa6UL, 0x70149f4cUL, 0xe0293e98UL, 0x1b237b71UL, - 0x3646f6e2UL, 0x6c8dedc4UL - }, - { - 0x6f76172eUL, 0xdeec2e5cUL, 0x66a95af9UL, 0xcd52b5f2UL, 0x41d46da5UL, - 0x83a8db4aUL, 0xdc20b0d5UL, 0x633067ebUL, 0xc660cfd6UL, 0x57b099edUL, - 0xaf6133daUL, 0x85b361f5UL, 0xd017c5abUL, 0x7b5e8d17UL, 0xf6bd1a2eUL, - 0x360b321dUL, 0x6c16643aUL, 0xd82cc874UL, 0x6b2896a9UL, 0xd6512d52UL, - 0x77d35ce5UL, 0xefa6b9caUL, 0x043c75d5UL, 0x0878ebaaUL, 0x10f1d754UL, - 0x21e3aea8UL, 0x43c75d50UL, 0x878ebaa0UL, 0xd46c7301UL, 0x73a9e043UL, - 0xe753c086UL, 0x15d6874dUL - }, - { - 0x56f5cab9UL, 0xadeb9572UL, 0x80a62ca5UL, 0xda3d5f0bUL, 0x6f0bb857UL, - 0xde1770aeUL, 0x675fe71dUL, 0xcebfce3aUL, 0x460e9a35UL, 0x8c1d346aUL, - 0xc34b6e95UL, 0x5de7db6bUL, 0xbbcfb6d6UL, 0xacee6bedUL, 0x82add19bUL, - 0xde2aa577UL, 0x67244cafUL, 0xce48995eUL, 0x47e034fdUL, 0x8fc069faUL, - 0xc4f1d5b5UL, 0x5292ad2bUL, 0xa5255a56UL, 0x913bb2edUL, 0xf906639bUL, - 0x297dc177UL, 0x52fb82eeUL, 0xa5f705dcUL, 0x909f0df9UL, 0xfa4f1db3UL, - 0x2fef3d27UL, 0x5fde7a4eUL - }, - { - 0x385993acUL, 0x70b32758UL, 0xe1664eb0UL, 0x19bd9b21UL, 0x337b3642UL, - 0x66f66c84UL, 0xcdecd908UL, 0x40a8b451UL, 0x815168a2UL, 0xd9d3d705UL, - 0x68d6a84bUL, 0xd1ad5096UL, 0x782ba76dUL, 0xf0574edaUL, 0x3bdf9bf5UL, - 0x77bf37eaUL, 0xef7e6fd4UL, 0x058dd9e9UL, 0x0b1bb3d2UL, 0x163767a4UL, - 0x2c6ecf48UL, 0x58dd9e90UL, 0xb1bb3d20UL, 0xb8077c01UL, 0xab7ffe43UL, - 0x8d8efac7UL, 0xc06cf3cfUL, 0x5ba8e1dfUL, 0xb751c3beUL, 0xb5d2813dUL, - 0xb0d4043bUL, 0xbad90e37UL - }, - { - 0xb4247b20UL, 0xb339f001UL, 0xbd02e643UL, 0xa174cac7UL, 0x999893cfUL, - 0xe84021dfUL, 0x0bf145ffUL, 0x17e28bfeUL, 0x2fc517fcUL, 0x5f8a2ff8UL, - 0xbf145ff0UL, 0xa559b9a1UL, 0x91c27503UL, 0xf8f5ec47UL, 0x2a9adecfUL, - 0x5535bd9eUL, 0xaa6b7b3cUL, 0x8fa7f039UL, 0xc43ee633UL, 0x530cca27UL, - 0xa619944eUL, 0x97422eddUL, 0xf5f55bfbUL, 0x309bb1b7UL, 0x6137636eUL, - 0xc26ec6dcUL, 0x5fac8bf9UL, 0xbf5917f2UL, 0xa5c329a5UL, 0x90f7550bUL, - 0xfa9fac57UL, 0x2e4e5eefUL - }, - { - 0x695186a7UL, 0xd2a30d4eUL, 0x7e371cddUL, 0xfc6e39baUL, 0x23ad7535UL, - 0x475aea6aUL, 0x8eb5d4d4UL, 0xc61aafe9UL, 0x57445993UL, 0xae88b326UL, - 0x8660600dUL, 0xd7b1c65bUL, 0x74128af7UL, 0xe82515eeUL, 0x0b3b2d9dUL, - 0x16765b3aUL, 0x2cecb674UL, 0x59d96ce8UL, 0xb3b2d9d0UL, 0xbc14b5e1UL, - 0xa3586d83UL, 0x9dc1dd47UL, 0xe0f2bccfUL, 0x1a947fdfUL, 0x3528ffbeUL, - 0x6a51ff7cUL, 0xd4a3fef8UL, 0x7236fbb1UL, 0xe46df762UL, 0x13aae885UL, - 0x2755d10aUL, 0x4eaba214UL - }, - { - 0x66bc001eUL, 0xcd78003cUL, 0x41810639UL, 0x83020c72UL, 0xdd751ea5UL, - 0x619b3b0bUL, 0xc3367616UL, 0x5d1dea6dUL, 0xba3bd4daUL, 0xaf06aff5UL, - 0x857c59abUL, 0xd189b517UL, 0x78626c6fUL, 0xf0c4d8deUL, 0x3af8b7fdUL, - 0x75f16ffaUL, 0xebe2dff4UL, 0x0cb4b9a9UL, 0x19697352UL, 0x32d2e6a4UL, - 0x65a5cd48UL, 0xcb4b9a90UL, 0x4de63361UL, 0x9bcc66c2UL, 0xece9cbc5UL, - 0x02a291cbUL, 0x05452396UL, 0x0a8a472cUL, 0x15148e58UL, 0x2a291cb0UL, - 0x54523960UL, 0xa8a472c0UL - }, - { - 0xb58b27b3UL, 0xb0674927UL, 0xbbbf940fUL, 0xac0e2e5fUL, 0x836d5affUL, - 0xddabb3bfUL, 0x6026613fUL, 0xc04cc27eUL, 0x5be882bdUL, 0xb7d1057aUL, - 0xb4d30cb5UL, 0xb2d71f2bUL, 0xbedf3817UL, 0xa6cf766fUL, 0x96efea9fUL, - 0xf6aed37fUL, 0x362ca0bfUL, 0x6c59417eUL, 0xd8b282fcUL, 0x6a1403b9UL, - 0xd4280772UL, 0x732108a5UL, 0xe642114aUL, 0x17f524d5UL, 0x2fea49aaUL, - 0x5fd49354UL, 0xbfa926a8UL, 0xa4234b11UL, 0x93379063UL, 0xfd1e2687UL, - 0x214d4b4fUL, 0x429a969eUL - }, - { - 0xfe273162UL, 0x273f6485UL, 0x4e7ec90aUL, 0x9cfd9214UL, 0xe28a2269UL, - 0x1e654293UL, 0x3cca8526UL, 0x79950a4cUL, 0xf32a1498UL, 0x3d252f71UL, - 0x7a4a5ee2UL, 0xf494bdc4UL, 0x32587dc9UL, 0x64b0fb92UL, 0xc961f724UL, - 0x49b2e809UL, 0x9365d012UL, 0xfdbaa665UL, 0x20044a8bUL, 0x40089516UL, - 0x80112a2cUL, 0xdb535219UL, 0x6dd7a273UL, 0xdbaf44e6UL, 0x6c2f8f8dUL, - 0xd85f1f1aUL, 0x6bcf3875UL, 0xd79e70eaUL, 0x744de795UL, 0xe89bcf2aUL, - 0x0a469815UL, 0x148d302aUL - }, - { - 0xd3c98813UL, 0x7ce21667UL, 0xf9c42cceUL, 0x28f95fddUL, 0x51f2bfbaUL, - 0xa3e57f74UL, 0x9cbbf8a9UL, 0xe206f713UL, 0x1f7ce867UL, 0x3ef9d0ceUL, - 0x7df3a19cUL, 0xfbe74338UL, 0x2cbf8031UL, 0x597f0062UL, 0xb2fe00c4UL, - 0xbe8d07c9UL, 0xa66b09d3UL, 0x97a715e7UL, 0xf43f2d8fUL, 0x330f5d5fUL, - 0x661ebabeUL, 0xcc3d757cUL, 0x430becb9UL, 0x8617d972UL, 0xd75eb4a5UL, - 0x75cc6f0bUL, 0xeb98de16UL, 0x0c40ba6dUL, 0x188174daUL, 0x3102e9b4UL, - 0x6205d368UL, 0xc40ba6d0UL - }, - { - 0xf7d6deb4UL, 0x34dcbb29UL, 0x69b97652UL, 0xd372eca4UL, 0x7d94df09UL, - 0xfb29be12UL, 0x2d227a65UL, 0x5a44f4caUL, 0xb489e994UL, 0xb262d569UL, - 0xbfb4ac93UL, 0xa4185f67UL, 0x9341b88fUL, 0xfdf2775fUL, 0x2095e8ffUL, - 0x412bd1feUL, 0x8257a3fcUL, 0xdfde41b9UL, 0x64cd8533UL, 0xc99b0a66UL, - 0x4847128dUL, 0x908e251aUL, 0xfa6d4c75UL, 0x2fab9eabUL, 0x5f573d56UL, - 0xbeae7aacUL, 0xa62df319UL, 0x972ae073UL, 0xf524c6a7UL, 0x31388b0fUL, - 0x6271161eUL, 0xc4e22c3cUL - }, - { - 0xedb88320UL, 0x00000001UL, 0x00000002UL, 0x00000004UL, 0x00000008UL, - 0x00000010UL, 0x00000020UL, 0x00000040UL, 0x00000080UL, 0x00000100UL, - 0x00000200UL, 0x00000400UL, 0x00000800UL, 0x00001000UL, 0x00002000UL, - 0x00004000UL, 0x00008000UL, 0x00010000UL, 0x00020000UL, 0x00040000UL, - 0x00080000UL, 0x00100000UL, 0x00200000UL, 0x00400000UL, 0x00800000UL, - 0x01000000UL, 0x02000000UL, 0x04000000UL, 0x08000000UL, 0x10000000UL, - 0x20000000UL, 0x40000000UL - }, - { - 0x76dc4190UL, 0xedb88320UL, 0x00000001UL, 0x00000002UL, 0x00000004UL, - 0x00000008UL, 0x00000010UL, 0x00000020UL, 0x00000040UL, 0x00000080UL, - 0x00000100UL, 0x00000200UL, 0x00000400UL, 0x00000800UL, 0x00001000UL, - 0x00002000UL, 0x00004000UL, 0x00008000UL, 0x00010000UL, 0x00020000UL, - 0x00040000UL, 0x00080000UL, 0x00100000UL, 0x00200000UL, 0x00400000UL, - 0x00800000UL, 0x01000000UL, 0x02000000UL, 0x04000000UL, 0x08000000UL, - 0x10000000UL, 0x20000000UL - }, - { - 0x1db71064UL, 0x3b6e20c8UL, 0x76dc4190UL, 0xedb88320UL, 0x00000001UL, - 0x00000002UL, 0x00000004UL, 0x00000008UL, 0x00000010UL, 0x00000020UL, - 0x00000040UL, 0x00000080UL, 0x00000100UL, 0x00000200UL, 0x00000400UL, - 0x00000800UL, 0x00001000UL, 0x00002000UL, 0x00004000UL, 0x00008000UL, - 0x00010000UL, 0x00020000UL, 0x00040000UL, 0x00080000UL, 0x00100000UL, - 0x00200000UL, 0x00400000UL, 0x00800000UL, 0x01000000UL, 0x02000000UL, - 0x04000000UL, 0x08000000UL - } -}; -#endif /* CRC32_H_ */ +#endif /* CRC32_TBL_H_ */ diff --git a/libs/zlibng/deflate.c b/libs/zlibng/deflate.c index dd4edff0e..1707f75c2 100644 --- a/libs/zlibng/deflate.c +++ b/libs/zlibng/deflate.c @@ -47,15 +47,12 @@ * */ -/* @(#) $Id$ */ - #include "zbuild.h" #include "deflate.h" #include "deflate_p.h" -#include "match_p.h" #include "functable.h" -const char deflate_copyright[] = " deflate 1.2.11.f Copyright 1995-2016 Jean-loup Gailly and Mark Adler "; +const char PREFIX(deflate_copyright)[] = " deflate 1.2.11.f Copyright 1995-2016 Jean-loup Gailly and Mark Adler "; /* If you use the zlib library in a product, an acknowledgment is welcome in the documentation of your product. If for some reason you cannot @@ -83,7 +80,9 @@ const char deflate_copyright[] = " deflate 1.2.11.f Copyright 1995-2016 Jean-lou /* Invoked at the end of deflateResetKeep(). Useful for initializing arch-specific extension blocks. */ # define DEFLATE_RESET_KEEP_HOOK(strm) do {} while (0) /* Invoked at the beginning of deflateParams(). Useful for updating arch-specific compression parameters. */ -# define DEFLATE_PARAMS_HOOK(strm, level, strategy) do {} while (0) +# define DEFLATE_PARAMS_HOOK(strm, level, strategy, hook_flush) do {} while (0) +/* Returns whether the last deflate(flush) operation did everything it's supposed to do. */ +# define DEFLATE_DONE(strm, flush) 1 /* Adjusts the upper bound on compressed data length based on compression parameters and uncompressed data length. * Useful when arch-specific deflation code behaves differently than regular zlib-ng algorithms. */ # define DEFLATE_BOUND_ADJUST_COMPLEN(strm, complen, sourceLen) do {} while (0) @@ -94,6 +93,8 @@ const char deflate_copyright[] = " deflate 1.2.11.f Copyright 1995-2016 Jean-lou # define DEFLATE_HOOK(strm, flush, bstate) 0 /* Returns whether zlib-ng should compute a checksum. Set to 0 if arch-specific deflation code already does that. */ # define DEFLATE_NEED_CHECKSUM(strm) 1 +/* Returns whether reproducibility parameter can be set to a given value. */ +# define DEFLATE_CAN_SET_REPRODUCIBLE(strm, reproducible) 1 #endif /* =========================================================================== @@ -103,19 +104,17 @@ typedef block_state (*compress_func) (deflate_state *s, int flush); /* Compression function. Returns the block state after the call. */ static int deflateStateCheck (PREFIX3(stream) *strm); -static void slide_hash (deflate_state *s); static block_state deflate_stored (deflate_state *s, int flush); -ZLIB_INTERNAL block_state deflate_fast (deflate_state *s, int flush); -ZLIB_INTERNAL block_state deflate_quick (deflate_state *s, int flush); +Z_INTERNAL block_state deflate_fast (deflate_state *s, int flush); +Z_INTERNAL block_state deflate_quick (deflate_state *s, int flush); #ifndef NO_MEDIUM_STRATEGY -ZLIB_INTERNAL block_state deflate_medium (deflate_state *s, int flush); +Z_INTERNAL block_state deflate_medium (deflate_state *s, int flush); #endif -ZLIB_INTERNAL block_state deflate_slow (deflate_state *s, int flush); +Z_INTERNAL block_state deflate_slow (deflate_state *s, int flush); static block_state deflate_rle (deflate_state *s, int flush); static block_state deflate_huff (deflate_state *s, int flush); static void lm_init (deflate_state *s); -static void putShortMSB (deflate_state *s, uint16_t b); -ZLIB_INTERNAL unsigned read_buf (PREFIX3(stream) *strm, unsigned char *buf, unsigned size); +Z_INTERNAL unsigned read_buf (PREFIX3(stream) *strm, unsigned char *buf, unsigned size); extern void crc_reset(deflate_state *const s); #ifdef X86_PCLMULQDQ_CRC @@ -127,9 +126,6 @@ extern void copy_with_crc(PREFIX3(stream) *strm, unsigned char *dst, unsigned lo * Local data */ -#define NIL 0 -/* Tail of hash chains */ - /* Values for max_lazy_match, good_match and max_chain_length, depending on * the desired pack level (0..9). The values given below have been tuned to * exclude worst case performance for pathological files. Better values may be @@ -147,7 +143,7 @@ static const config configuration_table[10] = { /* good lazy nice chain */ /* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ -#ifdef X86_QUICK_STRATEGY +#ifndef NO_QUICK_STRATEGY /* 1 */ {4, 4, 8, 4, deflate_quick}, /* 2 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */ #else @@ -181,12 +177,10 @@ static const config configuration_table[10] = { /* =========================================================================== - * Initialize the hash table (avoiding 64K overflow for 16 bit systems). - * prev[] will be initialized on the fly. + * Initialize the hash table. prev[] will be initialized on the fly. */ #define CLEAR_HASH(s) do { \ - s->head[s->hash_size - 1] = NIL; \ - memset((unsigned char *)s->head, 0, (unsigned)(s->hash_size - 1) * sizeof(*s->head)); \ + memset((unsigned char *)s->head, 0, HASH_SIZE * sizeof(*s->head)); \ } while (0) /* =========================================================================== @@ -194,80 +188,80 @@ static const config configuration_table[10] = { * bit values at the expense of memory usage). We slide even when level == 0 to * keep the hash table consistent if we switch back to level > 0 later. */ -static void slide_hash(deflate_state *s) { - unsigned n; +Z_INTERNAL void slide_hash_c(deflate_state *s) { Pos *p; + unsigned n; unsigned int wsize = s->w_size; - n = s->hash_size; + n = HASH_SIZE; p = &s->head[n]; #ifdef NOT_TWEAK_COMPILER - do { - unsigned m; - m = *--p; - *p = (Pos)(m >= wsize ? m-wsize : NIL); - } while (--n); + do { + unsigned m; + m = *--p; + *p = (Pos)(m >= wsize ? m-wsize : 0); + } while (--n); #else - /* As of I make this change, gcc (4.8.*) isn't able to vectorize - * this hot loop using saturated-subtraction on x86-64 architecture. - * To avoid this defect, we can change the loop such that - * o. the pointer advance forward, and - * o. demote the variable 'm' to be local to the loop, and - * choose type "Pos" (instead of 'unsigned int') for the - * variable to avoid unncessary zero-extension. - */ - { - unsigned int i; - Pos *q = p - n; - for (i = 0; i < n; i++) { - Pos m = *q; - Pos t = wsize; - *q++ = (Pos)(m >= t ? m-t: NIL); - } - } - + /* As of I make this change, gcc (4.8.*) isn't able to vectorize + * this hot loop using saturated-subtraction on x86-64 architecture. + * To avoid this defect, we can change the loop such that + * o. the pointer advance forward, and + * o. demote the variable 'm' to be local to the loop, and + * choose type "Pos" (instead of 'unsigned int') for the + * variable to avoid unncessary zero-extension. + */ + { + unsigned int i; + Pos *q = p - n; + for (i = 0; i < n; i++) { + Pos m = *q; + Pos t = (Pos)wsize; + *q++ = (Pos)(m >= t ? m-t: 0); + } + } #endif /* NOT_TWEAK_COMPILER */ - n = wsize; - p = &s->prev[n]; + + n = wsize; + p = &s->prev[n]; #ifdef NOT_TWEAK_COMPILER - do { - unsigned m; - m = *--p; - *p = (Pos)(m >= wsize ? m-wsize : NIL); - /* If n is not on any hash chain, prev[n] is garbage but - * its value will never be used. - */ - } while (--n); + do { + unsigned m; + m = *--p; + *p = (Pos)(m >= wsize ? m-wsize : 0); + /* If n is not on any hash chain, prev[n] is garbage but + * its value will never be used. + */ + } while (--n); #else - { - unsigned int i; - Pos *q = p - n; - for (i = 0; i < n; i++) { - Pos m = *q; - Pos t = wsize; - *q++ = (Pos)(m >= t ? m-t: NIL); - } - } + { + unsigned int i; + Pos *q = p - n; + for (i = 0; i < n; i++) { + Pos m = *q; + Pos t = (Pos)wsize; + *q++ = (Pos)(m >= t ? m-t: 0); + } + } #endif /* NOT_TWEAK_COMPILER */ } /* ========================================================================= */ -int ZEXPORT PREFIX(deflateInit_)(PREFIX3(stream) *strm, int level, const char *version, int stream_size) { +int32_t Z_EXPORT PREFIX(deflateInit_)(PREFIX3(stream) *strm, int32_t level, const char *version, int32_t stream_size) { return PREFIX(deflateInit2_)(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, version, stream_size); /* Todo: ignore strm->next_in if we use it as window */ } /* ========================================================================= */ -int ZEXPORT PREFIX(deflateInit2_)(PREFIX3(stream) *strm, int level, int method, int windowBits, - int memLevel, int strategy, const char *version, int stream_size) { - unsigned window_padding = 0; +int32_t Z_EXPORT PREFIX(deflateInit2_)(PREFIX3(stream) *strm, int32_t level, int32_t method, int32_t windowBits, + int32_t memLevel, int32_t strategy, const char *version, int32_t stream_size) { + uint32_t window_padding = 0; deflate_state *s; int wrap = 1; static const char my_version[] = PREFIX2(VERSION); -#ifdef X86_CPUID +#if defined(X86_FEATURES) x86_check_features(); -#elif defined(__arm__) || defined(__aarch64__) || defined(_M_ARM) +#elif defined(ARM_FEATURES) arm_check_features(); #endif @@ -279,11 +273,11 @@ int ZEXPORT PREFIX(deflateInit2_)(PREFIX3(stream) *strm, int level, int method, strm->msg = NULL; if (strm->zalloc == NULL) { - strm->zalloc = zcalloc; + strm->zalloc = zng_calloc; strm->opaque = NULL; } if (strm->zfree == NULL) - strm->zfree = zcfree; + strm->zfree = zng_cfree; if (level == Z_DEFAULT_COMPRESSION) level = 6; @@ -305,7 +299,7 @@ int ZEXPORT PREFIX(deflateInit2_)(PREFIX3(stream) *strm, int level, int method, if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */ -#ifdef X86_QUICK_STRATEGY +#if !defined(NO_QUICK_STRATEGY) && !defined(S390_DFLTCC_DEFLATE) if (level == 1) windowBits = 13; #endif @@ -323,19 +317,6 @@ int ZEXPORT PREFIX(deflateInit2_)(PREFIX3(stream) *strm, int level, int method, s->w_size = 1 << s->w_bits; s->w_mask = s->w_size - 1; -#ifdef X86_SSE4_2_CRC_HASH - if (x86_cpu_has_sse42) - s->hash_bits = (unsigned int)15; - else -#endif - s->hash_bits = (unsigned int)memLevel + 7; - - s->hash_size = 1 << s->hash_bits; - s->hash_mask = s->hash_size - 1; -#if !defined(__x86_64__) && !defined(_M_X64) && !defined(__i386) && !defined(_M_IX86) - s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); -#endif - #ifdef X86_PCLMULQDQ_CRC window_padding = 8; #endif @@ -343,7 +324,7 @@ int ZEXPORT PREFIX(deflateInit2_)(PREFIX3(stream) *strm, int level, int method, s->window = (unsigned char *) ZALLOC_WINDOW(strm, s->w_size + window_padding, 2*sizeof(unsigned char)); s->prev = (Pos *) ZALLOC(strm, s->w_size, sizeof(Pos)); memset(s->prev, 0, s->w_size * sizeof(Pos)); - s->head = (Pos *) ZALLOC(strm, s->hash_size, sizeof(Pos)); + s->head = (Pos *) ZALLOC(strm, HASH_SIZE, sizeof(Pos)); s->high_water = 0; /* nothing written to s->window yet */ @@ -389,10 +370,9 @@ int ZEXPORT PREFIX(deflateInit2_)(PREFIX3(stream) *strm, int level, int method, */ s->pending_buf = (unsigned char *) ZALLOC(strm, s->lit_bufsize, 4); - s->pending_buf_size = (unsigned long)s->lit_bufsize * 4; + s->pending_buf_size = s->lit_bufsize * 4; - if (s->window == NULL || s->prev == NULL || s->head == NULL || - s->pending_buf == NULL) { + if (s->window == NULL || s->prev == NULL || s->head == NULL || s->pending_buf == NULL) { s->status = FINISH_STATE; strm->msg = ERR_MSG(Z_MEM_ERROR); PREFIX(deflateEnd)(strm); @@ -407,8 +387,8 @@ int ZEXPORT PREFIX(deflateInit2_)(PREFIX3(stream) *strm, int level, int method, s->level = level; s->strategy = strategy; - s->method = (unsigned char)method; s->block_open = 0; + s->reproducible = 0; return PREFIX(deflateReset)(strm); } @@ -418,8 +398,7 @@ int ZEXPORT PREFIX(deflateInit2_)(PREFIX3(stream) *strm, int level, int method, */ static int deflateStateCheck (PREFIX3(stream) *strm) { deflate_state *s; - if (strm == NULL || - strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) + if (strm == NULL || strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) return 1; s = strm->state; if (s == NULL || s->strm != strm || (s->status != INIT_STATE && @@ -437,7 +416,7 @@ static int deflateStateCheck (PREFIX3(stream) *strm) { } /* ========================================================================= */ -int ZEXPORT PREFIX(deflateSetDictionary)(PREFIX3(stream) *strm, const unsigned char *dictionary, unsigned int dictLength) { +int32_t Z_EXPORT PREFIX(deflateSetDictionary)(PREFIX3(stream) *strm, const uint8_t *dictionary, uint32_t dictLength) { deflate_state *s; unsigned int str, n; int wrap; @@ -462,7 +441,7 @@ int ZEXPORT PREFIX(deflateSetDictionary)(PREFIX3(stream) *strm, const unsigned c if (wrap == 0) { /* already empty otherwise */ CLEAR_HASH(s); s->strstart = 0; - s->block_start = 0L; + s->block_start = 0; s->insert = 0; } dictionary += dictLength - s->w_size; /* use the tail */ @@ -473,30 +452,30 @@ int ZEXPORT PREFIX(deflateSetDictionary)(PREFIX3(stream) *strm, const unsigned c avail = strm->avail_in; next = strm->next_in; strm->avail_in = dictLength; - strm->next_in = (const unsigned char *)dictionary; - functable.fill_window(s); + strm->next_in = (z_const unsigned char *)dictionary; + fill_window(s); while (s->lookahead >= MIN_MATCH) { str = s->strstart; n = s->lookahead - (MIN_MATCH-1); functable.insert_string(s, str, n); s->strstart = str + n; s->lookahead = MIN_MATCH-1; - functable.fill_window(s); + fill_window(s); } s->strstart += s->lookahead; - s->block_start = (long)s->strstart; + s->block_start = (int)s->strstart; s->insert = s->lookahead; s->lookahead = 0; - s->match_length = s->prev_length = MIN_MATCH-1; + s->prev_length = MIN_MATCH-1; s->match_available = 0; - strm->next_in = next; + strm->next_in = (z_const unsigned char *)next; strm->avail_in = avail; s->wrap = wrap; return Z_OK; } /* ========================================================================= */ -int ZEXPORT PREFIX(deflateGetDictionary)(PREFIX3(stream) *strm, unsigned char *dictionary, unsigned int *dictLength) { +int32_t Z_EXPORT PREFIX(deflateGetDictionary)(PREFIX3(stream) *strm, uint8_t *dictionary, uint32_t *dictLength) { deflate_state *s; unsigned int len; @@ -515,12 +494,11 @@ int ZEXPORT PREFIX(deflateGetDictionary)(PREFIX3(stream) *strm, unsigned char *d } /* ========================================================================= */ -int ZEXPORT PREFIX(deflateResetKeep)(PREFIX3(stream) *strm) { +int32_t Z_EXPORT PREFIX(deflateResetKeep)(PREFIX3(stream) *strm) { deflate_state *s; - if (deflateStateCheck(strm)) { + if (deflateStateCheck(strm)) return Z_STREAM_ERROR; - } strm->total_in = strm->total_out = 0; strm->msg = NULL; /* use zfree if we ever allocate msg dynamically */ @@ -530,9 +508,9 @@ int ZEXPORT PREFIX(deflateResetKeep)(PREFIX3(stream) *strm) { s->pending = 0; s->pending_out = s->pending_buf; - if (s->wrap < 0) { + if (s->wrap < 0) s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */ - } + s->status = #ifdef GZIP s->wrap == 2 ? GZIP_STATE : @@ -544,10 +522,10 @@ int ZEXPORT PREFIX(deflateResetKeep)(PREFIX3(stream) *strm) { crc_reset(s); else #endif - strm->adler = functable.adler32(0L, NULL, 0); + strm->adler = ADLER32_INITIAL_VALUE; s->last_flush = -2; - _tr_init(s); + zng_tr_init(s); DEFLATE_RESET_KEEP_HOOK(strm); /* hook for IBM Z DFLTCC */ @@ -555,7 +533,7 @@ int ZEXPORT PREFIX(deflateResetKeep)(PREFIX3(stream) *strm) { } /* ========================================================================= */ -int ZEXPORT PREFIX(deflateReset)(PREFIX3(stream) *strm) { +int32_t Z_EXPORT PREFIX(deflateReset)(PREFIX3(stream) *strm) { int ret; ret = PREFIX(deflateResetKeep)(strm); @@ -565,7 +543,7 @@ int ZEXPORT PREFIX(deflateReset)(PREFIX3(stream) *strm) { } /* ========================================================================= */ -int ZEXPORT PREFIX(deflateSetHeader)(PREFIX3(stream) *strm, PREFIX(gz_headerp) head) { +int32_t Z_EXPORT PREFIX(deflateSetHeader)(PREFIX3(stream) *strm, PREFIX(gz_headerp) head) { if (deflateStateCheck(strm) || strm->state->wrap != 2) return Z_STREAM_ERROR; strm->state->gzhead = head; @@ -573,7 +551,7 @@ int ZEXPORT PREFIX(deflateSetHeader)(PREFIX3(stream) *strm, PREFIX(gz_headerp) h } /* ========================================================================= */ -int ZEXPORT PREFIX(deflatePending)(PREFIX3(stream) *strm, uint32_t *pending, int *bits) { +int32_t Z_EXPORT PREFIX(deflatePending)(PREFIX3(stream) *strm, uint32_t *pending, int32_t *bits) { if (deflateStateCheck(strm)) return Z_STREAM_ERROR; if (pending != NULL) @@ -584,33 +562,38 @@ int ZEXPORT PREFIX(deflatePending)(PREFIX3(stream) *strm, uint32_t *pending, int } /* ========================================================================= */ -int ZEXPORT PREFIX(deflatePrime)(PREFIX3(stream) *strm, int bits, int value) { +int32_t Z_EXPORT PREFIX(deflatePrime)(PREFIX3(stream) *strm, int32_t bits, int32_t value) { deflate_state *s; - int put; + uint64_t value64 = (uint64_t)value; + int32_t put; if (deflateStateCheck(strm)) return Z_STREAM_ERROR; s = strm->state; - if (bits < 0 || bits > 16 || - s->sym_buf < s->pending_out + ((Buf_size + 7) >> 3)) + if (bits < 0 || bits > BIT_BUF_SIZE || bits > (int32_t)(sizeof(value) << 3) || + s->sym_buf < s->pending_out + ((BIT_BUF_SIZE + 7) >> 3)) return Z_BUF_ERROR; do { - put = Buf_size - s->bi_valid; + put = BIT_BUF_SIZE - s->bi_valid; if (put > bits) put = bits; - s->bi_buf |= (uint16_t)((value & ((1 << put) - 1)) << s->bi_valid); + if (s->bi_valid == 0) + s->bi_buf = value64; + else + s->bi_buf |= (value64 & ((UINT64_C(1) << put) - 1)) << s->bi_valid; s->bi_valid += put; - _tr_flush_bits(s); - value >>= put; + zng_tr_flush_bits(s); + value64 >>= put; bits -= put; } while (bits); return Z_OK; } /* ========================================================================= */ -int ZEXPORT PREFIX(deflateParams)(PREFIX3(stream) *strm, int level, int strategy) { +int32_t Z_EXPORT PREFIX(deflateParams)(PREFIX3(stream) *strm, int32_t level, int32_t strategy) { deflate_state *s; compress_func func; + int hook_flush = Z_NO_FLUSH; if (deflateStateCheck(strm)) return Z_STREAM_ERROR; @@ -618,25 +601,25 @@ int ZEXPORT PREFIX(deflateParams)(PREFIX3(stream) *strm, int level, int strategy if (level == Z_DEFAULT_COMPRESSION) level = 6; - if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { + if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) return Z_STREAM_ERROR; - } - DEFLATE_PARAMS_HOOK(strm, level, strategy); /* hook for IBM Z DFLTCC */ + DEFLATE_PARAMS_HOOK(strm, level, strategy, &hook_flush); /* hook for IBM Z DFLTCC */ func = configuration_table[s->level].func; - if ((strategy != s->strategy || func != configuration_table[level].func) && - s->last_flush != -2) { - /* Flush the last buffer: */ - int err = PREFIX(deflate)(strm, Z_BLOCK); + if (((strategy != s->strategy || func != configuration_table[level].func) && s->last_flush != -2) + || hook_flush != Z_NO_FLUSH) { + /* Flush the last buffer. Use Z_BLOCK mode, unless the hook requests a "stronger" one. */ + int flush = RANK(hook_flush) > RANK(Z_BLOCK) ? hook_flush : Z_BLOCK; + int err = PREFIX(deflate)(strm, flush); if (err == Z_STREAM_ERROR) return err; - if (strm->avail_in || (s->strstart - s->block_start) + s->lookahead) + if (strm->avail_in || ((int)s->strstart - s->block_start) + s->lookahead || !DEFLATE_DONE(strm, flush)) return Z_BUF_ERROR; } if (s->level != level) { if (s->level == 0 && s->matches != 0) { if (s->matches == 1) { - slide_hash(s); + functable.slide_hash(s); } else { CLEAR_HASH(s); } @@ -653,7 +636,7 @@ int ZEXPORT PREFIX(deflateParams)(PREFIX3(stream) *strm, int level, int strategy } /* ========================================================================= */ -int ZEXPORT PREFIX(deflateTune)(PREFIX3(stream) *strm, int good_length, int max_lazy, int nice_length, int max_chain) { +int32_t Z_EXPORT PREFIX(deflateTune)(PREFIX3(stream) *strm, int32_t good_length, int32_t max_lazy, int32_t nice_length, int32_t max_chain) { deflate_state *s; if (deflateStateCheck(strm)) @@ -683,7 +666,7 @@ int ZEXPORT PREFIX(deflateTune)(PREFIX3(stream) *strm, int good_length, int max_ * upper bound of about 14% expansion does not seem onerous for output buffer * allocation. */ -unsigned long ZEXPORT PREFIX(deflateBound)(PREFIX3(stream) *strm, unsigned long sourceLen) { +unsigned long Z_EXPORT PREFIX(deflateBound)(PREFIX3(stream) *strm, unsigned long sourceLen) { deflate_state *s; unsigned long complen, wraplen; @@ -735,49 +718,39 @@ unsigned long ZEXPORT PREFIX(deflateBound)(PREFIX3(stream) *strm, unsigned long /* if not default parameters, return conservative bound */ if (DEFLATE_NEED_CONSERVATIVE_BOUND(strm) || /* hook for IBM Z DFLTCC */ - s->w_bits != 15 || s->hash_bits != 8 + 7) + s->w_bits != 15 || HASH_BITS < 15) return complen + wraplen; /* default settings: return tight bound for that case */ return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + (sourceLen >> 25) + 13 - 6 + wraplen; } -/* ========================================================================= - * Put a short in the pending buffer. The 16-bit value is put in MSB order. - * IN assertion: the stream state is correct and there is enough room in - * pending_buf. - */ -static void putShortMSB(deflate_state *s, uint16_t b) { - put_byte(s, (unsigned char)(b >> 8)); - put_byte(s, (unsigned char)(b & 0xff)); -} - /* ========================================================================= * Flush as much pending output as possible. All deflate() output, except for * some deflate_stored() output, goes through this function so some * applications may wish to modify it to avoid allocating a large * strm->next_out buffer and copying into it. (See also read_buf()). */ -ZLIB_INTERNAL void flush_pending(PREFIX3(stream) *strm) { +Z_INTERNAL void flush_pending(PREFIX3(stream) *strm) { uint32_t len; deflate_state *s = strm->state; - _tr_flush_bits(s); + zng_tr_flush_bits(s); len = s->pending; if (len > strm->avail_out) len = strm->avail_out; if (len == 0) return; + Tracev((stderr, "[FLUSH]")); memcpy(strm->next_out, s->pending_out, len); strm->next_out += len; s->pending_out += len; strm->total_out += len; strm->avail_out -= len; s->pending -= len; - if (s->pending == 0) { + if (s->pending == 0) s->pending_out = s->pending_buf; - } } /* =========================================================================== @@ -790,21 +763,21 @@ ZLIB_INTERNAL void flush_pending(PREFIX3(stream) *strm) { } while (0) /* ========================================================================= */ -int ZEXPORT PREFIX(deflate)(PREFIX3(stream) *strm, int flush) { - int old_flush; /* value of flush param for previous deflate call */ +int32_t Z_EXPORT PREFIX(deflate)(PREFIX3(stream) *strm, int32_t flush) { + int32_t old_flush; /* value of flush param for previous deflate call */ deflate_state *s; - if (deflateStateCheck(strm) || flush > Z_BLOCK || flush < 0) { + if (deflateStateCheck(strm) || flush > Z_BLOCK || flush < 0) return Z_STREAM_ERROR; - } s = strm->state; - if (strm->next_out == NULL || (strm->avail_in != 0 && strm->next_in == NULL) || - (s->status == FINISH_STATE && flush != Z_FINISH)) { + if (strm->next_out == NULL || (strm->avail_in != 0 && strm->next_in == NULL) + || (s->status == FINISH_STATE && flush != Z_FINISH)) { ERR_RETURN(strm, Z_STREAM_ERROR); } - if (strm->avail_out == 0) + if (strm->avail_out == 0) { ERR_RETURN(strm, Z_BUF_ERROR); + } old_flush = s->last_flush; s->last_flush = flush; @@ -823,17 +796,16 @@ int ZEXPORT PREFIX(deflate)(PREFIX3(stream) *strm, int flush) { return Z_OK; } - /* Make sure there is something to do and avoid duplicate consecutive - * flushes. For repeated and useless calls with Z_FINISH, we keep - * returning Z_STREAM_END instead of Z_BUF_ERROR. - */ - } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) && - flush != Z_FINISH) { + /* Make sure there is something to do and avoid duplicate consecutive + * flushes. For repeated and useless calls with Z_FINISH, we keep + * returning Z_STREAM_END instead of Z_BUF_ERROR. + */ + } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) && flush != Z_FINISH) { ERR_RETURN(strm, Z_BUF_ERROR); } /* User must not provide more input after the first FINISH: */ - if (s->status == FINISH_STATE && strm->avail_in != 0) { + if (s->status == FINISH_STATE && strm->avail_in != 0) { ERR_RETURN(strm, Z_BUF_ERROR); } @@ -854,17 +826,16 @@ int ZEXPORT PREFIX(deflate)(PREFIX3(stream) *strm, int flush) { else level_flags = 3; header |= (level_flags << 6); - if (s->strstart != 0) header |= PRESET_DICT; + if (s->strstart != 0) + header |= PRESET_DICT; header += 31 - (header % 31); - putShortMSB(s, header); + put_short_msb(s, (uint16_t)header); /* Save the adler32 of the preset dictionary: */ - if (s->strstart != 0) { - putShortMSB(s, (uint16_t)(strm->adler >> 16)); - putShortMSB(s, (uint16_t)(strm->adler)); - } - strm->adler = functable.adler32(0L, NULL, 0); + if (s->strstart != 0) + put_uint32_msb(s, strm->adler); + strm->adler = ADLER32_INITIAL_VALUE; s->status = BUSY_STATE; /* Compression must start with an empty pending buffer */ @@ -882,10 +853,7 @@ int ZEXPORT PREFIX(deflate)(PREFIX3(stream) *strm, int flush) { put_byte(s, 139); put_byte(s, 8); if (s->gzhead == NULL) { - put_byte(s, 0); - put_byte(s, 0); - put_byte(s, 0); - put_byte(s, 0); + put_uint32(s, 0); put_byte(s, 0); put_byte(s, s->level == 9 ? 2 : (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? 4 : 0)); @@ -898,25 +866,18 @@ int ZEXPORT PREFIX(deflate)(PREFIX3(stream) *strm, int flush) { s->last_flush = -1; return Z_OK; } - } - else { + } else { put_byte(s, (s->gzhead->text ? 1 : 0) + (s->gzhead->hcrc ? 2 : 0) + (s->gzhead->extra == NULL ? 0 : 4) + (s->gzhead->name == NULL ? 0 : 8) + (s->gzhead->comment == NULL ? 0 : 16) ); - put_byte(s, (unsigned char)(s->gzhead->time & 0xff)); - put_byte(s, (unsigned char)((s->gzhead->time >> 8) & 0xff)); - put_byte(s, (unsigned char)((s->gzhead->time >> 16) & 0xff)); - put_byte(s, (unsigned char)((s->gzhead->time >> 24) & 0xff)); - put_byte(s, s->level == 9 ? 2 : - (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? 4 : 0)); + put_uint32(s, s->gzhead->time); + put_byte(s, s->level == 9 ? 2 : (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? 4 : 0)); put_byte(s, s->gzhead->os & 0xff); - if (s->gzhead->extra != NULL) { - put_byte(s, s->gzhead->extra_len & 0xff); - put_byte(s, (s->gzhead->extra_len >> 8) & 0xff); - } + if (s->gzhead->extra != NULL) + put_short(s, (uint16_t)s->gzhead->extra_len); if (s->gzhead->hcrc) strm->adler = PREFIX(crc32)(strm->adler, s->pending_buf, s->pending); s->gzindex = 0; @@ -952,7 +913,7 @@ int ZEXPORT PREFIX(deflate)(PREFIX3(stream) *strm, int flush) { if (s->status == NAME_STATE) { if (s->gzhead->name != NULL) { uint32_t beg = s->pending; /* start of bytes to update crc */ - int val; + unsigned char val; do { if (s->pending == s->pending_buf_size) { @@ -975,7 +936,7 @@ int ZEXPORT PREFIX(deflate)(PREFIX3(stream) *strm, int flush) { if (s->status == COMMENT_STATE) { if (s->gzhead->comment != NULL) { uint32_t beg = s->pending; /* start of bytes to update crc */ - int val; + unsigned char val; do { if (s->pending == s->pending_buf_size) { @@ -1003,8 +964,7 @@ int ZEXPORT PREFIX(deflate)(PREFIX3(stream) *strm, int flush) { return Z_OK; } } - put_byte(s, (unsigned char)(strm->adler & 0xff)); - put_byte(s, (unsigned char)((strm->adler >> 8) & 0xff)); + put_short(s, (uint16_t)strm->adler); crc_reset(s); } s->status = BUSY_STATE; @@ -1027,9 +987,6 @@ int ZEXPORT PREFIX(deflate)(PREFIX3(stream) *strm, int flush) { s->level == 0 ? deflate_stored(s, flush) : s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : s->strategy == Z_RLE ? deflate_rle(s, flush) : -#ifdef X86_QUICK_STRATEGY - (s->level == 1 && !x86_cpu_has_sse42) ? deflate_fast(s, flush) : -#endif (*(configuration_table[s->level].func))(s, flush); if (bstate == finish_started || bstate == finish_done) { @@ -1050,9 +1007,9 @@ int ZEXPORT PREFIX(deflate)(PREFIX3(stream) *strm, int flush) { } if (bstate == block_done) { if (flush == Z_PARTIAL_FLUSH) { - _tr_align(s); + zng_tr_align(s); } else if (flush != Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */ - _tr_stored_block(s, (char*)0, 0L, 0); + zng_tr_stored_block(s, (char*)0, 0L, 0); /* For a full flush, this empty block will be recognized * as a special marker by inflate_sync(). */ @@ -1060,23 +1017,21 @@ int ZEXPORT PREFIX(deflate)(PREFIX3(stream) *strm, int flush) { CLEAR_HASH(s); /* forget history */ if (s->lookahead == 0) { s->strstart = 0; - s->block_start = 0L; + s->block_start = 0; s->insert = 0; } } } flush_pending(strm); if (strm->avail_out == 0) { - s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */ - return Z_OK; + s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */ + return Z_OK; } } } if (flush != Z_FINISH) return Z_OK; - if (s->wrap <= 0) - return Z_STREAM_END; /* Write the trailer */ #ifdef GZIP @@ -1084,32 +1039,28 @@ int ZEXPORT PREFIX(deflate)(PREFIX3(stream) *strm, int flush) { # ifdef X86_PCLMULQDQ_CRC crc_finalize(s); # endif - put_byte(s, (unsigned char)(strm->adler & 0xff)); - put_byte(s, (unsigned char)((strm->adler >> 8) & 0xff)); - put_byte(s, (unsigned char)((strm->adler >> 16) & 0xff)); - put_byte(s, (unsigned char)((strm->adler >> 24) & 0xff)); - put_byte(s, (unsigned char)(strm->total_in & 0xff)); - put_byte(s, (unsigned char)((strm->total_in >> 8) & 0xff)); - put_byte(s, (unsigned char)((strm->total_in >> 16) & 0xff)); - put_byte(s, (unsigned char)((strm->total_in >> 24) & 0xff)); + put_uint32(s, strm->adler); + put_uint32(s, (uint32_t)strm->total_in); } else #endif - { - putShortMSB(s, (uint16_t)(strm->adler >> 16)); - putShortMSB(s, (uint16_t)strm->adler); - } + if (s->wrap == 1) + put_uint32_msb(s, strm->adler); flush_pending(strm); /* If avail_out is zero, the application will call deflate again * to flush the rest. */ if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */ - return s->pending != 0 ? Z_OK : Z_STREAM_END; + if (s->pending == 0) { + Assert(s->bi_valid == 0, "bi_buf not flushed"); + return Z_STREAM_END; + } + return Z_OK; } /* ========================================================================= */ -int ZEXPORT PREFIX(deflateEnd)(PREFIX3(stream) *strm) { - int status; +int32_t Z_EXPORT PREFIX(deflateEnd)(PREFIX3(stream) *strm) { + int32_t status; if (deflateStateCheck(strm)) return Z_STREAM_ERROR; @@ -1131,13 +1082,13 @@ int ZEXPORT PREFIX(deflateEnd)(PREFIX3(stream) *strm) { /* ========================================================================= * Copy the source state to the destination state. */ -int ZEXPORT PREFIX(deflateCopy)(PREFIX3(stream) *dest, PREFIX3(stream) *source) { +int32_t Z_EXPORT PREFIX(deflateCopy)(PREFIX3(stream) *dest, PREFIX3(stream) *source) { deflate_state *ds; deflate_state *ss; + uint32_t window_padding = 0; - if (deflateStateCheck(source) || dest == NULL) { + if (deflateStateCheck(source) || dest == NULL) return Z_STREAM_ERROR; - } ss = source->state; @@ -1150,9 +1101,13 @@ int ZEXPORT PREFIX(deflateCopy)(PREFIX3(stream) *dest, PREFIX3(stream) *source) ZCOPY_STATE((void *)ds, (void *)ss, sizeof(deflate_state)); ds->strm = dest; - ds->window = (unsigned char *) ZALLOC_WINDOW(dest, ds->w_size, 2*sizeof(unsigned char)); +#ifdef X86_PCLMULQDQ_CRC + window_padding = 8; +#endif + + ds->window = (unsigned char *) ZALLOC_WINDOW(dest, ds->w_size + window_padding, 2*sizeof(unsigned char)); ds->prev = (Pos *) ZALLOC(dest, ds->w_size, sizeof(Pos)); - ds->head = (Pos *) ZALLOC(dest, ds->hash_size, sizeof(Pos)); + ds->head = (Pos *) ZALLOC(dest, HASH_SIZE, sizeof(Pos)); ds->pending_buf = (unsigned char *) ZALLOC(dest, ds->lit_bufsize, 4); if (ds->window == NULL || ds->prev == NULL || ds->head == NULL || ds->pending_buf == NULL) { @@ -1162,8 +1117,8 @@ int ZEXPORT PREFIX(deflateCopy)(PREFIX3(stream) *dest, PREFIX3(stream) *source) memcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(unsigned char)); memcpy((void *)ds->prev, (void *)ss->prev, ds->w_size * sizeof(Pos)); - memcpy((void *)ds->head, (void *)ss->head, ds->hash_size * sizeof(Pos)); - memcpy(ds->pending_buf, ss->pending_buf, (unsigned int)ds->pending_buf_size); + memcpy((void *)ds->head, (void *)ss->head, HASH_SIZE * sizeof(Pos)); + memcpy(ds->pending_buf, ss->pending_buf, ds->pending_buf_size); ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); ds->sym_buf = ds->pending_buf + ds->lit_bufsize; @@ -1182,7 +1137,7 @@ int ZEXPORT PREFIX(deflateCopy)(PREFIX3(stream) *dest, PREFIX3(stream) *source) * allocating a large strm->next_in buffer and copying from it. * (See also flush_pending()). */ -ZLIB_INTERNAL unsigned read_buf(PREFIX3(stream) *strm, unsigned char *buf, unsigned size) { +Z_INTERNAL unsigned read_buf(PREFIX3(stream) *strm, unsigned char *buf, unsigned size) { uint32_t len = strm->avail_in; if (len > size) @@ -1194,13 +1149,11 @@ ZLIB_INTERNAL unsigned read_buf(PREFIX3(stream) *strm, unsigned char *buf, unsig if (!DEFLATE_NEED_CHECKSUM(strm)) { memcpy(buf, strm->next_in, len); - } else #ifdef GZIP - if (strm->state->wrap == 2) + } else if (strm->state->wrap == 2) { copy_with_crc(strm, buf, len); - else #endif - { + } else { memcpy(buf, strm->next_in, len); if (strm->state->wrap == 1) strm->adler = functable.adler32(strm->adler, buf, len); @@ -1215,7 +1168,7 @@ ZLIB_INTERNAL unsigned read_buf(PREFIX3(stream) *strm, unsigned char *buf, unsig * Initialize the "longest match" routines for a new zlib stream */ static void lm_init(deflate_state *s) { - s->window_size = (unsigned long)2L*s->w_size; + s->window_size = 2 * s->w_size; CLEAR_HASH(s); @@ -1227,13 +1180,12 @@ static void lm_init(deflate_state *s) { s->max_chain_length = configuration_table[s->level].max_chain; s->strstart = 0; - s->block_start = 0L; + s->block_start = 0; s->lookahead = 0; s->insert = 0; - s->match_length = s->prev_length = MIN_MATCH-1; + s->prev_length = MIN_MATCH-1; s->match_available = 0; s->match_start = 0; - s->ins_h = 0; } #ifdef ZLIB_DEBUG @@ -1243,12 +1195,23 @@ static void lm_init(deflate_state *s) { /* =========================================================================== * Check that the match at match_start is indeed a match. */ -void check_match(deflate_state *s, IPos start, IPos match, int length) { +void check_match(deflate_state *s, Pos start, Pos match, int length) { + /* check that the match length is valid*/ + if (length < MIN_MATCH || length > MAX_MATCH) { + fprintf(stderr, " start %u, match %u, length %d\n", start, match, length); + z_error("invalid match length"); + } + /* check that the match isn't at the same position as the start string */ + if (match == start) { + fprintf(stderr, " start %u, match %u, length %d\n", start, match, length); + z_error("invalid match position"); + } /* check that the match is indeed a match */ if (memcmp(s->window + match, s->window + start, length) != EQUAL) { + int32_t i = 0; fprintf(stderr, " start %u, match %u, length %d\n", start, match, length); do { - fprintf(stderr, "%c%c", s->window[match++], s->window[start++]); + fprintf(stderr, " %03d: match [%02x] start [%02x]\n", i++, s->window[match++], s->window[start++]); } while (--length != 0); z_error("invalid match"); } @@ -1274,27 +1237,32 @@ void check_match(deflate_state *s, IPos start, IPos match, int length) { * option -- not supported here). */ -void ZLIB_INTERNAL fill_window_c(deflate_state *s) { +void Z_INTERNAL fill_window(deflate_state *s) { unsigned n; - unsigned more; /* Amount of free space at the end of the window. */ + unsigned int more; /* Amount of free space at the end of the window. */ unsigned int wsize = s->w_size; Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead"); do { - more = (unsigned)(s->window_size -(unsigned long)s->lookahead -(unsigned long)s->strstart); + more = s->window_size - s->lookahead - s->strstart; /* If the window is almost full and there is insufficient lookahead, * move the upper half to the lower one to make room in the upper half. */ if (s->strstart >= wsize+MAX_DIST(s)) { - memcpy(s->window, s->window+wsize, (unsigned)wsize - more); - s->match_start -= wsize; + memcpy(s->window, s->window+wsize, (unsigned)wsize); + if (s->match_start >= wsize) { + s->match_start -= wsize; + } else { + s->match_start = 0; + s->prev_length = 0; + } s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ - s->block_start -= (long) wsize; + s->block_start -= (int)wsize; if (s->insert > s->strstart) s->insert = s->strstart; - slide_hash(s); + functable.slide_hash(s); more += wsize; } if (s->strm->avail_in == 0) @@ -1319,13 +1287,12 @@ void ZLIB_INTERNAL fill_window_c(deflate_state *s) { /* Initialize the hash value now that we have some input: */ if (s->lookahead + s->insert >= MIN_MATCH) { unsigned int str = s->strstart - s->insert; - s->ins_h = s->window[str]; if (str >= 1) - functable.insert_string(s, str + 2 - MIN_MATCH, 1); + functable.quick_insert_string(s, str + 2 - MIN_MATCH); #if MIN_MATCH != 3 #error Call insert_string() MIN_MATCH-3 more times while (s->insert) { - functable.insert_string(s, str, 1); + functable.quick_insert_string(s, str); str++; s->insert--; if (s->lookahead + s->insert < MIN_MATCH) @@ -1333,13 +1300,15 @@ void ZLIB_INTERNAL fill_window_c(deflate_state *s) { } #else unsigned int count; - if (unlikely(s->lookahead == 1)){ + if (UNLIKELY(s->lookahead == 1)) { count = s->insert - 1; - }else{ + } else { count = s->insert; } - functable.insert_string(s,str,count); - s->insert -= count; + if (count > 0) { + functable.insert_string(s, str, count); + s->insert -= count; + } #endif } /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, @@ -1355,8 +1324,8 @@ void ZLIB_INTERNAL fill_window_c(deflate_state *s) { * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. */ if (s->high_water < s->window_size) { - unsigned long curr = s->strstart + (unsigned long)(s->lookahead); - unsigned long init; + unsigned int curr = s->strstart + s->lookahead; + unsigned int init; if (s->high_water < curr) { /* Previous high water mark below current data -- zero WIN_INIT @@ -1365,17 +1334,17 @@ void ZLIB_INTERNAL fill_window_c(deflate_state *s) { init = s->window_size - curr; if (init > WIN_INIT) init = WIN_INIT; - memset(s->window + curr, 0, (unsigned)init); + memset(s->window + curr, 0, init); s->high_water = curr + init; - } else if (s->high_water < (unsigned long)curr + WIN_INIT) { + } else if (s->high_water < curr + WIN_INIT) { /* High water mark at or above current data, but below current data * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up * to end of window, whichever is less. */ - init = (unsigned long)curr + WIN_INIT - s->high_water; + init = curr + WIN_INIT - s->high_water; if (init > s->window_size - s->high_water) init = s->window_size - s->high_water; - memset(s->window + s->high_water, 0, (unsigned)init); + memset(s->window + s->high_water, 0, init); s->high_water += init; } } @@ -1423,7 +1392,7 @@ static block_state deflate_stored(deflate_state *s, int flush) { break; /* maximum stored block length that will fit in avail_out: */ have = s->strm->avail_out - have; - left = s->strstart - s->block_start; /* bytes left in window */ + left = (int)s->strstart - s->block_start; /* bytes left in window */ if (len > (unsigned long)left + s->strm->avail_in) len = left + s->strm->avail_in; /* limit len to the input */ if (len > have) @@ -1441,22 +1410,19 @@ static block_state deflate_stored(deflate_state *s, int flush) { * including any pending bits. This also updates the debugging counts. */ last = flush == Z_FINISH && len == left + s->strm->avail_in ? 1 : 0; - _tr_stored_block(s, (char *)0, 0L, last); + zng_tr_stored_block(s, (char *)0, 0L, last); /* Replace the lengths in the dummy stored block with len. */ - s->pending_buf[s->pending - 4] = len; - s->pending_buf[s->pending - 3] = len >> 8; - s->pending_buf[s->pending - 2] = ~len; - s->pending_buf[s->pending - 1] = ~len >> 8; + s->pending -= 4; + put_short(s, (uint16_t)len); + put_short(s, (uint16_t)~len); /* Write the stored block header bytes. */ flush_pending(s->strm); -#ifdef ZLIB_DEBUG /* Update debugging counts for the data about to be copied. */ - s->compressed_len += len << 3; - s->bits_sent += len << 3; -#endif + cmpr_bits_add(s, len << 3); + sent_bits_add(s, len << 3); /* Copy uncompressed bytes from the window to next_out. */ if (left) { @@ -1466,7 +1432,7 @@ static block_state deflate_stored(deflate_state *s, int flush) { s->strm->next_out += left; s->strm->avail_out -= left; s->strm->total_out += left; - s->block_start += left; + s->block_start += (int)left; len -= left; } @@ -1497,8 +1463,7 @@ static block_state deflate_stored(deflate_state *s, int flush) { memcpy(s->window, s->strm->next_in - s->w_size, s->w_size); s->strstart = s->w_size; s->insert = s->strstart; - } - else { + } else { if (s->window_size - s->strstart <= used) { /* Slide the window down. */ s->strstart -= s->w_size; @@ -1512,7 +1477,7 @@ static block_state deflate_stored(deflate_state *s, int flush) { s->strstart += used; s->insert += MIN(used, s->w_size - s->insert); } - s->block_start = s->strstart; + s->block_start = (int)s->strstart; } if (s->high_water < s->strstart) s->high_water = s->strstart; @@ -1522,15 +1487,14 @@ static block_state deflate_stored(deflate_state *s, int flush) { return finish_done; /* If flushing and all input has been consumed, then done. */ - if (flush != Z_NO_FLUSH && flush != Z_FINISH && - s->strm->avail_in == 0 && (long)s->strstart == s->block_start) + if (flush != Z_NO_FLUSH && flush != Z_FINISH && s->strm->avail_in == 0 && (int)s->strstart == s->block_start) return block_done; /* Fill the window with any remaining input. */ have = s->window_size - s->strstart; - if (s->strm->avail_in > have && s->block_start >= (long)s->w_size) { + if (s->strm->avail_in > have && s->block_start >= (int)s->w_size) { /* Slide the window down. */ - s->block_start -= s->w_size; + s->block_start -= (int)s->w_size; s->strstart -= s->w_size; memcpy(s->window, s->window + s->w_size, s->strstart); if (s->matches < 2) @@ -1558,15 +1522,12 @@ static block_state deflate_stored(deflate_state *s, int flush) { /* maximum stored block length that will fit in pending: */ have = MIN(s->pending_buf_size - have, MAX_STORED); min_block = MIN(have, s->w_size); - left = s->strstart - s->block_start; - if (left >= min_block || - ((left || flush == Z_FINISH) && flush != Z_NO_FLUSH && - s->strm->avail_in == 0 && left <= have)) { + left = (int)s->strstart - s->block_start; + if (left >= min_block || ((left || flush == Z_FINISH) && flush != Z_NO_FLUSH && s->strm->avail_in == 0 && left <= have)) { len = MIN(left, have); - last = flush == Z_FINISH && s->strm->avail_in == 0 && - len == left ? 1 : 0; - _tr_stored_block(s, (char *)s->window + s->block_start, len, last); - s->block_start += len; + last = flush == Z_FINISH && s->strm->avail_in == 0 && len == left ? 1 : 0; + zng_tr_stored_block(s, (char *)s->window + s->block_start, len, last); + s->block_start += (int)len; flush_pending(s->strm); } @@ -1581,9 +1542,10 @@ static block_state deflate_stored(deflate_state *s, int flush) { * deflate switches away from Z_RLE.) */ static block_state deflate_rle(deflate_state *s, int flush) { - int bflush; /* set if current block must be flushed */ + int bflush = 0; /* set if current block must be flushed */ unsigned int prev; /* byte at distance one to match */ unsigned char *scan, *strend; /* scan goes up to strend for length of run */ + uint32_t match_len = 0; for (;;) { /* Make sure that we always have enough lookahead, except @@ -1591,16 +1553,14 @@ static block_state deflate_rle(deflate_state *s, int flush) { * for the longest run, plus one for the unrolled loop. */ if (s->lookahead <= MAX_MATCH) { - functable.fill_window(s); - if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) { + fill_window(s); + if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) return need_more; - } if (s->lookahead == 0) break; /* flush the current block */ } /* See how many times the previous byte repeats */ - s->match_length = 0; if (s->lookahead >= MIN_MATCH && s->strstart > 0) { scan = s->window + s->strstart - 1; prev = *scan; @@ -1612,26 +1572,25 @@ static block_state deflate_rle(deflate_state *s, int flush) { prev == *++scan && prev == *++scan && prev == *++scan && prev == *++scan && scan < strend); - s->match_length = MAX_MATCH - (unsigned int)(strend - scan); - if (s->match_length > s->lookahead) - s->match_length = s->lookahead; + match_len = MAX_MATCH - (unsigned int)(strend - scan); + if (match_len > s->lookahead) + match_len = s->lookahead; } - Assert(scan <= s->window+(unsigned int)(s->window_size-1), "wild scan"); + Assert(scan <= s->window + s->window_size - 1, "wild scan"); } /* Emit match if have run of MIN_MATCH or longer, else emit literal */ - if (s->match_length >= MIN_MATCH) { - check_match(s, s->strstart, s->strstart - 1, s->match_length); + if (match_len >= MIN_MATCH) { + check_match(s, s->strstart, s->strstart - 1, match_len); - _tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush); + bflush = zng_tr_tally_dist(s, 1, match_len - MIN_MATCH); - s->lookahead -= s->match_length; - s->strstart += s->match_length; - s->match_length = 0; + s->lookahead -= match_len; + s->strstart += match_len; + match_len = 0; } else { /* No match, output a literal byte */ - Tracevv((stderr, "%c", s->window[s->strstart])); - _tr_tally_lit(s, s->window[s->strstart], bflush); + bflush = zng_tr_tally_lit(s, s->window[s->strstart]); s->lookahead--; s->strstart++; } @@ -1653,12 +1612,12 @@ static block_state deflate_rle(deflate_state *s, int flush) { * (It will be regenerated if this run of deflate switches away from Huffman.) */ static block_state deflate_huff(deflate_state *s, int flush) { - int bflush; /* set if current block must be flushed */ + int bflush = 0; /* set if current block must be flushed */ for (;;) { /* Make sure that we have a literal to write. */ if (s->lookahead == 0) { - functable.fill_window(s); + fill_window(s); if (s->lookahead == 0) { if (flush == Z_NO_FLUSH) return need_more; @@ -1667,9 +1626,7 @@ static block_state deflate_huff(deflate_state *s, int flush) { } /* Output a literal byte */ - s->match_length = 0; - Tracevv((stderr, "%c", s->window[s->strstart])); - _tr_tally_lit(s, s->window[s->strstart], bflush); + bflush = zng_tr_tally_lit(s, s->window[s->strstart]); s->lookahead--; s->strstart++; if (bflush) @@ -1685,28 +1642,141 @@ static block_state deflate_huff(deflate_state *s, int flush) { return block_done; } -#ifdef ZLIB_DEBUG -/* =========================================================================== - * Send a value on a given number of bits. - * IN assertion: length <= 16 and value fits in length bits. +#ifndef ZLIB_COMPAT +/* ========================================================================= + * Checks whether buffer size is sufficient and whether this parameter is a duplicate. */ -void send_bits(deflate_state *s, int value, int length) { - Tracevv((stderr, " l %2d v %4x ", length, value)); - Assert(length > 0 && length <= 15, "invalid length"); - s->bits_sent += (unsigned long)length; +static int32_t deflateSetParamPre(zng_deflate_param_value **out, size_t min_size, zng_deflate_param_value *param) { + int32_t buf_error = param->size < min_size; - /* If not enough room in bi_buf, use (valid) bits from bi_buf and - * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid)) - * unused bits in value. - */ - if (s->bi_valid > (int)Buf_size - length) { - s->bi_buf |= (uint16_t)value << s->bi_valid; - put_short(s, s->bi_buf); - s->bi_buf = (uint16_t)value >> (Buf_size - s->bi_valid); - s->bi_valid += length - Buf_size; - } else { - s->bi_buf |= (uint16_t)value << s->bi_valid; - s->bi_valid += length; + if (*out != NULL) { + (*out)->status = Z_BUF_ERROR; + buf_error = 1; } + *out = param; + return buf_error; +} + +/* ========================================================================= */ +int32_t Z_EXPORT zng_deflateSetParams(zng_stream *strm, zng_deflate_param_value *params, size_t count) { + size_t i; + deflate_state *s; + zng_deflate_param_value *new_level = NULL; + zng_deflate_param_value *new_strategy = NULL; + zng_deflate_param_value *new_reproducible = NULL; + int param_buf_error; + int version_error = 0; + int buf_error = 0; + int stream_error = 0; + int ret; + int val; + + /* Initialize the statuses. */ + for (i = 0; i < count; i++) + params[i].status = Z_OK; + + /* Check whether the stream state is consistent. */ + if (deflateStateCheck(strm)) + return Z_STREAM_ERROR; + s = strm->state; + + /* Check buffer sizes and detect duplicates. */ + for (i = 0; i < count; i++) { + switch (params[i].param) { + case Z_DEFLATE_LEVEL: + param_buf_error = deflateSetParamPre(&new_level, sizeof(int), ¶ms[i]); + break; + case Z_DEFLATE_STRATEGY: + param_buf_error = deflateSetParamPre(&new_strategy, sizeof(int), ¶ms[i]); + break; + case Z_DEFLATE_REPRODUCIBLE: + param_buf_error = deflateSetParamPre(&new_reproducible, sizeof(int), ¶ms[i]); + break; + default: + params[i].status = Z_VERSION_ERROR; + version_error = 1; + param_buf_error = 0; + break; + } + if (param_buf_error) { + params[i].status = Z_BUF_ERROR; + buf_error = 1; + } + } + /* Exit early if small buffers or duplicates are detected. */ + if (buf_error) + return Z_BUF_ERROR; + + /* Apply changes, remember if there were errors. */ + if (new_level != NULL || new_strategy != NULL) { + ret = PREFIX(deflateParams)(strm, new_level == NULL ? s->level : *(int *)new_level->buf, + new_strategy == NULL ? s->strategy : *(int *)new_strategy->buf); + if (ret != Z_OK) { + if (new_level != NULL) + new_level->status = Z_STREAM_ERROR; + if (new_strategy != NULL) + new_strategy->status = Z_STREAM_ERROR; + stream_error = 1; + } + } + if (new_reproducible != NULL) { + val = *(int *)new_reproducible->buf; + if (DEFLATE_CAN_SET_REPRODUCIBLE(strm, val)) { + s->reproducible = val; + } else { + new_reproducible->status = Z_STREAM_ERROR; + stream_error = 1; + } + } + + /* Report version errors only if there are no real errors. */ + return stream_error ? Z_STREAM_ERROR : (version_error ? Z_VERSION_ERROR : Z_OK); +} + +/* ========================================================================= */ +int32_t Z_EXPORT zng_deflateGetParams(zng_stream *strm, zng_deflate_param_value *params, size_t count) { + deflate_state *s; + size_t i; + int32_t buf_error = 0; + int32_t version_error = 0; + + /* Initialize the statuses. */ + for (i = 0; i < count; i++) + params[i].status = Z_OK; + + /* Check whether the stream state is consistent. */ + if (deflateStateCheck(strm)) + return Z_STREAM_ERROR; + s = strm->state; + + for (i = 0; i < count; i++) { + switch (params[i].param) { + case Z_DEFLATE_LEVEL: + if (params[i].size < sizeof(int)) + params[i].status = Z_BUF_ERROR; + else + *(int *)params[i].buf = s->level; + break; + case Z_DEFLATE_STRATEGY: + if (params[i].size < sizeof(int)) + params[i].status = Z_BUF_ERROR; + else + *(int *)params[i].buf = s->strategy; + break; + case Z_DEFLATE_REPRODUCIBLE: + if (params[i].size < sizeof(int)) + params[i].status = Z_BUF_ERROR; + else + *(int *)params[i].buf = s->reproducible; + break; + default: + params[i].status = Z_VERSION_ERROR; + version_error = 1; + break; + } + if (params[i].status == Z_BUF_ERROR) + buf_error = 1; + } + return buf_error ? Z_BUF_ERROR : (version_error ? Z_VERSION_ERROR : Z_OK); } #endif diff --git a/libs/zlibng/deflate.h b/libs/zlibng/deflate.h index bbe8f6b07..03ea3126f 100644 --- a/libs/zlibng/deflate.h +++ b/libs/zlibng/deflate.h @@ -10,10 +10,8 @@ subject to change. Applications should only use zlib.h. */ -/* @(#) $Id$ */ - #include "zutil.h" -#include "gzendian.h" +#include "zendian.h" /* define NO_GZIP when compiling if you want to disable gzip header and trailer creation by deflate(). NO_GZIP would be used to avoid linking in @@ -23,10 +21,6 @@ # define GZIP #endif -#define NIL 0 -/* Tail of hash chains */ - - /* =========================================================================== * Internal compression state. */ @@ -52,7 +46,7 @@ #define MAX_BITS 15 /* All codes must not exceed MAX_BITS bits */ -#define Buf_size 16 +#define BIT_BUF_SIZE 64 /* size of bit buffer in bi_buf */ #define END_BLOCK 256 @@ -70,6 +64,10 @@ #define FINISH_STATE 666 /* stream complete */ /* Stream status */ +#define HASH_BITS 16u /* log2(HASH_SIZE) */ +#define HASH_SIZE 65536u /* number of elements in hash table */ +#define HASH_MASK (HASH_SIZE - 1u) /* HASH_SIZE-1 */ + /* Data structure describing a single value and its code string. */ typedef struct ct_data_s { @@ -97,34 +95,47 @@ typedef struct tree_desc_s { } tree_desc; typedef uint16_t Pos; -typedef unsigned IPos; /* A Pos is an index in the character window. We use short instead of int to - * save space in the various tables. IPos is used only for parameter passing. + * save space in the various tables. */ typedef struct internal_state { PREFIX3(stream) *strm; /* pointer back to this zlib stream */ - int status; /* as the name implies */ unsigned char *pending_buf; /* output still pending */ - unsigned long pending_buf_size; /* size of pending_buf */ unsigned char *pending_out; /* next pending byte to output to the stream */ + uint32_t pending_buf_size; /* size of pending_buf */ uint32_t pending; /* nb of bytes in the pending buffer */ int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ - PREFIX(gz_headerp) gzhead; /* gzip header information to write */ uint32_t gzindex; /* where in extra, name, or comment */ - unsigned char method; /* can only be DEFLATED */ + PREFIX(gz_headerp) gzhead; /* gzip header information to write */ + int status; /* as the name implies */ int last_flush; /* value of flush param for previous deflate call */ + int reproducible; /* Whether reproducible compression results are required. */ -#ifdef X86_PCLMULQDQ_CRC - unsigned crc0[4 * 5]; -#endif + int block_open; + /* Whether or not a block is currently open for the QUICK deflation scheme. + * This is set to 1 if there is an active block, or 0 if the block was just closed. + */ /* used by deflate.c: */ unsigned int w_size; /* LZ77 window size (32K by default) */ unsigned int w_bits; /* log2(w_size) (8..16) */ unsigned int w_mask; /* w_size - 1 */ + unsigned int lookahead; /* number of valid bytes ahead in window */ + + unsigned int high_water; + /* High water mark offset in window for initialized bytes -- bytes above + * this are set to zero in order to avoid memory check warnings when + * longest match routines access bytes past the input. This is then + * updated to the new high water mark. + */ + + unsigned int window_size; + /* Actual size of window: 2*wSize, except when the user input buffer + * is directly used as sliding window. + */ unsigned char *window; /* Sliding window. Input bytes are read into the second half of the window, @@ -136,44 +147,24 @@ typedef struct internal_state { * To do: use the user input buffer as sliding window. */ - unsigned long window_size; - /* Actual size of window: 2*wSize, except when the user input buffer - * is directly used as sliding window. - */ - Pos *prev; /* Link to older string with same hash index. To limit the size of this * array to 64K, this link is maintained only for the last 32K strings. * An index in this array is thus a window index modulo 32K. */ - Pos *head; /* Heads of the hash chains or NIL. */ + Pos *head; /* Heads of the hash chains or 0. */ - unsigned int ins_h; /* hash index of string to be inserted */ - unsigned int hash_size; /* number of elements in hash table */ - unsigned int hash_bits; /* log2(hash_size) */ - unsigned int hash_mask; /* hash_size-1 */ - - #if !defined(__x86_64__) && !defined(_M_X64) && !defined(__i386) && !defined(_M_IX86) - unsigned int hash_shift; - #endif - /* Number of bits by which ins_h must be shifted at each input - * step. It must be such that after MIN_MATCH steps, the oldest - * byte no longer takes part in the hash key, that is: - * hash_shift * MIN_MATCH >= hash_bits - */ - - long block_start; + int block_start; /* Window position at the beginning of the current output block. Gets * negative when the window is moved backwards. */ unsigned int match_length; /* length of best match */ - IPos prev_match; /* previous match */ + Pos prev_match; /* previous match */ int match_available; /* set if previous match exists */ unsigned int strstart; /* start of string to insert */ unsigned int match_start; /* start of matching string */ - unsigned int lookahead; /* number of valid bytes ahead in window */ unsigned int prev_length; /* Length of the best match at previous step. Matches not greater than this @@ -181,15 +172,13 @@ typedef struct internal_state { */ unsigned int max_chain_length; - /* To speed up deflation, hash chains are never searched beyond this - * length. A higher limit improves compression ratio but degrades the - * speed. + /* To speed up deflation, hash chains are never searched beyond this length. + * A higher limit improves compression ratio but degrades the speed. */ unsigned int max_lazy_match; - /* Attempt to find a better match only when the current match is strictly - * smaller than this value. This mechanism is used only for compression - * levels >= 4. + /* Attempt to find a better match only when the current match is strictly smaller + * than this value. This mechanism is used only for compression levels >= 4. */ # define max_insert_length max_lazy_match /* Insert new strings in the hash table only if the match length is not @@ -205,6 +194,11 @@ typedef struct internal_state { int nice_match; /* Stop searching when current match exceeds this */ +#if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86) + /* Only used if X86_PCLMULQDQ_CRC is defined */ + unsigned crc0[4 * 5]; +#endif + /* used by trees.c: */ /* Didn't use ct_data typedef below to suppress compiler warning */ struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ @@ -229,8 +223,6 @@ typedef struct internal_state { /* Depth of each subtree used as tie breaker for trees of equal frequency */ - unsigned char *sym_buf; /* buffer for distances and literals/lengths */ - unsigned int lit_bufsize; /* Size of match buffer for literals/lengths. There are 4 reasons for * limiting lit_bufsize to 64K: @@ -251,41 +243,31 @@ typedef struct internal_state { * - I can't count above 4 */ - unsigned int sym_next; /* running index in sym_buf */ - unsigned int sym_end; /* symbol table full when sym_next reaches this */ + unsigned char *sym_buf; /* buffer for distances and literals/lengths */ + unsigned int sym_next; /* running index in sym_buf */ + unsigned int sym_end; /* symbol table full when sym_next reaches this */ unsigned long opt_len; /* bit length of current block with optimal trees */ unsigned long static_len; /* bit length of current block with static trees */ unsigned int matches; /* number of string matches in current block */ unsigned int insert; /* bytes at end of window left to insert */ -#ifdef ZLIB_DEBUG + /* compressed_len and bits_sent are only used if ZLIB_DEBUG is defined */ unsigned long compressed_len; /* total bit length of compressed file mod 2^32 */ unsigned long bits_sent; /* bit length of compressed data sent mod 2^32 */ -#endif - uint16_t bi_buf; - /* Output buffer. bits are inserted starting at the bottom (least - * significant bits). - */ - int bi_valid; - /* Number of valid bits in bi_buf. All bits above the last valid bit - * are always zero. - */ + /* Reserved for future use and alignment purposes */ + char *reserved_p; - unsigned long high_water; - /* High water mark offset in window for initialized bytes -- bytes above - * this are set to zero in order to avoid memory check warnings when - * longest match routines access bytes past the input. This is then - * updated to the new high water mark. - */ - int block_open; - /* Whether or not a block is currently open for the QUICK deflation scheme. - * This is set to 1 if there is an active block, or 0 if the block was just - * closed. - */ + uint64_t bi_buf; + /* Output buffer. bits are inserted starting at the bottom (least significant bits). */ -} deflate_state; + int32_t bi_valid; + /* Number of valid bits in bi_buf. All bits above the last valid bit are always zero. */ + + /* Reserved for future use and alignment purposes */ + int32_t reserved[11]; +} ALIGNED_(8) deflate_state; typedef enum { need_more, /* block not completed, need more input or more output */ @@ -297,18 +279,88 @@ typedef enum { /* Output a byte on the stream. * IN assertion: there is enough room in pending_buf. */ -#define put_byte(s, c) {s->pending_buf[s->pending++] = (unsigned char)(c);} +#define put_byte(s, c) { \ + s->pending_buf[s->pending++] = (unsigned char)(c); \ +} /* =========================================================================== * Output a short LSB first on the stream. - * IN assertion: there is enough room in pendingBuf. + * IN assertion: there is enough room in pending_buf. */ static inline void put_short(deflate_state *s, uint16_t w) { -#if BYTE_ORDER == BIG_ENDIAN - w = ZSWAP16(w); +#if defined(UNALIGNED_OK) + *(uint16_t *)(&s->pending_buf[s->pending]) = w; + s->pending += 2; +#else + put_byte(s, (w & 0xff)); + put_byte(s, ((w >> 8) & 0xff)); +#endif +} + +/* =========================================================================== + * Output a short MSB first on the stream. + * IN assertion: there is enough room in pending_buf. + */ +static inline void put_short_msb(deflate_state *s, uint16_t w) { + put_byte(s, ((w >> 8) & 0xff)); + put_byte(s, (w & 0xff)); +} + +/* =========================================================================== + * Output a 32-bit unsigned int LSB first on the stream. + * IN assertion: there is enough room in pending_buf. + */ +static inline void put_uint32(deflate_state *s, uint32_t dw) { +#if defined(UNALIGNED_OK) + *(uint32_t *)(&s->pending_buf[s->pending]) = dw; + s->pending += 4; +#else + put_byte(s, (dw & 0xff)); + put_byte(s, ((dw >> 8) & 0xff)); + put_byte(s, ((dw >> 16) & 0xff)); + put_byte(s, ((dw >> 24) & 0xff)); +#endif +} + +/* =========================================================================== + * Output a 32-bit unsigned int MSB first on the stream. + * IN assertion: there is enough room in pending_buf. + */ +static inline void put_uint32_msb(deflate_state *s, uint32_t dw) { +#if defined(UNALIGNED_OK) + *(uint32_t *)(&s->pending_buf[s->pending]) = ZSWAP32(dw); + s->pending += 4; +#else + put_byte(s, ((dw >> 24) & 0xff)); + put_byte(s, ((dw >> 16) & 0xff)); + put_byte(s, ((dw >> 8) & 0xff)); + put_byte(s, (dw & 0xff)); +#endif +} + +/* =========================================================================== + * Output a 64-bit unsigned int LSB first on the stream. + * IN assertion: there is enough room in pending_buf. + */ +static inline void put_uint64(deflate_state *s, uint64_t lld) { +#if defined(UNALIGNED64_OK) + *(uint64_t *)(&s->pending_buf[s->pending]) = lld; + s->pending += 8; +#elif defined(UNALIGNED_OK) + *(uint32_t *)(&s->pending_buf[s->pending]) = lld & 0xffffffff; + s->pending += 4; + *(uint32_t *)(&s->pending_buf[s->pending]) = (lld >> 32) & 0xffffffff; + s->pending += 4; +#else + put_byte(s, (lld & 0xff)); + put_byte(s, ((lld >> 8) & 0xff)); + put_byte(s, ((lld >> 16) & 0xff)); + put_byte(s, ((lld >> 24) & 0xff)); + put_byte(s, ((lld >> 32) & 0xff)); + put_byte(s, ((lld >> 40) & 0xff)); + put_byte(s, ((lld >> 48) & 0xff)); + put_byte(s, ((lld >> 56) & 0xff)); #endif - memcpy(&(s->pending_buf[s->pending]), &w, sizeof(uint16_t)); - s->pending += 2; } #define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) @@ -326,120 +378,34 @@ static inline void put_short(deflate_state *s, uint16_t w) { memory checker errors from longest match routines */ -void ZLIB_INTERNAL fill_window_c(deflate_state *s); +void Z_INTERNAL fill_window(deflate_state *s); +void Z_INTERNAL slide_hash_c(deflate_state *s); /* in trees.c */ -void ZLIB_INTERNAL _tr_init(deflate_state *s); -int ZLIB_INTERNAL _tr_tally(deflate_state *s, unsigned dist, unsigned lc); -void ZLIB_INTERNAL _tr_flush_block(deflate_state *s, char *buf, unsigned long stored_len, int last); -void ZLIB_INTERNAL _tr_flush_bits(deflate_state *s); -void ZLIB_INTERNAL _tr_align(deflate_state *s); -void ZLIB_INTERNAL _tr_stored_block(deflate_state *s, char *buf, unsigned long stored_len, int last); -void ZLIB_INTERNAL bi_windup(deflate_state *s); -unsigned ZLIB_INTERNAL bi_reverse(unsigned code, int len); -void ZLIB_INTERNAL flush_pending(PREFIX3(streamp) strm); - -#define d_code(dist) ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) +void Z_INTERNAL zng_tr_init(deflate_state *s); +void Z_INTERNAL zng_tr_flush_block(deflate_state *s, char *buf, uint32_t stored_len, int last); +void Z_INTERNAL zng_tr_flush_bits(deflate_state *s); +void Z_INTERNAL zng_tr_align(deflate_state *s); +void Z_INTERNAL zng_tr_stored_block(deflate_state *s, char *buf, uint32_t stored_len, int last); +unsigned Z_INTERNAL bi_reverse(unsigned code, int len); +void Z_INTERNAL flush_pending(PREFIX3(streamp) strm); +#define d_code(dist) ((dist) < 256 ? zng_dist_code[dist] : zng_dist_code[256+((dist)>>7)]) /* Mapping from a distance to a distance code. dist is the distance - 1 and - * must not have side effects. _dist_code[256] and _dist_code[257] are never + * must not have side effects. zng_dist_code[256] and zng_dist_code[257] are never * used. */ -#ifndef ZLIB_DEBUG -/* Inline versions of _tr_tally for speed: */ - -# if defined(GEN_TREES_H) - extern unsigned char ZLIB_INTERNAL _length_code[]; - extern unsigned char ZLIB_INTERNAL _dist_code[]; -# else - extern const unsigned char ZLIB_INTERNAL _length_code[]; - extern const unsigned char ZLIB_INTERNAL _dist_code[]; -# endif - -# define _tr_tally_lit(s, c, flush) \ - { unsigned char cc = (c); \ - s->sym_buf[s->sym_next++] = 0; \ - s->sym_buf[s->sym_next++] = 0; \ - s->sym_buf[s->sym_next++] = cc; \ - s->dyn_ltree[cc].Freq++; \ - flush = (s->sym_next == s->sym_end); \ - } -# define _tr_tally_dist(s, distance, length, flush) \ - { unsigned char len = (unsigned char)(length); \ - uint16_t dist = (uint16_t)(distance); \ - s->sym_buf[s->sym_next++] = dist; \ - s->sym_buf[s->sym_next++] = dist >> 8; \ - s->sym_buf[s->sym_next++] = len; \ - dist--; \ - s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ - s->dyn_dtree[d_code(dist)].Freq++; \ - flush = (s->sym_next == s->sym_end); \ - } -#else -# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) -# define _tr_tally_dist(s, distance, length, flush) \ - flush = _tr_tally(s, (unsigned)(distance), (unsigned)(length)) -#endif - -/* =========================================================================== - * Update a hash value with the given input byte - * IN assertion: all calls to to UPDATE_HASH are made with consecutive - * input characters, so that a running hash key can be computed from the - * previous key instead of complete recalculation each time. - */ - -#ifdef NOT_TWEAK_COMPILER -#define TRIGGER_LEVEL 6 -#else -#define TRIGGER_LEVEL 5 -#endif - -#if defined(__x86_64__) || defined(_M_X64) || defined(__i386) || defined(_M_IX86) -#define UPDATE_HASH(s, h, i) \ - do {\ - if (s->level < TRIGGER_LEVEL) \ - h = (3483 * (s->window[i]) +\ - 23081* (s->window[i+1]) +\ - 6954 * (s->window[i+2]) +\ - 20947* (s->window[i+3])) & s->hash_mask;\ - else\ - h = (25881* (s->window[i]) +\ - 24674* (s->window[i+1]) +\ - 25811* (s->window[i+2])) & s->hash_mask;\ - } while (0) -#else -# define UPDATE_HASH(s, h, i) (h = (((h) << s->hash_shift) ^ (s->window[i + (MIN_MATCH-1)])) & s->hash_mask) -#endif - -#ifndef ZLIB_DEBUG -# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len) -/* Send a code of the given tree. c and tree must not have side effects */ - -#else /* ZLIB_DEBUG */ -# define send_code(s, c, tree) \ - { if (z_verbose > 2) { \ - fprintf(stderr, "\ncd %3d ", (c)); \ - } \ - send_bits(s, tree[c].Code, tree[c].Len); \ - } -#endif - +/* Bit buffer and compress bits calculation debugging */ #ifdef ZLIB_DEBUG -void send_bits(deflate_state *s, int value, int length); +# define cmpr_bits_add(s, len) s->compressed_len += (len) +# define cmpr_bits_align(s) s->compressed_len = (s->compressed_len + 7) & ~7L +# define sent_bits_add(s, bits) s->bits_sent += (bits) +# define sent_bits_align(s) s->bits_sent = (s->bits_sent + 7) & ~7L #else -#define send_bits(s, value, length) \ -{ int len = length;\ - if (s->bi_valid > (int)Buf_size - len) {\ - int val = (int)value;\ - s->bi_buf |= (uint16_t)val << s->bi_valid;\ - put_short(s, s->bi_buf);\ - s->bi_buf = (uint16_t)val >> (Buf_size - s->bi_valid);\ - s->bi_valid += len - Buf_size;\ - } else {\ - s->bi_buf |= (uint16_t)(value) << s->bi_valid;\ - s->bi_valid += len;\ - }\ -} +# define cmpr_bits_add(s, len) (void)(len) +# define cmpr_bits_align(s) +# define sent_bits_add(s, bits) (void)(bits) +# define sent_bits_align(s) #endif #endif /* DEFLATE_H_ */ diff --git a/libs/zlibng/deflate_fast.c b/libs/zlibng/deflate_fast.c index 07f29f396..14718ba14 100644 --- a/libs/zlibng/deflate_fast.c +++ b/libs/zlibng/deflate_fast.c @@ -7,7 +7,6 @@ #include "zbuild.h" #include "deflate.h" #include "deflate_p.h" -#include "match_p.h" #include "functable.h" /* =========================================================================== @@ -17,9 +16,11 @@ * new strings in the dictionary only for unmatched strings or for short * matches. It is used only for the fast compression options. */ -ZLIB_INTERNAL block_state deflate_fast(deflate_state *s, int flush) { - IPos hash_head; /* head of the hash chain */ - int bflush; /* set if current block must be flushed */ +Z_INTERNAL block_state deflate_fast(deflate_state *s, int flush) { + Pos hash_head; /* head of the hash chain */ + int bflush = 0; /* set if current block must be flushed */ + int64_t dist; + uint32_t match_len = 0; for (;;) { /* Make sure that we always have enough lookahead, except @@ -28,93 +29,78 @@ ZLIB_INTERNAL block_state deflate_fast(deflate_state *s, int flush) { * string following the next match. */ if (s->lookahead < MIN_LOOKAHEAD) { - functable.fill_window(s); - if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { + fill_window(s); + if (UNLIKELY(s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH)) { return need_more; } - if (s->lookahead == 0) + if (UNLIKELY(s->lookahead == 0)) break; /* flush the current block */ } /* Insert the string window[strstart .. strstart+2] in the * dictionary, and set hash_head to the head of the hash chain: */ - hash_head = NIL; if (s->lookahead >= MIN_MATCH) { - hash_head = functable.insert_string(s, s->strstart, 1); - } + hash_head = functable.quick_insert_string(s, s->strstart); + dist = (int64_t)s->strstart - hash_head; - /* Find the longest match, discarding those <= prev_length. - * At this point we have always match_length < MIN_MATCH - */ - if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) { - /* To simplify the code, we prevent matches with the string - * of window index 0 (in particular we have to avoid a match - * of the string with itself at the start of the input file). + /* Find the longest match, discarding those <= prev_length. + * At this point we have always match length < MIN_MATCH */ - s->match_length = longest_match(s, hash_head); - /* longest_match() sets match_start */ + + if (dist <= MAX_DIST(s) && dist > 0) { + /* To simplify the code, we prevent matches with the string + * of window index 0 (in particular we have to avoid a match + * of the string with itself at the start of the input file). + */ + match_len = functable.longest_match(s, hash_head); + /* longest_match() sets match_start */ + } } - if (s->match_length >= MIN_MATCH) { - check_match(s, s->strstart, s->match_start, s->match_length); - _tr_tally_dist(s, s->strstart - s->match_start, s->match_length - MIN_MATCH, bflush); + if (match_len >= MIN_MATCH) { + check_match(s, s->strstart, s->match_start, match_len); - s->lookahead -= s->match_length; + bflush = zng_tr_tally_dist(s, s->strstart - s->match_start, match_len - MIN_MATCH); + + s->lookahead -= match_len; /* Insert new strings in the hash table only if the match length * is not too large. This saves time but degrades compression. */ - if (s->match_length <= s->max_insert_length && s->lookahead >= MIN_MATCH) { - s->match_length--; /* string at strstart already in table */ + if (match_len <= s->max_insert_length && s->lookahead >= MIN_MATCH) { + match_len--; /* string at strstart already in table */ s->strstart++; -#ifdef NOT_TWEAK_COMPILER - do { - functable.insert_string(s, s->strstart, 1); - s->strstart++; - /* strstart never exceeds WSIZE-MAX_MATCH, so there are - * always MIN_MATCH bytes ahead. - */ - } while (--s->match_length != 0); -#else - { - functable.insert_string(s, s->strstart, s->match_length); - s->strstart += s->match_length; - s->match_length = 0; - } -#endif + + functable.insert_string(s, s->strstart, match_len); + s->strstart += match_len; } else { - s->strstart += s->match_length; - s->match_length = 0; - s->ins_h = s->window[s->strstart]; -#ifndef NOT_TWEAK_COMPILER + s->strstart += match_len; +#if MIN_MATCH != 3 functable.insert_string(s, s->strstart + 2 - MIN_MATCH, MIN_MATCH - 2); #else - functable.insert_string(s, s->strstart + 2 - MIN_MATCH, 1); -#if MIN_MATCH != 3 -#warning Call insert_string() MIN_MATCH-3 more times -#endif + functable.quick_insert_string(s, s->strstart + 2 - MIN_MATCH); #endif /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not * matter since it will be recomputed at next deflate call. */ } + match_len = 0; } else { /* No match, output a literal byte */ - Tracevv((stderr, "%c", s->window[s->strstart])); - _tr_tally_lit(s, s->window[s->strstart], bflush); + bflush = zng_tr_tally_lit(s, s->window[s->strstart]); s->lookahead--; s->strstart++; } - if (bflush) + if (UNLIKELY(bflush)) FLUSH_BLOCK(s, 0); } s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; - if (flush == Z_FINISH) { + if (UNLIKELY(flush == Z_FINISH)) { FLUSH_BLOCK(s, 1); return finish_done; } - if (s->sym_next) + if (UNLIKELY(s->sym_next)) FLUSH_BLOCK(s, 0); return block_done; } diff --git a/libs/zlibng/deflate_medium.c b/libs/zlibng/deflate_medium.c index 330d255c8..dad550cd1 100644 --- a/libs/zlibng/deflate_medium.c +++ b/libs/zlibng/deflate_medium.c @@ -7,72 +7,50 @@ * For conditions of distribution and use, see copyright notice in zlib.h */ #ifndef NO_MEDIUM_STRATEGY +#include #include "zbuild.h" #include "deflate.h" #include "deflate_p.h" -#include "match_p.h" #include "functable.h" struct match { - unsigned int match_start; - unsigned int match_length; - unsigned int strstart; - unsigned int orgstart; + uint16_t match_start; + uint16_t match_length; + uint16_t strstart; + uint16_t orgstart; }; -#define MAX_DIST2 ((1 << MAX_WBITS) - MIN_LOOKAHEAD) - -static int tr_tally_dist(deflate_state *s, int distance, int length) { - return _tr_tally(s, distance, length); -} - -static int tr_tally_lit(deflate_state *s, int c) { - return _tr_tally(s, 0, c); -} - static int emit_match(deflate_state *s, struct match match) { - int flush = 0; + int bflush = 0; /* matches that are not long enough we need to emit as literals */ if (match.match_length < MIN_MATCH) { while (match.match_length) { - flush += tr_tally_lit(s, s->window[match.strstart]); + bflush += zng_tr_tally_lit(s, s->window[match.strstart]); s->lookahead--; match.strstart++; match.match_length--; } - return flush; + return bflush; } check_match(s, match.strstart, match.match_start, match.match_length); - flush += tr_tally_dist(s, match.strstart - match.match_start, match.match_length - MIN_MATCH); + bflush += zng_tr_tally_dist(s, match.strstart - match.match_start, match.match_length - MIN_MATCH); s->lookahead -= match.match_length; - return flush; + return bflush; } static void insert_match(deflate_state *s, struct match match) { - if (unlikely(s->lookahead <= match.match_length + MIN_MATCH)) + if (UNLIKELY(s->lookahead <= (unsigned int)(match.match_length + MIN_MATCH))) return; /* matches that are not long enough we need to emit as literals */ - if (match.match_length < MIN_MATCH) { -#ifdef NOT_TWEAK_COMPILER - while (match.match_length) { - match.strstart++; - match.match_length--; - - if (match.match_length) { - if (match.strstart >= match.orgstart) { - functable.insert_string(s, match.strstart, 1); - } - } - } -#else + if (LIKELY(match.match_length < MIN_MATCH)) { match.strstart++; match.match_length--; - if (match.match_length > 0) { + if (UNLIKELY(match.match_length > 0)) { if (match.strstart >= match.orgstart) { if (match.strstart + match.match_length - 1 >= match.orgstart) { functable.insert_string(s, match.strstart, match.match_length); @@ -83,7 +61,6 @@ static void insert_match(deflate_state *s, struct match match) { match.match_length = 0; } } -#endif return; } @@ -93,48 +70,35 @@ static void insert_match(deflate_state *s, struct match match) { if (match.match_length <= 16* s->max_insert_length && s->lookahead >= MIN_MATCH) { match.match_length--; /* string at strstart already in table */ match.strstart++; -#ifdef NOT_TWEAK_COMPILER - do { - if (likely(match.strstart >= match.orgstart)) { - functable.insert_string(s, match.strstart, 1); - } - match.strstart++; - /* strstart never exceeds WSIZE-MAX_MATCH, so there are - * always MIN_MATCH bytes ahead. - */ - } while (--match.match_length != 0); -#else - if (likely(match.strstart >= match.orgstart)) { - if (likely(match.strstart + match.match_length - 1 >= match.orgstart)) { + + if (LIKELY(match.strstart >= match.orgstart)) { + if (LIKELY(match.strstart + match.match_length - 1 >= match.orgstart)) { functable.insert_string(s, match.strstart, match.match_length); } else { functable.insert_string(s, match.strstart, match.orgstart - match.strstart + 1); } + } else if (match.orgstart < match.strstart + match.match_length) { + functable.insert_string(s, match.orgstart, match.strstart + match.match_length - match.orgstart); } match.strstart += match.match_length; match.match_length = 0; -#endif } else { match.strstart += match.match_length; match.match_length = 0; - s->ins_h = s->window[match.strstart]; if (match.strstart >= (MIN_MATCH - 2)) -#ifndef NOT_TWEAK_COMPILER +#if MIN_MATCH != 3 functable.insert_string(s, match.strstart + 2 - MIN_MATCH, MIN_MATCH - 2); #else - functable.insert_string(s, match.strstart + 2 - MIN_MATCH, 1); -#if MIN_MATCH != 3 -#warning Call insert_string() MIN_MATCH-3 more times + functable.quick_insert_string(s, match.strstart + 2 - MIN_MATCH); #endif -#endif - /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not - * matter since it will be recomputed at next deflate call. - */ + /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not + * matter since it will be recomputed at next deflate call. + */ } } static void fizzle_matches(deflate_state *s, struct match *current, struct match *next) { - IPos limit; + Pos limit; unsigned char *match, *orig; int changed = 0; struct match c, n; @@ -143,36 +107,36 @@ static void fizzle_matches(deflate_state *s, struct match *current, struct match if (current->match_length <= 1) return; - if (unlikely(current->match_length > 1 + next->match_start)) + if (UNLIKELY(current->match_length > 1 + next->match_start)) return; - if (unlikely(current->match_length > 1 + next->strstart)) + if (UNLIKELY(current->match_length > 1 + next->strstart)) return; match = s->window - current->match_length + 1 + next->match_start; orig = s->window - current->match_length + 1 + next->strstart; /* quick exit check.. if this fails then don't bother with anything else */ - if (likely(*match != *orig)) + if (LIKELY(*match != *orig)) return; c = *current; n = *next; /* step one: try to move the "next" match to the left as much as possible */ - limit = next->strstart > MAX_DIST2 ? next->strstart - MAX_DIST2 : 0; + limit = next->strstart > MAX_DIST(s) ? next->strstart - (Pos)MAX_DIST(s) : 0; match = s->window + n.match_start - 1; orig = s->window + n.strstart - 1; while (*match == *orig) { - if (c.match_length < 1) + if (UNLIKELY(c.match_length < 1)) break; - if (n.strstart <= limit) + if (UNLIKELY(n.strstart <= limit)) break; - if (n.match_length >= 256) + if (UNLIKELY(n.match_length >= 256)) break; - if (n.match_start <= 1) + if (UNLIKELY(n.match_start <= 1)) break; n.strstart--; @@ -196,15 +160,18 @@ static void fizzle_matches(deflate_state *s, struct match *current, struct match } } -ZLIB_INTERNAL block_state deflate_medium(deflate_state *s, int flush) { - struct match current_match, next_match; +Z_INTERNAL block_state deflate_medium(deflate_state *s, int flush) { + /* Align the first struct to start on a new cacheline, this allows us to fit both structs in one cacheline */ + ALIGNED_(16) struct match current_match; + struct match next_match; memset(¤t_match, 0, sizeof(struct match)); memset(&next_match, 0, sizeof(struct match)); for (;;) { - IPos hash_head = 0; /* head of the hash chain */ - int bflush; /* set if current block must be flushed */ + Pos hash_head = 0; /* head of the hash chain */ + int bflush = 0; /* set if current block must be flushed */ + int64_t dist; /* Make sure that we always have enough lookahead, except * at the end of the input file. We need MAX_MATCH bytes @@ -212,15 +179,14 @@ ZLIB_INTERNAL block_state deflate_medium(deflate_state *s, int flush) { * string following the next current_match. */ if (s->lookahead < MIN_LOOKAHEAD) { - functable.fill_window(s); + fill_window(s); if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { return need_more; } - if (s->lookahead == 0) + if (UNLIKELY(s->lookahead == 0)) break; /* flush the current block */ next_match.match_length = 0; } - s->prev_length = 2; /* Insert the string window[strstart .. strstart+2] in the * dictionary, and set hash_head to the head of the hash chain: @@ -230,63 +196,63 @@ ZLIB_INTERNAL block_state deflate_medium(deflate_state *s, int flush) { if (next_match.match_length > 0) { current_match = next_match; next_match.match_length = 0; - } else { hash_head = 0; if (s->lookahead >= MIN_MATCH) { - hash_head = functable.insert_string(s, s->strstart, 1); + hash_head = functable.quick_insert_string(s, s->strstart); } - /* set up the initial match to be a 1 byte literal */ - current_match.match_start = 0; - current_match.match_length = 1; - current_match.strstart = s->strstart; + current_match.strstart = (uint16_t)s->strstart; current_match.orgstart = current_match.strstart; /* Find the longest match, discarding those <= prev_length. * At this point we have always match_length < MIN_MATCH */ - if (hash_head != 0 && s->strstart - hash_head <= MAX_DIST2) { + dist = (int64_t)s->strstart - hash_head; + if (dist <= MAX_DIST(s) && dist > 0) { /* To simplify the code, we prevent matches with the string * of window index 0 (in particular we have to avoid a match * of the string with itself at the start of the input file). */ - current_match.match_length = longest_match(s, hash_head); - current_match.match_start = s->match_start; - if (current_match.match_length < MIN_MATCH) + current_match.match_length = (uint16_t)functable.longest_match(s, hash_head); + current_match.match_start = (uint16_t)s->match_start; + if (UNLIKELY(current_match.match_length < MIN_MATCH)) current_match.match_length = 1; - if (current_match.match_start >= current_match.strstart) { + if (UNLIKELY(current_match.match_start >= current_match.strstart)) { /* this can happen due to some restarts */ current_match.match_length = 1; } + } else { + /* Set up the match to be a 1 byte literal */ + current_match.match_start = 0; + current_match.match_length = 1; } } insert_match(s, current_match); /* now, look ahead one */ - if (s->lookahead > MIN_LOOKAHEAD && (current_match.strstart + current_match.match_length) < (s->window_size - MIN_LOOKAHEAD)) { + if (LIKELY(s->lookahead > MIN_LOOKAHEAD && (uint32_t)(current_match.strstart + current_match.match_length) < (s->window_size - MIN_LOOKAHEAD))) { s->strstart = current_match.strstart + current_match.match_length; - hash_head = functable.insert_string(s, s->strstart, 1); + hash_head = functable.quick_insert_string(s, s->strstart); - /* set up the initial match to be a 1 byte literal */ - next_match.match_start = 0; - next_match.match_length = 1; - next_match.strstart = s->strstart; + next_match.strstart = (uint16_t)s->strstart; next_match.orgstart = next_match.strstart; /* Find the longest match, discarding those <= prev_length. * At this point we have always match_length < MIN_MATCH */ - if (hash_head != 0 && s->strstart - hash_head <= MAX_DIST2) { + + dist = (int64_t)s->strstart - hash_head; + if (dist <= MAX_DIST(s) && dist > 0) { /* To simplify the code, we prevent matches with the string * of window index 0 (in particular we have to avoid a match * of the string with itself at the start of the input file). */ - next_match.match_length = longest_match(s, hash_head); - next_match.match_start = s->match_start; - if (next_match.match_start >= next_match.strstart) { + next_match.match_length = (uint16_t)functable.longest_match(s, hash_head); + next_match.match_start = (uint16_t)s->match_start; + if (UNLIKELY(next_match.match_start >= next_match.strstart)) { /* this can happen due to some restarts */ next_match.match_length = 1; } @@ -294,13 +260,13 @@ ZLIB_INTERNAL block_state deflate_medium(deflate_state *s, int flush) { next_match.match_length = 1; else fizzle_matches(s, ¤t_match, &next_match); + } else { + /* Set up the match to be a 1 byte literal */ + next_match.match_start = 0; + next_match.match_length = 1; } - /* short matches with a very long distance are rarely a good idea encoding wise */ - if (next_match.match_length == 3 && (next_match.strstart - next_match.match_start) > 12000) - next_match.match_length = 1; s->strstart = current_match.strstart; - } else { next_match.match_length = 0; } @@ -311,7 +277,7 @@ ZLIB_INTERNAL block_state deflate_medium(deflate_state *s, int flush) { /* move the "cursor" forward */ s->strstart += current_match.match_length; - if (bflush) + if (UNLIKELY(bflush)) FLUSH_BLOCK(s, 0); } s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; @@ -319,7 +285,7 @@ ZLIB_INTERNAL block_state deflate_medium(deflate_state *s, int flush) { FLUSH_BLOCK(s, 1); return finish_done; } - if (s->sym_next) + if (UNLIKELY(s->sym_next)) FLUSH_BLOCK(s, 0); return block_done; diff --git a/libs/zlibng/deflate_p.h b/libs/zlibng/deflate_p.h index 69a7c82a0..102a4de06 100644 --- a/libs/zlibng/deflate_p.h +++ b/libs/zlibng/deflate_p.h @@ -12,39 +12,45 @@ /* Forward declare common non-inlined functions declared in deflate.c */ #ifdef ZLIB_DEBUG -void check_match(deflate_state *s, IPos start, IPos match, int length); +void check_match(deflate_state *s, Pos start, Pos match, int length); #else #define check_match(s, start, match, length) #endif void flush_pending(PREFIX3(stream) *strm); /* =========================================================================== - * Insert string str in the dictionary and set match_head to the previous head - * of the hash chain (the most recent string with same hash key). Return - * the previous length of the hash chain. - * IN assertion: all calls to to INSERT_STRING are made with consecutive - * input characters and the first MIN_MATCH bytes of str are valid - * (except for the last MIN_MATCH-1 bytes of the input file). + * Save the match info and tally the frequency counts. Return true if + * the current block must be flushed. */ -static inline Pos insert_string_c(deflate_state *const s, const Pos str, unsigned int count) { - Pos ret = 0; - unsigned int idx; +extern const unsigned char Z_INTERNAL zng_length_code[]; +extern const unsigned char Z_INTERNAL zng_dist_code[]; - for (idx = 0; idx < count; idx++) { - UPDATE_HASH(s, s->ins_h, str+idx); +static inline int zng_tr_tally_lit(deflate_state *s, unsigned char c) { + /* c is the unmatched char */ + s->sym_buf[s->sym_next++] = 0; + s->sym_buf[s->sym_next++] = 0; + s->sym_buf[s->sym_next++] = c; + s->dyn_ltree[c].Freq++; + Tracevv((stderr, "%c", c)); + Assert(c <= (MAX_MATCH-MIN_MATCH), "zng_tr_tally: bad literal"); + return (s->sym_next == s->sym_end); +} - Pos head = s->head[s->ins_h]; - if (head != str+idx) { - s->prev[(str+idx) & s->w_mask] = head; - s->head[s->ins_h] = str+idx; - if (idx == count - 1) - ret = head; - } else if (idx == count - 1) { - ret = str + idx; - } - } - return ret; +static inline int zng_tr_tally_dist(deflate_state *s, uint32_t dist, uint32_t len) { + /* dist: distance of matched string */ + /* len: match length-MIN_MATCH */ + s->sym_buf[s->sym_next++] = (uint8_t)(dist); + s->sym_buf[s->sym_next++] = (uint8_t)(dist >> 8); + s->sym_buf[s->sym_next++] = (uint8_t)len; + s->matches++; + dist--; + Assert(dist < MAX_DIST(s) && (uint16_t)d_code(dist) < (uint16_t)D_CODES, + "zng_tr_tally: bad match"); + + s->dyn_ltree[zng_length_code[len]+LITERALS+1].Freq++; + s->dyn_dtree[d_code(dist)].Freq++; + return (s->sym_next == s->sym_end); } /* =========================================================================== @@ -52,14 +58,13 @@ static inline Pos insert_string_c(deflate_state *const s, const Pos str, unsigne * IN assertion: strstart is set to the end of the current match. */ #define FLUSH_BLOCK_ONLY(s, last) { \ - _tr_flush_block(s, (s->block_start >= 0L ? \ + zng_tr_flush_block(s, (s->block_start >= 0 ? \ (char *)&s->window[(unsigned)s->block_start] : \ NULL), \ - (unsigned long)((long)s->strstart - s->block_start), \ + (uint32_t)((int)s->strstart - s->block_start), \ (last)); \ - s->block_start = s->strstart; \ + s->block_start = (int)s->strstart; \ flush_pending(s->strm); \ - Tracev((stderr, "[FLUSH]")); \ } /* Same but force premature exit if necessary. */ diff --git a/libs/zlibng/deflate_quick.c b/libs/zlibng/deflate_quick.c new file mode 100644 index 000000000..268cce80d --- /dev/null +++ b/libs/zlibng/deflate_quick.c @@ -0,0 +1,121 @@ +/* + * The deflate_quick deflate strategy, designed to be used when cycles are + * at a premium. + * + * Copyright (C) 2013 Intel Corporation. All rights reserved. + * Authors: + * Wajdi Feghali + * Jim Guilford + * Vinodh Gopal + * Erdinc Ozturk + * Jim Kukunas + * + * Portions are Copyright (C) 2016 12Sided Technology, LLC. + * Author: + * Phil Vachon + * + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "zbuild.h" +#include "deflate.h" +#include "deflate_p.h" +#include "functable.h" +#include "trees_emit.h" + +extern const ct_data static_ltree[L_CODES+2]; +extern const ct_data static_dtree[D_CODES]; + +#define QUICK_START_BLOCK(s, last) { \ + zng_tr_emit_tree(s, STATIC_TREES, last); \ + s->block_open = 1 + (int)last; \ + s->block_start = (int)s->strstart; \ +} + +#define QUICK_END_BLOCK(s, last) { \ + if (s->block_open) { \ + zng_tr_emit_end_block(s, static_ltree, last); \ + s->block_open = 0; \ + s->block_start = (int)s->strstart; \ + flush_pending(s->strm); \ + if (s->strm->avail_out == 0) \ + return (last) ? finish_started : need_more; \ + } \ +} + +Z_INTERNAL block_state deflate_quick(deflate_state *s, int flush) { + Pos hash_head; + int64_t dist; + unsigned match_len, last; + + + last = (flush == Z_FINISH) ? 1 : 0; + if (UNLIKELY(last && s->block_open != 2)) { + /* Emit end of previous block */ + QUICK_END_BLOCK(s, 0); + /* Emit start of last block */ + QUICK_START_BLOCK(s, last); + } else if (UNLIKELY(s->block_open == 0 && s->lookahead > 0)) { + /* Start new block only when we have lookahead data, so that if no + input data is given an empty block will not be written */ + QUICK_START_BLOCK(s, last); + } + + for (;;) { + if (UNLIKELY(s->pending + ((BIT_BUF_SIZE + 7) >> 3) >= s->pending_buf_size)) { + flush_pending(s->strm); + if (s->strm->avail_out == 0) { + return (last && s->strm->avail_in == 0) ? finish_started : need_more; + } + } + + if (UNLIKELY(s->lookahead < MIN_LOOKAHEAD)) { + fill_window(s); + if (UNLIKELY(s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH)) { + return need_more; + } + if (UNLIKELY(s->lookahead == 0)) + break; + + if (UNLIKELY(s->block_open == 0)) { + /* Start new block when we have lookahead data, so that if no + input data is given an empty block will not be written */ + QUICK_START_BLOCK(s, last); + } + } + + if (LIKELY(s->lookahead >= MIN_MATCH)) { + hash_head = functable.quick_insert_string(s, s->strstart); + dist = (int64_t)s->strstart - hash_head; + + if (dist <= MAX_DIST(s) && dist > 0) { + match_len = functable.compare258(s->window + s->strstart, s->window + hash_head); + + if (match_len >= MIN_MATCH) { + if (UNLIKELY(match_len > s->lookahead)) + match_len = s->lookahead; + + check_match(s, s->strstart, hash_head, match_len); + + zng_tr_emit_dist(s, static_ltree, static_dtree, match_len - MIN_MATCH, (uint32_t)dist); + s->lookahead -= match_len; + s->strstart += match_len; + continue; + } + } + } + + zng_tr_emit_lit(s, static_ltree, s->window[s->strstart]); + s->strstart++; + s->lookahead--; + } + + s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; + if (UNLIKELY(last)) { + QUICK_END_BLOCK(s, 1); + return finish_done; + } + + QUICK_END_BLOCK(s, 0); + return block_done; +} diff --git a/libs/zlibng/deflate_slow.c b/libs/zlibng/deflate_slow.c index f4c8af769..cac8a9629 100644 --- a/libs/zlibng/deflate_slow.c +++ b/libs/zlibng/deflate_slow.c @@ -7,26 +7,18 @@ #include "zbuild.h" #include "deflate.h" #include "deflate_p.h" -#include "match_p.h" #include "functable.h" -/* =========================================================================== - * Local data - */ - -#ifndef TOO_FAR -# define TOO_FAR 4096 -#endif -/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */ - /* =========================================================================== * Same as deflate_medium, but achieves better compression. We use a lazy * evaluation for matches: a match is finally adopted only if there is * no better match at the next window position. */ -ZLIB_INTERNAL block_state deflate_slow(deflate_state *s, int flush) { - IPos hash_head; /* head of hash chain */ +Z_INTERNAL block_state deflate_slow(deflate_state *s, int flush) { + Pos hash_head; /* head of hash chain */ int bflush; /* set if current block must be flushed */ + int64_t dist; + uint32_t match_len; /* Process the input block. */ for (;;) { @@ -36,57 +28,53 @@ ZLIB_INTERNAL block_state deflate_slow(deflate_state *s, int flush) { * string following the next match. */ if (s->lookahead < MIN_LOOKAHEAD) { - functable.fill_window(s); - if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { + fill_window(s); + if (UNLIKELY(s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH)) { return need_more; } - if (s->lookahead == 0) + if (UNLIKELY(s->lookahead == 0)) break; /* flush the current block */ } /* Insert the string window[strstart .. strstart+2] in the * dictionary, and set hash_head to the head of the hash chain: */ - hash_head = NIL; - if (s->lookahead >= MIN_MATCH) { - hash_head = functable.insert_string(s, s->strstart, 1); + hash_head = 0; + if (LIKELY(s->lookahead >= MIN_MATCH)) { + hash_head = functable.quick_insert_string(s, s->strstart); } /* Find the longest match, discarding those <= prev_length. */ - s->prev_length = s->match_length, s->prev_match = s->match_start; - s->match_length = MIN_MATCH-1; + s->prev_match = (Pos)s->match_start; + match_len = MIN_MATCH-1; + dist = (int64_t)s->strstart - hash_head; - if (hash_head != NIL && s->prev_length < s->max_lazy_match && s->strstart - hash_head <= MAX_DIST(s)) { + if (dist <= MAX_DIST(s) && dist > 0 && s->prev_length < s->max_lazy_match) { /* To simplify the code, we prevent matches with the string * of window index 0 (in particular we have to avoid a match * of the string with itself at the start of the input file). */ - s->match_length = longest_match(s, hash_head); + match_len = functable.longest_match(s, hash_head); /* longest_match() sets match_start */ - if (s->match_length <= 5 && (s->strategy == Z_FILTERED -#if TOO_FAR <= 32767 - || (s->match_length == MIN_MATCH && s->strstart - s->match_start > TOO_FAR) -#endif - )) { - + if (match_len <= 5 && (s->strategy == Z_FILTERED)) { /* If prev_match is also MIN_MATCH, match_start is garbage * but we will ignore the current match anyway. */ - s->match_length = MIN_MATCH-1; + match_len = MIN_MATCH-1; } } /* If there was a match at the previous step and the current * match is not better, output the previous match: */ - if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) { + if (s->prev_length >= MIN_MATCH && match_len <= s->prev_length) { unsigned int max_insert = s->strstart + s->lookahead - MIN_MATCH; /* Do not insert strings in hash table beyond this. */ check_match(s, s->strstart-1, s->prev_match, s->prev_length); - _tr_tally_dist(s, s->strstart -1 - s->prev_match, s->prev_length - MIN_MATCH, bflush); + bflush = zng_tr_tally_dist(s, s->strstart -1 - s->prev_match, s->prev_length - MIN_MATCH); /* Insert in hash table all strings up to the end of the match. * strstart-1 and strstart are already inserted. If there is not @@ -95,70 +83,55 @@ ZLIB_INTERNAL block_state deflate_slow(deflate_state *s, int flush) { */ s->lookahead -= s->prev_length-1; -#ifdef NOT_TWEAK_COMPILER - s->prev_length -= 2; - do { - if (++s->strstart <= max_insert) { - functable.insert_string(s, s->strstart, 1); - } - } while (--s->prev_length != 0); - s->match_available = 0; - s->match_length = MIN_MATCH-1; - s->strstart++; -#else - { - unsigned int mov_fwd = s->prev_length - 2; - if (max_insert > s->strstart) { - unsigned int insert_cnt = mov_fwd; - if (unlikely(insert_cnt > max_insert - s->strstart)) - insert_cnt = max_insert - s->strstart; + unsigned int mov_fwd = s->prev_length - 2; + if (max_insert > s->strstart) { + unsigned int insert_cnt = mov_fwd; + if (UNLIKELY(insert_cnt > max_insert - s->strstart)) + insert_cnt = max_insert - s->strstart; - functable.insert_string(s, s->strstart + 1, insert_cnt); - } - s->prev_length = 0; - s->match_available = 0; - s->match_length = MIN_MATCH-1; - s->strstart += mov_fwd + 1; + functable.insert_string(s, s->strstart + 1, insert_cnt); } -#endif /*NOT_TWEAK_COMPILER*/ + s->prev_length = 0; + s->match_available = 0; + s->strstart += mov_fwd + 1; - if (bflush) FLUSH_BLOCK(s, 0); + if (UNLIKELY(bflush)) + FLUSH_BLOCK(s, 0); } else if (s->match_available) { /* If there was no match at the previous position, output a * single literal. If there was a match but the current match * is longer, truncate the previous match to a single literal. */ - Tracevv((stderr, "%c", s->window[s->strstart-1])); - _tr_tally_lit(s, s->window[s->strstart-1], bflush); - if (bflush) { + bflush = zng_tr_tally_lit(s, s->window[s->strstart-1]); + if (UNLIKELY(bflush)) FLUSH_BLOCK_ONLY(s, 0); - } + s->prev_length = match_len; s->strstart++; s->lookahead--; - if (s->strm->avail_out == 0) + if (UNLIKELY(s->strm->avail_out == 0)) return need_more; } else { /* There is no previous match to compare with, wait for * the next step to decide. */ + s->prev_length = match_len; s->match_available = 1; s->strstart++; s->lookahead--; } } Assert(flush != Z_NO_FLUSH, "no flush?"); - if (s->match_available) { - Tracevv((stderr, "%c", s->window[s->strstart-1])); - _tr_tally_lit(s, s->window[s->strstart-1], bflush); + if (UNLIKELY(s->match_available)) { + (void) zng_tr_tally_lit(s, s->window[s->strstart-1]); s->match_available = 0; } s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; - if (flush == Z_FINISH) { + if (UNLIKELY(flush == Z_FINISH)) { FLUSH_BLOCK(s, 1); return finish_done; } - if (s->sym_next) + if (UNLIKELY(s->sym_next)) FLUSH_BLOCK(s, 0); return block_done; } diff --git a/libs/zlibng/fallback_builtins.h b/libs/zlibng/fallback_builtins.h new file mode 100644 index 000000000..314ad3267 --- /dev/null +++ b/libs/zlibng/fallback_builtins.h @@ -0,0 +1,44 @@ +#ifndef X86_BUILTIN_CTZ_H +#define X86_BUILTIN_CTZ_H + +#if defined(_MSC_VER) && !defined(__clang__) +#if defined(_M_IX86) || defined(_M_AMD64) || defined(_M_IA64) || defined(_M_ARM) || defined(_M_ARM64) + +#include +#ifdef X86_FEATURES +# include "arch/x86/x86.h" +#endif + +/* This is not a general purpose replacement for __builtin_ctz. The function expects that value is != 0 + * Because of that assumption trailing_zero is not initialized and the return value of _BitScanForward is not checked + */ +static __forceinline unsigned long __builtin_ctz(uint32_t value) { +#ifdef X86_FEATURES + if (x86_cpu_has_tzcnt) + return _tzcnt_u32(value); +#endif + unsigned long trailing_zero; + _BitScanForward(&trailing_zero, value); + return trailing_zero; +} +#define HAVE_BUILTIN_CTZ + +#ifdef _M_AMD64 +/* This is not a general purpose replacement for __builtin_ctzll. The function expects that value is != 0 + * Because of that assumption trailing_zero is not initialized and the return value of _BitScanForward64 is not checked + */ +static __forceinline unsigned long long __builtin_ctzll(uint64_t value) { +#ifdef X86_FEATURES + if (x86_cpu_has_tzcnt) + return _tzcnt_u64(value); +#endif + unsigned long trailing_zero; + _BitScanForward64(&trailing_zero, value); + return trailing_zero; +} +#define HAVE_BUILTIN_CTZLL +#endif + +#endif +#endif +#endif diff --git a/libs/zlibng/functable.c b/libs/zlibng/functable.c index 108509798..acae44641 100644 --- a/libs/zlibng/functable.c +++ b/libs/zlibng/functable.c @@ -4,40 +4,95 @@ */ #include "zbuild.h" -#include "functable.h" +#include "zendian.h" #include "deflate.h" #include "deflate_p.h" -#include "gzendian.h" +#include "functable.h" -/* insert_string */ -#ifdef X86_SSE4_2_CRC_HASH -extern Pos insert_string_sse(deflate_state *const s, const Pos str, unsigned int count); -#elif defined(ARM_ACLE_CRC_HASH) -extern Pos insert_string_acle(deflate_state *const s, const Pos str, unsigned int count); +#ifdef X86_FEATURES +# include "fallback_builtins.h" #endif -/* fill_window */ +/* insert_string */ +extern void insert_string_c(deflate_state *const s, const uint32_t str, uint32_t count); +#ifdef X86_SSE42_CRC_HASH +extern void insert_string_sse4(deflate_state *const s, const uint32_t str, uint32_t count); +#elif defined(ARM_ACLE_CRC_HASH) +extern void insert_string_acle(deflate_state *const s, const uint32_t str, uint32_t count); +#endif + +/* quick_insert_string */ +extern Pos quick_insert_string_c(deflate_state *const s, const uint32_t str); +#ifdef X86_SSE42_CRC_HASH +extern Pos quick_insert_string_sse4(deflate_state *const s, const uint32_t str); +#elif defined(ARM_ACLE_CRC_HASH) +extern Pos quick_insert_string_acle(deflate_state *const s, const uint32_t str); +#endif + +/* slide_hash */ #ifdef X86_SSE2 -extern void fill_window_sse(deflate_state *s); -#elif defined(__arm__) || defined(__aarch64__) || defined(_M_ARM) -extern void fill_window_arm(deflate_state *s); +void slide_hash_sse2(deflate_state *s); +#elif defined(ARM_NEON_SLIDEHASH) +void slide_hash_neon(deflate_state *s); +#elif defined(POWER8_VSX_SLIDEHASH) +void slide_hash_power8(deflate_state *s); +#endif +#ifdef X86_AVX2 +void slide_hash_avx2(deflate_state *s); #endif /* adler32 */ extern uint32_t adler32_c(uint32_t adler, const unsigned char *buf, size_t len); -#if (defined(__ARM_NEON__) || defined(__ARM_NEON)) && defined(ARM_NEON_ADLER32) +#ifdef ARM_NEON_ADLER32 extern uint32_t adler32_neon(uint32_t adler, const unsigned char *buf, size_t len); #endif - -ZLIB_INTERNAL uint32_t crc32_generic(uint32_t, const unsigned char *, uint64_t); - -#ifdef DYNAMIC_CRC_TABLE -extern volatile int crc_table_empty; -extern void make_crc_table(void); +#ifdef X86_SSSE3_ADLER32 +extern uint32_t adler32_ssse3(uint32_t adler, const unsigned char *buf, size_t len); +#endif +#ifdef X86_AVX2_ADLER32 +extern uint32_t adler32_avx2(uint32_t adler, const unsigned char *buf, size_t len); +#endif +#ifdef POWER8_VSX_ADLER32 +extern uint32_t adler32_power8(uint32_t adler, const unsigned char* buf, size_t len); #endif -#ifdef __ARM_FEATURE_CRC32 +/* memory chunking */ +extern uint32_t chunksize_c(void); +extern uint8_t* chunkcopy_c(uint8_t *out, uint8_t const *from, unsigned len); +extern uint8_t* chunkcopy_safe_c(uint8_t *out, uint8_t const *from, unsigned len, uint8_t *safe); +extern uint8_t* chunkunroll_c(uint8_t *out, unsigned *dist, unsigned *len); +extern uint8_t* chunkmemset_c(uint8_t *out, unsigned dist, unsigned len); +extern uint8_t* chunkmemset_safe_c(uint8_t *out, unsigned dist, unsigned len, unsigned left); +#ifdef X86_SSE2_CHUNKSET +extern uint32_t chunksize_sse2(void); +extern uint8_t* chunkcopy_sse2(uint8_t *out, uint8_t const *from, unsigned len); +extern uint8_t* chunkcopy_safe_sse2(uint8_t *out, uint8_t const *from, unsigned len, uint8_t *safe); +extern uint8_t* chunkunroll_sse2(uint8_t *out, unsigned *dist, unsigned *len); +extern uint8_t* chunkmemset_sse2(uint8_t *out, unsigned dist, unsigned len); +extern uint8_t* chunkmemset_safe_sse2(uint8_t *out, unsigned dist, unsigned len, unsigned left); +#endif +#ifdef X86_AVX_CHUNKSET +extern uint32_t chunksize_avx(void); +extern uint8_t* chunkcopy_avx(uint8_t *out, uint8_t const *from, unsigned len); +extern uint8_t* chunkcopy_safe_avx(uint8_t *out, uint8_t const *from, unsigned len, uint8_t *safe); +extern uint8_t* chunkunroll_avx(uint8_t *out, unsigned *dist, unsigned *len); +extern uint8_t* chunkmemset_avx(uint8_t *out, unsigned dist, unsigned len); +extern uint8_t* chunkmemset_safe_avx(uint8_t *out, unsigned dist, unsigned len, unsigned left); +#endif +#ifdef ARM_NEON_CHUNKSET +extern uint32_t chunksize_neon(void); +extern uint8_t* chunkcopy_neon(uint8_t *out, uint8_t const *from, unsigned len); +extern uint8_t* chunkcopy_safe_neon(uint8_t *out, uint8_t const *from, unsigned len, uint8_t *safe); +extern uint8_t* chunkunroll_neon(uint8_t *out, unsigned *dist, unsigned *len); +extern uint8_t* chunkmemset_neon(uint8_t *out, unsigned dist, unsigned len); +extern uint8_t* chunkmemset_safe_neon(uint8_t *out, unsigned dist, unsigned len, unsigned left); +#endif + +/* CRC32 */ +Z_INTERNAL uint32_t crc32_generic(uint32_t, const unsigned char *, uint64_t); + +#ifdef ARM_ACLE_CRC_HASH extern uint32_t crc32_acle(uint32_t, const unsigned char *, uint64_t); #endif @@ -47,87 +102,365 @@ extern uint32_t crc32_little(uint32_t, const unsigned char *, uint64_t); extern uint32_t crc32_big(uint32_t, const unsigned char *, uint64_t); #endif -/* stub definitions */ -ZLIB_INTERNAL Pos insert_string_stub(deflate_state *const s, const Pos str, unsigned int count); -ZLIB_INTERNAL void fill_window_stub(deflate_state *s); -ZLIB_INTERNAL uint32_t adler32_stub(uint32_t adler, const unsigned char *buf, size_t len); -ZLIB_INTERNAL uint32_t crc32_stub(uint32_t crc, const unsigned char *buf, uint64_t len); +/* compare258 */ +extern uint32_t compare258_c(const unsigned char *src0, const unsigned char *src1); +#ifdef UNALIGNED_OK +extern uint32_t compare258_unaligned_16(const unsigned char *src0, const unsigned char *src1); +extern uint32_t compare258_unaligned_32(const unsigned char *src0, const unsigned char *src1); +#ifdef UNALIGNED64_OK +extern uint32_t compare258_unaligned_64(const unsigned char *src0, const unsigned char *src1); +#endif +#ifdef X86_SSE42_CMP_STR +extern uint32_t compare258_unaligned_sse4(const unsigned char *src0, const unsigned char *src1); +#endif +#if defined(X86_AVX2) && defined(HAVE_BUILTIN_CTZ) +extern uint32_t compare258_unaligned_avx2(const unsigned char *src0, const unsigned char *src1); +#endif +#endif -/* functable init */ -ZLIB_INTERNAL __thread struct functable_s functable = {fill_window_stub,insert_string_stub,adler32_stub,crc32_stub}; +/* longest_match */ +extern uint32_t longest_match_c(deflate_state *const s, Pos cur_match); +#ifdef UNALIGNED_OK +extern uint32_t longest_match_unaligned_16(deflate_state *const s, Pos cur_match); +extern uint32_t longest_match_unaligned_32(deflate_state *const s, Pos cur_match); +#ifdef UNALIGNED64_OK +extern uint32_t longest_match_unaligned_64(deflate_state *const s, Pos cur_match); +#endif +#ifdef X86_SSE42_CMP_STR +extern uint32_t longest_match_unaligned_sse4(deflate_state *const s, Pos cur_match); +#endif +#if defined(X86_AVX2) && defined(HAVE_BUILTIN_CTZ) +extern uint32_t longest_match_unaligned_avx2(deflate_state *const s, Pos cur_match); +#endif +#endif +Z_INTERNAL Z_TLS struct functable_s functable; + +Z_INTERNAL void cpu_check_features(void) +{ + static int features_checked = 0; + if (features_checked) + return; +#if defined(X86_FEATURES) + x86_check_features(); +#elif defined(ARM_FEATURES) + arm_check_features(); +#elif defined(POWER_FEATURES) + power_check_features(); +#endif + features_checked = 1; +} /* stub functions */ -ZLIB_INTERNAL Pos insert_string_stub(deflate_state *const s, const Pos str, unsigned int count) { +Z_INTERNAL void insert_string_stub(deflate_state *const s, const uint32_t str, uint32_t count) { // Initialize default - functable.insert_string=&insert_string_c; - #ifdef X86_SSE4_2_CRC_HASH + functable.insert_string = &insert_string_c; + cpu_check_features(); + +#ifdef X86_SSE42_CRC_HASH if (x86_cpu_has_sse42) - functable.insert_string=&insert_string_sse; - #elif defined(__ARM_FEATURE_CRC32) && defined(ARM_ACLE_CRC_HASH) + functable.insert_string = &insert_string_sse4; +#elif defined(ARM_ACLE_CRC_HASH) if (arm_cpu_has_crc32) - functable.insert_string=&insert_string_acle; - #endif + functable.insert_string = &insert_string_acle; +#endif - return functable.insert_string(s, str, count); + functable.insert_string(s, str, count); } -ZLIB_INTERNAL void fill_window_stub(deflate_state *s) { - // Initialize default - functable.fill_window=&fill_window_c; +Z_INTERNAL Pos quick_insert_string_stub(deflate_state *const s, const uint32_t str) { + functable.quick_insert_string = &quick_insert_string_c; - #ifdef X86_SSE2 - # if !defined(__x86_64__) && !defined(_M_X64) && !defined(X86_NOCHECK_SSE2) +#ifdef X86_SSE42_CRC_HASH + if (x86_cpu_has_sse42) + functable.quick_insert_string = &quick_insert_string_sse4; +#elif defined(ARM_ACLE_CRC_HASH) + if (arm_cpu_has_crc32) + functable.quick_insert_string = &quick_insert_string_acle; +#endif + + return functable.quick_insert_string(s, str); +} + +Z_INTERNAL void slide_hash_stub(deflate_state *s) { + + functable.slide_hash = &slide_hash_c; + cpu_check_features(); + +#ifdef X86_SSE2 +# if !defined(__x86_64__) && !defined(_M_X64) && !defined(X86_NOCHECK_SSE2) if (x86_cpu_has_sse2) - # endif - functable.fill_window=&fill_window_sse; - #elif defined(__arm__) || defined(__aarch64__) || defined(_M_ARM) - functable.fill_window=&fill_window_arm; - #endif +# endif + functable.slide_hash = &slide_hash_sse2; +#elif defined(ARM_NEON_SLIDEHASH) +# ifndef ARM_NOCHECK_NEON + if (arm_cpu_has_neon) +# endif + functable.slide_hash = &slide_hash_neon; +#endif +#ifdef X86_AVX2 + if (x86_cpu_has_avx2) + functable.slide_hash = &slide_hash_avx2; +#endif +#ifdef POWER8_VSX_SLIDEHASH + if (power_cpu_has_arch_2_07) + functable.slide_hash = &slide_hash_power8; +#endif - functable.fill_window(s); + functable.slide_hash(s); } -ZLIB_INTERNAL uint32_t adler32_stub(uint32_t adler, const unsigned char *buf, size_t len) { +Z_INTERNAL uint32_t adler32_stub(uint32_t adler, const unsigned char *buf, size_t len) { // Initialize default - functable.adler32=&adler32_c; + functable.adler32 = &adler32_c; + cpu_check_features(); - #if (defined(__ARM_NEON__) || defined(__ARM_NEON)) && defined(ARM_NEON_ADLER32) +#ifdef ARM_NEON_ADLER32 +# ifndef ARM_NOCHECK_NEON if (arm_cpu_has_neon) - functable.adler32=&adler32_neon; - #endif +# endif + functable.adler32 = &adler32_neon; +#endif +#ifdef X86_SSSE3_ADLER32 + if (x86_cpu_has_ssse3) + functable.adler32 = &adler32_ssse3; +#endif +#ifdef X86_AVX2_ADLER32 + if (x86_cpu_has_avx2) + functable.adler32 = &adler32_avx2; +#endif +#ifdef POWER8_VSX_ADLER32 + if (power_cpu_has_arch_2_07) + functable.adler32 = &adler32_power8; +#endif return functable.adler32(adler, buf, len); } -ZLIB_INTERNAL uint32_t crc32_stub(uint32_t crc, const unsigned char *buf, uint64_t len) { +Z_INTERNAL uint32_t chunksize_stub(void) { + // Initialize default + functable.chunksize = &chunksize_c; +#ifdef X86_SSE2_CHUNKSET +# if !defined(__x86_64__) && !defined(_M_X64) && !defined(X86_NOCHECK_SSE2) + if (x86_cpu_has_sse2) +# endif + functable.chunksize = &chunksize_sse2; +#endif +#ifdef X86_AVX_CHUNKSET + if (x86_cpu_has_avx2) + functable.chunksize = &chunksize_avx; +#endif +#ifdef ARM_NEON_CHUNKSET + if (arm_cpu_has_neon) + functable.chunksize = &chunksize_neon; +#endif - Assert(sizeof(uint64_t) >= sizeof(size_t), - "crc32_z takes size_t but internally we have a uint64_t len"); -/* return a function pointer for optimized arches here after a capability test */ + return functable.chunksize(); +} -#ifdef DYNAMIC_CRC_TABLE - if (crc_table_empty) - make_crc_table(); -#endif /* DYNAMIC_CRC_TABLE */ +Z_INTERNAL uint8_t* chunkcopy_stub(uint8_t *out, uint8_t const *from, unsigned len) { + // Initialize default + functable.chunkcopy = &chunkcopy_c; - if (sizeof(void *) == sizeof(ptrdiff_t)) { +#ifdef X86_SSE2_CHUNKSET +# if !defined(__x86_64__) && !defined(_M_X64) && !defined(X86_NOCHECK_SSE2) + if (x86_cpu_has_sse2) +# endif + functable.chunkcopy = &chunkcopy_sse2; +#endif +#ifdef X86_AVX_CHUNKSET + if (x86_cpu_has_avx2) + functable.chunkcopy = &chunkcopy_avx; +#endif +#ifdef ARM_NEON_CHUNKSET + if (arm_cpu_has_neon) + functable.chunkcopy = &chunkcopy_neon; +#endif + + return functable.chunkcopy(out, from, len); +} + +Z_INTERNAL uint8_t* chunkcopy_safe_stub(uint8_t *out, uint8_t const *from, unsigned len, uint8_t *safe) { + // Initialize default + functable.chunkcopy_safe = &chunkcopy_safe_c; + +#ifdef X86_SSE2_CHUNKSET +# if !defined(__x86_64__) && !defined(_M_X64) && !defined(X86_NOCHECK_SSE2) + if (x86_cpu_has_sse2) +# endif + functable.chunkcopy_safe = &chunkcopy_safe_sse2; +#endif +#ifdef X86_AVX_CHUNKSET + if (x86_cpu_has_avx2) + functable.chunkcopy_safe = &chunkcopy_safe_avx; +#endif +#ifdef ARM_NEON_CHUNKSET + if (arm_cpu_has_neon) + functable.chunkcopy_safe = &chunkcopy_safe_neon; +#endif + + return functable.chunkcopy_safe(out, from, len, safe); +} + +Z_INTERNAL uint8_t* chunkunroll_stub(uint8_t *out, unsigned *dist, unsigned *len) { + // Initialize default + functable.chunkunroll = &chunkunroll_c; + +#ifdef X86_SSE2_CHUNKSET +# if !defined(__x86_64__) && !defined(_M_X64) && !defined(X86_NOCHECK_SSE2) + if (x86_cpu_has_sse2) +# endif + functable.chunkunroll = &chunkunroll_sse2; +#endif +#ifdef X86_AVX_CHUNKSET + if (x86_cpu_has_avx2) + functable.chunkunroll = &chunkunroll_avx; +#endif +#ifdef ARM_NEON_CHUNKSET + if (arm_cpu_has_neon) + functable.chunkunroll = &chunkunroll_neon; +#endif + + return functable.chunkunroll(out, dist, len); +} + +Z_INTERNAL uint8_t* chunkmemset_stub(uint8_t *out, unsigned dist, unsigned len) { + // Initialize default + functable.chunkmemset = &chunkmemset_c; + +#ifdef X86_SSE2_CHUNKSET +# if !defined(__x86_64__) && !defined(_M_X64) && !defined(X86_NOCHECK_SSE2) + if (x86_cpu_has_sse2) +# endif + functable.chunkmemset = &chunkmemset_sse2; +#endif +#ifdef X86_AVX_CHUNKSET + if (x86_cpu_has_avx2) + functable.chunkmemset = &chunkmemset_avx; +#endif +#ifdef ARM_NEON_CHUNKSET + if (arm_cpu_has_neon) + functable.chunkmemset = &chunkmemset_neon; +#endif + + return functable.chunkmemset(out, dist, len); +} + +Z_INTERNAL uint8_t* chunkmemset_safe_stub(uint8_t *out, unsigned dist, unsigned len, unsigned left) { + // Initialize default + functable.chunkmemset_safe = &chunkmemset_safe_c; + +#ifdef X86_SSE2_CHUNKSET +# if !defined(__x86_64__) && !defined(_M_X64) && !defined(X86_NOCHECK_SSE2) + if (x86_cpu_has_sse2) +# endif + functable.chunkmemset_safe = &chunkmemset_safe_sse2; +#endif +#ifdef X86_AVX_CHUNKSET + if (x86_cpu_has_avx2) + functable.chunkmemset_safe = &chunkmemset_safe_avx; +#endif +#ifdef ARM_NEON_CHUNKSET + if (arm_cpu_has_neon) + functable.chunkmemset_safe = &chunkmemset_safe_neon; +#endif + + return functable.chunkmemset_safe(out, dist, len, left); +} + +Z_INTERNAL uint32_t crc32_stub(uint32_t crc, const unsigned char *buf, uint64_t len) { + int32_t use_byfour = sizeof(void *) == sizeof(ptrdiff_t); + + Assert(sizeof(uint64_t) >= sizeof(size_t), + "crc32_z takes size_t but internally we have a uint64_t len"); + /* return a function pointer for optimized arches here after a capability test */ + + cpu_check_features(); + + if (use_byfour) { #if BYTE_ORDER == LITTLE_ENDIAN - functable.crc32=crc32_little; -# if defined(__ARM_FEATURE_CRC32) && defined(ARM_ACLE_CRC_HASH) - if (arm_cpu_has_crc32) - functable.crc32=crc32_acle; + functable.crc32 = crc32_little; +# if defined(ARM_ACLE_CRC_HASH) + if (arm_cpu_has_crc32) + functable.crc32 = crc32_acle; # endif #elif BYTE_ORDER == BIG_ENDIAN - functable.crc32=crc32_big; + functable.crc32 = crc32_big; #else # error No endian defined #endif } else { - functable.crc32=crc32_generic; + functable.crc32 = crc32_generic; } return functable.crc32(crc, buf, len); } + +Z_INTERNAL uint32_t compare258_stub(const unsigned char *src0, const unsigned char *src1) { + + functable.compare258 = &compare258_c; + +#ifdef UNALIGNED_OK +# if defined(UNALIGNED64_OK) && defined(HAVE_BUILTIN_CTZLL) + functable.compare258 = &compare258_unaligned_64; +# elif defined(HAVE_BUILTIN_CTZ) + functable.compare258 = &compare258_unaligned_32; +# else + functable.compare258 = &compare258_unaligned_16; +# endif +# ifdef X86_SSE42_CMP_STR + if (x86_cpu_has_sse42) + functable.compare258 = &compare258_unaligned_sse4; +# endif +# if defined(X86_AVX2) && defined(HAVE_BUILTIN_CTZ) + if (x86_cpu_has_avx2) + functable.compare258 = &compare258_unaligned_avx2; +# endif +#endif + + return functable.compare258(src0, src1); +} + +Z_INTERNAL uint32_t longest_match_stub(deflate_state *const s, Pos cur_match) { + + functable.longest_match = &longest_match_c; + +#ifdef UNALIGNED_OK +# if defined(UNALIGNED64_OK) && defined(HAVE_BUILTIN_CTZLL) + functable.longest_match = &longest_match_unaligned_64; +# elif defined(HAVE_BUILTIN_CTZ) + functable.longest_match = &longest_match_unaligned_32; +# else + functable.longest_match = &longest_match_unaligned_16; +# endif +# ifdef X86_SSE42_CMP_STR + if (x86_cpu_has_sse42) + functable.longest_match = &longest_match_unaligned_sse4; +# endif +# if defined(X86_AVX2) && defined(HAVE_BUILTIN_CTZ) + if (x86_cpu_has_avx2) + functable.longest_match = &longest_match_unaligned_avx2; +# endif +#endif + + return functable.longest_match(s, cur_match); +} + +/* functable init */ +Z_INTERNAL Z_TLS struct functable_s functable = { + insert_string_stub, + quick_insert_string_stub, + adler32_stub, + crc32_stub, + slide_hash_stub, + compare258_stub, + longest_match_stub, + chunksize_stub, + chunkcopy_stub, + chunkcopy_safe_stub, + chunkunroll_stub, + chunkmemset_stub, + chunkmemset_safe_stub +}; diff --git a/libs/zlibng/functable.h b/libs/zlibng/functable.h index 280651c32..276c284a0 100644 --- a/libs/zlibng/functable.h +++ b/libs/zlibng/functable.h @@ -9,13 +9,21 @@ #include "deflate.h" struct functable_s { - void (* fill_window) (deflate_state *s); - Pos (* insert_string) (deflate_state *const s, const Pos str, unsigned int count); - uint32_t (* adler32) (uint32_t adler, const unsigned char *buf, size_t len); - uint32_t (* crc32) (uint32_t crc, const unsigned char *buf, uint64_t len); + void (* insert_string) (deflate_state *const s, const uint32_t str, uint32_t count); + Pos (* quick_insert_string)(deflate_state *const s, const uint32_t str); + uint32_t (* adler32) (uint32_t adler, const unsigned char *buf, size_t len); + uint32_t (* crc32) (uint32_t crc, const unsigned char *buf, uint64_t len); + void (* slide_hash) (deflate_state *s); + uint32_t (* compare258) (const unsigned char *src0, const unsigned char *src1); + uint32_t (* longest_match) (deflate_state *const s, Pos cur_match); + uint32_t (* chunksize) (void); + uint8_t* (* chunkcopy) (uint8_t *out, uint8_t const *from, unsigned len); + uint8_t* (* chunkcopy_safe) (uint8_t *out, uint8_t const *from, unsigned len, uint8_t *safe); + uint8_t* (* chunkunroll) (uint8_t *out, unsigned *dist, unsigned *len); + uint8_t* (* chunkmemset) (uint8_t *out, unsigned dist, unsigned len); + uint8_t* (* chunkmemset_safe) (uint8_t *out, unsigned dist, unsigned len, unsigned left); }; -ZLIB_INTERNAL extern __thread struct functable_s functable; - +Z_INTERNAL extern Z_TLS struct functable_s functable; #endif diff --git a/libs/zlibng/gzclose.c b/libs/zlibng/gzclose.c deleted file mode 100644 index bafb774c8..000000000 --- a/libs/zlibng/gzclose.c +++ /dev/null @@ -1,24 +0,0 @@ -/* gzclose.c -- zlib gzclose() function - * Copyright (C) 2004, 2010 Mark Adler - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -#include "zbuild.h" -#include "gzguts.h" - -/* gzclose() is in a separate file so that it is linked in only if it is used. - That way the other gzclose functions can be used instead to avoid linking in - unneeded compression or decompression routines. */ -int ZEXPORT PREFIX(gzclose)(gzFile file) { -#ifndef NO_GZCOMPRESS - gz_state *state; - - if (file == NULL) - return Z_STREAM_ERROR; - state = (gz_state *)file; - - return state->mode == GZ_READ ? PREFIX(gzclose_r)(file) : PREFIX(gzclose_w)(file); -#else - return PREFIX(gzclose_r)(file); -#endif -} diff --git a/libs/zlibng/gzendian.h b/libs/zlibng/gzendian.h deleted file mode 100644 index 5ee4cd387..000000000 --- a/libs/zlibng/gzendian.h +++ /dev/null @@ -1,60 +0,0 @@ -/* gzendian.h -- define BYTE_ORDER for endian tests - * For conditions of distribution and use, see copyright notice in zlib.h - */ - -#ifndef ENDIAN_H_ -#define ENDIAN_H_ - -/* First check whether the compiler knows the target __BYTE_ORDER__. */ -#if defined(__BYTE_ORDER__) -# if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ -# if !defined(LITTLE_ENDIAN) -# define LITTLE_ENDIAN __ORDER_LITTLE_ENDIAN__ -# endif -# if !defined(BYTE_ORDER) -# define BYTE_ORDER LITTLE_ENDIAN -# endif -# elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -# if !defined(BIG_ENDIAN) -# define BIG_ENDIAN __ORDER_BIG_ENDIAN__ -# endif -# if !defined(BYTE_ORDER) -# define BYTE_ORDER BIG_ENDIAN -# endif -# endif -#elif defined(__MINGW32__) -# include -#elif defined(WIN32) || defined(_WIN32) -# define LITTLE_ENDIAN 1234 -# define BIG_ENDIAN 4321 -# if defined(_M_IX86) || defined(_M_AMD64) || defined(_M_IA64) || defined (_M_ARM) -# define BYTE_ORDER LITTLE_ENDIAN -# else -# error Unknown endianness! -# endif -#elif defined(__linux__) -# include -#elif defined(__APPLE__) || defined(__arm__) || defined(__aarch64__) -# include -#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__DragonFly__) -# include -#elif defined(__sun) || defined(sun) -# include -# if !defined(LITTLE_ENDIAN) -# define LITTLE_ENDIAN 4321 -# endif -# if !defined(BIG_ENDIAN) -# define BIG_ENDIAN 1234 -# endif -# if !defined(BYTE_ORDER) -# if defined(_BIG_ENDIAN) -# define BYTE_ORDER BIG_ENDIAN -# else -# define BYTE_ORDER LITTLE_ENDIAN -# endif -# endif -#else -# include -#endif - -#endif diff --git a/libs/zlibng/gzguts.h b/libs/zlibng/gzguts.h index c2ff7bb96..16029607f 100644 --- a/libs/zlibng/gzguts.h +++ b/libs/zlibng/gzguts.h @@ -14,12 +14,12 @@ # endif #endif -#if defined(HAVE_INTERNAL) -# define ZLIB_INTERNAL __attribute__((visibility ("internal"))) -#elif defined(HAVE_HIDDEN) -# define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) +#if defined(HAVE_VISIBILITY_INTERNAL) +# define Z_INTERNAL __attribute__((visibility ("internal"))) +#elif defined(HAVE_VISIBILITY_HIDDEN) +# define Z_INTERNAL __attribute__((visibility ("hidden"))) #else -# define ZLIB_INTERNAL +# define Z_INTERNAL #endif #include @@ -29,12 +29,12 @@ #include #if defined(ZLIB_COMPAT) -# include "zlib.h" +# include "zlib.h" #else -# include "zlib-ng.h" +# include "zlib-ng.h" #endif -#ifdef WIN32 +#ifdef _WIN32 # include #endif @@ -42,11 +42,8 @@ # include /* for lseek(), read(), close(), write(), unlink() */ #endif -#if defined(_MSC_VER) || defined(WIN32) +#if defined(_WIN32) # include -#endif - -#if defined(_WIN32) || defined(__MINGW__) # define WIDECHAR #endif @@ -58,7 +55,7 @@ #endif /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */ -#if !defined(STDC99) && !defined(__CYGWIN__) && !defined(__MINGW__) && defined(WIN32) +#if !defined(STDC99) && !defined(__CYGWIN__) && !defined(__MINGW__) && defined(_WIN32) # if !defined(vsnprintf) # if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 ) # define vsnprintf _vsnprintf @@ -81,14 +78,6 @@ # define zstrerror() "stdio error (consult errno)" #endif -/* provide prototypes for these when building zlib without LFS */ -#if (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0) && defined(WITH_GZFILEOP) - ZEXTERN gzFile ZEXPORT PREFIX(gzopen64)(const char *, const char *); - ZEXTERN z_off64_t ZEXPORT PREFIX(gzseek64)(gzFile, z_off64_t, int); - ZEXTERN z_off64_t ZEXPORT PREFIX(gztell64)(gzFile); - ZEXTERN z_off64_t ZEXPORT PREFIX(gzoffset64)(gzFile); -#endif - /* default memLevel */ #if MAX_MEM_LEVEL >= 8 # define DEF_MEM_LEVEL 8 @@ -98,10 +87,8 @@ /* default i/o buffer size -- double this for output when reading (this and twice this must be able to fit in an unsigned type) */ -#if defined(S390_DFLTCC_DEFLATE) || defined(S390_DFLTCC_INFLATE) -#define GZBUFSIZE 262144 /* DFLTCC works faster with larger buffers */ -#else -#define GZBUFSIZE 8192 +#ifndef GZBUFSIZE +# define GZBUFSIZE 8192 #endif /* gzip modes, also provide a little integrity check on the passed structure */ @@ -139,6 +126,7 @@ typedef struct { /* just for writing */ int level; /* compression level */ int strategy; /* compression strategy */ + int reset; /* true if a reset is pending after a Z_FINISH */ /* seek request */ z_off64_t skip; /* amount to skip (already rewound if backwards) */ int seek; /* true if seek request pending */ @@ -151,7 +139,7 @@ typedef struct { typedef gz_state *gz_statep; /* shared functions */ -void ZLIB_INTERNAL gz_error(gz_state *, int, const char *); +void Z_INTERNAL gz_error(gz_state *, int, const char *); /* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t value -- needed when comparing unsigned to z_off64_t, which is signed @@ -159,7 +147,7 @@ void ZLIB_INTERNAL gz_error(gz_state *, int, const char *); #ifdef INT_MAX # define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX) #else -unsigned ZLIB_INTERNAL gz_intmax(void); +unsigned Z_INTERNAL gz_intmax(void); # define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax()) #endif diff --git a/libs/zlibng/gzlib.c b/libs/zlibng/gzlib.c index dbf27aa43..490551667 100644 --- a/libs/zlibng/gzlib.c +++ b/libs/zlibng/gzlib.c @@ -4,9 +4,10 @@ */ #include "zbuild.h" +#include "zutil_p.h" #include "gzguts.h" -#if defined(WIN32) && !defined(__BORLANDC__) +#if defined(_WIN32) # define LSEEK _lseeki64 #else #if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0 @@ -28,6 +29,8 @@ static void gz_reset(gz_state *state) { state->past = 0; /* have not read past end yet */ state->how = LOOK; /* look for gzip header */ } + else /* for writing ... */ + state->reset = 0; /* no deflateReset pending */ state->seek = 0; /* no seek request pending */ gz_error(state, Z_OK, NULL); /* clear error */ state->x.pos = 0; /* no uncompressed data yet */ @@ -51,7 +54,7 @@ static gzFile gz_open(const void *path, int fd, const char *mode) { return NULL; /* allocate gzFile structure to return */ - state = (gz_state *)malloc(sizeof(gz_state)); + state = (gz_state *)zng_alloc(sizeof(gz_state)); if (state == NULL) return NULL; state->size = 0; /* no buffers allocated yet */ @@ -80,7 +83,7 @@ static gzFile gz_open(const void *path, int fd, const char *mode) { break; #endif case '+': /* can't read and write at the same time */ - free(state); + zng_free(state); return NULL; case 'b': /* ignore -- will request binary anyway */ break; @@ -118,14 +121,14 @@ static gzFile gz_open(const void *path, int fd, const char *mode) { /* must provide an "r", "w", or "a" */ if (state->mode == GZ_NONE) { - free(state); + zng_free(state); return NULL; } /* can't force transparent read */ if (state->mode == GZ_READ) { if (state->direct) { - free(state); + zng_free(state); return NULL; } state->direct = 1; /* for empty file */ @@ -134,7 +137,7 @@ static gzFile gz_open(const void *path, int fd, const char *mode) { /* save the path name for error messages */ #ifdef WIDECHAR if (fd == -2) { - len = wcstombs(NULL, path, 0); + len = wcstombs(NULL, (const wchar_t *)path, 0); if (len == (size_t)-1) len = 0; } else @@ -142,13 +145,13 @@ static gzFile gz_open(const void *path, int fd, const char *mode) { len = strlen((const char *)path); state->path = (char *)malloc(len + 1); if (state->path == NULL) { - free(state); + zng_free(state); return NULL; } #ifdef WIDECHAR if (fd == -2) if (len) { - wcstombs(state->path, path, len + 1); + wcstombs(state->path, (const wchar_t *)path, len + 1); } else { *(state->path) = 0; } @@ -179,15 +182,15 @@ static gzFile gz_open(const void *path, int fd, const char *mode) { /* open the file with the appropriate flags (or just use fd) */ state->fd = fd > -1 ? fd : ( -#if defined(WIN32) || defined(__MINGW__) - fd == -2 ? _wopen(path, oflag, 0666) : +#if defined(_WIN32) + fd == -2 ? _wopen((const wchar_t *)path, oflag, 0666) : #elif __CYGWIN__ fd == -2 ? open(state->path, oflag, 0666) : #endif open((const char *)path, oflag, 0666)); if (state->fd == -1) { free(state->path); - free(state); + zng_free(state); return NULL; } if (state->mode == GZ_APPEND) { @@ -209,17 +212,18 @@ static gzFile gz_open(const void *path, int fd, const char *mode) { } /* -- see zlib.h -- */ -gzFile ZEXPORT PREFIX(gzopen)(const char *path, const char *mode) { +gzFile Z_EXPORT PREFIX(gzopen)(const char *path, const char *mode) { return gz_open(path, -1, mode); } -/* -- see zlib.h -- */ -gzFile ZEXPORT PREFIX(gzopen64)(const char *path, const char *mode) { +#ifdef ZLIB_COMPAT +gzFile Z_EXPORT PREFIX4(gzopen)(const char *path, const char *mode) { return gz_open(path, -1, mode); } +#endif /* -- see zlib.h -- */ -gzFile ZEXPORT PREFIX(gzdopen)(int fd, const char *mode) { +gzFile Z_EXPORT PREFIX(gzdopen)(int fd, const char *mode) { char *path; /* identifier for error messages */ gzFile gz; @@ -233,13 +237,27 @@ gzFile ZEXPORT PREFIX(gzdopen)(int fd, const char *mode) { /* -- see zlib.h -- */ #ifdef WIDECHAR -gzFile ZEXPORT PREFIX(gzopen_w)(const wchar_t *path, const char *mode) { +gzFile Z_EXPORT PREFIX(gzopen_w)(const wchar_t *path, const char *mode) { return gz_open(path, -2, mode); } #endif +int Z_EXPORT PREFIX(gzclose)(gzFile file) { +#ifndef NO_GZCOMPRESS + gz_state *state; + + if (file == NULL) + return Z_STREAM_ERROR; + state = (gz_state *)file; + + return state->mode == GZ_READ ? PREFIX(gzclose_r)(file) : PREFIX(gzclose_w)(file); +#else + return PREFIX(gzclose_r)(file); +#endif +} + /* -- see zlib.h -- */ -int ZEXPORT PREFIX(gzbuffer)(gzFile file, unsigned size) { +int Z_EXPORT PREFIX(gzbuffer)(gzFile file, unsigned size) { gz_state *state; /* get internal structure and check integrity */ @@ -263,7 +281,7 @@ int ZEXPORT PREFIX(gzbuffer)(gzFile file, unsigned size) { } /* -- see zlib.h -- */ -int ZEXPORT PREFIX(gzrewind)(gzFile file) { +int Z_EXPORT PREFIX(gzrewind)(gzFile file) { gz_state *state; /* get internal structure */ @@ -283,7 +301,7 @@ int ZEXPORT PREFIX(gzrewind)(gzFile file) { } /* -- see zlib.h -- */ -z_off64_t ZEXPORT PREFIX(gzseek64)(gzFile file, z_off64_t offset, int whence) { +z_off64_t Z_EXPORT PREFIX4(gzseek)(gzFile file, z_off64_t offset, int whence) { unsigned n; z_off64_t ret; gz_state *state; @@ -354,15 +372,17 @@ z_off64_t ZEXPORT PREFIX(gzseek64)(gzFile file, z_off64_t offset, int whence) { } /* -- see zlib.h -- */ -z_off_t ZEXPORT PREFIX(gzseek)(gzFile file, z_off_t offset, int whence) { +#ifdef ZLIB_COMPAT +z_off_t Z_EXPORT PREFIX(gzseek)(gzFile file, z_off_t offset, int whence) { z_off64_t ret; - ret = PREFIX(gzseek64)(file, (z_off64_t)offset, whence); + ret = PREFIX4(gzseek)(file, (z_off64_t)offset, whence); return ret == (z_off_t)ret ? (z_off_t)ret : -1; } +#endif /* -- see zlib.h -- */ -z_off64_t ZEXPORT PREFIX(gztell64)(gzFile file) { +z_off64_t Z_EXPORT PREFIX4(gztell)(gzFile file) { gz_state *state; /* get internal structure and check integrity */ @@ -377,15 +397,18 @@ z_off64_t ZEXPORT PREFIX(gztell64)(gzFile file) { } /* -- see zlib.h -- */ -z_off_t ZEXPORT PREFIX(gztell)(gzFile file) { +#ifdef ZLIB_COMPAT +z_off_t Z_EXPORT PREFIX(gztell)(gzFile file) { + z_off64_t ret; - ret = PREFIX(gztell64)(file); + ret = PREFIX4(gztell)(file); return ret == (z_off_t)ret ? (z_off_t)ret : -1; } +#endif /* -- see zlib.h -- */ -z_off64_t ZEXPORT PREFIX(gzoffset64)(gzFile file) { +z_off64_t Z_EXPORT PREFIX4(gzoffset)(gzFile file) { z_off64_t offset; gz_state *state; @@ -406,15 +429,17 @@ z_off64_t ZEXPORT PREFIX(gzoffset64)(gzFile file) { } /* -- see zlib.h -- */ -z_off_t ZEXPORT PREFIX(gzoffset)(gzFile file) { +#ifdef ZLIB_COMPAT +z_off_t Z_EXPORT PREFIX(gzoffset)(gzFile file) { z_off64_t ret; - ret = PREFIX(gzoffset64)(file); + ret = PREFIX4(gzoffset)(file); return ret == (z_off_t)ret ? (z_off_t)ret : -1; } +#endif /* -- see zlib.h -- */ -int ZEXPORT PREFIX(gzeof)(gzFile file) { +int Z_EXPORT PREFIX(gzeof)(gzFile file) { gz_state *state; /* get internal structure and check integrity */ @@ -429,7 +454,7 @@ int ZEXPORT PREFIX(gzeof)(gzFile file) { } /* -- see zlib.h -- */ -const char * ZEXPORT PREFIX(gzerror)(gzFile file, int *errnum) { +const char * Z_EXPORT PREFIX(gzerror)(gzFile file, int *errnum) { gz_state *state; /* get internal structure and check integrity */ @@ -446,7 +471,7 @@ const char * ZEXPORT PREFIX(gzerror)(gzFile file, int *errnum) { } /* -- see zlib.h -- */ -void ZEXPORT PREFIX(gzclearerr)(gzFile file) { +void Z_EXPORT PREFIX(gzclearerr)(gzFile file) { gz_state *state; /* get internal structure and check integrity */ @@ -470,7 +495,7 @@ void ZEXPORT PREFIX(gzclearerr)(gzFile file) { memory). Simply save the error message as a static string. If there is an allocation failure constructing the error message, then convert the error to out of memory. */ -void ZLIB_INTERNAL gz_error(gz_state *state, int err, const char *msg) { +void Z_INTERNAL gz_error(gz_state *state, int err, const char *msg) { /* free previously allocated message and clear */ if (state->msg != NULL) { if (state->err != Z_MEM_ERROR) @@ -504,7 +529,7 @@ void ZLIB_INTERNAL gz_error(gz_state *state, int err, const char *msg) { available) -- we need to do this to cover cases where 2's complement not used, since C standard permits 1's complement and sign-bit representations, otherwise we could just use ((unsigned)-1) >> 1 */ -unsigned ZLIB_INTERNAL gz_intmax() { +unsigned Z_INTERNAL gz_intmax() { unsigned p, q; p = 1; diff --git a/libs/zlibng/gzread.c b/libs/zlibng/gzread.c index e041a3817..c3b3a035f 100644 --- a/libs/zlibng/gzread.c +++ b/libs/zlibng/gzread.c @@ -4,6 +4,7 @@ */ #include "zbuild.h" +#include "zutil_p.h" #include "gzguts.h" /* Local functions */ @@ -83,11 +84,11 @@ static int gz_look(gz_state *state) { /* allocate read buffers and inflate memory */ if (state->size == 0) { /* allocate buffers */ - state->in = (unsigned char *)malloc(state->want); - state->out = (unsigned char *)malloc(state->want << 1); + state->in = (unsigned char *)zng_alloc(state->want); + state->out = (unsigned char *)zng_alloc(state->want << 1); if (state->in == NULL || state->out == NULL) { - free(state->out); - free(state->in); + zng_free(state->out); + zng_free(state->in); gz_error(state, Z_MEM_ERROR, "out of memory"); return -1; } @@ -100,8 +101,8 @@ static int gz_look(gz_state *state) { state->strm.avail_in = 0; state->strm.next_in = NULL; if (PREFIX(inflateInit2)(&(state->strm), 15 + 16) != Z_OK) { /* gunzip */ - free(state->out); - free(state->in); + zng_free(state->out); + zng_free(state->in); state->size = 0; gz_error(state, Z_MEM_ERROR, "out of memory"); return -1; @@ -343,7 +344,7 @@ static size_t gz_read(gz_state *state, void *buf, size_t len) { } /* -- see zlib.h -- */ -int ZEXPORT PREFIX(gzread)(gzFile file, void *buf, unsigned len) { +int Z_EXPORT PREFIX(gzread)(gzFile file, void *buf, unsigned len) { gz_state *state; /* get internal structure */ @@ -375,7 +376,7 @@ int ZEXPORT PREFIX(gzread)(gzFile file, void *buf, unsigned len) { } /* -- see zlib.h -- */ -size_t ZEXPORT PREFIX(gzfread)(void *buf, size_t size, size_t nitems, gzFile file) { +size_t Z_EXPORT PREFIX(gzfread)(void *buf, size_t size, size_t nitems, gzFile file) { size_t len; gz_state *state; @@ -394,11 +395,11 @@ size_t ZEXPORT PREFIX(gzfread)(void *buf, size_t size, size_t nitems, gzFile fil return 0; /* compute bytes to read -- error on overflow */ - len = nitems * size; - if (size && len / size != nitems) { + if (size && SIZE_MAX / size < nitems) { gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t"); return 0; } + len = nitems * size; /* read len or fewer bytes to buf, return the number of full items read */ return len ? gz_read(state, buf, len) / size : 0; @@ -407,7 +408,7 @@ size_t ZEXPORT PREFIX(gzfread)(void *buf, size_t size, size_t nitems, gzFile fil /* -- see zlib.h -- */ #undef gzgetc #undef zng_gzgetc -int ZEXPORT PREFIX(gzgetc)(gzFile file) { +int Z_EXPORT PREFIX(gzgetc)(gzFile file) { unsigned char buf[1]; gz_state *state; @@ -431,12 +432,12 @@ int ZEXPORT PREFIX(gzgetc)(gzFile file) { return gz_read(state, buf, 1) < 1 ? -1 : buf[0]; } -int ZEXPORT PREFIX(gzgetc_)(gzFile file) { +int Z_EXPORT PREFIX(gzgetc_)(gzFile file) { return PREFIX(gzgetc)(file); } /* -- see zlib.h -- */ -int ZEXPORT PREFIX(gzungetc)(int c, gzFile file) { +int Z_EXPORT PREFIX(gzungetc)(int c, gzFile file) { gz_state *state; /* get internal structure */ @@ -492,7 +493,7 @@ int ZEXPORT PREFIX(gzungetc)(int c, gzFile file) { } /* -- see zlib.h -- */ -char * ZEXPORT PREFIX(gzgets)(gzFile file, char *buf, int len) { +char * Z_EXPORT PREFIX(gzgets)(gzFile file, char *buf, int len) { unsigned left, n; char *str; unsigned char *eol; @@ -519,29 +520,31 @@ char * ZEXPORT PREFIX(gzgets)(gzFile file, char *buf, int len) { the contents, let the user worry about that) */ str = buf; left = (unsigned)len - 1; - if (left) do { - /* assure that something is in the output buffer */ - if (state->x.have == 0 && gz_fetch(state) == -1) - return NULL; /* error */ - if (state->x.have == 0) { /* end of file */ - state->past = 1; /* read past end */ - break; /* return what we have */ - } + if (left) { + do { + /* assure that something is in the output buffer */ + if (state->x.have == 0 && gz_fetch(state) == -1) + return NULL; /* error */ + if (state->x.have == 0) { /* end of file */ + state->past = 1; /* read past end */ + break; /* return what we have */ + } - /* look for end-of-line in current output buffer */ - n = state->x.have > left ? left : state->x.have; - eol = (unsigned char *)memchr(state->x.next, '\n', n); - if (eol != NULL) - n = (unsigned)(eol - state->x.next) + 1; + /* look for end-of-line in current output buffer */ + n = state->x.have > left ? left : state->x.have; + eol = (unsigned char *)memchr(state->x.next, '\n', n); + if (eol != NULL) + n = (unsigned)(eol - state->x.next) + 1; - /* copy through end-of-line, or remainder if not found */ - memcpy(buf, state->x.next, n); - state->x.have -= n; - state->x.next += n; - state->x.pos += n; - left -= n; - buf += n; - } while (left && eol == NULL); + /* copy through end-of-line, or remainder if not found */ + memcpy(buf, state->x.next, n); + state->x.have -= n; + state->x.next += n; + state->x.pos += n; + left -= n; + buf += n; + } while (left && eol == NULL); + } /* return terminated string, or if nothing, end of file */ if (buf == str) @@ -551,7 +554,7 @@ char * ZEXPORT PREFIX(gzgets)(gzFile file, char *buf, int len) { } /* -- see zlib.h -- */ -int ZEXPORT PREFIX(gzdirect)(gzFile file) { +int Z_EXPORT PREFIX(gzdirect)(gzFile file) { gz_state *state; /* get internal structure */ @@ -570,7 +573,7 @@ int ZEXPORT PREFIX(gzdirect)(gzFile file) { } /* -- see zlib.h -- */ -int ZEXPORT PREFIX(gzclose_r)(gzFile file) { +int Z_EXPORT PREFIX(gzclose_r)(gzFile file) { int ret, err; gz_state *state; @@ -587,13 +590,13 @@ int ZEXPORT PREFIX(gzclose_r)(gzFile file) { /* free memory and close file */ if (state->size) { PREFIX(inflateEnd)(&(state->strm)); - free(state->out); - free(state->in); + zng_free(state->out); + zng_free(state->in); } err = state->err == Z_BUF_ERROR ? Z_BUF_ERROR : Z_OK; gz_error(state, Z_OK, NULL); free(state->path); ret = close(state->fd); - free(state); + zng_free(state); return ret ? Z_ERRNO : err; } diff --git a/libs/zlibng/gzwrite.c b/libs/zlibng/gzwrite.c index 20e1d5c63..c4e178f9a 100644 --- a/libs/zlibng/gzwrite.c +++ b/libs/zlibng/gzwrite.c @@ -4,6 +4,7 @@ */ #include "zbuild.h" +#include "zutil_p.h" #include #include "gzguts.h" @@ -21,18 +22,19 @@ static int gz_init(gz_state *state) { PREFIX3(stream) *strm = &(state->strm); /* allocate input buffer (double size for gzprintf) */ - state->in = (unsigned char *)malloc(state->want << 1); + state->in = (unsigned char *)zng_alloc(state->want << 1); if (state->in == NULL) { gz_error(state, Z_MEM_ERROR, "out of memory"); return -1; } + memset(state->in, 0, state->want << 1); /* only need output buffer and deflate state if compressing */ if (!state->direct) { /* allocate output buffer */ - state->out = (unsigned char *)malloc(state->want); + state->out = (unsigned char *)zng_alloc(state->want); if (state->out == NULL) { - free(state->in); + zng_free(state->in); gz_error(state, Z_MEM_ERROR, "out of memory"); return -1; } @@ -43,8 +45,8 @@ static int gz_init(gz_state *state) { strm->opaque = NULL; ret = PREFIX(deflateInit2)(strm, state->level, Z_DEFLATED, MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy); if (ret != Z_OK) { - free(state->out); - free(state->in); + zng_free(state->out); + zng_free(state->in); gz_error(state, Z_MEM_ERROR, "out of memory"); return -1; } @@ -90,6 +92,15 @@ static int gz_comp(gz_state *state, int flush) { return 0; } + /* check for a pending reset */ + if (state->reset) { + /* don't start a new gzip member unless there is data to write */ + if (strm->avail_in == 0) + return 0; + PREFIX(deflateReset)(strm); + state->reset = 0; + } + /* run deflate() on provided input until it produces no more output */ ret = Z_OK; do { @@ -121,8 +132,7 @@ static int gz_comp(gz_state *state, int flush) { /* if that completed a deflate stream, allow another to start */ if (flush == Z_FINISH) - PREFIX(deflateReset)(strm); - + state->reset = 1; /* all done, no errors */ return 0; } @@ -203,7 +213,7 @@ static size_t gz_write(gz_state *state, void const *buf, size_t len) { return 0; /* directly compress user buffer to file */ - state->strm.next_in = (const unsigned char *)buf; + state->strm.next_in = (z_const unsigned char *) buf; do { unsigned n = (unsigned)-1; if (n > len) @@ -221,7 +231,7 @@ static size_t gz_write(gz_state *state, void const *buf, size_t len) { } /* -- see zlib.h -- */ -int ZEXPORT PREFIX(gzwrite)(gzFile file, void const *buf, unsigned len) { +int Z_EXPORT PREFIX(gzwrite)(gzFile file, void const *buf, unsigned len) { gz_state *state; /* get internal structure */ @@ -245,7 +255,7 @@ int ZEXPORT PREFIX(gzwrite)(gzFile file, void const *buf, unsigned len) { } /* -- see zlib.h -- */ -size_t ZEXPORT PREFIX(gzfwrite)(void const *buf, size_t size, size_t nitems, gzFile file) { +size_t Z_EXPORT PREFIX(gzfwrite)(void const *buf, size_t size, size_t nitems, gzFile file) { size_t len; gz_state *state; @@ -274,7 +284,7 @@ size_t ZEXPORT PREFIX(gzfwrite)(void const *buf, size_t size, size_t nitems, gzF } /* -- see zlib.h -- */ -int ZEXPORT PREFIX(gzputc)(gzFile file, int c) { +int Z_EXPORT PREFIX(gzputc)(gzFile file, int c) { unsigned have; unsigned char buf[1]; gz_state *state; @@ -319,7 +329,7 @@ int ZEXPORT PREFIX(gzputc)(gzFile file, int c) { } /* -- see zlib.h -- */ -int ZEXPORT PREFIX(gzputs)(gzFile file, const char *s) { +int Z_EXPORT PREFIX(gzputs)(gzFile file, const char *s) { size_t len, put; gz_state *state; @@ -343,7 +353,7 @@ int ZEXPORT PREFIX(gzputs)(gzFile file, const char *s) { } /* -- see zlib.h -- */ -int ZEXPORTVA PREFIX(gzvprintf)(gzFile file, const char *format, va_list va) { +int Z_EXPORTVA PREFIX(gzvprintf)(gzFile file, const char *format, va_list va) { int len; unsigned left; char *next; @@ -399,7 +409,7 @@ int ZEXPORTVA PREFIX(gzvprintf)(gzFile file, const char *format, va_list va) { return len; } -int ZEXPORTVA PREFIX(gzprintf)(gzFile file, const char *format, ...) { +int Z_EXPORTVA PREFIX(gzprintf)(gzFile file, const char *format, ...) { va_list va; int ret; @@ -410,7 +420,7 @@ int ZEXPORTVA PREFIX(gzprintf)(gzFile file, const char *format, ...) { } /* -- see zlib.h -- */ -int ZEXPORT PREFIX(gzflush)(gzFile file, int flush) { +int Z_EXPORT PREFIX(gzflush)(gzFile file, int flush) { gz_state *state; /* get internal structure */ @@ -439,7 +449,7 @@ int ZEXPORT PREFIX(gzflush)(gzFile file, int flush) { } /* -- see zlib.h -- */ -int ZEXPORT PREFIX(gzsetparams)(gzFile file, int level, int strategy) { +int Z_EXPORT PREFIX(gzsetparams)(gzFile file, int level, int strategy) { gz_state *state; PREFIX3(stream) *strm; @@ -477,7 +487,7 @@ int ZEXPORT PREFIX(gzsetparams)(gzFile file, int level, int strategy) { } /* -- see zlib.h -- */ -int ZEXPORT PREFIX(gzclose_w)(gzFile file) { +int Z_EXPORT PREFIX(gzclose_w)(gzFile file) { int ret = Z_OK; gz_state *state; @@ -503,14 +513,14 @@ int ZEXPORT PREFIX(gzclose_w)(gzFile file) { if (state->size) { if (!state->direct) { (void)PREFIX(deflateEnd)(&(state->strm)); - free(state->out); + zng_free(state->out); } - free(state->in); + zng_free(state->in); } gz_error(state, Z_OK, NULL); free(state->path); if (close(state->fd) == -1) ret = Z_ERRNO; - free(state); + zng_free(state); return ret; } diff --git a/libs/zlibng/infback.c b/libs/zlibng/infback.c index b4fb562b1..eecf03ada 100644 --- a/libs/zlibng/infback.c +++ b/libs/zlibng/infback.c @@ -15,9 +15,8 @@ #include "inftrees.h" #include "inflate.h" #include "inffast.h" - -/* function prototypes */ -static void fixedtables(struct inflate_state *state); +#include "inflate_p.h" +#include "functable.h" /* strm provides memory allocation functions in zalloc and zfree, or @@ -26,8 +25,8 @@ static void fixedtables(struct inflate_state *state); windowBits is in the range 8..15, and window is a user-supplied window and output buffer that is 2**windowBits bytes. */ -int ZEXPORT PREFIX(inflateBackInit_)(PREFIX3(stream) *strm, int windowBits, unsigned char *window, - const char *version, int stream_size) { +int32_t Z_EXPORT PREFIX(inflateBackInit_)(PREFIX3(stream) *strm, int32_t windowBits, uint8_t *window, + const char *version, int32_t stream_size) { struct inflate_state *state; if (version == NULL || version[0] != PREFIX2(VERSION)[0] || stream_size != (int)(sizeof(PREFIX3(stream)))) @@ -36,12 +35,12 @@ int ZEXPORT PREFIX(inflateBackInit_)(PREFIX3(stream) *strm, int windowBits, unsi return Z_STREAM_ERROR; strm->msg = NULL; /* in case we return an error */ if (strm->zalloc == NULL) { - strm->zalloc = zcalloc; + strm->zalloc = zng_calloc; strm->opaque = NULL; } if (strm->zfree == NULL) - strm->zfree = zcfree; - state = (struct inflate_state *)ZALLOC(strm, 1, sizeof(struct inflate_state)); + strm->zfree = zng_cfree; + state = (struct inflate_state *) ZALLOC(strm, 1, sizeof(struct inflate_state)); if (state == NULL) return Z_MEM_ERROR; Tracev((stderr, "inflate: allocated\n")); @@ -52,90 +51,14 @@ int ZEXPORT PREFIX(inflateBackInit_)(PREFIX3(stream) *strm, int windowBits, unsi state->window = window; state->wnext = 0; state->whave = 0; + state->chunksize = functable.chunksize(); return Z_OK; } /* - Return state with length and distance decoding tables and index sizes set to - fixed code decoding. Normally this returns fixed tables from inffixed.h. - If BUILDFIXED is defined, then instead this routine builds the tables the - first time it's called, and returns those tables the first time and - thereafter. This reduces the size of the code by about 2K bytes, in - exchange for a little execution time. However, BUILDFIXED should not be - used for threaded applications, since the rewriting of the tables and virgin - may not be thread-safe. - */ -static void fixedtables(struct inflate_state *state) { -#ifdef BUILDFIXED - static int virgin = 1; - static code *lenfix, *distfix; - static code fixed[544]; - - /* build fixed huffman tables if first call (may not be thread safe) */ - if (virgin) { - unsigned sym, bits; - static code *next; - - /* literal/length table */ - sym = 0; - while (sym < 144) state->lens[sym++] = 8; - while (sym < 256) state->lens[sym++] = 9; - while (sym < 280) state->lens[sym++] = 7; - while (sym < 288) state->lens[sym++] = 8; - next = fixed; - lenfix = next; - bits = 9; - inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); - - /* distance table */ - sym = 0; - while (sym < 32) state->lens[sym++] = 5; - distfix = next; - bits = 5; - inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); - - /* do this just once */ - virgin = 0; - } -#else /* !BUILDFIXED */ -# include "inffixed.h" -#endif /* BUILDFIXED */ - state->lencode = lenfix; - state->lenbits = 9; - state->distcode = distfix; - state->distbits = 5; -} - -/* Macros for inflateBack(): */ - -/* Load returned state from inflate_fast() */ -#define LOAD() \ - do { \ - put = strm->next_out; \ - left = strm->avail_out; \ - next = strm->next_in; \ - have = strm->avail_in; \ - hold = state->hold; \ - bits = state->bits; \ - } while (0) - -/* Set state from registers for inflate_fast() */ -#define RESTORE() \ - do { \ - strm->next_out = put; \ - strm->avail_out = left; \ - strm->next_in = next; \ - strm->avail_in = have; \ - state->hold = hold; \ - state->bits = bits; \ - } while (0) - -/* Clear the input bit accumulator */ -#define INITBITS() \ - do { \ - hold = 0; \ - bits = 0; \ - } while (0) + Private macros for inflateBack() + Look in inflate_p.h for macros shared with inflate() +*/ /* Assure that some input is available. If input is requested, but denied, then return a Z_BUF_ERROR from inflateBack(). */ @@ -157,37 +80,10 @@ static void fixedtables(struct inflate_state *state) { do { \ PULL(); \ have--; \ - hold += (*next++ << bits); \ + hold += ((unsigned)(*next++) << bits); \ bits += 8; \ } while (0) -/* Assure that there are at least n bits in the bit accumulator. If there is - not enough available input to do that, then return from inflateBack() with - an error. */ -#define NEEDBITS(n) \ - do { \ - while (bits < (unsigned)(n)) \ - PULLBYTE(); \ - } while (0) - -/* Return the low n bits of the bit accumulator (n < 16) */ -#define BITS(n) \ - (hold & ((1U << (n)) - 1)) - -/* Remove n bits from the bit accumulator */ -#define DROPBITS(n) \ - do { \ - hold >>= (n); \ - bits -= (unsigned)(n); \ - } while (0) - -/* Remove zero to seven bits as needed to go to a byte boundary */ -#define BYTEBITS() \ - do { \ - hold >>= bits & 7; \ - bits -= bits & 7; \ - } while (0) - /* Assure that some output space is available, by writing out the window if it's full. If the write fails, return from inflateBack() with a Z_BUF_ERROR. */ @@ -225,25 +121,25 @@ static void fixedtables(struct inflate_state *state) { in() should return zero on failure. out() should return non-zero on failure. If either in() or out() fails, than inflateBack() returns a Z_BUF_ERROR. strm->next_in can be checked for NULL to see whether it - was in() or out() that caused in the error. Otherwise, inflateBack() + was in() or out() that caused in the error. Otherwise, inflateBack() returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format error, or Z_MEM_ERROR if it could not allocate memory for the state. inflateBack() can also return Z_STREAM_ERROR if the input parameters are not correct, i.e. strm is NULL or the state was not initialized. */ -int ZEXPORT PREFIX(inflateBack)(PREFIX3(stream) *strm, in_func in, void *in_desc, out_func out, void *out_desc) { +int32_t Z_EXPORT PREFIX(inflateBack)(PREFIX3(stream) *strm, in_func in, void *in_desc, out_func out, void *out_desc) { struct inflate_state *state; - const unsigned char *next; /* next input */ - unsigned char *put; /* next output */ - unsigned have, left; /* available input and output */ - uint32_t hold; /* bit buffer */ - unsigned bits; /* bits in bit buffer */ - unsigned copy; /* number of stored or match bytes to copy */ - unsigned char *from; /* where to copy match bytes from */ - code here; /* current decoding table entry */ - code last; /* parent table entry */ - unsigned len; /* length to copy for repeats, bits to drop */ - int ret; /* return code */ + z_const unsigned char *next; /* next input */ + unsigned char *put; /* next output */ + unsigned have, left; /* available input and output */ + uint32_t hold; /* bit buffer */ + unsigned bits; /* bits in bit buffer */ + unsigned copy; /* number of stored or match bytes to copy */ + unsigned char *from; /* where to copy match bytes from */ + code here; /* current decoding table entry */ + code last; /* parent table entry */ + unsigned len; /* length to copy for repeats, bits to drop */ + int32_t ret; /* return code */ static const uint16_t order[19] = /* permutation of code lengths */ {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; @@ -316,10 +212,8 @@ int ZEXPORT PREFIX(inflateBack)(PREFIX3(stream) *strm, in_func in, void *in_desc copy = state->length; PULL(); ROOM(); - if (copy > have) - copy = have; - if (copy > left) - copy = left; + if (copy > have) copy = have; + if (copy > left) copy = left; memcpy(put, next, copy); have -= copy; next += copy; @@ -348,9 +242,9 @@ int ZEXPORT PREFIX(inflateBack)(PREFIX3(stream) *strm, in_func in, void *in_desc } #endif Tracev((stderr, "inflate: table sizes ok\n")); + state->have = 0; /* get code length code lengths (not a typo) */ - state->have = 0; while (state->have < state->ncode) { NEEDBITS(3); state->lens[order[state->have++]] = (uint16_t)BITS(3); @@ -359,23 +253,22 @@ int ZEXPORT PREFIX(inflateBack)(PREFIX3(stream) *strm, in_func in, void *in_desc while (state->have < 19) state->lens[order[state->have++]] = 0; state->next = state->codes; - state->lencode = (code const *)(state->next); + state->lencode = (const code *)(state->next); state->lenbits = 7; - ret = inflate_table(CODES, state->lens, 19, &(state->next), &(state->lenbits), state->work); + ret = zng_inflate_table(CODES, state->lens, 19, &(state->next), &(state->lenbits), state->work); if (ret) { strm->msg = (char *)"invalid code lengths set"; state->mode = BAD; break; } Tracev((stderr, "inflate: code lengths ok\n")); + state->have = 0; /* get length and distance code code lengths */ - state->have = 0; while (state->have < state->nlen + state->ndist) { for (;;) { here = state->lencode[BITS(state->lenbits)]; - if (here.bits <= bits) - break; + if (here.bits <= bits) break; PULLBYTE(); } if (here.val < 16) { @@ -390,7 +283,7 @@ int ZEXPORT PREFIX(inflateBack)(PREFIX3(stream) *strm, in_func in, void *in_desc state->mode = BAD; break; } - len = (unsigned)(state->lens[state->have - 1]); + len = state->lens[state->have - 1]; copy = 3 + BITS(2); DROPBITS(2); } else if (here.val == 17) { @@ -411,8 +304,10 @@ int ZEXPORT PREFIX(inflateBack)(PREFIX3(stream) *strm, in_func in, void *in_desc state->mode = BAD; break; } - while (copy--) + while (copy) { + --copy; state->lens[state->have++] = (uint16_t)len; + } } } @@ -431,17 +326,17 @@ int ZEXPORT PREFIX(inflateBack)(PREFIX3(stream) *strm, in_func in, void *in_desc values here (9 and 6) without reading the comments in inftrees.h concerning the ENOUGH constants, which depend on those values */ state->next = state->codes; - state->lencode = (code const *)(state->next); + state->lencode = (const code *)(state->next); state->lenbits = 9; - ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), &(state->lenbits), state->work); + ret = zng_inflate_table(LENS, state->lens, state->nlen, &(state->next), &(state->lenbits), state->work); if (ret) { strm->msg = (char *)"invalid literal/lengths set"; state->mode = BAD; break; } - state->distcode = (code const *)(state->next); + state->distcode = (const code *)(state->next); state->distbits = 6; - ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, + ret = zng_inflate_table(DISTS, state->lens + state->nlen, state->ndist, &(state->next), &(state->distbits), state->work); if (ret) { strm->msg = (char *)"invalid distances set"; @@ -458,7 +353,7 @@ int ZEXPORT PREFIX(inflateBack)(PREFIX3(stream) *strm, in_func in, void *in_desc RESTORE(); if (state->whave < state->wsize) state->whave = state->wsize - left; - inflate_fast(strm, state->wsize); + zng_inflate_fast(strm, state->wsize); LOAD(); break; } @@ -473,8 +368,7 @@ int ZEXPORT PREFIX(inflateBack)(PREFIX3(stream) *strm, in_func in, void *in_desc if (here.op && (here.op & 0xf0) == 0) { last = here; for (;;) { - here = state->lencode[last.val + - (BITS(last.bits + last.op) >> last.bits)]; + here = state->lencode[last.val + (BITS(last.bits + last.op) >> last.bits)]; if ((unsigned)last.bits + (unsigned)here.bits <= bits) break; PULLBYTE(); @@ -485,7 +379,7 @@ int ZEXPORT PREFIX(inflateBack)(PREFIX3(stream) *strm, in_func in, void *in_desc state->length = here.val; /* process literal */ - if (here.op == 0) { + if ((int)(here.op) == 0) { Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? "inflate: literal '%c'\n" : "inflate: literal 0x%02x\n", here.val)); @@ -512,7 +406,7 @@ int ZEXPORT PREFIX(inflateBack)(PREFIX3(stream) *strm, in_func in, void *in_desc /* length code -- get extra bits, if any */ state->extra = (here.op & 15); - if (state->extra != 0) { + if (state->extra) { NEEDBITS(state->extra); state->length += BITS(state->extra); DROPBITS(state->extra); @@ -543,19 +437,21 @@ int ZEXPORT PREFIX(inflateBack)(PREFIX3(stream) *strm, in_func in, void *in_desc break; } state->offset = here.val; + state->extra = (here.op & 15); /* get distance extra bits, if any */ - state->extra = (here.op & 15); - if (state->extra != 0) { + if (state->extra) { NEEDBITS(state->extra); state->offset += BITS(state->extra); DROPBITS(state->extra); } +#ifdef INFLATE_STRICT if (state->offset > state->wsize - (state->whave < state->wsize ? left : 0)) { strm->msg = (char *)"invalid distance too far back"; state->mode = BAD; break; } +#endif Tracevv((stderr, "inflate: distance %u\n", state->offset)); /* copy match from window to output */ @@ -604,7 +500,7 @@ int ZEXPORT PREFIX(inflateBack)(PREFIX3(stream) *strm, in_func in, void *in_desc return ret; } -int ZEXPORT PREFIX(inflateBackEnd)(PREFIX3(stream) *strm) { +int32_t Z_EXPORT PREFIX(inflateBackEnd)(PREFIX3(stream) *strm) { if (strm == NULL || strm->state == NULL || strm->zfree == NULL) return Z_STREAM_ERROR; ZFREE(strm, strm->state); diff --git a/libs/zlibng/inffast.c b/libs/zlibng/inffast.c index bd9b2a1c4..18ce570e9 100644 --- a/libs/zlibng/inffast.c +++ b/libs/zlibng/inffast.c @@ -8,19 +8,21 @@ #include "inftrees.h" #include "inflate.h" #include "inffast.h" -#include "memcopy.h" +#include "inflate_p.h" +#include "functable.h" -/* Return the low n bits of the bit accumulator (n < 16) */ -#define BITS(n) \ - (hold & ((UINT64_C(1) << (n)) - 1)) -/* Remove n bits from the bit accumulator */ -#define DROPBITS(n) \ - do { \ - hold >>= (n); \ - bits -= (unsigned)(n); \ - } while (0) +/* Load 64 bits from IN and place the bytes at offset BITS in the result. */ +static inline uint64_t load_64_bits(const unsigned char *in, unsigned bits) { + uint64_t chunk; + memcpy(&chunk, in, sizeof(chunk)); +#if BYTE_ORDER == LITTLE_ENDIAN + return chunk << bits; +#else + return ZSWAP64(chunk) << bits; +#endif +} /* Decode literal, length, and distance codes and write out the resulting literal and match bytes until either not enough input or output is @@ -60,17 +62,15 @@ requires strm->avail_out >= 258 for each loop to avoid checking for output space. */ -void ZLIB_INTERNAL inflate_fast(PREFIX3(stream) *strm, unsigned long start) { +void Z_INTERNAL zng_inflate_fast(PREFIX3(stream) *strm, unsigned long start) { /* start: inflate()'s starting value for strm->avail_out */ struct inflate_state *state; - const unsigned char *in; /* local strm->next_in */ + z_const unsigned char *in; /* local strm->next_in */ const unsigned char *last; /* have enough input while in < last */ unsigned char *out; /* local strm->next_out */ unsigned char *beg; /* inflate()'s initial strm->next_out */ unsigned char *end; /* while out < end, enough space available */ -#ifdef INFFAST_CHUNKSIZE unsigned char *safe; /* can use chunkcopy provided out < safe */ -#endif #ifdef INFLATE_STRICT unsigned dmax; /* maximum distance from zlib header */ #endif @@ -136,10 +136,7 @@ void ZLIB_INTERNAL inflate_fast(PREFIX3(stream) *strm, unsigned long start) { out = strm->next_out; beg = out - (start - strm->avail_out); end = out + (strm->avail_out - (INFLATE_FAST_MIN_LEFT - 1)); - -#ifdef INFFAST_CHUNKSIZE safe = out + strm->avail_out; -#endif #ifdef INFLATE_STRICT dmax = state->dmax; #endif @@ -174,15 +171,13 @@ void ZLIB_INTERNAL inflate_fast(PREFIX3(stream) *strm, unsigned long start) { } else if (op & 16) { /* length base */ len = here->val; op &= 15; /* number of extra bits */ - if (op) { - if (bits < op) { - hold |= load_64_bits(in, bits); - in += 6; - bits += 48; - } - len += BITS(op); - DROPBITS(op); + if (bits < op) { + hold |= load_64_bits(in, bits); + in += 6; + bits += 48; } + len += BITS(op); + DROPBITS(op); Tracevv((stderr, "inflate: length %u\n", len)); if (bits < 15) { hold |= load_64_bits(in, bits); @@ -204,8 +199,7 @@ void ZLIB_INTERNAL inflate_fast(PREFIX3(stream) *strm, unsigned long start) { dist += BITS(op); #ifdef INFLATE_STRICT if (dist > dmax) { - strm->msg = (char *)"invalid distance too far back"; - state->mode = BAD; + SET_BAD("invalid distance too far back"); break; } #endif @@ -216,8 +210,7 @@ void ZLIB_INTERNAL inflate_fast(PREFIX3(stream) *strm, unsigned long start) { op = dist - op; /* distance back in window */ if (op > whave) { if (state->sane) { - strm->msg = (char *)"invalid distance too far back"; - state->mode = BAD; + SET_BAD("invalid distance too far back"); break; } #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR @@ -240,7 +233,6 @@ void ZLIB_INTERNAL inflate_fast(PREFIX3(stream) *strm, unsigned long start) { } #endif } -#ifdef INFFAST_CHUNKSIZE from = window; if (wnext == 0) { /* very common case */ from += wsize - op; @@ -251,7 +243,7 @@ void ZLIB_INTERNAL inflate_fast(PREFIX3(stream) *strm, unsigned long start) { from += wsize - op; if (op < len) { /* some from end of window */ len -= op; - out = chunkcopysafe(out, from, op, safe); + out = functable.chunkcopy_safe(out, from, op, safe); from = window; /* more from start of window */ op = wnext; /* This (rare) case can create a situation where @@ -261,81 +253,28 @@ void ZLIB_INTERNAL inflate_fast(PREFIX3(stream) *strm, unsigned long start) { } if (op < len) { /* still need some from output */ len -= op; - out = chunkcopysafe(out, from, op, safe); - out = chunkunroll(out, &dist, &len); - out = chunkcopysafe(out, out - dist, len, safe); + out = functable.chunkcopy_safe(out, from, op, safe); + out = functable.chunkunroll(out, &dist, &len); + out = functable.chunkcopy_safe(out, out - dist, len, safe); } else { - out = chunkcopysafe(out, from, len, safe); + out = functable.chunkcopy_safe(out, from, len, safe); } -#else - from = window; - if (wnext == 0) { /* very common case */ - from += wsize - op; - if (op < len) { /* some from window */ - len -= op; - do { - *out++ = *from++; - } while (--op); - from = out - dist; /* rest from output */ - } - } else if (wnext < op) { /* wrap around window */ - from += wsize + wnext - op; - op -= wnext; - if (op < len) { /* some from end of window */ - len -= op; - do { - *out++ = *from++; - } while (--op); - from = window; - if (wnext < len) { /* some from start of window */ - op = wnext; - len -= op; - do { - *out++ = *from++; - } while (--op); - from = out - dist; /* rest from output */ - } - } - } else { /* contiguous in window */ - from += wnext - op; - if (op < len) { /* some from window */ - len -= op; - do { - *out++ = *from++; - } while (--op); - from = out - dist; /* rest from output */ - } - } - - out = chunk_copy(out, from, (int) (out - from), len); -#endif } else { -#ifdef INFFAST_CHUNKSIZE - /* Whole reference is in range of current output. No - range checks are necessary because we start with room - for at least 258 bytes of output, so unroll and roundoff - operations can write beyond `out+len` so long as they - stay within 258 bytes of `out`. + /* Whole reference is in range of current output. No range checks are + necessary because we start with room for at least 258 bytes of output, + so unroll and roundoff operations can write beyond `out+len` so long + as they stay within 258 bytes of `out`. */ - if (dist >= len || dist >= INFFAST_CHUNKSIZE) - out = chunkcopy(out, out - dist, len); + if (dist >= len || dist >= state->chunksize) + out = functable.chunkcopy(out, out - dist, len); else - out = chunkmemset(out, dist, len); -#else - if (len < sizeof(uint64_t)) - out = set_bytes(out, out - dist, dist, len); - else if (dist == 1) - out = byte_memset(out, len); - else - out = chunk_memset(out, out - dist, dist, len); -#endif + out = functable.chunkmemset(out, dist, len); } } else if ((op & 64) == 0) { /* 2nd level distance code */ here = dcode + here->val + BITS(op); goto dodist; } else { - strm->msg = (char *)"invalid distance code"; - state->mode = BAD; + SET_BAD("invalid distance code"); break; } } else if ((op & 64) == 0) { /* 2nd level length code */ @@ -346,8 +285,7 @@ void ZLIB_INTERNAL inflate_fast(PREFIX3(stream) *strm, unsigned long start) { state->mode = TYPE; break; } else { - strm->msg = (char *)"invalid literal/length code"; - state->mode = BAD; + SET_BAD("invalid literal/length code"); break; } } while (in < last && out < end); @@ -361,12 +299,10 @@ void ZLIB_INTERNAL inflate_fast(PREFIX3(stream) *strm, unsigned long start) { /* update state and return */ strm->next_in = in; strm->next_out = out; - strm->avail_in = - (unsigned)(in < last ? (INFLATE_FAST_MIN_HAVE - 1) + (last - in) - : (INFLATE_FAST_MIN_HAVE - 1) - (in - last)); - strm->avail_out = - (unsigned)(out < end ? (INFLATE_FAST_MIN_LEFT - 1) + (end - out) - : (INFLATE_FAST_MIN_LEFT - 1) - (out - end)); + strm->avail_in = (unsigned)(in < last ? (INFLATE_FAST_MIN_HAVE - 1) + (last - in) + : (INFLATE_FAST_MIN_HAVE - 1) - (in - last)); + strm->avail_out = (unsigned)(out < end ? (INFLATE_FAST_MIN_LEFT - 1) + (end - out) + : (INFLATE_FAST_MIN_LEFT - 1) - (out - end)); Assert(bits <= 32, "Remaining bits greater than 32"); state->hold = (uint32_t)hold; diff --git a/libs/zlibng/inffast.h b/libs/zlibng/inffast.h index 9ad21abc8..179a65da6 100644 --- a/libs/zlibng/inffast.h +++ b/libs/zlibng/inffast.h @@ -10,7 +10,7 @@ subject to change. Applications should only use zlib.h. */ -void ZLIB_INTERNAL inflate_fast(PREFIX3(stream) *strm, unsigned long start); +void Z_INTERNAL zng_inflate_fast(PREFIX3(stream) *strm, unsigned long start); #define INFLATE_FAST_MIN_HAVE 8 #define INFLATE_FAST_MIN_LEFT 258 diff --git a/libs/zlibng/inffixed.h b/libs/zlibng/inffixed.h deleted file mode 100644 index d62832776..000000000 --- a/libs/zlibng/inffixed.h +++ /dev/null @@ -1,94 +0,0 @@ - /* inffixed.h -- table for decoding fixed codes - * Generated automatically by makefixed(). - */ - - /* WARNING: this file should *not* be used by applications. - It is part of the implementation of this library and is - subject to change. Applications should only use zlib.h. - */ - - static const code lenfix[512] = { - {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48}, - {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128}, - {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59}, - {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176}, - {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20}, - {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100}, - {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8}, - {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216}, - {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76}, - {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114}, - {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2}, - {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148}, - {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42}, - {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86}, - {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15}, - {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236}, - {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62}, - {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142}, - {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31}, - {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162}, - {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25}, - {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105}, - {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4}, - {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202}, - {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69}, - {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125}, - {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13}, - {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195}, - {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35}, - {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91}, - {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19}, - {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246}, - {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55}, - {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135}, - {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99}, - {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190}, - {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16}, - {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96}, - {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6}, - {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209}, - {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72}, - {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116}, - {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4}, - {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153}, - {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44}, - {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82}, - {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11}, - {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229}, - {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58}, - {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138}, - {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51}, - {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173}, - {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30}, - {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110}, - {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0}, - {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195}, - {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65}, - {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121}, - {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9}, - {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258}, - {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37}, - {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93}, - {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23}, - {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251}, - {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51}, - {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131}, - {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67}, - {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183}, - {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23}, - {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103}, - {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9}, - {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223}, - {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79}, - {0,9,255} - }; - - static const code distfix[32] = { - {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025}, - {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193}, - {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385}, - {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577}, - {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073}, - {22,5,193},{64,5,0} - }; diff --git a/libs/zlibng/inffixed_tbl.h b/libs/zlibng/inffixed_tbl.h new file mode 100644 index 000000000..7292fa06e --- /dev/null +++ b/libs/zlibng/inffixed_tbl.h @@ -0,0 +1,94 @@ +/* inffixed_tbl.h -- table for decoding fixed codes + * Generated automatically by makefixed(). + */ + +/* WARNING: this file should *not* be used by applications. + * It is part of the implementation of this library and is + * subject to change. Applications should only use zlib.h. + */ + +static const code lenfix[512] = { + {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48}, + {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128}, + {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59}, + {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176}, + {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20}, + {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100}, + {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8}, + {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216}, + {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76}, + {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114}, + {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2}, + {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148}, + {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42}, + {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86}, + {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15}, + {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236}, + {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62}, + {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142}, + {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31}, + {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162}, + {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25}, + {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105}, + {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4}, + {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202}, + {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69}, + {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125}, + {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13}, + {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195}, + {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35}, + {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91}, + {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19}, + {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246}, + {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55}, + {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135}, + {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99}, + {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190}, + {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16}, + {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96}, + {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6}, + {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209}, + {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72}, + {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116}, + {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4}, + {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153}, + {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44}, + {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82}, + {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11}, + {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229}, + {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58}, + {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138}, + {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51}, + {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173}, + {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30}, + {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110}, + {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0}, + {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195}, + {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65}, + {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121}, + {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9}, + {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258}, + {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37}, + {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93}, + {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23}, + {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251}, + {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51}, + {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131}, + {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67}, + {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183}, + {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23}, + {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103}, + {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9}, + {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223}, + {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79}, + {0,9,255} +}; + +static const code distfix[32] = { + {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025}, + {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193}, + {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385}, + {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577}, + {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073}, + {22,5,193},{64,5,0} +}; diff --git a/libs/zlibng/inflate.c b/libs/zlibng/inflate.c index 8a8d328f9..5c30816dd 100644 --- a/libs/zlibng/inflate.c +++ b/libs/zlibng/inflate.c @@ -3,89 +3,13 @@ * For conditions of distribution and use, see copyright notice in zlib.h */ -/* - * Change history: - * - * 1.2.beta0 24 Nov 2002 - * - First version -- complete rewrite of inflate to simplify code, avoid - * creation of window when not needed, minimize use of window when it is - * needed, make inffast.c even faster, implement gzip decoding, and to - * improve code readability and style over the previous zlib inflate code - * - * 1.2.beta1 25 Nov 2002 - * - Use pointers for available input and output checking in inffast.c - * - Remove input and output counters in inffast.c - * - Change inffast.c entry and loop from avail_in >= 7 to >= 6 - * - Remove unnecessary second byte pull from length extra in inffast.c - * - Unroll direct copy to three copies per loop in inffast.c - * - * 1.2.beta2 4 Dec 2002 - * - Change external routine names to reduce potential conflicts - * - Correct filename to inffixed.h for fixed tables in inflate.c - * - Make hbuf[] unsigned char to match parameter type in inflate.c - * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset) - * to avoid negation problem on Alphas (64 bit) in inflate.c - * - * 1.2.beta3 22 Dec 2002 - * - Add comments on state->bits assertion in inffast.c - * - Add comments on op field in inftrees.h - * - Fix bug in reuse of allocated window after inflateReset() - * - Remove bit fields--back to byte structure for speed - * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths - * - Change post-increments to pre-increments in inflate_fast(), PPC biased? - * - Add compile time option, POSTINC, to use post-increments instead (Intel?) - * - Make MATCH copy in inflate() much faster for when inflate_fast() not used - * - Use local copies of stream next and avail values, as well as local bit - * buffer and bit count in inflate()--for speed when inflate_fast() not used - * - * 1.2.beta4 1 Jan 2003 - * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings - * - Move a comment on output buffer sizes from inffast.c to inflate.c - * - Add comments in inffast.c to introduce the inflate_fast() routine - * - Rearrange window copies in inflate_fast() for speed and simplification - * - Unroll last copy for window match in inflate_fast() - * - Use local copies of window variables in inflate_fast() for speed - * - Pull out common wnext == 0 case for speed in inflate_fast() - * - Make op and len in inflate_fast() unsigned for consistency - * - Add FAR to lcode and dcode declarations in inflate_fast() - * - Simplified bad distance check in inflate_fast() - * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new - * source file infback.c to provide a call-back interface to inflate for - * programs like gzip and unzip -- uses window as output buffer to avoid - * window copying - * - * 1.2.beta5 1 Jan 2003 - * - Improved inflateBack() interface to allow the caller to provide initial - * input in strm. - * - Fixed stored blocks bug in inflateBack() - * - * 1.2.beta6 4 Jan 2003 - * - Added comments in inffast.c on effectiveness of POSTINC - * - Typecasting all around to reduce compiler warnings - * - Changed loops from while (1) or do {} while (1) to for (;;), again to - * make compilers happy - * - Changed type of window in inflateBackInit() to unsigned char * - * - * 1.2.beta7 27 Jan 2003 - * - Changed many types to unsigned or unsigned short to avoid warnings - * - Added inflateCopy() function - * - * 1.2.0 9 Mar 2003 - * - Changed inflateBack() interface to provide separate opaque descriptors - * for the in() and out() functions - * - Changed inflateBack() argument and in_func typedef to swap the length - * and buffer address return values for the input function - * - Check next_in and next_out for Z_NULL on entry to inflate() - * - * The history for versions after 1.2.0 are in ChangeLog in zlib distribution. - */ - #include "zbuild.h" #include "zutil.h" #include "inftrees.h" #include "inflate.h" #include "inffast.h" -#include "memcopy.h" +#include "inflate_p.h" +#include "inffixed_tbl.h" #include "functable.h" /* Architecture-specific hooks. */ @@ -111,21 +35,13 @@ # define INFLATE_NEED_UPDATEWINDOW(strm) 1 /* Invoked at the beginning of inflateMark(). Useful for updating arch-specific pointers and offsets. */ # define INFLATE_MARK_HOOK(strm) do {} while (0) -#endif - -#ifdef MAKEFIXED -# ifndef BUILDFIXED -# define BUILDFIXED -# endif +/* Invoked at the beginning of inflateSyncPoint(). Useful for performing arch-specific state checks. */ +#define INFLATE_SYNC_POINT_HOOK(strm) do {} while (0) #endif /* function prototypes */ static int inflateStateCheck(PREFIX3(stream) *strm); -static void fixedtables(struct inflate_state *state); static int updatewindow(PREFIX3(stream) *strm, const unsigned char *end, uint32_t copy); -#ifdef BUILDFIXED - void makefixed(void); -#endif static uint32_t syncsearch(uint32_t *have, const unsigned char *buf, uint32_t len); static int inflateStateCheck(PREFIX3(stream) *strm) { @@ -138,7 +54,7 @@ static int inflateStateCheck(PREFIX3(stream) *strm) { return 0; } -int ZEXPORT PREFIX(inflateResetKeep)(PREFIX3(stream) *strm) { +int32_t Z_EXPORT PREFIX(inflateResetKeep)(PREFIX3(stream) *strm) { struct inflate_state *state; if (inflateStateCheck(strm)) @@ -149,9 +65,10 @@ int ZEXPORT PREFIX(inflateResetKeep)(PREFIX3(stream) *strm) { if (state->wrap) /* to support ill-conceived Java test suite */ strm->adler = state->wrap & 1; state->mode = HEAD; - state->check = functable.adler32(0L, NULL, 0); + state->check = ADLER32_INITIAL_VALUE; state->last = 0; state->havedict = 0; + state->flags = -1; state->dmax = 32768U; state->head = NULL; state->hold = 0; @@ -164,7 +81,7 @@ int ZEXPORT PREFIX(inflateResetKeep)(PREFIX3(stream) *strm) { return Z_OK; } -int ZEXPORT PREFIX(inflateReset)(PREFIX3(stream) *strm) { +int32_t Z_EXPORT PREFIX(inflateReset)(PREFIX3(stream) *strm) { struct inflate_state *state; if (inflateStateCheck(strm)) @@ -176,7 +93,7 @@ int ZEXPORT PREFIX(inflateReset)(PREFIX3(stream) *strm) { return PREFIX(inflateResetKeep)(strm); } -int ZEXPORT PREFIX(inflateReset2)(PREFIX3(stream) *strm, int windowBits) { +int32_t Z_EXPORT PREFIX(inflateReset2)(PREFIX3(stream) *strm, int32_t windowBits) { int wrap; struct inflate_state *state; @@ -211,13 +128,13 @@ int ZEXPORT PREFIX(inflateReset2)(PREFIX3(stream) *strm, int windowBits) { return PREFIX(inflateReset)(strm); } -int ZEXPORT PREFIX(inflateInit2_)(PREFIX3(stream) *strm, int windowBits, const char *version, int stream_size) { - int ret; +int32_t Z_EXPORT PREFIX(inflateInit2_)(PREFIX3(stream) *strm, int32_t windowBits, const char *version, int32_t stream_size) { + int32_t ret; struct inflate_state *state; -#ifdef X86_CPUID +#if defined(X86_FEATURES) x86_check_features(); -#elif defined(__arm__) || defined(__aarch64__) || defined(_M_ARM) +#elif defined(ARM_FEATURES) arm_check_features(); #endif @@ -227,11 +144,11 @@ int ZEXPORT PREFIX(inflateInit2_)(PREFIX3(stream) *strm, int windowBits, const c return Z_STREAM_ERROR; strm->msg = NULL; /* in case we return an error */ if (strm->zalloc == NULL) { - strm->zalloc = zcalloc; + strm->zalloc = zng_calloc; strm->opaque = NULL; } if (strm->zfree == NULL) - strm->zfree = zcfree; + strm->zfree = zng_cfree; state = (struct inflate_state *) ZALLOC_STATE(strm, 1, sizeof(struct inflate_state)); if (state == NULL) return Z_MEM_ERROR; @@ -240,6 +157,7 @@ int ZEXPORT PREFIX(inflateInit2_)(PREFIX3(stream) *strm, int windowBits, const c state->strm = strm; state->window = NULL; state->mode = HEAD; /* to pass state test in inflateReset2() */ + state->chunksize = functable.chunksize(); ret = PREFIX(inflateReset2)(strm, windowBits); if (ret != Z_OK) { ZFREE_STATE(strm, state); @@ -248,11 +166,11 @@ int ZEXPORT PREFIX(inflateInit2_)(PREFIX3(stream) *strm, int windowBits, const c return ret; } -int ZEXPORT PREFIX(inflateInit_)(PREFIX3(stream) *strm, const char *version, int stream_size) { +int32_t Z_EXPORT PREFIX(inflateInit_)(PREFIX3(stream) *strm, const char *version, int32_t stream_size) { return PREFIX(inflateInit2_)(strm, DEF_WBITS, version, stream_size); } -int ZEXPORT PREFIX(inflatePrime)(PREFIX3(stream) *strm, int bits, int value) { +int32_t Z_EXPORT PREFIX(inflatePrime)(PREFIX3(stream) *strm, int32_t bits, int32_t value) { struct inflate_state *state; if (inflateStateCheck(strm)) @@ -274,133 +192,24 @@ int ZEXPORT PREFIX(inflatePrime)(PREFIX3(stream) *strm, int bits, int value) { /* Return state with length and distance decoding tables and index sizes set to - fixed code decoding. Normally this returns fixed tables from inffixed.h. - If BUILDFIXED is defined, then instead this routine builds the tables the - first time it's called, and returns those tables the first time and - thereafter. This reduces the size of the code by about 2K bytes, in - exchange for a little execution time. However, BUILDFIXED should not be - used for threaded applications, since the rewriting of the tables and virgin - may not be thread-safe. + fixed code decoding. This returns fixed tables from inffixed_tbl.h. */ -static void fixedtables(struct inflate_state *state) { -#ifdef BUILDFIXED - static int virgin = 1; - static code *lenfix, *distfix; - static code fixed[544]; - /* build fixed huffman tables if first call (may not be thread safe) */ - if (virgin) { - unsigned sym, bits; - static code *next; - - /* literal/length table */ - sym = 0; - while (sym < 144) state->lens[sym++] = 8; - while (sym < 256) state->lens[sym++] = 9; - while (sym < 280) state->lens[sym++] = 7; - while (sym < 288) state->lens[sym++] = 8; - next = fixed; - lenfix = next; - bits = 9; - inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); - - /* distance table */ - sym = 0; - while (sym < 32) state->lens[sym++] = 5; - distfix = next; - bits = 5; - inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); - - /* do this just once */ - virgin = 0; - } -#else /* !BUILDFIXED */ -# include "inffixed.h" -#endif /* BUILDFIXED */ +void Z_INTERNAL fixedtables(struct inflate_state *state) { state->lencode = lenfix; state->lenbits = 9; state->distcode = distfix; state->distbits = 5; } -#ifdef MAKEFIXED -#include - -/* - Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also - defines BUILDFIXED, so the tables are built on the fly. makefixed() writes - those tables to stdout, which would be piped to inffixed.h. A small program - can simply call makefixed to do this: - - void makefixed(void); - - int main(void) - { - makefixed(); - return 0; - } - - Then that can be linked with zlib built with MAKEFIXED defined and run: - - a.out > inffixed.h - */ -void makefixed(void) { - unsigned low, size; - struct inflate_state state; - - fixedtables(&state); - puts(" /* inffixed.h -- table for decoding fixed codes"); - puts(" * Generated automatically by makefixed()."); - puts(" */"); - puts(""); - puts(" /* WARNING: this file should *not* be used by applications."); - puts(" It is part of the implementation of this library and is"); - puts(" subject to change. Applications should only use zlib.h."); - puts(" */"); - puts(""); - size = 1U << 9; - printf(" static const code lenfix[%u] = {", size); - low = 0; - for (;;) { - if ((low % 7) == 0) - printf("\n "); - printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op, - state.lencode[low].bits, state.lencode[low].val); - if (++low == size) - break; - putchar(','); - } - puts("\n };"); - size = 1U << 5; - printf("\n static const code distfix[%u] = {", size); - low = 0; - for (;;) { - if ((low % 6) == 0) - printf("\n "); - printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, state.distcode[low].val); - if (++low == size) - break; - putchar(','); - } - puts("\n };"); -} -#endif /* MAKEFIXED */ - -int ZLIB_INTERNAL inflate_ensure_window(struct inflate_state *state) -{ +int Z_INTERNAL inflate_ensure_window(struct inflate_state *state) { /* if it hasn't been done already, allocate space for the window */ if (state->window == NULL) { -#ifdef INFFAST_CHUNKSIZE unsigned wsize = 1U << state->wbits; - state->window = (unsigned char *) ZALLOC_WINDOW(state->strm, wsize + INFFAST_CHUNKSIZE, sizeof(unsigned char)); + state->window = (unsigned char *) ZALLOC_WINDOW(state->strm, wsize + state->chunksize, sizeof(unsigned char)); if (state->window == Z_NULL) return 1; - memset(state->window + wsize, 0, INFFAST_CHUNKSIZE); -#else - state->window = (unsigned char *) ZALLOC_WINDOW(state->strm, 1U << state->wbits, sizeof(unsigned char)); - if (state->window == NULL) - return 1; -#endif + memset(state->window + wsize, 0, state->chunksize); } /* if window not in use yet, initialize */ @@ -427,7 +236,7 @@ int ZLIB_INTERNAL inflate_ensure_window(struct inflate_state *state) output will fall in the output data, making match copies simpler and faster. The advantage may be dependent on the size of the processor's data caches. */ -static int updatewindow(PREFIX3(stream) *strm, const unsigned char *end, uint32_t copy) { +static int32_t updatewindow(PREFIX3(stream) *strm, const uint8_t *end, uint32_t copy) { struct inflate_state *state; uint32_t dist; @@ -461,66 +270,13 @@ static int updatewindow(PREFIX3(stream) *strm, const unsigned char *end, uint32_ return 0; } -/* Macros for inflate(): */ -/* check function to use adler32() for zlib or crc32() for gzip */ -#ifdef GUNZIP -# define UPDATE(check, buf, len) \ - (state->flags ? PREFIX(crc32)(check, buf, len) : functable.adler32(check, buf, len)) -#else -# define UPDATE(check, buf, len) functable.adler32(check, buf, len) -#endif +/* + Private macros for inflate() + Look in inflate_p.h for macros shared with inflateBack() +*/ -/* check macros for header crc */ -#ifdef GUNZIP -# define CRC2(check, word) \ - do { \ - hbuf[0] = (unsigned char)(word); \ - hbuf[1] = (unsigned char)((word) >> 8); \ - check = PREFIX(crc32)(check, hbuf, 2); \ - } while (0) - -# define CRC4(check, word) \ - do { \ - hbuf[0] = (unsigned char)(word); \ - hbuf[1] = (unsigned char)((word) >> 8); \ - hbuf[2] = (unsigned char)((word) >> 16); \ - hbuf[3] = (unsigned char)((word) >> 24); \ - check = PREFIX(crc32)(check, hbuf, 4); \ - } while (0) -#endif - -/* Load registers with state in inflate() for speed */ -#define LOAD() \ - do { \ - put = strm->next_out; \ - left = strm->avail_out; \ - next = strm->next_in; \ - have = strm->avail_in; \ - hold = state->hold; \ - bits = state->bits; \ - } while (0) - -/* Restore state from registers in inflate() */ -#define RESTORE() \ - do { \ - strm->next_out = put; \ - strm->avail_out = left; \ - strm->next_in = next; \ - strm->avail_in = have; \ - state->hold = hold; \ - state->bits = bits; \ - } while (0) - -/* Clear the input bit accumulator */ -#define INITBITS() \ - do { \ - hold = 0; \ - bits = 0; \ - } while (0) - -/* Get a byte of input into the bit accumulator, or return from inflate() - if there is no input available. */ +/* Get a byte of input into the bit accumulator, or return from inflate() if there is no input available. */ #define PULLBYTE() \ do { \ if (have == 0) goto inf_leave; \ @@ -529,32 +285,6 @@ static int updatewindow(PREFIX3(stream) *strm, const unsigned char *end, uint32_ bits += 8; \ } while (0) -/* Assure that there are at least n bits in the bit accumulator. If there is - not enough available input to do that, then return from inflate(). */ -#define NEEDBITS(n) \ - do { \ - while (bits < (unsigned)(n)) \ - PULLBYTE(); \ - } while (0) - -/* Return the low n bits of the bit accumulator (n < 16) */ -#define BITS(n) \ - (hold & ((1U << (n)) - 1)) - -/* Remove n bits from the bit accumulator */ -#define DROPBITS(n) \ - do { \ - hold >>= (n); \ - bits -= (unsigned)(n); \ - } while (0) - -/* Remove zero to seven bits as needed to go to a byte boundary */ -#define BYTEBITS() \ - do { \ - hold >>= bits & 7; \ - bits -= bits & 7; \ - } while (0) - /* inflate() uses a state machine to process as much input data and generate as much output data as possible before returning. The state machine is @@ -637,7 +367,7 @@ static int updatewindow(PREFIX3(stream) *strm, const unsigned char *end, uint32_ will return Z_BUF_ERROR if it has not reached the end of the stream. */ -int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { +int32_t Z_EXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int32_t flush) { struct inflate_state *state; const unsigned char *next; /* next input */ unsigned char *put; /* next output */ @@ -650,7 +380,7 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { code here; /* current decoding table entry */ code last; /* parent table entry */ unsigned len; /* length to copy for repeats, bits to drop */ - int ret; /* return code */ + int32_t ret; /* return code */ #ifdef GUNZIP unsigned char hbuf[4]; /* buffer for gzip header crc calculation */ #endif @@ -686,7 +416,6 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { state->mode = FLAGS; break; } - state->flags = 0; /* expect zlib header */ if (state->head != NULL) state->head->done = -1; if (!(state->wrap & 1) || /* check if zlib header allowed */ @@ -694,13 +423,11 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { if ( #endif ((BITS(8) << 8) + (hold >> 8)) % 31) { - strm->msg = (char *)"incorrect header check"; - state->mode = BAD; + SET_BAD("incorrect header check"); break; } if (BITS(4) != Z_DEFLATED) { - strm->msg = (char *)"unknown compression method"; - state->mode = BAD; + SET_BAD("unknown compression method"); break; } DROPBITS(4); @@ -708,28 +435,27 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { if (state->wbits == 0) state->wbits = len; if (len > 15 || len > state->wbits) { - strm->msg = (char *)"invalid window size"; - state->mode = BAD; + SET_BAD("invalid window size"); break; } state->dmax = 1U << len; + state->flags = 0; /* indicate zlib header */ Tracev((stderr, "inflate: zlib header ok\n")); - strm->adler = state->check = functable.adler32(0L, NULL, 0); + strm->adler = state->check = ADLER32_INITIAL_VALUE; state->mode = hold & 0x200 ? DICTID : TYPE; INITBITS(); break; #ifdef GUNZIP + case FLAGS: NEEDBITS(16); state->flags = (int)(hold); if ((state->flags & 0xff) != Z_DEFLATED) { - strm->msg = (char *)"unknown compression method"; - state->mode = BAD; + SET_BAD("unknown compression method"); break; } if (state->flags & 0xe000) { - strm->msg = (char *)"unknown header flags set"; - state->mode = BAD; + SET_BAD("unknown header flags set"); break; } if (state->head != NULL) @@ -738,6 +464,7 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { CRC2(state->check, hold); INITBITS(); state->mode = TIME; + case TIME: NEEDBITS(32); if (state->head != NULL) @@ -746,6 +473,7 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { CRC4(state->check, hold); INITBITS(); state->mode = OS; + case OS: NEEDBITS(16); if (state->head != NULL) { @@ -756,6 +484,7 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { CRC2(state->check, hold); INITBITS(); state->mode = EXLEN; + case EXLEN: if (state->flags & 0x0400) { NEEDBITS(16); @@ -769,14 +498,14 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { state->head->extra = NULL; } state->mode = EXTRA; + case EXTRA: if (state->flags & 0x0400) { copy = state->length; if (copy > have) copy = have; if (copy) { - if (state->head != NULL && - state->head->extra != NULL) { + if (state->head != NULL && state->head->extra != NULL) { len = state->head->extra_len - state->length; memcpy(state->head->extra + len, next, len + copy > state->head->extra_max ? @@ -793,6 +522,7 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { } state->length = 0; state->mode = NAME; + case NAME: if (state->flags & 0x0800) { if (have == 0) goto inf_leave; @@ -813,6 +543,7 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { } state->length = 0; state->mode = COMMENT; + case COMMENT: if (state->flags & 0x1000) { if (have == 0) goto inf_leave; @@ -833,12 +564,12 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { state->head->comment = NULL; } state->mode = HCRC; + case HCRC: if (state->flags & 0x0200) { NEEDBITS(16); if ((state->wrap & 4) && hold != (state->check & 0xffff)) { - strm->msg = (char *)"header crc mismatch"; - state->mode = BAD; + SET_BAD("header crc mismatch"); break; } INITBITS(); @@ -856,17 +587,21 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { strm->adler = state->check = ZSWAP32(hold); INITBITS(); state->mode = DICT; + case DICT: if (state->havedict == 0) { RESTORE(); return Z_NEED_DICT; } - strm->adler = state->check = functable.adler32(0L, NULL, 0); + strm->adler = state->check = ADLER32_INITIAL_VALUE; state->mode = TYPE; + case TYPE: if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave; + case TYPEDO: + /* determine and dispatch block type */ INFLATE_TYPEDO_HOOK(strm, flush); /* hook for IBM Z DFLTCC */ if (state->last) { BYTEBITS(); @@ -895,17 +630,17 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { state->mode = TABLE; break; case 3: - strm->msg = (char *)"invalid block type"; - state->mode = BAD; + SET_BAD("invalid block type"); } DROPBITS(2); break; + case STORED: + /* get and verify stored block length */ BYTEBITS(); /* go to byte boundary */ NEEDBITS(32); if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { - strm->msg = (char *)"invalid stored block lengths"; - state->mode = BAD; + SET_BAD("invalid stored block lengths"); break; } state->length = (uint16_t)hold; @@ -914,9 +649,12 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { state->mode = COPY_; if (flush == Z_TREES) goto inf_leave; + case COPY_: state->mode = COPY; + case COPY: + /* copy stored block from input to output */ copy = state->length; if (copy) { if (copy > have) copy = have; @@ -933,7 +671,9 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { Tracev((stderr, "inflate: stored end\n")); state->mode = TYPE; break; + case TABLE: + /* get dynamic table entries descriptor */ NEEDBITS(14); state->nlen = BITS(5) + 257; DROPBITS(5); @@ -943,15 +683,16 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { DROPBITS(4); #ifndef PKZIP_BUG_WORKAROUND if (state->nlen > 286 || state->ndist > 30) { - strm->msg = (char *)"too many length or distance symbols"; - state->mode = BAD; + SET_BAD("too many length or distance symbols"); break; } #endif Tracev((stderr, "inflate: table sizes ok\n")); state->have = 0; state->mode = LENLENS; + case LENLENS: + /* get code length code lengths (not a typo) */ while (state->have < state->ncode) { NEEDBITS(3); state->lens[order[state->have++]] = (uint16_t)BITS(3); @@ -962,16 +703,17 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { state->next = state->codes; state->lencode = (const code *)(state->next); state->lenbits = 7; - ret = inflate_table(CODES, state->lens, 19, &(state->next), &(state->lenbits), state->work); + ret = zng_inflate_table(CODES, state->lens, 19, &(state->next), &(state->lenbits), state->work); if (ret) { - strm->msg = (char *)"invalid code lengths set"; - state->mode = BAD; + SET_BAD("invalid code lengths set"); break; } Tracev((stderr, "inflate: code lengths ok\n")); state->have = 0; state->mode = CODELENS; + case CODELENS: + /* get length and distance code code lengths */ while (state->have < state->nlen + state->ndist) { for (;;) { here = state->lencode[BITS(state->lenbits)]; @@ -986,8 +728,7 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { NEEDBITS(here.bits + 2); DROPBITS(here.bits); if (state->have == 0) { - strm->msg = (char *)"invalid bit length repeat"; - state->mode = BAD; + SET_BAD("invalid bit length repeat"); break; } len = state->lens[state->have - 1]; @@ -1007,8 +748,7 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { DROPBITS(7); } if (state->have + copy > state->nlen + state->ndist) { - strm->msg = (char *)"invalid bit length repeat"; - state->mode = BAD; + SET_BAD("invalid bit length repeat"); break; } while (copy) { @@ -1024,8 +764,7 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { /* check for end-of-block code (better have one) */ if (state->lens[256] == 0) { - strm->msg = (char *)"invalid code -- missing end-of-block"; - state->mode = BAD; + SET_BAD("invalid code -- missing end-of-block"); break; } @@ -1035,38 +774,40 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { state->next = state->codes; state->lencode = (const code *)(state->next); state->lenbits = 9; - ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), &(state->lenbits), state->work); + ret = zng_inflate_table(LENS, state->lens, state->nlen, &(state->next), &(state->lenbits), state->work); if (ret) { - strm->msg = (char *)"invalid literal/lengths set"; - state->mode = BAD; + SET_BAD("invalid literal/lengths set"); break; } state->distcode = (const code *)(state->next); state->distbits = 6; - ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, + ret = zng_inflate_table(DISTS, state->lens + state->nlen, state->ndist, &(state->next), &(state->distbits), state->work); if (ret) { - strm->msg = (char *)"invalid distances set"; - state->mode = BAD; + SET_BAD("invalid distances set"); break; } Tracev((stderr, "inflate: codes ok\n")); state->mode = LEN_; if (flush == Z_TREES) goto inf_leave; + case LEN_: state->mode = LEN; + case LEN: - if (have >= INFLATE_FAST_MIN_HAVE && - left >= INFLATE_FAST_MIN_LEFT) { + /* use inflate_fast() if we have enough input and output */ + if (have >= INFLATE_FAST_MIN_HAVE && left >= INFLATE_FAST_MIN_LEFT) { RESTORE(); - inflate_fast(strm, out); + zng_inflate_fast(strm, out); LOAD(); if (state->mode == TYPE) state->back = -1; break; } state->back = 0; + + /* get a literal, length, or end-of-block code */ for (;;) { here = state->lencode[BITS(state->lenbits)]; if (here.bits <= bits) @@ -1087,6 +828,8 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { DROPBITS(here.bits); state->back += here.bits; state->length = here.val; + + /* process literal */ if ((int)(here.op) == 0) { Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? "inflate: literal '%c'\n" : @@ -1094,20 +837,27 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { state->mode = LIT; break; } + + /* process end of block */ if (here.op & 32) { Tracevv((stderr, "inflate: end of block\n")); state->back = -1; state->mode = TYPE; break; } + + /* invalid code */ if (here.op & 64) { - strm->msg = (char *)"invalid literal/length code"; - state->mode = BAD; + SET_BAD("invalid literal/length code"); break; } + + /* length code */ state->extra = (here.op & 15); state->mode = LENEXT; + case LENEXT: + /* get extra bits, if any */ if (state->extra) { NEEDBITS(state->extra); state->length += BITS(state->extra); @@ -1117,7 +867,9 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { Tracevv((stderr, "inflate: length %u\n", state->length)); state->was = state->length; state->mode = DIST; + case DIST: + /* get distance code */ for (;;) { here = state->distcode[BITS(state->distbits)]; if (here.bits <= bits) @@ -1138,14 +890,15 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { DROPBITS(here.bits); state->back += here.bits; if (here.op & 64) { - strm->msg = (char *)"invalid distance code"; - state->mode = BAD; + SET_BAD("invalid distance code"); break; } state->offset = here.val; state->extra = (here.op & 15); state->mode = DISTEXT; + case DISTEXT: + /* get distance extra bits, if any */ if (state->extra) { NEEDBITS(state->extra); state->offset += BITS(state->extra); @@ -1154,22 +907,22 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { } #ifdef INFLATE_STRICT if (state->offset > state->dmax) { - strm->msg = (char *)"invalid distance too far back"; - state->mode = BAD; + SET_BAD("invalid distance too far back"); break; } #endif Tracevv((stderr, "inflate: distance %u\n", state->offset)); state->mode = MATCH; + case MATCH: + /* copy match from window to output */ if (left == 0) goto inf_leave; copy = out - left; if (state->offset > copy) { /* copy from window */ copy = state->offset - copy; if (copy > state->whave) { if (state->sane) { - strm->msg = (char *)"invalid distance too far back"; - state->mode = BAD; + SET_BAD("invalid distance too far back"); break; } #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR @@ -1199,32 +952,21 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { copy = state->length; if (copy > left) copy = left; -#if defined(INFFAST_CHUNKSIZE) - put = chunkcopysafe(put, from, copy, put + left); -#else - if (copy >= sizeof(uint64_t)) - put = chunk_memcpy(put, from, copy); - else - put = copy_bytes(put, from, copy); -#endif + + put = functable.chunkcopy_safe(put, from, copy, put + left); } else { /* copy from output */ copy = state->length; if (copy > left) copy = left; -#if defined(INFFAST_CHUNKSIZE) - put = chunkmemsetsafe(put, state->offset, copy, left); -#else - if (copy >= sizeof(uint64_t)) - put = chunk_memset(put, put - state->offset, state->offset, copy); - else - put = set_bytes(put, put - state->offset, state->offset, copy); -#endif + + put = functable.chunkmemset_safe(put, state->offset, copy, left); } left -= copy; state->length -= copy; if (state->length == 0) state->mode = LEN; break; + case LIT: if (left == 0) goto inf_leave; @@ -1232,6 +974,7 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { left--; state->mode = LEN; break; + case CHECK: if (state->wrap) { NEEDBITS(32); @@ -1246,8 +989,7 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { state->flags ? hold : #endif ZSWAP32(hold)) != state->check) { - strm->msg = (char *)"incorrect data check"; - state->mode = BAD; + SET_BAD("incorrect data check"); break; } INITBITS(); @@ -1255,12 +997,12 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { } #ifdef GUNZIP state->mode = LENGTH; + case LENGTH: if (state->wrap && state->flags) { NEEDBITS(32); - if (hold != (state->total & 0xffffffffUL)) { - strm->msg = (char *)"incorrect length check"; - state->mode = BAD; + if ((state->wrap & 4) && hold != (state->total & 0xffffffff)) { + SET_BAD("incorrect length check"); break; } INITBITS(); @@ -1268,16 +1010,22 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { } #endif state->mode = DONE; + case DONE: + /* inflate stream terminated properly */ ret = Z_STREAM_END; goto inf_leave; + case BAD: ret = Z_DATA_ERROR; goto inf_leave; + case MEM: return Z_MEM_ERROR; + case SYNC: - default: + + default: /* can't happen, but makes compilers happy */ return Z_STREAM_ERROR; } @@ -1311,7 +1059,7 @@ int ZEXPORT PREFIX(inflate)(PREFIX3(stream) *strm, int flush) { return ret; } -int ZEXPORT PREFIX(inflateEnd)(PREFIX3(stream) *strm) { +int32_t Z_EXPORT PREFIX(inflateEnd)(PREFIX3(stream) *strm) { struct inflate_state *state; if (inflateStateCheck(strm)) return Z_STREAM_ERROR; @@ -1324,7 +1072,7 @@ int ZEXPORT PREFIX(inflateEnd)(PREFIX3(stream) *strm) { return Z_OK; } -int ZEXPORT PREFIX(inflateGetDictionary)(PREFIX3(stream) *strm, unsigned char *dictionary, unsigned int *dictLength) { +int32_t Z_EXPORT PREFIX(inflateGetDictionary)(PREFIX3(stream) *strm, uint8_t *dictionary, uint32_t *dictLength) { struct inflate_state *state; /* check state */ @@ -1342,10 +1090,10 @@ int ZEXPORT PREFIX(inflateGetDictionary)(PREFIX3(stream) *strm, unsigned char *d return Z_OK; } -int ZEXPORT PREFIX(inflateSetDictionary)(PREFIX3(stream) *strm, const unsigned char *dictionary, unsigned int dictLength) { +int32_t Z_EXPORT PREFIX(inflateSetDictionary)(PREFIX3(stream) *strm, const uint8_t *dictionary, uint32_t dictLength) { struct inflate_state *state; unsigned long dictid; - int ret; + int32_t ret; /* check state */ if (inflateStateCheck(strm)) @@ -1356,8 +1104,7 @@ int ZEXPORT PREFIX(inflateSetDictionary)(PREFIX3(stream) *strm, const unsigned c /* check for correct dictionary identifier */ if (state->mode == DICT) { - dictid = functable.adler32(0L, NULL, 0); - dictid = functable.adler32(dictid, dictionary, dictLength); + dictid = functable.adler32(ADLER32_INITIAL_VALUE, dictionary, dictLength); if (dictid != state->check) return Z_DATA_ERROR; } @@ -1374,7 +1121,7 @@ int ZEXPORT PREFIX(inflateSetDictionary)(PREFIX3(stream) *strm, const unsigned c return Z_OK; } -int ZEXPORT PREFIX(inflateGetHeader)(PREFIX3(stream) *strm, PREFIX(gz_headerp) head) { +int32_t Z_EXPORT PREFIX(inflateGetHeader)(PREFIX3(stream) *strm, PREFIX(gz_headerp) head) { struct inflate_state *state; /* check state */ @@ -1401,9 +1148,8 @@ int ZEXPORT PREFIX(inflateGetHeader)(PREFIX3(stream) *strm, PREFIX(gz_headerp) h called again with more data and the *have state. *have is initialized to zero for the first call. */ -static uint32_t syncsearch(uint32_t *have, const unsigned char *buf, uint32_t len) { - uint32_t got; - uint32_t next; +static uint32_t syncsearch(uint32_t *have, const uint8_t *buf, uint32_t len) { + uint32_t got, next; got = *have; next = 0; @@ -1420,8 +1166,9 @@ static uint32_t syncsearch(uint32_t *have, const unsigned char *buf, uint32_t le return next; } -int ZEXPORT PREFIX(inflateSync)(PREFIX3(stream) *strm) { +int32_t Z_EXPORT PREFIX(inflateSync)(PREFIX3(stream) *strm) { unsigned len; /* number of bytes to look at or looked at */ + int flags; /* temporary to save header status */ size_t in, out; /* temporary to save total_in and total_out */ unsigned char buf[4]; /* to restore bit buffer to byte string */ struct inflate_state *state; @@ -1457,13 +1204,17 @@ int ZEXPORT PREFIX(inflateSync)(PREFIX3(stream) *strm) { /* return no joy or set up to restart inflate() on a new block */ if (state->have != 4) return Z_DATA_ERROR; - if (state->mode == HEAD) - state->wrap = 0; /* never processed header, so assume raw */ + if (state->flags == -1) + state->wrap = 0; /* if no header yet, treat as raw */ + else + state->wrap &= ~4; /* no point in computing a check value now */ + flags = state->flags; in = strm->total_in; out = strm->total_out; PREFIX(inflateReset)(strm); strm->total_in = in; strm->total_out = out; + state->flags = flags; state->mode = TYPE; return Z_OK; } @@ -1476,16 +1227,17 @@ int ZEXPORT PREFIX(inflateSync)(PREFIX3(stream) *strm) { block. When decompressing, PPP checks that at the end of input packet, inflate is waiting for these length bytes. */ -int ZEXPORT PREFIX(inflateSyncPoint)(PREFIX3(stream) *strm) { +int32_t Z_EXPORT PREFIX(inflateSyncPoint)(PREFIX3(stream) *strm) { struct inflate_state *state; if (inflateStateCheck(strm)) return Z_STREAM_ERROR; + INFLATE_SYNC_POINT_HOOK(strm); state = (struct inflate_state *)strm->state; return state->mode == STORED && state->bits == 0; } -int ZEXPORT PREFIX(inflateCopy)(PREFIX3(stream) *dest, PREFIX3(stream) *source) { +int32_t Z_EXPORT PREFIX(inflateCopy)(PREFIX3(stream) *dest, PREFIX3(stream) *source) { struct inflate_state *state; struct inflate_state *copy; unsigned char *window; @@ -1497,13 +1249,12 @@ int ZEXPORT PREFIX(inflateCopy)(PREFIX3(stream) *dest, PREFIX3(stream) *source) state = (struct inflate_state *)source->state; /* allocate space */ - copy = (struct inflate_state *) - ZALLOC_STATE(source, 1, sizeof(struct inflate_state)); + copy = (struct inflate_state *)ZALLOC_STATE(source, 1, sizeof(struct inflate_state)); if (copy == NULL) return Z_MEM_ERROR; window = NULL; if (state->window != NULL) { - window = (unsigned char *) ZALLOC_WINDOW(source, 1U << state->wbits, sizeof(unsigned char)); + window = (unsigned char *)ZALLOC_WINDOW(source, 1U << state->wbits, sizeof(unsigned char)); if (window == NULL) { ZFREE_STATE(source, copy); return Z_MEM_ERROR; @@ -1528,7 +1279,7 @@ int ZEXPORT PREFIX(inflateCopy)(PREFIX3(stream) *dest, PREFIX3(stream) *source) return Z_OK; } -int ZEXPORT PREFIX(inflateUndermine)(PREFIX3(stream) *strm, int subvert) { +int32_t Z_EXPORT PREFIX(inflateUndermine)(PREFIX3(stream) *strm, int32_t subvert) { struct inflate_state *state; if (inflateStateCheck(strm)) @@ -1544,7 +1295,7 @@ int ZEXPORT PREFIX(inflateUndermine)(PREFIX3(stream) *strm, int subvert) { #endif } -int ZEXPORT PREFIX(inflateValidate)(PREFIX3(stream) *strm, int check) { +int32_t Z_EXPORT PREFIX(inflateValidate)(PREFIX3(stream) *strm, int32_t check) { struct inflate_state *state; if (inflateStateCheck(strm)) @@ -1557,18 +1308,19 @@ int ZEXPORT PREFIX(inflateValidate)(PREFIX3(stream) *strm, int check) { return Z_OK; } -long ZEXPORT PREFIX(inflateMark)(PREFIX3(stream) *strm) { +long Z_EXPORT PREFIX(inflateMark)(PREFIX3(stream) *strm) { struct inflate_state *state; if (inflateStateCheck(strm)) return -65536; INFLATE_MARK_HOOK(strm); /* hook for IBM Z DFLTCC */ state = (struct inflate_state *)strm->state; - return ((long)(state->back) << 16) + (state->mode == COPY ? state->length : + return (long)(((unsigned long)((long)state->back)) << 16) + + (state->mode == COPY ? state->length : (state->mode == MATCH ? state->was - state->length : 0)); } -unsigned long ZEXPORT PREFIX(inflateCodesUsed)(PREFIX3(stream) *strm) { +unsigned long Z_EXPORT PREFIX(inflateCodesUsed)(PREFIX3(stream) *strm) { struct inflate_state *state; if (strm == NULL || strm->state == NULL) return (unsigned long)-1; diff --git a/libs/zlibng/inflate.h b/libs/zlibng/inflate.h index 01fb1f9b0..a42749465 100644 --- a/libs/zlibng/inflate.h +++ b/libs/zlibng/inflate.h @@ -11,10 +11,9 @@ #ifndef INFLATE_H_ #define INFLATE_H_ -/* define NO_GZIP when compiling if you want to disable gzip header and - trailer decoding by inflate(). NO_GZIP would be used to avoid linking in - the crc code when it is not needed. For shared libraries, gzip decoding - should be left enabled. */ +/* define NO_GZIP when compiling if you want to disable gzip header and trailer decoding by inflate(). + NO_GZIP would be used to avoid linking in the crc code when it is not needed. + For shared libraries, gzip decoding should be left enabled. */ #ifndef NO_GZIP # define GUNZIP #endif @@ -89,7 +88,8 @@ struct inflate_state { int wrap; /* bit 0 true for zlib, bit 1 true for gzip, bit 2 true to validate check value */ int havedict; /* true if dictionary provided */ - int flags; /* gzip header method and flags (0 if zlib) */ + int flags; /* gzip header method and flags, 0 if zlib, or + -1 if raw or no header yet */ unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */ unsigned long check; /* protected copy of check value */ unsigned long total; /* protected copy of output count */ @@ -125,8 +125,10 @@ struct inflate_state { int sane; /* if false, allow invalid distance too far */ int back; /* bits back of last unprocessed length/lit */ unsigned was; /* initial length of match */ + uint32_t chunksize; /* size of memory copying chunk */ }; -int ZLIB_INTERNAL inflate_ensure_window(struct inflate_state *state); +int Z_INTERNAL inflate_ensure_window(struct inflate_state *state); +void Z_INTERNAL fixedtables(struct inflate_state *state); #endif /* INFLATE_H_ */ diff --git a/libs/zlibng/inflate_p.h b/libs/zlibng/inflate_p.h new file mode 100644 index 000000000..76fe2dccb --- /dev/null +++ b/libs/zlibng/inflate_p.h @@ -0,0 +1,101 @@ +/* inflate_p.h -- Private inline functions and macros shared with more than one deflate method + * + */ + +#ifndef INFLATE_P_H +#define INFLATE_P_H + +/* + * Macros shared by inflate() and inflateBack() + */ + +/* check function to use adler32() for zlib or crc32() for gzip */ +#ifdef GUNZIP +# define UPDATE(check, buf, len) \ + (state->flags ? PREFIX(crc32)(check, buf, len) : functable.adler32(check, buf, len)) +#else +# define UPDATE(check, buf, len) functable.adler32(check, buf, len) +#endif + +/* check macros for header crc */ +#ifdef GUNZIP +# define CRC2(check, word) \ + do { \ + hbuf[0] = (unsigned char)(word); \ + hbuf[1] = (unsigned char)((word) >> 8); \ + check = PREFIX(crc32)(check, hbuf, 2); \ + } while (0) + +# define CRC4(check, word) \ + do { \ + hbuf[0] = (unsigned char)(word); \ + hbuf[1] = (unsigned char)((word) >> 8); \ + hbuf[2] = (unsigned char)((word) >> 16); \ + hbuf[3] = (unsigned char)((word) >> 24); \ + check = PREFIX(crc32)(check, hbuf, 4); \ + } while (0) +#endif + +/* Load registers with state in inflate() for speed */ +#define LOAD() \ + do { \ + put = strm->next_out; \ + left = strm->avail_out; \ + next = strm->next_in; \ + have = strm->avail_in; \ + hold = state->hold; \ + bits = state->bits; \ + } while (0) + +/* Restore state from registers in inflate() */ +#define RESTORE() \ + do { \ + strm->next_out = put; \ + strm->avail_out = left; \ + strm->next_in = (z_const unsigned char *)next; \ + strm->avail_in = have; \ + state->hold = hold; \ + state->bits = bits; \ + } while (0) + +/* Clear the input bit accumulator */ +#define INITBITS() \ + do { \ + hold = 0; \ + bits = 0; \ + } while (0) + +/* Ensure that there is at least n bits in the bit accumulator. If there is + not enough available input to do that, then return from inflate()/inflateBack(). */ +#define NEEDBITS(n) \ + do { \ + while (bits < (unsigned)(n)) \ + PULLBYTE(); \ + } while (0) + +/* Return the low n bits of the bit accumulator (n < 16) */ +#define BITS(n) \ + (hold & ((1U << (unsigned)(n)) - 1)) + +/* Remove n bits from the bit accumulator */ +#define DROPBITS(n) \ + do { \ + hold >>= (n); \ + bits -= (unsigned)(n); \ + } while (0) + +/* Remove zero to seven bits as needed to go to a byte boundary */ +#define BYTEBITS() \ + do { \ + hold >>= bits & 7; \ + bits -= bits & 7; \ + } while (0) + +#endif + +/* Set mode=BAD and prepare error message */ +#define SET_BAD(errmsg) \ + do { \ + state->mode = BAD; \ + strm->msg = (char *)errmsg; \ + } while (0) diff --git a/libs/zlibng/inftrees.c b/libs/zlibng/inftrees.c index 51e85375c..faf1d249d 100644 --- a/libs/zlibng/inftrees.c +++ b/libs/zlibng/inftrees.c @@ -9,7 +9,7 @@ #define MAXBITS 15 -const char inflate_copyright[] = " inflate 1.2.11.f Copyright 1995-2016 Mark Adler "; +const char PREFIX(inflate_copyright)[] = " inflate 1.2.11.f Copyright 1995-2016 Mark Adler "; /* If you use the zlib library in a product, an acknowledgment is welcome in the documentation of your product. If for some reason you cannot @@ -29,8 +29,8 @@ const char inflate_copyright[] = " inflate 1.2.11.f Copyright 1995-2016 Mark Adl table index bits. It will differ if the request is greater than the longest code or if it is less than the shortest code. */ -int ZLIB_INTERNAL inflate_table(codetype type, uint16_t *lens, unsigned codes, - code * *table, unsigned *bits, uint16_t *work) { +int Z_INTERNAL zng_inflate_table(codetype type, uint16_t *lens, unsigned codes, + code * *table, unsigned *bits, uint16_t *work) { unsigned len; /* a code's length in bits */ unsigned sym; /* index of code symbols */ unsigned min, max; /* minimum and maximum code lengths */ diff --git a/libs/zlibng/inftrees.h b/libs/zlibng/inftrees.h index eaf3df1ca..7758737c2 100644 --- a/libs/zlibng/inftrees.h +++ b/libs/zlibng/inftrees.h @@ -60,7 +60,7 @@ typedef enum { DISTS } codetype; -int ZLIB_INTERNAL inflate_table (codetype type, uint16_t *lens, unsigned codes, +int Z_INTERNAL zng_inflate_table (codetype type, uint16_t *lens, unsigned codes, code * *table, unsigned *bits, uint16_t *work); #endif /* INFTREES_H_ */ diff --git a/libs/zlibng/insert_string.c b/libs/zlibng/insert_string.c new file mode 100644 index 000000000..4ddf9ae5d --- /dev/null +++ b/libs/zlibng/insert_string.c @@ -0,0 +1,25 @@ +/* insert_string_c -- insert_string variant for c + * + * Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + * + */ + +#include "zbuild.h" +#include "deflate.h" + +/* =========================================================================== + * Update a hash value with the given input byte + * IN assertion: all calls to to UPDATE_HASH are made with consecutive + * input characters, so that a running hash key can be computed from the + * previous key instead of complete recalculation each time. + */ +#define HASH_SLIDE 16 // Number of bits to slide hash + +#define UPDATE_HASH(s, h, val) \ + h = ((val * 2654435761U) >> HASH_SLIDE); + +#define INSERT_STRING insert_string_c +#define QUICK_INSERT_STRING quick_insert_string_c + +#include "insert_string_tpl.h" diff --git a/libs/zlibng/insert_string_tpl.h b/libs/zlibng/insert_string_tpl.h new file mode 100644 index 000000000..9796e5196 --- /dev/null +++ b/libs/zlibng/insert_string_tpl.h @@ -0,0 +1,89 @@ +#ifndef INSERT_STRING_H_ +#define INSERT_STRING_H_ + +/* insert_string.h -- Private insert_string functions shared with more than + * one insert string implementation + * + * Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler + * + * Copyright (C) 2013 Intel Corporation. All rights reserved. + * Authors: + * Wajdi Feghali + * Jim Guilford + * Vinodh Gopal + * Erdinc Ozturk + * Jim Kukunas + * + * Portions are Copyright (C) 2016 12Sided Technology, LLC. + * Author: + * Phil Vachon + * + * For conditions of distribution and use, see copyright notice in zlib.h + * + */ + +/* =========================================================================== + * Quick insert string str in the dictionary and set match_head to the previous head + * of the hash chain (the most recent string with same hash key). Return + * the previous length of the hash chain. + */ +Z_INTERNAL Pos QUICK_INSERT_STRING(deflate_state *const s, const uint32_t str) { + Pos head; + uint8_t *strstart = s->window + str; + uint32_t val, hm, h = 0; + +#ifdef UNALIGNED_OK + val = *(uint32_t *)(strstart); +#else + val = ((uint32_t)(strstart[0])); + val |= ((uint32_t)(strstart[1]) << 8); + val |= ((uint32_t)(strstart[2]) << 16); + val |= ((uint32_t)(strstart[3]) << 24); +#endif + + UPDATE_HASH(s, h, val); + hm = h & HASH_MASK; + + head = s->head[hm]; + if (LIKELY(head != str)) { + s->prev[str & s->w_mask] = head; + s->head[hm] = (Pos)str; + } + return head; +} + +/* =========================================================================== + * Insert string str in the dictionary and set match_head to the previous head + * of the hash chain (the most recent string with same hash key). Return + * the previous length of the hash chain. + * IN assertion: all calls to to INSERT_STRING are made with consecutive + * input characters and the first MIN_MATCH bytes of str are valid + * (except for the last MIN_MATCH-1 bytes of the input file). + */ +Z_INTERNAL void INSERT_STRING(deflate_state *const s, const uint32_t str, uint32_t count) { + uint8_t *strstart = s->window + str; + uint8_t *strend = strstart + count - 1; /* last position */ + + for (Pos idx = (Pos)str; strstart <= strend; idx++, strstart++) { + uint32_t val, hm, h = 0; + +#ifdef UNALIGNED_OK + val = *(uint32_t *)(strstart); +#else + val = ((uint32_t)(strstart[0])); + val |= ((uint32_t)(strstart[1]) << 8); + val |= ((uint32_t)(strstart[2]) << 16); + val |= ((uint32_t)(strstart[3]) << 24); +#endif + + UPDATE_HASH(s, h, val); + hm = h & HASH_MASK; + + Pos head = s->head[hm]; + if (LIKELY(head != idx)) { + s->prev[idx & s->w_mask] = head; + s->head[hm] = idx; + } + } +} +#endif diff --git a/libs/zlibng/match_p.h b/libs/zlibng/match_p.h deleted file mode 100644 index b956d8d52..000000000 --- a/libs/zlibng/match_p.h +++ /dev/null @@ -1,512 +0,0 @@ -/* - * Set match_start to the longest match starting at the given string and - * return its length. Matches shorter or equal to prev_length are discarded, - * in which case the result is equal to prev_length and match_start is garbage. - * - * IN assertions: cur_match is the head of the hash chain for the current - * string (strstart) and its distance is <= MAX_DIST, and prev_length >=1 - * OUT assertion: the match length is not greater than s->lookahead - */ - -#include "zbuild.h" -#include "deflate.h" - -#if (defined(UNALIGNED_OK) && MAX_MATCH == 258) - - /* ARM 32-bit clang/gcc builds perform better, on average, with std2. Both gcc and clang and define __GNUC__. */ -# if defined(__GNUC__) && defined(__arm__) && !defined(__aarch64__) -# define std2_longest_match - /* Only use std3_longest_match for little_endian systems, also avoid using it with - non-gcc compilers since the __builtin_ctzl() function might not be optimized. */ -# elif(defined(__GNUC__) && defined(HAVE_BUILTIN_CTZL) && ((__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) \ - || defined(__LITTLE_ENDIAN__))) -# define std3_longest_match -# elif(defined(_MSC_VER) && defined(_WIN32)) -# define std3_longest_match -# else -# define std2_longest_match -# endif - -#else -# define std1_longest_match -#endif - - -#if defined(_MSC_VER) && !defined(__clang__) -# if defined(_M_IX86) || defined(_M_AMD64) || defined(_M_IA64) -# include "arch/x86/ctzl.h" -# elif defined(_M_ARM) -# include "arch/arm/ctzl.h" -# endif -#endif - - - -#ifdef std1_longest_match - -/* - * Standard longest_match - * - */ -static inline unsigned longest_match(deflate_state *const s, IPos cur_match) { - const unsigned wmask = s->w_mask; - const Pos *prev = s->prev; - - unsigned chain_length; - IPos limit; - unsigned int len, best_len, nice_match; - unsigned char *scan, *match, *strend, scan_end, scan_end1; - - /* - * The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple - * of 16. It is easy to get rid of this optimization if necessary. - */ - Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); - - /* - * Do not waste too much time if we already have a good match - */ - best_len = s->prev_length; - chain_length = s->max_chain_length; - if (best_len >= s->good_match) - chain_length >>= 2; - - /* - * Do not looks for matches beyond the end of the input. This is - * necessary to make deflate deterministic - */ - nice_match = (unsigned int)s->nice_match > s->lookahead ? s->lookahead : (unsigned int)s->nice_match; - - /* - * Stop when cur_match becomes <= limit. To simplify the code, - * we prevent matches with the string of window index 0 - */ - limit = s->strstart > MAX_DIST(s) ? s->strstart - MAX_DIST(s) : 0; - - scan = s->window + s->strstart; - strend = s->window + s->strstart + MAX_MATCH; - scan_end1 = scan[best_len-1]; - scan_end = scan[best_len]; - - Assert((unsigned long)s->strstart <= s->window_size - MIN_LOOKAHEAD, "need lookahead"); - do { - if (cur_match >= s->strstart) { - break; - } - match = s->window + cur_match; - - /* - * Skip to next match if the match length cannot increase - * or if the match length is less than 2. Note that the checks - * below for insufficient lookahead only occur occasionally - * for performance reasons. Therefore uninitialized memory - * will be accessed and conditional jumps will be made that - * depend on those values. However the length of the match - * is limited to the lookahead, so the output of deflate is not - * affected by the uninitialized values. - */ - if (match[best_len] != scan_end || - match[best_len-1] != scan_end1 || - *match != *scan || - *++match != scan[1]) - continue; - - /* - * The check at best_len-1 can be removed because it will - * be made again later. (This heuristic is not always a win.) - * It is not necessary to compare scan[2] and match[2] since - * they are always equal when the other bytes match, given - * that the hash keys are equal and that HASH_BITS >= 8. - */ - scan += 2; - match++; - Assert(*scan == *match, "match[2]?"); - - /* - * We check for insufficient lookahead only every 8th - * comparision; the 256th check will be made at strstart + 258. - */ - do { - } while (*++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - *++scan == *++match && *++scan == *++match && - scan < strend); - - Assert(scan <= s->window+(unsigned int)(s->window_size-1), "wild scan"); - - len = MAX_MATCH - (int)(strend - scan); - scan = strend - MAX_MATCH; - - if (len > best_len) { - s->match_start = cur_match; - best_len = len; - if (len >= nice_match) - break; - scan_end1 = scan[best_len-1]; - scan_end = scan[best_len]; - } else { - /* - * The probability of finding a match later if we here - * is pretty low, so for performance it's best to - * outright stop here for the lower compression levels - */ - if (s->level < TRIGGER_LEVEL) - break; - } - } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length); - - if ((unsigned int)best_len <= s->lookahead) - return best_len; - return s->lookahead; -} -#endif - -#ifdef std2_longest_match -/* - * UNALIGNED_OK longest_match - * - */ -static inline unsigned longest_match(deflate_state *const s, IPos cur_match) { - const unsigned wmask = s->w_mask; - const Pos *prev = s->prev; - - uint16_t scan_start, scan_end; - unsigned chain_length; - IPos limit; - unsigned int len, best_len, nice_match; - unsigned char *scan, *strend; - - /* - * The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple - * of 16. It is easy to get rid of this optimization if necessary. - */ - Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); - - /* - * Do not waste too much time if we already have a good match - */ - best_len = s->prev_length; - chain_length = s->max_chain_length; - if (best_len >= s->good_match) - chain_length >>= 2; - - /* - * Do not look for matches beyond the end of the input. This is - * necessary to make deflate deterministic - */ - nice_match = (unsigned int)s->nice_match > s->lookahead ? s->lookahead : s->nice_match; - - /* - * Stop when cur_match becomes <= limit. To simplify the code, - * we prevent matches with the string of window index 0 - */ - limit = s->strstart > MAX_DIST(s) ? s->strstart - MAX_DIST(s) : 0; - - scan = s->window + s->strstart; - strend = s->window + s->strstart + MAX_MATCH - 1; - memcpy(&scan_start, scan, sizeof(scan_start)); - memcpy(&scan_end, scan + best_len - 1, sizeof(scan_end)); - - Assert((unsigned long)s->strstart <= s->window_size - MIN_LOOKAHEAD, "need lookahead"); - do { - unsigned char *match; - if (cur_match >= s->strstart) { - break; - } - match = s->window + cur_match; - - /* - * Skip to next match if the match length cannot increase - * or if the match length is less than 2. Note that the checks - * below for insufficient lookahead only occur occasionally - * for performance reasons. Therefore uninitialized memory - * will be accessed and conditional jumps will be made that - * depend on those values. However the length of the match - * is limited to the lookahead, so the output of deflate is not - * affected by the uninitialized values. - */ - uint16_t val; - memcpy(&val, match + best_len - 1, sizeof(val)); - if (likely(val != scan_end)) - continue; - - memcpy(&val, match, sizeof(val)); - if (val != scan_start) - continue; - - /* It is not necessary to compare scan[2] and match[2] since - * they are always equal when the other bytes match, given that - * the hash keys are equal and that HASH_BITS >= 8. Compare 2 - * bytes at a time at strstart+3, +5, ... up to strstart+257. - * We check for insufficient lookahead only every 4th - * comparison; the 128th check will be made at strstart+257. - * If MAX_MATCH-2 is not a multiple of 8, it is necessary to - * put more guard bytes at the end of the window, or to check - * more often for insufficient lookahead. - */ - Assert(scan[2] == match[2], "scan[2]?"); - scan++; - match++; - - do { - uint16_t mval, sval; - - memcpy(&mval, match, sizeof(mval)); - memcpy(&sval, scan, sizeof(sval)); - if (mval != sval) - break; - match += sizeof(mval); - scan += sizeof(sval); - - memcpy(&mval, match, sizeof(mval)); - memcpy(&sval, scan, sizeof(sval)); - if (mval != sval) - break; - match += sizeof(mval); - scan += sizeof(sval); - - memcpy(&mval, match, sizeof(mval)); - memcpy(&sval, scan, sizeof(sval)); - if (mval != sval) - break; - match += sizeof(mval); - scan += sizeof(sval); - - memcpy(&mval, match, sizeof(mval)); - memcpy(&sval, scan, sizeof(sval)); - if (mval != sval) - break; - match += sizeof(mval); - scan += sizeof(sval); - } while (scan < strend); - - /* - * Here, scan <= window + strstart + 257 - */ - Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); - if (*scan == *match) - scan++; - - len = (MAX_MATCH -1) - (int)(strend-scan); - scan = strend - (MAX_MATCH-1); - - if (len > best_len) { - s->match_start = cur_match; - best_len = len; - if (len >= nice_match) - break; - memcpy(&scan_end, scan + best_len - 1, sizeof(scan_end)); - } else { - /* - * The probability of finding a match later if we here - * is pretty low, so for performance it's best to - * outright stop here for the lower compression levels - */ - if (s->level < TRIGGER_LEVEL) - break; - } - } while (--chain_length && (cur_match = prev[cur_match & wmask]) > limit); - - if ((unsigned)best_len <= s->lookahead) - return best_len; - return s->lookahead; -} -#endif - -#ifdef std3_longest_match -/* longest_match() with minor change to improve performance (in terms of - * execution time). - * - * The pristine longest_match() function is sketched below (strip the - * then-clause of the "#ifdef UNALIGNED_OK"-directive) - * - * ------------------------------------------------------------ - * unsigned int longest_match(...) { - * ... - * do { - * match = s->window + cur_match; //s0 - * if (*(ushf*)(match+best_len-1) != scan_end || //s1 - * *(ushf*)match != scan_start) continue; //s2 - * ... - * - * do { - * } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && - * *(ushf*)(scan+=2) == *(ushf*)(match+=2) && - * *(ushf*)(scan+=2) == *(ushf*)(match+=2) && - * *(ushf*)(scan+=2) == *(ushf*)(match+=2) && - * scan < strend); //s3 - * - * ... - * } while(cond); //s4 - * - * ------------------------------------------------------------- - * - * The change include: - * - * 1) The hottest statements of the function is: s0, s1 and s4. Pull them - * together to form a new loop. The benefit is two-fold: - * - * o. Ease the compiler to yield good code layout: the conditional-branch - * corresponding to s1 and its biased target s4 become very close (likely, - * fit in the same cache-line), hence improving instruction-fetching - * efficiency. - * - * o. Ease the compiler to promote "s->window" into register. "s->window" - * is loop-invariant; it is supposed to be promoted into register and keep - * the value throughout the entire loop. However, there are many such - * loop-invariant, and x86-family has small register file; "s->window" is - * likely to be chosen as register-allocation victim such that its value - * is reloaded from memory in every single iteration. By forming a new loop, - * "s->window" is loop-invariant of that newly created tight loop. It is - * lot easier for compiler to promote this quantity to register and keep - * its value throughout the entire small loop. - * - * 2) Transfrom s3 such that it examines sizeof(long)-byte-match at a time. - * This is done by: - * ------------------------------------------------ - * v1 = load from "scan" by sizeof(long) bytes - * v2 = load from "match" by sizeof(lnog) bytes - * v3 = v1 xor v2 - * match-bit = little-endian-machine(yes-for-x86) ? - * count-trailing-zero(v3) : - * count-leading-zero(v3); - * - * match-byte = match-bit/8 - * - * "scan" and "match" advance if necessary - * ------------------------------------------------- - */ - -static inline unsigned longest_match(deflate_state *const s, IPos cur_match) { - unsigned int strstart = s->strstart; - unsigned chain_length = s->max_chain_length;/* max hash chain length */ - unsigned char *window = s->window; - register unsigned char *scan = window + strstart; /* current string */ - register unsigned char *match; /* matched string */ - register unsigned int len; /* length of current match */ - unsigned int best_len = s->prev_length; /* best match length so far */ - unsigned int nice_match = s->nice_match; /* stop if match long enough */ - IPos limit = strstart > (IPos)MAX_DIST(s) ? - strstart - (IPos)MAX_DIST(s) : NIL; - /* Stop when cur_match becomes <= limit. To simplify the code, - * we prevent matches with the string of window index 0. - */ - Pos *prev = s->prev; - unsigned int wmask = s->w_mask; - - register unsigned char *strend = window + strstart + MAX_MATCH; - - uint16_t scan_start, scan_end; - - memcpy(&scan_start, scan, sizeof(scan_start)); - memcpy(&scan_end, scan+best_len-1, sizeof(scan_end)); - - /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. - * It is easy to get rid of this optimization if necessary. - */ - Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); - - /* Do not waste too much time if we already have a good match: */ - if (s->prev_length >= s->good_match) { - chain_length >>= 2; - } - /* Do not look for matches beyond the end of the input. This is necessary - * to make deflate deterministic. - */ - if ((unsigned int)nice_match > s->lookahead) nice_match = s->lookahead; - - Assert((unsigned long)strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); - - do { - if (cur_match >= strstart) { - break; - } - - /* Skip to next match if the match length cannot increase - * or if the match length is less than 2. Note that the checks below - * for insufficient lookahead only occur occasionally for performance - * reasons. Therefore uninitialized memory will be accessed, and - * conditional jumps will be made that depend on those values. - * However the length of the match is limited to the lookahead, so - * the output of deflate is not affected by the uninitialized values. - */ - int cont = 1; - do { - match = window + cur_match; - if (likely(memcmp(match+best_len-1, &scan_end, sizeof(scan_end)) != 0)) { - if ((cur_match = prev[cur_match & wmask]) > limit - && --chain_length != 0) { - continue; - } else { - cont = 0; - } - } - break; - } while (1); - - if (!cont) - break; - - if (memcmp(match, &scan_start, sizeof(scan_start)) != 0) - continue; - - /* It is not necessary to compare scan[2] and match[2] since they are - * always equal when the other bytes match, given that the hash keys - * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at - * strstart+3, +5, ... up to strstart+257. We check for insufficient - * lookahead only every 4th comparison; the 128th check will be made - * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is - * necessary to put more guard bytes at the end of the window, or - * to check more often for insufficient lookahead. - */ - scan += 2, match+=2; - Assert(*scan == *match, "match[2]?"); - do { - unsigned long sv, mv, xor; - - memcpy(&sv, scan, sizeof(sv)); - memcpy(&mv, match, sizeof(mv)); - - xor = sv ^ mv; - - if (xor) { - int match_byte = __builtin_ctzl(xor) / 8; - scan += match_byte; - break; - } else { - scan += sizeof(unsigned long); - match += sizeof(unsigned long); - } - } while (scan < strend); - - if (scan > strend) - scan = strend; - - Assert(scan <= window + (unsigned)(s->window_size-1), "wild scan"); - - len = MAX_MATCH - (int)(strend - scan); - scan = strend - MAX_MATCH; - - if (len > best_len) { - s->match_start = cur_match; - best_len = len; - if (len >= nice_match) - break; - memcpy(&scan_end, scan+best_len-1, sizeof(scan_end)); - } else { - /* - * The probability of finding a match later if we here - * is pretty low, so for performance it's best to - * outright stop here for the lower compression levels - */ - if (s->level < TRIGGER_LEVEL) - break; - } - } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length != 0); - - if ((unsigned int)best_len <= s->lookahead) - return (unsigned int)best_len; - return s->lookahead; -} -#endif diff --git a/libs/zlibng/match_tpl.h b/libs/zlibng/match_tpl.h new file mode 100644 index 000000000..b15ca17b9 --- /dev/null +++ b/libs/zlibng/match_tpl.h @@ -0,0 +1,180 @@ + +#include "zbuild.h" +#include "deflate.h" +#include "functable.h" + +#ifndef MATCH_TPL_H +#define MATCH_TPL_H + +#ifdef UNALIGNED_OK +# ifdef UNALIGNED64_OK +typedef uint64_t bestcmp_t; +# else +typedef uint32_t bestcmp_t; +# endif +#else +typedef uint8_t bestcmp_t; +#endif + +#define EARLY_EXIT_TRIGGER_LEVEL 5 + +#endif + +/* Set match_start to the longest match starting at the given string and + * return its length. Matches shorter or equal to prev_length are discarded, + * in which case the result is equal to prev_length and match_start is garbage. + * + * IN assertions: cur_match is the head of the hash chain for the current + * string (strstart) and its distance is <= MAX_DIST, and prev_length >=1 + * OUT assertion: the match length is not greater than s->lookahead + */ +Z_INTERNAL uint32_t LONGEST_MATCH(deflate_state *const s, Pos cur_match) { + unsigned int strstart = s->strstart; + const unsigned wmask = s->w_mask; + unsigned char *window = s->window; + unsigned char *scan = window + strstart; + Z_REGISTER unsigned char *mbase_start = window; + Z_REGISTER unsigned char *mbase_end; + const Pos *prev = s->prev; + Pos limit; + int32_t early_exit; + uint32_t chain_length, nice_match, best_len, offset; + uint32_t lookahead = s->lookahead; + bestcmp_t scan_end; +#ifndef UNALIGNED_OK + bestcmp_t scan_end0; +#else + bestcmp_t scan_start; +#endif + +#define GOTO_NEXT_CHAIN \ + if (--chain_length && (cur_match = prev[cur_match & wmask]) > limit) \ + continue; \ + return best_len; + + /* The code is optimized for MAX_MATCH-2 multiple of 16. */ + Assert(MAX_MATCH == 258, "Code too clever"); + + best_len = s->prev_length ? s->prev_length : 1; + + /* Calculate read offset which should only extend an extra byte + * to find the next best match length. + */ + offset = best_len-1; +#ifdef UNALIGNED_OK + if (best_len >= sizeof(uint32_t)) { + offset -= 2; +#ifdef UNALIGNED64_OK + if (best_len >= sizeof(uint64_t)) + offset -= 4; +#endif + } +#endif + + scan_end = *(bestcmp_t *)(scan+offset); +#ifndef UNALIGNED_OK + scan_end0 = *(bestcmp_t *)(scan+offset+1); +#else + scan_start = *(bestcmp_t *)(scan); +#endif + mbase_end = (mbase_start+offset); + + /* Do not waste too much time if we already have a good match */ + chain_length = s->max_chain_length; + early_exit = s->level < EARLY_EXIT_TRIGGER_LEVEL; + if (best_len >= s->good_match) + chain_length >>= 2; + nice_match = (uint32_t)s->nice_match; + + /* Stop when cur_match becomes <= limit. To simplify the code, + * we prevent matches with the string of window index 0 + */ + limit = strstart > MAX_DIST(s) ? (Pos)(strstart - MAX_DIST(s)) : 0; + + Assert((unsigned long)strstart <= s->window_size - MIN_LOOKAHEAD, "need lookahead"); + for (;;) { + if (cur_match >= strstart) + break; + + /* Skip to next match if the match length cannot increase or if the match length is + * less than 2. Note that the checks below for insufficient lookahead only occur + * occasionally for performance reasons. + * Therefore uninitialized memory will be accessed and conditional jumps will be made + * that depend on those values. However the length of the match is limited to the + * lookahead, so the output of deflate is not affected by the uninitialized values. + */ +#ifdef UNALIGNED_OK + if (best_len < sizeof(uint32_t)) { + for (;;) { + if (*(uint16_t *)(mbase_end+cur_match) == (uint16_t)scan_end && + *(uint16_t *)(mbase_start+cur_match) == (uint16_t)scan_start) + break; + GOTO_NEXT_CHAIN; + } +# ifdef UNALIGNED64_OK + } else if (best_len >= sizeof(uint64_t)) { + for (;;) { + if (*(uint64_t *)(mbase_end+cur_match) == (uint64_t)scan_end && + *(uint64_t *)(mbase_start+cur_match) == (uint64_t)scan_start) + break; + GOTO_NEXT_CHAIN; + } +# endif + } else { + for (;;) { + if (*(uint32_t *)(mbase_end+cur_match) == (uint32_t)scan_end && + *(uint32_t *)(mbase_start+cur_match) == (uint32_t)scan_start) + break; + GOTO_NEXT_CHAIN; + } + } +#else + for (;;) { + if (mbase_end[cur_match] == scan_end && mbase_end[cur_match+1] == scan_end0 && + mbase_start[cur_match] == scan[0] && mbase_start[cur_match+1] == scan[1]) + break; + GOTO_NEXT_CHAIN; + } +#endif + uint32_t len = COMPARE256(scan+2, mbase_start+cur_match+2) + 2; + Assert(scan+len <= window+(unsigned)(s->window_size-1), "wild scan"); + + if (len > best_len) { + s->match_start = cur_match; + /* Do not look for matches beyond the end of the input. */ + if (len > lookahead) + return lookahead; + best_len = len; + if (best_len >= nice_match) + return best_len; + + offset = best_len-1; +#ifdef UNALIGNED_OK + if (best_len >= sizeof(uint32_t)) { + offset -= 2; +#ifdef UNALIGNED64_OK + if (best_len >= sizeof(uint64_t)) + offset -= 4; +#endif + } +#endif + scan_end = *(bestcmp_t *)(scan+offset); +#ifndef UNALIGNED_OK + scan_end0 = *(bestcmp_t *)(scan+offset+1); +#endif + mbase_end = (mbase_start+offset); + } else if (UNLIKELY(early_exit)) { + /* The probability of finding a match later if we here is pretty low, so for + * performance it's best to outright stop here for the lower compression levels + */ + break; + } + GOTO_NEXT_CHAIN; + } + + return best_len; +} + +#undef LONGEST_MATCH +#undef COMPARE256 +#undef COMPARE258 diff --git a/libs/zlibng/memcopy.h b/libs/zlibng/memcopy.h deleted file mode 100644 index 301aa5f73..000000000 --- a/libs/zlibng/memcopy.h +++ /dev/null @@ -1,674 +0,0 @@ -/* memcopy.h -- inline functions to copy small data chunks. - * For conditions of distribution and use, see copyright notice in zlib.h - */ -#ifndef MEMCOPY_H_ - #define MEMCOPY_H_ - - #include "gzendian.h" - -/* Load 64 bits from IN and place the bytes at offset BITS in the result. */ -static inline uint64_t load_64_bits(const unsigned char *in, unsigned bits) { - uint64_t chunk; - memcpy(&chunk, in, sizeof(chunk)); - - #if BYTE_ORDER == LITTLE_ENDIAN - return chunk << bits; - #else - return ZSWAP64(chunk) << bits; - #endif -} - - #if (defined(__GNUC__) || defined(__clang__)) && defined(__ARM_NEON__) - #include -typedef uint8x16_t inffast_chunk_t; - #define INFFAST_CHUNKSIZE sizeof(inffast_chunk_t) - #endif - - #if defined(X86_SSE2) - #include -typedef __m128i inffast_chunk_t; - #define INFFAST_CHUNKSIZE sizeof(inffast_chunk_t) - #endif - - #ifdef INFFAST_CHUNKSIZE -/* - Ask the compiler to perform a wide, unaligned load with an machine - instruction appropriate for the inffast_chunk_t type. - */ -static inline inffast_chunk_t loadchunk(unsigned char const* s) { - inffast_chunk_t c; - memcpy(&c, s, sizeof(c)); - return c; -} - -/* - Ask the compiler to perform a wide, unaligned store with an machine - instruction appropriate for the inffast_chunk_t type. - */ -static inline void storechunk(unsigned char* d, inffast_chunk_t c) { - memcpy(d, &c, sizeof(c)); -} - -/* - Behave like memcpy, but assume that it's OK to overwrite at least - INFFAST_CHUNKSIZE bytes of output even if the length is shorter than this, - that the length is non-zero, and that `from` lags `out` by at least - INFFAST_CHUNKSIZE bytes (or that they don't overlap at all or simply that - the distance is less than the length of the copy). - - Aside from better memory bus utilisation, this means that short copies - (INFFAST_CHUNKSIZE bytes or fewer) will fall straight through the loop - without iteration, which will hopefully make the branch prediction more - reliable. - */ -static inline unsigned char* chunkcopy(unsigned char *out, unsigned char const *from, unsigned len) { - --len; - storechunk(out, loadchunk(from)); - out += (len % INFFAST_CHUNKSIZE) + 1; - from += (len % INFFAST_CHUNKSIZE) + 1; - len /= INFFAST_CHUNKSIZE; - while (len > 0) { - storechunk(out, loadchunk(from)); - out += INFFAST_CHUNKSIZE; - from += INFFAST_CHUNKSIZE; - --len; - } - return out; -} - -/* - Behave like chunkcopy, but avoid writing beyond of legal output. - */ -static inline unsigned char* chunkcopysafe(unsigned char *out, unsigned char const *from, unsigned len, - unsigned char *safe) { - if ((safe - out) < (ptrdiff_t)INFFAST_CHUNKSIZE) { - if (len & 8) { - memcpy(out, from, 8); - out += 8; - from += 8; - } - if (len & 4) { - memcpy(out, from, 4); - out += 4; - from += 4; - } - if (len & 2) { - memcpy(out, from, 2); - out += 2; - from += 2; - } - if (len & 1) { - *out++ = *from++; - } - return out; - } - return chunkcopy(out, from, len); -} - -/* - Perform short copies until distance can be rewritten as being at least - INFFAST_CHUNKSIZE. - - This assumes that it's OK to overwrite at least the first - 2*INFFAST_CHUNKSIZE bytes of output even if the copy is shorter than this. - This assumption holds because inflate_fast() starts every iteration with at - least 258 bytes of output space available (258 being the maximum length - output from a single token; see inflate_fast()'s assumptions below). - */ -static inline unsigned char* chunkunroll(unsigned char *out, unsigned *dist, unsigned *len) { - unsigned char const *from = out - *dist; - while (*dist < *len && *dist < INFFAST_CHUNKSIZE) { - storechunk(out, loadchunk(from)); - out += *dist; - *len -= *dist; - *dist += *dist; - } - return out; -} - -static inline inffast_chunk_t chunkmemset_1(unsigned char *from) { - #if defined(X86_SSE2) - int8_t c; - memcpy(&c, from, sizeof(c)); - return _mm_set1_epi8(c); - #elif defined(__ARM_NEON__) || defined(__ARM_NEON) - return vld1q_dup_u8(from); - #endif -} - -static inline inffast_chunk_t chunkmemset_2(unsigned char *from) { - int16_t c; - memcpy(&c, from, sizeof(c)); - #if defined(X86_SSE2) - return _mm_set1_epi16(c); - #elif defined(__ARM_NEON__) || defined(__ARM_NEON) - return vreinterpretq_u8_s16(vdupq_n_s16(c)); - #endif -} - -static inline inffast_chunk_t chunkmemset_4(unsigned char *from) { - int32_t c; - memcpy(&c, from, sizeof(c)); - #if defined(X86_SSE2) - return _mm_set1_epi32(c); - #elif defined(__ARM_NEON__) || defined(__ARM_NEON) - return vreinterpretq_u8_s32(vdupq_n_s32(c)); - #endif -} - -static inline inffast_chunk_t chunkmemset_8(unsigned char *from) { - #if defined(X86_SSE2) - int64_t c; - memcpy(&c, from, sizeof(c)); - return _mm_set1_epi64x(c); - #elif defined(__ARM_NEON__) || defined(__ARM_NEON) - return vcombine_u8(vld1_u8(from), vld1_u8(from)); - #endif -} - - #if defined(__ARM_NEON__) || defined(__ARM_NEON) -static inline unsigned char *chunkmemset_3(unsigned char *out, unsigned char *from, unsigned dist, unsigned len) { - uint8x8x3_t chunks; - unsigned sz = sizeof(chunks); - if (len < sz) { - out = chunkunroll(out, &dist, &len); - return chunkcopy(out, out - dist, len); - } - - /* Load 3 bytes 'a,b,c' from FROM and duplicate across all lanes: - chunks[0] = {a,a,a,a,a,a,a,a} - chunks[1] = {b,b,b,b,b,b,b,b} - chunks[2] = {c,c,c,c,c,c,c,c}. */ - chunks = vld3_dup_u8(from); - - unsigned rem = len % sz; - len -= rem; - while (len) { - /* Store "a,b,c, ..., a,b,c". */ - vst3_u8(out, chunks); - out += sz; - len -= sz; - } - - if (!rem) - return out; - - /* Last, deal with the case when LEN is not a multiple of SZ. */ - out = chunkunroll(out, &dist, &rem); - return chunkcopy(out, out - dist, rem); -} - #endif - - #if defined(__aarch64__) -static inline unsigned char *chunkmemset_6(unsigned char *out, unsigned char *from, unsigned dist, unsigned len) { - uint16x8x3_t chunks; - unsigned sz = sizeof(chunks); - if (len < sz) { - out = chunkunroll(out, &dist, &len); - return chunkcopy(out, out - dist, len); - } - - /* Load 6 bytes 'ab,cd,ef' from FROM and duplicate across all lanes: - chunks[0] = {ab,ab,ab,ab,ab,ab,ab,ab} - chunks[1] = {cd,cd,cd,cd,cd,cd,cd,cd} - chunks[2] = {ef,ef,ef,ef,ef,ef,ef,ef}. */ - chunks = vld3q_dup_u16((unsigned short *)from); - - unsigned rem = len % sz; - len -= rem; - while (len) { - /* Store "ab,cd,ef, ..., ab,cd,ef". */ - vst3q_u16((unsigned short *)out, chunks); - out += sz; - len -= sz; - } - - if (rem) - return out; - - /* Last, deal with the case when LEN is not a multiple of SZ. */ - out = chunkunroll(out, &dist, &rem); - return chunkcopy(out, out - dist, rem); -} - #endif - -/* Copy DIST bytes from OUT - DIST into OUT + DIST * k, for 0 <= k < LEN/DIST. Return OUT + LEN. */ -static inline unsigned char *chunkmemset(unsigned char *out, unsigned dist, unsigned len) { - Assert(len >= sizeof(uint64_t), "chunkmemset should be called on larger chunks"); - Assert(dist > 0, "cannot have a distance 0"); - - unsigned char *from = out - dist; - inffast_chunk_t chunk; - unsigned sz = sizeof(chunk); - if (len < sz) { - do { - *out++ = *from++; - --len; - } while (len != 0); - return out; - } - - switch (dist) { - case 1: { - chunk = chunkmemset_1(from); - break; - } - case 2: { - chunk = chunkmemset_2(from); - break; - } - #if defined(__ARM_NEON__) || defined(__ARM_NEON) - case 3: - return chunkmemset_3(out, from, dist, len); - #endif - case 4: { - chunk = chunkmemset_4(from); - break; - } - #if defined(__aarch64__) - case 6: - return chunkmemset_6(out, from, dist, len); - #endif - case 8: { - chunk = chunkmemset_8(from); - break; - } - case 16: - memcpy(&chunk, from, sz); - break; - - default: - out = chunkunroll(out, &dist, &len); - return chunkcopy(out, out - dist, len); - } - - unsigned rem = len % sz; - len -= rem; - while (len) { - memcpy(out, &chunk, sz); - out += sz; - len -= sz; - } - - /* Last, deal with the case when LEN is not a multiple of SZ. */ - if (rem) - memcpy(out, &chunk, rem); - out += rem; - return out; -} - -static inline unsigned char* chunkmemsetsafe(unsigned char *out, unsigned dist, unsigned len, unsigned left) { - if (left < (unsigned)(3 * INFFAST_CHUNKSIZE)) { - while (len > 0) { - *out = *(out - dist); - out++; - --len; - } - return out; - } - - return chunkmemset(out, dist, len); -} - - #else /* INFFAST_CHUNKSIZE */ - -static inline unsigned char *copy_1_bytes(unsigned char *out, unsigned char *from) { - *out++ = *from; - return out; -} - -static inline unsigned char *copy_2_bytes(unsigned char *out, unsigned char *from) { - uint16_t chunk; - unsigned sz = sizeof(chunk); - memcpy(&chunk, from, sz); - memcpy(out, &chunk, sz); - return out + sz; -} - -static inline unsigned char *copy_3_bytes(unsigned char *out, unsigned char *from) { - out = copy_1_bytes(out, from); - return copy_2_bytes(out, from + 1); -} - -static inline unsigned char *copy_4_bytes(unsigned char *out, unsigned char *from) { - uint32_t chunk; - unsigned sz = sizeof(chunk); - memcpy(&chunk, from, sz); - memcpy(out, &chunk, sz); - return out + sz; -} - -static inline unsigned char *copy_5_bytes(unsigned char *out, unsigned char *from) { - out = copy_1_bytes(out, from); - return copy_4_bytes(out, from + 1); -} - -static inline unsigned char *copy_6_bytes(unsigned char *out, unsigned char *from) { - out = copy_2_bytes(out, from); - return copy_4_bytes(out, from + 2); -} - -static inline unsigned char *copy_7_bytes(unsigned char *out, unsigned char *from) { - out = copy_3_bytes(out, from); - return copy_4_bytes(out, from + 3); -} - -static inline unsigned char *copy_8_bytes(unsigned char *out, unsigned char *from) { - uint64_t chunk; - unsigned sz = sizeof(chunk); - memcpy(&chunk, from, sz); - memcpy(out, &chunk, sz); - return out + sz; -} - -/* Copy LEN bytes (7 or fewer) from FROM into OUT. Return OUT + LEN. */ -static inline unsigned char *copy_bytes(unsigned char *out, unsigned char *from, unsigned len) { - Assert(len < 8, "copy_bytes should be called with less than 8 bytes"); - - #ifndef UNALIGNED_OK - while (len--) { - *out++ = *from++; - } - return out; - #else - switch (len) { - case 7: - return copy_7_bytes(out, from); - case 6: - return copy_6_bytes(out, from); - case 5: - return copy_5_bytes(out, from); - case 4: - return copy_4_bytes(out, from); - case 3: - return copy_3_bytes(out, from); - case 2: - return copy_2_bytes(out, from); - case 1: - return copy_1_bytes(out, from); - case 0: - return out; - default: - Assert(0, "should not happen"); - } - - return out; - #endif /* UNALIGNED_OK */ -} - -/* Copy LEN bytes (7 or fewer) from FROM into OUT. Return OUT + LEN. */ -static inline unsigned char *set_bytes(unsigned char *out, unsigned char *from, unsigned dist, unsigned len) { - Assert(len < 8, "set_bytes should be called with less than 8 bytes"); - - #ifndef UNALIGNED_OK - (void)dist; - while (len--) { - *out++ = *from++; - } - return out; - #else - if (dist >= len) - return copy_bytes(out, from, len); - - switch (dist) { - case 6: - Assert(len == 7, "len should be exactly 7"); - out = copy_6_bytes(out, from); - return copy_1_bytes(out, from); - - case 5: - Assert(len == 6 || len == 7, "len should be either 6 or 7"); - out = copy_5_bytes(out, from); - return copy_bytes(out, from, len - 5); - - case 4: - Assert(len == 5 || len == 6 || len == 7, "len should be either 5, 6, or 7"); - out = copy_4_bytes(out, from); - return copy_bytes(out, from, len - 4); - - case 3: - Assert(4 <= len && len <= 7, "len should be between 4 and 7"); - out = copy_3_bytes(out, from); - switch (len) { - case 7: - return copy_4_bytes(out, from); - case 6: - return copy_3_bytes(out, from); - case 5: - return copy_2_bytes(out, from); - case 4: - return copy_1_bytes(out, from); - default: - Assert(0, "should not happen"); - break; - } - - case 2: - Assert(3 <= len && len <= 7, "len should be between 3 and 7"); - out = copy_2_bytes(out, from); - switch (len) { - case 7: - out = copy_4_bytes(out, from); - out = copy_1_bytes(out, from); - return out; - case 6: - out = copy_4_bytes(out, from); - return out; - case 5: - out = copy_2_bytes(out, from); - out = copy_1_bytes(out, from); - return out; - case 4: - out = copy_2_bytes(out, from); - return out; - case 3: - out = copy_1_bytes(out, from); - return out; - default: - Assert(0, "should not happen"); - break; - } - - case 1: - Assert(2 <= len && len <= 7, "len should be between 2 and 7"); - unsigned char c = *from; - switch (len) { - case 7: - memset(out, c, 7); - return out + 7; - case 6: - memset(out, c, 6); - return out + 6; - case 5: - memset(out, c, 5); - return out + 5; - case 4: - memset(out, c, 4); - return out + 4; - case 3: - memset(out, c, 3); - return out + 3; - case 2: - memset(out, c, 2); - return out + 2; - default: - Assert(0, "should not happen"); - break; - } - } - return out; - #endif /* UNALIGNED_OK */ -} - -/* Byte by byte semantics: copy LEN bytes from OUT + DIST and write them to OUT. Return OUT + LEN. */ -static inline unsigned char *chunk_memcpy(unsigned char *out, unsigned char *from, unsigned len) { - unsigned sz = sizeof(uint64_t); - Assert(len >= sz, "chunk_memcpy should be called on larger chunks"); - - /* Copy a few bytes to make sure the loop below has a multiple of SZ bytes to be copied. */ - copy_8_bytes(out, from); - - unsigned rem = len % sz; - len /= sz; - out += rem; - from += rem; - - unsigned by8 = len % sz; - len -= by8; - switch (by8) { - case 7: - out = copy_8_bytes(out, from); - from += sz; - case 6: - out = copy_8_bytes(out, from); - from += sz; - case 5: - out = copy_8_bytes(out, from); - from += sz; - case 4: - out = copy_8_bytes(out, from); - from += sz; - case 3: - out = copy_8_bytes(out, from); - from += sz; - case 2: - out = copy_8_bytes(out, from); - from += sz; - case 1: - out = copy_8_bytes(out, from); - from += sz; - } - - while (len) { - out = copy_8_bytes(out, from); - from += sz; - out = copy_8_bytes(out, from); - from += sz; - out = copy_8_bytes(out, from); - from += sz; - out = copy_8_bytes(out, from); - from += sz; - out = copy_8_bytes(out, from); - from += sz; - out = copy_8_bytes(out, from); - from += sz; - out = copy_8_bytes(out, from); - from += sz; - out = copy_8_bytes(out, from); - from += sz; - - len -= 8; - } - - return out; -} - -/* Memset LEN bytes in OUT with the value at OUT - 1. Return OUT + LEN. */ -static inline unsigned char *byte_memset(unsigned char *out, unsigned len) { - unsigned sz = sizeof(uint64_t); - Assert(len >= sz, "byte_memset should be called on larger chunks"); - - unsigned char *from = out - 1; - unsigned char c = *from; - - /* First, deal with the case when LEN is not a multiple of SZ. */ - memset(out, c, sz); - unsigned rem = len % sz; - len /= sz; - out += rem; - - unsigned by8 = len % 8; - len -= by8; - switch (by8) { - case 7: - memset(out, c, sz); - out += sz; - case 6: - memset(out, c, sz); - out += sz; - case 5: - memset(out, c, sz); - out += sz; - case 4: - memset(out, c, sz); - out += sz; - case 3: - memset(out, c, sz); - out += sz; - case 2: - memset(out, c, sz); - out += sz; - case 1: - memset(out, c, sz); - out += sz; - } - - while (len) { - /* When sz is a constant, the compiler replaces __builtin_memset with an - inline version that does not incur a function call overhead. */ - memset(out, c, sz); - out += sz; - memset(out, c, sz); - out += sz; - memset(out, c, sz); - out += sz; - memset(out, c, sz); - out += sz; - memset(out, c, sz); - out += sz; - memset(out, c, sz); - out += sz; - memset(out, c, sz); - out += sz; - memset(out, c, sz); - out += sz; - len -= 8; - } - - return out; -} - -/* Copy DIST bytes from OUT - DIST into OUT + DIST * k, for 0 <= k < LEN/DIST. Return OUT + LEN. */ -static inline unsigned char *chunk_memset(unsigned char *out, unsigned char *from, unsigned dist, unsigned len) { - if (dist >= len) - return chunk_memcpy(out, from, len); - - Assert(len >= sizeof(uint64_t), "chunk_memset should be called on larger chunks"); - - /* Double up the size of the memset pattern until reaching the largest pattern of size less than SZ. */ - unsigned sz = sizeof(uint64_t); - while (dist < len && dist < sz) { - copy_8_bytes(out, from); - - out += dist; - len -= dist; - dist += dist; - - /* Make sure the next memcpy has at least SZ bytes to be copied. */ - if (len < sz) - /* Finish up byte by byte when there are not enough bytes left. */ - return set_bytes(out, from, dist, len); - } - - return chunk_memcpy(out, from, len); -} - -/* Byte by byte semantics: copy LEN bytes from FROM and write them to OUT. Return OUT + LEN. */ -static inline unsigned char *chunk_copy(unsigned char *out, unsigned char *from, int dist, unsigned len) { - if (len < sizeof(uint64_t)) { - if (dist > 0) - return set_bytes(out, from, dist, len); - - return copy_bytes(out, from, len); - } - - if (dist == 1) - return byte_memset(out, len); - - if (dist > 0) - return chunk_memset(out, from, dist, len); - - return chunk_memcpy(out, from, len); -} - #endif /* INFFAST_CHUNKSIZE */ -#endif /* MEMCOPY_H_ */ diff --git a/libs/zlibng/test/.gitignore b/libs/zlibng/test/.gitignore index 2c3af0a08..96a3cad07 100644 --- a/libs/zlibng/test/.gitignore +++ b/libs/zlibng/test/.gitignore @@ -1,2 +1,5 @@ # ignore Makefiles; they're all automatically generated Makefile +/switchlevels +/switchlevels.dSYM/ +/switchlevels.exe diff --git a/libs/zlibng/test/CVE-2003-0107.c b/libs/zlibng/test/CVE-2003-0107.c index 306421e9f..51c79b2cd 100644 --- a/libs/zlibng/test/CVE-2003-0107.c +++ b/libs/zlibng/test/CVE-2003-0107.c @@ -5,16 +5,18 @@ #include int main(void) { -gzFile f; -int ret; + gzFile f; + int ret; -if(!(f = gzopen("/dev/null", "w"))) { -perror("/dev/null"); -exit(1); -} -ret = gzprintf(f, "%10240s", ""); -printf("gzprintf -> %d\n", ret); -ret = gzclose(f); -printf("gzclose -> %d [%d]\n", ret, errno); -exit(0); + if(!(f = gzopen("/dev/null", "w"))) { + perror("/dev/null"); + exit(1); + } + + ret = gzprintf(f, "%10240s", ""); + printf("gzprintf -> %d\n", ret); + ret = gzclose(f); + printf("gzclose -> %d [%d]\n", ret, errno); + + exit(0); } diff --git a/libs/zlibng/test/GH-361/test.txt b/libs/zlibng/test/GH-361/test.txt new file mode 100644 index 000000000..2b102819f --- /dev/null +++ b/libs/zlibng/test/GH-361/test.txt @@ -0,0 +1,4 @@ +.....-.u..|u....-...!..A.#?)9.._B..F..| +00000650 fa 13 88 89 2c 1f 81 0f e4 e9 ce 39 a0 87 2e 2e |....,......9....| +00000660 a5 0c 08 9c ec fc 88 6d 16 02 0a a0 3d fc 36 29 |.......m....=.6)| +00000670 8d f5 c3 ba 1d 07 f4 78 e1 a0 41 f9 89 15 a5 69 |.......x..A.... \ No newline at end of file diff --git a/libs/zlibng/test/GH-364/test.bin b/libs/zlibng/test/GH-364/test.bin new file mode 100644 index 000000000..1b1cb4d44 Binary files /dev/null and b/libs/zlibng/test/GH-364/test.bin differ diff --git a/libs/zlibng/test/GH-382/defneg3.dat b/libs/zlibng/test/GH-382/defneg3.dat new file mode 100644 index 000000000..5fa6a0804 --- /dev/null +++ b/libs/zlibng/test/GH-382/defneg3.dat @@ -0,0 +1 @@ +oÌ™Ì?ÌOÌÃÌḩÌÕÌ>ÌÌÌàÌ̹̘ÌÔÌEÌsÌ—ÌÌ4̢̙̑Ì6ÌÌØÌæÌ\ÌÌÌ5̪̲̕ÌmÌÌ–Ìç̺̜ÌÙ̧ÌÌíÌíÌ–ÌÌëÌmÌìÌÎ̵ÌGÌïÌOÌÛÌ ÌÃÌòÌÎÌôÌ„Ì;Ì”ÌýÌ’ÌÓÌÀÌ×Ì,ÌÑÌ¢ÌáÌAÌ9Ì»ÌæÌ‚ÌÂÌsÌý̼ÌÝÌÌ­ÌeÌòÌÝÌUÌuÌí̱ÌËÌwÌùÌ•ÌDÌß̋̽Ìt̞̣̹ÌöÌôÌOÌîÌíÌ…ÌpÌGÌìÌ°ÌÀÌ(ÌÌÌ̤Ì{Ì“ÌßÌïÌÕÌÌøÌÌMÌ#ÌÌí̵ÌdÌ·ÌIÌßÌhÌ_ÌpÌJÌÇÌ¢ÌÎÌÌoÌÌêÌÁÌ;Ì<̘ÌZÌÈÌÑÌoÌWÌ„Ì¿Ì}ÌáÌÌÌ:Ìá̧̻̕ÌeÌFÌtÌ(ÌEÌoÌàÌpÌÌ¢Ì(Ì;ÌþÌëÌóÌ!̹̹ÌÉÌÌœÌîÌÖÌ4ÌÈÌ3ÌëÌ‹ÌBÌŽÌÆÌuÌPÌ6Ì“ÌþÌ&̦̳̕ÌÁÌðÌ»ÌÌÌTÌÀ̧ÌbÌÌÒÌÕÌëÌ{ÌÆÌ¡ÌÊÌNÌ9ÌÇÌÌBÌÑ \ No newline at end of file diff --git a/libs/zlibng/test/GH-751/test.txt b/libs/zlibng/test/GH-751/test.txt new file mode 100644 index 000000000..ef2143ece --- /dev/null +++ b/libs/zlibng/test/GH-751/test.txt @@ -0,0 +1 @@ +abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc diff --git a/libs/zlibng/test/INDEX b/libs/zlibng/test/INDEX deleted file mode 100644 index f167df87e..000000000 --- a/libs/zlibng/test/INDEX +++ /dev/null @@ -1,10 +0,0 @@ -Makefile.in: template for Unix Makefile - -CVE-2003-0107.c: -CVE-2002-0059 : -CVE-2004-0797 : -CVE-2005-1849 : -CVE-2005-2096 : test cases for the relevant CVEs - -testCVEinputs.sh: script to run tests for CVEs where input data is supplied - diff --git a/libs/zlibng/test/Makefile.in b/libs/zlibng/test/Makefile.in index 4b858f744..97b8be753 100644 --- a/libs/zlibng/test/Makefile.in +++ b/libs/zlibng/test/Makefile.in @@ -7,14 +7,15 @@ CFLAGS= EXE= SRCDIR= SRCTOP= -TEST_LDFLAGS=-L.. ../libz.a +LIBNAME= +TEST_LDFLAGS=-L.. ../$(LIBNAME).a WITH_FUZZERS= COMPATTESTS = QEMU_RUN= QEMU_VER:=$(shell command -v $(QEMU_RUN) --version 2> /dev/null) -all: oldtests cvetests $(COMPATTESTS) fuzzer +all: oldtests cvetests $(COMPATTESTS) fuzzer ghtests oldtests: #set by ../configure check_cross_dep: @@ -45,35 +46,28 @@ fuzzer: endif teststatic: check_cross_dep - @TMPST=tmpst_$$; \ - if echo hello world | ${QEMU_RUN} ../minigzip$(EXE) | ${QEMU_RUN} ../minigzip$(EXE) -d && ${QEMU_RUN} ../example$(EXE) $$TMPST ; then \ + @TMPST=tmpst_$$$$; \ + HELLOST=tmphellost_$$$$; \ + if echo hello world | ${QEMU_RUN} ../minigzip$(EXE) > $$HELLOST && ${QEMU_RUN} ../minigzip$(EXE) -d < $$HELLOST && ${QEMU_RUN} ../example$(EXE) $$TMPST && ${QEMU_RUN} ../adler32_test$(EXE); then \ echo ' *** zlib test OK ***'; \ else \ echo ' *** zlib test FAILED ***'; exit 1; \ - fi - @rm -f tmpst_$$ + fi; \ + rm -f $$TMPST $$HELLOST testshared: check_cross_dep @LD_LIBRARY_PATH=`pwd`/..:$(LD_LIBRARY_PATH) ; export LD_LIBRARY_PATH; \ LD_LIBRARYN32_PATH=`pwd`/..:$(LD_LIBRARYN32_PATH) ; export LD_LIBRARYN32_PATH; \ DYLD_LIBRARY_PATH=`pwd`/..:$(DYLD_LIBRARY_PATH) ; export DYLD_LIBRARY_PATH; \ SHLIB_PATH=`pwd`/..:$(SHLIB_PATH) ; export SHLIB_PATH; \ - TMPSH=tmpsh_$$; \ - if echo hello world | ${QEMU_RUN} ../minigzipsh$(EXE) | ${QEMU_RUN} ../minigzipsh$(EXE) -d && ${QEMU_RUN} ../examplesh$(EXE) $$TMPSH; then \ + TMPSH=tmpsh_$$$$; \ + HELLOSH=tmphellosh_$$$$; \ + if echo hello world | ${QEMU_RUN} ../minigzipsh$(EXE) > $$HELLOSH && ${QEMU_RUN} ../minigzipsh$(EXE) -d < $$HELLOSH && ${QEMU_RUN} ../examplesh$(EXE) $$TMPSH && ${QEMU_RUN} ../adler32_testsh$(EXE); then \ echo ' *** zlib shared test OK ***'; \ else \ echo ' *** zlib shared test FAILED ***'; exit 1; \ - fi - @rm -f tmpsh_$$ - -test64: check_cross_dep - @TMP64=tmp64_$$; \ - if echo hello world | ${QEMU_RUN} ../minigzip64$(EXE) | ${QEMU_RUN} ../minigzip64$(EXE) -d && ${QEMU_RUN} ../example64$(EXE) $$TMP64; then \ - echo ' *** zlib 64-bit test OK ***'; \ - else \ - echo ' *** zlib 64-bit test FAILED ***'; exit 1; \ - fi - @rm -f tmp64_$$ + fi; \ + rm -f $$TMPSH $$HELLOSH cvetests: testCVEinputs @@ -96,10 +90,27 @@ CVE-2003-0107.o: $(SRCDIR)/CVE-2003-0107.c CVE-2003-0107$(EXE): CVE-2003-0107.o $(CC) $(CFLAGS) -o $@ CVE-2003-0107.o $(TEST_LDFLAGS) +.PHONY: ghtests +ghtests: testGH-361 testGH-364 testGH-751 + +.PHONY: testGH-361 +testGH-361: + $(QEMU_RUN) ../minigzip$(EXE) -4 <$(SRCDIR)/GH-361/test.txt >/dev/null + +switchlevels$(EXE): $(SRCDIR)/switchlevels.c + $(CC) $(CFLAGS) -I.. -I$(SRCTOP) -o $@ $< $(TEST_LDFLAGS) + +.PHONY: testGH-364 +testGH-364: switchlevels$(EXE) + $(QEMU_RUN) ./switchlevels$(EXE) 1 5 9 3 <$(SRCDIR)/GH-364/test.bin >/dev/null + +.PHONY: testGH-751 +testGH-751: + $(QEMU_RUN) ../minigzip$(EXE) <$(SRCDIR)/GH-751/test.txt | $(QEMU_RUN) ../minigzip$(EXE) -d >/dev/null clean: rm -f *.o *.gcda *.gcno *.gcov - rm -f CVE-2003-0107$(EXE) + rm -f CVE-2003-0107$(EXE) switchlevels$(EXE) distclean: rm -f Makefile diff --git a/libs/zlibng/test/README.md b/libs/zlibng/test/README.md new file mode 100644 index 000000000..247d5bac7 --- /dev/null +++ b/libs/zlibng/test/README.md @@ -0,0 +1,36 @@ +Contents +-------- + +|Name|Description| +|-|-| +|[CVE-2003-0107.c](https://nvd.nist.gov/vuln/detail/CVE-2003-0107)|Buffer overflow in the gzprintf function, requires ZLIB_COMPAT| +|[CVE-2002-0059](https://nvd.nist.gov/vuln/detail/CVE-2002-0059)|inflateEnd to release memory more than once| +|[CVE-2004-0797](https://nvd.nist.gov/vuln/detail/CVE-2004-0797)|Error handling in inflate and inflateBack causes crash| +|[CVE-2005-1849](https://nvd.nist.gov/vuln/detail/CVE-2005-1849)|inftrees.h bug causes crash| +|[CVE-2005-2096](https://nvd.nist.gov/vuln/detail/CVE-2005-2096)|Buffer overflow when incomplete code description +|[GH-361](https://github.com/zlib-ng/zlib-ng/issues/361)|Test case for overlapping matches| +|[GH-364](https://github.com/zlib-ng/zlib-ng/issues/364)|Test case for switching compression levels| +|[GH-382](https://github.com/zlib-ng/zlib-ng/issues/382)|Test case for deflateEnd returning -3 in deflate quick| + +Copying +------- + +Some of the files in _test_ are licensed differently: + + - test/data/fireworks.jpeg is Copyright 2013 Steinar H. Gunderson, and + is licensed under the Creative Commons Attribution 3.0 license + (CC-BY-3.0). See https://creativecommons.org/licenses/by/3.0/ + for more information. + + - test/data/paper-100k.pdf is an excerpt (bytes 92160 to 194560) from the paper + “Combinatorial Modeling of Chromatin Features Quantitatively Predicts DNA + Replication Timing in _Drosophila_†by Federico Comoglio and Renato Paro, + which is licensed under the CC-BY license. See + http://www.ploscompbiol.org/static/license for more information. + + - test/data/lcet10.txt is from Project Gutenberg. It does not have expired + copyright, but is still in the public domain according to the license information. + (http://www.gutenberg.org/ebooks/53). + + - test/GH-382/defneg3.dat was the smallest file generated by Nathan Moinvaziri + that reproduced GH-382. It is licensed under the terms of the zlib license. diff --git a/libs/zlibng/test/abi/ignore b/libs/zlibng/test/abi/ignore new file mode 100644 index 000000000..dba3639cb --- /dev/null +++ b/libs/zlibng/test/abi/ignore @@ -0,0 +1,12 @@ +# See https://sourceware.org/libabigail/manual/libabigail-concepts.html#suppression-specifications + +[suppress_type] + name = internal_state + +[suppress_type] + name_regexp = z_stream.* + +# Size varies with version number +[suppress_variable] + name = zlibng_string + diff --git a/libs/zlibng/test/abi/zlib-v1.2.11-arm-linux-gnueabihf.abi b/libs/zlibng/test/abi/zlib-v1.2.11-arm-linux-gnueabihf.abi new file mode 100644 index 000000000..152a742cf --- /dev/null +++ b/libs/zlibng/test/abi/zlib-v1.2.11-arm-linux-gnueabihf.abi @@ -0,0 +1,119 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/libs/zlibng/test/abi/zlib-v1.2.11-x86_64-linux-gnu.abi b/libs/zlibng/test/abi/zlib-v1.2.11-x86_64-linux-gnu.abi new file mode 100644 index 000000000..00a520c63 --- /dev/null +++ b/libs/zlibng/test/abi/zlib-v1.2.11-x86_64-linux-gnu.abi @@ -0,0 +1,1037 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/libs/zlibng/test/abicheck.md b/libs/zlibng/test/abicheck.md new file mode 100644 index 000000000..6e9e58aad --- /dev/null +++ b/libs/zlibng/test/abicheck.md @@ -0,0 +1,59 @@ +ABI Compatibility test +---------------------- + +abicheck.sh uses libabigail to check ABI stability. +It will abort if the current source +tree has a change that breaks binary compatibility. + +This protects against the common scenario where: +- an app is compiled against the current zlib-ng +- the system package manager updates the zlib-ng shared library +- the app now crashes because some symbol is + missing or some public structure or parameter + has changed type or size + +If run with --zlib-compat, it verifies that the +current source tree generates a library that +is ABI-compatible with the reference release +of classic zlib. This ensures that building +zlib-ng with --zlib-compat does what it says on the tin. + +abicheck.sh is not perfect, but it can catch +many common compatibility issues. + +Cached files test/abi/*.abi +--------------------------- + +Comparing to the old version of zlib (or zlib-ng) +means someone has to check out and build +the previous source tree and extract its .abi +using abidw. This can be slow. + +If you don't mind the slowness, run abicheck.sh --refresh_if, +and it will download and build the reference version +and extract the .abi on the spot if needed. +(FIXME: should this be the default?) + +On the next run, the reference .abi file will already be +present, and that step will be skipped. +It's stored in the tests/abi directory, +in a file with the architecture and git hash in the name. + +If you're running continuous integration +which clear out the source tree on each run, +and you don't want your build machines +constantly downloading and building the old +version, you can check the .abi file into git. + +To make this easier, a helper script could be written to automatically build +all the configurations tested by .github/worflows/abicheck.yml +Then they could be checked into git en masse by a maintainer +when a new platform is added or a new major version (which +intentionally breaks backwards compatibility) is being prepared. + +Further reading +--------------- + +- https://sourceware.org/libabigail/manual/ +- https://developers.redhat.com/blog/2014/10/23/comparing-abis-for-compatibility-with-libabigail-part-1/ +- https://developers.redhat.com/blog/2020/04/02/how-to-write-an-abi-compliance-checker-using-libabigail/ diff --git a/libs/zlibng/test/abicheck.sh b/libs/zlibng/test/abicheck.sh new file mode 100644 index 000000000..89199a59a --- /dev/null +++ b/libs/zlibng/test/abicheck.sh @@ -0,0 +1,164 @@ +#!/bin/sh +set -ex +TESTDIR="$(cd $(dirname "$0"); pwd)" + +usage() { + cat <<_EOF_ +Usage: $0 [--zlib-compat][--refresh][--refresh-if] + +Build shared library with -ggdb, then compare its ABI to the stable +ABI, and abort if differences found. + +Options: +--zlib-compat - check the ABI of the zlib-compatible flavor of zlib-ng. +--refresh - build the reference library and extract its ABI rather than using a stored ABI file. +--refresh-if - refresh only if ABI file not present. + +Obeys CHOST, CONFIGURE_ARGS, CFLAGS, and LDFLAGS. + +Requires libabigail (on Ubuntu, install package abigail-tools). +_EOF_ +} + +# Print the multiarch tuple for the current (non-cross) machine, +# or the empty string if unavailable. +detect_chost() { + dpkg-architecture -qDEB_HOST_MULTIARCH || + $CC -print-multiarch || + $CC -print-search-dirs | sed 's/:/\n/g' | grep -E '^/lib/[^/]+$' | sed 's%.*/%%' || + true +} + +if ! test -f "configure" +then + echo "Please run from top of source tree" + exit 1 +fi + +suffix="-ng" +CONFIGURE_ARGS_NG="$CONFIGURE_ARGS" +refresh=false +refresh_if=false +for arg +do + case "$arg" in + --zlib-compat) + suffix="" + CONFIGURE_ARGS_NG="$CONFIGURE_ARGS_NG --zlib-compat" + ;; + --refresh) + refresh=true + ;; + --refresh_if) + refresh_if=true + ;; + --help) + usage + exit 0 + ;; + *) + echo "Unknown arg '$arg'" + usage + exit 1 + ;; + esac +done + +# Choose reference repo and commit +if test "$suffix" = "" +then + # Reference is zlib 1.2.11 + ABI_GIT_REPO=https://github.com/madler/zlib.git + ABI_GIT_COMMIT=v1.2.11 +else + # Reference should be the tag for zlib-ng 2.0 + # but until that bright, shining day, use some + # random recent SHA. Annoyingly, can't shorten it. + ABI_GIT_REPO=https://github.com/zlib-ng/zlib-ng.git + ABI_GIT_COMMIT=56ce27343bf295ae9457f8e3d38ec96d2f949a1c +fi +# FIXME: even when using a tag, check the hash. + +# Test compat build for ABI compatibility with zlib +if test "$CHOST" = "" +then + # Note: don't export CHOST here, as we don't want configure seeing it + # when it's just the name for the build machine. + # Leave it as a plain shell variable, not an environment variable. + CHOST=$(detect_chost) + # Support -m32 for non-cross builds. + case "$CFLAGS" in + *-m32*) M32="-m32";; + *) M32="";; + esac +fi + +# Canonicalize CHOST to work around bug in original zlib's configure +export CHOST=$(sh $TESTDIR/../tools/config.sub $CHOST) + +if test "$CHOST" = "" +then + echo "abicheck: SKIP, as we don't know CHOST" + exit 0 +fi + +ABIFILE="test/abi/zlib$suffix-$ABI_GIT_COMMIT-$CHOST$M32.abi" +if ! $refresh && $refresh_if && ! test -f "$ABIFILE" +then + refresh=true +fi +abidw --version + +if $refresh +then + # Check out reference source + rm -rf btmp1 + mkdir -p btmp1/src.d + cd btmp1/src.d + git init + git remote add origin $ABI_GIT_REPO + git fetch origin $ABI_GIT_COMMIT + git reset --hard FETCH_HEAD + cd .. + # Build unstripped, uninstalled, very debug shared library + CFLAGS="$CFLAGS -ggdb" sh src.d/configure $CONFIGURE_ARGS + make -j2 + cd .. + # Find shared library, extract its abi + dylib1=$(find btmp1 -type f -name '*.dylib*' -print -o -type f -name '*.so.*' -print) + abidw $dylib1 > "$ABIFILE" + # Maintainers may wish to check $ABIFILE into git when a new + # target is added, or when a major release happens that is + # intended to change the ABI. Alternately, this script could + # just always rebuild the reference source, and dispense with + # caching abi files in git (but that would slow builds down). +fi + +if test -f "$ABIFILE" +then + ABIFILE="$ABIFILE" +else + echo "abicheck: SKIP: $ABIFILE not found; rerun with --refresh or --refresh_if" + exit 0 +fi + +# Build unstripped, uninstalled, very debug shared library +rm -rf btmp2 +mkdir btmp2 +cd btmp2 +CFLAGS="$CFLAGS -ggdb" ../configure $CONFIGURE_ARGS_NG +make -j2 +cd .. +# Find shared library, extract its abi +dylib2=$(find btmp2 -type f -name '*.dylib*' -print -o -type f -name '*.so.*' -print) +abidw $dylib2 > btmp2/zlib${suffix}-built.abi + +# Compare it to the reference +# FIXME: use --no-added-syms for now, but we probably want to be more strict. +if abidiff --no-added-syms --suppressions test/abi/ignore "$ABIFILE" btmp2/zlib${suffix}-built.abi +then + echo "abicheck: PASS" +else + echo "abicheck: FAIL" + exit 1 +fi diff --git a/libs/zlibng/test/adler32_test.c b/libs/zlibng/test/adler32_test.c new file mode 100644 index 000000000..f681877d3 --- /dev/null +++ b/libs/zlibng/test/adler32_test.c @@ -0,0 +1,365 @@ +/* adler32_test.c -- unit test for adler32 in the zlib compression library + * Copyright (C) 2020 IBM Corporation + * Author: Rogerio Alves + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include +#include +#include + +#include "zbuild.h" +#ifdef ZLIB_COMPAT +# include "zlib.h" +#else +# include "zlib-ng.h" +#endif + +typedef struct { + uint32_t line; + uint32_t adler; + const uint8_t *buf; + uint32_t len; + uint32_t expect; +} adler32_test; + +void test_adler32(uint32_t adler, const uint8_t *buf, uint32_t len, uint32_t chk, uint32_t line) { + uint32_t res = PREFIX(adler32)(adler, buf, len); + if (res != chk) { + fprintf(stderr, "FAIL [%d]: adler32 returned 0x%08X expected 0x%08X\n", + line, res, chk); + exit(1); + } +} + +static const uint8_t long_string[5552] = { + 'q','j','d','w','q','4','8','m','B','u','k','J','V','U','z','V','V','f','M','j','i','q','S','W','L','5','G','n','F','S','P','Q', + 'Q','D','i','6','m','E','9','Z','a','A','P','h','9','d','r','b','5','t','X','U','U','L','w','q','e','k','E','H','6','W','7','k', + 'A','x','N','Q','R','k','d','V','5','y','n','U','N','W','Q','Y','i','W','5','9','R','p','D','C','x','p','u','h','C','a','m','r', + 'z','n','z','A','d','J','6','u','N','e','r','x','7','Q','3','v','V','h','H','S','H','S','f','K','f','e','E','T','9','J','f','K', + 'w','t','x','J','2','y','7','B','x','X','X','p','G','b','T','g','3','k','U','6','E','Z','M','t','J','q','v','n','S','T','6','x', + '5','x','4','P','z','p','M','F','V','b','d','m','f','G','n','J','m','w','z','K','8','a','q','E','D','e','b','3','h','B','V','g', + 'y','3','P','L','5','8','r','z','X','b','Q','g','H','7','L','c','Z','B','3','C','4','y','t','u','k','z','h','v','C','Y','p','p', + '8','H','v','5','X','w','4','L','R','V','V','4','U','C','8','4','T','E','a','N','Z','S','7','U','u','z','f','H','p','P','J','u', + 'Y','Z','h','T','6','e','v','z','V','F','h','u','y','H','b','k','J','M','f','3','6','g','y','L','E','W','t','B','B','d','d','9', + 'u','M','Z','k','F','G','f','h','q','k','5','k','f','r','M','7','c','M','7','y','n','u','8','b','d','7','Q','f','E','m','F','K', + 'x','W','f','B','2','F','8','5','q','z','y','3','R','i','U','m','X','k','h','N','J','y','B','C','h','u','x','4','f','k','J','5', + '6','X','T','W','h','8','J','4','m','K','p','N','3','g','C','g','A','E','e','Z','x','A','P','2','E','4','t','Q','5','X','Y','j', + '6','m','b','h','G','a','v','6','t','v','6','C','M','G','P','u','B','C','A','V','b','2','9','d','2','c','5','a','b','X','w','V', + 'G','6','a','7','c','8','G','6','K','U','Q','m','w','P','V','5','N','x','b','v','x','E','N','C','A','N','t','v','N','B','z','X', + 'B','R','q','U','n','i','A','Q','d','m','a','D','7','Y','f','3','J','8','Y','m','w','Z','b','w','r','H','q','E','j','c','u','E', + 'i','i','S','b','n','G','P','a','F','j','c','R','D','D','G','F','v','i','a','i','M','7','B','e','w','m','L','E','F','2','Y','4', + '4','7','Y','C','t','y','q','7','2','V','G','m','m','E','e','V','u','m','L','p','R','X','W','z','V','K','E','k','p','V','r','J', + 'd','N','3','t','i','u','S','V','w','2','w','U','Q','3','F','q','4','h','q','k','B','7','R','X','B','F','Q','Z','b','b','4','E', + 'K','v','T','B','w','k','V','C','x','d','K','g','N','S','u','k','p','9','z','w','c','y','U','M','V','E','2','Y','P','F','h','9', + 'T','y','h','w','b','9','P','w','G','c','W','W','k','j','J','Q','N','B','U','G','6','9','U','b','v','a','N','9','N','C','G','n', + 'x','R','6','9','Q','C','h','e','j','P','U','h','U','R','i','4','T','B','W','5','w','m','J','p','e','7','r','9','t','c','9','Z', + 'j','p','r','F','C','e','U','P','x','T','A','N','7','6','a','i','y','e','w','F','C','X','H','Y','G','C','q','q','m','A','t','7', + 'z','u','D','S','L','U','C','f','7','e','t','G','V','F','u','c','x','5','M','7','N','i','M','6','h','2','n','H','S','h','K','M', + 'd','T','z','X','d','x','x','4','q','z','d','D','a','2','X','r','p','r','R','m','U','U','y','S','H','c','a','F','e','Z','a','U', + 'P','9','V','J','e','q','j','Y','M','x','e','v','K','7','M','P','N','2','b','6','f','P','h','H','4','U','X','k','n','f','Q','M', + '9','9','a','J','N','e','w','y','f','F','P','p','a','F','Y','a','M','L','W','i','T','M','B','3','U','v','X','v','G','p','7','a', + 'f','u','4','S','y','X','9','g','g','b','B','G','c','i','M','U','n','m','a','7','q','f','9','n','Q','2','V','L','6','e','T','R', + '2','4','9','d','6','Q','B','Y','q','2','4','9','G','Q','E','b','Y','5','u','2','T','Q','G','L','5','n','4','Y','2','y','G','F', + 'j','c','8','M','G','L','e','3','a','N','v','A','A','W','t','R','S','2','i','D','R','8','j','d','Q','3','6','C','V','M','e','w', + 'j','U','Z','w','M','4','b','m','8','J','P','Q','L','P','R','c','r','b','V','C','3','N','8','K','4','d','W','D','N','U','A','A', + '2','J','p','b','D','d','p','j','N','C','k','A','j','B','a','c','u','v','L','X','U','B','4','U','X','W','e','C','b','C','u','d', + 'A','v','U','z','P','t','D','e','5','y','Y','c','x','K','4','7','j','e','e','D','M','5','K','B','Q','6','d','p','T','T','R','j', + 'M','E','E','M','r','N','6','8','7','q','x','F','S','x','E','U','4','d','B','6','5','W','C','e','m','J','e','5','j','w','V','J', + 'w','v','d','7','v','f','K','u','m','8','h','W','T','e','Q','j','M','8','R','Y','d','B','R','2','r','F','j','7','d','E','q','V', + 'k','e','j','P','9','3','X','R','p','R','b','A','v','7','4','A','M','2','k','r','E','7','X','3','7','k','5','c','B','7','W','5', + 'u','J','B','Q','R','2','V','7','h','Q','h','9','g','G','y','c','c','x','M','z','7','G','2','J','w','v','j','5','9','E','b','k', + 'z','W','T','C','b','4','K','R','X','T','k','V','S','G','2','j','d','6','y','E','4','P','H','K','w','a','m','F','Z','x','9','j', + 'i','2','d','X','u','a','4','a','M','z','8','p','p','z','g','t','H','5','Y','L','Q','c','R','F','m','E','n','G','X','d','f','7', + 'x','8','j','g','J','z','D','S','a','S','h','y','5','h','Y','N','p','w','Y','W','h','E','N','v','8','Q','D','W','Z','k','f','e', + 'r','Z','D','7','R','D','T','2','H','X','z','G','X','f','v','E','z','P','v','U','H','e','4','R','W','U','x','t','t','4','w','p', + 'r','z','K','9','f','g','h','P','r','f','v','k','h','c','e','5','8','a','L','F','J','M','G','R','a','N','q','S','g','W','e','7', + 'R','K','R','A','B','z','6','v','S','p','w','n','e','x','k','E','r','j','f','Y','x','8','9','z','e','T','6','E','G','v','9','f', + 'D','A','N','v','y','U','7','D','M','2','E','5','W','G','6','b','9','q','g','Y','F','f','k','q','Q','E','x','Y','C','R','G','6', + 'R','h','4','J','d','U','D','b','9','b','8','r','f','V','d','g','b','2','z','Z','d','m','X','v','j','Y','d','w','K','8','G','r', + 'v','j','N','y','c','h','u','5','z','g','J','H','a','Z','b','z','G','C','r','P','f','y','P','6','F','P','h','7','9','w','7','y', + 'R','3','n','E','h','G','D','4','m','Y','E','q','k','a','f','a','R','B','q','t','W','E','T','p','H','7','k','X','2','d','X','6', + 'W','n','H','m','w','M','i','Y','M','E','F','5','R','p','p','y','c','b','q','R','9','Y','t','T','7','w','u','K','M','Q','z','n', + 'P','7','g','x','6','R','4','x','N','v','w','M','6','j','K','v','7','a','Y','4','a','M','6','n','z','3','E','2','V','N','4','i', + 'E','f','u','W','J','W','e','8','3','Q','e','a','F','P','c','3','P','k','i','z','d','q','m','q','M','a','d','8','D','3','F','M', + 'e','d','E','j','z','V','e','d','z','H','D','J','8','X','g','E','i','u','c','7','A','w','S','J','2','A','e','8','r','q','C','m', + '9','9','a','g','2','y','y','P','M','e','8','3','T','r','m','8','j','v','r','p','M','Z','Y','g','a','9','2','d','H','B','m','9', + '4','6','a','Z','V','u','S','H','g','3','X','h','i','N','3','B','S','E','k','9','k','2','9','R','A','i','3','L','X','M','B','S', + '4','S','F','F','F','w','u','d','M','T','9','K','B','7','R','U','R','8','D','8','T','5','U','t','E','R','x','n','x','h','v','k', + 'B','N','k','E','U','T','t','p','r','u','Z','h','t','E','4','i','P','z','f','z','q','M','p','f','A','K','2','D','t','j','f','c', + 'Y','E','N','M','x','k','g','7','T','U','2','c','d','V','g','2','z','L','i','j','Y','q','b','T','A','y','v','a','t','N','5','t', + 'Z','5','n','D','a','y','G','n','P','x','V','k','M','8','t','J','Z','G','g','5','9','R','h','P','P','J','N','X','p','G','J','p', + '2','y','A','v','d','G','U','z','3','V','M','y','q','U','N','M','Y','p','B','Z','U','h','j','q','z','q','x','w','7','d','J','Q', + 'u','F','q','3','m','9','c','Q','W','d','6','7','b','V','M','7','P','j','r','k','9','h','R','z','m','b','i','B','u','E','L','9', + 'k','v','h','h','W','2','K','e','M','U','Q','p','A','Q','Y','J','G','E','T','U','L','f','q','G','4','z','K','K','y','a','U','W', + 'K','D','P','c','N','D','V','S','Y','6','T','p','R','y','y','J','a','T','J','W','Q','9','p','F','P','X','y','k','9','z','z','4', + 'G','d','a','z','X','n','h','4','J','P','W','V','D','r','U','m','a','8','a','b','X','F','J','X','L','4','S','X','5','W','p','W', + 'h','y','x','B','f','d','C','X','w','7','r','g','V','T','H','a','i','4','N','v','c','w','n','2','3','A','i','A','J','9','N','c', + 'z','7','n','n','3','n','h','n','i','R','i','b','E','h','k','U','c','c','U','6','f','x','q','N','y','H','M','e','J','B','U','B', + 'r','g','a','8','V','a','G','V','y','u','c','c','v','C','H','W','y','g','z','Q','2','4','k','S','m','f','e','G','H','v','Q','3', + 'P','e','f','S','V','P','c','U','e','3','P','x','d','c','7','c','f','g','D','w','2','t','q','y','g','2','Q','V','4','K','a','Q', + 'g','B','b','L','x','9','m','a','K','4','i','x','g','Q','M','9','W','N','2','w','p','v','2','k','B','y','9','k','A','c','f','Z', + 'D','R','A','S','d','v','w','f','f','q','t','K','3','j','x','D','G','P','n','u','r','v','U','k','A','2','d','R','N','T','G','4', + 'B','g','k','t','h','7','J','k','F','A','C','g','W','g','J','F','z','S','Q','c','v','M','b','D','e','H','Q','S','j','v','G','E', + 'R','k','f','i','P','E','F','N','6','y','p','b','t','M','c','Q','B','7','g','w','J','7','3','d','V','E','m','z','6','6','P','P', + 'd','i','r','J','H','D','H','J','r','b','n','v','z','W','e','u','g','B','u','Z','2','m','D','5','h','F','X','B','2','r','6','w', + 'u','Y','4','N','X','K','a','v','V','3','j','B','r','r','C','c','w','R','g','S','8','V','b','F','2','N','M','c','K','8','Y','E', + 'E','N','K','X','K','V','B','x','n','Q','p','a','q','f','k','t','z','Y','E','P','Z','y','n','a','c','B','V','a','x','b','d','X', + 'r','d','8','P','H','F','v','r','V','5','g','J','w','6','i','h','d','d','p','J','c','c','Y','S','q','W','m','U','5','G','b','H', + 'N','z','E','Z','K','E','y','M','c','G','i','d','w','Z','D','N','N','w','S','t','g','y','a','Y','b','H','e','M','N','f','Y','Y', + '7','a','9','b','M','U','k','a','V','k','C','n','a','k','U','H','A','M','i','v','k','t','a','d','i','3','F','d','5','2','A','p', + 'U','c','J','U','R','h','G','d','A','Y','v','q','X','c','w','r','x','4','j','3','4','b','F','d','a','L','N','J','3','Z','g','6', + 'W','Q','R','u','P','t','M','A','3','F','6','y','K','Y','G','2','t','v','u','p','w','b','G','S','K','5','p','4','d','E','w','6', + 'g','t','V','4','b','2','n','b','Z','3','3','f','m','d','2','c','a','m','j','X','U','E','D','6','6','F','w','H','9','7','Z','Y', + 'd','X','C','K','i','g','p','F','Y','n','2','b','F','4','R','u','V','k','f','d','J','i','a','b','X','H','7','v','K','a','Q','i', + 'W','M','j','M','i','a','i','n','F','h','r','q','4','w','x','m','4','q','y','F','8','w','i','4','D','B','A','L','B','U','u','K', + 'v','K','n','a','Q','i','e','k','v','Q','U','5','w','Q','c','r','A','6','M','w','y','g','n','e','v','K','7','W','u','2','y','f', + 'Q','u','e','r','y','a','w','V','p','f','Q','z','C','u','i','i','9','S','P','q','L','r','C','H','S','3','E','p','8','S','m','Q', + 'S','K','r','V','b','J','R','m','w','c','n','Q','N','Q','4','M','u','f','X','S','f','U','Z','x','U','4','j','K','4','G','z','X', + '7','Q','j','R','h','i','G','m','q','c','V','T','x','U','a','E','b','Q','q','E','i','F','K','7','K','i','R','J','5','Y','F','V', + 'B','7','R','8','M','i','f','j','Z','w','j','b','B','u','p','N','Y','r','S','r','f','h','E','J','T','B','P','R','D','V','K','A', + 'Z','A','R','j','z','f','B','i','Y','L','F','G','V','Y','w','R','C','P','G','m','9','7','C','5','e','y','w','N','K','N','a','Q', + 'j','a','W','3','2','f','G','w','n','M','6','F','u','K','8','g','8','M','G','r','e','9','Z','z','y','2','G','U','k','G','6','m', + 'A','D','4','n','b','8','a','q','S','m','S','6','5','R','5','D','5','S','B','g','X','T','8','Q','V','d','A','n','g','y','8','a', + 'h','7','K','9','H','D','J','F','w','G','4','w','T','J','F','f','i','8','X','e','B','J','K','H','7','V','y','X','7','E','8','S', + 'A','d','b','w','S','8','Y','a','J','d','j','E','V','J','T','E','U','R','5','7','V','M','E','v','D','3','z','5','r','k','z','v', + 'e','m','A','7','P','8','j','X','E','f','Q','q','8','D','g','y','8','j','A','e','B','c','c','M','z','k','2','c','q','v','v','y', + 'Q','y','h','g','p','v','M','m','m','C','G','D','k','8','u','T','n','Q','H','G','H','f','b','J','j','5','X','c','i','7','7','q', + 'b','R','8','b','b','z','f','f','h','Y','Q','7','u','B','X','e','i','j','M','q','C','T','M','v','t','J','J','w','b','F','v','J', + 'm','e','2','u','e','8','L','V','G','q','A','j','m','7','m','g','m','5','i','r','p','p','U','y','F','6','f','b','u','6','q','L', + 'M','E','t','V','W','C','t','e','p','w','a','n','w','y','X','h','8','e','G','C','H','q','r','X','G','9','c','h','7','k','8','M', + 'G','b','a','m','Y','Q','w','8','J','z','a','F','r','4','W','M','j','P','q','a','z','U','y','u','3','b','Z','f','Y','5','7','g', + 'N','M','h','M','a','3','C','K','6','6','f','a','p','i','f','q','k','T','i','z','w','f','Z','c','H','L','X','g','6','m','g','r', + 'w','Y','u','K','8','L','p','8','P','R','A','R','A','b','Z','V','a','x','V','c','G','A','H','t','Y','6','P','T','L','W','N','z', + 'g','z','k','d','E','v','C','t','Z','M','Z','K','4','w','9','5','D','W','f','U','8','5','u','6','b','5','B','8','g','y','C','E', + 'Q','z','e','9','p','N','S','P','D','D','f','x','k','Z','4','R','v','X','V','k','p','b','n','t','c','F','R','e','x','9','C','D', + 'J','2','6','f','Z','D','w','J','R','j','j','9','b','w','N','N','p','R','f','Z','z','j','F','r','Q','e','F','x','f','t','V','V', + 'A','y','J','G','W','Z','H','r','D','5','M','u','H','V','L','N','U','V','X','z','j','9','r','v','e','d','R','c','u','V','x','r', + 'c','6','k','L','h','q','w','U','W','Q','g','G','F','C','t','E','a','D','h','x','9','5','P','R','Z','E','M','5','f','4','2','t', + 'A','6','f','r','X','G','X','Y','B','8','G','E','n','B','v','x','f','M','R','f','B','z','Y','3','2','q','z','G','t','P','C','6', + '6','r','z','J','r','c','n','d','6','h','e','w','D','D','h','V','L','u','i','b','5','K','d','S','y','9','N','p','E','r','D','k', + 'B','z','u','v','d','Q','p','K','5','m','J','r','b','Y','Z','7','p','M','J','F','E','q','x','f','E','K','U','U','4','f','a','6', + 'g','5','a','q','D','U','8','F','y','R','a','P','5','5','x','z','6','V','T','P','D','m','y','7','U','5','C','A','7','Q','h','w', + 'r','6','x','g','Q','i','b','K','F','p','B','X','Q','h','i','E','r','C','z','v','x','W','Q','6','p','6','b','M','K','V','x','u', + 'k','d','R','S','k','Q','p','n','h','d','Q','Y','x','n','x','5','K','t','5','w','A','5','p','k','F','z','W','p','j','U','y','V', + 'x','G','m','y','L','A','X','H','G','A','a','J','5','E','P','q','E','U','7','p','6','A','9','n','d','G','D','g','i','h','t','W', + 'b','c','E','2','P','d','y','J','M','u','4','g','P','S','X','J','v','w','3','v','D','q','U','i','U','T','q','E','Y','5','2','t', + 'b','j','P','2','j','D','9','y','i','B','5','Y','3','X','L','w','m','V','X','z','X','r','Z','d','H','L','A','H','k','R','X','5', + 'i','L','m','q','3','p','a','G','P','j','g','h','R','P','Y','U','z','M','5','R','M','A','E','Q','V','c','w','r','4','M','S','k', + 'N','D','i','R','R','x','t','q','T','i','u','N','K','R','x','Z','K','a','g','G','y','9','c','j','J','S','9','3','H','T','f','F', + 'q','6','D','W','F','K','h','e','p','p','b','q','N','k','A','C','m','y','u','B','J','v','q','D','e','j','e','b','2','w','R','t', + 'J','N','j','F','T','A','8','L','m','X','i','T','g','j','c','V','4','V','h','2','h','R','p','2','9','k','c','c','G','D','h','z', + 't','i','h','t','W','R','n','Y','i','8','u','6','G','9','T','P','9','9','J','P','Y','R','h','X','K','z','h','L','W','r','C','U', + '2','L','T','k','2','m','6','W','L','P','T','Z','z','t','i','H','5','G','w','t','E','v','z','k','b','H','b','b','W','W','u','b', + 'i','h','C','Q','n','H','N','u','5','u','K','X','r','M','W','U','3','Y','k','P','2','k','x','f','x','C','w','z','z','b','G','8', + 'y','W','e','j','v','2','v','r','t','q','z','p','Y','d','w','6','Z','D','J','L','9','F','z','G','U','4','a','8','H','6','U','a', + 'q','7','y','Q','J','v','m','D','P','S','j','q','v','t','n','t','g','j','3','t','8','f','K','K','7','b','W','d','F','i','N','K', + 'a','R','V','V','V','v','m','A','Q','2','y','j','c','t','f','k','j','7','X','y','j','b','U','F','w','W','3','9','6','A','S','J', + 'p','q','2','Z','7','L','p','b','7','b','5','i','p','r','r','h','P','M','h','j','c','y','e','u','h','B','d','9','9','u','f','d', + 'g','u','p','w','u','9','S','c','L','U','g','A','y','V','F','V','6','D','D','X','i','V','m','u','Y','P','J','v','L','T','A','F', + 'M','Q','H','Z','6','v','8','p','A','L','P','z','C','V','a','C','h','X','j','W','8','G','z','j','d','M','4','u','x','w','H','g', + 'V','q','K','z','b','g','2','3','D','N','y','G','X','F','T','v','T','L','y','v','L','9','g','c','C','R','8','L','A','7','Y','N', + 't','n','R','6','b','n','m','9','i','h','t','T','F','a','V','N','J','J','3','J','q','p','W','7','b','T','G','r','M','k','a','7', + 'D','H','v','y','T','A','C','U','P','u','q','L','R','Y','4','q','h','y','f','F','J','x','K','7','N','B','v','3','a','Z','M','t', + 'U','x','8','9','V','E','t','j','K','r','u','Y','Y','A','u','w','Y','2','y','Q','z','S','n','J','B','2','t','X','x','K','z','g', + '6','d','n','i','7','Z','N','F','Q','6','w','N','r','b','k','d','W','X','S','t','c','U','m','6','4','2','e','w','6','x','Z','a', + 'Q','A','7','4','h','H','z','r','e','J','q','j','w','4','q','c','i','R','4','x','n','r','j','r','P','g','E','7','t','k','b','Z', + 'r','A','b','d','g','i','G','V','D','E','U','L','b','J','U','q','2','S','K','m','A','U','L','k','Q','4','N','p','k','G','C','6', + 'R','Z','B','y','B','B','j','y','x','L','d','h','L','G','6','x','H','z','T','5','d','Y','4','2','m','q','Q','y','H','6','c','N', + 'u','m','U','v','i','Y','Z','7','4','L','K','F','b','v','2','Y','h','x','8','a','R','w','q','x','E','a','T','y','m','C','2','Q', + 'U','T','D','Q','v','u','M','9','D','8','r','8','b','m','p','E','7','C','T','9','B','A','G','k','b','G','z','Z','G','L','N','k', + 'h','3','k','J','e','f','d','x','F','8','W','K','7','T','6','h','H','V','C','h','P','u','H','e','v','w','z','P','K','r','D','G', + 'X','Z','B','X','f','H','Q','4','e','D','y','W','Z','6','4','K','A','e','a','F','S','N','h','x','S','W','J','c','E','P','g','j', + 'a','w','T','m','Z','X','E','P','Y','R','M','2','R','2','X','N','F','X','Y','W','x','z','p','J','g','n','D','4','i','p','6','N', + 'r','9','G','k','E','h','T','h','U','h','x','B','Q','9','H','7','w','U','P','Q','d','G','6','q','p','j','j','v','C','a','X','J', + 'N','G','Y','w','f','H','C','x','F','k','z','3','9','r','h','8','7','5','V','i','V','C','R','q','x','N','2','2','i','W','F','U', + '7','T','H','f','z','E','a','n','u','Q','t','U','Y','G','t','3','A','m','r','6','d','f','e','n','e','z','F','u','U','N','8','m', + 'h','p','R','N','S','H','6','6','V','M','S','t','q','P','E','i','u','y','g','8','L','Q','Y','Y','G','e','W','W','C','G','y','b', + 'y','t','u','P','R','P','5','m','N','K','B','Z','w','f','t','k','x','3','L','b','q','d','w','S','G','E','h','R','F','4','q','e', + '5','6','F','2','n','q','T','R','y','f','n','Y','h','2','F','u','x','M','i','i','h','w','G','C','Z','v','i','C','a','X','U','C', + 'Y','8','d','h','R','x','V','n','v','G','i','D','a','U','p','U','a','e','b','F','w','P','d','X','n','K','h','9','H','r','b','g', + '2','f','m','X','k','m','q','6','n','5','b','G','H','d','R','9','D','U','c','r','Z','Y','W','S','Z','x','p','t','x','y','4','k', + 'j','F','U','t','C','i','e','i','b','p','e','4','C','z','h','3','3','5','Q','P','n','G','i','A','8','c','Q','z','B','a','V','4', + '2','B','2','z','u','u','3','i','L','w','y','g','K','H','k','y','2','B','b','e','5','e','4','e','U','4','z','n','P','z','a','c', + 'E','f','u','M','G','C','g','z','j','4','E','7','R','t','D','K','c','t','p','g','W','H','C','H','J','Q','J','c','F','5','4','W', + 'K','7','j','h','A','T','K','z','t','S','f','f','j','C','c','8','n','7','c','T','U','R','Q','E','7','A','W','Z','z','K','5','j', + '2','H','k','a','j','g','g','W','w','4','T','A','9','J','U','e','S','N','P','K','d','k','L','Q','G','Z','e','W','i','H','u','j', + 'C','z','4','E','2','v','5','L','u','9','Z','a','9','A','b','C','M','G','X','B','C','2','Y','Z','e','U','n','E','5','Y','n','y', + 'F','h','H','p','9','j','Y','F','V','w','Y','r','8','Q','f','C','J','4','T','t','z','Q','N','M','e','7','4','3','y','E','M','m', + 'b','S','c','h','w','a','X','E','d','E','z','t','h','9','k','p','A','k','K','H','x','q','K','Z','B','u','a','9','3','U','U','u', + '8','E','D','v','y','k','W','Y','X','k','r','R','D','X','n','Q','V','d','e','D','g','x','E','V','Y','w','k','m','K','r','H','D', + 't','2','6','N','U','g','3','t','B','9','t','u','M','D','z','Y','K','z','K','r','V','5','i','e','p','M','d','t','w','6','a','f', + 'f','W','k','L','i','g','M','V','M','Y','b','x','e','4','h','h','Y','g','w','Z','m','e','e','6','R','W','M','x','G','y','V','n', + '6','e','g','A','g','K','a','N','7','p','a','u','E','4','6','M','t','X','h','g','b','j','p','5','x','x','B','P','3','J','M','7', + 'j','Z','P','y','e','Q','Z','e','t','j','3','t','F','V','x','m','b','b','B','y','J','L','L','9','3','R','a','5','j','S','V','t', + 'e','2','6','m','H','w','r','w','r','6','Q','3','x','z','m','A','d','x','t','E','H','c','Z','x','c','P','j','r','u','U','W','k', + '6','g','X','g','n','f','n','7','H','M','B','t','v','6','v','x','g','M','f','e','2','w','m','y','d','H','S','q','c','K','U','H', + '2','X','h','d','p','Q','7','J','X','i','X','f','a','z','V','A','F','2','8','z','v','h','C','h','e','4','g','z','w','z','h','q', + 'p','6','B','n','m','8','h','W','U','7','z','h','T','6','J','f','4','Z','n','Q','W','z','2','N','4','t','g','7','u','4','X','2', + 'C','F','L','n','J','n','m','j','3','P','3','Y','e','J','R','A','H','e','R','D','z','7','u','X','Y','y','D','w','J','m','G','U', + 'P','H','5','S','d','a','F','F','Y','c','M','f','3','3','L','v','V','B','U','C','A','d','N','H','Q','h','7','8','4','r','p','G', + 'v','M','D','H','7','e','E','r','i','K','Q','i','B','D','M','Z','p','c','R','G','u','c','H','a','N','k','E','f','9','R','7','x', + '6','3','5','u','x','3','h','v','p','6','q','r','j','u','f','W','T','q','P','n','Y','L','B','6','U','w','P','2','T','W','R','g', + '2','3','3','e','N','V','a','j','b','e','4','T','u','J','u','u','F','B','D','G','H','x','x','k','5','G','e','3','4','B','m','L', + 'S','b','i','t','T','p','M','D','Z','A','A','i','r','J','p','4','H','U','A','G','y','d','Q','5','U','R','F','8','q','a','S','H', + 'n','5','z','9','g','3','u','R','H','m','G','m','b','p','c','L','Z','Y','u','m','i','K','A','Q','R','T','X','G','t','b','8','7', + '7','6','w','M','N','f','R','G','r','L','m','q','n','7','5','k','X','8','g','u','K','7','Y','w','K','q','U','e','W','A','r','i', + 'Z','a','p','q','L','5','P','u','n','t','y','G','x','C','N','X','q','P','r','U','v','A','r','r','q','e','f','c','z','M','7','N', + '6','a','z','Z','a','t','f','p','4','v','J','Y','j','h','M','D','t','k','A','B','p','Q','A','y','x','X','7','p','S','8','m','M', + 'y','K','B','A','5','2','7','b','y','R','K','q','A','u','3','J'}; + +static const adler32_test tests[] = { + {__LINE__, 0x1, (const uint8_t *)0x0, 0, 0x1}, + {__LINE__, 0x1, (const uint8_t *)"", 1, 0x10001}, + {__LINE__, 0x1, (const uint8_t *)"a", 1, 0x620062}, + {__LINE__, 0x1, (const uint8_t *)"abacus", 6, 0x8400270}, + {__LINE__, 0x1, (const uint8_t *)"backlog", 7, 0xb1f02d4}, + {__LINE__, 0x1, (const uint8_t *)"campfire", 8, 0xea10348}, + {__LINE__, 0x1, (const uint8_t *)"delta", 5, 0x61a020b}, + {__LINE__, 0x1, (const uint8_t *)"executable", 10, 0x16fa0423}, + {__LINE__, 0x1, (const uint8_t *)"file", 4, 0x41401a1}, + {__LINE__, 0x1, (const uint8_t *)"greatest", 8, 0xefa0360}, + {__LINE__, 0x1, (const uint8_t *)"inverter", 8, 0xf6f0370}, + {__LINE__, 0x1, (const uint8_t *)"jigsaw", 6, 0x8bd0286}, + {__LINE__, 0x1, (const uint8_t *)"karate", 6, 0x8a50279}, + {__LINE__, 0x1, (const uint8_t *)"landscape", 9, 0x126a03ac}, + {__LINE__, 0x1, (const uint8_t *)"machine", 7, 0xb5302d6}, + {__LINE__, 0x1, (const uint8_t *)"nanometer", 9, 0x12d803ca}, + {__LINE__, 0x1, (const uint8_t *)"oblivion", 8, 0xf220363}, + {__LINE__, 0x1, (const uint8_t *)"panama", 6, 0x8a1026f}, + {__LINE__, 0x1, (const uint8_t *)"quest", 5, 0x6970233}, + {__LINE__, 0x1, (const uint8_t *)"resource", 8, 0xf8d0369}, + {__LINE__, 0x1, (const uint8_t *)"secret", 6, 0x8d10287}, + {__LINE__, 0x1, (const uint8_t *)"ultimate", 8, 0xf8d0366}, + {__LINE__, 0x1, (const uint8_t *)"vector", 6, 0x8fb0294}, + {__LINE__, 0x1, (const uint8_t *)"walrus", 6, 0x918029f}, + {__LINE__, 0x1, (const uint8_t *)"xeno", 4, 0x45e01bb}, + {__LINE__, 0x1, (const uint8_t *)"yelling", 7, 0xbfe02f5}, + {__LINE__, 0x1, (const uint8_t *)"zero", 4, 0x46e01c1}, + {__LINE__, 0x1, (const uint8_t *)"4BJD7PocN1VqX0jXVpWB", 20, 0x3eef064d}, + {__LINE__, 0x1, (const uint8_t *)"F1rPWI7XvDs6nAIRx41l", 20, 0x425d065f}, + {__LINE__, 0x1, (const uint8_t *)"ldhKlsVkPFOveXgkGtC2", 20, 0x4f1a073e}, + {__LINE__, 0x1, (const uint8_t *)"5KKnGOOrs8BvJ35iKTOS", 20, 0x42290650}, + {__LINE__, 0x1, (const uint8_t *)"0l1tw7GOcem06Ddu7yn4", 20, 0x43fd0690}, + {__LINE__, 0x1, (const uint8_t *)"MCr47CjPIn9R1IvE1Tm5", 20, 0x3f770609}, + {__LINE__, 0x1, (const uint8_t *)"UcixbzPKTIv0SvILHVdO", 20, 0x4c7c0703}, + {__LINE__, 0x1, (const uint8_t *)"dGnAyAhRQDsWw0ESou24", 20, 0x48ac06b7}, + {__LINE__, 0x1, (const uint8_t *)"di0nvmY9UYMYDh0r45XT", 20, 0x489a0698}, + {__LINE__, 0x1, (const uint8_t *)"2XKDwHfAhFsV0RhbqtvH", 20, 0x44a906e6}, + {__LINE__, 0x1, (const uint8_t *)"ZhrANFIiIvRnqClIVyeD", 20, 0x4a29071c}, + {__LINE__, 0x1, (const uint8_t *)"v7Q9ehzioTOVeDIZioT1", 20, 0x4a7706f9}, + {__LINE__, 0x1, (const uint8_t *)"Yod5hEeKcYqyhfXbhxj2", 20, 0x4ce60769}, + {__LINE__, 0x1, (const uint8_t *)"GehSWY2ay4uUKhehXYb0", 20, 0x48ae06e5}, + {__LINE__, 0x1, (const uint8_t *)"kwytJmq6UqpflV8Y8GoE", 20, 0x51d60750}, + {__LINE__, 0x1, (const uint8_t *)"70684206568419061514", 20, 0x2b100414}, + {__LINE__, 0x1, (const uint8_t *)"42015093765128581010", 20, 0x2a550405}, + {__LINE__, 0x1, (const uint8_t *)"88214814356148806939", 20, 0x2b450423}, + {__LINE__, 0x1, (const uint8_t *)"43472694284527343838", 20, 0x2b460421}, + {__LINE__, 0x1, (const uint8_t *)"49769333513942933689", 20, 0x2bc1042b}, + {__LINE__, 0x1, (const uint8_t *)"54979784887993251199", 20, 0x2ccd043d}, + {__LINE__, 0x1, (const uint8_t *)"58360544869206793220", 20, 0x2b68041a}, + {__LINE__, 0x1, (const uint8_t *)"27347953487840714234", 20, 0x2b84041d}, + {__LINE__, 0x1, (const uint8_t *)"07650690295365319082", 20, 0x2afa0417}, + {__LINE__, 0x1, (const uint8_t *)"42655507906821911703", 20, 0x2aff0412}, + {__LINE__, 0x1, (const uint8_t *)"29977409200786225655", 20, 0x2b8d0420}, + {__LINE__, 0x1, (const uint8_t *)"85181542907229116674", 20, 0x2b140419}, + {__LINE__, 0x1, (const uint8_t *)"87963594337989416799", 20, 0x2c8e043f}, + {__LINE__, 0x1, (const uint8_t *)"21395988329504168551", 20, 0x2b68041f}, + {__LINE__, 0x1, (const uint8_t *)"51991013580943379423", 20, 0x2af10417}, + {__LINE__, 0x1, (const uint8_t *)"*]+@!);({_$;}[_},?{?;(_?,=-][@", 30, 0x7c9d0841}, + {__LINE__, 0x1, (const uint8_t *)"_@:_).&(#.[:[{[:)$++-($_;@[)}+", 30, 0x71060751}, + {__LINE__, 0x1, (const uint8_t *)"&[!,[$_==}+.]@!;*(+},[;:)$;)-@", 30, 0x7095070a}, + {__LINE__, 0x1, (const uint8_t *)"]{.[.+?+[[=;[?}_#&;[=)__$$:+=_", 30, 0x82530815}, + {__LINE__, 0x1, (const uint8_t *)"-%.)=/[@].:.(:,()$;=%@-$?]{%+%", 30, 0x61250661}, + {__LINE__, 0x1, (const uint8_t *)"+]#$(@&.=:,*];/.!]%/{:){:@(;)$", 30, 0x642006a3}, + {__LINE__, 0x1, (const uint8_t *)")-._.:?[&:.=+}(*$/=!.${;(=$@!}", 30, 0x674206cb}, + {__LINE__, 0x1, (const uint8_t *)":(_*&%/[[}+,?#$&*+#[([*-/#;%(]", 30, 0x67670680}, + {__LINE__, 0x1, (const uint8_t *)"{[#-;:$/{)(+[}#]/{&!%(@)%:@-$:", 30, 0x7547070f}, + {__LINE__, 0x1, (const uint8_t *)"_{$*,}(&,@.)):=!/%(&(,,-?$}}}!", 30, 0x69ea06ee}, + {__LINE__, 0x1, (const uint8_t *)"e$98KNzqaV)Y:2X?]77].{gKRD4G5{mHZk,Z)SpU%L3FSgv!Wb8MLAFdi{+fp)c,@8m6v)yXg@]HBDFk?.4&}g5_udE*JHCiH=aL", 100, 0x1b01e92}, + {__LINE__, 0x1, (const uint8_t *)"r*Fd}ef+5RJQ;+W=4jTR9)R*p!B;]Ed7tkrLi;88U7g@3v!5pk2X6D)vt,.@N8c]@yyEcKi[vwUu@.Ppm@C6%Mv*3Nw}Y,58_aH)", 100, 0xfbdb1e96}, + {__LINE__, 0x1, (const uint8_t *)"h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&", 100, 0x47a61ec8}, + {__LINE__, 0x1, (const uint8_t *)long_string, 5552, 0x8b81718f}, + {__LINE__, 0x7a30360d, (const uint8_t *)0x0, 0, 0x1}, + {__LINE__, 0x6fd767ee, (const uint8_t *)"", 1, 0xd7c567ee}, + {__LINE__, 0xefeb7589, (const uint8_t *)"a", 1, 0x65e475ea}, + {__LINE__, 0x61cf7e6b, (const uint8_t *)"abacus", 6, 0x60b880da}, + {__LINE__, 0xdc712e2, (const uint8_t *)"backlog", 7, 0x9d0d15b5}, + {__LINE__, 0xad23c7fd, (const uint8_t *)"campfire", 8, 0xfbfecb44}, + {__LINE__, 0x85cb2317, (const uint8_t *)"delta", 5, 0x3b622521}, + {__LINE__, 0x9eed31b0, (const uint8_t *)"executable", 10, 0xa6db35d2}, + {__LINE__, 0xb94f34ca, (const uint8_t *)"file", 4, 0x9096366a}, + {__LINE__, 0xab058a2, (const uint8_t *)"greatest", 8, 0xded05c01}, + {__LINE__, 0x5bff2b7a, (const uint8_t *)"inverter", 8, 0xc7452ee9}, + {__LINE__, 0x605c9a5f, (const uint8_t *)"jigsaw", 6, 0x7899ce4}, + {__LINE__, 0x51bdeea5, (const uint8_t *)"karate", 6, 0xf285f11d}, + {__LINE__, 0x85c21c79, (const uint8_t *)"landscape", 9, 0x98732024}, + {__LINE__, 0x97216f56, (const uint8_t *)"machine", 7, 0xadf4722b}, + {__LINE__, 0x18444af2, (const uint8_t *)"nanometer", 9, 0xcdb34ebb}, + {__LINE__, 0xbe6ce359, (const uint8_t *)"oblivion", 8, 0xe8b7e6bb}, + {__LINE__, 0x843071f1, (const uint8_t *)"panama", 6, 0x389e745f}, + {__LINE__, 0xf2480c60, (const uint8_t *)"quest", 5, 0x36c90e92}, + {__LINE__, 0x2d2feb3d, (const uint8_t *)"resource", 8, 0x9705eea5}, + {__LINE__, 0x7490310a, (const uint8_t *)"secret", 6, 0xa3a63390}, + {__LINE__, 0x97d247d4, (const uint8_t *)"ultimate", 8, 0xe6154b39}, + {__LINE__, 0x93cf7599, (const uint8_t *)"vector", 6, 0x5e87782c}, + {__LINE__, 0x73c84278, (const uint8_t *)"walrus", 6, 0xbc84516}, + {__LINE__, 0x228a87d1, (const uint8_t *)"xeno", 4, 0x4646898b}, + {__LINE__, 0xa7a048d0, (const uint8_t *)"yelling", 7, 0xb1654bc4}, + {__LINE__, 0x1f0ded40, (const uint8_t *)"zero", 4, 0xd8a4ef00}, + {__LINE__, 0xa804a62f, (const uint8_t *)"4BJD7PocN1VqX0jXVpWB", 20, 0xe34eac7b}, + {__LINE__, 0x508fae6a, (const uint8_t *)"F1rPWI7XvDs6nAIRx41l", 20, 0x33f2b4c8}, + {__LINE__, 0xe5adaf4f, (const uint8_t *)"ldhKlsVkPFOveXgkGtC2", 20, 0xe7b1b68c}, + {__LINE__, 0x67136a40, (const uint8_t *)"5KKnGOOrs8BvJ35iKTOS", 20, 0xf6a0708f}, + {__LINE__, 0xb00c4a10, (const uint8_t *)"0l1tw7GOcem06Ddu7yn4", 20, 0xbd8f509f}, + {__LINE__, 0x2e0c84b5, (const uint8_t *)"MCr47CjPIn9R1IvE1Tm5", 20, 0xcc298abd}, + {__LINE__, 0x81238d44, (const uint8_t *)"UcixbzPKTIv0SvILHVdO", 20, 0xd7809446}, + {__LINE__, 0xf853aa92, (const uint8_t *)"dGnAyAhRQDsWw0ESou24", 20, 0x9525b148}, + {__LINE__, 0x5a692325, (const uint8_t *)"di0nvmY9UYMYDh0r45XT", 20, 0x620029bc}, + {__LINE__, 0x3275b9f, (const uint8_t *)"2XKDwHfAhFsV0RhbqtvH", 20, 0x70916284}, + {__LINE__, 0x38371feb, (const uint8_t *)"ZhrANFIiIvRnqClIVyeD", 20, 0xd52706}, + {__LINE__, 0xafc8bf62, (const uint8_t *)"v7Q9ehzioTOVeDIZioT1", 20, 0xeeb4c65a}, + {__LINE__, 0x9b07db73, (const uint8_t *)"Yod5hEeKcYqyhfXbhxj2", 20, 0xde3e2db}, + {__LINE__, 0xe75b214, (const uint8_t *)"GehSWY2ay4uUKhehXYb0", 20, 0x4171b8f8}, + {__LINE__, 0x72d0fe6f, (const uint8_t *)"kwytJmq6UqpflV8Y8GoE", 20, 0xa66a05cd}, + {__LINE__, 0xf857a4b1, (const uint8_t *)"70684206568419061514", 20, 0x1f9a8c4}, + {__LINE__, 0x54b8e14, (const uint8_t *)"42015093765128581010", 20, 0x49c19218}, + {__LINE__, 0xd6aa5616, (const uint8_t *)"88214814356148806939", 20, 0xbbfc5a38}, + {__LINE__, 0x11e63098, (const uint8_t *)"43472694284527343838", 20, 0x93434b8}, + {__LINE__, 0xbe92385, (const uint8_t *)"49769333513942933689", 20, 0xfe1827af}, + {__LINE__, 0x49511de0, (const uint8_t *)"54979784887993251199", 20, 0xcba8221c}, + {__LINE__, 0x3db13bc1, (const uint8_t *)"58360544869206793220", 20, 0x14643fda}, + {__LINE__, 0xbb899bea, (const uint8_t *)"27347953487840714234", 20, 0x1604a006}, + {__LINE__, 0xf6cd9436, (const uint8_t *)"07650690295365319082", 20, 0xb69f984c}, + {__LINE__, 0x9109e6c3, (const uint8_t *)"42655507906821911703", 20, 0xc43eead4}, + {__LINE__, 0x75770fc, (const uint8_t *)"29977409200786225655", 20, 0x707751b}, + {__LINE__, 0x69b1d19b, (const uint8_t *)"85181542907229116674", 20, 0xf5bdd5b3}, + {__LINE__, 0xc6132975, (const uint8_t *)"87963594337989416799", 20, 0x2fed2db3}, + {__LINE__, 0xd58cb00c, (const uint8_t *)"21395988329504168551", 20, 0xc2a2b42a}, + {__LINE__, 0xb63b8caa, (const uint8_t *)"51991013580943379423", 20, 0xdf0590c0}, + {__LINE__, 0x8a45a2b8, (const uint8_t *)"*]+@!);({_$;}[_},?{?;(_?,=-][@", 30, 0x1980aaf8}, + {__LINE__, 0xcbe95b78, (const uint8_t *)"_@:_).&(#.[:[{[:)$++-($_;@[)}+", 30, 0xf58662c8}, + {__LINE__, 0x4ef8a54b, (const uint8_t *)"&[!,[$_==}+.]@!;*(+},[;:)$;)-@", 30, 0x1f65ac54}, + {__LINE__, 0x76ad267a, (const uint8_t *)"]{.[.+?+[[=;[?}_#&;[=)__$$:+=_", 30, 0x7b792e8e}, + {__LINE__, 0x569e613c, (const uint8_t *)"-%.)=/[@].:.(:,()$;=%@-$?]{%+%", 30, 0x1d61679c}, + {__LINE__, 0x36aa61da, (const uint8_t *)"+]#$(@&.=:,*];/.!]%/{:){:@(;)$", 30, 0x12ec687c}, + {__LINE__, 0xf67222df, (const uint8_t *)")-._.:?[&:.=+}(*$/=!.${;(=$@!}", 30, 0x740329a9}, + {__LINE__, 0x74b34fd3, (const uint8_t *)":(_*&%/[[}+,?#$&*+#[([*-/#;%(]", 30, 0x374c5652}, + {__LINE__, 0x351fd770, (const uint8_t *)"{[#-;:$/{)(+[}#]/{&!%(@)%:@-$:", 30, 0xeadfde7e}, + {__LINE__, 0xc45aef77, (const uint8_t *)"_{$*,}(&,@.)):=!/%(&(,,-?$}}}!", 30, 0x3fcbf664}, + {__LINE__, 0xd034ea71, (const uint8_t *)"e$98KNzqaV)Y:2X?]77].{gKRD4G5{mHZk,Z)SpU%L3FSgv!Wb8MLAFdi{+fp)c,@8m6v)yXg@]HBDFk?.4&}g5_udE*JHCiH=aL", 100, 0x6b080911}, + {__LINE__, 0xdeadc0de, (const uint8_t *)"r*Fd}ef+5RJQ;+W=4jTR9)R*p!B;]Ed7tkrLi;88U7g@3v!5pk2X6D)vt,.@N8c]@yyEcKi[vwUu@.Ppm@C6%Mv*3Nw}Y,58_aH)", 100, 0x355fdf73}, + {__LINE__, 0xba5eba11, (const uint8_t *)"h{bcmdC+a;t+Cf{6Y_dFq-{X4Yu&7uNfVDh?q&_u.UWJU],-GiH7ADzb7-V.Q%4=+v!$L9W+T=bP]$_:]Vyg}A.ygD.r;h-D]m%&", 100, 0xb48bd8d8}, + {__LINE__, 0x7712aa45, (const uint8_t *)long_string, 5552, 0x7dc51be2}, +}; + +static const int test_size = sizeof(tests) / sizeof(tests[0]); + +int main(void) { + int i; + for (i = 0; i < test_size; i++) { + test_adler32(tests[i].adler, tests[i].buf, tests[i].len, tests[i].expect, tests[i].line); + } + + return 0; +} diff --git a/libs/zlibng/test/data/fireworks.jpg b/libs/zlibng/test/data/fireworks.jpg new file mode 100644 index 000000000..078cf1755 Binary files /dev/null and b/libs/zlibng/test/data/fireworks.jpg differ diff --git a/libs/zlibng/test/data/lcet10.txt b/libs/zlibng/test/data/lcet10.txt new file mode 100644 index 000000000..26b187d04 --- /dev/null +++ b/libs/zlibng/test/data/lcet10.txt @@ -0,0 +1,7519 @@ + + +The Project Gutenberg Etext of LOC WORKSHOP ON ELECTRONIC TEXTS + + + + + WORKSHOP ON ELECTRONIC TEXTS + + PROCEEDINGS + + + + Edited by James Daly + + + + + + + + 9-10 June 1992 + + + Library of Congress + Washington, D.C. + + + + Supported by a Grant from the David and Lucile Packard Foundation + + + *** *** *** ****** *** *** *** + + + TABLE OF CONTENTS + + +Acknowledgements + +Introduction + +Proceedings + Welcome + Prosser Gifford and Carl Fleischhauer + + Session I. Content in a New Form: Who Will Use It and What Will They Do? + James Daly (Moderator) + Avra Michelson, Overview + Susan H. Veccia, User Evaluation + Joanne Freeman, Beyond the Scholar + Discussion + + Session II. Show and Tell + Jacqueline Hess (Moderator) + Elli Mylonas, Perseus Project + Discussion + Eric M. Calaluca, Patrologia Latina Database + Carl Fleischhauer and Ricky Erway, American Memory + Discussion + Dorothy Twohig, The Papers of George Washington + Discussion + Maria L. Lebron, The Online Journal of Current Clinical Trials + Discussion + Lynne K. Personius, Cornell mathematics books + Discussion + + Session III. Distribution, Networks, and Networking: + Options for Dissemination + Robert G. Zich (Moderator) + Clifford A. Lynch + Discussion + Howard Besser + Discussion + Ronald L. Larsen + Edwin B. Brownrigg + Discussion + + Session IV. Image Capture, Text Capture, Overview of Text and + Image Storage Formats + William L. Hooton (Moderator) + A) Principal Methods for Image Capture of Text: + direct scanning, use of microform + Anne R. Kenney + Pamela Q.J. Andre + Judith A. Zidar + Donald J. Waters + Discussion + B) Special Problems: bound volumes, conservation, + reproducing printed halftones + George Thoma + Carl Fleischhauer + Discussion + C) Image Standards and Implications for Preservation + Jean Baronas + Patricia Battin + Discussion + D) Text Conversion: OCR vs. rekeying, standards of accuracy + and use of imperfect texts, service bureaus + Michael Lesk + Ricky Erway + Judith A. Zidar + Discussion + + Session V. Approaches to Preparing Electronic Texts + Susan Hockey (Moderator) + Stuart Weibel + Discussion + C.M. Sperberg-McQueen + Discussion + Eric M. Calaluca + Discussion + + Session VI. Copyright Issues + Marybeth Peters + + Session VII. Conclusion + Prosser Gifford (Moderator) + General discussion + +Appendix I: Program + +Appendix II: Abstracts + +Appendix III: Directory of Participants + + + *** *** *** ****** *** *** *** + + + Acknowledgements + +I would like to thank Carl Fleischhauer and Prosser Gifford for the +opportunity to learn about areas of human activity unknown to me a scant +ten months ago, and the David and Lucile Packard Foundation for +supporting that opportunity. The help given by others is acknowledged on +a separate page. + + 19 October 1992 + + + *** *** *** ****** *** *** *** + + + INTRODUCTION + +The Workshop on Electronic Texts (1) drew together representatives of +various projects and interest groups to compare ideas, beliefs, +experiences, and, in particular, methods of placing and presenting +historical textual materials in computerized form. Most attendees gained +much in insight and outlook from the event. But the assembly did not +form a new nation, or, to put it another way, the diversity of projects +and interests was too great to draw the representatives into a cohesive, +action-oriented body.(2) + +Everyone attending the Workshop shared an interest in preserving and +providing access to historical texts. But within this broad field the +attendees represented a variety of formal, informal, figurative, and +literal groups, with many individuals belonging to more than one. These +groups may be defined roughly according to the following topics or +activities: + +* Imaging +* Searchable coded texts +* National and international computer networks +* CD-ROM production and dissemination +* Methods and technology for converting older paper materials into +electronic form +* Study of the use of digital materials by scholars and others + +This summary is arranged thematically and does not follow the actual +sequence of presentations. + +NOTES: + (1) In this document, the phrase electronic text is used to mean + any computerized reproduction or version of a document, book, + article, or manuscript (including images), and not merely a machine- + readable or machine-searchable text. + + (2) The Workshop was held at the Library of Congress on 9-10 June + 1992, with funding from the David and Lucile Packard Foundation. + The document that follows represents a summary of the presentations + made at the Workshop and was compiled by James DALY. This + introduction was written by DALY and Carl FLEISCHHAUER. + + +PRESERVATION AND IMAGING + +Preservation, as that term is used by archivists,(3) was most explicitly +discussed in the context of imaging. Anne KENNEY and Lynne PERSONIUS +explained how the concept of a faithful copy and the user-friendliness of +the traditional book have guided their project at Cornell University.(4) +Although interested in computerized dissemination, participants in the +Cornell project are creating digital image sets of older books in the +public domain as a source for a fresh paper facsimile or, in a future +phase, microfilm. The books returned to the library shelves are +high-quality and useful replacements on acid-free paper that should last +a long time. To date, the Cornell project has placed little or no +emphasis on creating searchable texts; one would not be surprised to find +that the project participants view such texts as new editions, and thus +not as faithful reproductions. + +In her talk on preservation, Patricia BATTIN struck an ecumenical and +flexible note as she endorsed the creation and dissemination of a variety +of types of digital copies. Do not be too narrow in defining what counts +as a preservation element, BATTIN counseled; for the present, at least, +digital copies made with preservation in mind cannot be as narrowly +standardized as, say, microfilm copies with the same objective. Setting +standards precipitously can inhibit creativity, but delay can result in +chaos, she advised. + +In part, BATTIN's position reflected the unsettled nature of image-format +standards, and attendees could hear echoes of this unsettledness in the +comments of various speakers. For example, Jean BARONAS reviewed the +status of several formal standards moving through committees of experts; +and Clifford LYNCH encouraged the use of a new guideline for transmitting +document images on Internet. Testimony from participants in the National +Agricultural Library's (NAL) Text Digitization Program and LC's American +Memory project highlighted some of the challenges to the actual creation +or interchange of images, including difficulties in converting +preservation microfilm to digital form. Donald WATERS reported on the +progress of a master plan for a project at Yale University to convert +books on microfilm to digital image sets, Project Open Book (POB). + +The Workshop offered rather less of an imaging practicum than planned, +but "how-to" hints emerge at various points, for example, throughout +KENNEY's presentation and in the discussion of arcana such as +thresholding and dithering offered by George THOMA and FLEISCHHAUER. + +NOTES: + (3) Although there is a sense in which any reproductions of + historical materials preserve the human record, specialists in the + field have developed particular guidelines for the creation of + acceptable preservation copies. + + (4) Titles and affiliations of presenters are given at the + beginning of their respective talks and in the Directory of + Participants (Appendix III). + + +THE MACHINE-READABLE TEXT: MARKUP AND USE + +The sections of the Workshop that dealt with machine-readable text tended +to be more concerned with access and use than with preservation, at least +in the narrow technical sense. Michael SPERBERG-McQUEEN made a forceful +presentation on the Text Encoding Initiative's (TEI) implementation of +the Standard Generalized Markup Language (SGML). His ideas were echoed +by Susan HOCKEY, Elli MYLONAS, and Stuart WEIBEL. While the +presentations made by the TEI advocates contained no practicum, their +discussion focused on the value of the finished product, what the +European Community calls reusability, but what may also be termed +durability. They argued that marking up--that is, coding--a text in a +well-conceived way will permit it to be moved from one computer +environment to another, as well as to be used by various users. Two +kinds of markup were distinguished: 1) procedural markup, which +describes the features of a text (e.g., dots on a page), and 2) +descriptive markup, which describes the structure or elements of a +document (e.g., chapters, paragraphs, and front matter). + +The TEI proponents emphasized the importance of texts to scholarship. +They explained how heavily coded (and thus analyzed and annotated) texts +can underlie research, play a role in scholarly communication, and +facilitate classroom teaching. SPERBERG-McQUEEN reminded listeners that +a written or printed item (e.g., a particular edition of a book) is +merely a representation of the abstraction we call a text. To concern +ourselves with faithfully reproducing a printed instance of the text, +SPERBERG-McQUEEN argued, is to concern ourselves with the representation +of a representation ("images as simulacra for the text"). The TEI proponents' +interest in images tends to focus on corollary materials for use in teaching, +for example, photographs of the Acropolis to accompany a Greek text. + +By the end of the Workshop, SPERBERG-McQUEEN confessed to having been +converted to a limited extent to the view that electronic images +constitute a promising alternative to microfilming; indeed, an +alternative probably superior to microfilming. But he was not convinced +that electronic images constitute a serious attempt to represent text in +electronic form. HOCKEY and MYLONAS also conceded that their experience +at the Pierce Symposium the previous week at Georgetown University and +the present conference at the Library of Congress had compelled them to +reevaluate their perspective on the usefulness of text as images. +Attendees could see that the text and image advocates were in +constructive tension, so to say. + +Three nonTEI presentations described approaches to preparing +machine-readable text that are less rigorous and thus less expensive. In +the case of the Papers of George Washington, Dorothy TWOHIG explained +that the digital version will provide a not-quite-perfect rendering of +the transcribed text--some 135,000 documents, available for research +during the decades while the perfect or print version is completed. +Members of the American Memory team and the staff of NAL's Text +Digitization Program (see below) also outlined a middle ground concerning +searchable texts. In the case of American Memory, contractors produce +texts with about 99-percent accuracy that serve as "browse" or +"reference" versions of written or printed originals. End users who need +faithful copies or perfect renditions must refer to accompanying sets of +digital facsimile images or consult copies of the originals in a nearby +library or archive. American Memory staff argued that the high cost of +producing 100-percent accurate copies would prevent LC from offering +access to large parts of its collections. + + +THE MACHINE-READABLE TEXT: METHODS OF CONVERSION + +Although the Workshop did not include a systematic examination of the +methods for converting texts from paper (or from facsimile images) into +machine-readable form, nevertheless, various speakers touched upon this +matter. For example, WEIBEL reported that OCLC has experimented with a +merging of multiple optical character recognition systems that will +reduce errors from an unacceptable rate of 5 characters out of every +l,000 to an unacceptable rate of 2 characters out of every l,000. + +Pamela ANDRE presented an overview of NAL's Text Digitization Program and +Judith ZIDAR discussed the technical details. ZIDAR explained how NAL +purchased hardware and software capable of performing optical character +recognition (OCR) and text conversion and used its own staff to convert +texts. The process, ZIDAR said, required extensive editing and project +staff found themselves considering alternatives, including rekeying +and/or creating abstracts or summaries of texts. NAL reckoned costs at +$7 per page. By way of contrast, Ricky ERWAY explained that American +Memory had decided from the start to contract out conversion to external +service bureaus. The criteria used to select these contractors were cost +and quality of results, as opposed to methods of conversion. ERWAY noted +that historical documents or books often do not lend themselves to OCR. +Bound materials represent a special problem. In her experience, quality +control--inspecting incoming materials, counting errors in samples--posed +the most time-consuming aspect of contracting out conversion. ERWAY +reckoned American Memory's costs at $4 per page, but cautioned that fewer +cost-elements had been included than in NAL's figure. + + +OPTIONS FOR DISSEMINATION + +The topic of dissemination proper emerged at various points during the +Workshop. At the session devoted to national and international computer +networks, LYNCH, Howard BESSER, Ronald LARSEN, and Edwin BROWNRIGG +highlighted the virtues of Internet today and of the network that will +evolve from Internet. Listeners could discern in these narratives a +vision of an information democracy in which millions of citizens freely +find and use what they need. LYNCH noted that a lack of standards +inhibits disseminating multimedia on the network, a topic also discussed +by BESSER. LARSEN addressed the issues of network scalability and +modularity and commented upon the difficulty of anticipating the effects +of growth in orders of magnitude. BROWNRIGG talked about the ability of +packet radio to provide certain links in a network without the need for +wiring. However, the presenters also called attention to the +shortcomings and incongruities of present-day computer networks. For +example: 1) Network use is growing dramatically, but much network +traffic consists of personal communication (E-mail). 2) Large bodies of +information are available, but a user's ability to search across their +entirety is limited. 3) There are significant resources for science and +technology, but few network sources provide content in the humanities. +4) Machine-readable texts are commonplace, but the capability of the +system to deal with images (let alone other media formats) lags behind. +A glimpse of a multimedia future for networks, however, was provided by +Maria LEBRON in her overview of the Online Journal of Current Clinical +Trials (OJCCT), and the process of scholarly publishing on-line. + +The contrasting form of the CD-ROM disk was never systematically +analyzed, but attendees could glean an impression from several of the +show-and-tell presentations. The Perseus and American Memory examples +demonstrated recently published disks, while the descriptions of the +IBYCUS version of the Papers of George Washington and Chadwyck-Healey's +Patrologia Latina Database (PLD) told of disks to come. According to +Eric CALALUCA, PLD's principal focus has been on converting Jacques-Paul +Migne's definitive collection of Latin texts to machine-readable form. +Although everyone could share the network advocates' enthusiasm for an +on-line future, the possibility of rolling up one's sleeves for a session +with a CD-ROM containing both textual materials and a powerful retrieval +engine made the disk seem an appealing vessel indeed. The overall +discussion suggested that the transition from CD-ROM to on-line networked +access may prove far slower and more difficult than has been anticipated. + + +WHO ARE THE USERS AND WHAT DO THEY DO? + +Although concerned with the technicalities of production, the Workshop +never lost sight of the purposes and uses of electronic versions of +textual materials. As noted above, those interested in imaging discussed +the problematical matter of digital preservation, while the TEI proponents +described how machine-readable texts can be used in research. This latter +topic received thorough treatment in the paper read by Avra MICHELSON. +She placed the phenomenon of electronic texts within the context of +broader trends in information technology and scholarly communication. + +Among other things, MICHELSON described on-line conferences that +represent a vigorous and important intellectual forum for certain +disciplines. Internet now carries more than 700 conferences, with about +80 percent of these devoted to topics in the social sciences and the +humanities. Other scholars use on-line networks for "distance learning." +Meanwhile, there has been a tremendous growth in end-user computing; +professors today are less likely than their predecessors to ask the +campus computer center to process their data. Electronic texts are one +key to these sophisticated applications, MICHELSON reported, and more and +more scholars in the humanities now work in an on-line environment. +Toward the end of the Workshop, Michael LESK presented a corollary to +MICHELSON's talk, reporting the results of an experiment that compared +the work of one group of chemistry students using traditional printed +texts and two groups using electronic sources. The experiment +demonstrated that in the event one does not know what to read, one needs +the electronic systems; the electronic systems hold no advantage at the +moment if one knows what to read, but neither do they impose a penalty. + +DALY provided an anecdotal account of the revolutionizing impact of the +new technology on his previous methods of research in the field of classics. +His account, by extrapolation, served to illustrate in part the arguments +made by MICHELSON concerning the positive effects of the sudden and radical +transformation being wrought in the ways scholars work. + +Susan VECCIA and Joanne FREEMAN delineated the use of electronic +materials outside the university. The most interesting aspect of their +use, FREEMAN said, could be seen as a paradox: teachers in elementary +and secondary schools requested access to primary source materials but, +at the same time, found that "primariness" itself made these materials +difficult for their students to use. + + +OTHER TOPICS + +Marybeth PETERS reviewed copyright law in the United States and offered +advice during a lively discussion of this subject. But uncertainty +remains concerning the price of copyright in a digital medium, because a +solution remains to be worked out concerning management and synthesis of +copyrighted and out-of-copyright pieces of a database. + +As moderator of the final session of the Workshop, Prosser GIFFORD directed +discussion to future courses of action and the potential role of LC in +advancing them. Among the recommendations that emerged were the following: + + * Workshop participants should 1) begin to think about working + with image material, but structure and digitize it in such a + way that at a later stage it can be interpreted into text, and + 2) find a common way to build text and images together so that + they can be used jointly at some stage in the future, with + appropriate network support, because that is how users will want + to access these materials. The Library might encourage attempts + to bring together people who are working on texts and images. + + * A network version of American Memory should be developed or + consideration should be given to making the data in it + available to people interested in doing network multimedia. + Given the current dearth of digital data that is appealing and + unencumbered by extremely complex rights problems, developing a + network version of American Memory could do much to help make + network multimedia a reality. + + * Concerning the thorny issue of electronic deposit, LC should + initiate a catalytic process in terms of distributed + responsibility, that is, bring together the distributed + organizations and set up a study group to look at all the + issues related to electronic deposit and see where we as a + nation should move. For example, LC might attempt to persuade + one major library in each state to deal with its state + equivalent publisher, which might produce a cooperative project + that would be equitably distributed around the country, and one + in which LC would be dealing with a minimal number of publishers + and minimal copyright problems. LC must also deal with the + concept of on-line publishing, determining, among other things, + how serials such as OJCCT might be deposited for copyright. + + * Since a number of projects are planning to carry out + preservation by creating digital images that will end up in + on-line or near-line storage at some institution, LC might play + a helpful role, at least in the near term, by accelerating how + to catalog that information into the Research Library Information + Network (RLIN) and then into OCLC, so that it would be accessible. + This would reduce the possibility of multiple institutions digitizing + the same work. + + +CONCLUSION + +The Workshop was valuable because it brought together partisans from +various groups and provided an occasion to compare goals and methods. +The more committed partisans frequently communicate with others in their +groups, but less often across group boundaries. The Workshop was also +valuable to attendees--including those involved with American Memory--who +came less committed to particular approaches or concepts. These +attendees learned a great deal, and plan to select and employ elements of +imaging, text-coding, and networked distribution that suit their +respective projects and purposes. + +Still, reality rears its ugly head: no breakthrough has been achieved. +On the imaging side, one confronts a proliferation of competing +data-interchange standards and a lack of consensus on the role of digital +facsimiles in preservation. In the realm of machine-readable texts, one +encounters a reasonably mature standard but methodological difficulties +and high costs. These latter problems, of course, represent a special +impediment to the desire, as it is sometimes expressed in the popular +press, "to put the [contents of the] Library of Congress on line." In +the words of one participant, there was "no solution to the economic +problems--the projects that are out there are surviving, but it is going +to be a lot of work to transform the information industry, and so far the +investment to do that is not forthcoming" (LESK, per litteras). + + + *** *** *** ****** *** *** *** + + + PROCEEDINGS + + +WELCOME + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +GIFFORD * Origin of Workshop in current Librarian's desire to make LC's +collections more widely available * Desiderata arising from the prospect +of greater interconnectedness * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +After welcoming participants on behalf of the Library of Congress, +American Memory (AM), and the National Demonstration Lab, Prosser +GIFFORD, director for scholarly programs, Library of Congress, located +the origin of the Workshop on Electronic Texts in a conversation he had +had considerably more than a year ago with Carl FLEISCHHAUER concerning +some of the issues faced by AM. On the assumption that numerous other +people were asking the same questions, the decision was made to bring +together as many of these people as possible to ask the same questions +together. In a deeper sense, GIFFORD said, the origin of the Workshop +lay in the desire of the current Librarian of Congress, James H. +Billington, to make the collections of the Library, especially those +offering unique or unusual testimony on aspects of the American +experience, available to a much wider circle of users than those few +people who can come to Washington to use them. This meant that the +emphasis of AM, from the outset, has been on archival collections of the +basic material, and on making these collections themselves available, +rather than selected or heavily edited products. + +From AM's emphasis followed the questions with which the Workshop began: +who will use these materials, and in what form will they wish to use +them. But an even larger issue deserving mention, in GIFFORD's view, was +the phenomenal growth in Internet connectivity. He expressed the hope +that the prospect of greater interconnectedness than ever before would +lead to: 1) much more cooperative and mutually supportive endeavors; 2) +development of systems of shared and distributed responsibilities to +avoid duplication and to ensure accuracy and preservation of unique +materials; and 3) agreement on the necessary standards and development of +the appropriate directories and indices to make navigation +straightforward among the varied resources that are, and increasingly +will be, available. In this connection, GIFFORD requested that +participants reflect from the outset upon the sorts of outcomes they +thought the Workshop might have. Did those present constitute a group +with sufficient common interests to propose a next step or next steps, +and if so, what might those be? They would return to these questions the +following afternoon. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +FLEISCHHAUER * Core of Workshop concerns preparation and production of +materials * Special challenge in conversion of textual materials * +Quality versus quantity * Do the several groups represented share common +interests? * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Carl FLEISCHHAUER, coordinator, American Memory, Library of Congress, +emphasized that he would attempt to represent the people who perform some +of the work of converting or preparing materials and that the core of +the Workshop had to do with preparation and production. FLEISCHHAUER +then drew a distinction between the long term, when many things would be +available and connected in the ways that GIFFORD described, and the short +term, in which AM not only has wrestled with the issue of what is the +best course to pursue but also has faced a variety of technical +challenges. + +FLEISCHHAUER remarked AM's endeavors to deal with a wide range of library +formats, such as motion picture collections, sound-recording collections, +and pictorial collections of various sorts, especially collections of +photographs. In the course of these efforts, AM kept coming back to +textual materials--manuscripts or rare printed matter, bound materials, +etc. Text posed the greatest conversion challenge of all. Thus, the +genesis of the Workshop, which reflects the problems faced by AM. These +problems include physical problems. For example, those in the library +and archive business deal with collections made up of fragile and rare +manuscript items, bound materials, especially the notoriously brittle +bound materials of the late nineteenth century. These are precious +cultural artifacts, however, as well as interesting sources of +information, and LC desires to retain and conserve them. AM needs to +handle things without damaging them. Guillotining a book to run it +through a sheet feeder must be avoided at all costs. + +Beyond physical problems, issues pertaining to quality arose. For +example, the desire to provide users with a searchable text is affected +by the question of acceptable level of accuracy. One hundred percent +accuracy is tremendously expensive. On the other hand, the output of +optical character recognition (OCR) can be tremendously inaccurate. +Although AM has attempted to find a middle ground, uncertainty persists +as to whether or not it has discovered the right solution. + +Questions of quality arose concerning images as well. FLEISCHHAUER +contrasted the extremely high level of quality of the digital images in +the Cornell Xerox Project with AM's efforts to provide a browse-quality +or access-quality image, as opposed to an archival or preservation image. +FLEISCHHAUER therefore welcomed the opportunity to compare notes. + +FLEISCHHAUER observed in passing that conversations he had had about +networks have begun to signal that for various forms of media a +determination may be made that there is a browse-quality item, or a +distribution-and-access-quality item that may coexist in some systems +with a higher quality archival item that would be inconvenient to send +through the network because of its size. FLEISCHHAUER referred, of +course, to images more than to searchable text. + +As AM considered those questions, several conceptual issues arose: ought +AM occasionally to reproduce materials entirely through an image set, at +other times, entirely through a text set, and in some cases, a mix? +There probably would be times when the historical authenticity of an +artifact would require that its image be used. An image might be +desirable as a recourse for users if one could not provide 100-percent +accurate text. Again, AM wondered, as a practical matter, if a +distinction could be drawn between rare printed matter that might exist +in multiple collections--that is, in ten or fifteen libraries. In such +cases, the need for perfect reproduction would be less than for unique +items. Implicit in his remarks, FLEISCHHAUER conceded, was the admission +that AM has been tilting strongly towards quantity and drawing back a +little from perfect quality. That is, it seemed to AM that society would +be better served if more things were distributed by LC--even if they were +not quite perfect--than if fewer things, perfectly represented, were +distributed. This was stated as a proposition to be tested, with +responses to be gathered from users. + +In thinking about issues related to reproduction of materials and seeing +other people engaged in parallel activities, AM deemed it useful to +convene a conference. Hence, the Workshop. FLEISCHHAUER thereupon +surveyed the several groups represented: 1) the world of images (image +users and image makers); 2) the world of text and scholarship and, within +this group, those concerned with language--FLEISCHHAUER confessed to finding +delightful irony in the fact that some of the most advanced thinkers on +computerized texts are those dealing with ancient Greek and Roman materials; +3) the network world; and 4) the general world of library science, which +includes people interested in preservation and cataloging. + +FLEISCHHAUER concluded his remarks with special thanks to the David and +Lucile Packard Foundation for its support of the meeting, the American +Memory group, the Office for Scholarly Programs, the National +Demonstration Lab, and the Office of Special Events. He expressed the +hope that David Woodley Packard might be able to attend, noting that +Packard's work and the work of the foundation had sponsored a number of +projects in the text area. + + ****** + +SESSION I. CONTENT IN A NEW FORM: WHO WILL USE IT AND WHAT WILL THEY DO? + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +DALY * Acknowledgements * A new Latin authors disk * Effects of the new +technology on previous methods of research * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Serving as moderator, James DALY acknowledged the generosity of all the +presenters for giving of their time, counsel, and patience in planning +the Workshop, as well as of members of the American Memory project and +other Library of Congress staff, and the David and Lucile Packard +Foundation and its executive director, Colburn S. Wilbur. + +DALY then recounted his visit in March to the Center for Electronic Texts +in the Humanities (CETH) and the Department of Classics at Rutgers +University, where an old friend, Lowell Edmunds, introduced him to the +department's IBYCUS scholarly personal computer, and, in particular, the +new Latin CD-ROM, containing, among other things, almost all classical +Latin literary texts through A.D. 200. Packard Humanities Institute +(PHI), Los Altos, California, released this disk late in 1991, with a +nominal triennial licensing fee. + +Playing with the disk for an hour or so at Rutgers brought home to DALY +at once the revolutionizing impact of the new technology on his previous +methods of research. Had this disk been available two or three years +earlier, DALY contended, when he was engaged in preparing a commentary on +Book 10 of Virgil's Aeneid for Cambridge University Press, he would not +have required a forty-eight-square-foot table on which to spread the +numerous, most frequently consulted items, including some ten or twelve +concordances to key Latin authors, an almost equal number of lexica to +authors who lacked concordances, and where either lexica or concordances +were lacking, numerous editions of authors antedating and postdating Virgil. + +Nor, when checking each of the average six to seven words contained in +the Virgilian hexameter for its usage elsewhere in Virgil's works or +other Latin authors, would DALY have had to maintain the laborious +mechanical process of flipping through these concordances, lexica, and +editions each time. Nor would he have had to frequent as often the +Milton S. Eisenhower Library at the Johns Hopkins University to consult +the Thesaurus Linguae Latinae. Instead of devoting countless hours, or +the bulk of his research time, to gathering data concerning Virgil's use +of words, DALY--now freed by PHI's Latin authors disk from the +tyrannical, yet in some ways paradoxically happy scholarly drudgery-- +would have been able to devote that same bulk of time to analyzing and +interpreting Virgilian verbal usage. + +Citing Theodore Brunner, Gregory Crane, Elli MYLONAS, and Avra MICHELSON, +DALY argued that this reversal in his style of work, made possible by the +new technology, would perhaps have resulted in better, more productive +research. Indeed, even in the course of his browsing the Latin authors +disk at Rutgers, its powerful search, retrieval, and highlighting +capabilities suggested to him several new avenues of research into +Virgil's use of sound effects. This anecdotal account, DALY maintained, +may serve to illustrate in part the sudden and radical transformation +being wrought in the ways scholars work. + + ****** + +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +MICHELSON * Elements related to scholarship and technology * Electronic +texts within the context of broader trends within information technology +and scholarly communication * Evaluation of the prospects for the use of +electronic texts * Relationship of electronic texts to processes of +scholarly communication in humanities research * New exchange formats +created by scholars * Projects initiated to increase scholarly access to +converted text * Trend toward making electronic resources available +through research and education networks * Changes taking place in +scholarly communication among humanities scholars * Network-mediated +scholarship transforming traditional scholarly practices * Key +information technology trends affecting the conduct of scholarly +communication over the next decade * The trend toward end-user computing +* The trend toward greater connectivity * Effects of these trends * Key +transformations taking place * Summary of principal arguments * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Avra MICHELSON, Archival Research and Evaluation Staff, National Archives +and Records Administration (NARA), argued that establishing who will use +electronic texts and what they will use them for involves a consideration +of both information technology and scholarship trends. This +consideration includes several elements related to scholarship and +technology: 1) the key trends in information technology that are most +relevant to scholarship; 2) the key trends in the use of currently +available technology by scholars in the nonscientific community; and 3) +the relationship between these two very distinct but interrelated trends. +The investment in understanding this relationship being made by +information providers, technologists, and public policy developers, as +well as by scholars themselves, seems to be pervasive and growing, +MICHELSON contended. She drew on collaborative work with Jeff Rothenberg +on the scholarly use of technology. + +MICHELSON sought to place the phenomenon of electronic texts within the +context of broader trends within information technology and scholarly +communication. She argued that electronic texts are of most use to +researchers to the extent that the researchers' working context (i.e., +their relevant bibliographic sources, collegial feedback, analytic tools, +notes, drafts, etc.), along with their field's primary and secondary +sources, also is accessible in electronic form and can be integrated in +ways that are unique to the on-line environment. + +Evaluation of the prospects for the use of electronic texts includes two +elements: 1) an examination of the ways in which researchers currently +are using electronic texts along with other electronic resources, and 2) +an analysis of key information technology trends that are affecting the +long-term conduct of scholarly communication. MICHELSON limited her +discussion of the use of electronic texts to the practices of humanists +and noted that the scientific community was outside the panel's overview. + +MICHELSON examined the nature of the current relationship of electronic +texts in particular, and electronic resources in general, to what she +maintained were, essentially, five processes of scholarly communication +in humanities research. Researchers 1) identify sources, 2) communicate +with their colleagues, 3) interpret and analyze data, 4) disseminate +their research findings, and 5) prepare curricula to instruct the next +generation of scholars and students. This examination would produce a +clearer understanding of the synergy among these five processes that +fuels the tendency of the use of electronic resources for one process to +stimulate its use for other processes of scholarly communication. + +For the first process of scholarly communication, the identification of +sources, MICHELSON remarked the opportunity scholars now enjoy to +supplement traditional word-of-mouth searches for sources among their +colleagues with new forms of electronic searching. So, for example, +instead of having to visit the library, researchers are able to explore +descriptions of holdings in their offices. Furthermore, if their own +institutions' holdings prove insufficient, scholars can access more than +200 major American library catalogues over Internet, including the +universities of California, Michigan, Pennsylvania, and Wisconsin. +Direct access to the bibliographic databases offers intellectual +empowerment to scholars by presenting a comprehensive means of browsing +through libraries from their homes and offices at their convenience. + +The second process of communication involves communication among +scholars. Beyond the most common methods of communication, scholars are +using E-mail and a variety of new electronic communications formats +derived from it for further academic interchange. E-mail exchanges are +growing at an astonishing rate, reportedly 15 percent a month. They +currently constitute approximately half the traffic on research and +education networks. Moreover, the global spread of E-mail has been so +rapid that it is now possible for American scholars to use it to +communicate with colleagues in close to 140 other countries. + +Other new exchange formats created by scholars and operating on Internet +include more than 700 conferences, with about 80 percent of these devoted +to topics in the social sciences and humanities. The rate of growth of +these scholarly electronic conferences also is astonishing. From l990 to +l991, 200 new conferences were identified on Internet. From October 1991 +to June 1992, an additional 150 conferences in the social sciences and +humanities were added to this directory of listings. Scholars have +established conferences in virtually every field, within every different +discipline. For example, there are currently close to 600 active social +science and humanities conferences on topics such as art and +architecture, ethnomusicology, folklore, Japanese culture, medical +education, and gifted and talented education. The appeal to scholars of +communicating through these conferences is that, unlike any other medium, +electronic conferences today provide a forum for global communication +with peers at the front end of the research process. + +Interpretation and analysis of sources constitutes the third process of +scholarly communication that MICHELSON discussed in terms of texts and +textual resources. The methods used to analyze sources fall somewhere on +a continuum from quantitative analysis to qualitative analysis. +Typically, evidence is culled and evaluated using methods drawn from both +ends of this continuum. At one end, quantitative analysis involves the +use of mathematical processes such as a count of frequencies and +distributions of occurrences or, on a higher level, regression analysis. +At the other end of the continuum, qualitative analysis typically +involves nonmathematical processes oriented toward language +interpretation or the building of theory. Aspects of this work involve +the processing--either manual or computational--of large and sometimes +massive amounts of textual sources, although the use of nontextual +sources as evidence, such as photographs, sound recordings, film footage, +and artifacts, is significant as well. + +Scholars have discovered that many of the methods of interpretation and +analysis that are related to both quantitative and qualitative methods +are processes that can be performed by computers. For example, computers +can count. They can count brush strokes used in a Rembrandt painting or +perform regression analysis for understanding cause and effect. By means +of advanced technologies, computers can recognize patterns, analyze text, +and model concepts. Furthermore, computers can complete these processes +faster with more sources and with greater precision than scholars who +must rely on manual interpretation of data. But if scholars are to use +computers for these processes, source materials must be in a form +amenable to computer-assisted analysis. For this reason many scholars, +once they have identified the sources that are key to their research, are +converting them to machine-readable form. Thus, a representative example +of the numerous textual conversion projects organized by scholars around +the world in recent years to support computational text analysis is the +TLG, the Thesaurus Linguae Graecae. This project is devoted to +converting the extant ancient texts of classical Greece. (Editor's note: +according to the TLG Newsletter of May l992, TLG was in use in thirty-two +different countries. This figure updates MICHELSON's previous count by one.) + +The scholars performing these conversions have been asked to recognize +that the electronic sources they are converting for one use possess value +for other research purposes as well. As a result, during the past few +years, humanities scholars have initiated a number of projects to +increase scholarly access to converted text. So, for example, the Text +Encoding Initiative (TEI), about which more is said later in the program, +was established as an effort by scholars to determine standard elements +and methods for encoding machine-readable text for electronic exchange. +In a second effort to facilitate the sharing of converted text, scholars +have created a new institution, the Center for Electronic Texts in the +Humanities (CETH). The center estimates that there are 8,000 series of +source texts in the humanities that have been converted to +machine-readable form worldwide. CETH is undertaking an international +search for converted text in the humanities, compiling it into an +electronic library, and preparing bibliographic descriptions of the +sources for the Research Libraries Information Network's (RLIN) +machine-readable data file. The library profession has begun to initiate +large conversion projects as well, such as American Memory. + +While scholars have been making converted text available to one another, +typically on disk or on CD-ROM, the clear trend is toward making these +resources available through research and education networks. Thus, the +American and French Research on the Treasury of the French Language +(ARTFL) and the Dante Project are already available on Internet. +MICHELSON summarized this section on interpretation and analysis by +noting that: 1) increasing numbers of humanities scholars in the library +community are recognizing the importance to the advancement of +scholarship of retrospective conversion of source materials in the arts +and humanities; and 2) there is a growing realization that making the +sources available on research and education networks maximizes their +usefulness for the analysis performed by humanities scholars. + +The fourth process of scholarly communication is dissemination of +research findings, that is, publication. Scholars are using existing +research and education networks to engineer a new type of publication: +scholarly-controlled journals that are electronically produced and +disseminated. Although such journals are still emerging as a +communication format, their number has grown, from approximately twelve +to thirty-six during the past year (July 1991 to June 1992). Most of +these electronic scholarly journals are devoted to topics in the +humanities. As with network conferences, scholarly enthusiasm for these +electronic journals stems from the medium's unique ability to advance +scholarship in a way that no other medium can do by supporting global +feedback and interchange, practically in real time, early in the research +process. Beyond scholarly journals, MICHELSON remarked the delivery of +commercial full-text products, such as articles in professional journals, +newsletters, magazines, wire services, and reference sources. These are +being delivered via on-line local library catalogues, especially through +CD-ROMs. Furthermore, according to MICHELSON, there is general optimism +that the copyright and fees issues impeding the delivery of full text on +existing research and education networks soon will be resolved. + +The final process of scholarly communication is curriculum development +and instruction, and this involves the use of computer information +technologies in two areas. The first is the development of +computer-oriented instructional tools, which includes simulations, +multimedia applications, and computer tools that are used to assist in +the analysis of sources in the classroom, etc. The Perseus Project, a +database that provides a multimedia curriculum on classical Greek +civilization, is a good example of the way in which entire curricula are +being recast using information technologies. It is anticipated that the +current difficulty in exchanging electronically computer-based +instructional software, which in turn makes it difficult for one scholar +to build upon the work of others, will be resolved before too long. +Stand-alone curricular applications that involve electronic text will be +sharable through networks, reinforcing their significance as intellectual +products as well as instructional tools. + +The second aspect of electronic learning involves the use of research and +education networks for distance education programs. Such programs +interactively link teachers with students in geographically scattered +locations and rely on the availability of electronic instructional +resources. Distance education programs are gaining wide appeal among +state departments of education because of their demonstrated capacity to +bring advanced specialized course work and an array of experts to many +classrooms. A recent report found that at least 32 states operated at +least one statewide network for education in 1991, with networks under +development in many of the remaining states. + +MICHELSON summarized this section by noting two striking changes taking +place in scholarly communication among humanities scholars. First is the +extent to which electronic text in particular, and electronic resources +in general, are being infused into each of the five processes described +above. As mentioned earlier, there is a certain synergy at work here. +The use of electronic resources for one process tends to stimulate its +use for other processes, because the chief course of movement is toward a +comprehensive on-line working context for humanities scholars that +includes on-line availability of key bibliographies, scholarly feedback, +sources, analytical tools, and publications. MICHELSON noted further +that the movement toward a comprehensive on-line working context for +humanities scholars is not new. In fact, it has been underway for more +than forty years in the humanities, since Father Roberto Busa began +developing an electronic concordance of the works of Saint Thomas Aquinas +in 1949. What we are witnessing today, MICHELSON contended, is not the +beginning of this on-line transition but, for at least some humanities +scholars, the turning point in the transition from a print to an +electronic working context. Coinciding with the on-line transition, the +second striking change is the extent to which research and education +networks are becoming the new medium of scholarly communication. The +existing Internet and the pending National Education and Research Network +(NREN) represent the new meeting ground where scholars are going for +bibliographic information, scholarly dialogue and feedback, the most +current publications in their field, and high-level educational +offerings. Traditional scholarly practices are undergoing tremendous +transformations as a result of the emergence and growing prominence of +what is called network-mediated scholarship. + +MICHELSON next turned to the second element of the framework she proposed +at the outset of her talk for evaluating the prospects for electronic +text, namely the key information technology trends affecting the conduct +of scholarly communication over the next decade: 1) end-user computing +and 2) connectivity. + +End-user computing means that the person touching the keyboard, or +performing computations, is the same as the person who initiates or +consumes the computation. The emergence of personal computers, along +with a host of other forces, such as ubiquitous computing, advances in +interface design, and the on-line transition, is prompting the consumers +of computation to do their own computing, and is thus rendering obsolete +the traditional distinction between end users and ultimate users. + +The trend toward end-user computing is significant to consideration of +the prospects for electronic texts because it means that researchers are +becoming more adept at doing their own computations and, thus, more +competent in the use of electronic media. By avoiding programmer +intermediaries, computation is becoming central to the researcher's +thought process. This direct involvement in computing is changing the +researcher's perspective on the nature of research itself, that is, the +kinds of questions that can be posed, the analytical methodologies that +can be used, the types and amount of sources that are appropriate for +analyses, and the form in which findings are presented. The trend toward +end-user computing means that, increasingly, electronic media and +computation are being infused into all processes of humanities +scholarship, inspiring remarkable transformations in scholarly +communication. + +The trend toward greater connectivity suggests that researchers are using +computation increasingly in network environments. Connectivity is +important to scholarship because it erases the distance that separates +students from teachers and scholars from their colleagues, while allowing +users to access remote databases, share information in many different +media, connect to their working context wherever they are, and +collaborate in all phases of research. + +The combination of the trend toward end-user computing and the trend +toward connectivity suggests that the scholarly use of electronic +resources, already evident among some researchers, will soon become an +established feature of scholarship. The effects of these trends, along +with ongoing changes in scholarly practices, point to a future in which +humanities researchers will use computation and electronic communication +to help them formulate ideas, access sources, perform research, +collaborate with colleagues, seek peer review, publish and disseminate +results, and engage in many other professional and educational activities. + +In summary, MICHELSON emphasized four points: 1) A portion of humanities +scholars already consider electronic texts the preferred format for +analysis and dissemination. 2) Scholars are using these electronic +texts, in conjunction with other electronic resources, in all the +processes of scholarly communication. 3) The humanities scholars' +working context is in the process of changing from print technology to +electronic technology, in many ways mirroring transformations that have +occurred or are occurring within the scientific community. 4) These +changes are occurring in conjunction with the development of a new +communication medium: research and education networks that are +characterized by their capacity to advance scholarship in a wholly unique +way. + +MICHELSON also reiterated her three principal arguments: l) Electronic +texts are best understood in terms of the relationship to other +electronic resources and the growing prominence of network-mediated +scholarship. 2) The prospects for electronic texts lie in their capacity +to be integrated into the on-line network of electronic resources that +comprise the new working context for scholars. 3) Retrospective conversion +of portions of the scholarly record should be a key strategy as information +providers respond to changes in scholarly communication practices. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +VECCIA * AM's evaluation project and public users of electronic resources +* AM and its design * Site selection and evaluating the Macintosh +implementation of AM * Characteristics of the six public libraries +selected * Characteristics of AM's users in these libraries * Principal +ways AM is being used * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Susan VECCIA, team leader, and Joanne FREEMAN, associate coordinator, +American Memory, Library of Congress, gave a joint presentation. First, +by way of introduction, VECCIA explained her and FREEMAN's roles in +American Memory (AM). Serving principally as an observer, VECCIA has +assisted with the evaluation project of AM, placing AM collections in a +variety of different sites around the country and helping to organize and +implement that project. FREEMAN has been an associate coordinator of AM +and has been involved principally with the interpretative materials, +preparing some of the electronic exhibits and printed historical +information that accompanies AM and that is requested by users. VECCIA +and FREEMAN shared anecdotal observations concerning AM with public users +of electronic resources. Notwithstanding a fairly structured evaluation +in progress, both VECCIA and FREEMAN chose not to report on specifics in +terms of numbers, etc., because they felt it was too early in the +evaluation project to do so. + +AM is an electronic archive of primary source materials from the Library +of Congress, selected collections representing a variety of formats-- +photographs, graphic arts, recorded sound, motion pictures, broadsides, +and soon, pamphlets and books. In terms of the design of this system, +the interpretative exhibits have been kept separate from the primary +resources, with good reason. Accompanying this collection are printed +documentation and user guides, as well as guides that FREEMAN prepared for +teachers so that they may begin using the content of the system at once. + +VECCIA described the evaluation project before talking about the public +users of AM, limiting her remarks to public libraries, because FREEMAN +would talk more specifically about schools from kindergarten to twelfth +grade (K-12). Having started in spring 1991, the evaluation currently +involves testing of the Macintosh implementation of AM. Since the +primary goal of this evaluation is to determine the most appropriate +audience or audiences for AM, very different sites were selected. This +makes evaluation difficult because of the varying degrees of technology +literacy among the sites. AM is situated in forty-four locations, of +which six are public libraries and sixteen are schools. Represented +among the schools are elementary, junior high, and high schools. +District offices also are involved in the evaluation, which will +conclude in summer 1993. + +VECCIA focused the remainder of her talk on the six public libraries, one +of which doubles as a state library. They represent a range of +geographic areas and a range of demographic characteristics. For +example, three are located in urban settings, two in rural settings, and +one in a suburban setting. A range of technical expertise is to be found +among these facilities as well. For example, one is an "Apple library of +the future," while two others are rural one-room libraries--in one, AM +sits at the front desk next to a tractor manual. + +All public libraries have been extremely enthusiastic, supportive, and +appreciative of the work that AM has been doing. VECCIA characterized +various users: Most users in public libraries describe themselves as +general readers; of the students who use AM in the public libraries, +those in fourth grade and above seem most interested. Public libraries +in rural sites tend to attract retired people, who have been highly +receptive to AM. Users tend to fall into two additional categories: +people interested in the content and historical connotations of these +primary resources, and those fascinated by the technology. The format +receiving the most comments has been motion pictures. The adult users in +public libraries are more comfortable with IBM computers, whereas young +people seem comfortable with either IBM or Macintosh, although most of +them seem to come from a Macintosh background. This same tendency is +found in the schools. + +What kinds of things do users do with AM? In a public library there are +two main goals or ways that AM is being used: as an individual learning +tool, and as a leisure activity. Adult learning was one area that VECCIA +would highlight as a possible application for a tool such as AM. She +described a patron of a rural public library who comes in every day on +his lunch hour and literally reads AM, methodically going through the +collection image by image. At the end of his hour he makes an electronic +bookmark, puts it in his pocket, and returns to work. The next day he +comes in and resumes where he left off. Interestingly, this man had +never been in the library before he used AM. In another small, rural +library, the coordinator reports that AM is a popular activity for some +of the older, retired people in the community, who ordinarily would not +use "those things,"--computers. Another example of adult learning in +public libraries is book groups, one of which, in particular, is using AM +as part of its reading on industrialization, integration, and urbanization +in the early 1900s. + +One library reports that a family is using AM to help educate their +children. In another instance, individuals from a local museum came in +to use AM to prepare an exhibit on toys of the past. These two examples +emphasize the mission of the public library as a cultural institution, +reaching out to people who do not have the same resources available to +those who live in a metropolitan area or have access to a major library. +One rural library reports that junior high school students in large +numbers came in one afternoon to use AM for entertainment. A number of +public libraries reported great interest among postcard collectors in the +Detroit collection, which was essentially a collection of images used on +postcards around the turn of the century. Train buffs are similarly +interested because that was a time of great interest in railroading. +People, it was found, relate to things that they know of firsthand. For +example, in both rural public libraries where AM was made available, +observers reported that the older people with personal remembrances of +the turn of the century were gravitating to the Detroit collection. +These examples served to underscore MICHELSON's observation re the +integration of electronic tools and ideas--that people learn best when +the material relates to something they know. + +VECCIA made the final point that in many cases AM serves as a +public-relations tool for the public libraries that are testing it. In +one case, AM is being used as a vehicle to secure additional funding for +the library. In another case, AM has served as an inspiration to the +staff of a major local public library in the South to think about ways to +make its own collection of photographs more accessible to the public. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +FREEMAN * AM and archival electronic resources in a school environment * +Questions concerning context * Questions concerning the electronic format +itself * Computer anxiety * Access and availability of the system * +Hardware * Strengths gained through the use of archival resources in +schools * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Reiterating an observation made by VECCIA, that AM is an archival +resource made up of primary materials with very little interpretation, +FREEMAN stated that the project has attempted to bridge the gap between +these bare primary materials and a school environment, and in that cause +has created guided introductions to AM collections. Loud demand from the +educational community, chiefly from teachers working with the upper +grades of elementary school through high school, greeted the announcement +that AM would be tested around the country. + +FREEMAN reported not only on what was learned about AM in a school +environment, but also on several universal questions that were raised +concerning archival electronic resources in schools. She discussed +several strengths of this type of material in a school environment as +opposed to a highly structured resource that offers a limited number of +paths to follow. + +FREEMAN first raised several questions about using AM in a school +environment. There is often some difficulty in developing a sense of +what the system contains. Many students sit down at a computer resource +and assume that, because AM comes from the Library of Congress, all of +American history is now at their fingertips. As a result of that sort of +mistaken judgment, some students are known to conclude that AM contains +nothing of use to them when they look for one or two things and do not +find them. It is difficult to discover that middle ground where one has +a sense of what the system contains. Some students grope toward the idea +of an archive, a new idea to them, since they have not previously +experienced what it means to have access to a vast body of somewhat +random information. + +Other questions raised by FREEMAN concerned the electronic format itself. +For instance, in a school environment it is often difficult both for +teachers and students to gain a sense of what it is they are viewing. +They understand that it is a visual image, but they do not necessarily +know that it is a postcard from the turn of the century, a panoramic +photograph, or even machine-readable text of an eighteenth-century +broadside, a twentieth-century printed book, or a nineteenth-century +diary. That distinction is often difficult for people in a school +environment to grasp. Because of that, it occasionally becomes difficult +to draw conclusions from what one is viewing. + +FREEMAN also noted the obvious fear of the computer, which constitutes a +difficulty in using an electronic resource. Though students in general +did not suffer from this anxiety, several older students feared that they +were computer-illiterate, an assumption that became self-fulfilling when +they searched for something but failed to find it. FREEMAN said she +believed that some teachers also fear computer resources, because they +believe they lack complete control. FREEMAN related the example of +teachers shooing away students because it was not their time to use the +system. This was a case in which the situation had to be extremely +structured so that the teachers would not feel that they had lost their +grasp on what the system contained. + +A final question raised by FREEMAN concerned access and availability of +the system. She noted the occasional existence of a gap in communication +between school librarians and teachers. Often AM sits in a school +library and the librarian is the person responsible for monitoring the +system. Teachers do not always take into their world new library +resources about which the librarian is excited. Indeed, at the sites +where AM had been used most effectively within a library, the librarian +was required to go to specific teachers and instruct them in its use. As +a result, several AM sites will have in-service sessions over a summer, +in the hope that perhaps, with a more individualized link, teachers will +be more likely to use the resource. + +A related issue in the school context concerned the number of +workstations available at any one location. Centralization of equipment +at the district level, with teachers invited to download things and walk +away with them, proved unsuccessful because the hours these offices were +open were also school hours. + +Another issue was hardware. As VECCIA observed, a range of sites exists, +some technologically advanced and others essentially acquiring their +first computer for the primary purpose of using it in conjunction with +AM's testing. Users at technologically sophisticated sites want even +more sophisticated hardware, so that they can perform even more +sophisticated tasks with the materials in AM. But once they acquire a +newer piece of hardware, they must learn how to use that also; at an +unsophisticated site it takes an extremely long time simply to become +accustomed to the computer, not to mention the program offered with the +computer. All of these small issues raise one large question, namely, +are systems like AM truly rewarding in a school environment, or do they +simply act as innovative toys that do little more than spark interest? + +FREEMAN contended that the evaluation project has revealed several strengths +that were gained through the use of archival resources in schools, including: + + * Psychic rewards from using AM as a vast, rich database, with + teachers assigning various projects to students--oral presentations, + written reports, a documentary, a turn-of-the-century newspaper-- + projects that start with the materials in AM but are completed using + other resources; AM thus is used as a research tool in conjunction + with other electronic resources, as well as with books and items in + the library where the system is set up. + + * Students are acquiring computer literacy in a humanities context. + + * This sort of system is overcoming the isolation between disciplines + that often exists in schools. For example, many English teachers are + requiring their students to write papers on historical topics + represented in AM. Numerous teachers have reported that their + students are learning critical thinking skills using the system. + + * On a broader level, AM is introducing primary materials, not only + to students but also to teachers, in an environment where often + simply none exist--an exciting thing for the students because it + helps them learn to conduct research, to interpret, and to draw + their own conclusions. In learning to conduct research and what it + means, students are motivated to seek knowledge. That relates to + another positive outcome--a high level of personal involvement of + students with the materials in this system and greater motivation to + conduct their own research and draw their own conclusions. + + * Perhaps the most ironic strength of these kinds of archival + electronic resources is that many of the teachers AM interviewed + were desperate, it is no exaggeration to say, not only for primary + materials but for unstructured primary materials. These would, they + thought, foster personally motivated research, exploration, and + excitement in their students. Indeed, these materials have done + just that. Ironically, however, this lack of structure produces + some of the confusion to which the newness of these kinds of + resources may also contribute. The key to effective use of archival + products in a school environment is a clear, effective introduction + to the system and to what it contains. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +DISCUSSION * Nothing known, quantitatively, about the number of +humanities scholars who must see the original versus those who would +settle for an edited transcript, or about the ways in which humanities +scholars are using information technology * Firm conclusions concerning +the manner and extent of the use of supporting materials in print +provided by AM to await completion of evaluative study * A listener's +reflections on additional applications of electronic texts * Role of +electronic resources in teaching elementary research skills to students * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +During the discussion that followed the presentations by MICHELSON, +VECCIA, and FREEMAN, additional points emerged. + +LESK asked if MICHELSON could give any quantitative estimate of the +number of humanities scholars who must see or want to see the original, +or the best possible version of the material, versus those who typically +would settle for an edited transcript. While unable to provide a figure, +she offered her impressions as an archivist who has done some reference +work and has discussed this issue with other archivists who perform +reference, that those who use archives and those who use primary sources +for what would be considered very high-level scholarly research, as +opposed to, say, undergraduate papers, were few in number, especially +given the public interest in using primary sources to conduct +genealogical or avocational research and the kind of professional +research done by people in private industry or the federal government. +More important in MICHELSON's view was that, quantitatively, nothing is +known about the ways in which, for example, humanities scholars are using +information technology. No studies exist to offer guidance in creating +strategies. The most recent study was conducted in 1985 by the American +Council of Learned Societies (ACLS), and what it showed was that 50 +percent of humanities scholars at that time were using computers. That +constitutes the extent of our knowledge. + +Concerning AM's strategy for orienting people toward the scope of +electronic resources, FREEMAN could offer no hard conclusions at this +point, because she and her colleagues were still waiting to see, +particularly in the schools, what has been made of their efforts. Within +the system, however, AM has provided what are called electronic exhibits- +-such as introductions to time periods and materials--and these are +intended to offer a student user a sense of what a broadside is and what +it might tell her or him. But FREEMAN conceded that the project staff +would have to talk with students next year, after teachers have had a +summer to use the materials, and attempt to discover what the students +were learning from the materials. In addition, FREEMAN described +supporting materials in print provided by AM at the request of local +teachers during a meeting held at LC. These included time lines, +bibliographies, and other materials that could be reproduced on a +photocopier in a classroom. Teachers could walk away with and use these, +and in this way gain a better understanding of the contents. But again, +reaching firm conclusions concerning the manner and extent of their use +would have to wait until next year. + +As to the changes she saw occurring at the National Archives and Records +Administration (NARA) as a result of the increasing emphasis on +technology in scholarly research, MICHELSON stated that NARA at this +point was absorbing the report by her and Jeff Rothenberg addressing +strategies for the archival profession in general, although not for the +National Archives specifically. NARA is just beginning to establish its +role and what it can do. In terms of changes and initiatives that NARA +can take, no clear response could be given at this time. + +GREENFIELD remarked two trends mentioned in the session. Reflecting on +DALY's opening comments on how he could have used a Latin collection of +text in an electronic form, he said that at first he thought most scholars +would be unwilling to do that. But as he thought of that in terms of the +original meaning of research--that is, having already mastered these texts, +researching them for critical and comparative purposes--for the first time, +the electronic format made a lot of sense. GREENFIELD could envision +growing numbers of scholars learning the new technologies for that very +aspect of their scholarship and for convenience's sake. + +Listening to VECCIA and FREEMAN, GREENFIELD thought of an additional +application of electronic texts. He realized that AM could be used as a +guide to lead someone to original sources. Students cannot be expected +to have mastered these sources, things they have never known about +before. Thus, AM is leading them, in theory, to a vast body of +information and giving them a superficial overview of it, enabling them +to select parts of it. GREENFIELD asked if any evidence exists that this +resource will indeed teach the new user, the K-12 students, how to do +research. Scholars already know how to do research and are applying +these new tools. But he wondered why students would go beyond picking +out things that were most exciting to them. + +FREEMAN conceded the correctness of GREENFIELD's observation as applied +to a school environment. The risk is that a student would sit down at a +system, play with it, find some things of interest, and then walk away. +But in the relatively controlled situation of a school library, much will +depend on the instructions a teacher or a librarian gives a student. She +viewed the situation not as one of fine-tuning research skills but of +involving students at a personal level in understanding and researching +things. Given the guidance one can receive at school, it then becomes +possible to teach elementary research skills to students, which in fact +one particular librarian said she was teaching her fifth graders. +FREEMAN concluded that introducing the idea of following one's own path +of inquiry, which is essentially what research entails, involves more +than teaching specific skills. To these comments VECCIA added the +observation that the individual teacher and the use of a creative +resource, rather than AM itself, seemed to make the key difference. +Some schools and some teachers are making excellent use of the nature +of critical thinking and teaching skills, she said. + +Concurring with these remarks, DALY closed the session with the thought that +the more that producers produced for teachers and for scholars to use with +their students, the more successful their electronic products would prove. + + ****** + +SESSION II. SHOW AND TELL + +Jacqueline HESS, director, National Demonstration Laboratory, served as +moderator of the "show-and-tell" session. She noted that a +question-and-answer period would follow each presentation. + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +MYLONAS * Overview and content of Perseus * Perseus' primary materials +exist in a system-independent, archival form * A concession * Textual +aspects of Perseus * Tools to use with the Greek text * Prepared indices +and full-text searches in Perseus * English-Greek word search leads to +close study of words and concepts * Navigating Perseus by tracing down +indices * Using the iconography to perform research * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Elli MYLONAS, managing editor, Perseus Project, Harvard University, first +gave an overview of Perseus, a large, collaborative effort based at +Harvard University but with contributors and collaborators located at +numerous universities and colleges in the United States (e.g., Bowdoin, +Maryland, Pomona, Chicago, Virginia). Funded primarily by the +Annenberg/CPB Project, with additional funding from Apple, Harvard, and +the Packard Humanities Institute, among others, Perseus is a multimedia, +hypertextual database for teaching and research on classical Greek +civilization, which was released in February 1992 in version 1.0 and +distributed by Yale University Press. + +Consisting entirely of primary materials, Perseus includes ancient Greek +texts and translations of those texts; catalog entries--that is, museum +catalog entries, not library catalog entries--on vases, sites, coins, +sculpture, and archaeological objects; maps; and a dictionary, among +other sources. The number of objects and the objects for which catalog +entries exist are accompanied by thousands of color images, which +constitute a major feature of the database. Perseus contains +approximately 30 megabytes of text, an amount that will double in +subsequent versions. In addition to these primary materials, the Perseus +Project has been building tools for using them, making access and +navigation easier, the goal being to build part of the electronic +environment discussed earlier in the morning in which students or +scholars can work with their sources. + +The demonstration of Perseus will show only a fraction of the real work +that has gone into it, because the project had to face the dilemma of +what to enter when putting something into machine-readable form: should +one aim for very high quality or make concessions in order to get the +material in? Since Perseus decided to opt for very high quality, all of +its primary materials exist in a system-independent--insofar as it is +possible to be system-independent--archival form. Deciding what that +archival form would be and attaining it required much work and thought. +For example, all the texts are marked up in SGML, which will be made +compatible with the guidelines of the Text Encoding Initiative (TEI) when +they are issued. + +Drawings are postscript files, not meeting international standards, but +at least designed to go across platforms. Images, or rather the real +archival forms, consist of the best available slides, which are being +digitized. Much of the catalog material exists in database form--a form +that the average user could use, manipulate, and display on a personal +computer, but only at great cost. Thus, this is where the concession +comes in: All of this rich, well-marked-up information is stripped of +much of its content; the images are converted into bit-maps and the text +into small formatted chunks. All this information can then be imported +into HyperCard and run on a mid-range Macintosh, which is what Perseus +users have. This fact has made it possible for Perseus to attain wide +use fairly rapidly. Without those archival forms the HyperCard version +being demonstrated could not be made easily, and the project could not +have the potential to move to other forms and machines and software as +they appear, none of which information is in Perseus on the CD. + +Of the numerous multimedia aspects of Perseus, MYLONAS focused on the +textual. Part of what makes Perseus such a pleasure to use, MYLONAS +said, is this effort at seamless integration and the ability to move +around both visual and textual material. Perseus also made the decision +not to attempt to interpret its material any more than one interprets by +selecting. But, MYLONAS emphasized, Perseus is not courseware: No +syllabus exists. There is no effort to define how one teaches a topic +using Perseus, although the project may eventually collect papers by +people who have used it to teach. Rather, Perseus aims to provide +primary material in a kind of electronic library, an electronic sandbox, +so to say, in which students and scholars who are working on this +material can explore by themselves. With that, MYLONAS demonstrated +Perseus, beginning with the Perseus gateway, the first thing one sees +upon opening Perseus--an effort in part to solve the contextualizing +problem--which tells the user what the system contains. + +MYLONAS demonstrated only a very small portion, beginning with primary +texts and running off the CD-ROM. Having selected Aeschylus' Prometheus +Bound, which was viewable in Greek and English pretty much in the same +segments together, MYLONAS demonstrated tools to use with the Greek text, +something not possible with a book: looking up the dictionary entry form +of an unfamiliar word in Greek after subjecting it to Perseus' +morphological analysis for all the texts. After finding out about a +word, a user may then decide to see if it is used anywhere else in Greek. +Because vast amounts of indexing support all of the primary material, one +can find out where else all forms of a particular Greek word appear-- +often not a trivial matter because Greek is highly inflected. Further, +since the story of Prometheus has to do with the origins of sacrifice, a +user may wish to study and explore sacrifice in Greek literature; by +typing sacrifice into a small window, a user goes to the English-Greek +word list--something one cannot do without the computer (Perseus has +indexed the definitions of its dictionary)--the string sacrifice appears +in the definitions of these sixty-five words. One may then find out +where any of those words is used in the work(s) of a particular author. +The English definitions are not lemmatized. + +All of the indices driving this kind of usage were originally devised for +speed, MYLONAS observed; in other words, all that kind of information-- +all forms of all words, where they exist, the dictionary form they belong +to--were collected into databases, which will expedite searching. Then +it was discovered that one can do things searching in these databases +that could not be done searching in the full texts. Thus, although there +are full-text searches in Perseus, much of the work is done behind the +scenes, using prepared indices. Re the indexing that is done behind the +scenes, MYLONAS pointed out that without the SGML forms of the text, it +could not be done effectively. Much of this indexing is based on the +structures that are made explicit by the SGML tagging. + +It was found that one of the things many of Perseus' non-Greek-reading +users do is start from the dictionary and then move into the close study +of words and concepts via this kind of English-Greek word search, by which +means they might select a concept. This exercise has been assigned to +students in core courses at Harvard--to study a concept by looking for the +English word in the dictionary, finding the Greek words, and then finding +the words in the Greek but, of course, reading across in the English. +That tells them a great deal about what a translation means as well. + +Should one also wish to see images that have to do with sacrifice, that +person would go to the object key word search, which allows one to +perform a similar kind of index retrieval on the database of +archaeological objects. Without words, pictures are useless; Perseus has +not reached the point where it can do much with images that are not +cataloged. Thus, although it is possible in Perseus with text and images +to navigate by knowing where one wants to end up--for example, a +red-figure vase from the Boston Museum of Fine Arts--one can perform this +kind of navigation very easily by tracing down indices. MYLONAS +illustrated several generic scenes of sacrifice on vases. The features +demonstrated derived from Perseus 1.0; version 2.0 will implement even +better means of retrieval. + +MYLONAS closed by looking at one of the pictures and noting again that +one can do a great deal of research using the iconography as well as the +texts. For instance, students in a core course at Harvard this year were +highly interested in Greek concepts of foreigners and representations of +non-Greeks. So they performed a great deal of research, both with texts +(e.g., Herodotus) and with iconography on vases and coins, on how the +Greeks portrayed non-Greeks. At the same time, art historians who study +iconography were also interested, and were able to use this material. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +DISCUSSION * Indexing and searchability of all English words in Perseus * +Several features of Perseus 1.0 * Several levels of customization +possible * Perseus used for general education * Perseus' effects on +education * Contextual information in Perseus * Main challenge and +emphasis of Perseus * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Several points emerged in the discussion that followed MYLONAS's presentation. + +Although MYLONAS had not demonstrated Perseus' ability to cross-search +documents, she confirmed that all English words in Perseus are indexed +and can be searched. So, for example, sacrifice could have been searched +in all texts, the historical essay, and all the catalogue entries with +their descriptions--in short, in all of Perseus. + +Boolean logic is not in Perseus 1.0 but will be added to the next +version, although an effort is being made not to restrict Perseus to a +database in which one just performs searching, Boolean or otherwise. It +is possible to move laterally through the documents by selecting a word +one is interested in and selecting an area of information one is +interested in and trying to look that word up in that area. + +Since Perseus was developed in HyperCard, several levels of customization +are possible. Simple authoring tools exist that allow one to create +annotated paths through the information, which are useful for note-taking +and for guided tours for teaching purposes and for expository writing. +With a little more ingenuity it is possible to begin to add or substitute +material in Perseus. + +Perseus has not been used so much for classics education as for general +education, where it seemed to have an impact on the students in the core +course at Harvard (a general required course that students must take in +certain areas). Students were able to use primary material much more. + +The Perseus Project has an evaluation team at the University of Maryland +that has been documenting Perseus' effects on education. Perseus is very +popular, and anecdotal evidence indicates that it is having an effect at +places other than Harvard, for example, test sites at Ball State +University, Drury College, and numerous small places where opportunities +to use vast amounts of primary data may not exist. One documented effect +is that archaeological, anthropological, and philological research is +being done by the same person instead of by three different people. + +The contextual information in Perseus includes an overview essay, a +fairly linear historical essay on the fifth century B.C. that provides +links into the primary material (e.g., Herodotus, Thucydides, and +Plutarch), via small gray underscoring (on the screen) of linked +passages. These are handmade links into other material. + +To different extents, most of the production work was done at Harvard, +where the people and the equipment are located. Much of the +collaborative activity involved data collection and structuring, because +the main challenge and the emphasis of Perseus is the gathering of +primary material, that is, building a useful environment for studying +classical Greece, collecting data, and making it useful. +Systems-building is definitely not the main concern. Thus, much of the +work has involved writing essays, collecting information, rewriting it, +and tagging it. That can be done off site. The creative link for the +overview essay as well as for both systems and data was collaborative, +and was forged via E-mail and paper mail with professors at Pomona and +Bowdoin. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +CALALUCA * PLD's principal focus and contribution to scholarship * +Various questions preparatory to beginning the project * Basis for +project * Basic rule in converting PLD * Concerning the images in PLD * +Running PLD under a variety of retrieval softwares * Encoding the +database a hard-fought issue * Various features demonstrated * Importance +of user documentation * Limitations of the CD-ROM version * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Eric CALALUCA, vice president, Chadwyck-Healey, Inc., demonstrated a +software interpretation of the Patrologia Latina Database (PLD). PLD's +principal focus from the beginning of the project about three-and-a-half +years ago was on converting Migne's Latin series, and in the end, +CALALUCA suggested, conversion of the text will be the major contribution +to scholarship. CALALUCA stressed that, as possibly the only private +publishing organization at the Workshop, Chadwyck-Healey had sought no +federal funds or national foundation support before embarking upon the +project, but instead had relied upon a great deal of homework and +marketing to accomplish the task of conversion. + +Ever since the possibilities of computer-searching have emerged, scholars +in the field of late ancient and early medieval studies (philosophers, +theologians, classicists, and those studying the history of natural law +and the history of the legal development of Western civilization) have +been longing for a fully searchable version of Western literature, for +example, all the texts of Augustine and Bernard of Clairvaux and +Boethius, not to mention all the secondary and tertiary authors. + +Various questions arose, CALALUCA said. Should one convert Migne? +Should the database be encoded? Is it necessary to do that? How should +it be delivered? What about CD-ROM? Since this is a transitional +medium, why even bother to create software to run on a CD-ROM? Since +everybody knows people will be networking information, why go to the +trouble--which is far greater with CD-ROM than with the production of +magnetic data? Finally, how does one make the data available? Can many +of the hurdles to using electronic information that some publishers have +imposed upon databases be eliminated? + +The PLD project was based on the principle that computer-searching of +texts is most effective when it is done with a large database. Because +PLD represented a collection that serves so many disciplines across so +many periods, it was irresistible. + +The basic rule in converting PLD was to do no harm, to avoid the sins of +intrusion in such a database: no introduction of newer editions, no +on-the-spot changes, no eradicating of all possible falsehoods from an +edition. Thus, PLD is not the final act in electronic publishing for +this discipline, but simply the beginning. The conversion of PLD has +evoked numerous unanticipated questions: How will information be used? +What about networking? Can the rights of a database be protected? +Should one protect the rights of a database? How can it be made +available? + +Those converting PLD also tried to avoid the sins of omission, that is, +excluding portions of the collections or whole sections. What about the +images? PLD is full of images, some are extremely pious +nineteenth-century representations of the Fathers, while others contain +highly interesting elements. The goal was to cover all the text of Migne +(including notes, in Greek and in Hebrew, the latter of which, in +particular, causes problems in creating a search structure), all the +indices, and even the images, which are being scanned in separately +searchable files. + +Several North American institutions that have placed acquisition requests +for the PLD database have requested it in magnetic form without software, +which means they are already running it without software, without +anything demonstrated at the Workshop. + +What cannot practically be done is go back and reconvert and re-encode +data, a time-consuming and extremely costly enterprise. CALALUCA sees +PLD as a database that can, and should, be run under a variety of +retrieval softwares. This will permit the widest possible searches. +Consequently, the need to produce a CD-ROM of PLD, as well as to develop +software that could handle some 1.3 gigabyte of heavily encoded text, +developed out of conversations with collection development and reference +librarians who wanted software both compassionate enough for the +pedestrian but also capable of incorporating the most detailed +lexicographical studies that a user desires to conduct. In the end, the +encoding and conversion of the data will prove the most enduring +testament to the value of the project. + +The encoding of the database was also a hard-fought issue: Did the +database need to be encoded? Were there normative structures for encoding +humanist texts? Should it be SGML? What about the TEI--will it last, +will it prove useful? CALALUCA expressed some minor doubts as to whether +a data bank can be fully TEI-conformant. Every effort can be made, but +in the end to be TEI-conformant means to accept the need to make some +firm encoding decisions that can, indeed, be disputed. The TEI points +the publisher in a proper direction but does not presume to make all the +decisions for him or her. Essentially, the goal of encoding was to +eliminate, as much as possible, the hindrances to information-networking, +so that if an institution acquires a database, everybody associated with +the institution can have access to it. + +CALALUCA demonstrated a portion of Volume 160, because it had the most +anomalies in it. The software was created by Electronic Book +Technologies of Providence, RI, and is called Dynatext. The software +works only with SGML-coded data. + +Viewing a table of contents on the screen, the audience saw how Dynatext +treats each element as a book and attempts to simplify movement through a +volume. Familiarity with the Patrologia in print (i.e., the text, its +source, and the editions) will make the machine-readable versions highly +useful. (Software with a Windows application was sought for PLD, +CALALUCA said, because this was the main trend for scholarly use.) + +CALALUCA also demonstrated how a user can perform a variety of searches +and quickly move to any part of a volume; the look-up screen provides +some basic, simple word-searching. + +CALALUCA argued that one of the major difficulties is not the software. +Rather, in creating a product that will be used by scholars representing +a broad spectrum of computer sophistication, user documentation proves +to be the most important service one can provide. + +CALALUCA next illustrated a truncated search under mysterium within ten +words of virtus and how one would be able to find its contents throughout +the entire database. He said that the exciting thing about PLD is that +many of the applications in the retrieval software being written for it +will exceed the capabilities of the software employed now for the CD-ROM +version. The CD-ROM faces genuine limitations, in terms of speed and +comprehensiveness, in the creation of a retrieval software to run it. +CALALUCA said he hoped that individual scholars will download the data, +if they wish, to their personal computers, and have ready access to +important texts on a constant basis, which they will be able to use in +their research and from which they might even be able to publish. + +(CALALUCA explained that the blue numbers represented Migne's column numbers, +which are the standard scholarly references. Pulling up a note, he stated +that these texts were heavily edited and the image files would appear simply +as a note as well, so that one could quickly access an image.) + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +FLEISCHHAUER/ERWAY * Several problems with which AM is still wrestling * +Various search and retrieval capabilities * Illustration of automatic +stemming and a truncated search * AM's attempt to find ways to connect +cataloging to the texts * AM's gravitation towards SGML * Striking a +balance between quantity and quality * How AM furnishes users recourse to +images * Conducting a search in a full-text environment * Macintosh and +IBM prototypes of AM * Multimedia aspects of AM * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +A demonstration of American Memory by its coordinator, Carl FLEISCHHAUER, +and Ricky ERWAY, associate coordinator, Library of Congress, concluded +the morning session. Beginning with a collection of broadsides from the +Continental Congress and the Constitutional Convention, the only text +collection in a presentable form at the time of the Workshop, FLEISCHHAUER +highlighted several of the problems with which AM is still wrestling. +(In its final form, the disk will contain two collections, not only the +broadsides but also the full text with illustrations of a set of +approximately 300 African-American pamphlets from the period 1870 to 1910.) + +As FREEMAN had explained earlier, AM has attempted to use a small amount +of interpretation to introduce collections. In the present case, the +contractor, a company named Quick Source, in Silver Spring, MD., used +software called Toolbook and put together a modestly interactive +introduction to the collection. Like the two preceding speakers, +FLEISCHHAUER argued that the real asset was the underlying collection. + +FLEISCHHAUER proceeded to describe various search and retrieval +capabilities while ERWAY worked the computer. In this particular package +the "go to" pull-down allowed the user in effect to jump out of Toolbook, +where the interactive program was located, and enter the third-party +software used by AM for this text collection, which is called Personal +Librarian. This was the Windows version of Personal Librarian, a +software application put together by a company in Rockville, Md. + +Since the broadsides came from the Revolutionary War period, a search was +conducted using the words British or war, with the default operator reset +as or. FLEISCHHAUER demonstrated both automatic stemming (which finds +other forms of the same root) and a truncated search. One of Personal +Librarian's strongest features, the relevance ranking, was represented by +a chart that indicated how often words being sought appeared in +documents, with the one receiving the most "hits" obtaining the highest +score. The "hit list" that is supplied takes the relevance ranking into +account, making the first hit, in effect, the one the software has +selected as the most relevant example. + +While in the text of one of the broadside documents, FLEISCHHAUER +remarked AM's attempt to find ways to connect cataloging to the texts, +which it does in different ways in different manifestations. In the case +shown, the cataloging was pasted on: AM took MARC records that were +written as on-line records right into one of the Library's mainframe +retrieval programs, pulled them out, and handed them off to the contractor, +who massaged them somewhat to display them in the manner shown. One of +AM's questions is, Does the cataloguing normally performed in the mainframe +work in this context, or had AM ought to think through adjustments? + +FLEISCHHAUER made the additional point that, as far as the text goes, AM +has gravitated towards SGML (he pointed to the boldface in the upper part +of the screen). Although extremely limited in its ability to translate +or interpret SGML, Personal Librarian will furnish both bold and italics +on screen; a fairly easy thing to do, but it is one of the ways in which +SGML is useful. + +Striking a balance between quantity and quality has been a major concern +of AM, with accuracy being one of the places where project staff have +felt that less than 100-percent accuracy was not unacceptable. +FLEISCHHAUER cited the example of the standard of the rekeying industry, +namely 99.95 percent; as one service bureau informed him, to go from +99.95 to 100 percent would double the cost. + +FLEISCHHAUER next demonstrated how AM furnishes users recourse to images, +and at the same time recalled LESK's pointed question concerning the +number of people who would look at those images and the number who would +work only with the text. If the implication of LESK's question was +sound, FLEISCHHAUER said, it raised the stakes for text accuracy and +reduced the value of the strategy for images. + +Contending that preservation is always a bugaboo, FLEISCHHAUER +demonstrated several images derived from a scan of a preservation +microfilm that AM had made. He awarded a grade of C at best, perhaps a +C minus or a C plus, for how well it worked out. Indeed, the matter of +learning if other people had better ideas about scanning in general, and, +in particular, scanning from microfilm, was one of the factors that drove +AM to attempt to think through the agenda for the Workshop. Skew, for +example, was one of the issues that AM in its ignorance had not reckoned +would prove so difficult. + +Further, the handling of images of the sort shown, in a desktop computer +environment, involved a considerable amount of zooming and scrolling. +Ultimately, AM staff feel that perhaps the paper copy that is printed out +might be the most useful one, but they remain uncertain as to how much +on-screen reading users will do. + +Returning to the text, FLEISCHHAUER asked viewers to imagine a person who +might be conducting a search in a full-text environment. With this +scenario, he proceeded to illustrate other features of Personal Librarian +that he considered helpful; for example, it provides the ability to +notice words as one reads. Clicking the "include" button on the bottom +of the search window pops the words that have been highlighted into the +search. Thus, a user can refine the search as he or she reads, +re-executing the search and continuing to find things in the quest for +materials. This software not only contains relevance ranking, Boolean +operators, and truncation, it also permits one to perform word algebra, +so to say, where one puts two or three words in parentheses and links +them with one Boolean operator and then a couple of words in another set +of parentheses and asks for things within so many words of others. + +Until they became acquainted recently with some of the work being done in +classics, the AM staff had not realized that a large number of the +projects that involve electronic texts were being done by people with a +profound interest in language and linguistics. Their search strategies +and thinking are oriented to those fields, as is shown in particular by +the Perseus example. As amateur historians, the AM staff were thinking +more of searching for concepts and ideas than for particular words. +Obviously, FLEISCHHAUER conceded, searching for concepts and ideas and +searching for words may be two rather closely related things. + +While displaying several images, FLEISCHHAUER observed that the Macintosh +prototype built by AM contains a greater diversity of formats. Echoing a +previous speaker, he said that it was easier to stitch things together in +the Macintosh, though it tended to be a little more anemic in search and +retrieval. AM, therefore, increasingly has been investigating +sophisticated retrieval engines in the IBM format. + +FLEISCHHAUER demonstrated several additional examples of the prototype +interfaces: One was AM's metaphor for the network future, in which a +kind of reading-room graphic suggests how one would be able to go around +to different materials. AM contains a large number of photographs in +analog video form worked up from a videodisc, which enable users to make +copies to print or incorporate in digital documents. A frame-grabber is +built into the system, making it possible to bring an image into a window +and digitize or print it out. + +FLEISCHHAUER next demonstrated sound recording, which included texts. +Recycled from a previous project, the collection included sixty 78-rpm +phonograph records of political speeches that were made during and +immediately after World War I. These constituted approximately three +hours of audio, as AM has digitized it, which occupy 150 megabytes on a +CD. Thus, they are considerably compressed. From the catalogue card, +FLEISCHHAUER proceeded to a transcript of a speech with the audio +available and with highlighted text following it as it played. +A photograph has been added and a transcription made. + +Considerable value has been added beyond what the Library of Congress +normally would do in cataloguing a sound recording, which raises several +questions for AM concerning where to draw lines about how much value it can +afford to add and at what point, perhaps, this becomes more than AM could +reasonably do or reasonably wish to do. FLEISCHHAUER also demonstrated +a motion picture. As FREEMAN had reported earlier, the motion picture +materials have proved the most popular, not surprisingly. This says more +about the medium, he thought, than about AM's presentation of it. + +Because AM's goal was to bring together things that could be used by +historians or by people who were curious about history, +turn-of-the-century footage seemed to represent the most appropriate +collections from the Library of Congress in motion pictures. These were +the very first films made by Thomas Edison's company and some others at +that time. The particular example illustrated was a Biograph film, +brought in with a frame-grabber into a window. A single videodisc +contains about fifty titles and pieces of film from that period, all of +New York City. Taken together, AM believes, they provide an interesting +documentary resource. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +DISCUSSION * Using the frame-grabber in AM * Volume of material processed +and to be processed * Purpose of AM within LC * Cataloguing and the +nature of AM's material * SGML coding and the question of quality versus +quantity * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +During the question-and-answer period that followed FLEISCHHAUER's +presentation, several clarifications were made. + +AM is bringing in motion pictures from a videodisc. The frame-grabber +devices create a window on a computer screen, which permits users to +digitize a single frame of the movie or one of the photographs. It +produces a crude, rough-and-ready image that high school students can +incorporate into papers, and that has worked very nicely in this way. + +Commenting on FLEISCHHAUER's assertion that AM was looking more at +searching ideas than words, MYLONAS argued that without words an idea +does not exist. FLEISCHHAUER conceded that he ought to have articulated +his point more clearly. MYLONAS stated that they were in fact both +talking about the same thing. By searching for words and by forcing +people to focus on the word, the Perseus Project felt that they would get +them to the idea. The way one reviews results is tailored more to one +kind of user than another. + +Concerning the total volume of material that has been processed in this +way, AM at this point has in retrievable form seven or eight collections, +all of them photographic. In the Macintosh environment, for example, +there probably are 35,000-40,000 photographs. The sound recordings +number sixty items. The broadsides number about 300 items. There are +500 political cartoons in the form of drawings. The motion pictures, as +individual items, number sixty to seventy. + +AM also has a manuscript collection, the life history portion of one of +the federal project series, which will contain 2,900 individual +documents, all first-person narratives. AM has in process about 350 +African-American pamphlets, or about 12,000 printed pages for the period +1870-1910. Also in the works are some 4,000 panoramic photographs. AM +has recycled a fair amount of the work done by LC's Prints and +Photographs Division during the Library's optical disk pilot project in +the 1980s. For example, a special division of LC has tooled up and +thought through all the ramifications of electronic presentation of +photographs. Indeed, they are wheeling them out in great barrel loads. +The purpose of AM within the Library, it is hoped, is to catalyze several +of the other special collection divisions which have no particular +experience with, in some cases, mixed feelings about, an activity such as +AM. Moreover, in many cases the divisions may be characterized as not +only lacking experience in "electronifying" things but also in automated +cataloguing. MARC cataloguing as practiced in the United States is +heavily weighted toward the description of monograph and serial +materials, but is much thinner when one enters the world of manuscripts +and things that are held in the Library's music collection and other +units. In response to a comment by LESK, that AM's material is very +heavily photographic, and is so primarily because individual records have +been made for each photograph, FLEISCHHAUER observed that an item-level +catalog record exists, for example, for each photograph in the Detroit +Publishing collection of 25,000 pictures. In the case of the Federal +Writers Project, for which nearly 3,000 documents exist, representing +information from twenty-six different states, AM with the assistance of +Karen STUART of the Manuscript Division will attempt to find some way not +only to have a collection-level record but perhaps a MARC record for each +state, which will then serve as an umbrella for the 100-200 documents +that come under it. But that drama remains to be enacted. The AM staff +is conservative and clings to cataloguing, though of course visitors tout +artificial intelligence and neural networks in a manner that suggests that +perhaps one need not have cataloguing or that much of it could be put aside. + +The matter of SGML coding, FLEISCHHAUER conceded, returned the discussion +to the earlier treated question of quality versus quantity in the Library +of Congress. Of course, text conversion can be done with 100-percent +accuracy, but it means that when one's holdings are as vast as LC's only +a tiny amount will be exposed, whereas permitting lower levels of +accuracy can lead to exposing or sharing larger amounts, but with the +quality correspondingly impaired. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +TWOHIG * A contrary experience concerning electronic options * Volume of +material in the Washington papers and a suggestion of David Packard * +Implications of Packard's suggestion * Transcribing the documents for the +CD-ROM * Accuracy of transcriptions * The CD-ROM edition of the Founding +Fathers documents * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Finding encouragement in a comment of MICHELSON's from the morning +session--that numerous people in the humanities were choosing electronic +options to do their work--Dorothy TWOHIG, editor, The Papers of George +Washington, opened her illustrated talk by noting that her experience +with literary scholars and numerous people in editing was contrary to +MICHELSON's. TWOHIG emphasized literary scholars' complete ignorance of +the technological options available to them or their reluctance or, in +some cases, their downright hostility toward these options. + +After providing an overview of the five Founding Fathers projects +(Jefferson at Princeton, Franklin at Yale, John Adams at the +Massachusetts Historical Society, and Madison down the hall from her at +the University of Virginia), TWOHIG observed that the Washington papers, +like all of the projects, include both sides of the Washington +correspondence and deal with some 135,000 documents to be published with +extensive annotation in eighty to eighty-five volumes, a project that +will not be completed until well into the next century. Thus, it was +with considerable enthusiasm several years ago that the Washington Papers +Project (WPP) greeted David Packard's suggestion that the papers of the +Founding Fathers could be published easily and inexpensively, and to the +great benefit of American scholarship, via CD-ROM. + +In pragmatic terms, funding from the Packard Foundation would expedite +the transcription of thousands of documents waiting to be put on disk in +the WPP offices. Further, since the costs of collecting, editing, and +converting the Founding Fathers documents into letterpress editions were +running into the millions of dollars, and the considerable staffs +involved in all of these projects were devoting their careers to +producing the work, the Packard Foundation's suggestion had a +revolutionary aspect: Transcriptions of the entire corpus of the +Founding Fathers papers would be available on CD-ROM to public and +college libraries, even high schools, at a fraction of the cost-- +$100-$150 for the annual license fee--to produce a limited university +press run of 1,000 of each volume of the published papers at $45-$150 per +printed volume. Given the current budget crunch in educational systems +and the corresponding constraints on librarians in smaller institutions +who wish to add these volumes to their collections, producing the +documents on CD-ROM would likely open a greatly expanded audience for the +papers. TWOHIG stressed, however, that development of the Founding +Fathers CD-ROM is still in its infancy. Serious software problems remain +to be resolved before the material can be put into readable form. + +Funding from the Packard Foundation resulted in a major push to +transcribe the 75,000 or so documents of the Washington papers remaining +to be transcribed onto computer disks. Slides illustrated several of the +problems encountered, for example, the present inability of CD-ROM to +indicate the cross-outs (deleted material) in eighteenth century +documents. TWOHIG next described documents from various periods in the +eighteenth century that have been transcribed in chronological order and +delivered to the Packard offices in California, where they are converted +to the CD-ROM, a process that is expected to consume five years to +complete (that is, reckoning from David Packard's suggestion made several +years ago, until about July 1994). TWOHIG found an encouraging +indication of the project's benefits in the ongoing use made by scholars +of the search functions of the CD-ROM, particularly in reducing the time +spent in manually turning the pages of the Washington papers. + +TWOHIG next furnished details concerning the accuracy of transcriptions. +For instance, the insertion of thousands of documents on the CD-ROM +currently does not permit each document to be verified against the +original manuscript several times as in the case of documents that appear +in the published edition. However, the transcriptions receive a cursory +check for obvious typos, the misspellings of proper names, and other +errors from the WPP CD-ROM editor. Eventually, all documents that appear +in the electronic version will be checked by project editors. Although +this process has met with opposition from some of the editors on the +grounds that imperfect work may leave their offices, the advantages in +making this material available as a research tool outweigh fears about the +misspelling of proper names and other relatively minor editorial matters. + +Completion of all five Founding Fathers projects (i.e., retrievability +and searchability of all of the documents by proper names, alternate +spellings, or varieties of subjects) will provide one of the richest +sources of this size for the history of the United States in the latter +part of the eighteenth century. Further, publication on CD-ROM will +allow editors to include even minutiae, such as laundry lists, not +included in the printed volumes. + +It seems possible that the extensive annotation provided in the printed +volumes eventually will be added to the CD-ROM edition, pending +negotiations with the publishers of the papers. At the moment, the +Founding Fathers CD-ROM is accessible only on the IBYCUS, a computer +developed out of the Thesaurus Linguae Graecae project and designed for +the use of classical scholars. There are perhaps 400 IBYCUS computers in +the country, most of which are in university classics departments. +Ultimately, it is anticipated that the CD-ROM edition of the Founding +Fathers documents will run on any IBM-compatible or Macintosh computer +with a CD-ROM drive. Numerous changes in the software will also occur +before the project is completed. (Editor's note: an IBYCUS was +unavailable to demonstrate the CD-ROM.) + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +DISCUSSION * Several additional features of WPP clarified * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Discussion following TWOHIG's presentation served to clarify several +additional features, including (1) that the project's primary +intellectual product consists in the electronic transcription of the +material; (2) that the text transmitted to the CD-ROM people is not +marked up; (3) that cataloging and subject-indexing of the material +remain to be worked out (though at this point material can be retrieved +by name); and (4) that because all the searching is done in the hardware, +the IBYCUS is designed to read a CD-ROM which contains only sequential +text files. Technically, it then becomes very easy to read the material +off and put it on another device. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +LEBRON * Overview of the history of the joint project between AAAS and +OCLC * Several practices the on-line environment shares with traditional +publishing on hard copy * Several technical and behavioral barriers to +electronic publishing * How AAAS and OCLC arrived at the subject of +clinical trials * Advantages of the electronic format and other features +of OJCCT * An illustrated tour of the journal * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Maria LEBRON, managing editor, The Online Journal of Current Clinical +Trials (OJCCT), presented an illustrated overview of the history of the +joint project between the American Association for the Advancement of +Science (AAAS) and the Online Computer Library Center, Inc. (OCLC). The +joint venture between AAAS and OCLC owes its beginning to a +reorganization launched by the new chief executive officer at OCLC about +three years ago and combines the strengths of these two disparate +organizations. In short, OJCCT represents the process of scholarly +publishing on line. + +LEBRON next discussed several practices the on-line environment shares +with traditional publishing on hard copy--for example, peer review of +manuscripts--that are highly important in the academic world. LEBRON +noted in particular the implications of citation counts for tenure +committees and grants committees. In the traditional hard-copy +environment, citation counts are readily demonstrable, whereas the +on-line environment represents an ethereal medium to most academics. + +LEBRON remarked several technical and behavioral barriers to electronic +publishing, for instance, the problems in transmission created by special +characters or by complex graphics and halftones. In addition, she noted +economic limitations such as the storage costs of maintaining back issues +and market or audience education. + +Manuscripts cannot be uploaded to OJCCT, LEBRON explained, because it is +not a bulletin board or E-mail, forms of electronic transmission of +information that have created an ambience clouding people's understanding +of what the journal is attempting to do. OJCCT, which publishes +peer-reviewed medical articles dealing with the subject of clinical +trials, includes text, tabular material, and graphics, although at this +time it can transmit only line illustrations. + +Next, LEBRON described how AAAS and OCLC arrived at the subject of +clinical trials: It is 1) a highly statistical discipline that 2) does +not require halftones but can satisfy the needs of its audience with line +illustrations and graphic material, and 3) there is a need for the speedy +dissemination of high-quality research results. Clinical trials are +research activities that involve the administration of a test treatment +to some experimental unit in order to test its usefulness before it is +made available to the general population. LEBRON proceeded to give +additional information on OJCCT concerning its editor-in-chief, editorial +board, editorial content, and the types of articles it publishes +(including peer-reviewed research reports and reviews), as well as +features shared by other traditional hard-copy journals. + +Among the advantages of the electronic format are faster dissemination of +information, including raw data, and the absence of space constraints +because pages do not exist. (This latter fact creates an interesting +situation when it comes to citations.) Nor are there any issues. AAAS's +capacity to download materials directly from the journal to a +subscriber's printer, hard drive, or floppy disk helps ensure highly +accurate transcription. Other features of OJCCT include on-screen alerts +that allow linkage of subsequently published documents to the original +documents; on-line searching by subject, author, title, etc.; indexing of +every single word that appears in an article; viewing access to an +article by component (abstract, full text, or graphs); numbered +paragraphs to replace page counts; publication in Science every thirty +days of indexing of all articles published in the journal; +typeset-quality screens; and Hypertext links that enable subscribers to +bring up Medline abstracts directly without leaving the journal. + +After detailing the two primary ways to gain access to the journal, +through the OCLC network and Compuserv if one desires graphics or through +the Internet if just an ASCII file is desired, LEBRON illustrated the +speedy editorial process and the coding of the document using SGML tags +after it has been accepted for publication. She also gave an illustrated +tour of the journal, its search-and-retrieval capabilities in particular, +but also including problems associated with scanning in illustrations, +and the importance of on-screen alerts to the medical profession re +retractions or corrections, or more frequently, editorials, letters to +the editors, or follow-up reports. She closed by inviting the audience +to join AAAS on 1 July, when OJCCT was scheduled to go on-line. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +DISCUSSION * Additional features of OJCCT * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +In the lengthy discussion that followed LEBRON's presentation, these +points emerged: + + * The SGML text can be tailored as users wish. + + * All these articles have a fairly simple document definition. + + * Document-type definitions (DTDs) were developed and given to OJCCT + for coding. + + * No articles will be removed from the journal. (Because there are + no back issues, there are no lost issues either. Once a subscriber + logs onto the journal he or she has access not only to the currently + published materials, but retrospectively to everything that has been + published in it. Thus the table of contents grows bigger. The date + of publication serves to distinguish between currently published + materials and older materials.) + + * The pricing system for the journal resembles that for most medical + journals: for 1992, $95 for a year, plus telecommunications charges + (there are no connect time charges); for 1993, $110 for the + entire year for single users, though the journal can be put on a + local area network (LAN). However, only one person can access the + journal at a time. Site licenses may come in the future. + + * AAAS is working closely with colleagues at OCLC to display + mathematical equations on screen. + + * Without compromising any steps in the editorial process, the + technology has reduced the time lag between when a manuscript is + originally submitted and the time it is accepted; the review process + does not differ greatly from the standard six-to-eight weeks + employed by many of the hard-copy journals. The process still + depends on people. + + * As far as a preservation copy is concerned, articles will be + maintained on the computer permanently and subscribers, as part of + their subscription, will receive a microfiche-quality archival copy + of everything published during that year; in addition, reprints can + be purchased in much the same way as in a hard-copy environment. + Hard copies are prepared but are not the primary medium for the + dissemination of the information. + + * Because OJCCT is not yet on line, it is difficult to know how many + people would simply browse through the journal on the screen as + opposed to downloading the whole thing and printing it out; a mix of + both types of users likely will result. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PERSONIUS * Developments in technology over the past decade * The CLASS +Project * Advantages for technology and for the CLASS Project * +Developing a network application an underlying assumption of the project +* Details of the scanning process * Print-on-demand copies of books * +Future plans include development of a browsing tool * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Lynne PERSONIUS, assistant director, Cornell Information Technologies for +Scholarly Information Services, Cornell University, first commented on +the tremendous impact that developments in technology over the past ten +years--networking, in particular--have had on the way information is +handled, and how, in her own case, these developments have counterbalanced +Cornell's relative geographical isolation. Other significant technologies +include scanners, which are much more sophisticated than they were ten years +ago; mass storage and the dramatic savings that result from it in terms of +both space and money relative to twenty or thirty years ago; new and +improved printing technologies, which have greatly affected the distribution +of information; and, of course, digital technologies, whose applicability to +library preservation remains at issue. + +Given that context, PERSONIUS described the College Library Access and +Storage System (CLASS) Project, a library preservation project, +primarily, and what has been accomplished. Directly funded by the +Commission on Preservation and Access and by the Xerox Corporation, which +has provided a significant amount of hardware, the CLASS Project has been +working with a development team at Xerox to develop a software +application tailored to library preservation requirements. Within +Cornell, participants in the project have been working jointly with both +library and information technologies. The focus of the project has been +on reformatting and saving books that are in brittle condition. +PERSONIUS showed Workshop participants a brittle book, and described how +such books were the result of developments in papermaking around the +beginning of the Industrial Revolution. The papermaking process was +changed so that a significant amount of acid was introduced into the +actual paper itself, which deteriorates as it sits on library shelves. + +One of the advantages for technology and for the CLASS Project is that +the information in brittle books is mostly out of copyright and thus +offers an opportunity to work with material that requires library +preservation, and to create and work on an infrastructure to save the +material. Acknowledging the familiarity of those working in preservation +with this information, PERSONIUS noted that several things are being +done: the primary preservation technology used today is photocopying of +brittle material. Saving the intellectual content of the material is the +main goal. With microfilm copy, the intellectual content is preserved on +the assumption that in the future the image can be reformatted in any +other way that then exists. + +An underlying assumption of the CLASS Project from the beginning was +that it would develop a network application. Project staff scan books +at a workstation located in the library, near the brittle material. +An image-server filing system is located at a distance from that +workstation, and a printer is located in another building. All of the +materials digitized and stored on the image-filing system are cataloged +in the on-line catalogue. In fact, a record for each of these electronic +books is stored in the RLIN database so that a record exists of what is +in the digital library throughout standard catalogue procedures. In the +future, researchers working from their own workstations in their offices, +or their networks, will have access--wherever they might be--through a +request server being built into the new digital library. A second +assumption is that the preferred means of finding the material will be by +looking through a catalogue. PERSONIUS described the scanning process, +which uses a prototype scanner being developed by Xerox and which scans a +very high resolution image at great speed. Another significant feature, +because this is a preservation application, is the placing of the pages +that fall apart one for one on the platen. Ordinarily, a scanner could +be used with some sort of a document feeder, but because of this +application that is not feasible. Further, because CLASS is a +preservation application, after the paper replacement is made there, a +very careful quality control check is performed. An original book is +compared to the printed copy and verification is made, before proceeding, +that all of the image, all of the information, has been captured. Then, +a new library book is produced: The printed images are rebound by a +commercial binder and a new book is returned to the shelf. +Significantly, the books returned to the library shelves are beautiful +and useful replacements on acid-free paper that should last a long time, +in effect, the equivalent of preservation photocopies. Thus, the project +has a library of digital books. In essence, CLASS is scanning and +storing books as 600 dot-per-inch bit-mapped images, compressed using +Group 4 CCITT (i.e., the French acronym for International Consultative +Committee for Telegraph and Telephone) compression. They are stored as +TIFF files on an optical filing system that is composed of a database +used for searching and locating the books and an optical jukebox that +stores 64 twelve-inch platters. A very-high-resolution printed copy of +these books at 600 dots per inch is created, using a Xerox DocuTech +printer to make the paper replacements on acid-free paper. + +PERSONIUS maintained that the CLASS Project presents an opportunity to +introduce people to books as digital images by using a paper medium. +Books are returned to the shelves while people are also given the ability +to print on demand--to make their own copies of books. (PERSONIUS +distributed copies of an engineering journal published by engineering +students at Cornell around 1900 as an example of what a print-on-demand +copy of material might be like. This very cheap copy would be available +to people to use for their own research purposes and would bridge the gap +between an electronic work and the paper that readers like to have.) +PERSONIUS then attempted to illustrate a very early prototype of +networked access to this digital library. Xerox Corporation has +developed a prototype of a view station that can send images across the +network to be viewed. + +The particular library brought down for demonstration contained two +mathematics books. CLASS is developing and will spend the next year +developing an application that allows people at workstations to browse +the books. Thus, CLASS is developing a browsing tool, on the assumption +that users do not want to read an entire book from a workstation, but +would prefer to be able to look through and decide if they would like to +have a printed copy of it. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +DISCUSSION * Re retrieval software * "Digital file copyright" * Scanning +rate during production * Autosegmentation * Criteria employed in +selecting books for scanning * Compression and decompression of images * +OCR not precluded * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +During the question-and-answer period that followed her presentation, +PERSONIUS made these additional points: + + * Re retrieval software, Cornell is developing a Unix-based server + as well as clients for the server that support multiple platforms + (Macintosh, IBM and Sun workstations), in the hope that people from + any of those platforms will retrieve books; a further operating + assumption is that standard interfaces will be used as much as + possible, where standards can be put in place, because CLASS + considers this retrieval software a library application and would + like to be able to look at material not only at Cornell but at other + institutions. + + * The phrase "digital file copyright by Cornell University" was + added at the advice of Cornell's legal staff with the caveat that it + probably would not hold up in court. Cornell does not want people + to copy its books and sell them but would like to keep them + available for use in a library environment for library purposes. + + * In production the scanner can scan about 300 pages per hour, + capturing 600 dots per inch. + + * The Xerox software has filters to scan halftone material and avoid + the moire patterns that occur when halftone material is scanned. + Xerox has been working on hardware and software that would enable + the scanner itself to recognize this situation and deal with it + appropriately--a kind of autosegmentation that would enable the + scanner to handle halftone material as well as text on a single page. + + * The books subjected to the elaborate process described above were + selected because CLASS is a preservation project, with the first 500 + books selected coming from Cornell's mathematics collection, because + they were still being heavily used and because, although they were + in need of preservation, the mathematics library and the mathematics + faculty were uncomfortable having them microfilmed. (They wanted a + printed copy.) Thus, these books became a logical choice for this + project. Other books were chosen by the project's selection committees + for experiments with the technology, as well as to meet a demand or need. + + * Images will be decompressed before they are sent over the line; at + this time they are compressed and sent to the image filing system + and then sent to the printer as compressed images; they are returned + to the workstation as compressed 600-dpi images and the workstation + decompresses and scales them for display--an inefficient way to + access the material though it works quite well for printing and + other purposes. + + * CLASS is also decompressing on Macintosh and IBM, a slow process + right now. Eventually, compression and decompression will take + place on an image conversion server. Trade-offs will be made, based + on future performance testing, concerning where the file is + compressed and what resolution image is sent. + + * OCR has not been precluded; images are being stored that have been + scanned at a high resolution, which presumably would suit them well + to an OCR process. Because the material being scanned is about 100 + years old and was printed with less-than-ideal technologies, very + early and preliminary tests have not produced good results. But the + project is capturing an image that is of sufficient resolution to be + subjected to OCR in the future. Moreover, the system architecture + and the system plan have a logical place to store an OCR image if it + has been captured. But that is not being done now. + + ****** + +SESSION III. DISTRIBUTION, NETWORKS, AND NETWORKING: OPTIONS FOR +DISSEMINATION + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +ZICH * Issues pertaining to CD-ROMs * Options for publishing in CD-ROM * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Robert ZICH, special assistant to the associate librarian for special +projects, Library of Congress, and moderator of this session, first noted +the blessed but somewhat awkward circumstance of having four very +distinguished people representing networks and networking or at least +leaning in that direction, while lacking anyone to speak from the +strongest possible background in CD-ROMs. ZICH expressed the hope that +members of the audience would join the discussion. He stressed the +subtitle of this particular session, "Options for Dissemination," and, +concerning CD-ROMs, the importance of determining when it would be wise +to consider dissemination in CD-ROM versus networks. A shopping list of +issues pertaining to CD-ROMs included: the grounds for selecting +commercial publishers, and in-house publication where possible versus +nonprofit or government publication. A similar list for networks +included: determining when one should consider dissemination through a +network, identifying the mechanisms or entities that exist to place items +on networks, identifying the pool of existing networks, determining how a +producer would choose between networks, and identifying the elements of +a business arrangement in a network. + +Options for publishing in CD-ROM: an outside publisher versus +self-publication. If an outside publisher is used, it can be nonprofit, +such as the Government Printing Office (GPO) or the National Technical +Information Service (NTIS), in the case of government. The pros and cons +associated with employing an outside publisher are obvious. Among the +pros, there is no trouble getting accepted. One pays the bill and, in +effect, goes one's way. Among the cons, when one pays an outside +publisher to perform the work, that publisher will perform the work it is +obliged to do, but perhaps without the production expertise and skill in +marketing and dissemination that some would seek. There is the body of +commercial publishers that do possess that kind of expertise in +distribution and marketing but that obviously are selective. In +self-publication, one exercises full control, but then one must handle +matters such as distribution and marketing. Such are some of the options +for publishing in the case of CD-ROM. + +In the case of technical and design issues, which are also important, +there are many matters which many at the Workshop already knew a good +deal about: retrieval system requirements and costs, what to do about +images, the various capabilities and platforms, the trade-offs between +cost and performance, concerns about local-area networkability, +interoperability, etc. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +LYNCH * Creating networked information is different from using networks +as an access or dissemination vehicle * Networked multimedia on a large +scale does not yet work * Typical CD-ROM publication model a two-edged +sword * Publishing information on a CD-ROM in the present world of +immature standards * Contrast between CD-ROM and network pricing * +Examples demonstrated earlier in the day as a set of insular information +gems * Paramount need to link databases * Layering to become increasingly +necessary * Project NEEDS and the issues of information reuse and active +versus passive use * X-Windows as a way of differentiating between +network access and networked information * Barriers to the distribution +of networked multimedia information * Need for good, real-time delivery +protocols * The question of presentation integrity in client-server +computing in the academic world * Recommendations for producing multimedia ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Clifford LYNCH, director, Library Automation, University of California, +opened his talk with the general observation that networked information +constituted a difficult and elusive topic because it is something just +starting to develop and not yet fully understood. LYNCH contended that +creating genuinely networked information was different from using +networks as an access or dissemination vehicle and was more sophisticated +and more subtle. He invited the members of the audience to extrapolate, +from what they heard about the preceding demonstration projects, to what +sort of a world of electronics information--scholarly, archival, +cultural, etc.--they wished to end up with ten or fifteen years from now. +LYNCH suggested that to extrapolate directly from these projects would +produce unpleasant results. + +Putting the issue of CD-ROM in perspective before getting into +generalities on networked information, LYNCH observed that those engaged +in multimedia today who wish to ship a product, so to say, probably do +not have much choice except to use CD-ROM: networked multimedia on a +large scale basically does not yet work because the technology does not +exist. For example, anybody who has tried moving images around over the +Internet knows that this is an exciting touch-and-go process, a +fascinating and fertile area for experimentation, research, and +development, but not something that one can become deeply enthusiastic +about committing to production systems at this time. + +This situation will change, LYNCH said. He differentiated CD-ROM from +the practices that have been followed up to now in distributing data on +CD-ROM. For LYNCH the problem with CD-ROM is not its portability or its +slowness but the two-edged sword of having the retrieval application and +the user interface inextricably bound up with the data, which is the +typical CD-ROM publication model. It is not a case of publishing data +but of distributing a typically stand-alone, typically closed system, +all--software, user interface, and data--on a little disk. Hence, all +the between-disk navigational issues as well as the impossibility in most +cases of integrating data on one disk with that on another. Most CD-ROM +retrieval software does not network very gracefully at present. However, +in the present world of immature standards and lack of understanding of +what network information is or what the ground rules are for creating or +using it, publishing information on a CD-ROM does add value in a very +real sense. + +LYNCH drew a contrast between CD-ROM and network pricing and in doing so +highlighted something bizarre in information pricing. A large +institution such as the University of California has vendors who will +offer to sell information on CD-ROM for a price per year in four digits, +but for the same data (e.g., an abstracting and indexing database) on +magnetic tape, regardless of how many people may use it concurrently, +will quote a price in six digits. + +What is packaged with the CD-ROM in one sense adds value--a complete +access system, not just raw, unrefined information--although it is not +generally perceived that way. This is because the access software, +although it adds value, is viewed by some people, particularly in the +university environment where there is a very heavy commitment to +networking, as being developed in the wrong direction. + +Given that context, LYNCH described the examples demonstrated as a set of +insular information gems--Perseus, for example, offers nicely linked +information, but would be very difficult to integrate with other +databases, that is, to link together seamlessly with other source files +from other sources. It resembles an island, and in this respect is +similar to numerous stand-alone projects that are based on videodiscs, +that is, on the single-workstation concept. + +As scholarship evolves in a network environment, the paramount need will +be to link databases. We must link personal databases to public +databases, to group databases, in fairly seamless ways--which is +extremely difficult in the environments under discussion with copies of +databases proliferating all over the place. + +The notion of layering also struck LYNCH as lurking in several of the +projects demonstrated. Several databases in a sense constitute +information archives without a significant amount of navigation built in. +Educators, critics, and others will want a layered structure--one that +defines or links paths through the layers to allow users to reach +specific points. In LYNCH's view, layering will become increasingly +necessary, and not just within a single resource but across resources +(e.g., tracing mythology and cultural themes across several classics +databases as well as a database of Renaissance culture). This ability to +organize resources, to build things out of multiple other things on the +network or select pieces of it, represented for LYNCH one of the key +aspects of network information. + +Contending that information reuse constituted another significant issue, +LYNCH commended to the audience's attention Project NEEDS (i.e., National +Engineering Education Delivery System). This project's objective is to +produce a database of engineering courseware as well as the components +that can be used to develop new courseware. In a number of the existing +applications, LYNCH said, the issue of reuse (how much one can take apart +and reuse in other applications) was not being well considered. He also +raised the issue of active versus passive use, one aspect of which is +how much information will be manipulated locally by users. Most people, +he argued, may do a little browsing and then will wish to print. LYNCH +was uncertain how these resources would be used by the vast majority of +users in the network environment. + +LYNCH next said a few words about X-Windows as a way of differentiating +between network access and networked information. A number of the +applications demonstrated at the Workshop could be rewritten to use X +across the network, so that one could run them from any X-capable device- +-a workstation, an X terminal--and transact with a database across the +network. Although this opens up access a little, assuming one has enough +network to handle it, it does not provide an interface to develop a +program that conveniently integrates information from multiple databases. +X is a viewing technology that has limits. In a real sense, it is just a +graphical version of remote log-in across the network. X-type applications +represent only one step in the progression towards real access. + +LYNCH next discussed barriers to the distribution of networked multimedia +information. The heart of the problem is a lack of standards to provide +the ability for computers to talk to each other, retrieve information, +and shuffle it around fairly casually. At the moment, little progress is +being made on standards for networked information; for example, present +standards do not cover images, digital voice, and digital video. A +useful tool kit of exchange formats for basic texts is only now being +assembled. The synchronization of content streams (i.e., synchronizing a +voice track to a video track, establishing temporal relations between +different components in a multimedia object) constitutes another issue +for networked multimedia that is just beginning to receive attention. + +Underlying network protocols also need some work; good, real-time +delivery protocols on the Internet do not yet exist. In LYNCH's view, +highly important in this context is the notion of networked digital +object IDs, the ability of one object on the network to point to another +object (or component thereof) on the network. Serious bandwidth issues +also exist. LYNCH was uncertain if billion-bit-per-second networks would +prove sufficient if numerous people ran video in parallel. + +LYNCH concluded by offering an issue for database creators to consider, +as well as several comments about what might constitute good trial +multimedia experiments. In a networked information world the database +builder or service builder (publisher) does not exercise the same +extensive control over the integrity of the presentation; strange +programs "munge" with one's data before the user sees it. Serious +thought must be given to what guarantees integrity of presentation. Part +of that is related to where one draws the boundaries around a networked +information service. This question of presentation integrity in +client-server computing has not been stressed enough in the academic +world, LYNCH argued, though commercial service providers deal with it +regularly. + +Concerning multimedia, LYNCH observed that good multimedia at the moment +is hideously expensive to produce. He recommended producing multimedia +with either very high sale value, or multimedia with a very long life +span, or multimedia that will have a very broad usage base and whose +costs therefore can be amortized among large numbers of users. In this +connection, historical and humanistically oriented material may be a good +place to start, because it tends to have a longer life span than much of +the scientific material, as well as a wider user base. LYNCH noted, for +example, that American Memory fits many of the criteria outlined. He +remarked the extensive discussion about bringing the Internet or the +National Research and Education Network (NREN) into the K-12 environment +as a way of helping the American educational system. + +LYNCH closed by noting that the kinds of applications demonstrated struck +him as excellent justifications of broad-scale networking for K-12, but +that at this time no "killer" application exists to mobilize the K-12 +community to obtain connectivity. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +DISCUSSION * Dearth of genuinely interesting applications on the network +a slow-changing situation * The issue of the integrity of presentation in +a networked environment * Several reasons why CD-ROM software does not +network * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +During the discussion period that followed LYNCH's presentation, several +additional points were made. + +LYNCH reiterated even more strongly his contention that, historically, +once one goes outside high-end science and the group of those who need +access to supercomputers, there is a great dearth of genuinely +interesting applications on the network. He saw this situation changing +slowly, with some of the scientific databases and scholarly discussion +groups and electronic journals coming on as well as with the availability +of Wide Area Information Servers (WAIS) and some of the databases that +are being mounted there. However, many of those things do not seem to +have piqued great popular interest. For instance, most high school +students of LYNCH's acquaintance would not qualify as devotees of serious +molecular biology. + +Concerning the issue of the integrity of presentation, LYNCH believed +that a couple of information providers have laid down the law at least on +certain things. For example, his recollection was that the National +Library of Medicine feels strongly that one needs to employ the +identifier field if he or she is to mount a database commercially. The +problem with a real networked environment is that one does not know who +is reformatting and reprocessing one's data when one enters a client +server mode. It becomes anybody's guess, for example, if the network +uses a Z39.50 server, or what clients are doing with one's data. A data +provider can say that his contract will only permit clients to have +access to his data after he vets them and their presentation and makes +certain it suits him. But LYNCH held out little expectation that the +network marketplace would evolve in that way, because it required too +much prior negotiation. + +CD-ROM software does not network for a variety of reasons, LYNCH said. +He speculated that CD-ROM publishers are not eager to have their products +really hook into wide area networks, because they fear it will make their +data suppliers nervous. Moreover, until relatively recently, one had to +be rather adroit to run a full TCP/IP stack plus applications on a +PC-size machine, whereas nowadays it is becoming easier as PCs grow +bigger and faster. LYNCH also speculated that software providers had not +heard from their customers until the last year or so, or had not heard +from enough of their customers. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +BESSER * Implications of disseminating images on the network; planning +the distribution of multimedia documents poses two critical +implementation problems * Layered approach represents the way to deal +with users' capabilities * Problems in platform design; file size and its +implications for networking * Transmission of megabyte size images +impractical * Compression and decompression at the user's end * Promising +trends for compression * A disadvantage of using X-Windows * A project at +the Smithsonian that mounts images on several networks * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Howard BESSER, School of Library and Information Science, University of +Pittsburgh, spoke primarily about multimedia, focusing on images and the +broad implications of disseminating them on the network. He argued that +planning the distribution of multimedia documents posed two critical +implementation problems, which he framed in the form of two questions: +1) What platform will one use and what hardware and software will users +have for viewing of the material? and 2) How can one deliver a +sufficiently robust set of information in an accessible format in a +reasonable amount of time? Depending on whether network or CD-ROM is the +medium used, this question raises different issues of storage, +compression, and transmission. + +Concerning the design of platforms (e.g., sound, gray scale, simple +color, etc.) and the various capabilities users may have, BESSER +maintained that a layered approach was the way to deal with users' +capabilities. A result would be that users with less powerful +workstations would simply have less functionality. He urged members of +the audience to advocate standards and accompanying software that handle +layered functionality across a wide variety of platforms. + +BESSER also addressed problems in platform design, namely, deciding how +large a machine to design for situations when the largest number of users +have the lowest level of the machine, and one desires higher +functionality. BESSER then proceeded to the question of file size and +its implications for networking. He discussed still images in the main. +For example, a digital color image that fills the screen of a standard +mega-pel workstation (Sun or Next) will require one megabyte of storage +for an eight-bit image or three megabytes of storage for a true color or +twenty-four-bit image. Lossless compression algorithms (that is, +computational procedures in which no data is lost in the process of +compressing [and decompressing] an image--the exact bit-representation is +maintained) might bring storage down to a third of a megabyte per image, +but not much further than that. The question of size makes it difficult +to fit an appropriately sized set of these images on a single disk or to +transmit them quickly enough on a network. + +With these full screen mega-pel images that constitute a third of a +megabyte, one gets 1,000-3,000 full-screen images on a one-gigabyte disk; +a standard CD-ROM represents approximately 60 percent of that. Storing +images the size of a PC screen (just 8 bit color) increases storage +capacity to 4,000-12,000 images per gigabyte; 60 percent of that gives +one the size of a CD-ROM, which in turn creates a major problem. One +cannot have full-screen, full-color images with lossless compression; one +must compress them or use a lower resolution. For megabyte-size images, +anything slower than a T-1 speed is impractical. For example, on a +fifty-six-kilobaud line, it takes three minutes to transfer a +one-megabyte file, if it is not compressed; and this speed assumes ideal +circumstances (no other user contending for network bandwidth). Thus, +questions of disk access, remote display, and current telephone +connection speed make transmission of megabyte-size images impractical. + +BESSER then discussed ways to deal with these large images, for example, +compression and decompression at the user's end. In this connection, the +issues of how much one is willing to lose in the compression process and +what image quality one needs in the first place are unknown. But what is +known is that compression entails some loss of data. BESSER urged that +more studies be conducted on image quality in different situations, for +example, what kind of images are needed for what kind of disciplines, and +what kind of image quality is needed for a browsing tool, an intermediate +viewing tool, and archiving. + +BESSER remarked two promising trends for compression: from a technical +perspective, algorithms that use what is called subjective redundancy +employ principles from visual psycho-physics to identify and remove +information from the image that the human eye cannot perceive; from an +interchange and interoperability perspective, the JPEG (i.e., Joint +Photographic Experts Group, an ISO standard) compression algorithms also +offer promise. These issues of compression and decompression, BESSER +argued, resembled those raised earlier concerning the design of different +platforms. Gauging the capabilities of potential users constitutes a +primary goal. BESSER advocated layering or separating the images from +the applications that retrieve and display them, to avoid tying them to +particular software. + +BESSER detailed several lessons learned from his work at Berkeley with +Imagequery, especially the advantages and disadvantages of using +X-Windows. In the latter category, for example, retrieval is tied +directly to one's data, an intolerable situation in the long run on a +networked system. Finally, BESSER described a project of Jim Wallace at +the Smithsonian Institution, who is mounting images in a extremely +rudimentary way on the Compuserv and Genie networks and is preparing to +mount them on America On Line. Although the average user takes over +thirty minutes to download these images (assuming a fairly fast modem), +nevertheless, images have been downloaded 25,000 times. + +BESSER concluded his talk with several comments on the business +arrangement between the Smithsonian and Compuserv. He contended that not +enough is known concerning the value of images. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +DISCUSSION * Creating digitized photographic collections nearly +impossible except with large organizations like museums * Need for study +to determine quality of images users will tolerate * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +During the brief exchange between LESK and BESSER that followed, several +clarifications emerged. + +LESK argued that the photographers were far ahead of BESSER: It is +almost impossible to create such digitized photographic collections +except with large organizations like museums, because all the +photographic agencies have been going crazy about this and will not sign +licensing agreements on any sort of reasonable terms. LESK had heard +that National Geographic, for example, had tried to buy the right to use +some image in some kind of educational production for $100 per image, but +the photographers will not touch it. They want accounting and payment +for each use, which cannot be accomplished within the system. BESSER +responded that a consortium of photographers, headed by a former National +Geographic photographer, had started assembling its own collection of +electronic reproductions of images, with the money going back to the +cooperative. + +LESK contended that BESSER was unnecessarily pessimistic about multimedia +images, because people are accustomed to low-quality images, particularly +from video. BESSER urged the launching of a study to determine what +users would tolerate, what they would feel comfortable with, and what +absolutely is the highest quality they would ever need. Conceding that +he had adopted a dire tone in order to arouse people about the issue, +BESSER closed on a sanguine note by saying that he would not be in this +business if he did not think that things could be accomplished. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +LARSEN * Issues of scalability and modularity * Geometric growth of the +Internet and the role played by layering * Basic functions sustaining +this growth * A library's roles and functions in a network environment * +Effects of implementation of the Z39.50 protocol for information +retrieval on the library system * The trade-off between volumes of data +and its potential usage * A snapshot of current trends * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Ronald LARSEN, associate director for information technology, University +of Maryland at College Park, first addressed the issues of scalability +and modularity. He noted the difficulty of anticipating the effects of +orders-of-magnitude growth, reflecting on the twenty years of experience +with the Arpanet and Internet. Recalling the day's demonstrations of +CD-ROM and optical disk material, he went on to ask if the field has yet +learned how to scale new systems to enable delivery and dissemination +across large-scale networks. + +LARSEN focused on the geometric growth of the Internet from its inception +circa 1969 to the present, and the adjustments required to respond to +that rapid growth. To illustrate the issue of scalability, LARSEN +considered computer networks as including three generic components: +computers, network communication nodes, and communication media. Each +component scales (e.g., computers range from PCs to supercomputers; +network nodes scale from interface cards in a PC through sophisticated +routers and gateways; and communication media range from 2,400-baud +dial-up facilities through 4.5-Mbps backbone links, and eventually to +multigigabit-per-second communication lines), and architecturally, the +components are organized to scale hierarchically from local area networks +to international-scale networks. Such growth is made possible by +building layers of communication protocols, as BESSER pointed out. +By layering both physically and logically, a sense of scalability is +maintained from local area networks in offices, across campuses, through +bridges, routers, campus backbones, fiber-optic links, etc., up into +regional networks and ultimately into national and international +networks. + +LARSEN then illustrated the geometric growth over a two-year period-- +through September 1991--of the number of networks that comprise the +Internet. This growth has been sustained largely by the availability of +three basic functions: electronic mail, file transfer (ftp), and remote +log-on (telnet). LARSEN also reviewed the growth in the kind of traffic +that occurs on the network. Network traffic reflects the joint contributions +of a larger population of users and increasing use per user. Today one sees +serious applications involving moving images across the network--a rarity +ten years ago. LARSEN recalled and concurred with BESSER's main point +that the interesting problems occur at the application level. + +LARSEN then illustrated a model of a library's roles and functions in a +network environment. He noted, in particular, the placement of on-line +catalogues onto the network and patrons obtaining access to the library +increasingly through local networks, campus networks, and the Internet. +LARSEN supported LYNCH's earlier suggestion that we need to address +fundamental questions of networked information in order to build +environments that scale in the information sense as well as in the +physical sense. + +LARSEN supported the role of the library system as the access point into +the nation's electronic collections. Implementation of the Z39.50 +protocol for information retrieval would make such access practical and +feasible. For example, this would enable patrons in Maryland to search +California libraries, or other libraries around the world that are +conformant with Z39.50 in a manner that is familiar to University of +Maryland patrons. This client-server model also supports moving beyond +secondary content into primary content. (The notion of how one links +from secondary content to primary content, LARSEN said, represents a +fundamental problem that requires rigorous thought.) After noting +numerous network experiments in accessing full-text materials, including +projects supporting the ordering of materials across the network, LARSEN +revisited the issue of transmitting high-density, high-resolution color +images across the network and the large amounts of bandwidth they +require. He went on to address the bandwidth and synchronization +problems inherent in sending full-motion video across the network. + +LARSEN illustrated the trade-off between volumes of data in bytes or +orders of magnitude and the potential usage of that data. He discussed +transmission rates (particularly, the time it takes to move various forms +of information), and what one could do with a network supporting +multigigabit-per-second transmission. At the moment, the network +environment includes a composite of data-transmission requirements, +volumes and forms, going from steady to bursty (high-volume) and from +very slow to very fast. This aggregate must be considered in the design, +construction, and operation of multigigabyte networks. + +LARSEN's objective is to use the networks and library systems now being +constructed to increase access to resources wherever they exist, and +thus, to evolve toward an on-line electronic virtual library. + +LARSEN concluded by offering a snapshot of current trends: continuing +geometric growth in network capacity and number of users; slower +development of applications; and glacial development and adoption of +standards. The challenge is to design and develop each new application +system with network access and scalability in mind. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +BROWNRIGG * Access to the Internet cannot be taken for granted * Packet +radio and the development of MELVYL in 1980-81 in the Division of Library +Automation at the University of California * Design criteria for packet +radio * A demonstration project in San Diego and future plans * Spread +spectrum * Frequencies at which the radios will run and plans to +reimplement the WAIS server software in the public domain * Need for an +infrastructure of radios that do not move around * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Edwin BROWNRIGG, executive director, Memex Research Institute, first +polled the audience in order to seek out regular users of the Internet as +well as those planning to use it some time in the future. With nearly +everybody in the room falling into one category or the other, BROWNRIGG +made a point re access, namely that numerous individuals, especially those +who use the Internet every day, take for granted their access to it, the +speeds with which they are connected, and how well it all works. +However, as BROWNRIGG discovered between 1987 and 1989 in Australia, +if one wants access to the Internet but cannot afford it or has some +physical boundary that prevents her or him from gaining access, it can +be extremely frustrating. He suggested that because of economics and +physical barriers we were beginning to create a world of haves and have-nots +in the process of scholarly communication, even in the United States. + +BROWNRIGG detailed the development of MELVYL in academic year 1980-81 in +the Division of Library Automation at the University of California, in +order to underscore the issue of access to the system, which at the +outset was extremely limited. In short, the project needed to build a +network, which at that time entailed use of satellite technology, that is, +putting earth stations on campus and also acquiring some terrestrial links +from the State of California's microwave system. The installation of +satellite links, however, did not solve the problem (which actually +formed part of a larger problem involving politics and financial resources). +For while the project team could get a signal onto a campus, it had no means +of distributing the signal throughout the campus. The solution involved +adopting a recent development in wireless communication called packet radio, +which combined the basic notion of packet-switching with radio. The project +used this technology to get the signal from a point on campus where it +came down, an earth station for example, into the libraries, because it +found that wiring the libraries, especially the older marble buildings, +would cost $2,000-$5,000 per terminal. + +BROWNRIGG noted that, ten years ago, the project had neither the public +policy nor the technology that would have allowed it to use packet radio +in any meaningful way. Since then much had changed. He proceeded to +detail research and development of the technology, how it is being +deployed in California, and what direction he thought it would take. +The design criteria are to produce a high-speed, one-time, low-cost, +high-quality, secure, license-free device (packet radio) that one can +plug in and play today, forget about it, and have access to the Internet. +By high speed, BROWNRIGG meant 1 megabyte and 1.5 megabytes. Those units +have been built, he continued, and are in the process of being +type-certified by an independent underwriting laboratory so that they can +be type-licensed by the Federal Communications Commission. As is the +case with citizens band, one will be able to purchase a unit and not have +to worry about applying for a license. + +The basic idea, BROWNRIGG elaborated, is to take high-speed radio data +transmission and create a backbone network that at certain strategic +points in the network will "gateway" into a medium-speed packet radio +(i.e., one that runs at 38.4 kilobytes), so that perhaps by 1994-1995 +people, like those in the audience for the price of a VCR could purchase +a medium-speed radio for the office or home, have full network connectivity +to the Internet, and partake of all its services, with no need for an FCC +license and no regular bill from the local common carrier. BROWNRIGG +presented several details of a demonstration project currently taking +place in San Diego and described plans, pending funding, to install a +full-bore network in the San Francisco area. This network will have 600 +nodes running at backbone speeds, and 100 of these nodes will be libraries, +which in turn will be the gateway ports to the 38.4 kilobyte radios that +will give coverage for the neighborhoods surrounding the libraries. + +BROWNRIGG next explained Part 15.247, a new rule within Title 47 of the +Code of Federal Regulations enacted by the FCC in 1985. This rule +challenged the industry, which has only now risen to the occasion, to +build a radio that would run at no more than one watt of output power and +use a fairly exotic method of modulating the radio wave called spread +spectrum. Spread spectrum in fact permits the building of networks so +that numerous data communications can occur simultaneously, without +interfering with each other, within the same wide radio channel. + +BROWNRIGG explained that the frequencies at which the radios would run +are very short wave signals. They are well above standard microwave and +radar. With a radio wave that small, one watt becomes a tremendous punch +per bit and thus makes transmission at reasonable speed possible. In +order to minimize the potential for congestion, the project is +undertaking to reimplement software which has been available in the +networking business and is taken for granted now, for example, TCP/IP, +routing algorithms, bridges, and gateways. In addition, the project +plans to take the WAIS server software in the public domain and +reimplement it so that one can have a WAIS server on a Mac instead of a +Unix machine. The Memex Research Institute believes that libraries, in +particular, will want to use the WAIS servers with packet radio. This +project, which has a team of about twelve people, will run through 1993 +and will include the 100 libraries already mentioned as well as other +professionals such as those in the medical profession, engineering, and +law. Thus, the need is to create an infrastructure of radios that do not +move around, which, BROWNRIGG hopes, will solve a problem not only for +libraries but for individuals who, by and large today, do not have access +to the Internet from their homes and offices. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +DISCUSSION * Project operating frequencies * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +During a brief discussion period, which also concluded the day's +proceedings, BROWNRIGG stated that the project was operating in four +frequencies. The slow speed is operating at 435 megahertz, and it would +later go up to 920 megahertz. With the high-speed frequency, the +one-megabyte radios will run at 2.4 gigabits, and 1.5 will run at 5.7. +At 5.7, rain can be a factor, but it would have to be tropical rain, +unlike what falls in most parts of the United States. + + ****** + +SESSION IV. IMAGE CAPTURE, TEXT CAPTURE, OVERVIEW OF TEXT AND + IMAGE STORAGE FORMATS + +William HOOTON, vice president of operations, I-NET, moderated this session. + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +KENNEY * Factors influencing development of CXP * Advantages of using +digital technology versus photocopy and microfilm * A primary goal of +CXP; publishing challenges * Characteristics of copies printed * Quality +of samples achieved in image capture * Several factors to be considered +in choosing scanning * Emphasis of CXP on timely and cost-effective +production of black-and-white printed facsimiles * Results of producing +microfilm from digital files * Advantages of creating microfilm * Details +concerning production * Costs * Role of digital technology in library +preservation * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Anne KENNEY, associate director, Department of Preservation and +Conservation, Cornell University, opened her talk by observing that the +Cornell Xerox Project (CXP) has been guided by the assumption that the +ability to produce printed facsimiles or to replace paper with paper +would be important, at least for the present generation of users and +equipment. She described three factors that influenced development of +the project: 1) Because the project has emphasized the preservation of +deteriorating brittle books, the quality of what was produced had to be +sufficiently high to return a paper replacement to the shelf. CXP was +only interested in using: 2) a system that was cost-effective, which +meant that it had to be cost-competitive with the processes currently +available, principally photocopy and microfilm, and 3) new or currently +available product hardware and software. + +KENNEY described the advantages that using digital technology offers over +both photocopy and microfilm: 1) The potential exists to create a higher +quality reproduction of a deteriorating original than conventional +light-lens technology. 2) Because a digital image is an encoded +representation, it can be reproduced again and again with no resulting +loss of quality, as opposed to the situation with light-lens processes, +in which there is discernible difference between a second and a +subsequent generation of an image. 3) A digital image can be manipulated +in a number of ways to improve image capture; for example, Xerox has +developed a windowing application that enables one to capture a page +containing both text and illustrations in a manner that optimizes the +reproduction of both. (With light-lens technology, one must choose which +to optimize, text or the illustration; in preservation microfilming, the +current practice is to shoot an illustrated page twice, once to highlight +the text and the second time to provide the best capture for the +illustration.) 4) A digital image can also be edited, density levels +adjusted to remove underlining and stains, and to increase legibility for +faint documents. 5) On-screen inspection can take place at the time of +initial setup and adjustments made prior to scanning, factors that +substantially reduce the number of retakes required in quality control. + +A primary goal of CXP has been to evaluate the paper output printed on +the Xerox DocuTech, a high-speed printer that produces 600-dpi pages from +scanned images at a rate of 135 pages a minute. KENNEY recounted several +publishing challenges to represent faithful and legible reproductions of +the originals that the 600-dpi copy for the most part successfully +captured. For example, many of the deteriorating volumes in the project +were heavily illustrated with fine line drawings or halftones or came in +languages such as Japanese, in which the buildup of characters comprised +of varying strokes is difficult to reproduce at lower resolutions; a +surprising number of them came with annotations and mathematical +formulas, which it was critical to be able to duplicate exactly. + +KENNEY noted that 1) the copies are being printed on paper that meets the +ANSI standards for performance, 2) the DocuTech printer meets the machine +and toner requirements for proper adhesion of print to page, as described +by the National Archives, and thus 3) paper product is considered to be +the archival equivalent of preservation photocopy. + +KENNEY then discussed several samples of the quality achieved in the +project that had been distributed in a handout, for example, a copy of a +print-on-demand version of the 1911 Reed lecture on the steam turbine, +which contains halftones, line drawings, and illustrations embedded in +text; the first four loose pages in the volume compared the capture +capabilities of scanning to photocopy for a standard test target, the +IEEE standard 167A 1987 test chart. In all instances scanning proved +superior to photocopy, though only slightly more so in one. + +Conceding the simplistic nature of her review of the quality of scanning +to photocopy, KENNEY described it as one representation of the kinds of +settings that could be used with scanning capabilities on the equipment +CXP uses. KENNEY also pointed out that CXP investigated the quality +achieved with binary scanning only, and noted the great promise in gray +scale and color scanning, whose advantages and disadvantages need to be +examined. She argued further that scanning resolutions and file formats +can represent a complex trade-off between the time it takes to capture +material, file size, fidelity to the original, and on-screen display; and +printing and equipment availability. All these factors must be taken +into consideration. + +CXP placed primary emphasis on the production in a timely and +cost-effective manner of printed facsimiles that consisted largely of +black-and-white text. With binary scanning, large files may be +compressed efficiently and in a lossless manner (i.e., no data is lost in +the process of compressing [and decompressing] an image--the exact +bit-representation is maintained) using Group 4 CCITT (i.e., the French +acronym for International Consultative Committee for Telegraph and +Telephone) compression. CXP was getting compression ratios of about +forty to one. Gray-scale compression, which primarily uses JPEG, is much +less economical and can represent a lossy compression (i.e., not +lossless), so that as one compresses and decompresses, the illustration +is subtly changed. While binary files produce a high-quality printed +version, it appears 1) that other combinations of spatial resolution with +gray and/or color hold great promise as well, and 2) that gray scale can +represent a tremendous advantage for on-screen viewing. The quality +associated with binary and gray scale also depends on the equipment used. +For instance, binary scanning produces a much better copy on a binary +printer. + +Among CXP's findings concerning the production of microfilm from digital +files, KENNEY reported that the digital files for the same Reed lecture +were used to produce sample film using an electron beam recorder. The +resulting film was faithful to the image capture of the digital files, +and while CXP felt that the text and image pages represented in the Reed +lecture were superior to that of the light-lens film, the resolution +readings for the 600 dpi were not as high as standard microfilming. +KENNEY argued that the standards defined for light-lens technology are +not totally transferable to a digital environment. Moreover, they are +based on definition of quality for a preservation copy. Although making +this case will prove to be a long, uphill struggle, CXP plans to continue +to investigate the issue over the course of the next year. + +KENNEY concluded this portion of her talk with a discussion of the +advantages of creating film: it can serve as a primary backup and as a +preservation master to the digital file; it could then become the print +or production master and service copies could be paper, film, optical +disks, magnetic media, or on-screen display. + +Finally, KENNEY presented details re production: + + * Development and testing of a moderately-high resolution production + scanning workstation represented a third goal of CXP; to date, 1,000 + volumes have been scanned, or about 300,000 images. + + * The resulting digital files are stored and used to produce + hard-copy replacements for the originals and additional prints on + demand; although the initial costs are high, scanning technology + offers an affordable means for reformatting brittle material. + + * A technician in production mode can scan 300 pages per hour when + performing single-sheet scanning, which is a necessity when working + with truly brittle paper; this figure is expected to increase + significantly with subsequent iterations of the software from Xerox; + a three-month time-and-cost study of scanning found that the average + 300-page book would take about an hour and forty minutes to scan + (this figure included the time for setup, which involves keying in + primary bibliographic data, going into quality control mode to + define page size, establishing front-to-back registration, and + scanning sample pages to identify a default range of settings for + the entire book--functions not dissimilar to those performed by + filmers or those preparing a book for photocopy). + + * The final step in the scanning process involved rescans, which + happily were few and far between, representing well under 1 percent + of the total pages scanned. + +In addition to technician time, CXP costed out equipment, amortized over +four years, the cost of storing and refreshing the digital files every +four years, and the cost of printing and binding, book-cloth binding, a +paper reproduction. The total amounted to a little under $65 per single +300-page volume, with 30 percent overhead included--a figure competitive +with the prices currently charged by photocopy vendors. + +Of course, with scanning, in addition to the paper facsimile, one is left +with a digital file from which subsequent copies of the book can be +produced for a fraction of the cost of photocopy, with readers afforded +choices in the form of these copies. + +KENNEY concluded that digital technology offers an electronic means for a +library preservation effort to pay for itself. If a brittle-book program +included the means of disseminating reprints of books that are in demand +by libraries and researchers alike, the initial investment in capture +could be recovered and used to preserve additional but less popular +books. She disclosed that an economic model for a self-sustaining +program could be developed for CXP's report to the Commission on +Preservation and Access (CPA). + +KENNEY stressed that the focus of CXP has been on obtaining high quality +in a production environment. The use of digital technology is viewed as +an affordable alternative to other reformatting options. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +ANDRE * Overview and history of NATDP * Various agricultural CD-ROM +products created inhouse and by service bureaus * Pilot project on +Internet transmission * Additional products in progress * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Pamela ANDRE, associate director for automation, National Agricultural +Text Digitizing Program (NATDP), National Agricultural Library (NAL), +presented an overview of NATDP, which has been underway at NAL the last +four years, before Judith ZIDAR discussed the technical details. ANDRE +defined agricultural information as a broad range of material going from +basic and applied research in the hard sciences to the one-page pamphlets +that are distributed by the cooperative state extension services on such +things as how to grow blueberries. + +NATDP began in late 1986 with a meeting of representatives from the +land-grant library community to deal with the issue of electronic +information. NAL and forty-five of these libraries banded together to +establish this project--to evaluate the technology for converting what +were then source documents in paper form into electronic form, to provide +access to that digital information, and then to distribute it. +Distributing that material to the community--the university community as +well as the extension service community, potentially down to the county +level--constituted the group's chief concern. + +Since January 1988 (when the microcomputer-based scanning system was +installed at NAL), NATDP has done a variety of things, concerning which +ZIDAR would provide further details. For example, the first technology +considered in the project's discussion phase was digital videodisc, which +indicates how long ago it was conceived. + +Over the four years of this project, four separate CD-ROM products on +four different agricultural topics were created, two at a +scanning-and-OCR station installed at NAL, and two by service bureaus. +Thus, NATDP has gained comparative information in terms of those relative +costs. Each of these products contained the full ASCII text as well as +page images of the material, or between 4,000 and 6,000 pages of material +on these disks. Topics included aquaculture, food, agriculture and +science (i.e., international agriculture and research), acid rain, and +Agent Orange, which was the final product distributed (approximately +eighteen months before the Workshop). + +The third phase of NATDP focused on delivery mechanisms other than +CD-ROM. At the suggestion of Clifford LYNCH, who was a technical +consultant to the project at this point, NATDP became involved with the +Internet and initiated a project with the help of North Carolina State +University, in which fourteen of the land-grant university libraries are +transmitting digital images over the Internet in response to interlibrary +loan requests--a topic for another meeting. At this point, the pilot +project had been completed for about a year and the final report would be +available shortly after the Workshop. In the meantime, the project's +success had led to its extension. (ANDRE noted that one of the first +things done under the program title was to select a retrieval package to +use with subsequent products; Windows Personal Librarian was the package +of choice after a lengthy evaluation.) + +Three additional products had been planned and were in progress: + + 1) An arrangement with the American Society of Agronomy--a + professional society that has published the Agronomy Journal since + about 1908--to scan and create bit-mapped images of its journal. + ASA granted permission first to put and then to distribute this + material in electronic form, to hold it at NAL, and to use these + electronic images as a mechanism to deliver documents or print out + material for patrons, among other uses. Effectively, NAL has the + right to use this material in support of its program. + (Significantly, this arrangement offers a potential cooperative + model for working with other professional societies in agriculture + to try to do the same thing--put the journals of particular interest + to agriculture research into electronic form.) + + 2) An extension of the earlier product on aquaculture. + + 3) The George Washington Carver Papers--a joint project with + Tuskegee University to scan and convert from microfilm some 3,500 + images of Carver's papers, letters, and drawings. + +It was anticipated that all of these products would appear no more than +six months after the Workshop. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +ZIDAR * (A separate arena for scanning) * Steps in creating a database * +Image capture, with and without performing OCR * Keying in tracking data +* Scanning, with electronic and manual tracking * Adjustments during +scanning process * Scanning resolutions * Compression * De-skewing and +filtering * Image capture from microform: the papers and letters of +George Washington Carver * Equipment used for a scanning system * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Judith ZIDAR, coordinator, National Agricultural Text Digitizing Program +(NATDP), National Agricultural Library (NAL), illustrated the technical +details of NATDP, including her primary responsibility, scanning and +creating databases on a topic and putting them on CD-ROM. + +(ZIDAR remarked a separate arena from the CD-ROM projects, although the +processing of the material is nearly identical, in which NATDP is also +scanning material and loading it on a Next microcomputer, which in turn +is linked to NAL's integrated library system. Thus, searches in NAL's +bibliographic database will enable people to pull up actual page images +and text for any documents that have been entered.) + +In accordance with the session's topic, ZIDAR focused her illustrated +talk on image capture, offering a primer on the three main steps in the +process: 1) assemble the printed publications; 2) design the database +(database design occurs in the process of preparing the material for +scanning; this step entails reviewing and organizing the material, +defining the contents--what will constitute a record, what kinds of +fields will be captured in terms of author, title, etc.); 3) perform a +certain amount of markup on the paper publications. NAL performs this +task record by record, preparing work sheets or some other sort of +tracking material and designing descriptors and other enhancements to be +added to the data that will not be captured from the printed publication. +Part of this process also involves determining NATDP's file and directory +structure: NATDP attempts to avoid putting more than approximately 100 +images in a directory, because placing more than that on a CD-ROM would +reduce the access speed. + +This up-front process takes approximately two weeks for a +6,000-7,000-page database. The next step is to capture the page images. +How long this process takes is determined by the decision whether or not +to perform OCR. Not performing OCR speeds the process, whereas text +capture requires greater care because of the quality of the image: it +has to be straighter and allowance must be made for text on a page, not +just for the capture of photographs. + +NATDP keys in tracking data, that is, a standard bibliographic record +including the title of the book and the title of the chapter, which will +later either become the access information or will be attached to the +front of a full-text record so that it is searchable. + +Images are scanned from a bound or unbound publication, chiefly from +bound publications in the case of NATDP, however, because often they are +the only copies and the publications are returned to the shelves. NATDP +usually scans one record at a time, because its database tracking system +tracks the document in that way and does not require further logical +separating of the images. After performing optical character +recognition, NATDP moves the images off the hard disk and maintains a +volume sheet. Though the system tracks electronically, all the +processing steps are also tracked manually with a log sheet. + +ZIDAR next illustrated the kinds of adjustments that one can make when +scanning from paper and microfilm, for example, redoing images that need +special handling, setting for dithering or gray scale, and adjusting for +brightness or for the whole book at one time. + +NATDP is scanning at 300 dots per inch, a standard scanning resolution. +Though adequate for capturing text that is all of a standard size, 300 +dpi is unsuitable for any kind of photographic material or for very small +text. Many scanners allow for different image formats, TIFF, of course, +being a de facto standard. But if one intends to exchange images with +other people, the ability to scan other image formats, even if they are +less common, becomes highly desirable. + +CCITT Group 4 is the standard compression for normal black-and-white +images, JPEG for gray scale or color. ZIDAR recommended 1) using the +standard compressions, particularly if one attempts to make material +available and to allow users to download images and reuse them from +CD-ROMs; and 2) maintaining the ability to output an uncompressed image, +because in image exchange uncompressed images are more likely to be able +to cross platforms. + +ZIDAR emphasized the importance of de-skewing and filtering as +requirements on NATDP's upgraded system. For instance, scanning bound +books, particularly books published by the federal government whose pages +are skewed, and trying to scan them straight if OCR is to be performed, +is extremely time-consuming. The same holds for filtering of +poor-quality or older materials. + +ZIDAR described image capture from microform, using as an example three +reels from a sixty-seven-reel set of the papers and letters of George +Washington Carver that had been produced by Tuskegee University. These +resulted in approximately 3,500 images, which NATDP had had scanned by +its service contractor, Science Applications International Corporation +(SAIC). NATDP also created bibliographic records for access. (NATDP did +not have such specialized equipment as a microfilm scanner. + +Unfortunately, the process of scanning from microfilm was not an +unqualified success, ZIDAR reported: because microfilm frame sizes vary, +occasionally some frames were missed, which without spending much time +and money could not be recaptured. + +OCR could not be performed from the scanned images of the frames. The +bleeding in the text simply output text, when OCR was run, that could not +even be edited. NATDP tested for negative versus positive images, +landscape versus portrait orientation, and single- versus dual-page +microfilm, none of which seemed to affect the quality of the image; but +also on none of them could OCR be performed. + +In selecting the microfilm they would use, therefore, NATDP had other +factors in mind. ZIDAR noted two factors that influenced the quality of +the images: 1) the inherent quality of the original and 2) the amount of +size reduction on the pages. + +The Carver papers were selected because they are informative and visually +interesting, treat a single subject, and are valuable in their own right. +The images were scanned and divided into logical records by SAIC, then +delivered, and loaded onto NATDP's system, where bibliographic +information taken directly from the images was added. Scanning was +completed in summer 1991 and by the end of summer 1992 the disk was +scheduled to be published. + +Problems encountered during processing included the following: Because +the microfilm scanning had to be done in a batch, adjustment for +individual page variations was not possible. The frame size varied on +account of the nature of the material, and therefore some of the frames +were missed while others were just partial frames. The only way to go +back and capture this material was to print out the page with the +microfilm reader from the missing frame and then scan it in from the +page, which was extremely time-consuming. The quality of the images +scanned from the printout of the microfilm compared unfavorably with that +of the original images captured directly from the microfilm. The +inability to perform OCR also was a major disappointment. At the time, +computer output microfilm was unavailable to test. + +The equipment used for a scanning system was the last topic addressed by +ZIDAR. The type of equipment that one would purchase for a scanning +system included: a microcomputer, at least a 386, but preferably a 486; +a large hard disk, 380 megabyte at minimum; a multi-tasking operating +system that allows one to run some things in batch in the background +while scanning or doing text editing, for example, Unix or OS/2 and, +theoretically, Windows; a high-speed scanner and scanning software that +allows one to make the various adjustments mentioned earlier; a +high-resolution monitor (150 dpi ); OCR software and hardware to perform +text recognition; an optical disk subsystem on which to archive all the +images as the processing is done; file management and tracking software. + +ZIDAR opined that the software one purchases was more important than the +hardware and might also cost more than the hardware, but it was likely to +prove critical to the success or failure of one's system. In addition to +a stand-alone scanning workstation for image capture, then, text capture +requires one or two editing stations networked to this scanning station +to perform editing. Editing the text takes two or three times as long as +capturing the images. + +Finally, ZIDAR stressed the importance of buying an open system that allows +for more than one vendor, complies with standards, and can be upgraded. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +WATERS *Yale University Library's master plan to convert microfilm to +digital imagery (POB) * The place of electronic tools in the library of +the future * The uses of images and an image library * Primary input from +preservation microfilm * Features distinguishing POB from CXP and key +hypotheses guiding POB * Use of vendor selection process to facilitate +organizational work * Criteria for selecting vendor * Finalists and +results of process for Yale * Key factor distinguishing vendors * +Components, design principles, and some estimated costs of POB * Role of +preservation materials in developing imaging market * Factors affecting +quality and cost * Factors affecting the usability of complex documents +in image form * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Donald WATERS, head of the Systems Office, Yale University Library, +reported on the progress of a master plan for a project at Yale to +convert microfilm to digital imagery, Project Open Book (POB). Stating +that POB was in an advanced stage of planning, WATERS detailed, in +particular, the process of selecting a vendor partner and several key +issues under discussion as Yale prepares to move into the project itself. +He commented first on the vision that serves as the context of POB and +then described its purpose and scope. + +WATERS sees the library of the future not necessarily as an electronic +library but as a place that generates, preserves, and improves for its +clients ready access to both intellectual and physical recorded +knowledge. Electronic tools must find a place in the library in the +context of this vision. Several roles for electronic tools include +serving as: indirect sources of electronic knowledge or as "finding" +aids (the on-line catalogues, the article-level indices, registers for +documents and archives); direct sources of recorded knowledge; full-text +images; and various kinds of compound sources of recorded knowledge (the +so-called compound documents of Hypertext, mixed text and image, +mixed-text image format, and multimedia). + +POB is looking particularly at images and an image library, the uses to +which images will be put (e.g., storage, printing, browsing, and then use +as input for other processes), OCR as a subsequent process to image +capture, or creating an image library, and also possibly generating +microfilm. + +While input will come from a variety of sources, POB is considering +especially input from preservation microfilm. A possible outcome is that +the film and paper which provide the input for the image library +eventually may go off into remote storage, and that the image library may +be the primary access tool. + +The purpose and scope of POB focus on imaging. Though related to CXP, +POB has two features which distinguish it: 1) scale--conversion of +10,000 volumes into digital image form; and 2) source--conversion from +microfilm. Given these features, several key working hypotheses guide +POB, including: 1) Since POB is using microfilm, it is not concerned with +the image library as a preservation medium. 2) Digital imagery can improve +access to recorded knowledge through printing and network distribution at +a modest incremental cost of microfilm. 3) Capturing and storing documents +in a digital image form is necessary to further improvements in access. +(POB distinguishes between the imaging, digitizing process and OCR, +which at this stage it does not plan to perform.) + +Currently in its first or organizational phase, POB found that it could +use a vendor selection process to facilitate a good deal of the +organizational work (e.g., creating a project team and advisory board, +confirming the validity of the plan, establishing the cost of the project +and a budget, selecting the materials to convert, and then raising the +necessary funds). + +POB developed numerous selection criteria, including: a firm committed +to image-document management, the ability to serve as systems integrator +in a large-scale project over several years, interest in developing the +requisite software as a standard rather than a custom product, and a +willingness to invest substantial resources in the project itself. + +Two vendors, DEC and Xerox, were selected as finalists in October 1991, +and with the support of the Commission on Preservation and Access, each +was commissioned to generate a detailed requirements analysis for the +project and then to submit a formal proposal for the completion of the +project, which included a budget and costs. The terms were that POB would +pay the loser. The results for Yale of involving a vendor included: +broad involvement of Yale staff across the board at a relatively low +cost, which may have long-term significance in carrying out the project +(twenty-five to thirty university people are engaged in POB); better +understanding of the factors that affect corporate response to markets +for imaging products; a competitive proposal; and a more sophisticated +view of the imaging markets. + +The most important factor that distinguished the vendors under +consideration was their identification with the customer. The size and +internal complexity of the company also was an important factor. POB was +looking at large companies that had substantial resources. In the end, +the process generated for Yale two competitive proposals, with Xerox's +the clear winner. WATERS then described the components of the proposal, +the design principles, and some of the costs estimated for the process. + +Components are essentially four: a conversion subsystem, a +network-accessible storage subsystem for 10,000 books (and POB expects +200 to 600 dpi storage), browsing stations distributed on the campus +network, and network access to the image printers. + +Among the design principles, POB wanted conversion at the highest +possible resolution. Assuming TIFF files, TIFF files with Group 4 +compression, TCP/IP, and ethernet network on campus, POB wanted a +client-server approach with image documents distributed to the +workstations and made accessible through native workstation interfaces +such as Windows. POB also insisted on a phased approach to +implementation: 1) a stand-alone, single-user, low-cost entry into the +business with a workstation focused on conversion and allowing POB to +explore user access; 2) movement into a higher-volume conversion with +network-accessible storage and multiple access stations; and 3) a +high-volume conversion, full-capacity storage, and multiple browsing +stations distributed throughout the campus. + +The costs proposed for start-up assumed the existence of the Yale network +and its two DocuTech image printers. Other start-up costs are estimated +at $1 million over the three phases. At the end of the project, the annual +operating costs estimated primarily for the software and hardware proposed +come to about $60,000, but these exclude costs for labor needed in the +conversion process, network and printer usage, and facilities management. + +Finally, the selection process produced for Yale a more sophisticated +view of the imaging markets: the management of complex documents in +image form is not a preservation problem, not a library problem, but a +general problem in a broad, general industry. Preservation materials are +useful for developing that market because of the qualities of the +material. For example, much of it is out of copyright. The resolution +of key issues such as the quality of scanning and image browsing also +will affect development of that market. + +The technology is readily available but changing rapidly. In this +context of rapid change, several factors affect quality and cost, to +which POB intends to pay particular attention, for example, the various +levels of resolution that can be achieved. POB believes it can bring +resolution up to 600 dpi, but an interpolation process from 400 to 600 is +more likely. The variation quality in microfilm will prove to be a +highly important factor. POB may reexamine the standards used to film in +the first place by looking at this process as a follow-on to microfilming. + +Other important factors include: the techniques available to the +operator for handling material, the ways of integrating quality control +into the digitizing work flow, and a work flow that includes indexing and +storage. POB's requirement was to be able to deal with quality control +at the point of scanning. Thus, thanks to Xerox, POB anticipates having +a mechanism which will allow it not only to scan in batch form, but to +review the material as it goes through the scanner and control quality +from the outset. + +The standards for measuring quality and costs depend greatly on the uses +of the material, including subsequent OCR, storage, printing, and +browsing. But especially at issue for POB is the facility for browsing. +This facility, WATERS said, is perhaps the weakest aspect of imaging +technology and the most in need of development. + +A variety of factors affect the usability of complex documents in image +form, among them: 1) the ability of the system to handle the full range +of document types, not just monographs but serials, multi-part +monographs, and manuscripts; 2) the location of the database of record +for bibliographic information about the image document, which POB wants +to enter once and in the most useful place, the on-line catalog; 3) a +document identifier for referencing the bibliographic information in one +place and the images in another; 4) the technique for making the basic +internal structure of the document accessible to the reader; and finally, +5) the physical presentation on the CRT of those documents. POB is ready +to complete this phase now. One last decision involves deciding which +material to scan. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +DISCUSSION * TIFF files constitute de facto standard * NARA's experience +with image conversion software and text conversion * RFC 1314 * +Considerable flux concerning available hardware and software solutions * +NAL through-put rate during scanning * Window management questions * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +In the question-and-answer period that followed WATERS's presentation, +the following points emerged: + + * ZIDAR's statement about using TIFF files as a standard meant de + facto standard. This is what most people use and typically exchange + with other groups, across platforms, or even occasionally across + display software. + + * HOLMES commented on the unsuccessful experience of NARA in + attempting to run image-conversion software or to exchange between + applications: What are supposedly TIFF files go into other software + that is supposed to be able to accept TIFF but cannot recognize the + format and cannot deal with it, and thus renders the exchange + useless. Re text conversion, he noted the different recognition + rates obtained by substituting the make and model of scanners in + NARA's recent test of an "intelligent" character-recognition product + for a new company. In the selection of hardware and software, + HOLMES argued, software no longer constitutes the overriding factor + it did until about a year ago; rather it is perhaps important to + look at both now. + + * Danny Cohen and Alan Katz of the University of Southern California + Information Sciences Institute began circulating as an Internet RFC + (RFC 1314) about a month ago a standard for a TIFF interchange + format for Internet distribution of monochrome bit-mapped images, + which LYNCH said he believed would be used as a de facto standard. + + * FLEISCHHAUER's impression from hearing these reports and thinking + about AM's experience was that there is considerable flux concerning + available hardware and software solutions. HOOTON agreed and + commented at the same time on ZIDAR's statement that the equipment + employed affects the results produced. One cannot draw a complete + conclusion by saying it is difficult or impossible to perform OCR + from scanning microfilm, for example, with that device, that set of + parameters, and system requirements, because numerous other people + are accomplishing just that, using other components, perhaps. + HOOTON opined that both the hardware and the software were highly + important. Most of the problems discussed today have been solved in + numerous different ways by other people. Though it is good to be + cognizant of various experiences, this is not to say that it will + always be thus. + + * At NAL, the through-put rate of the scanning process for paper, + page by page, performing OCR, ranges from 300 to 600 pages per day; + not performing OCR is considerably faster, although how much faster + is not known. This is for scanning from bound books, which is much + slower. + + * WATERS commented on window management questions: DEC proposed an + X-Windows solution which was problematical for two reasons. One was + POB's requirement to be able to manipulate images on the workstation + and bring them down to the workstation itself and the other was + network usage. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +THOMA * Illustration of deficiencies in scanning and storage process * +Image quality in this process * Different costs entailed by better image +quality * Techniques for overcoming various de-ficiencies: fixed +thresholding, dynamic thresholding, dithering, image merge * Page edge +effects * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +George THOMA, chief, Communications Engineering Branch, National Library +of Medicine (NLM), illustrated several of the deficiencies discussed by +the previous speakers. He introduced the topic of special problems by +noting the advantages of electronic imaging. For example, it is regenerable +because it is a coded file, and real-time quality control is possible with +electronic capture, whereas in photographic capture it is not. + +One of the difficulties discussed in the scanning and storage process was +image quality which, without belaboring the obvious, means different +things for maps, medical X-rays, or broadcast television. In the case of +documents, THOMA said, image quality boils down to legibility of the +textual parts, and fidelity in the case of gray or color photo print-type +material. Legibility boils down to scan density, the standard in most +cases being 300 dpi. Increasing the resolution with scanners that +perform 600 or 1200 dpi, however, comes at a cost. + +Better image quality entails at least four different kinds of costs: 1) +equipment costs, because the CCD (i.e., charge-couple device) with +greater number of elements costs more; 2) time costs that translate to +the actual capture costs, because manual labor is involved (the time is +also dependent on the fact that more data has to be moved around in the +machine in the scanning or network devices that perform the scanning as +well as the storage); 3) media costs, because at high resolutions larger +files have to be stored; and 4) transmission costs, because there is just +more data to be transmitted. + +But while resolution takes care of the issue of legibility in image +quality, other deficiencies have to do with contrast and elements on the +page scanned or the image that needed to be removed or clarified. Thus, +THOMA proceeded to illustrate various deficiencies, how they are +manifested, and several techniques to overcome them. + +Fixed thresholding was the first technique described, suitable for +black-and-white text, when the contrast does not vary over the page. One +can have many different threshold levels in scanning devices. Thus, +THOMA offered an example of extremely poor contrast, which resulted from +the fact that the stock was a heavy red. This is the sort of image that +when microfilmed fails to provide any legibility whatsoever. Fixed +thresholding is the way to change the black-to-red contrast to the +desired black-to-white contrast. + +Other examples included material that had been browned or yellowed by +age. This was also a case of contrast deficiency, and correction was +done by fixed thresholding. A final example boils down to the same +thing, slight variability, but it is not significant. Fixed thresholding +solves this problem as well. The microfilm equivalent is certainly legible, +but it comes with dark areas. Though THOMA did not have a slide of the +microfilm in this case, he did show the reproduced electronic image. + +When one has variable contrast over a page or the lighting over the page +area varies, especially in the case where a bound volume has light +shining on it, the image must be processed by a dynamic thresholding +scheme. One scheme, dynamic averaging, allows the threshold level not to +be fixed but to be recomputed for every pixel from the neighboring +characteristics. The neighbors of a pixel determine where the threshold +should be set for that pixel. + +THOMA showed an example of a page that had been made deficient by a +variety of techniques, including a burn mark, coffee stains, and a yellow +marker. Application of a fixed-thresholding scheme, THOMA argued, might +take care of several deficiencies on the page but not all of them. +Performing the calculation for a dynamic threshold setting, however, +removes most of the deficiencies so that at least the text is legible. + +Another problem is representing a gray level with black-and-white pixels +by a process known as dithering or electronic screening. But dithering +does not provide good image quality for pure black-and-white textual +material. THOMA illustrated this point with examples. Although its +suitability for photoprint is the reason for electronic screening or +dithering, it cannot be used for every compound image. In the document +that was distributed by CXP, THOMA noticed that the dithered image of the +IEEE test chart evinced some deterioration in the text. He presented an +extreme example of deterioration in the text in which compounded +documents had to be set right by other techniques. The technique +illustrated by the present example was an image merge in which the page +is scanned twice and the settings go from fixed threshold to the +dithering matrix; the resulting images are merged to give the best +results with each technique. + +THOMA illustrated how dithering is also used in nonphotographic or +nonprint materials with an example of a grayish page from a medical text, +which was reproduced to show all of the gray that appeared in the +original. Dithering provided a reproduction of all the gray in the +original of another example from the same text. + +THOMA finally illustrated the problem of bordering, or page-edge, +effects. Books and bound volumes that are placed on a photocopy machine +or a scanner produce page-edge effects that are undesirable for two +reasons: 1) the aesthetics of the image; after all, if the image is to +be preserved, one does not necessarily want to keep all of its +deficiencies; 2) compression (with the bordering problem THOMA +illustrated, the compression ratio deteriorated tremendously). One way +to eliminate this more serious problem is to have the operator at the +point of scanning window the part of the image that is desirable and +automatically turn all of the pixels out of that picture to white. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +FLEISCHHAUER * AM's experience with scanning bound materials * Dithering +* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Carl FLEISCHHAUER, coordinator, American Memory, Library of Congress, +reported AM's experience with scanning bound materials, which he likened +to the problems involved in using photocopying machines. Very few +devices in the industry offer book-edge scanning, let alone book cradles. +The problem may be unsolvable, FLEISCHHAUER said, because a large enough +market does not exist for a preservation-quality scanner. AM is using a +Kurzweil scanner, which is a book-edge scanner now sold by Xerox. + +Devoting the remainder of his brief presentation to dithering, +FLEISCHHAUER related AM's experience with a contractor who was using +unsophisticated equipment and software to reduce moire patterns from +printed halftones. AM took the same image and used the dithering +algorithm that forms part of the same Kurzweil Xerox scanner; it +disguised moire patterns much more effectively. + +FLEISCHHAUER also observed that dithering produces a binary file which is +useful for numerous purposes, for example, printing it on a laser printer +without having to "re-halftone" it. But it tends to defeat efficient +compression, because the very thing that dithers to reduce moire patterns +also tends to work against compression schemes. AM thought the +difference in image quality was worth it. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +DISCUSSION * Relative use as a criterion for POB's selection of books to +be converted into digital form * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +During the discussion period, WATERS noted that one of the criteria for +selecting books among the 10,000 to be converted into digital image form +would be how much relative use they would receive--a subject still +requiring evaluation. The challenge will be to understand whether +coherent bodies of material will increase usage or whether POB should +seek material that is being used, scan that, and make it more accessible. +POB might decide to digitize materials that are already heavily used, in +order to make them more accessible and decrease wear on them. Another +approach would be to provide a large body of intellectually coherent +material that may be used more in digital form than it is currently used +in microfilm. POB would seek material that was out of copyright. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +BARONAS * Origin and scope of AIIM * Types of documents produced in +AIIM's standards program * Domain of AIIM's standardization work * AIIM's +structure * TC 171 and MS23 * Electronic image management standards * +Categories of EIM standardization where AIIM standards are being +developed * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Jean BARONAS, senior manager, Department of Standards and Technology, +Association for Information and Image Management (AIIM), described the +not-for-profit association and the national and international programs +for standardization in which AIIM is active. + +Accredited for twenty-five years as the nation's standards development +organization for document image management, AIIM began life in a library +community developing microfilm standards. Today the association +maintains both its library and business-image management standardization +activities--and has moved into electronic image-management +standardization (EIM). + +BARONAS defined the program's scope. AIIM deals with: 1) the +terminology of standards and of the technology it uses; 2) methods of +measurement for the systems, as well as quality; 3) methodologies for +users to evaluate and measure quality; 4) the features of apparatus used +to manage and edit images; and 5) the procedures used to manage images. + +BARONAS noted that three types of documents are produced in the AIIM +standards program: the first two, accredited by the American National +Standards Institute (ANSI), are standards and standard recommended +practices. Recommended practices differ from standards in that they +contain more tutorial information. A technical report is not an ANSI +standard. Because AIIM's policies and procedures for developing +standards are approved by ANSI, its standards are labeled ANSI/AIIM, +followed by the number and title of the standard. + +BARONAS then illustrated the domain of AIIM's standardization work. For +example, AIIM is the administrator of the U.S. Technical Advisory Group +(TAG) to the International Standards Organization's (ISO) technical +committee, TC l7l Micrographics and Optical Memories for Document and +Image Recording, Storage, and Use. AIIM officially works through ANSI in +the international standardization process. + +BARONAS described AIIM's structure, including its board of directors, its +standards board of twelve individuals active in the image-management +industry, its strategic planning and legal admissibility task forces, and +its National Standards Council, which is comprised of the members of a +number of organizations who vote on every AIIM standard before it is +published. BARONAS pointed out that AIIM's liaisons deal with numerous +other standards developers, including the optical disk community, office +and publishing systems, image-codes-and-character set committees, and the +National Information Standards Organization (NISO). + +BARONAS illustrated the procedures of TC l7l, which covers all aspects of +image management. When AIIM's national program has conceptualized a new +project, it is usually submitted to the international level, so that the +member countries of TC l7l can simultaneously work on the development of +the standard or the technical report. BARONAS also illustrated a classic +microfilm standard, MS23, which deals with numerous imaging concepts that +apply to electronic imaging. Originally developed in the l970s, revised +in the l980s, and revised again in l991, this standard is scheduled for +another revision. MS23 is an active standard whereby users may propose +new density ranges and new methods of evaluating film images in the +standard's revision. + +BARONAS detailed several electronic image-management standards, for +instance, ANSI/AIIM MS44, a quality-control guideline for scanning 8.5" +by 11" black-and-white office documents. This standard is used with the +IEEE fax image--a continuous tone photographic image with gray scales, +text, and several continuous tone pictures--and AIIM test target number +2, a representative document used in office document management. + +BARONAS next outlined the four categories of EIM standardization in which +AIIM standards are being developed: transfer and retrieval, evaluation, +optical disc and document scanning applications, and design and +conversion of documents. She detailed several of the main projects of +each: 1) in the category of image transfer and retrieval, a bi-level +image transfer format, ANSI/AIIM MS53, which is a proposed standard that +describes a file header for image transfer between unlike systems when +the images are compressed using G3 and G4 compression; 2) the category of +image evaluation, which includes the AIIM-proposed TR26 tutorial on image +resolution (this technical report will treat the differences and +similarities between classical or photographic and electronic imaging); +3) design and conversion, which includes a proposed technical report +called "Forms Design Optimization for EIM" (this report considers how +general-purpose business forms can be best designed so that scanning is +optimized; reprographic characteristics such as type, rules, background, +tint, and color will likewise be treated in the technical report); 4) +disk and document scanning applications includes a project a) on planning +platters and disk management, b) on generating an application profile for +EIM when images are stored and distributed on CD-ROM, and c) on +evaluating SCSI2, and how a common command set can be generated for SCSI2 +so that document scanners are more easily integrated. (ANSI/AIIM MS53 +will also apply to compressed images.) + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +BATTIN * The implications of standards for preservation * A major +obstacle to successful cooperation * A hindrance to access in the digital +environment * Standards a double-edged sword for those concerned with the +preservation of the human record * Near-term prognosis for reliable +archival standards * Preservation concerns for electronic media * Need +for reconceptualizing our preservation principles * Standards in the real +world and the politics of reproduction * Need to redefine the concept of +archival and to begin to think in terms of life cycles * Cooperation and +the La Guardia Eight * Concerns generated by discussions on the problems +of preserving text and image * General principles to be adopted in a +world without standards * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Patricia BATTIN, president, the Commission on Preservation and Access +(CPA), addressed the implications of standards for preservation. She +listed several areas where the library profession and the analog world of +the printed book had made enormous contributions over the past hundred +years--for example, in bibliographic formats, binding standards, and, most +important, in determining what constitutes longevity or archival quality. + +Although standards have lightened the preservation burden through the +development of national and international collaborative programs, +nevertheless, a pervasive mistrust of other people's standards remains a +major obstacle to successful cooperation, BATTIN said. + +The zeal to achieve perfection, regardless of the cost, has hindered +rather than facilitated access in some instances, and in the digital +environment, where no real standards exist, has brought an ironically +just reward. + +BATTIN argued that standards are a double-edged sword for those concerned +with the preservation of the human record, that is, the provision of +access to recorded knowledge in a multitude of media as far into the +future as possible. Standards are essential to facilitate +interconnectivity and access, but, BATTIN said, as LYNCH pointed out +yesterday, if set too soon they can hinder creativity, expansion of +capability, and the broadening of access. The characteristics of +standards for digital imagery differ radically from those for analog +imagery. And the nature of digital technology implies continuing +volatility and change. To reiterate, precipitous standard-setting can +inhibit creativity, but delayed standard-setting results in chaos. + +Since in BATTIN'S opinion the near-term prognosis for reliable archival +standards, as defined by librarians in the analog world, is poor, two +alternatives remain: standing pat with the old technology, or +reconceptualizing. + +Preservation concerns for electronic media fall into two general domains. +One is the continuing assurance of access to knowledge originally +generated, stored, disseminated, and used in electronic form. This +domain contains several subdivisions, including 1) the closed, +proprietary systems discussed the previous day, bundled information such +as electronic journals and government agency records, and electronically +produced or captured raw data; and 2) the application of digital +technologies to the reformatting of materials originally published on a +deteriorating analog medium such as acid paper or videotape. + +The preservation of electronic media requires a reconceptualizing of our +preservation principles during a volatile, standardless transition which +may last far longer than any of us envision today. BATTIN urged the +necessity of shifting focus from assessing, measuring, and setting +standards for the permanence of the medium to the concept of managing +continuing access to information stored on a variety of media and +requiring a variety of ever-changing hardware and software for access--a +fundamental shift for the library profession. + +BATTIN offered a primer on how to move forward with reasonable confidence +in a world without standards. Her comments fell roughly into two sections: +1) standards in the real world and 2) the politics of reproduction. + +In regard to real-world standards, BATTIN argued the need to redefine the +concept of archive and to begin to think in terms of life cycles. In +the past, the naive assumption that paper would last forever produced a +cavalier attitude toward life cycles. The transient nature of the +electronic media has compelled people to recognize and accept upfront the +concept of life cycles in place of permanency. + +Digital standards have to be developed and set in a cooperative context +to ensure efficient exchange of information. Moreover, during this +transition period, greater flexibility concerning how concepts such as +backup copies and archival copies in the CXP are defined is necessary, +or the opportunity to move forward will be lost. + +In terms of cooperation, particularly in the university setting, BATTIN +also argued the need to avoid going off in a hundred different +directions. The CPA has catalyzed a small group of universities called +the La Guardia Eight--because La Guardia Airport is where meetings take +place--Harvard, Yale, Cornell, Princeton, Penn State, Tennessee, +Stanford, and USC, to develop a digital preservation consortium to look +at all these issues and develop de facto standards as we move along, +instead of waiting for something that is officially blessed. Continuing +to apply analog values and definitions of standards to the digital +environment, BATTIN said, will effectively lead to forfeiture of the +benefits of digital technology to research and scholarship. + +Under the second rubric, the politics of reproduction, BATTIN reiterated +an oft-made argument concerning the electronic library, namely, that it +is more difficult to transform than to create, and nowhere is that belief +expressed more dramatically than in the conversion of brittle books to +new media. Preserving information published in electronic media involves +making sure the information remains accessible and that digital +information is not lost through reproduction. In the analog world of +photocopies and microfilm, the issue of fidelity to the original becomes +paramount, as do issues of "Whose fidelity?" and "Whose original?" + +BATTIN elaborated these arguments with a few examples from a recent study +conducted by the CPA on the problems of preserving text and image. +Discussions with scholars, librarians, and curators in a variety of +disciplines dependent on text and image generated a variety of concerns, +for example: 1) Copy what is, not what the technology is capable of. +This is very important for the history of ideas. Scholars wish to know +what the author saw and worked from. And make available at the +workstation the opportunity to erase all the defects and enhance the +presentation. 2) The fidelity of reproduction--what is good enough, what +can we afford, and the difference it makes--issues of subjective versus +objective resolution. 3) The differences between primary and secondary +users. Restricting the definition of primary user to the one in whose +discipline the material has been published runs one headlong into the +reality that these printed books have had a host of other users from a +host of other disciplines, who not only were looking for very different +things, but who also shared values very different from those of the +primary user. 4) The relationship of the standard of reproduction to new +capabilities of scholarship--the browsing standard versus an archival +standard. How good must the archival standard be? Can a distinction be +drawn between potential users in setting standards for reproduction? +Archival storage, use copies, browsing copies--ought an attempt to set +standards even be made? 5) Finally, costs. How much are we prepared to +pay to capture absolute fidelity? What are the trade-offs between vastly +enhanced access, degrees of fidelity, and costs? + +These standards, BATTIN concluded, serve to complicate further the +reproduction process, and add to the long list of technical standards +that are necessary to ensure widespread access. Ways to articulate and +analyze the costs that are attached to the different levels of standards +must be found. + +Given the chaos concerning standards, which promises to linger for the +foreseeable future, BATTIN urged adoption of the following general +principles: + + * Strive to understand the changing information requirements of + scholarly disciplines as more and more technology is integrated into + the process of research and scholarly communication in order to meet + future scholarly needs, not to build for the past. Capture + deteriorating information at the highest affordable resolution, even + though the dissemination and display technologies will lag. + + * Develop cooperative mechanisms to foster agreement on protocols + for document structure and other interchange mechanisms necessary + for widespread dissemination and use before official standards are + set. + + * Accept that, in a transition period, de facto standards will have + to be developed. + + * Capture information in a way that keeps all options open and + provides for total convertibility: OCR, scanning of microfilm, + producing microfilm from scanned documents, etc. + + * Work closely with the generators of information and the builders + of networks and databases to ensure that continuing accessibility is + a primary concern from the beginning. + + * Piggyback on standards under development for the broad market, and + avoid library-specific standards; work with the vendors, in order to + take advantage of that which is being standardized for the rest of + the world. + + * Concentrate efforts on managing permanence in the digital world, + rather than perfecting the longevity of a particular medium. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +DISCUSSION * Additional comments on TIFF * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +During the brief discussion period that followed BATTIN's presentation, +BARONAS explained that TIFF was not developed in collaboration with or +under the auspices of AIIM. TIFF is a company product, not a standard, +is owned by two corporations, and is always changing. BARONAS also +observed that ANSI/AIIM MS53, a bi-level image file transfer format that +allows unlike systems to exchange images, is compatible with TIFF as well +as with DEC's architecture and IBM's MODCA/IOCA. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +HOOTON * Several questions to be considered in discussing text conversion +* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +HOOTON introduced the final topic, text conversion, by noting that it is +becoming an increasingly important part of the imaging business. Many +people now realize that it enhances their system to be able to have more +and more character data as part of their imaging system. Re the issue of +OCR versus rekeying, HOOTON posed several questions: How does one get +text into computer-readable form? Does one use automated processes? +Does one attempt to eliminate the use of operators where possible? +Standards for accuracy, he said, are extremely important: it makes a +major difference in cost and time whether one sets as a standard 98.5 +percent acceptance or 99.5 percent. He mentioned outsourcing as a +possibility for converting text. Finally, what one does with the image +to prepare it for the recognition process is also important, he said, +because such preparation changes how recognition is viewed, as well as +facilitates recognition itself. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +LESK * Roles of participants in CORE * Data flow * The scanning process * +The image interface * Results of experiments involving the use of +electronic resources and traditional paper copies * Testing the issue of +serendipity * Conclusions * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Michael LESK, executive director, Computer Science Research, Bell +Communications Research, Inc. (Bellcore), discussed the Chemical Online +Retrieval Experiment (CORE), a cooperative project involving Cornell +University, OCLC, Bellcore, and the American Chemical Society (ACS). + +LESK spoke on 1) how the scanning was performed, including the unusual +feature of page segmentation, and 2) the use made of the text and the +image in experiments. + +Working with the chemistry journals (because ACS has been saving its +typesetting tapes since the mid-1970s and thus has a significant back-run +of the most important chemistry journals in the United States), CORE is +attempting to create an automated chemical library. Approximately a +quarter of the pages by square inch are made up of images of +quasi-pictorial material; dealing with the graphic components of the +pages is extremely important. LESK described the roles of participants +in CORE: 1) ACS provides copyright permission, journals on paper, +journals on microfilm, and some of the definitions of the files; 2) at +Bellcore, LESK chiefly performs the data preparation, while Dennis Egan +performs experiments on the users of chemical abstracts, and supplies the +indexing and numerous magnetic tapes; 3) Cornell provides the site of the +experiment; 4) OCLC develops retrieval software and other user interfaces. +Various manufacturers and publishers have furnished other help. + +Concerning data flow, Bellcore receives microfilm and paper from ACS; the +microfilm is scanned by outside vendors, while the paper is scanned +inhouse on an Improvision scanner, twenty pages per minute at 300 dpi, +which provides sufficient quality for all practical uses. LESK would +prefer to have more gray level, because one of the ACS journals prints on +some colored pages, which creates a problem. + +Bellcore performs all this scanning, creates a page-image file, and also +selects from the pages the graphics, to mix with the text file (which is +discussed later in the Workshop). The user is always searching the ASCII +file, but she or he may see a display based on the ASCII or a display +based on the images. + +LESK illustrated how the program performs page analysis, and the image +interface. (The user types several words, is presented with a list-- +usually of the titles of articles contained in an issue--that derives +from the ASCII, clicks on an icon and receives an image that mirrors an +ACS page.) LESK also illustrated an alternative interface, based on text +on the ASCII, the so-called SuperBook interface from Bellcore. + +LESK next presented the results of an experiment conducted by Dennis Egan +and involving thirty-six students at Cornell, one third of them +undergraduate chemistry majors, one third senior undergraduate chemistry +majors, and one third graduate chemistry students. A third of them +received the paper journals, the traditional paper copies and chemical +abstracts on paper. A third received image displays of the pictures of +the pages, and a third received the text display with pop-up graphics. + +The students were given several questions made up by some chemistry +professors. The questions fell into five classes, ranging from very easy +to very difficult, and included questions designed to simulate browsing +as well as a traditional information retrieval-type task. + +LESK furnished the following results. In the straightforward question +search--the question being, what is the phosphorus oxygen bond distance +and hydroxy phosphate?--the students were told that they could take +fifteen minutes and, then, if they wished, give up. The students with +paper took more than fifteen minutes on average, and yet most of them +gave up. The students with either electronic format, text or image, +received good scores in reasonable time, hardly ever had to give up, and +usually found the right answer. + +In the browsing study, the students were given a list of eight topics, +told to imagine that an issue of the Journal of the American Chemical +Society had just appeared on their desks, and were also told to flip +through it and to find topics mentioned in the issue. The average scores +were about the same. (The students were told to answer yes or no about +whether or not particular topics appeared.) The errors, however, were +quite different. The students with paper rarely said that something +appeared when it had not. But they often failed to find something +actually mentioned in the issue. The computer people found numerous +things, but they also frequently said that a topic was mentioned when it +was not. (The reason, of course, was that they were performing word +searches. They were finding that words were mentioned and they were +concluding that they had accomplished their task.) + +This question also contained a trick to test the issue of serendipity. +The students were given another list of eight topics and instructed, +without taking a second look at the journal, to recall how many of this +new list of eight topics were in this particular issue. This was an +attempt to see if they performed better at remembering what they were not +looking for. They all performed about the same, paper or electronics, +about 62 percent accurate. In short, LESK said, people were not very +good when it came to serendipity, but they were no worse at it with +computers than they were with paper. + +(LESK gave a parenthetical illustration of the learning curve of students +who used SuperBook.) + +The students using the electronic systems started off worse than the ones +using print, but by the third of the three sessions in the series had +caught up to print. As one might expect, electronics provide a much +better means of finding what one wants to read; reading speeds, once the +object of the search has been found, are about the same. + +Almost none of the students could perform the hard task--the analogous +transformation. (It would require the expertise of organic chemists to +complete.) But an interesting result was that the students using the text +search performed terribly, while those using the image system did best. +That the text search system is driven by text offers the explanation. +Everything is focused on the text; to see the pictures, one must press +on an icon. Many students found the right article containing the answer +to the question, but they did not click on the icon to bring up the right +figure and see it. They did not know that they had found the right place, +and thus got it wrong. + +The short answer demonstrated by this experiment was that in the event +one does not know what to read, one needs the electronic systems; the +electronic systems hold no advantage at the moment if one knows what to +read, but neither do they impose a penalty. + +LESK concluded by commenting that, on one hand, the image system was easy +to use. On the other hand, the text display system, which represented +twenty man-years of work in programming and polishing, was not winning, +because the text was not being read, just searched. The much easier +system is highly competitive as well as remarkably effective for the +actual chemists. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +ERWAY * Most challenging aspect of working on AM * Assumptions guiding +AM's approach * Testing different types of service bureaus * AM's +requirement for 99.95 percent accuracy * Requirements for text-coding * +Additional factors influencing AM's approach to coding * Results of AM's +experience with rekeying * Other problems in dealing with service bureaus +* Quality control the most time-consuming aspect of contracting out +conversion * Long-term outlook uncertain * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +To Ricky ERWAY, associate coordinator, American Memory, Library of +Congress, the constant variety of conversion projects taking place +simultaneously represented perhaps the most challenging aspect of working +on AM. Thus, the challenge was not to find a solution for text +conversion but a tool kit of solutions to apply to LC's varied +collections that need to be converted. ERWAY limited her remarks to the +process of converting text to machine-readable form, and the variety of +LC's text collections, for example, bound volumes, microfilm, and +handwritten manuscripts. + +Two assumptions have guided AM's approach, ERWAY said: 1) A desire not +to perform the conversion inhouse. Because of the variety of formats and +types of texts, to capitalize the equipment and have the talents and +skills to operate them at LC would be extremely expensive. Further, the +natural inclination to upgrade to newer and better equipment each year +made it reasonable for AM to focus on what it did best and seek external +conversion services. Using service bureaus also allowed AM to have +several types of operations take place at the same time. 2) AM was not a +technology project, but an effort to improve access to library +collections. Hence, whether text was converted using OCR or rekeying +mattered little to AM. What mattered were cost and accuracy of results. + +AM considered different types of service bureaus and selected three to +perform several small tests in order to acquire a sense of the field. +The sample collections with which they worked included handwritten +correspondence, typewritten manuscripts from the 1940s, and +eighteenth-century printed broadsides on microfilm. On none of these +samples was OCR performed; they were all rekeyed. AM had several special +requirements for the three service bureaus it had engaged. For instance, +any errors in the original text were to be retained. Working from bound +volumes or anything that could not be sheet-fed also constituted a factor +eliminating companies that would have performed OCR. + +AM requires 99.95 percent accuracy, which, though it sounds high, often +means one or two errors per page. The initial batch of test samples +contained several handwritten materials for which AM did not require +text-coding. The results, ERWAY reported, were in all cases fairly +comparable: for the most part, all three service bureaus achieved 99.95 +percent accuracy. AM was satisfied with the work but surprised at the cost. + +As AM began converting whole collections, it retained the requirement for +99.95 percent accuracy and added requirements for text-coding. AM needed +to begin performing work more than three years ago before LC requirements +for SGML applications had been established. Since AM's goal was simply +to retain any of the intellectual content represented by the formatting +of the document (which would be lost if one performed a straight ASCII +conversion), AM used "SGML-like" codes. These codes resembled SGML tags +but were used without the benefit of document-type definitions. AM found +that many service bureaus were not yet SGML-proficient. + +Additional factors influencing the approach AM took with respect to +coding included: 1) the inability of any known microcomputer-based +user-retrieval software to take advantage of SGML coding; and 2) the +multiple inconsistencies in format of the older documents, which +confirmed AM in its desire not to attempt to force the different formats +to conform to a single document-type definition (DTD) and thus create the +need for a separate DTD for each document. + +The five text collections that AM has converted or is in the process of +converting include a collection of eighteenth-century broadsides, a +collection of pamphlets, two typescript document collections, and a +collection of 150 books. + +ERWAY next reviewed the results of AM's experience with rekeying, noting +again that because the bulk of AM's materials are historical, the quality +of the text often does not lend itself to OCR. While non-English +speakers are less likely to guess or elaborate or correct typos in the +original text, they are also less able to infer what we would; they also +are nearly incapable of converting handwritten text. Another +disadvantage of working with overseas keyers is that they are much less +likely to telephone with questions, especially on the coding, with the +result that they develop their own rules as they encounter new +situations. + +Government contracting procedures and time frames posed a major challenge +to performing the conversion. Many service bureaus are not accustomed to +retaining the image, even if they perform OCR. Thus, questions of image +format and storage media were somewhat novel to many of them. ERWAY also +remarked other problems in dealing with service bureaus, for example, +their inability to perform text conversion from the kind of microfilm +that LC uses for preservation purposes. + +But quality control, in ERWAY's experience, was the most time-consuming +aspect of contracting out conversion. AM has been attempting to perform +a 10-percent quality review, looking at either every tenth document or +every tenth page to make certain that the service bureaus are maintaining +99.95 percent accuracy. But even if they are complying with the +requirement for accuracy, finding errors produces a desire to correct +them and, in turn, to clean up the whole collection, which defeats the +purpose to some extent. Even a double entry requires a +character-by-character comparison to the original to meet the accuracy +requirement. LC is not accustomed to publish imperfect texts, which +makes attempting to deal with the industry standard an emotionally +fraught issue for AM. As was mentioned in the previous day's discussion, +going from 99.95 to 99.99 percent accuracy usually doubles costs and +means a third keying or another complete run-through of the text. + +Although AM has learned much from its experiences with various collections +and various service bureaus, ERWAY concluded pessimistically that no +breakthrough has been achieved. Incremental improvements have occurred +in some of the OCR technology, some of the processes, and some of the +standards acceptances, which, though they may lead to somewhat lower costs, +do not offer much encouragement to many people who are anxiously awaiting +the day that the entire contents of LC are available on-line. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +ZIDAR * Several answers to why one attempts to perform full-text +conversion * Per page cost of performing OCR * Typical problems +encountered during editing * Editing poor copy OCR vs. rekeying * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Judith ZIDAR, coordinator, National Agricultural Text Digitizing Program +(NATDP), National Agricultural Library (NAL), offered several answers to +the question of why one attempts to perform full-text conversion: 1) +Text in an image can be read by a human but not by a computer, so of +course it is not searchable and there is not much one can do with it. 2) +Some material simply requires word-level access. For instance, the legal +profession insists on full-text access to its material; with taxonomic or +geographic material, which entails numerous names, one virtually requires +word-level access. 3) Full text permits rapid browsing and searching, +something that cannot be achieved in an image with today's technology. +4) Text stored as ASCII and delivered in ASCII is standardized and highly +portable. 5) People just want full-text searching, even those who do not +know how to do it. NAL, for the most part, is performing OCR at an +actual cost per average-size page of approximately $7. NAL scans the +page to create the electronic image and passes it through the OCR device. + +ZIDAR next rehearsed several typical problems encountered during editing. +Praising the celerity of her student workers, ZIDAR observed that editing +requires approximately five to ten minutes per page, assuming that there +are no large tables to audit. Confusion among the three characters I, 1, +and l, constitutes perhaps the most common problem encountered. Zeroes +and O's also are frequently confused. Double M's create a particular +problem, even on clean pages. They are so wide in most fonts that they +touch, and the system simply cannot tell where one letter ends and the +other begins. Complex page formats occasionally fail to columnate +properly, which entails rescanning as though one were working with a +single column, entering the ASCII, and decolumnating for better +searching. With proportionally spaced text, OCR can have difficulty +discerning what is a space and what are merely spaces between letters, as +opposed to spaces between words, and therefore will merge text or break +up words where it should not. + +ZIDAR said that it can often take longer to edit a poor-copy OCR than to +key it from scratch. NAL has also experimented with partial editing of +text, whereby project workers go into and clean up the format, removing +stray characters but not running a spell-check. NAL corrects typos in +the title and authors' names, which provides a foothold for searching and +browsing. Even extremely poor-quality OCR (e.g., 60-percent accuracy) +can still be searched, because numerous words are correct, while the +important words are probably repeated often enough that they are likely +to be found correct somewhere. Librarians, however, cannot tolerate this +situation, though end users seem more willing to use this text for +searching, provided that NAL indicates that it is unedited. ZIDAR +concluded that rekeying of text may be the best route to take, in spite +of numerous problems with quality control and cost. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +DISCUSSION * Modifying an image before performing OCR * NAL's costs per +page *AM's costs per page and experience with Federal Prison Industries * +Elements comprising NATDP's costs per page * OCR and structured markup * +Distinction between the structure of a document and its representation +when put on the screen or printed * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +HOOTON prefaced the lengthy discussion that followed with several +comments about modifying an image before one reaches the point of +performing OCR. For example, in regard to an application containing a +significant amount of redundant data, such as form-type data, numerous +companies today are working on various kinds of form renewal, prior to +going through a recognition process, by using dropout colors. Thus, +acquiring access to form design or using electronic means are worth +considering. HOOTON also noted that conversion usually makes or breaks +one's imaging system. It is extremely important, extremely costly in +terms of either capital investment or service, and determines the quality +of the remainder of one's system, because it determines the character of +the raw material used by the system. + +Concerning the four projects undertaken by NAL, two inside and two +performed by outside contractors, ZIDAR revealed that an in-house service +bureau executed the first at a cost between $8 and $10 per page for +everything, including building of the database. The project undertaken +by the Consultative Group on International Agricultural Research (CGIAR) +cost approximately $10 per page for the conversion, plus some expenses +for the software and building of the database. The Acid Rain Project--a +two-disk set produced by the University of Vermont, consisting of +Canadian publications on acid rain--cost $6.70 per page for everything, +including keying of the text, which was double keyed, scanning of the +images, and building of the database. The in-house project offered +considerable ease of convenience and greater control of the process. On +the other hand, the service bureaus know their job and perform it +expeditiously, because they have more people. + +As a useful comparison, ERWAY revealed AM's costs as follows: $0.75 +cents to $0.85 cents per thousand characters, with an average page +containing 2,700 characters. Requirements for coding and imaging +increase the costs. Thus, conversion of the text, including the coding, +costs approximately $3 per page. (This figure does not include the +imaging and database-building included in the NAL costs.) AM also +enjoyed a happy experience with Federal Prison Industries, which +precluded the necessity of going through the request-for-proposal process +to award a contract, because it is another government agency. The +prisoners performed AM's rekeying just as well as other service bureaus +and proved handy as well. AM shipped them the books, which they would +photocopy on a book-edge scanner. They would perform the markup on +photocopies, return the books as soon as they were done with them, +perform the keying, and return the material to AM on WORM disks. + +ZIDAR detailed the elements that constitute the previously noted cost of +approximately $7 per page. Most significant is the editing, correction +of errors, and spell-checkings, which though they may sound easy to +perform require, in fact, a great deal of time. Reformatting text also +takes a while, but a significant amount of NAL's expenses are for equipment, +which was extremely expensive when purchased because it was one of the few +systems on the market. The costs of equipment are being amortized over +five years but are still quite high, nearly $2,000 per month. + +HOCKEY raised a general question concerning OCR and the amount of editing +required (substantial in her experience) to generate the kind of +structured markup necessary for manipulating the text on the computer or +loading it into any retrieval system. She wondered if the speakers could +extend the previous question about the cost-benefit of adding or exerting +structured markup. ERWAY noted that several OCR systems retain italics, +bolding, and other spatial formatting. While the material may not be in +the format desired, these systems possess the ability to remove the +original materials quickly from the hands of the people performing the +conversion, as well as to retain that information so that users can work +with it. HOCKEY rejoined that the current thinking on markup is that one +should not say that something is italic or bold so much as why it is that +way. To be sure, one needs to know that something was italicized, but +how can one get from one to the other? One can map from the structure to +the typographic representation. + +FLEISCHHAUER suggested that, given the 100 million items the Library +holds, it may not be possible for LC to do more than report that a thing +was in italics as opposed to why it was italics, although that may be +desirable in some contexts. Promising to talk a bit during the afternoon +session about several experiments OCLC performed on automatic recognition +of document elements, and which they hoped to extend, WEIBEL said that in +fact one can recognize the major elements of a document with a fairly +high degree of reliability, at least as good as OCR. STEVENS drew a +useful distinction between standard, generalized markup (i.e., defining +for a document-type definition the structure of the document), and what +he termed a style sheet, which had to do with italics, bolding, and other +forms of emphasis. Thus, two different components are at work, one being +the structure of the document itself (its logic), and the other being its +representation when it is put on the screen or printed. + + ****** + +SESSION V. APPROACHES TO PREPARING ELECTRONIC TEXTS + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +HOCKEY * Text in ASCII and the representation of electronic text versus +an image * The need to look at ways of using markup to assist retrieval * +The need for an encoding format that will be reusable and multifunctional ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Susan HOCKEY, director, Center for Electronic Texts in the Humanities +(CETH), Rutgers and Princeton Universities, announced that one talk +(WEIBEL's) was moved into this session from the morning and that David +Packard was unable to attend. The session would attempt to focus more on +what one can do with a text in ASCII and the representation of electronic +text rather than just an image, what one can do with a computer that +cannot be done with a book or an image. It would be argued that one can +do much more than just read a text, and from that starting point one can +use markup and methods of preparing the text to take full advantage of +the capability of the computer. That would lead to a discussion of what +the European Community calls REUSABILITY, what may better be termed +DURABILITY, that is, how to prepare or make a text that will last a long +time and that can be used for as many applications as possible, which +would lead to issues of improving intellectual access. + +HOCKEY urged the need to look at ways of using markup to facilitate retrieval, +not just for referencing or to help locate an item that is retrieved, but also to put markup tags in +a text to help retrieve the thing sought either with linguistic tagging or +interpretation. HOCKEY also argued that little advancement had occurred in +the software tools currently available for retrieving and searching text. +She pressed the desideratum of going beyond Boolean searches and performing +more sophisticated searching, which the insertion of more markup in the text +would facilitate. Thinking about electronic texts as opposed to images means +considering material that will never appear in print form, or print will not +be its primary form, that is, material which only appears in electronic form. +HOCKEY alluded to the history and the need for markup and tagging and +electronic text, which was developed through the use of computers in the +humanities; as MICHELSON had observed, Father Busa had started in 1949 +to prepare the first-ever text on the computer. + +HOCKEY remarked several large projects, particularly in Europe, for the +compilation of dictionaries, language studies, and language analysis, in +which people have built up archives of text and have begun to recognize +the need for an encoding format that will be reusable and multifunctional, +that can be used not just to print the text, which may be assumed to be a +byproduct of what one wants to do, but to structure it inside the computer +so that it can be searched, built into a Hypertext system, etc. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +WEIBEL * OCLC's approach to preparing electronic text: retroconversion, +keying of texts, more automated ways of developing data * Project ADAPT +and the CORE Project * Intelligent character recognition does not exist * +Advantages of SGML * Data should be free of procedural markup; +descriptive markup strongly advocated * OCLC's interface illustrated * +Storage requirements and costs for putting a lot of information on line * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Stuart WEIBEL, senior research scientist, Online Computer Library Center, +Inc. (OCLC), described OCLC's approach to preparing electronic text. He +argued that the electronic world into which we are moving must +accommodate not only the future but the past as well, and to some degree +even the present. Thus, starting out at one end with retroconversion and +keying of texts, one would like to move toward much more automated ways +of developing data. + +For example, Project ADAPT had to do with automatically converting +document images into a structured document database with OCR text as +indexing and also a little bit of automatic formatting and tagging of +that text. The CORE project hosted by Cornell University, Bellcore, +OCLC, the American Chemical Society, and Chemical Abstracts, constitutes +WEIBEL's principal concern at the moment. This project is an example of +converting text for which one already has a machine-readable version into +a format more suitable for electronic delivery and database searching. +(Since Michael LESK had previously described CORE, WEIBEL would say +little concerning it.) Borrowing a chemical phrase, de novo synthesis, +WEIBEL cited the Online Journal of Current Clinical Trials as an example +of de novo electronic publishing, that is, a form in which the primary +form of the information is electronic. + +Project ADAPT, then, which OCLC completed a couple of years ago and in +fact is about to resume, is a model in which one takes page images either +in paper or microfilm and converts them automatically to a searchable +electronic database, either on-line or local. The operating assumption +is that accepting some blemishes in the data, especially for +retroconversion of materials, will make it possible to accomplish more. +Not enough money is available to support perfect conversion. + +WEIBEL related several steps taken to perform image preprocessing +(processing on the image before performing optical character +recognition), as well as image postprocessing. He denied the existence +of intelligent character recognition and asserted that what is wanted is +page recognition, which is a long way off. OCLC has experimented with +merging of multiple optical character recognition systems that will +reduce errors from an unacceptable rate of 5 characters out of every +l,000 to an unacceptable rate of 2 characters out of every l,000, but it +is not good enough. It will never be perfect. + +Concerning the CORE Project, WEIBEL observed that Bellcore is taking the +topography files, extracting the page images, and converting those +topography files to SGML markup. LESK hands that data off to OCLC, which +builds that data into a Newton database, the same system that underlies +the on-line system in virtually all of the reference products at OCLC. +The long-term goal is to make the systems interoperable so that not just +Bellcore's system and OCLC's system can access this data, but other +systems can as well, and the key to that is the Z39.50 common command +language and the full-text extension. Z39.50 is fine for MARC records, +but is not enough to do it for full text (that is, make full texts +interoperable). + +WEIBEL next outlined the critical role of SGML for a variety of purposes, +for example, as noted by HOCKEY, in the world of extremely large +databases, using highly structured data to perform field searches. +WEIBEL argued that by building the structure of the data in (i.e., the +structure of the data originally on a printed page), it becomes easy to +look at a journal article even if one cannot read the characters and know +where the title or author is, or what the sections of that document would be. +OCLC wants to make that structure explicit in the database, because it will +be important for retrieval purposes. + +The second big advantage of SGML is that it gives one the ability to +build structure into the database that can be used for display purposes +without contaminating the data with instructions about how to format +things. The distinction lies between procedural markup, which tells one +where to put dots on the page, and descriptive markup, which describes +the elements of a document. + +WEIBEL believes that there should be no procedural markup in the data at +all, that the data should be completely unsullied by information about +italics or boldness. That should be left up to the display device, +whether that display device is a page printer or a screen display device. +By keeping one's database free of that kind of contamination, one can +make decisions down the road, for example, reorganize the data in ways +that are not cramped by built-in notions of what should be italic and +what should be bold. WEIBEL strongly advocated descriptive markup. As +an example, he illustrated the index structure in the CORE data. With +subsequent illustrated examples of markup, WEIBEL acknowledged the common +complaint that SGML is hard to read in its native form, although markup +decreases considerably once one gets into the body. Without the markup, +however, one would not have the structure in the data. One can pass +markup through a LaTeX processor and convert it relatively easily to a +printed version of the document. + +WEIBEL next illustrated an extremely cluttered screen dump of OCLC's +system, in order to show as much as possible the inherent capability on +the screen. (He noted parenthetically that he had become a supporter of +X-Windows as a result of the progress of the CORE Project.) WEIBEL also +illustrated the two major parts of the interface: l) a control box that +allows one to generate lists of items, which resembles a small table of +contents based on key words one wishes to search, and 2) a document +viewer, which is a separate process in and of itself. He demonstrated +how to follow links through the electronic database simply by selecting +the appropriate button and bringing them up. He also noted problems that +remain to be accommodated in the interface (e.g., as pointed out by LESK, +what happens when users do not click on the icon for the figure). + +Given the constraints of time, WEIBEL omitted a large number of ancillary +items in order to say a few words concerning storage requirements and +what will be required to put a lot of things on line. Since it is +extremely expensive to reconvert all of this data, especially if it is +just in paper form (and even if it is in electronic form in typesetting +tapes), he advocated building journals electronically from the start. In +that case, if one only has text graphics and indexing (which is all that +one needs with de novo electronic publishing, because there is no need to +go back and look at bit-maps of pages), one can get 10,000 journals of +full text, or almost 6 million pages per year. These pages can be put in +approximately 135 gigabytes of storage, which is not all that much, +WEIBEL said. For twenty years, something less than three terabytes would +be required. WEIBEL calculated the costs of storing this information as +follows: If a gigabyte costs approximately $1,000, then a terabyte costs +approximately $1 million to buy in terms of hardware. One also needs a +building to put it in and a staff like OCLC to handle that information. +So, to support a terabyte, multiply by five, which gives $5 million per +year for a supported terabyte of data. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +DISCUSSION * Tapes saved by ACS are the typography files originally +supporting publication of the journal * Cost of building tagged text into +the database * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +During the question-and-answer period that followed WEIBEL's +presentation, these clarifications emerged. The tapes saved by the +American Chemical Society are the typography files that originally +supported the publication of the journal. Although they are not tagged +in SGML, they are tagged in very fine detail. Every single sentence is +marked, all the registry numbers, all the publications issues, dates, and +volumes. No cost figures on tagging material on a per-megabyte basis +were available. Because ACS's typesetting system runs from tagged text, +there is no extra cost per article. It was unknown what it costs ACS to +keyboard the tagged text rather than just keyboard the text in the +cheapest process. In other words, since one intends to publish things +and will need to build tagged text into a typography system in any case, +if one does that in such a way that it can drive not only typography but +an electronic system (which is what ACS intends to do--move to SGML +publishing), the marginal cost is zero. The marginal cost represents the +cost of building tagged text into the database, which is small. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +SPERBERG-McQUEEN * Distinction between texts and computers * Implications +of recognizing that all representation is encoding * Dealing with +complicated representations of text entails the need for a grammar of +documents * Variety of forms of formal grammars * Text as a bit-mapped +image does not represent a serious attempt to represent text in +electronic form * SGML, the TEI, document-type declarations, and the +reusability and longevity of data * TEI conformance explicitly allows +extension or modification of the TEI tag set * Administrative background +of the TEI * Several design goals for the TEI tag set * An absolutely +fixed requirement of the TEI Guidelines * Challenges the TEI has +attempted to face * Good texts not beyond economic feasibility * The +issue of reproducibility or processability * The issue of mages as +simulacra for the text redux * One's model of text determines what one's +software can do with a text and has economic consequences * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Prior to speaking about SGML and markup, Michael SPERBERG-McQUEEN, editor, +Text Encoding Initiative (TEI), University of Illinois-Chicago, first drew +a distinction between texts and computers: Texts are abstract cultural +and linguistic objects while computers are complicated physical devices, +he said. Abstract objects cannot be placed inside physical devices; with +computers one can only represent text and act upon those representations. + +The recognition that all representation is encoding, SPERBERG-McQUEEN +argued, leads to the recognition of two things: 1) The topic description +for this session is slightly misleading, because there can be no discussion +of pros and cons of text-coding unless what one means is pros and cons of +working with text with computers. 2) No text can be represented in a +computer without some sort of encoding; images are one way of encoding text, +ASCII is another, SGML yet another. There is no encoding without some +information loss, that is, there is no perfect reproduction of a text that +allows one to do away with the original. Thus, the question becomes, +What is the most useful representation of text for a serious work? +This depends on what kind of serious work one is talking about. + +The projects demonstrated the previous day all involved highly complex +information and fairly complex manipulation of the textual material. +In order to use that complicated information, one has to calculate it +slowly or manually and store the result. It needs to be stored, therefore, +as part of one's representation of the text. Thus, one needs to store the +structure in the text. To deal with complicated representations of text, +one needs somehow to control the complexity of the representation of a text; +that means one needs a way of finding out whether a document and an +electronic representation of a document is legal or not; and that +means one needs a grammar of documents. + +SPERBERG-McQUEEN discussed the variety of forms of formal grammars, +implicit and explicit, as applied to text, and their capabilities. He +argued that these grammars correspond to different models of text that +different developers have. For example, one implicit model of the text +is that there is no internal structure, but just one thing after another, +a few characters and then perhaps a start-title command, and then a few +more characters and an end-title command. SPERBERG-McQUEEN also +distinguished several kinds of text that have a sort of hierarchical +structure that is not very well defined, which, typically, corresponds +to grammars that are not very well defined, as well as hierarchies that +are very well defined (e.g., the Thesaurus Linguae Graecae) and extremely +complicated things such as SGML, which handle strictly hierarchical data +very nicely. + +SPERBERG-McQUEEN conceded that one other model not illustrated on his two +displays was the model of text as a bit-mapped image, an image of a page, +and confessed to having been converted to a limited extent by the +Workshop to the view that electronic images constitute a promising, +probably superior alternative to microfilming. But he was not convinced +that electronic images represent a serious attempt to represent text in +electronic form. Many of their problems stem from the fact that they are +not direct attempts to represent the text but attempts to represent the +page, thus making them representations of representations. + +In this situation of increasingly complicated textual information and the +need to control that complexity in a useful way (which begs the question +of the need for good textual grammars), one has the introduction of SGML. +With SGML, one can develop specific document-type declarations +for specific text types or, as with the TEI, attempts to generate +general document-type declarations that can handle all sorts of text. +The TEI is an attempt to develop formats for text representation that +will ensure the kind of reusability and longevity of data discussed earlier. +It offers a way to stay alive in the state of permanent technological +revolution. + +It has been a continuing challenge in the TEI to create document grammars +that do some work in controlling the complexity of the textual object but +also allowing one to represent the real text that one will find. +Fundamental to the notion of the TEI is that TEI conformance allows one +the ability to extend or modify the TEI tag set so that it fits the text +that one is attempting to represent. + +SPERBERG-McQUEEN next outlined the administrative background of the TEI. +The TEI is an international project to develop and disseminate guidelines +for the encoding and interchange of machine-readable text. It is +sponsored by the Association for Computers in the Humanities, the +Association for Computational Linguistics, and the Association for +Literary and Linguistic Computing. Representatives of numerous other +professional societies sit on its advisory board. The TEI has a number +of affiliated projects that have provided assistance by testing drafts of +the guidelines. + +Among the design goals for the TEI tag set, the scheme first of all must +meet the needs of research, because the TEI came out of the research +community, which did not feel adequately served by existing tag sets. +The tag set must be extensive as well as compatible with existing and +emerging standards. In 1990, version 1.0 of the Guidelines was released +(SPERBERG-McQUEEN illustrated their contents). + +SPERBERG-McQUEEN noted that one problem besetting electronic text has +been the lack of adequate internal or external documentation for many +existing electronic texts. The TEI guidelines as currently formulated +contain few fixed requirements, but one of them is this: There must +always be a document header, an in-file SGML tag that provides +1) a bibliographic description of the electronic object one is talking +about (that is, who included it, when, what for, and under which title); +and 2) the copy text from which it was derived, if any. If there was +no copy text or if the copy text is unknown, then one states as much. +Version 2.0 of the Guidelines was scheduled to be completed in fall 1992 +and a revised third version is to be presented to the TEI advisory board +for its endorsement this coming winter. The TEI itself exists to provide +a markup language, not a marked-up text. + +Among the challenges the TEI has attempted to face is the need for a +markup language that will work for existing projects, that is, handle the +level of markup that people are using now to tag only chapter, section, +and paragraph divisions and not much else. At the same time, such a +language also will be able to scale up gracefully to handle the highly +detailed markup which many people foresee as the future destination of +much electronic text, and which is not the future destination but the +present home of numerous electronic texts in specialized areas. + +SPERBERG-McQUEEN dismissed the lowest-common-denominator approach as +unable to support the kind of applications that draw people who have +never been in the public library regularly before, and make them come +back. He advocated more interesting text and more intelligent text. +Asserting that it is not beyond economic feasibility to have good texts, +SPERBERG-McQUEEN noted that the TEI Guidelines listing 200-odd tags +contains tags that one is expected to enter every time the relevant +textual feature occurs. It contains all the tags that people need now, +and it is not expected that everyone will tag things in the same way. + +The question of how people will tag the text is in large part a function +of their reaction to what SPERBERG-McQUEEN termed the issue of +reproducibility. What one needs to be able to reproduce are the things +one wants to work with. Perhaps a more useful concept than that of +reproducibility or recoverability is that of processability, that is, +what can one get from an electronic text without reading it again +in the original. He illustrated this contention with a page from +Jan Comenius's bilingual Introduction to Latin. + +SPERBERG-McQUEEN returned at length to the issue of images as simulacra +for the text, in order to reiterate his belief that in the long run more +than images of pages of particular editions of the text are needed, +because just as second-generation photocopies and second-generation +microfilm degenerate, so second-generation representations tend to +degenerate, and one tends to overstress some relatively trivial aspects +of the text such as its layout on the page, which is not always +significant, despite what the text critics might say, and slight other +pieces of information such as the very important lexical ties between the +English and Latin versions of Comenius's bilingual text, for example. +Moreover, in many crucial respects it is easy to fool oneself concerning +what a scanned image of the text will accomplish. For example, in order +to study the transmission of texts, information concerning the text +carrier is necessary, which scanned images simply do not always handle. +Further, even the high-quality materials being produced at Cornell use +much of the information that one would need if studying those books as +physical objects. It is a choice that has been made. It is an arguably +justifiable choice, but one does not know what color those pen strokes in +the margin are or whether there was a stain on the page, because it has +been filtered out. One does not know whether there were rips in the page +because they do not show up, and on a couple of the marginal marks one +loses half of the mark because the pen is very light and the scanner +failed to pick it up, and so what is clearly a checkmark in the margin of +the original becomes a little scoop in the margin of the facsimile. +Standard problems for facsimile editions, not new to electronics, but +also true of light-lens photography, and are remarked here because it is +important that we not fool ourselves that even if we produce a very nice +image of this page with good contrast, we are not replacing the +manuscript any more than microfilm has replaced the manuscript. + +The TEI comes from the research community, where its first allegiance +lies, but it is not just an academic exercise. It has relevance far +beyond those who spend all of their time studying text, because one's +model of text determines what one's software can do with a text. Good +models lead to good software. Bad models lead to bad software. That has +economic consequences, and it is these economic consequences that have +led the European Community to help support the TEI, and that will lead, +SPERBERG-McQUEEN hoped, some software vendors to realize that if they +provide software with a better model of the text they can make a killing. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +DISCUSSION * Implications of different DTDs and tag sets * ODA versus SGML * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +During the discussion that followed, several additional points were made. +Neither AAP (i.e., Association of American Publishers) nor CALS (i.e., +Computer-aided Acquisition and Logistics Support) has a document-type +definition for ancient Greek drama, although the TEI will be able to +handle that. Given this state of affairs and assuming that the +technical-journal producers and the commercial vendors decide to use the +other two types, then an institution like the Library of Congress, which +might receive all of their publications, would have to be able to handle +three different types of document definitions and tag sets and be able to +distinguish among them. + +Office Document Architecture (ODA) has some advantages that flow from its +tight focus on office documents and clear directions for implementation. +Much of the ODA standard is easier to read and clearer at first reading +than the SGML standard, which is extremely general. What that means is +that if one wants to use graphics in TIFF and ODA, one is stuck, because +ODA defines graphics formats while TIFF does not, whereas SGML says the +world is not waiting for this work group to create another graphics format. +What is needed is an ability to use whatever graphics format one wants. + +The TEI provides a socket that allows one to connect the SGML document to +the graphics. The notation that the graphics are in is clearly a choice +that one needs to make based on her or his environment, and that is one +advantage. SGML is less megalomaniacal in attempting to define formats +for all kinds of information, though more megalomaniacal in attempting to +cover all sorts of documents. The other advantage is that the model of +text represented by SGML is simply an order of magnitude richer and more +flexible than the model of text offered by ODA. Both offer hierarchical +structures, but SGML recognizes that the hierarchical model of the text +that one is looking at may not have been in the minds of the designers, +whereas ODA does not. + +ODA is not really aiming for the kind of document that the TEI wants to +encompass. The TEI can handle the kind of material ODA has, as well as a +significantly broader range of material. ODA seems to be very much +focused on office documents, which is what it started out being called-- +office document architecture. + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +CALALUCA * Text-encoding from a publisher's perspective * +Responsibilities of a publisher * Reproduction of Migne's Latin series +whole and complete with SGML tags based on perceived need and expected +use * Particular decisions arising from the general decision to produce +and publish PLD * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +The final speaker in this session, Eric CALALUCA, vice president, +Chadwyck-Healey, Inc., spoke from the perspective of a publisher re +text-encoding, rather than as one qualified to discuss methods of +encoding data, and observed that the presenters sitting in the room, +whether they had chosen to or not, were acting as publishers: making +choices, gathering data, gathering information, and making assessments. +CALALUCA offered the hard-won conviction that in publishing very large +text files (such as PLD), one cannot avoid making personal judgments of +appropriateness and structure. + +In CALALUCA's view, encoding decisions stem from prior judgments. Two +notions have become axioms for him in the consideration of future sources +for electronic publication: 1) electronic text publishing is as personal +as any other kind of publishing, and questions of if and how to encode +the data are simply a consequence of that prior decision; 2) all +personal decisions are open to criticism, which is unavoidable. + +CALALUCA rehearsed his role as a publisher or, better, as an intermediary +between what is viewed as a sound idea and the people who would make use +of it. Finding the specialist to advise in this process is the core of +that function. The publisher must monitor and hug the fine line between +giving users what they want and suggesting what they might need. One +responsibility of a publisher is to represent the desires of scholars and +research librarians as opposed to bullheadedly forcing them into areas +they would not choose to enter. + +CALALUCA likened the questions being raised today about data structure +and standards to the decisions faced by the Abbe Migne himself during +production of the Patrologia series in the mid-nineteenth century. +Chadwyck-Healey's decision to reproduce Migne's Latin series whole and +complete with SGML tags was also based upon a perceived need and an +expected use. In the same way that Migne's work came to be far more than +a simple handbook for clerics, PLD is already far more than a database +for theologians. It is a bedrock source for the study of Western +civilization, CALALUCA asserted. + +In regard to the decision to produce and publish PLD, the editorial board +offered direct judgments on the question of appropriateness of these +texts for conversion, their encoding and their distribution, and +concluded that the best possible project was one that avoided overt +intrusions or exclusions in so important a resource. Thus, the general +decision to transmit the original collection as clearly as possible with +the widest possible avenues for use led to other decisions: 1) To encode +the data or not, SGML or not, TEI or not. Again, the expected user +community asserted the need for normative tagging structures of important +humanities texts, and the TEI seemed the most appropriate structure for +that purpose. Research librarians, who are trained to view the larger +impact of electronic text sources on 80 or 90 or 100 doctoral +disciplines, loudly approved the decision to include tagging. They see +what is coming better than the specialist who is completely focused on +one edition of Ambrose's De Anima, and they also understand that the +potential uses exceed present expectations. 2) What will be tagged and +what will not. Once again, the board realized that one must tag the +obvious. But in no way should one attempt to identify through encoding +schemes every single discrete area of a text that might someday be +searched. That was another decision. Searching by a column number, an +author, a word, a volume, permitting combination searches, and tagging +notations seemed logical choices as core elements. 3) How does one make +the data available? Tieing it to a CD-ROM edition creates limitations, +but a magnetic tape file that is very large, is accompanied by the +encoding specifications, and that allows one to make local modifications +also allows one to incorporate any changes one may desire within the +bounds of private research, though exporting tag files from a CD-ROM +could serve just as well. Since no one on the board could possibly +anticipate each and every way in which a scholar might choose to mine +this data bank, it was decided to satisfy the basics and make some +provisions for what might come. 4) Not to encode the database would rob +it of the interchangeability and portability these important texts should +accommodate. For CALALUCA, the extensive options presented by full-text +searching require care in text selection and strongly support encoding of +data to facilitate the widest possible search strategies. Better +software can always be created, but summoning the resources, the people, +and the energy to reconvert the text is another matter. + +PLD is being encoded, captured, and distributed, because to +Chadwyck-Healey and the board it offers the widest possible array of +future research applications that can be seen today. CALALUCA concluded +by urging the encoding of all important text sources in whatever way +seems most appropriate and durable at the time, without blanching at the +thought that one's work may require emendation in the future. (Thus, +Chadwyck-Healey produced a very large humanities text database before the +final release of the TEI Guidelines.) + + ****** + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +DISCUSSION * Creating texts with markup advocated * Trends in encoding * +The TEI and the issue of interchangeability of standards * A +misconception concerning the TEI * Implications for an institution like +LC in the event that a multiplicity of DTDs develops * Producing images +as a first step towards possible conversion to full text through +character recognition * The AAP tag sets as a common starting point and +the need for caution * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +HOCKEY prefaced the discussion that followed with several comments in +favor of creating texts with markup and on trends in encoding. In the +future, when many more texts are available for on-line searching, real +problems in finding what is wanted will develop, if one is faced with +millions of words of data. It therefore becomes important to consider +putting markup in texts to help searchers home in on the actual things +they wish to retrieve. Various approaches to refining retrieval methods +toward this end include building on a computer version of a dictionary +and letting the computer look up words in it to obtain more information +about the semantic structure or semantic field of a word, its grammatical +structure, and syntactic structure. + +HOCKEY commented on the present keen interest in the encoding world +in creating: 1) machine-readable versions of dictionaries that can be +initially tagged in SGML, which gives a structure to the dictionary entry; +these entries can then be converted into a more rigid or otherwise +different database structure inside the computer, which can be treated as +a dynamic tool for searching mechanisms; 2) large bodies of text to study +the language. In order to incorporate more sophisticated mechanisms, +more about how words behave needs to be known, which can be learned in +part from information in dictionaries. However, the last ten years have +seen much interest in studying the structure of printed dictionaries +converted into computer-readable form. The information one derives about +many words from those is only partial, one or two definitions of the +common or the usual meaning of a word, and then numerous definitions of +unusual usages. If the computer is using a dictionary to help retrieve +words in a text, it needs much more information about the common usages, +because those are the ones that occur over and over again. Hence the +current interest in developing large bodies of text in computer-readable +form in order to study the language. Several projects are engaged in +compiling, for example, 100 million words. HOCKEY described one with +which she was associated briefly at Oxford University involving +compilation of 100 million words of British English: about 10 percent of +that will contain detailed linguistic tagging encoded in SGML; it will +have word class taggings, with words identified as nouns, verbs, +adjectives, or other parts of speech. This tagging can then be used by +programs which will begin to learn a bit more about the structure of the +language, and then, can go to tag more text. + +HOCKEY said that the more that is tagged accurately, the more one can +refine the tagging process and thus the bigger body of text one can build +up with linguistic tagging incorporated into it. Hence, the more tagging +or annotation there is in the text, the more one may begin to learn about +language and the more it will help accomplish more intelligent OCR. She +recommended the development of software tools that will help one begin to +understand more about a text, which can then be applied to scanning +images of that text in that format and to using more intelligence to help +one interpret or understand the text. + +HOCKEY posited the need to think about common methods of text-encoding +for a long time to come, because building these large bodies of text is +extremely expensive and will only be done once. + +In the more general discussion on approaches to encoding that followed, +these points were made: + +BESSER identified the underlying problem with standards that all have to +struggle with in adopting a standard, namely, the tension between a very +highly defined standard that is very interchangeable but does not work +for everyone because something is lacking, and a standard that is less +defined, more open, more adaptable, but less interchangeable. Contending +that the way in which people use SGML is not sufficiently defined, BESSER +wondered 1) if people resist the TEI because they think it is too defined +in certain things they do not fit into, and 2) how progress with +interchangeability can be made without frightening people away. + +SPERBERG-McQUEEN replied that the published drafts of the TEI had met +with surprisingly little objection on the grounds that they do not allow +one to handle X or Y or Z. Particular concerns of the affiliated +projects have led, in practice, to discussions of how extensions are to +be made; the primary concern of any project has to be how it can be +represented locally, thus making interchange secondary. The TEI has +received much criticism based on the notion that everything in it is +required or even recommended, which, as it happens, is a misconception +from the beginning, because none of it is required and very little is +actually actively recommended for all cases, except that one document +one's source. + +SPERBERG-McQUEEN agreed with BESSER about this trade-off: all the +projects in a set of twenty TEI-conformant projects will not necessarily +tag the material in the same way. One result of the TEI will be that the +easiest problems will be solved--those dealing with the external form of +the information; but the problem that is hardest in interchange is that +one is not encoding what another wants, and vice versa. Thus, after +the adoption of a common notation, the differences in the underlying +conceptions of what is interesting about texts become more visible. +The success of a standard like the TEI will lie in the ability of +the recipient of interchanged texts to use some of what it contains +and to add the information that was not encoded that one wants, in a +layered way, so that texts can be gradually enriched and one does not +have to put in everything all at once. Hence, having a well-behaved +markup scheme is important. + +STEVENS followed up on the paradoxical analogy that BESSER alluded to in +the example of the MARC records, namely, the formats that are the same +except that they are different. STEVENS drew a parallel between +document-type definitions and MARC records for books and serials and maps, +where one has a tagging structure and there is a text-interchange. +STEVENS opined that the producers of the information will set the terms +for the standard (i.e., develop document-type definitions for the users +of their products), creating a situation that will be problematical for +an institution like the Library of Congress, which will have to deal with +the DTDs in the event that a multiplicity of them develops. Thus, +numerous people are seeking a standard but cannot find the tag set that +will be acceptable to them and their clients. SPERBERG-McQUEEN agreed +with this view, and said that the situation was in a way worse: attempting +to unify arbitrary DTDs resembled attempting to unify a MARC record with a +bibliographic record done according to the Prussian instructions. +According to STEVENS, this situation occurred very early in the process. + +WATERS recalled from early discussions on Project Open Book the concern +of many people that merely by producing images, POB was not really +enhancing intellectual access to the material. Nevertheless, not wishing +to overemphasize the opposition between imaging and full text, WATERS +stated that POB views getting the images as a first step toward possibly +converting to full text through character recognition, if the technology +is appropriate. WATERS also emphasized that encoding is involved even +with a set of images. + +SPERBERG-McQUEEN agreed with WATERS that one can create an SGML document +consisting wholly of images. At first sight, organizing graphic images +with an SGML document may not seem to offer great advantages, but the +advantages of the scheme WATERS described would be precisely that +ability to move into something that is more of a multimedia document: +a combination of transcribed text and page images. WEIBEL concurred in +this judgment, offering evidence from Project ADAPT, where a page is +divided into text elements and graphic elements, and in fact the text +elements are organized by columns and lines. These lines may be used as +the basis for distributing documents in a network environment. As one +develops software intelligent enough to recognize what those elements +are, it makes sense to apply SGML to an image initially, that may, in +fact, ultimately become more and more text, either through OCR or edited +OCR or even just through keying. For WATERS, the labor of composing the +document and saying this set of documents or this set of images belongs +to this document constitutes a significant investment. + +WEIBEL also made the point that the AAP tag sets, while not excessively +prescriptive, offer a common starting point; they do not define the +structure of the documents, though. They have some recommendations about +DTDs one could use as examples, but they do just suggest tag sets. For +example, the CORE project attempts to use the AAP markup as much as +possible, but there are clearly areas where structure must be added. +That in no way contradicts the use of AAP tag sets. + +SPERBERG-McQUEEN noted that the TEI prepared a long working paper early +on about the AAP tag set and what it lacked that the TEI thought it +needed, and a fairly long critique of the naming conventions, which has +led to a very different style of naming in the TEI. He stressed the +importance of the opposition between prescriptive markup, the kind that a +publisher or anybody can do when producing documents de novo, and +descriptive markup, in which one has to take what the text carrier +provides. In these particular tag sets it is easy to overemphasize this +opposition, because the AAP tag set is extremely flexible. Even if one +just used the DTDs, they allow almost anything to appear almost anywhere. + + ****** + +SESSION VI. COPYRIGHT ISSUES + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +PETERS * Several cautions concerning copyright in an electronic +environment * Review of copyright law in the United States * The notion +of the public good and the desirability of incentives to promote it * +What copyright protects * Works not protected by copyright * The rights +of copyright holders * Publishers' concerns in today's electronic +environment * Compulsory licenses * The price of copyright in a digital +medium and the need for cooperation * Additional clarifications * Rough +justice oftentimes the outcome in numerous copyright matters * Copyright +in an electronic society * Copyright law always only sets up the +boundaries; anything can be changed by contract * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +Marybeth PETERS, policy planning adviser to the Register of Copyrights, +Library of Congress, made several general comments and then opened the +floor to discussion of subjects of interest to the audience. + +Having attended several sessions in an effort to gain a sense of what +people did and where copyright would affect their lives, PETERS expressed +the following cautions: + + * If one takes and converts materials and puts them in new forms, + then, from a copyright point of view, one is creating something and + will receive some rights. + + * However, if what one is converting already exists, a question + immediately arises about the status of the materials in question. + + * Putting something in the public domain in the United States offers + some freedom from anxiety, but distributing it throughout the world + on a network is another matter, even if one has put it in the public + domain in the United States. Re foreign laws, very frequently a + work can be in the public domain in the United States but protected + in other countries. Thus, one must consider all of the places a + work may reach, lest one unwittingly become liable to being faced + with a suit for copyright infringement, or at least a letter + demanding discussion of what one is doing. + +PETERS reviewed copyright law in the United States. The U.S. +Constitution effectively states that Congress has the power to enact +copyright laws for two purposes: 1) to encourage the creation and +dissemination of intellectual works for the good of society as a whole; +and, significantly, 2) to give creators and those who package and +disseminate materials the economic rewards that are due them. + +Congress strives to strike a balance, which at times can become an +emotional issue. The United States has never accepted the notion of the +natural right of an author so much as it has accepted the notion of the +public good and the desirability of incentives to promote it. This state +of affairs, however, has created strains on the international level and +is the reason for several of the differences in the laws that we have. +Today the United States protects almost every kind of work that can be +called an expression of an author. The standard for gaining copyright +protection is simply originality. This is a low standard and means that +a work is not copied from something else, as well as shows a certain +minimal amount of authorship. One can also acquire copyright protection +for making a new version of preexisting material, provided it manifests +some spark of creativity. + +However, copyright does not protect ideas, methods, systems--only the way +that one expresses those things. Nor does copyright protect anything +that is mechanical, anything that does not involve choice, or criteria +concerning whether or not one should do a thing. For example, the +results of a process called declicking, in which one mechanically removes +impure sounds from old recordings, are not copyrightable. On the other +hand, the choice to record a song digitally and to increase the sound of +violins or to bring up the tympani constitutes the results of conversion +that are copyrightable. Moreover, if a work is protected by copyright in +the United States, one generally needs the permission of the copyright +owner to convert it. Normally, who will own the new--that is, converted- +-material is a matter of contract. In the absence of a contract, the +person who creates the new material is the author and owner. But people +do not generally think about the copyright implications until after the +fact. PETERS stressed the need when dealing with copyrighted works to +think about copyright in advance. One's bargaining power is much greater +up front than it is down the road. + +PETERS next discussed works not protected by copyright, for example, any +work done by a federal employee as part of his or her official duties is +in the public domain in the United States. The issue is not wholly free +of doubt concerning whether or not the work is in the public domain +outside the United States. Other materials in the public domain include: +any works published more than seventy-five years ago, and any work +published in the United States more than twenty-eight years ago, whose +copyright was not renewed. In talking about the new technology and +putting material in a digital form to send all over the world, PETERS +cautioned, one must keep in mind that while the rights may not be an +issue in the United States, they may be in different parts of the world, +where most countries previously employed a copyright term of the life of +the author plus fifty years. + +PETERS next reviewed the economics of copyright holding. Simply, +economic rights are the rights to control the reproduction of a work in +any form. They belong to the author, or in the case of a work made for +hire, the employer. The second right, which is critical to conversion, +is the right to change a work. The right to make new versions is perhaps +one of the most significant rights of authors, particularly in an +electronic world. The third right is the right to publish the work and +the right to disseminate it, something that everyone who deals in an +electronic medium needs to know. The basic rule is if a copy is sold, +all rights of distribution are extinguished with the sale of that copy. +The key is that it must be sold. A number of companies overcome this +obstacle by leasing or renting their product. These companies argue that +if the material is rented or leased and not sold, they control the uses +of a work. The fourth right, and one very important in a digital world, +is a right of public performance, which means the right to show the work +sequentially. For example, copyright owners control the showing of a +CD-ROM product in a public place such as a public library. The reverse +side of public performance is something called the right of public +display. Moral rights also exist, which at the federal level apply only +to very limited visual works of art, but in theory may apply under +contract and other principles. Moral rights may include the right of an +author to have his or her name on a work, the right of attribution, and +the right to object to distortion or mutilation--the right of integrity. + +The way copyright law is worded gives much latitude to activities such as +preservation; to use of material for scholarly and research purposes when +the user does not make multiple copies; and to the generation of +facsimile copies of unpublished works by libraries for themselves and +other libraries. But the law does not allow anyone to become the +distributor of the product for the entire world. In today's electronic +environment, publishers are extremely concerned that the entire world is +networked and can obtain the information desired from a single copy in a +single library. Hence, if there is to be only one sale, which publishers +may choose to live with, they will obtain their money in other ways, for +example, from access and use. Hence, the development of site licenses +and other kinds of agreements to cover what publishers believe they +should be compensated for. Any solution that the United States takes +today has to consider the international arena. + +Noting that the United States is a member of the Berne Convention and +subscribes to its provisions, PETERS described the permissions process. +She also defined compulsory licenses. A compulsory license, of which the +United States has had a few, builds into the law the right to use a work +subject to certain terms and conditions. In the international arena, +however, the ability to use compulsory licenses is extremely limited. +Thus, clearinghouses and other collectives comprise one option that has +succeeded in providing for use of a work. Often overlooked when one +begins to use copyrighted material and put products together is how +expensive the permissions process and managing it is. According to +PETERS, the price of copyright in a digital medium, whatever solution is +worked out, will include managing and assembling the database. She +strongly recommended that publishers and librarians or people with +various backgrounds cooperate to work out administratively feasible +systems, in order to produce better results. + +In the lengthy question-and-answer period that followed PETERS's +presentation, the following points emerged: + + * The Copyright Office maintains that anything mechanical and + totally exhaustive probably is not protected. In the event that + what an individual did in developing potentially copyrightable + material is not understood, the Copyright Office will ask about the + creative choices the applicant chose to make or not to make. As a + practical matter, if one believes she or he has made enough of those + choices, that person has a right to assert a copyright and someone + else must assert that the work is not copyrightable. The more + mechanical, the more automatic, a thing is, the less likely it is to + be copyrightable. + + * Nearly all photographs are deemed to be copyrightable, but no one + worries about them much, because everyone is free to take the same + image. Thus, a photographic copyright represents what is called a + "thin" copyright. The photograph itself must be duplicated, in + order for copyright to be violated. + + * The Copyright Office takes the position that X-rays are not + copyrightable because they are mechanical. It can be argued + whether or not image enhancement in scanning can be protected. One + must exercise care with material created with public funds and + generally in the public domain. An article written by a federal + employee, if written as part of official duties, is not + copyrightable. However, control over a scientific article written + by a National Institutes of Health grantee (i.e., someone who + receives money from the U.S. government), depends on NIH policy. If + the government agency has no policy (and that policy can be + contained in its regulations, the contract, or the grant), the + author retains copyright. If a provision of the contract, grant, or + regulation states that there will be no copyright, then it does not + exist. When a work is created, copyright automatically comes into + existence unless something exists that says it does not. + + * An enhanced electronic copy of a print copy of an older reference + work in the public domain that does not contain copyrightable new + material is a purely mechanical rendition of the original work, and + is not copyrightable. + + * Usually, when a work enters the public domain, nothing can remove + it. For example, Congress recently passed into law the concept of + automatic renewal, which means that copyright on any work published + between l964 and l978 does not have to be renewed in order to + receive a seventy-five-year term. But any work not renewed before + 1964 is in the public domain. + + * Concerning whether or not the United States keeps track of when + authors die, nothing was ever done, nor is anything being done at + the moment by the Copyright Office. + + * Software that drives a mechanical process is itself copyrightable. + If one changes platforms, the software itself has a copyright. The + World Intellectual Property Organization will hold a symposium 28 + March through 2 April l993, at Harvard University, on digital + technology, and will study this entire issue. If one purchases a + computer software package, such as MacPaint, and creates something + new, one receives protection only for that which has been added. + +PETERS added that often in copyright matters, rough justice is the +outcome, for example, in collective licensing, ASCAP (i.e., American +Society of Composers, Authors, and Publishers), and BMI (i.e., Broadcast +Music, Inc.), where it may seem that the big guys receive more than their +due. Of course, people ought not to copy a creative product without +paying for it; there should be some compensation. But the truth of the +world, and it is not a great truth, is that the big guy gets played on +the radio more frequently than the little guy, who has to do much more +until he becomes a big guy. That is true of every author, every +composer, everyone, and, unfortunately, is part of life. + +Copyright always originates with the author, except in cases of works +made for hire. (Most software falls into this category.) When an author +sends his article to a journal, he has not relinquished copyright, though +he retains the right to relinquish it. The author receives absolutely +everything. The less prominent the author, the more leverage the +publisher will have in contract negotiations. In order to transfer the +rights, the author must sign an agreement giving them away. + +In an electronic society, it is important to be able to license a writer +and work out deals. With regard to use of a work, it usually is much +easier when a publisher holds the rights. In an electronic era, a real +problem arises when one is digitizing and making information available. +PETERS referred again to electronic licensing clearinghouses. Copyright +ought to remain with the author, but as one moves forward globally in the +electronic arena, a middleman who can handle the various rights becomes +increasingly necessary. + +The notion of copyright law is that it resides with the individual, but +in an on-line environment, where a work can be adapted and tinkered with +by many individuals, there is concern. If changes are authorized and +there is no agreement to the contrary, the person who changes a work owns +the changes. To put it another way, the person who acquires permission +to change a work technically will become the author and the owner, unless +some agreement to the contrary has been made. It is typical for the +original publisher to try to control all of the versions and all of the +uses. Copyright law always only sets up the boundaries. Anything can be +changed by contract. + + ****** + +SESSION VII. CONCLUSION + ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +GENERAL DISCUSSION * Two questions for discussion * Different emphases in +the Workshop * Bringing the text and image partisans together * +Desiderata in planning the long-term development of something * Questions +surrounding the issue of electronic deposit * Discussion of electronic +deposit as an allusion to the issue of standards * Need for a directory +of preservation projects in digital form and for access to their +digitized files * CETH's catalogue of machine-readable texts in the +humanities * What constitutes a publication in the electronic world? * +Need for LC to deal with the concept of on-line publishing * LC's Network +Development Office exploring the limits of MARC as a standard in terms +of handling electronic information * Magnitude of the problem and the +need for distributed responsibility in order to maintain and store +electronic information * Workshop participants to be viewed as a starting +point * Development of a network version of AM urged * A step toward AM's +construction of some sort of apparatus for network access * A delicate +and agonizing policy question for LC * Re the issue of electronic +deposit, LC urged to initiate a catalytic process in terms of distributed +responsibility * Suggestions for cooperative ventures * Commercial +publishers' fears * Strategic questions for getting the image and text +people to think through long-term cooperation * Clarification of the +driving force behind both the Perseus and the Cornell Xerox projects * ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + +In his role as moderator of the concluding session, GIFFORD raised two +questions he believed would benefit from discussion: 1) Are there enough +commonalities among those of us that have been here for two days so that +we can see courses of action that should be taken in the future? And, if +so, what are they and who might take them? 2) Partly derivative from +that, but obviously very dangerous to LC as host, do you see a role for +the Library of Congress in all this? Of course, the Library of Congress +holds a rather special status in a number of these matters, because it is +not perceived as a player with an economic stake in them, but are there +roles that LC can play that can help advance us toward where we are heading? + +Describing himself as an uninformed observer of the technicalities of the +last two days, GIFFORD detected three different emphases in the Workshop: +1) people who are very deeply committed to text; 2) people who are almost +passionate about images; and 3) a few people who are very committed to +what happens to the networks. In other words, the new networking +dimension, the accessibility of the processability, the portability of +all this across the networks. How do we pull those three together? + +Adding a question that reflected HOCKEY's comment that this was the +fourth workshop she had attended in the previous thirty days, FLEISCHHAUER +wondered to what extent this meeting had reinvented the wheel, or if it +had contributed anything in the way of bringing together a different group +of people from those who normally appear on the workshop circuit. + +HOCKEY confessed to being struck at this meeting and the one the +Electronic Pierce Consortium organized the previous week that this was a +coming together of people working on texts and not images. Attempting to +bring the two together is something we ought to be thinking about for the +future: How one can think about working with image material to begin +with, but structuring it and digitizing it in such a way that at a later +stage it can be interpreted into text, and find a common way of building +text and images together so that they can be used jointly in the future, +with the network support to begin there because that is how people will +want to access it. + +In planning the long-term development of something, which is what is +being done in electronic text, HOCKEY stressed the importance not only +of discussing the technical aspects of how one does it but particularly +of thinking about what the people who use the stuff will want to do. +But conversely, there are numerous things that people start to do with +electronic text or material that nobody ever thought of in the beginning. + +LESK, in response to the question concerning the role of the Library of +Congress, remarked the often suggested desideratum of having electronic +deposit: Since everything is now computer-typeset, an entire decade of +material that was machine-readable exists, but the publishers frequently +did not save it; has LC taken any action to have its copyright deposit +operation start collecting these machine-readable versions? In the +absence of PETERS, GIFFORD replied that the question was being +actively considered but that that was only one dimension of the problem. +Another dimension is the whole question of the integrity of the original +electronic document. It becomes highly important in science to prove +authorship. How will that be done? + +ERWAY explained that, under the old policy, to make a claim for a +copyright for works that were published in electronic form, including +software, one had to submit a paper copy of the first and last twenty +pages of code--something that represented the work but did not include +the entire work itself and had little value to anyone. As a temporary +measure, LC has claimed the right to demand electronic versions of +electronic publications. This measure entails a proactive role for the +Library to say that it wants a particular electronic version. Publishers +then have perhaps a year to submit it. But the real problem for LC is +what to do with all this material in all these different formats. Will +the Library mount it? How will it give people access to it? How does LC +keep track of the appropriate computers, software, and media? The situation +is so hard to control, ERWAY said, that it makes sense for each publishing +house to maintain its own archive. But LC cannot enforce that either. + +GIFFORD acknowledged LESK's suggestion that establishing a priority +offered the solution, albeit a fairly complicated one. But who maintains +that register?, he asked. GRABER noted that LC does attempt to collect a +Macintosh version and the IBM-compatible version of software. It does +not collect other versions. But while true for software, BYRUM observed, +this reply does not speak to materials, that is, all the materials that +were published that were on somebody's microcomputer or driver tapes +at a publishing office across the country. LC does well to acquire +specific machine-readable products selectively that were intended to be +machine-readable. Materials that were in machine-readable form at one time, +BYRUM said, would be beyond LC's capability at the moment, insofar as +attempting to acquire, organize, and preserve them are concerned--and +preservation would be the most important consideration. In this +connection, GIFFORD reiterated the need to work out some sense of +distributive responsibility for a number of these issues, which +inevitably will require significant cooperation and discussion. +Nobody can do it all. + +LESK suggested that some publishers may look with favor on LC beginning +to serve as a depository of tapes in an electronic manuscript standard. +Publishers may view this as a service that they did not have to perform +and they might send in tapes. However, SPERBERG-McQUEEN countered, +although publishers have had equivalent services available to them for a +long time, the electronic text archive has never turned away or been +flooded with tapes and is forever sending feedback to the depositor. +Some publishers do send in tapes. + +ANDRE viewed this discussion as an allusion to the issue of standards. +She recommended that the AAP standard and the TEI, which has already been +somewhat harmonized internationally and which also shares several +compatibilities with the AAP, be harmonized to ensure sufficient +compatibility in the software. She drew the line at saying LC ought to +be the locus or forum for such harmonization. + +Taking the group in a slightly different direction, but one where at +least in the near term LC might play a helpful role, LYNCH remarked the +plans of a number of projects to carry out preservation by creating +digital images that will end up in on-line or near-line storage at some +institution. Presumably, LC will link this material somehow to its +on-line catalog in most cases. Thus, it is in a digital form. LYNCH had +the impression that many of these institutions would be willing to make +those files accessible to other people outside the institution, provided +that there is no copyright problem. This desideratum will require +propagating the knowledge that those digitized files exist, so that they +can end up in other on-line catalogs. Although uncertain about the +mechanism for achieving this result, LYNCH said that it warranted +scrutiny because it seemed to be connected to some of the basic issues of +cataloging and distribution of records. It would be foolish, given the +amount of work that all of us have to do and our meager resources, to +discover multiple institutions digitizing the same work. Re microforms, +LYNCH said, we are in pretty good shape. + +BATTIN called this a big problem and noted that the Cornell people (who +had already departed) were working on it. At issue from the beginning +was to learn how to catalog that information into RLIN and then into +OCLC, so that it would be accessible. That issue remains to be resolved. +LYNCH rejoined that putting it into OCLC or RLIN was helpful insofar as +somebody who is thinking of performing preservation activity on that work +could learn about it. It is not necessarily helpful for institutions to +make that available. BATTIN opined that the idea was that it not only be +for preservation purposes but for the convenience of people looking for +this material. She endorsed LYNCH's dictum that duplication of this +effort was to be avoided by every means. + +HOCKEY informed the Workshop about one major current activity of CETH, +namely a catalogue of machine-readable texts in the humanities. Held on +RLIN at present, the catalogue has been concentrated on ASCII as opposed +to digitized images of text. She is exploring ways to improve the +catalogue and make it more widely available, and welcomed suggestions +about these concerns. CETH owns the records, which are not just +restricted to RLIN, and can distribute them however it wishes. + +Taking up LESK's earlier question, BATTIN inquired whether LC, since it +is accepting electronic files and designing a mechanism for dealing with +that rather than putting books on shelves, would become responsible for +the National Copyright Depository of Electronic Materials. Of course +that could not be accomplished overnight, but it would be something LC +could plan for. GIFFORD acknowledged that much thought was being devoted +to that set of problems and returned the discussion to the issue raised +by LYNCH--whether or not putting the kind of records that both BATTIN and +HOCKEY have been talking about in RLIN is not a satisfactory solution. +It seemed to him that RLIN answered LYNCH's original point concerning +some kind of directory for these kinds of materials. In a situation +where somebody is attempting to decide whether or not to scan this or +film that or to learn whether or not someone has already done so, LYNCH +suggested, RLIN is helpful, but it is not helpful in the case of a local, +on-line catalogue. Further, one would like to have her or his system be +aware that that exists in digital form, so that one can present it to a +patron, even though one did not digitize it, if it is out of copyright. +The only way to make those linkages would be to perform a tremendous +amount of real-time look-up, which would be awkward at best, or +periodically to yank the whole file from RLIN and match it against one's +own stuff, which is a nuisance. + +But where, ERWAY inquired, does one stop including things that are +available with Internet, for instance, in one's local catalogue? +It almost seems that that is LC's means to acquire access to them. +That represents LC's new form of library loan. Perhaps LC's new on-line +catalogue is an amalgamation of all these catalogues on line. LYNCH +conceded that perhaps that was true in the very long term, but was not +applicable to scanning in the short term. In his view, the totals cited +by Yale, 10,000 books over perhaps a four-year period, and 1,000-1,500 +books from Cornell, were not big numbers, while searching all over +creation for relatively rare occurrences will prove to be less efficient. +As GIFFORD wondered if this would not be a separable file on RLIN and +could be requested from them, BATTIN interjected that it was easily +accessible to an institution. SEVERTSON pointed out that that file, cum +enhancements, was available with reference information on CD-ROM, which +makes it a little more available. + +In HOCKEY's view, the real question facing the Workshop is what to put in +this catalogue, because that raises the question of what constitutes a +publication in the electronic world. (WEIBEL interjected that Eric Joule +in OCLC's Office of Research is also wrestling with this particular +problem, while GIFFORD thought it sounded fairly generic.) HOCKEY +contended that a majority of texts in the humanities are in the hands +of either a small number of large research institutions or individuals +and are not generally available for anyone else to access at all. +She wondered if these texts ought to be catalogued. + +After argument proceeded back and forth for several minutes over why +cataloguing might be a necessary service, LEBRON suggested that this +issue involved the responsibility of a publisher. The fact that someone +has created something electronically and keeps it under his or her +control does not constitute publication. Publication implies +dissemination. While it would be important for a scholar to let other +people know that this creation exists, in many respects this is no +different from an unpublished manuscript. That is what is being accessed +in there, except that now one is not looking at it in the hard-copy but +in the electronic environment. + +LEBRON expressed puzzlement at the variety of ways electronic publishing +has been viewed. Much of what has been discussed throughout these two +days has concerned CD-ROM publishing, whereas in the on-line environment +that she confronts, the constraints and challenges are very different. +Sooner or later LC will have to deal with the concept of on-line +publishing. Taking up the comment ERWAY made earlier about storing +copies, LEBRON gave her own journal as an example. How would she deposit +OJCCT for copyright?, she asked, because the journal will exist in the +mainframe at OCLC and people will be able to access it. Here the +situation is different, ownership versus access, and is something that +arises with publication in the on-line environment, faster than is +sometimes realized. Lacking clear answers to all of these questions +herself, LEBRON did not anticipate that LC would be able to take a role +in helping to define some of them for quite a while. + +GREENFIELD observed that LC's Network Development Office is attempting, +among other things, to explore the limits of MARC as a standard in terms +of handling electronic information. GREENFIELD also noted that Rebecca +GUENTHER from that office gave a paper to the American Society for +Information Science (ASIS) summarizing several of the discussion papers +that were coming out of the Network Development Office. GREENFIELD said +he understood that that office had a list-server soliciting just the kind +of feedback received today concerning the difficulties of identifying and +cataloguing electronic information. GREENFIELD hoped that everybody +would be aware of that and somehow contribute to that conversation. + +Noting two of LC's roles, first, to act as a repository of record for +material that is copyrighted in this country, and second, to make +materials it holds available in some limited form to a clientele that +goes beyond Congress, BESSER suggested that it was incumbent on LC to +extend those responsibilities to all the things being published in +electronic form. This would mean eventually accepting electronic +formats. LC could require that at some point they be in a certain +limited set of formats, and then develop mechanisms for allowing people +to access those in the same way that other things are accessed. This +does not imply that they are on the network and available to everyone. +LC does that with most of its bibliographic records, BESSER said, which +end up migrating to the utility (e.g., OCLC) or somewhere else. But just +as most of LC's books are available in some form through interlibrary +loan or some other mechanism, so in the same way electronic formats ought +to be available to others in some format, though with some copyright +considerations. BESSER was not suggesting that these mechanisms be +established tomorrow, only that they seemed to fall within LC's purview, +and that there should be long-range plans to establish them. + +Acknowledging that those from LC in the room agreed with BESSER +concerning the need to confront difficult questions, GIFFORD underscored +the magnitude of the problem of what to keep and what to select. GIFFORD +noted that LC currently receives some 31,000 items per day, not counting +electronic materials, and argued for much more distributed responsibility +in order to maintain and store electronic information. + +BESSER responded that the assembled group could be viewed as a starting +point, whose initial operating premise could be helping to move in this +direction and defining how LC could do so, for example, in areas of +standardization or distribution of responsibility. + +FLEISCHHAUER added that AM was fully engaged, wrestling with some of the +questions that pertain to the conversion of older historical materials, +which would be one thing that the Library of Congress might do. Several +points mentioned by BESSER and several others on this question have a +much greater impact on those who are concerned with cataloguing and the +networking of bibliographic information, as well as preservation itself. + +Speaking directly to AM, which he considered was a largely uncopyrighted +database, LYNCH urged development of a network version of AM, or +consideration of making the data in it available to people interested in +doing network multimedia. On account of the current great shortage of +digital data that is both appealing and unencumbered by complex rights +problems, this course of action could have a significant effect on making +network multimedia a reality. + +In this connection, FLEISCHHAUER reported on a fragmentary prototype in +LC's Office of Information Technology Services that attempts to associate +digital images of photographs with cataloguing information in ways that +work within a local area network--a step, so to say, toward AM's +construction of some sort of apparatus for access. Further, AM has +attempted to use standard data forms in order to help make that +distinction between the access tools and the underlying data, and thus +believes that the database is networkable. + +A delicate and agonizing policy question for LC, however, which comes +back to resources and unfortunately has an impact on this, is to find +some appropriate, honorable, and legal cost-recovery possibilities. A +certain skittishness concerning cost-recovery has made people unsure +exactly what to do. AM would be highly receptive to discussing further +LYNCH's offer to test or demonstrate its database in a network +environment, FLEISCHHAUER said. + +Returning the discussion to what she viewed as the vital issue of +electronic deposit, BATTIN recommended that LC initiate a catalytic +process in terms of distributed responsibility, that is, bring together +the distributed organizations and set up a study group to look at all +these issues and see where we as a nation should move. The broader +issues of how we deal with the management of electronic information will +not disappear, but only grow worse. + +LESK took up this theme and suggested that LC attempt to persuade one +major library in each state to deal with its state equivalent publisher, +which might produce a cooperative project that would be equitably +distributed around the country, and one in which LC would be dealing with +a minimal number of publishers and minimal copyright problems. + +GRABER remarked the recent development in the scientific community of a +willingness to use SGML and either deposit or interchange on a fairly +standardized format. He wondered if a similar movement was taking place +in the humanities. Although the National Library of Medicine found only +a few publishers to cooperate in a like venture two or three years ago, a +new effort might generate a much larger number willing to cooperate. + +KIMBALL recounted his unit's (Machine-Readable Collections Reading Room) +troubles with the commercial publishers of electronic media in acquiring +materials for LC's collections, in particular the publishers' fear that +they would not be able to cover their costs and would lose control of +their products, that LC would give them away or sell them and make +profits from them. He doubted that the publishing industry was prepared +to move into this area at the moment, given its resistance to allowing LC +to use its machine-readable materials as the Library would like. + +The copyright law now addresses compact disk as a medium, and LC can +request one copy of that, or two copies if it is the only version, and +can request copies of software, but that fails to address magazines or +books or anything like that which is in machine-readable form. + +GIFFORD acknowledged the thorny nature of this issue, which he illustrated +with the example of the cumbersome process involved in putting a copy of a +scientific database on a LAN in LC's science reading room. He also +acknowledged that LC needs help and could enlist the energies and talents +of Workshop participants in thinking through a number of these problems. + +GIFFORD returned the discussion to getting the image and text people to +think through together where they want to go in the long term. MYLONAS +conceded that her experience at the Pierce Symposium the previous week at +Georgetown University and this week at LC had forced her to reevaluate +her perspective on the usefulness of text as images. MYLONAS framed the +issues in a series of questions: How do we acquire machine-readable +text? Do we take pictures of it and perform OCR on it later? Is it +important to obtain very high-quality images and text, etc.? +FLEISCHHAUER agreed with MYLONAS's framing of strategic questions, adding +that a large institution such as LC probably has to do all of those +things at different times. Thus, the trick is to exercise judgment. The +Workshop had added to his and AM's considerations in making those +judgments. Concerning future meetings or discussions, MYLONAS suggested +that screening priorities would be helpful. + +WEIBEL opined that the diversity reflected in this group was a sign both +of the health and of the immaturity of the field, and more time would +have to pass before we convince one another concerning standards. + +An exchange between MYLONAS and BATTIN clarified the point that the +driving force behind both the Perseus and the Cornell Xerox projects was +the preservation of knowledge for the future, not simply for particular +research use. In the case of Perseus, MYLONAS said, the assumption was +that the texts would not be entered again into electronically readable +form. SPERBERG-McQUEEN added that a scanned image would not serve as an +archival copy for purposes of preservation in the case of, say, the Bill +of Rights, in the sense that the scanned images are effectively the +archival copies for the Cornell mathematics books. + + + *** *** *** ****** *** *** *** + + + Appendix I: PROGRAM + + + + WORKSHOP + ON + ELECTRONIC + TEXTS + + + + 9-10 June 1992 + + Library of Congress + Washington, D.C. + + + + Supported by a Grant from the David and Lucile Packard Foundation + + +Tuesday, 9 June 1992 + +NATIONAL DEMONSTRATION LAB, ATRIUM, LIBRARY MADISON + +8:30 AM Coffee and Danish, registration + +9:00 AM Welcome + + Prosser Gifford, Director for Scholarly Programs, and Carl + Fleischhauer, Coordinator, American Memory, Library of + Congress + +9:l5 AM Session I. Content in a New Form: Who Will Use It and What + Will They Do? + + Broad description of the range of electronic information. + Characterization of who uses it and how it is or may be used. + In addition to a look at scholarly uses, this session will + include a presentation on use by students (K-12 and college) + and the general public. + + Moderator: James Daly + Avra Michelson, Archival Research and Evaluation Staff, + National Archives and Records Administration (Overview) + Susan H. Veccia, Team Leader, American Memory, User Evaluation, + and + Joanne Freeman, Associate Coordinator, American Memory, Library + of Congress (Beyond the scholar) + +10:30- +11:00 AM Break + +11:00 AM Session II. Show and Tell. + + Each presentation to consist of a fifteen-minute + statement/show; group discussion will follow lunch. + + Moderator: Jacqueline Hess, Director, National Demonstration + Lab + + 1. A classics project, stressing texts and text retrieval + more than multimedia: Perseus Project, Harvard + University + Elli Mylonas, Managing Editor + + 2. Other humanities projects employing the emerging norms of + the Text Encoding Initiative (TEI): Chadwyck-Healey's + The English Poetry Full Text Database and/or Patrologia + Latina Database + Eric M. Calaluca, Vice President, Chadwyck-Healey, Inc. + + 3. American Memory + Carl Fleischhauer, Coordinator, and + Ricky Erway, Associate Coordinator, Library of Congress + + 4. Founding Fathers example from Packard Humanities + Institute: The Papers of George Washington, University + of Virginia + Dorothy Twohig, Managing Editor, and/or + David Woodley Packard + + 5. An electronic medical journal offering graphics and + full-text searchability: The Online Journal of Current + Clinical Trials, American Association for the Advancement + of Science + Maria L. Lebron, Managing Editor + + 6. A project that offers facsimile images of pages but omits + searchable text: Cornell math books + Lynne K. Personius, Assistant Director, Cornell + Information Technologies for Scholarly Information + Sources, Cornell University + +12:30 PM Lunch (Dining Room A, Library Madison 620. Exhibits + available.) + +1:30 PM Session II. Show and Tell (Cont'd.). + +3:00- +3:30 PM Break + +3:30- +5:30 PM Session III. Distribution, Networks, and Networking: Options + for Dissemination. + + Published disks: University presses and public-sector + publishers, private-sector publishers + Computer networks + + Moderator: Robert G. Zich, Special Assistant to the Associate + Librarian for Special Projects, Library of Congress + Clifford A. Lynch, Director, Library Automation, University of + California + Howard Besser, School of Library and Information Science, + University of Pittsburgh + Ronald L. Larsen, Associate Director of Libraries for + Information Technology, University of Maryland at College + Park + Edwin B. Brownrigg, Executive Director, Memex Research + Institute + +6:30 PM Reception (Montpelier Room, Library Madison 619.) + + ****** + +Wednesday, 10 June 1992 + +DINING ROOM A, LIBRARY MADISON 620 + +8:30 AM Coffee and Danish + +9:00 AM Session IV. Image Capture, Text Capture, Overview of Text and + Image Storage Formats. + + Moderator: William L. Hooton, Vice President of Operations, + I-NET + + A) Principal Methods for Image Capture of Text: + Direct scanning + Use of microform + + Anne R. Kenney, Assistant Director, Department of Preservation + and Conservation, Cornell University + Pamela Q.J. Andre, Associate Director, Automation, and + Judith A. Zidar, Coordinator, National Agricultural Text + Digitizing Program (NATDP), National Agricultural Library + (NAL) + Donald J. Waters, Head, Systems Office, Yale University Library + + B) Special Problems: + Bound volumes + Conservation + Reproducing printed halftones + + Carl Fleischhauer, Coordinator, American Memory, Library of + Congress + George Thoma, Chief, Communications Engineering Branch, + National Library of Medicine (NLM) + +10:30- +11:00 AM Break + +11:00 AM Session IV. Image Capture, Text Capture, Overview of Text and + Image Storage Formats (Cont'd.). + + C) Image Standards and Implications for Preservation + + Jean Baronas, Senior Manager, Department of Standards and + Technology, Association for Information and Image Management + (AIIM) + Patricia Battin, President, The Commission on Preservation and + Access (CPA) + + D) Text Conversion: + OCR vs. rekeying + Standards of accuracy and use of imperfect texts + Service bureaus + + Stuart Weibel, Senior Research Specialist, Online Computer + Library Center, Inc. (OCLC) + Michael Lesk, Executive Director, Computer Science Research, + Bellcore + Ricky Erway, Associate Coordinator, American Memory, Library of + Congress + Pamela Q.J. Andre, Associate Director, Automation, and + Judith A. Zidar, Coordinator, National Agricultural Text + Digitizing Program (NATDP), National Agricultural Library + (NAL) + +12:30- +1:30 PM Lunch + +1:30 PM Session V. Approaches to Preparing Electronic Texts. + + Discussion of approaches to structuring text for the computer; + pros and cons of text coding, description of methods in + practice, and comparison of text-coding methods. + + Moderator: Susan Hockey, Director, Center for Electronic Texts + in the Humanities (CETH), Rutgers and Princeton Universities + David Woodley Packard + C.M. Sperberg-McQueen, Editor, Text Encoding Initiative (TEI), + University of Illinois-Chicago + Eric M. Calaluca, Vice President, Chadwyck-Healey, Inc. + +3:30- +4:00 PM Break + +4:00 PM Session VI. Copyright Issues. + + Marybeth Peters, Policy Planning Adviser to the Register of + Copyrights, Library of Congress + +5:00 PM Session VII. Conclusion. + + General discussion. + What topics were omitted or given short shrift that anyone + would like to talk about now? + Is there a "group" here? What should the group do next, if + anything? What should the Library of Congress do next, if + anything? + Moderator: Prosser Gifford, Director for Scholarly Programs, + Library of Congress + +6:00 PM Adjourn + + + *** *** *** ****** *** *** *** + + + Appendix II: ABSTRACTS + + +SESSION I + +Avra MICHELSON Forecasting the Use of Electronic Texts by + Social Sciences and Humanities Scholars + +This presentation explores the ways in which electronic texts are likely +to be used by the non-scientific scholarly community. Many of the +remarks are drawn from a report the speaker coauthored with Jeff +Rothenberg, a computer scientist at The RAND Corporation. + +The speaker assesses 1) current scholarly use of information technology +and 2) the key trends in information technology most relevant to the +research process, in order to predict how social sciences and humanities +scholars are apt to use electronic texts. In introducing the topic, +current use of electronic texts is explored broadly within the context of +scholarly communication. From the perspective of scholarly +communication, the work of humanities and social sciences scholars +involves five processes: 1) identification of sources, 2) communication +with colleagues, 3) interpretation and analysis of data, 4) dissemination +of research findings, and 5) curriculum development and instruction. The +extent to which computation currently permeates aspects of scholarly +communication represents a viable indicator of the prospects for +electronic texts. + +The discussion of current practice is balanced by an analysis of key +trends in the scholarly use of information technology. These include the +trends toward end-user computing and connectivity, which provide a +framework for forecasting the use of electronic texts through this +millennium. The presentation concludes with a summary of the ways in +which the nonscientific scholarly community can be expected to use +electronic texts, and the implications of that use for information +providers. + +Susan VECCIA and Joanne FREEMAN Electronic Archives for the Public: + Use of American Memory in Public and + School Libraries + +This joint discussion focuses on nonscholarly applications of electronic +library materials, specifically addressing use of the Library of Congress +American Memory (AM) program in a small number of public and school +libraries throughout the United States. AM consists of selected Library +of Congress primary archival materials, stored on optical media +(CD-ROM/videodisc), and presented with little or no editing. Many +collections are accompanied by electronic introductions and user's guides +offering background information and historical context. Collections +represent a variety of formats including photographs, graphic arts, +motion pictures, recorded sound, music, broadsides and manuscripts, +books, and pamphlets. + +In 1991, the Library of Congress began a nationwide evaluation of AM in +different types of institutions. Test sites include public libraries, +elementary and secondary school libraries, college and university +libraries, state libraries, and special libraries. Susan VECCIA and +Joanne FREEMAN will discuss their observations on the use of AM by the +nonscholarly community, using evidence gleaned from this ongoing +evaluation effort. + +VECCIA will comment on the overall goals of the evaluation project, and +the types of public and school libraries included in this study. Her +comments on nonscholarly use of AM will focus on the public library as a +cultural and community institution, often bridging the gap between formal +and informal education. FREEMAN will discuss the use of AM in school +libraries. Use by students and teachers has revealed some broad +questions about the use of electronic resources, as well as definite +benefits gained by the "nonscholar." Topics will include the problem of +grasping content and context in an electronic environment, the stumbling +blocks created by "new" technologies, and the unique skills and interests +awakened through use of electronic resources. + +SESSION II + +Elli MYLONAS The Perseus Project: Interactive Sources and + Studies in Classical Greece + +The Perseus Project (5) has just released Perseus 1.0, the first publicly +available version of its hypertextual database of multimedia materials on +classical Greece. Perseus is designed to be used by a wide audience, +comprised of readers at the student and scholar levels. As such, it must +be able to locate information using different strategies, and it must +contain enough detail to serve the different needs of its users. In +addition, it must be delivered so that it is affordable to its target +audience. [These problems and the solutions we chose are described in +Mylonas, "An Interface to Classical Greek Civilization," JASIS 43:2, +March 1992.] + +In order to achieve its objective, the project staff decided to make a +conscious separation between selecting and converting textual, database, +and image data on the one hand, and putting it into a delivery system on +the other. That way, it is possible to create the electronic data +without thinking about the restrictions of the delivery system. We have +made a great effort to choose system-independent formats for our data, +and to put as much thought and work as possible into structuring it so +that the translation from paper to electronic form will enhance the value +of the data. [A discussion of these solutions as of two years ago is in +Elli Mylonas, Gregory Crane, Kenneth Morrell, and D. Neel Smith, "The +Perseus Project: Data in the Electronic Age," in Accessing Antiquity: +The Computerization of Classical Databases, J. Solomon and T. Worthen +(eds.), University of Arizona Press, in press.] + +Much of the work on Perseus is focused on collecting and converting the +data on which the project is based. At the same time, it is necessary to +provide means of access to the information, in order to make it usable, +and them to investigate how it is used. As we learn more about what +students and scholars from different backgrounds do with Perseus, we can +adjust our data collection, and also modify the system to accommodate +them. In creating a delivery system for general use, we have tried to +avoid favoring any one type of use by allowing multiple forms of access +to and navigation through the system. + +The way text is handled exemplifies some of these principles. All text +in Perseus is tagged using SGML, following the guidelines of the Text +Encoding Initiative (TEI). This markup is used to index the text, and +process it so that it can be imported into HyperCard. No SGML markup +remains in the text that reaches the user, because currently it would be +too expensive to create a system that acts on SGML in real time. +However, the regularity provided by SGML is essential for verifying the +content of the texts, and greatly speeds all the processing performed on +them. The fact that the texts exist in SGML ensures that they will be +relatively easy to port to different hardware and software, and so will +outlast the current delivery platform. Finally, the SGML markup +incorporates existing canonical reference systems (chapter, verse, line, +etc.); indexing and navigation are based on these features. This ensures +that the same canonical reference will always resolve to the same point +within a text, and that all versions of our texts, regardless of delivery +platform (even paper printouts) will function the same way. + +In order to provide tools for users, the text is processed by a +morphological analyzer, and the results are stored in a database. +Together with the index, the Greek-English Lexicon, and the index of all +the English words in the definitions of the lexicon, the morphological +analyses comprise a set of linguistic tools that allow users of all +levels to work with the textual information, and to accomplish different +tasks. For example, students who read no Greek may explore a concept as +it appears in Greek texts by using the English-Greek index, and then +looking up works in the texts and translations, or scholars may do +detailed morphological studies of word use by using the morphological +analyses of the texts. Because these tools were not designed for any one +use, the same tools and the same data can be used by both students and +scholars. + +NOTES: + (5) Perseus is based at Harvard University, with collaborators at + several other universities. The project has been funded primarily + by the Annenberg/CPB Project, as well as by Harvard University, + Apple Computer, and others. It is published by Yale University + Press. Perseus runs on Macintosh computers, under the HyperCard + program. + +Eric CALALUCA + +Chadwyck-Healey embarked last year on two distinct yet related full-text +humanities database projects. + +The English Poetry Full-Text Database and the Patrologia Latina Database +represent new approaches to linguistic research resources. The size and +complexity of the projects present problems for electronic publishers, +but surmountable ones if they remain abreast of the latest possibilities +in data capture and retrieval software techniques. + +The issues which required address prior to the commencement of the +projects were legion: + + 1. Editorial selection (or exclusion) of materials in each + database + + 2. Deciding whether or not to incorporate a normative encoding + structure into the databases? + A. If one is selected, should it be SGML? + B. If SGML, then the TEI? + + 3. Deliver as CD-ROM, magnetic tape, or both? + + 4. Can one produce retrieval software advanced enough for the + postdoctoral linguist, yet accessible enough for unattended + general use? Should one try? + + 5. Re fair and liberal networking policies, what are the risks to + an electronic publisher? + + 6. How does the emergence of national and international education + networks affect the use and viability of research projects + requiring high investment? Do the new European Community + directives concerning database protection necessitate two + distinct publishing projects, one for North America and one for + overseas? + +From new notions of "scholarly fair use" to the future of optical media, +virtually every issue related to electronic publishing was aired. The +result is two projects which have been constructed to provide the quality +research resources with the fewest encumbrances to use by teachers and +private scholars. + +Dorothy TWOHIG + +In spring 1988 the editors of the papers of George Washington, John +Adams, Thomas Jefferson, James Madison, and Benjamin Franklin were +approached by classics scholar David Packard on behalf of the Packard +Humanities Foundation with a proposal to produce a CD-ROM edition of the +complete papers of each of the Founding Fathers. This electronic edition +will supplement the published volumes, making the documents widely +available to students and researchers at reasonable cost. We estimate +that our CD-ROM edition of Washington's Papers will be substantially +completed within the next two years and ready for publication. Within +the next ten years or so, similar CD-ROM editions of the Franklin, Adams, +Jefferson, and Madison papers also will be available. At the Library of +Congress's session on technology, I would like to discuss not only the +experience of the Washington Papers in producing the CD-ROM edition, but +the impact technology has had on these major editorial projects. +Already, we are editing our volumes with an eye to the material that will +be readily available in the CD-ROM edition. The completed electronic +edition will provide immense possibilities for the searching of documents +for information in a way never possible before. The kind of technical +innovations that are currently available and on the drawing board will +soon revolutionize historical research and the production of historical +documents. Unfortunately, much of this new technology is not being used +in the planning stages of historical projects, simply because many +historians are aware only in the vaguest way of its existence. At least +two major new historical editing projects are considering microfilm +editions, simply because they are not aware of the possibilities of +electronic alternatives and the advantages of the new technology in terms +of flexibility and research potential compared to microfilm. In fact, +too many of us in history and literature are still at the stage of +struggling with our PCs. There are many historical editorial projects in +progress presently, and an equal number of literary projects. While the +two fields have somewhat different approaches to textual editing, there +are ways in which electronic technology can be of service to both. + +Since few of the editors involved in the Founding Fathers CD-ROM editions +are technical experts in any sense, I hope to point out in my discussion +of our experience how many of these electronic innovations can be used +successfully by scholars who are novices in the world of new technology. +One of the major concerns of the sponsors of the multitude of new +scholarly editions is the limited audience reached by the published +volumes. Most of these editions are being published in small quantities +and the publishers' price for them puts them out of the reach not only of +individual scholars but of most public libraries and all but the largest +educational institutions. However, little attention is being given to +ways in which technology can bypass conventional publication to make +historical and literary documents more widely available. + +What attracted us most to the CD-ROM edition of The Papers of George +Washington was the fact that David Packard's aim was to make a complete +edition of all of the 135,000 documents we have collected available in an +inexpensive format that would be placed in public libraries, small +colleges, and even high schools. This would provide an audience far +beyond our present 1,000-copy, $45 published edition. Since the CD-ROM +edition will carry none of the explanatory annotation that appears in the +published volumes, we also feel that the use of the CD-ROM will lead many +researchers to seek out the published volumes. + +In addition to ignorance of new technical advances, I have found that too +many editors--and historians and literary scholars--are resistant and +even hostile to suggestions that electronic technology may enhance their +work. I intend to discuss some of the arguments traditionalists are +advancing to resist technology, ranging from distrust of the speed with +which it changes (we are already wondering what is out there that is +better than CD-ROM) to suspicion of the technical language used to +describe electronic developments. + +Maria LEBRON + +The Online Journal of Current Clinical Trials, a joint venture of the +American Association for the Advancement of Science (AAAS) and the Online +Computer Library Center, Inc. (OCLC), is the first peer-reviewed journal +to provide full text, tabular material, and line illustrations on line. +This presentation will discuss the genesis and start-up period of the +journal. Topics of discussion will include historical overview, +day-to-day management of the editorial peer review, and manuscript +tagging and publication. A demonstration of the journal and its features +will accompany the presentation. + +Lynne PERSONIUS + +Cornell University Library, Cornell Information Technologies, and Xerox +Corporation, with the support of the Commission on Preservation and +Access, and Sun Microsystems, Inc., have been collaborating in a project +to test a prototype system for recording brittle books as digital images +and producing, on demand, high-quality archival paper replacements. The +project goes beyond that, however, to investigate some of the issues +surrounding scanning, storing, retrieving, and providing access to +digital images in a network environment. + +The Joint Study in Digital Preservation began in January 1990. Xerox +provided the College Library Access and Storage System (CLASS) software, +a prototype 600-dots-per-inch (dpi) scanner, and the hardware necessary +to support network printing on the DocuTech printer housed in Cornell's +Computing and Communications Center (CCC). + +The Cornell staff using the hardware and software became an integral part +of the development and testing process for enhancements to the CLASS +software system. The collaborative nature of this relationship is +resulting in a system that is specifically tailored to the preservation +application. + +A digital library of 1,000 volumes (or approximately 300,000 images) has +been created and is stored on an optical jukebox that resides in CCC. +The library includes a collection of select mathematics monographs that +provides mathematics faculty with an opportunity to use the electronic +library. The remaining volumes were chosen for the library to test the +various capabilities of the scanning system. + +One project objective is to provide users of the Cornell library and the +library staff with the ability to request facsimiles of digitized images +or to retrieve the actual electronic image for browsing. A prototype +viewing workstation has been created by Xerox, with input into the design +by a committee of Cornell librarians and computer professionals. This +will allow us to experiment with patron access to the images that make up +the digital library. The viewing station provides search, retrieval, and +(ultimately) printing functions with enhancements to facilitate +navigation through multiple documents. + +Cornell currently is working to extend access to the digital library to +readers using workstations from their offices. This year is devoted to +the development of a network resident image conversion and delivery +server, and client software that will support readers who use Apple +Macintosh computers, IBM windows platforms, and Sun workstations. +Equipment for this development was provided by Sun Microsystems with +support from the Commission on Preservation and Access. + +During the show-and-tell session of the Workshop on Electronic Texts, a +prototype view station will be demonstrated. In addition, a display of +original library books that have been digitized will be available for +review with associated printed copies for comparison. The fifteen-minute +overview of the project will include a slide presentation that +constitutes a "tour" of the preservation digitizing process. + +The final network-connected version of the viewing station will provide +library users with another mechanism for accessing the digital library, +and will also provide the capability of viewing images directly. This +will not require special software, although a powerful computer with good +graphics will be needed. + +The Joint Study in Digital Preservation has generated a great deal of +interest in the library community. Unfortunately, or perhaps +fortunately, this project serves to raise a vast number of other issues +surrounding the use of digital technology for the preservation and use of +deteriorating library materials, which subsequent projects will need to +examine. Much work remains. + +SESSION III + +Howard BESSER Networking Multimedia Databases + +What do we have to consider in building and distributing databases of +visual materials in a multi-user environment? This presentation examines +a variety of concerns that need to be addressed before a multimedia +database can be set up in a networked environment. + +In the past it has not been feasible to implement databases of visual +materials in shared-user environments because of technological barriers. +Each of the two basic models for multi-user multimedia databases has +posed its own problem. The analog multimedia storage model (represented +by Project Athena's parallel analog and digital networks) has required an +incredibly complex (and expensive) infrastructure. The economies of +scale that make multi-user setups cheaper per user served do not operate +in an environment that requires a computer workstation, videodisc player, +and two display devices for each user. + +The digital multimedia storage model has required vast amounts of storage +space (as much as one gigabyte per thirty still images). In the past the +cost of such a large amount of storage space made this model a +prohibitive choice as well. But plunging storage costs are finally +making this second alternative viable. + +If storage no longer poses such an impediment, what do we need to +consider in building digitally stored multi-user databases of visual +materials? This presentation will examine the networking and +telecommunication constraints that must be overcome before such databases +can become commonplace and useful to a large number of people. + +The key problem is the vast size of multimedia documents, and how this +affects not only storage but telecommunications transmission time. +Anything slower than T-1 speed is impractical for files of 1 megabyte or +larger (which is likely to be small for a multimedia document). For +instance, even on a 56 Kb line it would take three minutes to transfer a +1-megabyte file. And these figures assume ideal circumstances, and do +not take into consideration other users contending for network bandwidth, +disk access time, or the time needed for remote display. Current common +telephone transmission rates would be completely impractical; few users +would be willing to wait the hour necessary to transmit a single image at +2400 baud. + +This necessitates compression, which itself raises a number of other +issues. In order to decrease file sizes significantly, we must employ +lossy compression algorithms. But how much quality can we afford to +lose? To date there has been only one significant study done of +image-quality needs for a particular user group, and this study did not +look at loss resulting from compression. Only after identifying +image-quality needs can we begin to address storage and network bandwidth +needs. + +Experience with X-Windows-based applications (such as Imagequery, the +University of California at Berkeley image database) demonstrates the +utility of a client-server topology, but also points to the limitation of +current software for a distributed environment. For example, +applications like Imagequery can incorporate compression, but current X +implementations do not permit decompression at the end user's +workstation. Such decompression at the host computer alleviates storage +capacity problems while doing nothing to address problems of +telecommunications bandwidth. + +We need to examine the effects on network through-put of moving +multimedia documents around on a network. We need to examine various +topologies that will help us avoid bottlenecks around servers and +gateways. Experience with applications such as these raise still broader +questions. How closely is the multimedia document tied to the software +for viewing it? Can it be accessed and viewed from other applications? +Experience with the MARC format (and more recently with the Z39.50 +protocols) shows how useful it can be to store documents in a form in +which they can be accessed by a variety of application software. + +Finally, from an intellectual-access standpoint, we need to address the +issue of providing access to these multimedia documents in +interdisciplinary environments. We need to examine terminology and +indexing strategies that will allow us to provide access to this material +in a cross-disciplinary way. + +Ronald LARSEN Directions in High-Performance Networking for + Libraries + +The pace at which computing technology has advanced over the past forty +years shows no sign of abating. Roughly speaking, each five-year period +has yielded an order-of-magnitude improvement in price and performance of +computing equipment. No fundamental hurdles are likely to prevent this +pace from continuing for at least the next decade. It is only in the +past five years, though, that computing has become ubiquitous in +libraries, affecting all staff and patrons, directly or indirectly. + +During these same five years, communications rates on the Internet, the +principal academic computing network, have grown from 56 kbps to 1.5 +Mbps, and the NSFNet backbone is now running 45 Mbps. Over the next five +years, communication rates on the backbone are expected to exceed 1 Gbps. +Growth in both the population of network users and the volume of network +traffic has continued to grow geometrically, at rates approaching 15 +percent per month. This flood of capacity and use, likened by some to +"drinking from a firehose," creates immense opportunities and challenges +for libraries. Libraries must anticipate the future implications of this +technology, participate in its development, and deploy it to ensure +access to the world's information resources. + +The infrastructure for the information age is being put in place. +Libraries face strategic decisions about their role in the development, +deployment, and use of this infrastructure. The emerging infrastructure +is much more than computers and communication lines. It is more than the +ability to compute at a remote site, send electronic mail to a peer +across the country, or move a file from one library to another. The next +five years will witness substantial development of the information +infrastructure of the network. + +In order to provide appropriate leadership, library professionals must +have a fundamental understanding of and appreciation for computer +networking, from local area networks to the National Research and +Education Network (NREN). This presentation addresses these +fundamentals, and how they relate to libraries today and in the near +future. + +Edwin BROWNRIGG Electronic Library Visions and Realities + +The electronic library has been a vision desired by many--and rejected by +some--since Vannevar Bush coined the term memex to describe an automated, +intelligent, personal information system. Variations on this vision have +included Ted Nelson's Xanadau, Alan Kay's Dynabook, and Lancaster's +"paperless library," with the most recent incarnation being the +"Knowledge Navigator" described by John Scully of Apple. But the reality +of library service has been less visionary and the leap to the electronic +library has eluded universities, publishers, and information technology +files. + +The Memex Research Institute (MemRI), an independent, nonprofit research +and development organization, has created an Electronic Library Program +of shared research and development in order to make the collective vision +more concrete. The program is working toward the creation of large, +indexed publicly available electronic image collections of published +documents in academic, special, and public libraries. This strategic +plan is the result of the first stage of the program, which has been an +investigation of the information technologies available to support such +an effort, the economic parameters of electronic service compared to +traditional library operations, and the business and political factors +affecting the shift from print distribution to electronic networked +access. + +The strategic plan envisions a combination of publicly searchable access +databases, image (and text) document collections stored on network "file +servers," local and remote network access, and an intellectual property +management-control system. This combination of technology and +information content is defined in this plan as an E-library or E-library +collection. Some participating sponsors are already developing projects +based on MemRI's recommended directions. + +The E-library strategy projected in this plan is a visionary one that can +enable major changes and improvements in academic, public, and special +library service. This vision is, though, one that can be realized with +today's technology. At the same time, it will challenge the political +and social structure within which libraries operate: in academic +libraries, the traditional emphasis on local collections, extending to +accreditation issues; in public libraries, the potential of electronic +branch and central libraries fully available to the public; and for +special libraries, new opportunities for shared collections and networks. + +The environment in which this strategic plan has been developed is, at +the moment, dominated by a sense of library limits. The continued +expansion and rapid growth of local academic library collections is now +clearly at an end. Corporate libraries, and even law libraries, are +faced with operating within a difficult economic climate, as well as with +very active competition from commercial information sources. For +example, public libraries may be seen as a desirable but not critical +municipal service in a time when the budgets of safety and health +agencies are being cut back. + +Further, libraries in general have a very high labor-to-cost ratio in +their budgets, and labor costs are still increasing, notwithstanding +automation investments. It is difficult for libraries to obtain capital, +startup, or seed funding for innovative activities, and those +technology-intensive initiatives that offer the potential of decreased +labor costs can provoke the opposition of library staff. + +However, libraries have achieved some considerable successes in the past +two decades by improving both their service and their credibility within +their organizations--and these positive changes have been accomplished +mostly with judicious use of information technologies. The advances in +computing and information technology have been well-chronicled: the +continuing precipitous drop in computing costs, the growth of the +Internet and private networks, and the explosive increase in publicly +available information databases. + +For example, OCLC has become one of the largest computer network +organizations in the world by creating a cooperative cataloging network +of more than 6,000 libraries worldwide. On-line public access catalogs +now serve millions of users on more than 50,000 dedicated terminals in +the United States alone. The University of California MELVYL on-line +catalog system has now expanded into an index database reference service +and supports more than six million searches a year. And, libraries have +become the largest group of customers of CD-ROM publishing technology; +more than 30,000 optical media publications such as those offered by +InfoTrac and Silver Platter are subscribed to by U.S. libraries. + +This march of technology continues and in the next decade will result in +further innovations that are extremely difficult to predict. What is +clear is that libraries can now go beyond automation of their order files +and catalogs to automation of their collections themselves--and it is +possible to circumvent the fiscal limitations that appear to obtain +today. + +This Electronic Library Strategic Plan recommends a paradigm shift in +library service, and demonstrates the steps necessary to provide improved +library services with limited capacities and operating investments. + +SESSION IV-A + +Anne KENNEY + +The Cornell/Xerox Joint Study in Digital Preservation resulted in the +recording of 1,000 brittle books as 600-dpi digital images and the +production, on demand, of high-quality and archivally sound paper +replacements. The project, which was supported by the Commission on +Preservation and Access, also investigated some of the issues surrounding +scanning, storing, retrieving, and providing access to digital images in +a network environment. + +Anne Kenney will focus on some of the issues surrounding direct scanning +as identified in the Cornell Xerox Project. Among those to be discussed +are: image versus text capture; indexing and access; image-capture +capabilities; a comparison to photocopy and microfilm; production and +cost analysis; storage formats, protocols, and standards; and the use of +this scanning technology for preservation purposes. + +The 600-dpi digital images produced in the Cornell Xerox Project proved +highly acceptable for creating paper replacements of deteriorating +originals. The 1,000 scanned volumes provided an array of image-capture +challenges that are common to nineteenth-century printing techniques and +embrittled material, and that defy the use of text-conversion processes. +These challenges include diminished contrast between text and background, +fragile and deteriorated pages, uneven printing, elaborate type faces, +faint and bold text adjacency, handwritten text and annotations, nonRoman +languages, and a proliferation of illustrated material embedded in text. +The latter category included high-frequency and low-frequency halftones, +continuous tone photographs, intricate mathematical drawings, maps, +etchings, reverse-polarity drawings, and engravings. + +The Xerox prototype scanning system provided a number of important +features for capturing this diverse material. Technicians used multiple +threshold settings, filters, line art and halftone definitions, +autosegmentation, windowing, and software-editing programs to optimize +image capture. At the same time, this project focused on production. +The goal was to make scanning as affordable and acceptable as +photocopying and microfilming for preservation reformatting. A +time-and-cost study conducted during the last three months of this +project confirmed the economic viability of digital scanning, and these +findings will be discussed here. + +From the outset, the Cornell Xerox Project was predicated on the use of +nonproprietary standards and the use of common protocols when standards +did not exist. Digital files were created as TIFF images which were +compressed prior to storage using Group 4 CCITT compression. The Xerox +software is MS DOS based and utilizes off-the shelf programs such as +Microsoft Windows and Wang Image Wizard. The digital library is designed +to be hardware-independent and to provide interchangeability with other +institutions through network connections. Access to the digital files +themselves is two-tiered: Bibliographic records for the computer files +are created in RLIN and Cornell's local system and access into the actual +digital images comprising a book is provided through a document control +structure and a networked image file-server, both of which will be +described. + +The presentation will conclude with a discussion of some of the issues +surrounding the use of this technology as a preservation tool (storage, +refreshing, backup). + +Pamela ANDRE and Judith ZIDAR + +The National Agricultural Library (NAL) has had extensive experience with +raster scanning of printed materials. Since 1987, the Library has +participated in the National Agricultural Text Digitizing Project (NATDP) +a cooperative effort between NAL and forty-five land grant university +libraries. An overview of the project will be presented, giving its +history and NAL's strategy for the future. + +An in-depth discussion of NATDP will follow, including a description of +the scanning process, from the gathering of the printed materials to the +archiving of the electronic pages. The type of equipment required for a +stand-alone scanning workstation and the importance of file management +software will be discussed. Issues concerning the images themselves will +be addressed briefly, such as image format; black and white versus color; +gray scale versus dithering; and resolution. + +Also described will be a study currently in progress by NAL to evaluate +the usefulness of converting microfilm to electronic images in order to +improve access. With the cooperation of Tuskegee University, NAL has +selected three reels of microfilm from a collection of sixty-seven reels +containing the papers, letters, and drawings of George Washington Carver. +The three reels were converted into 3,500 electronic images using a +specialized microfilm scanner. The selection, filming, and indexing of +this material will be discussed. + +Donald WATERS + +Project Open Book, the Yale University Library's effort to convert 10, +000 books from microfilm to digital imagery, is currently in an advanced +state of planning and organization. The Yale Library has selected a +major vendor to serve as a partner in the project and as systems +integrator. In its proposal, the successful vendor helped isolate areas +of risk and uncertainty as well as key issues to be addressed during the +life of the project. The Yale Library is now poised to decide what +material it will convert to digital image form and to seek funding, +initially for the first phase and then for the entire project. + +The proposal that Yale accepted for the implementation of Project Open +Book will provide at the end of three phases a conversion subsystem, +browsing stations distributed on the campus network within the Yale +Library, a subsystem for storing 10,000 books at 200 and 600 dots per +inch, and network access to the image printers. Pricing for the system +implementation assumes the existence of Yale's campus ethernet network +and its high-speed image printers, and includes other requisite hardware +and software, as well as system integration services. Proposed operating +costs include hardware and software maintenance, but do not include +estimates for the facilities management of the storage devices and image +servers. + +Yale selected its vendor partner in a formal process, partly funded by +the Commission for Preservation and Access. Following a request for +proposal, the Yale Library selected two vendors as finalists to work with +Yale staff to generate a detailed analysis of requirements for Project +Open Book. Each vendor used the results of the requirements analysis to +generate and submit a formal proposal for the entire project. This +competitive process not only enabled the Yale Library to select its +primary vendor partner but also revealed much about the state of the +imaging industry, about the varying, corporate commitments to the markets +for imaging technology, and about the varying organizational dynamics +through which major companies are responding to and seeking to develop +these markets. + +Project Open Book is focused specifically on the conversion of images +from microfilm to digital form. The technology for scanning microfilm is +readily available but is changing rapidly. In its project requirements, +the Yale Library emphasized features of the technology that affect the +technical quality of digital image production and the costs of creating +and storing the image library: What levels of digital resolution can be +achieved by scanning microfilm? How does variation in the quality of +microfilm, particularly in film produced to preservation standards, +affect the quality of the digital images? What technologies can an +operator effectively and economically apply when scanning film to +separate two-up images and to control for and correct image +imperfections? How can quality control best be integrated into +digitizing work flow that includes document indexing and storage? + +The actual and expected uses of digital images--storage, browsing, +printing, and OCR--help determine the standards for measuring their +quality. Browsing is especially important, but the facilities available +for readers to browse image documents is perhaps the weakest aspect of +imaging technology and most in need of development. As it defined its +requirements, the Yale Library concentrated on some fundamental aspects +of usability for image documents: Does the system have sufficient +flexibility to handle the full range of document types, including +monographs, multi-part and multivolume sets, and serials, as well as +manuscript collections? What conventions are necessary to identify a +document uniquely for storage and retrieval? Where is the database of +record for storing bibliographic information about the image document? +How are basic internal structures of documents, such as pagination, made +accessible to the reader? How are the image documents physically +presented on the screen to the reader? + +The Yale Library designed Project Open Book on the assumption that +microfilm is more than adequate as a medium for preserving the content of +deteriorated library materials. As planning in the project has advanced, +it is increasingly clear that the challenge of digital image technology +and the key to the success of efforts like Project Open Book is to +provide a means of both preserving and improving access to those +deteriorated materials. + +SESSION IV-B + +George THOMA + +In the use of electronic imaging for document preservation, there are +several issues to consider, such as: ensuring adequate image quality, +maintaining substantial conversion rates (through-put), providing unique +identification for automated access and retrieval, and accommodating +bound volumes and fragile material. + +To maintain high image quality, image processing functions are required +to correct the deficiencies in the scanned image. Some commercially +available systems include these functions, while some do not. The +scanned raw image must be processed to correct contrast deficiencies-- +both poor overall contrast resulting from light print and/or dark +background, and variable contrast resulting from stains and +bleed-through. Furthermore, the scan density must be adequate to allow +legibility of print and sufficient fidelity in the pseudo-halftoned gray +material. Borders or page-edge effects must be removed for both +compactibility and aesthetics. Page skew must be corrected for aesthetic +reasons and to enable accurate character recognition if desired. +Compound images consisting of both two-toned text and gray-scale +illustrations must be processed appropriately to retain the quality of +each. + +SESSION IV-C + +Jean BARONAS + +Standards publications being developed by scientists, engineers, and +business managers in Association for Information and Image Management +(AIIM) standards committees can be applied to electronic image management +(EIM) processes including: document (image) transfer, retrieval and +evaluation; optical disk and document scanning; and document design and +conversion. When combined with EIM system planning and operations, +standards can assist in generating image databases that are +interchangeable among a variety of systems. The applications of +different approaches for image-tagging, indexing, compression, and +transfer often cause uncertainty concerning EIM system compatibility, +calibration, performance, and upward compatibility, until standard +implementation parameters are established. The AIIM standards that are +being developed for these applications can be used to decrease the +uncertainty, successfully integrate imaging processes, and promote "open +systems." AIIM is an accredited American National Standards Institute +(ANSI) standards developer with more than twenty committees comprised of +300 volunteers representing users, vendors, and manufacturers. The +standards publications that are developed in these committees have +national acceptance and provide the basis for international harmonization +in the development of new International Organization for Standardization +(ISO) standards. + +This presentation describes the development of AIIM's EIM standards and a +new effort at AIIM, a database on standards projects in a wide framework +of imaging industries including capture, recording, processing, +duplication, distribution, display, evaluation, and preservation. The +AIIM Imagery Database will cover imaging standards being developed by +many organizations in many different countries. It will contain +standards publications' dates, origins, related national and +international projects, status, key words, and abstracts. The ANSI Image +Technology Standards Board requested that such a database be established, +as did the ISO/International Electrotechnical Commission Joint Task Force +on Imagery. AIIM will take on the leadership role for the database and +coordinate its development with several standards developers. + +Patricia BATTIN + + Characteristics of standards for digital imagery: + + * Nature of digital technology implies continuing volatility. + + * Precipitous standard-setting not possible and probably not + desirable. + + * Standards are a complex issue involving the medium, the + hardware, the software, and the technical capacity for + reproductive fidelity and clarity. + + * The prognosis for reliable archival standards (as defined by + librarians) in the foreseeable future is poor. + + Significant potential and attractiveness of digital technology as a + preservation medium and access mechanism. + + Productive use of digital imagery for preservation requires a + reconceptualizing of preservation principles in a volatile, + standardless world. + + Concept of managing continuing access in the digital environment + rather than focusing on the permanence of the medium and long-term + archival standards developed for the analog world. + + Transition period: How long and what to do? + + * Redefine "archival." + + * Remove the burden of "archival copy" from paper artifacts. + + * Use digital technology for storage, develop management + strategies for refreshing medium, hardware and software. + + * Create acid-free paper copies for transition period backup + until we develop reliable procedures for ensuring continuing + access to digital files. + +SESSION IV-D + +Stuart WEIBEL The Role of SGML Markup in the CORE Project (6) + +The emergence of high-speed telecommunications networks as a basic +feature of the scholarly workplace is driving the demand for electronic +document delivery. Three distinct categories of electronic +publishing/republishing are necessary to support access demands in this +emerging environment: + + 1.) Conversion of paper or microfilm archives to electronic format + 2.) Conversion of electronic files to formats tailored to + electronic retrieval and display + 3.) Primary electronic publishing (materials for which the + electronic version is the primary format) + +OCLC has experimental or product development activities in each of these +areas. Among the challenges that lie ahead is the integration of these +three types of information stores in coherent distributed systems. + +The CORE (Chemistry Online Retrieval Experiment) Project is a model for +the conversion of large text and graphics collections for which +electronic typesetting files are available (category 2). The American +Chemical Society has made available computer typography files dating from +1980 for its twenty journals. This collection of some 250 journal-years +is being converted to an electronic format that will be accessible +through several end-user applications. + +The use of Standard Generalized Markup Language (SGML) offers the means +to capture the structural richness of the original articles in a way that +will support a variety of retrieval, navigation, and display options +necessary to navigate effectively in very large text databases. + +An SGML document consists of text that is marked up with descriptive tags +that specify the function of a given element within the document. As a +formal language construct, an SGML document can be parsed against a +document-type definition (DTD) that unambiguously defines what elements +are allowed and where in the document they can (or must) occur. This +formalized map of article structure allows the user interface design to +be uncoupled from the underlying database system, an important step +toward interoperability. Demonstration of this separability is a part of +the CORE project, wherein user interface designs born of very different +philosophies will access the same database. + +NOTES: + (6) The CORE project is a collaboration among Cornell University's + Mann Library, Bell Communications Research (Bellcore), the American + Chemical Society (ACS), the Chemical Abstracts Service (CAS), and + OCLC. + +Michael LESK The CORE Electronic Chemistry Library + +A major on-line file of chemical journal literature complete with +graphics is being developed to test the usability of fully electronic +access to documents, as a joint project of Cornell University, the +American Chemical Society, the Chemical Abstracts Service, OCLC, and +Bellcore (with additional support from Sun Microsystems, Springer-Verlag, +DigitaI Equipment Corporation, Sony Corporation of America, and Apple +Computers). Our file contains the American Chemical Society's on-line +journals, supplemented with the graphics from the paper publication. The +indexing of the articles from Chemical Abstracts Documents is available +in both image and text format, and several different interfaces can be +used. Our goals are (1) to assess the effectiveness and acceptability of +electronic access to primary journals as compared with paper, and (2) to +identify the most desirable functions of the user interface to an +electronic system of journals, including in particular a comparison of +page-image display with ASCII display interfaces. Early experiments with +chemistry students on a variety of tasks suggest that searching tasks are +completed much faster with any electronic system than with paper, but +that for reading all versions of the articles are roughly equivalent. + +Pamela ANDRE and Judith ZIDAR + +Text conversion is far more expensive and time-consuming than image +capture alone. NAL's experience with optical character recognition (OCR) +will be related and compared with the experience of having text rekeyed. +What factors affect OCR accuracy? How accurate does full text have to be +in order to be useful? How do different users react to imperfect text? +These are questions that will be explored. For many, a service bureau +may be a better solution than performing the work inhouse; this will also +be discussed. + +SESSION VI + +Marybeth PETERS + +Copyright law protects creative works. Protection granted by the law to +authors and disseminators of works includes the right to do or authorize +the following: reproduce the work, prepare derivative works, distribute +the work to the public, and publicly perform or display the work. In +addition, copyright owners of sound recordings and computer programs have +the right to control rental of their works. These rights are not +unlimited; there are a number of exceptions and limitations. + +An electronic environment places strains on the copyright system. +Copyright owners want to control uses of their work and be paid for any +use; the public wants quick and easy access at little or no cost. The +marketplace is working in this area. Contracts, guidelines on electronic +use, and collective licensing are in use and being refined. + +Issues concerning the ability to change works without detection are more +difficult to deal with. Questions concerning the integrity of the work +and the status of the changed version under the copyright law are to be +addressed. These are public policy issues which require informed +dialogue. + + + *** *** *** ****** *** *** *** + + + Appendix III: DIRECTORY OF PARTICIPANTS + + +PRESENTERS: + + Pamela Q.J. Andre + Associate Director, Automation + National Agricultural Library + 10301 Baltimore Boulevard + Beltsville, MD 20705-2351 + Phone: (301) 504-6813 + Fax: (301) 504-7473 + E-mail: INTERNET: PANDRE@ASRR.ARSUSDA.GOV + + Jean Baronas, Senior Manager + Department of Standards and Technology + Association for Information and Image Management (AIIM) + 1100 Wayne Avenue, Suite 1100 + Silver Spring, MD 20910 + Phone: (301) 587-8202 + Fax: (301) 587-2711 + + Patricia Battin, President + The Commission on Preservation and Access + 1400 16th Street, N.W. + Suite 740 + Washington, DC 20036-2217 + Phone: (202) 939-3400 + Fax: (202) 939-3407 + E-mail: CPA@GWUVM.BITNET + + Howard Besser + Centre Canadien d'Architecture + (Canadian Center for Architecture) + 1920, rue Baile + Montreal, Quebec H3H 2S6 + CANADA + Phone: (514) 939-7001 + Fax: (514) 939-7020 + E-mail: howard@lis.pitt.edu + + Edwin B. Brownrigg, Executive Director + Memex Research Institute + 422 Bonita Avenue + Roseville, CA 95678 + Phone: (916) 784-2298 + Fax: (916) 786-7559 + E-mail: BITNET: MEMEX@CALSTATE.2 + + Eric M. Calaluca, Vice President + Chadwyck-Healey, Inc. + 1101 King Street + Alexandria, VA 223l4 + Phone: (800) 752-05l5 + Fax: (703) 683-7589 + + James Daly + 4015 Deepwood Road + Baltimore, MD 21218-1404 + Phone: (410) 235-0763 + + Ricky Erway, Associate Coordinator + American Memory + Library of Congress + Phone: (202) 707-6233 + Fax: (202) 707-3764 + + Carl Fleischhauer, Coordinator + American Memory + Library of Congress + Phone: (202) 707-6233 + Fax: (202) 707-3764 + + Joanne Freeman + 2000 Jefferson Park Avenue, No. 7 + Charlottesville, VA 22903 + + Prosser Gifford + Director for Scholarly Programs + Library of Congress + Phone: (202) 707-1517 + Fax: (202) 707-9898 + E-mail: pgif@seq1.loc.gov + + Jacqueline Hess, Director + National Demonstration Laboratory + for Interactive Information Technologies + Library of Congress + Phone: (202) 707-4157 + Fax: (202) 707-2829 + + Susan Hockey, Director + Center for Electronic Texts in the Humanities (CETH) + Alexander Library + Rutgers University + 169 College Avenue + New Brunswick, NJ 08903 + Phone: (908) 932-1384 + Fax: (908) 932-1386 + E-mail: hockey@zodiac.rutgers.edu + + William L. Hooton, Vice President + Business & Technical Development + Imaging & Information Systems Group + I-NET + 6430 Rockledge Drive, Suite 400 + Bethesda, MD 208l7 + Phone: (301) 564-6750 + Fax: (513) 564-6867 + + Anne R. Kenney, Associate Director + Department of Preservation and Conservation + 701 Olin Library + Cornell University + Ithaca, NY 14853 + Phone: (607) 255-6875 + Fax: (607) 255-9346 + E-mail: LYDY@CORNELLA.BITNET + + Ronald L. Larsen + Associate Director for Information Technology + University of Maryland at College Park + Room B0224, McKeldin Library + College Park, MD 20742-7011 + Phone: (301) 405-9194 + Fax: (301) 314-9865 + E-mail: rlarsen@libr.umd.edu + + Maria L. Lebron, Managing Editor + The Online Journal of Current Clinical Trials + l333 H Street, N.W. + Washington, DC 20005 + Phone: (202) 326-6735 + Fax: (202) 842-2868 + E-mail: PUBSAAAS@GWUVM.BITNET + + Michael Lesk, Executive Director + Computer Science Research + Bell Communications Research, Inc. + Rm 2A-385 + 445 South Street + Morristown, NJ 07960-l9l0 + Phone: (201) 829-4070 + Fax: (201) 829-5981 + E-mail: lesk@bellcore.com (Internet) or bellcore!lesk (uucp) + + Clifford A. Lynch + Director, Library Automation + University of California, + Office of the President + 300 Lakeside Drive, 8th Floor + Oakland, CA 94612-3350 + Phone: (510) 987-0522 + Fax: (510) 839-3573 + E-mail: calur@uccmvsa + + Avra Michelson + National Archives and Records Administration + NSZ Rm. 14N + 7th & Pennsylvania, N.W. + Washington, D.C. 20408 + Phone: (202) 501-5544 + Fax: (202) 501-5533 + E-mail: tmi@cu.nih.gov + + Elli Mylonas, Managing Editor + Perseus Project + Department of the Classics + Harvard University + 319 Boylston Hall + Cambridge, MA 02138 + Phone: (617) 495-9025, (617) 495-0456 (direct) + Fax: (617) 496-8886 + E-mail: Elli@IKAROS.Harvard.EDU or elli@wjh12.harvard.edu + + David Woodley Packard + Packard Humanities Institute + 300 Second Street, Suite 201 + Los Altos, CA 94002 + Phone: (415) 948-0150 (PHI) + Fax: (415) 948-5793 + + Lynne K. Personius, Assistant Director + Cornell Information Technologies for + Scholarly Information Sources + 502 Olin Library + Cornell University + Ithaca, NY 14853 + Phone: (607) 255-3393 + Fax: (607) 255-9346 + E-mail: JRN@CORNELLC.BITNET + + Marybeth Peters + Policy Planning Adviser to the + Register of Copyrights + Library of Congress + Office LM 403 + Phone: (202) 707-8350 + Fax: (202) 707-8366 + + C. Michael Sperberg-McQueen + Editor, Text Encoding Initiative + Computer Center (M/C 135) + University of Illinois at Chicago + Box 6998 + Chicago, IL 60680 + Phone: (312) 413-0317 + Fax: (312) 996-6834 + E-mail: u35395@uicvm..cc.uic.edu or u35395@uicvm.bitnet + + George R. Thoma, Chief + Communications Engineering Branch + National Library of Medicine + 8600 Rockville Pike + Bethesda, MD 20894 + Phone: (301) 496-4496 + Fax: (301) 402-0341 + E-mail: thoma@lhc.nlm.nih.gov + + Dorothy Twohig, Editor + The Papers of George Washington + 504 Alderman Library + University of Virginia + Charlottesville, VA 22903-2498 + Phone: (804) 924-0523 + Fax: (804) 924-4337 + + Susan H. Veccia, Team leader + American Memory, User Evaluation + Library of Congress + American Memory Evaluation Project + Phone: (202) 707-9104 + Fax: (202) 707-3764 + E-mail: svec@seq1.loc.gov + + Donald J. Waters, Head + Systems Office + Yale University Library + New Haven, CT 06520 + Phone: (203) 432-4889 + Fax: (203) 432-7231 + E-mail: DWATERS@YALEVM.BITNET or DWATERS@YALEVM.YCC.YALE.EDU + + Stuart Weibel, Senior Research Scientist + OCLC + 6565 Frantz Road + Dublin, OH 43017 + Phone: (614) 764-608l + Fax: (614) 764-2344 + E-mail: INTERNET: Stu@rsch.oclc.org + + Robert G. Zich + Special Assistant to the Associate Librarian + for Special Projects + Library of Congress + Phone: (202) 707-6233 + Fax: (202) 707-3764 + E-mail: rzic@seq1.loc.gov + + Judith A. Zidar, Coordinator + National Agricultural Text Digitizing Program + Information Systems Division + National Agricultural Library + 10301 Baltimore Boulevard + Beltsville, MD 20705-2351 + Phone: (301) 504-6813 or 504-5853 + Fax: (301) 504-7473 + E-mail: INTERNET: JZIDAR@ASRR.ARSUSDA.GOV + + +OBSERVERS: + + Helen Aguera, Program Officer + Division of Research + Room 318 + National Endowment for the Humanities + 1100 Pennsylvania Avenue, N.W. + Washington, D.C. 20506 + Phone: (202) 786-0358 + Fax: (202) 786-0243 + + M. Ellyn Blanton, Deputy Director + National Demonstration Laboratory + for Interactive Information Technologies + Library of Congress + Phone: (202) 707-4157 + Fax: (202) 707-2829 + + Charles M. Dollar + National Archives and Records Administration + NSZ Rm. 14N + 7th & Pennsylvania, N.W. + Washington, DC 20408 + Phone: (202) 501-5532 + Fax: (202) 501-5512 + + Jeffrey Field, Deputy to the Director + Division of Preservation and Access + Room 802 + National Endowment for the Humanities + 1100 Pennsylvania Avenue, N.W. + Washington, DC 20506 + Phone: (202) 786-0570 + Fax: (202) 786-0243 + + Lorrin Garson + American Chemical Society + Research and Development Department + 1155 16th Street, N.W. + Washington, D.C. 20036 + Phone: (202) 872-4541 + Fax: E-mail: INTERNET: LRG96@ACS.ORG + + William M. Holmes, Jr. + National Archives and Records Administration + NSZ Rm. 14N + 7th & Pennsylvania, N.W. + Washington, DC 20408 + Phone: (202) 501-5540 + Fax: (202) 501-5512 + E-mail: WHOLMES@AMERICAN.EDU + + Sperling Martin + Information Resource Management + 20030 Doolittle Street + Gaithersburg, MD 20879 + Phone: (301) 924-1803 + + Michael Neuman, Director + The Center for Text and Technology + Academic Computing Center + 238 Reiss Science Building + Georgetown University + Washington, DC 20057 + Phone: (202) 687-6096 + Fax: (202) 687-6003 + E-mail: neuman@guvax.bitnet, neuman@guvax.georgetown.edu + + Barbara Paulson, Program Officer + Division of Preservation and Access + Room 802 + National Endowment for the Humanities + 1100 Pennsylvania Avenue, N.W. + Washington, DC 20506 + Phone: (202) 786-0577 + Fax: (202) 786-0243 + + Allen H. Renear + Senior Academic Planning Analyst + Brown University Computing and Information Services + 115 Waterman Street + Campus Box 1885 + Providence, R.I. 02912 + Phone: (401) 863-7312 + Fax: (401) 863-7329 + E-mail: BITNET: Allen@BROWNVM or + INTERNET: Allen@brownvm.brown.edu + + Susan M. Severtson, President + Chadwyck-Healey, Inc. + 1101 King Street + Alexandria, VA 223l4 + Phone: (800) 752-05l5 + Fax: (703) 683-7589 + + Frank Withrow + U.S. Department of Education + 555 New Jersey Avenue, N.W. + Washington, DC 20208-5644 + Phone: (202) 219-2200 + Fax: (202) 219-2106 + + +(LC STAFF) + + Linda L. Arret + Machine-Readable Collections Reading Room LJ 132 + (202) 707-1490 + + John D. Byrum, Jr. + Descriptive Cataloging Division LM 540 + (202) 707-5194 + + Mary Jane Cavallo + Science and Technology Division LA 5210 + (202) 707-1219 + + Susan Thea David + Congressional Research Service LM 226 + (202) 707-7169 + + Robert Dierker + Senior Adviser for Multimedia Activities LM 608 + (202) 707-6151 + + William W. Ellis + Associate Librarian for Science and Technology LM 611 + (202) 707-6928 + + Ronald Gephart + Manuscript Division LM 102 + (202) 707-5097 + + James Graber + Information Technology Services LM G51 + (202) 707-9628 + + Rich Greenfield + American Memory LM 603 + (202) 707-6233 + + Rebecca Guenther + Network Development LM 639 + (202) 707-5092 + + Kenneth E. Harris + Preservation LM G21 + (202) 707-5213 + + Staley Hitchcock + Manuscript Division LM 102 + (202) 707-5383 + + Bohdan Kantor + Office of Special Projects LM 612 + (202) 707-0180 + + John W. Kimball, Jr + Machine-Readable Collections Reading Room LJ 132 + (202) 707-6560 + + Basil Manns + Information Technology Services LM G51 + (202) 707-8345 + + Sally Hart McCallum + Network Development LM 639 + (202) 707-6237 + + Dana J. Pratt + Publishing Office LM 602 + (202) 707-6027 + + Jane Riefenhauser + American Memory LM 603 + (202) 707-6233 + + William Z. Schenck + Collections Development LM 650 + (202) 707-7706 + + Chandru J. Shahani + Preservation Research and Testing Office (R&T) LM G38 + (202) 707-5607 + + William J. Sittig + Collections Development LM 650 + (202) 707-7050 + + Paul Smith + Manuscript Division LM 102 + (202) 707-5097 + + James L. Stevens + Information Technology Services LM G51 + (202) 707-9688 + + Karen Stuart + Manuscript Division LM 130 + (202) 707-5389 + + Tamara Swora + Preservation Microfilming Office LM G05 + (202) 707-6293 + + Sarah Thomas + Collections Cataloging LM 642 + (202) 707-5333 + + + END + ************************************************************* + +Note: This file has been edited for use on computer networks. This +editing required the removal of diacritics, underlining, and fonts such +as italics and bold. + +kde 11/92 + +[A few of the italics (when used for emphasis) were replaced by CAPS mh] + +*End of The Project Gutenberg Etext of LOC WORKSHOP ON ELECTRONIC ETEXTS + diff --git a/libs/zlibng/test/data/paper-100k.pdf b/libs/zlibng/test/data/paper-100k.pdf new file mode 100644 index 000000000..b3325e4a2 --- /dev/null +++ b/libs/zlibng/test/data/paper-100k.pdf @@ -0,0 +1,598 @@ + + + C=10 M=100 Y=50 K=0 + CMYK + PROCESS + 10.000002 + 100.000000 + 50.000000 + 0.000000 + + + C=0 M=95 Y=20 K=0 + CMYK + PROCESS + 0.000000 + 94.999999 + 19.999999 + 0.000000 + + + C=25 M=25 Y=40 K=0 + CMYK + PROCESS + 25.000000 + 25.000000 + 39.999998 + 0.000000 + + + C=40 M=45 Y=50 K=5 + CMYK + PROCESS + 39.999998 + 44.999999 + 50.000000 + 5.000001 + + + C=50 M=50 Y=60 K=25 + CMYK + PROCESS + 50.000000 + 50.000000 + 60.000002 + 25.000000 + + + C=55 M=60 Y=65 K=40 + CMYK + PROCESS + 55.000001 + 60.000002 + 64.999998 + 39.999998 + + + C=25 M=40 Y=65 K=0 + CMYK + PROCESS + 25.000000 + 39.999998 + 64.999998 + 0.000000 + + + C=30 M=50 Y=75 K=10 + CMYK + PROCESS + 30.000001 + 50.000000 + 75.000000 + 10.000002 + + + C=35 M=60 Y=80 K=25 + CMYK + PROCESS + 35.000002 + 60.000002 + 80.000001 + 25.000000 + + + C=40 M=65 Y=90 K=35 + CMYK + PROCESS + 39.999998 + 64.999998 + 90.000004 + 35.000002 + + + C=40 M=70 Y=100 K=50 + CMYK + PROCESS + 39.999998 + 69.999999 + 100.000000 + 50.000000 + + + C=50 M=70 Y=80 K=70 + CMYK + PROCESS + 50.000000 + 69.999999 + 80.000001 + 69.999999 + + + + + + Grays + 1 + + + + C=0 M=0 Y=0 K=100 + CMYK + PROCESS + 0.000000 + 0.000000 + 0.000000 + 100.000000 + + + C=0 M=0 Y=0 K=90 + CMYK + PROCESS + 0.000000 + 0.000000 + 0.000000 + 89.999402 + + + C=0 M=0 Y=0 K=80 + CMYK + PROCESS + 0.000000 + 0.000000 + 0.000000 + 79.998797 + + + C=0 M=0 Y=0 K=70 + CMYK + PROCESS + 0.000000 + 0.000000 + 0.000000 + 69.999701 + + + C=0 M=0 Y=0 K=60 + CMYK + PROCESS + 0.000000 + 0.000000 + 0.000000 + 59.999102 + + + C=0 M=0 Y=0 K=50 + CMYK + PROCESS + 0.000000 + 0.000000 + 0.000000 + 50.000000 + + + C=0 M=0 Y=0 K=40 + CMYK + PROCESS + 0.000000 + 0.000000 + 0.000000 + 39.999402 + + + C=0 M=0 Y=0 K=30 + CMYK + PROCESS + 0.000000 + 0.000000 + 0.000000 + 29.998803 + + + C=0 M=0 Y=0 K=20 + CMYK + PROCESS + 0.000000 + 0.000000 + 0.000000 + 19.999701 + + + C=0 M=0 Y=0 K=10 + CMYK + PROCESS + 0.000000 + 0.000000 + 0.000000 + 9.999102 + + + C=0 M=0 Y=0 K=5 + CMYK + PROCESS + 0.000000 + 0.000000 + 0.000000 + 4.998803 + + + + + + Brights + 1 + + + + C=0 M=100 Y=100 K=0 + CMYK + PROCESS + 0.000000 + 100.000000 + 100.000000 + 0.000000 + + + C=0 M=75 Y=100 K=0 + CMYK + PROCESS + 0.000000 + 75.000000 + 100.000000 + 0.000000 + + + C=0 M=10 Y=95 K=0 + CMYK + PROCESS + 0.000000 + 10.000002 + 94.999999 + 0.000000 + + + C=85 M=10 Y=100 K=0 + CMYK + PROCESS + 84.999996 + 10.000002 + 100.000000 + 0.000000 + + + C=100 M=90 Y=0 K=0 + CMYK + PROCESS + 100.000000 + 90.000004 + 0.000000 + 0.000000 + + + C=60 M=90 Y=0 K=0 + CMYK + PROCESS + 60.000002 + 90.000004 + 0.003099 + 0.003099 + + + + + + + + + Adobe PDF library 9.00 + + + + + + + + + + + + + + + + + + + + + + + + + +endstream endobj 145 0 obj<> endobj 1 0 obj<> endobj 2 0 obj<>/Font<>/ProcSet[/PDF/Text]/ExtGState<>>> endobj 3 0 obj<>stream +hÞ”[MsÜF’½ëWðnmU(s™e{¥ÝñØkjw²`7ÈƨhhÒœÝ_±‡ù½›ïe€&›rl(BÑÄG¡ª2óåËúæ_o’‹ûáÍ·ß|óƒ»H.>Þ½)V¥sæ"–þ§ËWq’\X¯âØ¥÷obÞïïåÇÇ5þ{|ó)ú¥^×íxyºl•D]ÿE~gÅ*vMû¥Þè_YôþÇAÚ¨jqÕÙèÝ·?ób¾*¢]ýPïøW¹rÑØñ‰UÝ×mž©?ôõ04]‹»±\¹}ºüüñßÞ\¯Ê²¼¸NVIîd=ßɼöuÕÊp6wòñîN~¹re¢ßŽU;6c565î–2éc³®v¸„uì» gƒ¿ŠèSšü3Í>_áïD04í½¬îçQwñ#*Îåã¿Èׇ}µ“ÁL%´ÇýmÝË_9f€¹˜ÜÊ0Ü“²^YצYÓN¾9nëpsìe)ë¾9Œ²òŠÃ&ò„|÷€O›"–Ý~lÆíüýms¿•=2yT­×ǾZ?­ø'Ñ=ÊV÷Wø;“ù¨`L)·T0¦XåA4&ÅåÝq'×»êIGJd½×©Å·ÍC7bb©1QßíêðtÓrJ1EãÊ\ES·Ã±çR!â"º«dîwÇ +?‰ÖÝþ°«G³ÞqÏ p§Û¢õÝ_ß⧑«}}؉øü+.ÅDûöAèþ¹˜É¤$&þ¼ +*÷vÐoˆ¼:UçTæ¿išÍ‘ksØô÷?ây'ÒÛVƒ^4Ñm]Oß½ëŽA½©Ä$x‹I;#ŠúŠ¹4Õ.|ö®ëý®oîýŽQˆwÇv­KÊ,ăñ2kd‡6ÕX‹³,–‰4#.CÍ›¿ ²]ó¥Þ=é‹F6­õw¡â–QD1ü{~Û´Õ(µ}ÒËE´œK_ßw•*hZ@CtûEAËgÛ/Ê)rjöòìJÿ´Ñ‡vS×è\a¼ #ŸxhêGý­FšæØ“õ¶ïöøØü}l¶cYŒh)ùª¨â(»·ÇTþæNšÒÉþ¨ñÈSb”²áû[,Ê”¥W%üÊ£MswW÷/S2²¨ÌXËGåO¨¥ªáï5Œ´Ìåþr>ë®ýû,ž„Ø ¼Îb`'%ÉóÍÅE,Bþ>ö|$•G0§,1%ñž@ÜèÏT/¿2Ž;ë‡,žBQC)e¸‡™]…MÎR™Ø¶±~˜Rmê[Qž¾ +P c§ ƒ] î©QÉkO‡NFšáJ_¶Øù•É‡·Íz{θ‡C½nîš5”ÚÉ<Âòe’ƒÚH²˜¥‚Q`Su/JCSI£cÛüvôf“F·M·ëî¡asÖ£ßpΪ?™äŸÆ²óy»·Ý€˜'°#‘ó¡°ø;¥nåi*s¨ð#–}ðêÞõO¸‚ß×ëmÕ6າˆY‚Â^õzÉ .R`cß­aôXg|_Ž½~¬á"ÒÜhjñ@÷þͼ ú,Îø=qr‚Ðf²Î®½Â¥Œš40ÆP“Ûu}€ž`‘Ë@4Ë ë;ÂzRìÏ—¶{í»¯u,"ÞM¡ØOµ&SÔ›&´©÷"a™*W`èÕ"IˆF$—,Ñb¥OÚè¦És=<¦Ò#jáâå¬ú{ˆ~ñ›rå-"ß"· .êYF}V$¹[ù'=ùžªJ’}ÛJéZÄgŽÂ6`v©õÆ&v—‹¬Àeøœ¬z|$Üã¥lUr«»«iÚƒþ]ªÀ³øŽ=Xê3M7ª˜‰-ÉuÕ®• ÛîQ/ç1y°Ü8âöî8ˆÑ@š®ôv…—’å´pËÎÓ:c²‘Ș‰…€ei$ˆŸeTW=]C +Çè]•¼E³Á;ÍÈ»p×~Í +åU{¯»Q*0÷5á.õxr"ÎCŽ¾ë»¡;l›]uùñï³$ÍJĘ‘C…8Þ÷22´?¡Õá×@Hr… ü4AïØÉð$[ˆ­Z«ë3‰£X+!M²·Í?86À[T°¢>yúÙœh×ÝÒ°q ¢Pç$áð +ŒY¸p%«öb¥#XŠ5¡|–b¥^Q*B;óN™ºËJ:”à§3RÕÿüã…ò»¬Èå*ðÄ›9"‰a½­÷x¼pNA +è +S²b' –Uäp‹~tÜ…å6ûC×äs$Œt€Wh¿eÞ¢»+hªq², GFÙIHÆø[W5‡SØa<DèŽìßXÝî¦ÝSq-¾Í˜Ô1æ¨+£"G[»†‘!&f,Ý­pág‘ âä|ùž‰ùç­v0EÂQÍ`ÒŽIYZå)Ž+S ÄÔåðˆwMïï¹@Å]ÁàÚçG\¡Ñµc¬v[ŸøCÝ?0˜!ÿ¨Öâÿ8äÖC1Rµ<*—ªåùŸ`yqY¦ˆ!K5¦_¨Ñq7ß|èM ¾õQS›:¦Y0âªްYuÈIaf>]"B”ç] <-W½{0psõïÛ涹¼f^HãGØè¾Ñ¸ÍÆÁ†dV`)0¥ÉÐÒØYohjVÆBÕ訅ôù¤aRpvã)øP¬¾ßO¢ûÓí%‰Ãâ̹ Wˆ-%Œ~©×— >ì-œ@¨Üe‚\›:¹‘Ô¬¸ ‡+pÌXÈËðI”ûRt/€·¸'* ÓO€.©áXIMh=N`B—šû©epxcš_ ±¾~¿»dâ¦~–§žÐR„‡'%¤ÚWº( &­£o×·+,NyL'³$RxÜa9™KBˆYXW2¿ÆòÓ¨ò³/0Ã,sJý1yX>(f$ÆWò(»J +쇋®ŒÃD~äŸ1R­ÎáîûîQg#¨p©øpœ2 :}R·ŠHX0 ‹â= ³#Î1pëë:º­]³cö®ÕQ3&ŸsdÊëÙÖ̤j¸¾×íoF?¦ÛË8âV&Ñþ–Ó’™âñSnÞ#ÅÂ:tÂb0£2.£»±¡×žz••D-º‹;„¸+,ø=߃`®p©ð!jΰL “D]asÉ ›ÀäáF½cÊÌT óÊ\0ø¦>I/LPaªf¡¿ rF“´ HKìØ™e(ÕÎçO/ìe£ì;ex~ÎZôYï þPŽÉò3c³»d|¾¸Võ4ádOЇÒ)óñZ~Fë$¸Ö•K$tI¦‰@[µAuÆ0\¼d‚ ™FdõÕZ¸sËj†?K~ºoXŽå&=xÕï ìØ6U8¬~.PTZ;@°WaNCnuÿ›ðùè¡ùPä(Ψ-ñ&âfM’¿Ȳñ!<™ó±×4¬lÿ×ÈÄømC ãåÑ5cÂ^A®Ö—Y‹1xU_§–2Ðg¦t´i¦´Mc¡¾%='0Ä>ÿâ·¢ÖÚ“uWHh*ZC‘w3ÿ¨‚ÌH£¶ÛVwAûðкÛa Hœ¯‰Êð“*^¶I˜Ø½SÄ®¡lÖ«p*>Q„!:MÖ¥¥€Ml±µ’™¡Õ²"rÙ9ù1LAéëDà‹m]X؆¡IÓ)ÑW”'Szó»¾S4CBå…lĉ‡™&6¼q“j¦È‚Ÿ©:î ·ŠS³”H+z·ý ãG?_KtÉŒb~£Ùî> 4=t£Uÿ¦® *¡8g2a¨¼Šj£DÖÒ&§üý_ß©Büô¬å{õ +™ Åg­B$E»Ä³Mõt|G +þǨ>#!›8ÂJM:>ž„3ðw•Îy².ê#®­Á’˜3—Ÿ:0QãIó.Žµ8k±"t›NÈZ}õGÍøØ%@i"çÜ·µL¥ž€·5)³½w?/Æ>Ñ+ú$´.&Ž¡NØô3ꔈ{[ª“-R 韹¡n>Êuš e›ã‰P 4~ð€z¥£åZÝË](œiæîð~ð|¢Máë 6A8°*¡Ÿî‰®;Ù:±üMãõê‡ùh‚!÷¥GÍ°þÁÖ#;ÌB­Î¡±jPëDía•¦h±¶S~‚¯È—wjyÇ¡Q£|¨ÃãáE‰½êQ÷©ú'ࢳ»ªX +Î|J1c@«Ø"ëA¾'cÝeI3ÈŠ°Z²G£#s>]žME÷Ìnó,ÓÑR\ÉFuNT':òƒnÉöjœD“JÁXI…¹gc÷ëq«¸Ðm¼†7óÌ°¬Ž‚5“zÚŽDyò®Öý¬ú¶F ÇAN;·etS?L°£óÙ…1g«B†üÔþBÐ@¨Ï3V̶žºžuÙD»|±“Ão‚nh®ÓAìJF*§ƒgyÆhL¤“V¨²â±VÎBb¬eh£¿¯‚Ì×”†|é0*n7AHRiDª£ÆH‹‚§Ä*ÎH,puÉ¢—)?Ëe —÷°;šÐÉÍ55§îåÎܬÓ_눉8Û3¯¼SíYéMÙˆ tþ¾mî4„BXIâÞŽA…õ•<.}ûú"!‡.ðüõÌd>?3Aq«ÝæÌ‹xîHÁã—Šžt} lh*Qô„®ðLPô3ÉC{ËA+Í¥Þ[Ù²Ìü½“Äþêz'ñw’—/ýéÙKiž„·ŠsoÉEúú›×óý$ö¤¡(ž +{giÉÿ´â0sä +úäIÌÑŸŽ›¬â8õ48²'eö—ŪLL"ã\FxË _¬BOù!¬óÑ'o¯=µ`$žjð† Ï̵õ4ËÝ©Â#,$Y¡·†×»ÛØãÛµì½ÈR²…Gíª,|{`²Œ§öWlÐŒš•/†¬Âpïí¿«aÕšÉ%ã/·÷Š—è[Ó$¦G’¢RŸ"/ŸAØiôŒ£;F«ÓË6ä”’+um`P­þ,ÎåÑkë‹€À••¿¥‘ŠŒ^T½tÄÇfTˆ‚'Íã)É{.\¯Ur!|©ÖOÚÄ +ÛùÙS¹ªÔËvíÿ* + ¡ó«…Å!Xwµrñ»»Fá,ÄûäýXÑ•vvºhë™0z +õ'wJ)s² üüî]hµízoá‰/1#œ—AËû-—ø+Æ/ÇÎ6ñ=ân–ò„f©Ý˜`7‰µötÄòåˆ/­-óÉî(þÀ†¨¿ežÍ>Ίe£h"ÙAOàä'Þê¡ñ¶yôám(‡K@ ®6®~J2U#œ +Òã<‹â†²ÖãrñJqÃä¢óé[ä $ÊÓê‚o0-ó¸xf>f¥A´Q'n¼C*Ë9»Ṳ́ÇOÚ–œè VJ|×vœœØ‚ðª?2*“×( XŠ¦dø\îÓ0)IPÐù«sföèOˆœ§ñ.Í7Î'‡£N£ +„àÅâ8ÉltGÖšÈü®,Ìœ¡Œ¬Kñ‰dîÆG´ÆdOšH^e1g³µ›pÆ5ö%Æ‹$æ$¯Aé¤/9hoZK¿Ä`_Z%SæBõPVçß[þZ¦ì´P7‘ô/¬¥±ŽwV•S6p½O®´‡Quîl6à ×” ˜­F±akï׊¬–'d§yvÕèyi¸ù*m4,Å>éÑ ÜG]ž“Õ 9D7ÿ"˜¶*™éœ¨ºWíAØh8ªD\©›1¥qšuÄ51Ëc¯ƒ÷u«YÔéñyÜתkÒæÌŒÏݱ+ezuœˆÝ¡80T,•ŠÉÀôäÜJµ®™*y‚+š¢Â”L^5•³Fæ–µ¿îzãV1àÜ›gª¼ì¡eþu×­µL[yzÝü#ä·¦cƒñŒA¬m“´×GôüDÛþL-d>ô©šâ{[sGžíÉ•,£ê5yþ¥i5,çiKàèäÖç ôv7eÈä™W +ïĺ‰ái´”[v¡Ÿªx~ÊÖe@UpžéRDOÿï¢ÂUhâåV•F;€uCǾ4Ö&Èä!ˆÖ¼æ3Ð,§3xeÁ(ÏCHϵÍìŬ,Ì{Ë¢j ¯ðAsùJè6ǯBäõ OÆÌÏ€+œ}ø ɯp9)êÈeš;Á)¨g…ùäe»ÓrŸb­Z«Ã‘7N}Ç£4)[V~¥ñæš‹ãóVû@õ‡›¿©P?œe·ýÏ_~‡ +—%Šø_ßþ ëæ¼-wQ[ž ól‡¯²EÏ6bÙ¤çåjc{޷뫾ÖÀs”ÈÉøLÆ2=éÂÿZ%Ë‘H0èÛi4>v:ò26¿ +#œDiæyé +m—È8#ˆuïK˜€àhÑæK#ziT”\Ýûá =e̽òݲ±ž%œ>â¸'o?þ¬¹Þ¨'–{H4Ày±'›ªõ•LŸ=ÇÌëÞ‡x‹ŒŸ¯…ŸÇ‹»jí1|}óc£ª‘^i‹¾ïÝÉÕùtB×}¥[Ñ~¾„VÀ;-9¼l¯ÔNï§[pô#[rÂÙ–øùäë«s¨n!à†¹OŒEtôp·`ÓÜôÖí|v+bþE‚R»šyoXT€`Ûãz§Uw(#äE¸ ¥žRõm÷à3Oý•+´©-ÖÍBoU`úÇÆ{ÌmóŠäÎUÐî”jë›0ÎvU0ù{òÜÕØÓ4AÔ#x/kqC8øÉ&‹(Ž£/^Ôs²äÓY×g2›ê"@grÞ½É6Ò™™â6˜ÚðÕÑL9À9·.o³KùœMPºWtôu)="kúÔRfH©ûkßÊÓoØQ‹Î¤Ä¼B[ÎHi}?Üqí‹sSŠg“°©èxËOhï¢ý” ­S )·C¥Ìa)žÔºYð:ìk=ƱYóÅÑ—".òS²èar/{˜DÒ¦Lç¢t:µ h¢MlÈæÏÚ²KL¾ŒbxD®ºÑÌAÆ/­'–V˜å¥#”_lÇ×wŨŽ{ù-“å™P3´¯°ŒaæÄÚç„ô09úpŒ,Æœ,†ÿsÕ¾;Ð+šW!ÀEëÏ _Ehí¾çÔ­•D6•vÃ$Ñtxéd›ôŒ¢ß&ÜwÑc£my82Ñ+pÔÕFO)ŠW%_6‘AˆgYý<ÈUÈ*:p|+ó<öá¬ðºîµ„Æt}8…,!e„óÉü4@áË„R\s!{ô>ú%!–e +éÌþ¶·É0ÒZw?ŒO~cÇ=L"RÈ'mSQhkŸ£Y¯ð9 +¨ëŸtË žÿ>·ç}½¯T-ŒwÆS0k Í»ªG ®‚Ý÷µÿKâËV6Uøg½’l×ûšç"ñªcéOGžQ¢ëe÷âtd=ÎÙyyÜ<…*‘J-V›Þ©Òoq€ z[áå…X@4¯Va`ñ) ‚º? Ù-aoN`,‡ÝiîšÙÀ´*¦Í…æ¿ü™v6j›øi–dçØÅS…4DÎõš¸ :QßæÜð°ƒ>ü·Z‹¼l­êúQ]güÎõYêà"ÁïÍb}$ˆ âP#í™è‰òqŠc²¥ÍiGY^;ò;®äaEv0ÌÐqಙ±Þ•“¢º¢ -Œ…¡øª^ÌJ÷d49[ŸºaArë]½÷ îŒvFMTQÒ¨8ÃvǾ¹=2IžÇ>V´l“¹;öãVy Èg½;®›¦Ó]áâŒ(—f„¤¬7#6vûæ7Ãã[M Å?oª} 2´ +€£ŒCf© `Ü ôsthC“ÿ‰BV.ÿ]àXA™+YýýDZ’mGÓ'̇ ˜ó£Li7ŒõÓ‚F©¾¥ðÿœè[Š½ÿ¨Ð¤§­ E¦¼¸.e‘ÂQuù?ÿ姛°ØwÝþp9–bË¿¥÷„I±)ÿp6»ôøø¸:ìºA(?cï𳫮Ǚ +ÇtZzy]:œþ­jZËM±—iœX§e§ÿ«Û÷µúï=arÝ?`KhŇaÀ &ˤk¢¯%óûuÇÆ&e/þO€¦±.µ +endstream endobj 4 0 obj<> endobj 5 0 obj<>/ProcSet[/PDF/Text]/ExtGState<>>> endobj 6 0 obj<>stream +hÞÌ[Û’äÆq}çWì‹#0Ž™.uá‡%)YT¥][K>`z03»M=Ãa8üþ^ç9Y…KO/I…eKÁ.¦ª²2Ož¼Ô¯þí]öæaøäÓ÷Ÿüê7îMöæýý'å¦r®x“ÊáÒ–›ÔöÏ‹I3óæýþ“”ôrñ~‹ÿ=ò!ùíp¬®2¿©’ôê¦0~S$õUš øC^•?ø«Oöu•Yù廦Ço©üÖÝã*ß”I½Ý^eÕÆ&Í0´W™Ì"¹Ý5úœI¶òn±É“n_ã¦KÆö°‘»…‘ë·».½ÜoxÅÈ8õî*ËäßÝ5~±xåñ*Ëå£Õ'»v1ˤ›«ÌÉ﮾}ÿ;Y×M¶É¼Á|.ë;ö ^Ë“»Vfhäý±}šr©“»g,-O°2—æae¶²r5Èœø¬ÇVF.“9z½h¾™ìøµLæ"Z™ÿI…éÒLÆå¤Éã˱ƒÜ‹y]Cû#„“͛ŚÊÜèššZÌ·H,=¶ +¿Ì=‘-·.Ï!þnçmrÛj|T&ÞõíUžb·!|ÑáËSU26ýS2É®ÖMxÁ•Ìñ¶Ÿu¨¦ÁVeÆÅÝÕéøˢšÞÿ3V‚ù@Ínwøº“A®nŒLÇR ú‡›õëÔÇñ܃îÝɈ.¶œG‘´ÇQÅÒv Ãh‹‘Éy +•ßl{¡Júf‡Uù¤[Ì¢HºÃðI‰Jã‹Ï­l‡3òÆQÕj×^Q7ó¢¶âÂçó*•Ïížfá“Ã(~^zä ÞΖšWNž>4?Œxˆ{ÜLzÛan2Âp›Xé3^)ñ©BÀšñbå©jaØVUϹIïÌ,‡¡6œý¯~S(žT"¹#\„ˈ'N.r—åÀ“Ég¢X7NF…b¢ÙX`ßR¥Ä´ ѼÃØ··'™”LÎë†è-ÅŽT^ýÍ™ñu>€½1ïÚÃÃly–OFÝaûK*í à!KîpEÝÙq¸’›¡UÅÜcÈðaÁA[ƹ©>ŠªÎoÒ,{ãd~EšzÂOõ;$æÚŽØ!5z‚Д‡þí»;H[6y§Áyg¢n:(âBôµ¥frûË„š ¡S3]%³ÄS™èCƒ©8Ž;7ÍœsÔUÞlªªZÃÊeT ø~Àë¸VX\|þû·ºQåÒ¶Ðñ|9Yu$¯«ò/ðÚ÷úÚI Q&]->7k³ÂB–.k¤3Mn~Ôå7óºÚq£c•ÉûGhå €.€‚]Ó~Óäjuk»ø·ºƒ·–W·õ 3ž'ªÂ6- S +0F(=8G;ŒqKkÕola»“§º7ÈÛ—ø†x‰¤~“|Ù( ¨e˜ Ööövнév'Uƒ‘Ô ÊøN J¼ïá;%õþ­fÖC=ÂÓYò.Â_³•äÌm…Ë?1¤‡çY ?f“¯šñQ—ÛÝ JÝLrßõ—¬ç®ë€O»AÅöÍ•`hÚö¡°zïÚXE›o¯õȲpˆŠ"ªðN™²÷ÇF©ãžK Ë3oj’<öy8ªo¯ûAA£D­ d6–üvÉy船L{§`ÕaÈÒÉ$=`.Ä;JEA§‡NöšTøˆß^UñHß mÇÝ Öâ“ëK¶{_ouêí +S*›™¹¹Í¡C+·9 öuôÐ7£ZË +s1@µ4)Ljƒ{ØÑ?5*õâÑè<ð góœ²z BÄ›ªè‘¾ö“€Ø1eø è‹ÅjE<µZÀ“\&¡…¦Ål )49ªkÁv5Om §r;”ávíuáÇ]§÷BX6y$§ ½k‡­FÈtÙä¢Ö=ù‹pÿa« Ñ ¿ãþŽqi´ìiƒ„ÓÄ°T9p}eW÷hTÊ×Þ‘S0^Åþ­ò8{¦˜XG¾D|áÉsÍ÷AOÇ0ƒ}Àd~žeQø /8‹ix‚§]ˆÐe›K°§?dZ n~8FF¨Ë¥‚áôñs#³´¥cØ·nß©„F,ûp#QÈ“Zh¶e= ÿXËöæiäéÖ ÛÓÇ+1© vóÙ§_jìYÂå…v<Û Áœ¨½)¿UKЈ+’ð< êú›öá ° Z3,?Ëè•v§AtÄX~‚ÈôEwš~ÐðØHT)æ&zñÎÝûlEë^ÂÑP¨ºÉ9×”Ý(¯ìëö ¡NVEßn¨²”QGP‹¬À7êË /.þû›«Ò˜êIÕ$AçÒɇl˜g‘M"ïá$”!¹)ŽÂÇ,Âáæ¾ÛöT%ÛÜñÂþ>‰ë½ ±¤‚=¯Œ lW.á_æõæþB†XÀy߃A9¥ÇDqGl9õÇn€[°þgÃ%Ô6yíæÝQj»Ú"ÍÂÞ@²@êƒòH ~N·ÜÞ)56OI€¿?1š'©„Ðltœ÷"Þk}BwChh½}œ÷QxÅá.z@Œ™{È\e,à+¹Òbe²úŽ Ó£Pâ†ð˜± ¸AËœa^2½vêú„(ÚÇ[|aš™Œ +[Q†ÇvGç!ß&¿æJƒáÛrËÌGsHy!üÉ­RmØ/· < +±Pª¯?ûL½uÆ$¥¦'<ܾ©ÁTf.`­¦rÛBH‡&Fâh»R–3Ú€ÀNpz¯Òùs³ \õ:’ºdØ`‘j·{ù18æ c1;¶×ÄYL™1Üڧ&f³ŽÝ3y“åbFmx Ù'—#Šû3áÏÑ½É ü Yìš'*#ySåq9¢¼¿t Gç(zhïäþݵtÜ‘¸¨qLû#FßÊÀ”¢Ód·Ê,”£p™&§5°ÈB¦QX·€rb‹^c‹,×›‰ +²pë¿Â­4ÜÂòõNîdᎩ*nýËÙK¹Ïâ[6]Å1HI|¨÷à€¢.\‘dŸª’EÕ!æ¿;%´Ú ó©û—A›ªtÅÚ”çÀÉÞo¯•y™äSuiÖ³"NîÄÌ2Ro­µî‰¾üØ>Óß#Ó-Ϭ±‚?ž¿'ÀðÍ•ä7^–dÏÀ}8=<ÀJÈñWû‡·¤Ô½°Žé A Üp)a|áa°5Ö! œÊ2>hÈhe“†*ƒk$W{3•–EMY2ƒ<{J¹•²´ Ž’fÉï»±¾Ý½@P• 9ayóHf*ÛEКMC ÁzH¤u&j~D¾mõ‘lòMòÇí â*“C7Æk\ȃô~x‰uªA¨nÃ:*~R³·>ÕLóEÙöÂ,èõJˆ¬e—hGl1³³$*•™œi”o’cW,Ý=¶ý„*E¥œvasBœc>GY|Å72²Aœ£¬»öNŸô* ¡¶]ß7"·F“¼•zaù°r +³`Œ©¡’† ZhÇB\é&À_@»W†,ð䫵GÛòyZFãú׫›Ì +¶e %ˆÔ™¹ûÍÈ• :ê_qÇ&ŸÁ¿Ò §«ª\«Õûú»†ô¯Ýý ½“S˜HÚµ6>¨ã,è%·]NR ÒÎY YKbÌØÇfÊw[:^Ìø—ã®I¡é[úùŠL[`~¤)CY2æ=+Ø$T¿çÌð¦K^>œ1윕fVàh÷á3× > +`ÿÐîe’ŽÂ'…ý§kežZ¥DÈ.)ìS-È+¬Pš*×Ú±,¿þâbsfÜ&­¼û[›…ÀŒŒ0Qäb˜GÇ…ê3fµ"ñ±»Tzþ?.-gð÷E¨,ÿÛq¢6à:ñ¹Ò¼¸Dø¢`=<¢6l™XœÜ¶-cýö+\6C,` ­6Ý},°ÐR/CÇõž–ä¡õ‹ð6„¦EÐг¸žCV>mðN1`-dnC LOêô?Û-“?]CÎøY.í"n"5,à ‘)…8‡)–e7[ %7ö +´°%™s5lQœòrYx³–èZ,–"¾p¹ › ?¦¯9~œ9ƒË!`€Ýç¨R9r@ø:ÇìüšŽMö½®æ4~@K`^!ÌAòl)±ôÊOmw¸³L¼8³h®œ@/ªokÆÄ“›öš÷*ÖÜBÝ6àÚúW ’¹é8ag*Ƙ°³Y̸9ëÖìA,gêŒaa÷Nóч—Kê´ y +cÐ1ŠˆÙ›Gù6¤¾ýôf )J²ý»€'Ú^çÑNï»a‡ÒÔ@©õ=-› +[w®ÌÞ‹I `3¢&"ÚBSݨ±SñšÈiHÅÜ—h#ScÞɦږŶšƒ> ¦Ðm›ah†Îq%‚«ÂqUHnÈoÆî†K5%‰»ø&èb'l1´}`‹)Í4ÙàÅʘÐá H´Ý®{½Þ-?ZÄ>†Ó(ï³¼i,‹¯Ù ®Æ±Å%fH1ë̾)d4lcˆœKgËÂËY€xaÁëOt›uê¥K{™W­ú­Æ„mˆû¢}êuB¹OIé”/j®ñŒg/ò$ÄYú«2ÔΗêSh‘úP1eæŠÞî‹Ãv'¨©ÀœFMâØŒ¾µÚœ ò¿˜z` r~™plT¯²=÷¢€çù1ëýG°43ö"–ê€etÉËÀPøAþ×V`–wK³ÞÿeÞV—} +€½æºW!Xá³)CÎKÛfœÓ0`•Ô#¨R‰Ž»¢ñ&4RB‡.lø¡ì±71ï jæ‹*xÞ„¶²“òxüíÕW{6Ý®|µ'\DŽâ¦{ÖUþ•1$Ÿ÷ÝÐÛ]½«|¤p“ÇÛh»®GLÄ3‘-kÓn…¦uPäíño©ìŠT)Öðk91Š¦Ðpî…)ˆ² ¯tóÂ,Vr[*6.Àck*ä?šÙQøÓ`ûúY\X­­^yµÔÐh\´èú£ºÃØØ´šì&–#þpÐÀ¥XVš†zßè=*¤ÊàÅ¡~ /ØœÖC"](¸þÉ¿ÉF¾Z,á°_ +9ŒZg÷¢VÃÒØ4}g\5(ÿ¿¤oP;€Äú6IùŒ›)¼zDôHYr³_ƒ›) +é;¨ÏQ¦ÓÉZ63ëôîÙE ®Ö†°)krA²…Clóýü"¹œ–S" +Ùl­,ðµòfÛ„2à„oi5qõkUtŽáS²Ù„[2FÒüðØÞ¶cìßuÏš|È3¾ÖŸ + #S7©cÁÚHG°[ »šþiáÇ.ãØMï2ùùÔ>uë8Lt¼È}T€cÓS¹:kyh¡Íå”y•áQÀàNÝî”îa¯֒À€lb©`æ«Ö¾z­dè \Õýä/vZÎ1²þÎC|ÊsÇlÑâ+©'!þu"Ù,Žïë—XeN÷2`8²P-’YwÒRêU/hÚá´¿Õ‚˜çË,ÑæTÜÚ¶ýöÔŽ¡A¼ä>Fé‰S‹e(´áxÄ £ñéE6ªo×­s‡ö}_!ôNû½@Á5þFã@Ñ—Õb§ôwÝ)y'xsvä“ã~óD¾d³ÌÍaùB¯W¹"ÃV-f”IÿÕ›záUyÁ¸”áÒŸerYŠ<Á˜jŠÉC²á–0Ÿ8;íØG–Yk,1)ÝžºÝS¸u K…Tò`Sµ! iþzA¬ËW)™Y!!¢åßgÙ`I“&³.ªÚlv§…‡C +SM™tè|,ç1=€î¥jù+õÖ!¹$—°¡Ú-sYH‹P‹) +=€ò‘\™ª²Yfy6}†ÔmZUùl_™föRþ,ä‹çc\,Jp#´ÝYãÛÀ1™Ë’ˆƒ†Ç!Ü/X2;?Å1çÎxR‚äPŒfw]—×V)‡Wy3öZ.&ã1ôVßTÚŽˆTãä˜È‚—<¬BnûòsY¸Q(â´(åÞѱs‡F©dÍ\n&«zPgÙ¦i²ŠI-üʲËS󢧲IF|ätn>¸`óL´Ûô\2ŽÆ¯s­j ìlºìÒuÌ¢„F*Ç8;p¼áٽࢠí^.›ü"ÀÖ('Æ™ŽÇÚèœÕ¾¥A]YÐ5‡i„T `‘“×^ +çÙ¤}Š•öu”µ,v\bß¡ã‘œ Êøœr_æ# +jÆa“÷YÄâ‚åK5y¯ž?2_ÒÃúâBŽíL>»0ÌÈ÷Ùв2”TÚ´,äöûS­]*ûZûžðÀúï7ÉWï”M2MJÿy9Åâyû‚.ñî¸ýž©$†ƒ»®Ü3°ÁǼ™²°4ëAÀ3í2‡ÆxÊKhŒùx6tª3|ûæöå#‰!XPq-c¥Å_ïÌ[ +Rì)?¶ÛGTà ØÄçØÍ;¥1Q[Õ=;mts9CºŠ<ÓxÇi_ˆ>ô9xqy$ìò¢ ä ¯4r¨wìfcƒé[ßqó=Pm•ï"c’Oì«G±íªôÅÌ܈—ç’×™ ãÛ+Jç–X´ÞÍdZºÐŽ¤© m¿G·¹F¼å¢•P£êØhN^O;jòé,ln—Ïf‚wÍìÌtðËcÇ#–Q…*çF<÷-¤쵊…ýkÎAro”äå‚0{ªlõ¹ØÀ2'FB'`,ú¯[ +Mb 7,¤ÿû!t™M½—Á®*L¸iWý^jôÚat¦ßQ8ZêÌÍDG-;FtÔæZø˜•’?•‹Þ•Zí† Ïâ×ÇÂÄÝT>.‰pV1Ì”É*—a«Ò¶2Ÿ:0½à¤:¨lh³*%ÔºA[ïæ¢r`Ùýа5I{©ž Tmdžø9 +mQFëæ¬ëLusWÄî íªšbë4²î%> cŒeS¶Dí 8iHc˜–C"‰]:ˆm˜ùL1‘ÕãeìøðÁhC3ˆvø, Î:Õ/ÞXd¤Iÿ¦-¹6µåÇ|±³15kÜG}1«c>ñ­¥—iwšG÷S&óZ{›mr× Çvlôn¡¾‰ç\Cq˜GyWYö, ¦* ÖV« +Ã?Š˜Šì'ÄÄ#>È£h>ۼ纽åÚgö†ë¹¢Ð9˜©èÉ£œýñùR{yˆjÖð,–Ä_ ë•gÉ#4¼¡'7¶ÿ³$v뱜ÿ©èG>×­š2¦rJkÙ!¤Y,Ë3Óü!ј—ÿˆÎÄU?¹tVQ×%»Œ½Tyåbê7gÎþ¬è¨Ï‚,m 'ÕÔ”’.¨ºàL> £Ã'Ãã¡8ŠTrïBS6*Ÿ±wÚóˆmèv6Þ/’2x¡dRfëµYì€V¡k-Œ–JÏ}ÙîC\´Ð°eg>;Àdìy‘Ü0U¨ >³a™!ÅfT 9+K—û M +VÏB…¼ ÑŸâN½7—y ÖÞxúU³csɆG$˜•ÏåJìÍ/3÷ÚÅ"ˆ˜> +DãvË…‚<4јΛ|Ø€`íܾÀyæl\[æ> kû¶¼kGàšSiø%MB!‰MB¬™kŸñ Ë_´·Å_È•²þrž ]Õdª>Í™0— ê^þ÷Æ‹*_M˜ÿñ„nãgÃëx” îè«é r‘ÇCH»µÉ4‡¨þ´Šp¹ÅïŠiLèÛÍŠêÍØ[é[(¨¯¿üû˜ý쬆Êüê§ì:{ÑÖ5“ü§Ð†NåùùysÜuÃöŠ4Y^EÚ¦ëÑ'ãxˆ¹¸º©\…³¤¿«'MƒQGó438Å€­ŸünwÚ³cAX–â÷ð€©°%_ Nṯ¯eóûM–¦…É´Mé×ï?ùW)Ý» +endstream endobj 7 0 obj<> endobj 8 0 obj<>/XObject<>/ProcSet[/PDF/Text/ImageC]/ExtGState<>>> endobj 9 0 obj<>stream +hÞœZÉrãF½ë+t™pF„QPð­7íðÒ¶¾´ú’ 7Ð(ZŽ‰ùŒùÞÉ—YÅÅ-M8&Ñ µdåòòeB_üóV]oÆ«×wW_|•_«ë»õ•OË<7×ýO3gܵ*ò´4>¿¾Û^e$M7ÕCµœš¾gs£UZ&‹z:Ôu‡Ÿ6uÉ×ßãr©Iî“ÙÇ»oé`eäd¥R–ö½{{• ³»_ñRËËÔ¹L…Wÿ¯²°.ÍH¾ð. ïTXfËÒ…W_^.£Ã\^VÞåŸïø!¹Ä:-’Ûýn×ÖÛº›ªá 7*R›|ÕlöC_&õÉ­}}?»á‹Í]¸4æz®Rå}!›-ûnÝ Û¦ÛÌæÚ*RIß-i¹6Ž–W›ªéð#Oódz¨&<z–Ñ"é÷, ­‡j[úá¿¡ÝP¯Ö>oTËåžÌÑÔ#Ës÷w:¾Q-é¿ë'1EžTÓt™ñ¡®Œ–4J¢Žõoûšå3ÊCÖ5ž +zšj1q‘tûí‚Wñ§)뺚H5c_Ý6Û¦­†öéæ$Ðz?ÐV´Úæ9­©Ÿênä+XW’F°u¢Ž³2Üö«ºÅ•,žð¾ û4ݲ݇¥¹ ÂÊÒŸx5¿­›/ª±^ÎÞÔ.A“5Lêe¹ÉuÒÖu _Í‹T‘®û-=“D:ùà²<‡6î‡ø´Ý·SóX M5…=óäëfµb×'¡óäûjøÔ?žNÿ—"Í-9‹N–tN5ÁØ6ÃƉ¶åWA'«§?⧧Ÿ"”ÍJz&¼ûáÍoßÉ€¡¹æãé¬U³bu‘ØìÐÜØlºfÝ,«nj¡DºF™4ÛÝÐ?ÖòóÒ¥0b¢S±Ö-ø,ŠÉ%èöêÅ(ÎíóQœ–eùÄp¡âªBÿ)†­³ªn…—síRE÷¸ ÉU5qdä3gA1>ô‡î~–F¼º«>±1 ¦T2õ›~{#Ábá#‡INÖ O"wãNMGJ¿ ×*6ÞùäÍë÷çáIrÎFô1R:m%dƾբųÉè|þ?GÌ®eÐpÚ“ m³y`ƒ:$EŽ!ËáMt.æ\ÀeÃ0‹ãÄ‚ú(‹8s@„HÄ ·?¼ÂPFÖê]‹«…Y†dœšnpz¾6p×q¿ÙÔã$°çèVÒ6Ay²çtèeœ\´žÎ”9óL#²à·¥ß„T“è „êvÕ05U %Ä÷ÛsàÎ3h¦éÖý° ²cž î6Øà[üÚ7'†.S&Ëj V7<Ô˜ÆXÇa{ÓÚâ,Š %ZB°Ðåss. ðŠ¬,)^rŸZc9Û~HîH)9ùÙÐï7ØNpÐØŒ]µOcŸ³Š-óXW `F°|»˜Í=é½éª˜  Ã+ÊZi%ñÐŒ´¢2º ãtZ3›Ã.ë`sÚD—0àC5,ú¡‘%Eó— +¨Ø³ÁKhæÓ>Ä +á-bìJjcSœÄÉ*XœjA—G®Ý#lÈS½ø Ý›Üòèƒt8Ò#8B„ጢó òaærzOæ#XS¢ó¯k +Žg²².,{˜e¬Ü’4È3 /oV4‘$‘i!Ua’O¾«Æ™¢Ä +Ÿ¦T¢¡Å™ÂÕa9˜£‘„,9ìÅñT€@@ŠlÞ=DTnÉË›™¢‡;z +! ¥€¸"%ß1ô€ŸÍ8ײår°¢-m®6SHÌØl‰8ÑîJpÒxP‚-=ŒF?:HO±Þ>ý1S`"@œÌÁQxªÂ=±3"êô–’ D@%V$ʲYhzØô,]-ã*`cÍÑh!ÚØ@Çã8Š’غ©q”¡Õ4#¿Ô:‡’B–Æ Ž±„[$j/>EN7⛶št¼XàRžÈnð¹Ä÷ÉWŒaª¶\bH'Ð&ëuÉT ´‡ <à/¦)x‹›¹•D1 *僆y9b›Û‘ëʾdCámðW-î–‘ºü¦Ç+lkÞ“LÃ<3î3!ÌáJëç\ÁåyW0Z`PËsH0É¢’XÍý–I½d÷.hæsÕcÅ$mV ¬bxΑ×ÌÚ²å1:oιÒZ$~Åñ$ÝĘüU»Ý ŽÑ“àPrD&S¼%ò«f^´8²Üú hm!;=U`óMÝsxÔ"É44ÐKšàa!2Ü„ô0±B)ª›Nð‚IŒ‡Ó7,—Jvý(‘‰{+á8ª8G;ã)÷í^¡ 6ô Ib=8=Ì »–¿Œ)´%$€9fåuÈ + Ç;Ü¢á <™Ÿõ4ÍX=R,‘ æä4B^2ˆòÁ:l©“P¯Ê(ï²ò3˜t"®'×TÌÎñŠE_Õ;#tZñ| u­$`Õ2`Pä žjv+böeDƒwwW¿]YhÇjNPTm§%UÜ\‚ÛkàÊÜõr{õÅ7[uý¶¿úIŠ÷À¯i¯"“¥á1ïsJo^R[,Z-Wu*Ånt»|¨A‰–RcX$W²ˆ$…À‘5ZuLç–£Ÿ Ó?ËP#5ª˜—+U«A)8‡Y2P’^r`ø”Y‘6q9Â1±ë\*rÉsà¼lR°ñ©ò¼`[.™Ïb)qŸ¼ºŸqUÇá^D<Ž.T‘Ø[*/§¡âĉèDI¤ +rѵü(ƒ6²âB¦ô\E†ŠúÎ2acôy¢1胰ûX)5¡¶™Ô[wýÏ7²ž2v»¯ãÁtRMbiË âŒUÔ#ù©eÚ¨$ÌÞ£dÂh3XòX×yÑ3i–±¬[_–ad›Â—ìváÑ0(“—Äg)®¼+àw‰Â²Ï}Ô’—[¸k. +bd˜|ΰ± +¤¤*ÇÓ…¶Ó‡$Mg(Ï£O!¢Ña27¨âfþX6fæü*Ÿ_€ +âåâlc^Œ60P•]Þäñd“ .OÂÔ(¿•ª4—ž·ªUÃà` +Ãl»ml ‰ÈåTu›¶alS0õPGþmOT +rsÉwì¡FÒb`¥ŒD^ÑOܸ)l(ï䈊ћöRÂlòi!8ýîÒ$·SäÕhù‰pÈ^Ìox^#™ýîöVv†WIA]cï8Ey},˜%T +ÃÂìö!ÏÛX {”»äÈCó{LL +x?WëgiÂæ{Ÿ,úiâîwDÖúsœh, +g=4èáI)ý=,AiSûAv—tò’V Hº8‘éøé' +Æ.”{Ÿ¼fgÉ@—Þ Þçè3î%×1tÍ•_É}vˆ•´ÀÐqØÏ2Ø>ÿþöl‹¯BM>Âd(§Öû.~Å)‹øE%Ó¢Ø8ê;­†æxËTaWbrRÇÚœlûÍ ÁŽ´”™¿Øeʪ¿îÈvEiòk¸qŒw°F!mæH´ŽôÚË|aË¢Œùâ~õì[ÉPœ%T¨ÖE¤6ÌÙñFùåDë(äÄ¿‚Öj!sªž48Ù…‘ÓM Ö±<ÙøX裸ËHW࢕ëÕ†Â5ŦœXÑÊãvä†ý ^âv %œ— +ã†OEЀ¸ßDÚ÷0yl³Ýoe¹“ø ú=¼) +ÆósVCuè„u˜³3WÕø ²¸p(wxJ4l_Eâ@£’‡[Xž›'4íÔTÄ\8&+‰Ô“ &! xd|0Œ0Â}G‰D}Ž@…:Fh¨Ï¾þd:Þ}Š\©è>áS¥FYlWDำp„|ò“Ö<Ê·æ1„¸b&ø¹`«DŸThcˆoŠ +iŒ×m*‡ùHTÔ%#„2¼|ÐÊ;!óñs{)º¹).Xl¤3™„ZËÅ%ò~F¨†pÇâ¼ú€ÊÏ@Ÿï×Ö¤›U*& ¤úÃ~ò^´$ +E™Nn2îGÑù ÀÌiü¯s°+Å•—¢½Ž½ Ùßq7šžtï|,ðÆXãóØEìÛ¾Ÿd¹âæ[Ëê崴‡èé)6ëF[€ÕB¼]ÛO©¼Sò)WޔϹ”Ðt<G\É|s$™Üëëeß­æÜ°V|ÍÙŸVHÓŒ¹ïø¸B.ßY,€ÿñëâçèo‰+MÚd”ûJFñD¿P¡ƒ‡¾Öš¤ô>|!¹GwÉæy$|¶ Þóè¬&ÃfäÞåtþ²™[÷ÌéL&Þβ„]Õq©Ö­BqM€V^Â=KÄõþgÌW#§‘64Íδ9ÉC€ä^ª÷©Žõø^¤ñ&“&Á?.‘Ê‘ò"Rëäž¹À;f þÇ QJÅÿ|ƒcÚ„˜.Tò¾®†‘gæJ€©1•k.<ëõºYrA!âÇP”É(Ck™h% Ä/M§ÏÔØö,þþ\®ÜH=§¤~fÈe/ˆð”£ñ‹·xóßós˜nF‚K&ðê‚à&‹†"bꇋö!ÚRÄ6ÞÓŸþÂàÄ+â_øÓõDLøý%:HÅ$]é,V}ó%)SQ53㯜_üÚjÓÝrѤ<è:MÉ ‘(¾”¥-m¯zžÎç­~âÍ„ ¯¤¿‰ÅVpD +™ÓßÒŸò½S£øó9†þÈw"·óxàM‡"žøþ»oå3Q‘¼é·»PÝs¢×@æ× aßÖÁ4ä_øF‡û‡”°n\Š#ÑÒÍLû„¤Œd`gó2/‘]¿­º}øÓ(@“&R‰ïy aÇ éÛý]GžF“¿*òËÌö›qä¦f‰†’’eê´¾V¢âØ0ÿ¯¹ à +endstream endobj 10 0 obj<> endobj 11 0 obj<>stream +hÞTP»nÃ0 ÜõStmt4¼äxèµ›]‘hW@M ´<øï+)N‚ <€GîH¹o-Ùò‹î0À`É0ÎnapÁÑ”«ÃÖeÔ“ò £¸[ç€SKƒƒºò;çÀ+ìNåÛkñò“ ²¥v}ùsŽD·xÿ‡R€š Bîß•ÿP‚̺Ù¯¡Ê}¹Y;ƒ³WYшPWØ\É<ÏnŠË ‹ëfQTÇFÄÝMªtÌ=^˜c¸|qŽÌ-áý)Þùä•Jü 0fdi` +endstream endobj 12 0 obj<>stream +hÞbd`ad`ddò ðò ðÑvL) 0q6q5µ‰ŠþæËùÝ÷«ægëyþ+‚Ýßy…@ÜHꀀ‘Ÿ™‘‘IH‹ïû¢ï³¾ÿmXñ»Ärj.+ˆr@tEñâ¼¼ââ¼¼ÅÅ+V,^¼BŽ ÀªÅ'c +endstream endobj 13 0 obj<> endobj 14 0 obj<>stream +hÞìÛO«+ÇÁ'àûÄlf˜Í+È:AÙ½Œ ÖÖÆzg6Yi“¥ !Ûƒ÷?€£p Z_o´t6ƒ áÞ…!Èp `4' ƒÁp¦¸‹vWÿÓ¿sԭ硸Ü#u—ZUÝ­î_U?>p6»ÝîEƒétª}ÆêîîîÅ æo-—Ëõz½ßïµ'À¥…K¯–˳ív«‰FéÄ<¿"Ü]Jõ.'ÏóÉdÒ~=¦•Fé¼y~n0×뵆¸„p¡Õy=–繆Ÿ³çù‘>À%ÌçóÎ+±,Ë4Àø\(϶ۭæ8£ý~ßç2l:j+€ñ¹\žïFà¼V«•™7«)ÏŸN§ó.7’ëõZ œK¸Bë™ç/—KÍ02My~x½ÏêÛív6›5ÝH. - p›Íæ ‡%ó<×hcrbž„[ŦH:ja€³X,µW\MWbY–i4€19=Ïl-¦…N—çyíµÖd2Ùï÷fVÜ‚³äù<àr²,«½ÖZ­Váݦ)úÛíVÓŒÆEóüÉd¢…N×”Øïv»ðîz½®}w¹\j:€Ñ8Kžn$k+Y,ZàDM×ZÓé´X Ïó¦‡%Ã[`Î’ç/—ËÚJÖëµ8QÓµV–e-À žç7Õ'ŒpŠÉdR{¹µßïã2ÛíÖ%À¸5¥ñËårÛj½^¯V«p‡Øôp÷f³Ñ¼' +]µ×Zóù¼²dÓ…Y¸rÓŒ#ДçŸh¹\j[€ÓÍçóÚË­õz]Y²ež†fKäù¡N pºý~ßtÅ•çù) 08çÍó'“I:U €ã:å¾i2–e`è.1?±Xì÷{m p¢étZ{¹µÙlj—_¯×µË‡z4&ÀÐ]"Ï7 àtÛí¶é‰È¦Uò<ïÖ®jÓ¤ƒv¹¿kn$Ã2³Ù¬=Òoz€yž7]_ív»–›fõ¡N 0\My~ÿ©õáÆ0,Üôd÷t:ÕȇZ¯×gv2Ô©a†ëô<¿°ÛíÜ9œKçSGujX€á:WžßRÕb±ÐÎýµÌ”8Q¨Yó Ôóüý~_[Õt:ÕÎý­V« åùËåRó Ôóü éÎQ;ô7™L.”燚ó<×ÂC$ϸ*ëõúÅ%…ú52À1Ïßívò|€-‹Ú ªét:?DX¾¶žÙl¦‘†èŒy~Ó½g¸ÔÎ}ì÷û¦ ›Íæ ªZæZ„·45Ààœ+Ïϲ¬é†qµZig€>š®©&“ɵ5MÑ_.—š`pNÌó·Ûíz½žÏç/š™ÐÓyø–Ñ<ϵ6À°4åùç2ŸÏ52@Ûíö¼$ò@OËå²ö‚j:]çb±¨­s6›ip€a¹hž*×Â}äy>™LÎ~MµÙlÌ»‡ËåùËåRóô´^¯›.«öûý)57 ¸Z–Käùáž1Ë2m Ðßl6«½² +¯ŸXójµjºfËó\Ë ÅyóüpWnOœBpkò<Ÿ7Øl6'V¾Ûíš*ßn·`(Öëõü«Õêî­,Ë­¢ö §‡‡Wîó,ûòåKí×ìÍë׿úégŸ|ª)àš½÷λ¿úé‡ïðæõk­WÎ5cuÿÕ«WÚ€ýâ‹_ýÇ´(ŸgÙÃÃ6«õáûx f¬Þ{çÝpÖ4¹¿¿y~(ï½ó®9¢pµ¾|ù²x &¹Zcd>ϲй¿ûècãª4ùÝG—#ý"PúÛ×_k¸6ÅAúÛ_ÿæ¯_|¡AÆ$Ž®†ÎýòåK @ª˜ñ›©>\¡?þþñ ýðýÞ¼~­MF#thù ì) €‘ùêÕ«ß}ôq,ŸgÙ¡å³O>­Íó¥úp!á ‹Çì¡3±Ã!_9Hÿò§? ~¯Ä›×¯Ë'äCWOGWîòðð aÆáó,kIãÏU>|ÿƒCSG Éï>ú8\á>tõßþú7•#4¼êü>»¿}ýu¹_]=ô`zúÕ¹£ñ4y~Œ•L…Ó˜çÿåOn:B¿ÏëÄ\ÔEóüPù—/_jägqézïwÃZùÓŸ4&‚Á‘ç•2-ÄG08òü±rB …øGž?VNÈ´ÁàÈóÇÊ €â#yþX9!ÐB|ƒ#Ï+'dZˆ`päùcå„ @ ñ Ž<¬œ®ÄÝÝÝ‹·¶Ûíõl•øèP¡ûŠ~ ª5xòü±rBnÙ~¿ß6Ëó¼iÅÍfs÷Öz½•t~Ðn·+–ϲ,ü¿vyþÑBOµôcKõé—Ê–,Viê&y>ÏNž?Vò|à–ŽVm`»Ùl¦ÓieÉÕjÕô»Ýn>ŸW–¯¤ƒòü£Å½Vm®Þ¿_ +áõårYY>ì é(€<Ÿg'Ï+y>pËÒD·=Ï_¯×åì7˜L&ÅŸËå2­·ÛÅf³YX>Ž„?+ѱ<ÿhíã2i®~P¿<¾ óÃë1ÃËÇ?C=•H_žÏ³“ç•<¸eEžß3wÝív1òÝï÷Å‹å¤w½^——o)ñd2)Gôqšwe@ž´¢éBoöYøÐ~ ‹EñVVŠFãàN¨­¼°<Ÿg'Ï+y>pËŠÜu³ÙôY8Næ¯ÌÇÎó¼˜ì]Éuc>Ÿ%yZ¬*Ž <Êóëõ:´I¹‰Ú»fµZõ©öÐ~‰ùüb±hªª<”#ÏçÙÉóÇJžܬ<Ïûççûý¾iòv°Z­Ò¨¿˜^ ù ›Í&”kóüíÏúja3ŠµÂw<±•ž1>*Òõ>ß½xD¢g~~h¿ÄyûéÈBÜ…ÊQmž\„O,Öê3¨‘<¬äùÀÍŠ¹kŸ…³,k™ÌŸF¸»Ý®x¥iÒxñî|>¯”óü<ÏÊŴÿBøX MƒãGo…eÊk§¤úƒÈóûËÑ/E{Îf³–,ïE•!ì9ÅB¹Gjóùòþ­¬>¨ò`4‘ç•<¸Yëõºižvj±X”cóT%nÏÿërà˜ç‡UŠ ç©ðzebzܲÖd29: +¾þ:Ñgû¡ýÒ™ÿ§OU”óü8·¿Ot®„Ö‘K'yþXÉó€›U$±“ÉdþÖb±¯4åÞEÌnª­˜Mgqǘ·©Â˜ÙÆ|>®RTUž¿Ùlâ¬ûJ°Óã"Ìß"ÆÚá£c:Ý4½¼Óõçù±æ? M××Ú/±ò¬!-F…Êq•¢+=Ç\Ò)÷cø7~ñ°zèô8ÐgØ‚'Ï+y>Àà„ÛÀí/¥ÚpǺMq·ê wµáF8¦ñþ:܇6ÝY× +ŸnœÃ-pyªa¹´„-íMV «Ç<$V¶Íì•¡i2êYv¶güŽa»ûY9l9ñ@†¢itøihš;§ß§*óºÓé÷é¼îøJí4ìp:Š?aåSSLƒðÒŠ¿¤ÇMí¾þäùc%ÏœKäù-3Øû$ÛMÉl6+f/—ŸyoÏáËSéÊâDè¦í,ϻ묭¼m§¤ã6Ö Ô)y~LMÓ¸eît1\~bŠ?ãÏPíÔciÐ9ÏóÊ*-gÝ4Žî“÷©¹Épóüø8C¹×í—ؼMóÂë•YG÷Hgžß§fx”ç—<`p.‘ç7MW.¢Î2ôߤÅbQ¹GÞívéb•H$|Pšü‡ÛÕÊ„›åtƒÓq‡Ú‡BýY–•+ ÿ·áµ#1ݽMcÍóÓOO;:ìw%éw—çÃ-H“ÕÎyÝ•U:#ô´Â[Îó[¾ì)¿AG4re•ÎæM+”çóìäùc%Ïœ³çùiî] ·›f£Ei˜ßãËQj´f wiòþìü¬°LSD¿ßïÓ1‚–»é[p;yþ釡PF)ýQ‹lí¯Iü=ç„xÂiú9+~ËÊ?7}R÷b­øÀc¿Œ7|‘£Oz#ÈóË× GôKûNÚ¶õHyšAçHØæ³ÿ.3Jòü±’ç ÎÙóüøPy ½ã fg>ÿX—Ž¶Ü`¦cåÁ‚bôùjñ~6*?þè|ûÚùü•§ Ú…ûñmIü¸PIøjóŸ…ÿWª-žQ,°Z­6›MŸO õ„Ãò±òPIh™þO´lÛAÝV ûIQIøOø³eú'êEË”¿`gåíûjî9±Ëb¢ê/wel“ðŸâ•ÙlVy<¤ÒéÀÐ¥á|ùÅp^JW©âÓì=ª|c%MQsí6ĪZ~²[¶¤Ó óü4œ?¢_j³÷BœcPþˆ£{¤i–BŸ-2yþXÉóçìy~e¢ûr¹\¯×•h¹gL³Ùö,zþKíy~Ëçîv»JUå(5­*|¯Î¦¨ m:ïºÒÅ}ýjµzQ'~ñðŸJÄÕ[¾þ~¿O·¶²z{ú*oª¡ÈˆúäùE/4mÃl6«]«Ož6¯©é +Óé´ç¨Gô¢KÜÚ¦é÷é~噫˜šVÆ銇¹Ây»rŠo…˯Ç3mz>ŒQäç™J=éZå +ËçÕÚÅXíqÏ 7Ïc¸•ñ‘Cû%^¥ ?¢|ISî‘Ú¹q­J…í(ÆjýÜÐIž?Vò|€Á9ož¿ÙlÒ4>Ïó–Yôi6{ô=f–;Ô¶RŸ‰Óéýƒ¾Kšç·'Ò¡©Ó¡“J^é‡í¬h5¨ÕVf˜§Ãy~ûÆ·lCgžß¹y ÓDò| "œNk³ÖxLO2ñÔWy+®R9éÅçÅ*§ô¦zÊç™ðVåW ¾[9۔ϫáƒ*_*~V: ÑÓ•çùÅóqéëñ‹§ƒ#‡öËci(§|E‘+ÑÞ#ñÝ´GâZá­Ê—*ÿúŸòÀ7Bž?Vò|€Á9ož_‰mãóÝqrZçÓâu1i¸«Í²¬6$i‘ƼEdn®ÍÒíé¹bq·~\óV¶¿3rO?«iª|Yÿ0¿%Òo™Tß™uz†ùµÛЙç´y-ƒM;ª<n\ñ#8›ÍÂÉöî­ðŸxŽmT§ˆp/ÖŠ¯Ôžâ©#Ô\|PüñMãÜbáðÑÅqøˆ¸mq 3¬Õ”ÇeÂGT¶íE×t-®<Ï/~’B[ÅoÄÙJ\¿<þòÇ«ø òÞRÙ¸pñ)a±¸måK¬´Gâ®UÔ¾~±Vù‚-½6€”<¬äùƒsÆÀàœ1ÏOoùã i|=Êšojsì–l¿e“:ç?—ãÓ¦Ûít{úßü¦Ðÿ‘öôs+Ï5Ôå†Íó<Í«ËADÚei|”~J¦)¤QI¡ÓĻҕVJ§>¦ÛYžLØžçW>=‹I¿`Ӟг›:²tÿé\Šp)†\ço…ÿô|¾,œLÂùªX+œâ:,Ba±bù°bÓð_1nß –×jú -çù•Ï +ßèˆÇÜ*ž1> +_omiÞÐq±GÚ¯Žè—(´dø òÞRÛ¶¡Úbœ·ügŸ)ÿö•?+8âÉGn™<¬äùƒsÆ<¿2ñ¯2¼’ú†?[ªª Ø$|P¸«mº“­ “›L§ÓôÖûzòü4I¨ÌµKç–§-YÞ€J§„Õk›1ÒKGj*i!¥_ތʷ¨M?ÒÌ¿¥¡ZöðÚ¾«l^vÈ]ª<ŸJžvâ£'Ó4– ‡’ç•2Ààœ+ÏÏó¼=×MgA·Ï +Ûn·iÜÅ7Mœ ]ûŒyËtýr¬}=y~g÷•g­7U7 ÿC¡a›fà÷œÜž.7£Rye(J·6~ÐAy~¨?Ǫږ4_QžœÅß¾þúó,+Ê—/_>ïÆÈó{ +={-|©+ÜBy>ç"Ï+y>Ààœ+ÏOço6›òýÓã²ív»\.{û“ɤi–~±…‹Å¢g°_¾óPžŸnXKž:¨O_¨´[8ÿé³ÿ¤#M›úú®AÓÖÞPéŠñ ‘°ña¯hùÖOÖMò|àó,‹qÊï>úøy7FžßÓõ'œò|ngoç8ò|€Á9Wž?›Í:gYW–™N¸bÜívëõº3Û¯<Pk»ÝfYÖ™íÇ)èéHDX·çf‡%z*¡²ÍóÓ »ÿ~“¦×Sý7£§øeÛ*Ïó>ƒ8¡§*#POÙMò|@ž?Dò|n‡<¬äùƒs–O.¤­7#´aå­PgZCøÄÊqZ*}«v¸!ýOÜMò|@ž?DNn‡½}¬äùƒS´ö£ìJ&\NÔkµÏ…NÓÑ°@S¤^oÉÌÓ:lj:Cûñm¤¼\.+ ¯V«ö +>.#Øï÷iø_ Òûx‚íÙÞPµV´mOÐMM‡aùQ`ÜäùC$áävØÛÇJž08'æùiÛ'¸®¬þ¬,pD¤ß”™é·Ì¥?"Ò?.Ì|ª<ÿ &jj™Îþ +Ö¹=#ýétZyt¢³¡ÚÒ‹'è¦,ËäùpãäùC$áävØÛÇJž08§äùéÔît†|­4¹ UU–Ùï÷ý·- H˦N§Ó>õL&“tKRi:}܆µ{²<ÿñí,ýö& +-Óþ]Z"ý"!ï¹íãaKGú4TgÍÅwì|ºäBÝÔ4N$χÛ!Ï" '·ÃÞ>Vò|€ÁY¯×wGÙï÷›Í¦òbmH› +‹UVlJÑw»Ýjµjš^ϲ¬2[»IøˆårÙ”Z/‹Ðý'Ò‡%ÃG78´aMÂê•Vêì¾´ýÓJZ¶*ÔÚ¡ÜÚ¡¹Âw ߥOË„eBýqõÉdj‹›tèf”{*lCØ ÂÎptC›jû@ew +Úûg隸‹†¯9/9ôa`¸äùC$áävØÛÇJžÀåìv»íÏš¢Ýž¶%'¦îçÝ0n“<ˆ$œÜ{ûXÉó€èþþþó,‹¥çbåòåË—Mkýíë¯›Ö +o5­Õ´J(a3ݼs•rVöÞ;ïž½þÐ ×SþúÅåø誶í òáûÄoñ—?ýy(›ýððàÔÄ¡äùc%Ï¢žAAe±ri™¬^žÓ^)-qSÓ*E°|èæ)ÊÍ–¦c³åxi:0[Žeå¢=Ø¿üö׿)9´®rÍ¥<.Y¤Ê—/_¾|®aåûûû¦Ušf\?:µåÍë×M«„·šÖjZ¥²m®ð€±’ç+Š<_ž¯(Š¢t^n÷º®å²üÀQ¥ô¼æt…ŒÕEóüÏ>ùTž¯(ò|EQEž/Ï8ÝEóü–Û1y¾¢ÈóEQyþAM«Èó€1¬<ÿáááÐÍSy~ÿãEž¯(Š¢Èó®Ö°òü#6OQäùýy¾¢(Š"ϸZò|E‘çËóEQy>Àõ{óúu¸iŠ¥çbåòÙ'Ÿ6­ÞjZëË—/+ o6›»»»ívÛ´Êq›7”"=PäùŠ¢(Š<ÿQžpõÖëõ‹Ÿm6 Â-{óúõß¾þúôê©­ÿáá¡i•ûûûÚUÂëgÙ$¥ùêիϳLQŠ2ô1kåŒå½wÞ•çwn›k €‹úß~øß&“¢ü×bqhÐÑBgÔ2딉dÀÉóàúÉóàúýßÿú?ÿó¿ÿ¢ü¯ÿüÏß}ôñAåÍë×Ú.m>Ÿ¿øÙÝÝ€+$Ï€ë'Ï€ë'ÏžÑ~ÿãrùÝ‹ÿ¯(áÿáÍ)y>ð\v»&“ob˜_”ðŠHRò|àYl6yæe6{£} Bž<½õú_µI~,«Õ½V€2y>ðIJìûö0¿(›M®­ ’çOi¹ü®O˜ÊdòMžÿ¤Å  ÏžLÿ0¿(óù· €´Ûí¶Ûí~¿/¿(Ïž@žÿ4›½9(Ì/ÊÝÝ?µ5k·Û¥oÕ&öåÓÐ^ž\ÚÑa~Q¶ÛkCèo¿ÿ15¡ìv?hJˬV÷óù·E ÿ¿»ûgKɲtàhEö¾ÝnÓ·jûöwåùÀEív?L§?:Ì%¬žç?iIh±ßÿ¸^ÿk¹ü®r¸ÍçßJõ Yöý‰'¢Í&׌Jž Ån÷ÃdòÍ)ZQ‹hLH¯,û>íGYx׈Øf“Ÿ~"ò¸G烰Ýþû,a~Q²ì{M +=3üJY.¿»ñv;ñ)¡ò,};!‘ç?¯Í&_,þ1ŸÊrùÝ~ÿ£6Ôzý¯žùØlöf·û!PK†Å4,7(üÐÜÝýóÐ ßásÄé¨O }aŸ ?yþ3Z.¿«Ü×O&߸µ‡ŠƒÂü<ÿ)¬þíÌ*ãÂp;V«û³¤Ðóù·7ۆ皜÷ˆ.'Üçn6›»_ +/îv; ”<ÿ¹dÙ÷Mw÷Óéß·Ûk"x¬öj ˱X8ˆ:W •kanǹÂü¢l6ù ¶áy'ç;\BžçY–Íf³­&“Éb±X¯×Z yþ³è„|sö¸qýÃüÚ@¬OzFíÌ-ØïæŽÎ#n6{£µ·íöß—H¡ÃÁuSÏ‘]hr~Q6›ÜŽ +pŠív[žrŸeYí¤µh·Û…ef³Y\Ë,}`äùO)Ïêœ-l$<öŽû<À²Ùäõ¬V÷Úœ»\ÝòtÌÈtNÎï[l_=ô‘à‹Å¢¸Ͳì Ãòq@3×o~šÊc‰òüv‹Å?N‰MÂÍþvûo͈ƒ¥˜Ü:ërù]çñåàb¬²ìûCg݇0¬µÛýðØc,àFŽövè“ƯV÷î.§¸ ],G¬»Z­ŠÕÛ§ôŒ<¿EŸD±OY,þ‘ç?iOF¬s"ëdòM‘4öÔçјP§#‹ñ {uØ·ûŒ‡©˜á—u>,3Ÿ;úf¼»ûg{#ô^ìì g!€£m·Ûâ&t³Ù±ú~¿w Ü&y~“õú_g óã-–}¯U«öèìÐ0¿Vé<²n!–äÖtÎ  ì÷?¶WöJÂo܈۰3‡ïêèX.¿³Ó!æùGO°w Ü&y~­ÎÉÇ•ùüÛ#RMžWžÿtw÷ÏÐwE1.Sk:ý{Ëžt£…;«Ð;ÚŸÑèÆ +ÇZŸz:™ õŒxbyg~åû×Ö~~ Å/;Àbž¿^¯XÝü|àfÉóSáƼ}^_œ!Ù9‹ò\•yÆa6{SéÄðʈs°#l6yûnJs-ÿè<¬SŒFç¼úp¸õ¬ªój¬cagœœ_è<ÅyPà8ÅMèl6;bÝpëzâô~€’çWäùO3ñBY.¿+–¯Í{oyV䘬×ÿj +…âÀcWä~b[õ9$ÃèF༹qg¬ÞÝï_3žwr~¡sœåˆ:X,Å}høOžçýW̲¬Xq2™hFàÖÈóËòü§>á|X¦²b–}ßgJÿègEŽIçÔVMTØï¼tÌjè<¦FKrk:‡®}%ü6õ›³OÎ/„–ï©·j·ÛÅ[ÑÉd²\.7›MK°–ϲl:ƵŸš¸5òü²åò»>a~íìúýþÇöYÊ'Æ2<™žÃ:fcڧž+ãêœp»ZÝßòî}CÍçßÆ$3ìÃáEûçh¥£³÷γÙÈNe—˜œ_è¼BȲïíƇZ¯×/êÌ©œáGËåR—sÐóƒOIžu†¡L&ß´çð›MÞ9Á²i’?×`»ýwÏG-ŒÈÚwøõú_ç;Y}Û~lÞÚŽšeßÿöÍ/ÄŽì<ðzôCD*a‡! Å&Æ,¤À;ì—ÆYðîãZ{`½YÖS/Æ »‚Ç ˜fÈ,fm‡‚dÿqÏNU´ØRÆÊÄÓ‰Ù†3šY:Es©ò¢XL¼Ñg§ÜËáγKiÆ|XzÞîKqÏHÖašë´Dg¤Ï èÁ"åÃF ì@ЧÒä|Žt =Ö ‚ +oÓÃá^¨Wƒü²ÒëÂKý ‚ ˆá0‚.ý_‘•-`YSúðÕqœ¬-zÞùü ˜ª¸²|IwREÜ=ÙF¢h¾TÎs隺¥H%aéYª=»dÒ—&õ£ÛûZ4øëûQÁKHË;£¬:9ŸoJ¢Ç:ADKA^ö ‚ ¢‡¸®ÛG<÷Þð wguunÍ4M~›Q%ÿ°, þäû~͵*g/ôÜç+ŠÜÜþVš.‡çé_èfQ—ùЛ$E9¸=ƒV­¿³òÅÝ4$ gåÊ| +EiK=~XåaÔêpX=Éù iü¥”ÀAQ'ð"¬"7~ãÉßþÜK¯fôg/ÿ!‚ :Cžïa²{á©øžoÛ6ûÆ4M×u‡ïD€KC=Oî¹Ï—¾•3-EóÜ—ºøҥ¤âÖá8;Š.Ô4×KO8o5Ð õgƒC±ølêÏÒ”ï(¸ 5Ï£5;>wà°íQ{›±žä|†t£ô) l‚ ˆrñ}õ1ƒÁÞÍK/ñù8ýëO?ÿM8à›G¯Ì?øÙWß~'õ€?µQל>}úÌ™3O=õ™«¶C]I]IèÆ“O>Ùê®ìÀÿžç±{IýçATâŽãÄ„ý°ƒb@¡Ï>_jÚ™,j®Ä¼Ab)¤‚K4]dAÕ§O)' < ·(ŽÉ¬}ï ÛÛÛë999¡¡Øj¨+©+ êÊâ ‡Ã.ù|×uSî ø#ëé_?|+ã8*ç÷ÙçK5»a\)%; g¸j€Ã÷£^5¾Hs,ù±ººGÍöGH‹9ÎNu—vÝ[ŽŽ©,¥äGj¡K‹ ‡w¥Û7ÚØ’u&ç7ÕwA]%Š"ö®-bš&ÓõüE;‰a1ó_Äç_Ü=f®þüÖ~¼<ž">ÿÚGÆææÑýK{÷6'íØ‚½¹¹ÉtÓññ1 ÈVC]Ù666¨+©+›¢c>ŸIï,Ý ÿ„°;õ<¯ñªŠ[U¶"öÖ竸Ü»4á–ÞýkFjc(“! gx»•ÓóêU#3â‡i®«Ÿì8;´ì4H#9Þx$®;\¤!°Šb|5ï­ ‚è*âÛhL×Ã[¶išü7–eÁÉðU¿Ä ‰ŠŠ¾Ÿ>·†q¥‘버Ì6zÈv«`ž´L‘¯kséÇJG*x—Ê¥‡3U6¡´QáöaªÔà íLbyƒÉùŠÓ¶º¸ AD@:KÍÊÀç™l¥¼ƒã>Ÿ |æç/íÝC|þædvq÷XL×'‚ ˆ¶Ð1ŸÏ2LÓ\Í€ÿ³±šMÕ•Œ%ç+¦è÷Óçã&°R¯%5l®{‹ê‚©Jº²º5í!¸¿ª4Vf +®¾ÛÕªž7–ŽÌe‡eÍm{¤®ô¡g)ŒU:èti@¡O¢f“óÒgJëÖ"‚ ˆÚàÆ^c“õ<ùëâqŠ~‰ï°¸Ïçß»ú(cäæÑ}Äç_Ü=ÞœÌÄt}êk‚ ¢-tÌçóç{*­!ü?cFêuñÿpzèó¥£R‘¢â“)¯²i2ÇC9ìðý¨žúÀHƒ¾nWwKZm¡}jRʽHGfî8£J¤@ fÕ6þ{‹t£V=.ÌU·O­DOÎW¬F· AÔ7© öø_µù|Qàßž>€ß >ÿÜèdþÿxíÎ õ5AÑ:æóyz€¶>‰8††aÖ{èóñ ùÒù¤2Ç4×)K¶þ®¯awúWT@†q¥žëG«¬xMv +T}#Åv8¼«É}2-A!ÝÀ_ëi|­¶Ð:$ç3¤‘bx¦ÓÈ'‚HÂïûÈ_uðù€wuŸùùËãG#ç·&ˆÒ?™?? ÃÕÂTZ½¬ä|†ã8YŸí›Ï—ŒrzáÝÞîuÈÏ츈f‡mj¨ €ÔÈB+ü3®­j€¾éàE ¢’?_|] +ÙJs2»¸{̾?{ý€úš ‚h óùšcÛ¶tw@VbCß|¾&úBV¨'²Ðƒ}YþEÌ Œö6c#þéïФÙÚ%î‰í +Q9jsËÐp›<âßÀjìº·à—¾Á¼¨ÓÍV‡tå¯9‘[šâ®s³ã§þð(¾Ѷ;‚ ˆTLÓdï¡A,ûYþ +œã³I¤>ÿòxÊüü…Ñ!üxóè>âó/íÝÛœÌø“=‚ ˆv@>¿‘¦F°,+õã½òùRwQ§ý“æZÖ ïR‚©T™Â µPVV¶Zš‹Ô¼©M%xZ¬þ“oÒ*nA%¶“•zHߤ)뢅ú8Îô;ÜHë<¿tgVý= 'u)øþ!­RY9‚ ˆ.Á-:àºnVZŒ(ŠÇaŸ2M³ÜšdùüÅãœüµ£ÛÓðýÉü!âóÏoMÄ®Ý9¡¾&‚ Zùüz€fxVƒ”T]ß+Ÿ+ôš#£h.u;ôú_O;ÃáûQmUÒMè)¢g*¯´V:oyð¼q#a&•W¬¥Oè8X—ªrØöHÿ Mxì‰ÝEýµ’nºÑ³1ñ0DýÉù üYÓÈ&‚ ý±,Kå¥uñ蟇Ðu]ñíð}¿”j¨øüçnDˆÒO¸<Öú¿”ƒƒƒõõõíííùœžS톺’º’ÐýýýÖueß|~žç9Ž³òø`0DQTõuyfB*|"'¹±?>Þ£qwT¿<÷ýHê©ô—Tš#Í®¿ëñ*i›¢‡Ã¬6žÝݔٓ†3©Íö¼qEW‡õPejÄZ²¸„ƒ}ËÚ(EãWt¨¹»›Úk€W¬Îmkê©gKRŠ>ADà•9öÒšõNšÜ–oÜeU#‡Ï¿¸{Œøü›G÷oOœßš¬íÌêÜë9>>¦Ùj¨+©+ êÊâôÇçAKà†Q©!‡`øµÇñ}?öOÎâqƒçy<íÁ4ÍX”¡ŸEsÏÛöøFÏ 4ib#ÕÆU¤Îv7FΠ…g‡™:¨¶#WÐMåÄJÓtõL)×VúIãbz®HR^ÃÜ—Åä&¦ÜFÕ°>”•ß"ùÌ.õ š^mCum¬0>¯)EŸ " x…÷YöÒªâóá6™¨V„>s2C|þ¥½{miü›7o2Ý4›ÍÚRgE¢( l[†™çya"Ÿ‚¡5DÁÇ>”QQæg‡»2uA`99G§ÔÐÀöö6ôãÆƆJW€„̶m>ÎáG|ï’Ê(Uo‡Ó¤?,Õ•úL®>ø|˜#†aœBKª˜æ0;àÒ0UÅIŸ/ž2Ó4aš‹¿/îóƒ`S4ð£†Y妹®a¯t×€æ ÆÌá#mkÛ£¦’f¥©’pXÖFývEÚé +4i8LçÙ]]–{n JÒlózrŒa­Æ[¯ y†»€›]öE×½¥[w‡w¥’5¯¶éîY輡@Ú׎O‚ ˆ¶†!“T¸ŒÍGŸ2ˆøüó[“µíññqÇ pEŽã – e¥kÆR7¡üÔ¡ÈÇ\EÑE÷¼+³XÊ7f,öˆçyÒr`̈©¢—êJXMÓDFi–âS¥¶mgÝ£ÊÇYª‹z´…ÖÍÊ>ø|X½¹Ì‡o\×eòÀ`01…^ +©ÿÉ >?ëƒ}~–™¬MF)È»Úú +iv±VJ?¦l/ÆRy¶¦¹îº·êläd˜)u”6x’æEëÓN7Tx{ÂðÓª1a"Hg1XÆa…YÊ™Ãx€6g|~L=ªÎÆGL}² ¡&ÒpFSA϶LpÍc‹ …­7ºÅG‚ ú’wÍ^Þ?øÁJ}þÉÉÉ|þË3Î^?@”¾´>bQYÀ pµTQ,õQE6ƒd9*>Ÿ— +(šR¯õà²EáÖ+V”ŠÏ·,KZ”ëºY>¿þ¶Â#Vbä(iÔsŒÒX­Ô?žÌp¦Ñ®yQ}ðù|‡Ir +ÃíêJQñùYw‘Ïç#Y¦ZüýºñthÛé¬ôó9ü¬¦®!yruuO¥ª ¦qJSôµÚ”¡ú®´†Ãáݶ,GM­H¾5¥ß«8Ùz“µiØÝ1ô—äŠÓG‡<¤ùÚî¹#‚è61—Êúúúk¯½†²··çlll°d˵#ÄçÿôŸßQ/*øœ§ÁÉT”bQ¯¿þº(óÇ¥+üõÙgŸ=}ú4’bÍ ÉÓO?½š—õÆo<ùä“<+8™<ÏÊÓ>ô¡qKÎä†ä•W^ɺÜp8äAÏóÄ?qS +ßdÝ \‘ÛN¸õ`Ž¢ë•,*õd^_b]+ +†Sì|îókn«¯}ík*I¹/¼ð?-k”ž9s&«Vb~òÇ>ö±X­’Mº¿¿+j0$cÌã7˜,**J½¨ÍÍMiQìœsçÎuÛçû¾Ï&r”ábgÖÓZù|n÷ù¸è{≷©UìL©åËJ)¯¨Vp¡’u-knœÅ} +Ú•o¿¸„Š„3w>Òýÿü™ŸÖ_«Ôq¥(úšõùÒœØWÿþûü ˜J§UjØ®ÎUô³Ï¼Ù „‡öYYÙ‚Ã4׋—CWTúõ¯íÒ½ÐÚŸ ¢aò¤PÅ(æçç;ßA +a)Ž›››óù£÷—ÉlŽøüW¶"õ¢RáÙ’± p**«¨3gÎdYúXQpEžkSܬ­­!µúÊW¾’šü,ú|äa óÇΡ\ª(•ü|^žŸ=ȃeYHQ| q'5?¿ž¶‚Í +ßøÆ7ð¢ž}öYƒH¥Ï=÷R+Q0Æj•lÒÔämÅ¡i½ª¨¨ñx¬R”J~þ+¯¼ÒmŸÏÆrßJ*Y;¹J§~ŸÓ\_4íóß~† ´/=ûtðù ó“ªôK¯UÎkRâá8;ÏÿùbÆUÑ®À§>þñ«_ë‰'ÞŠ]¨)ç#MÑOæi×P«Ø¸‚ ‚Û×Fj•:Úq|æOÞhÜç[ÖÞãÜšÖY«d~ûÅ*îs)7º‹‹îq` +ü…w ágŸy7¿o]þÝß{kY¥Ïùš×vߤkQƒOœØ¸:ÿ7?TYŽšõùxl1ù4ojm_çìõƒ,Ÿï]ݧžªÑsª¸ž<ëtnHðBø D|>^žüœz!ø¥çy,hUMî5è9K­Y'óä®> ìB¸óç]œÚq0á÷<àèû>Rf ‹[‰µU¥xÓIÛŸ§7§ÖF5ŒmÖP0ÚkP¦„ +¥?auƒ|¾¢ï6ëó¿ðÅ˸êI:ä¦ìJÍ¥º/©ôË­•çkHËÇ,ÏüÉ0®Tì +ôÝgŸy76`ªÜ;T˜ å/;J¡Î©éýêíŸö‚ßóx–Üâ}ÕÑyŸÏVïä¨F&~¹Q9i³çðù_þò—áµ”wŽ²>ÂÏažËmÛ£“““ØGøñàAú8põÔóÕkÅßú­©ÞŸþiØH­ MRÏçw¥ +(¦ô˪Õ÷‡{ð×4ùIûúÌ3ëçßÊj«o}k7G +ñK/Ý®´—íùRô«®W0*Ô«W[­²z0Šæxmÿê¯nÕ_+4”T>ýëÿ\s­¤ãêoÿöê|ðtðýBs0¦Š &Ÿ~úzk»tjÃí7þĉ+XT¥›qê¯?ð'TêÓ¼Áµ}¡¢¸Ù›A‘ +¼b§šØÜäöù—ÇSÄç_»sBUŽãàJVEŸoÛ6;MÔ¤‹e|>³¢¿å‰âYP3£\Ÿ¿ÒïSKø³|~ª æ†+}<íŸWÏìùV<|”ÂTâñˆ|íÏ£lb؋Dz΢R:ïóy Jú°`ë<,57{ŸŸoÖø~”CHÖƒÎuË"¦ŠMÌÒ/ˆT=5x@k8ÎÜlÍßçwñ(’J2¹6+IÎýzÀ}ô‚ní‰WضGMU .N “Ñ|Ó-ë0ÍuÏ—µöªokb³‰/#•"Í͆Y¯áÓÀ—£:¥7©†í)]ÞµõA=dYŸíÎÉ¥½{'ó‡·§Ÿ¿¶sDm[ܦ4ÞRŸÏÒ°³ö(šR®nD1Ë ÅŠYÊð{>jážPºÏ}²Ñö§ŠwþKè) ž‚~ä#_^T|>7áC™*£Ôó<¶×¾&ÛD±ýùlââÚ„; ø`†Fãµ¢¸Un&³ùÍ£û é¼Ïç#“ ¬sxŒ‡ªÔˆÏ¼¸a’««{ÍõÑ–žr§N¥×R·aˆ›‚Æô¼ñpxwñXb@ÅŠ›j?¤-’ùŒ|)ú5 h ʽì5ð®†)­•¶v—³»øü…ÉË–ˆrG.á¬K5(}i¤ÁÇ"¬“zúgm+†#]Þ5\E ‚ úÉR>s2cºþÂè~ô®îgùü³×ô¿÷ù|>wwwÇažMg †Yj…ŸSPwsCbYÖJ1¾O^KÅ”ÞÔbæ3×G©J9kG@¬+³®ëºß7Œ¿œ™ïQ4Ç ‰¢ÃG*rœÅ©îXYÙÒY–j›¢‡Nšš×R4 /Jc[0´ŸâtÎÒæ0ÅRBÐàpˆûk®± ¹—Màf¥ж—µMƒ×vãŽty×y0AôŠ¥|þµ;'ÜØÃF‡HŠþdöè_ “ùÛG÷Ù÷º±½½½¾¾þÔSOinòERefYJ4$80lŸ/5¥ISÄÿšª‚ `%dù|Ö•ÀÉÉIò¯®û}ÍM¾x¬¬|ï¦|#'µ>ëÅ$ü÷7ÝûR÷S}~Ö~ të»T79PlVW*îþP_ñ¤Ø¶ƒÀã)Ü…&kË/-î@‰M@ žŒèÚجYY.wÙsçüÖ¤H9}ðù !´„G‘9[.Mù|ék#ïÚ¸Þ±¬ ÍG—¢Ò‡sr¸©áð.®=³Ì´*îð3fʾ4aµŠ*¬sÔ†£aŠ>Lê–îwÀËõÛ3if»¶©Å­C*Ò .›ŠGºnk¾(áku#ïYmc‹ JÑ'‚hKùüÉlÎuýædviïâó¯ÝyäpÎ݈à{ï꾆Jssóõ×_o‘ÌÏrõû|&íc¶GÝ”&MÏg†ord„BW2s˜š Ü"™ÏŽ0Äœd>?æí91ÏŸêóù†‹ÜVM,vcc#µ+ë÷ùl &CHêeÚó |hÏÚLiƒdueœ½~@ùùËÞi,ö„/ïUW¦Ÿ¿ÐOžKmd+Þ «PúùÒò¡‹ë¯0œ­®îåˆ#äÛ>ЊœgÞ2øíÔŸ¢¯aˆA}„ã³Æ÷#}*£sK¶XØÕ7Uñ®®¶=Ò¿ u“熖Zð§¥èAp|߇Rx?µ,+öZ ¿´mÛó¼Š^®—òù‹÷k“›G÷ŸÏ¼ +ÿñòxªS“?âðððµ×^#ŸÏá†D´µ"0a(rkšfêXB€îºnÒØÇ|óYÕHíÊíííÝÝÝÔ¿¶Îçö:¿Tw+ú|èYöhv±»c¿Lõùb¿ÃØpg0,µ^‰Å²®ÜÛÛË:§,ŸŸUN†Pq)ŽÅ8T¢0€“Iø0ìùÜasê·œ#€Õ +²º²tbæ"EuÌçóÑžu u˜°\ìØdó·æz6èó¥B²æŒDÜFjžÎ'RDéC§@³Ã­‡ëÞZYÙR—]¼døl¹7åû‘mª“ùp§Q¤ãnV<"V³õ•Zèúã %6fBUjwKŸ\„âšYÅH†KK—ÓV,MZm¸“þw¡DLºs¤EÑg‚ ˆŠ€÷PÑðH3¢KÑ^Öç¯í1mrîF´t}ò`'œßš°/Œõì$GQCR»‰»Ç‚A©ÏgDQÄM+•:˜Û/â_<3¦µ“n0&îÔX¾ïóñPÊŠ'¥|ÏH,;ˆï…šºà0· ÉÖKýýåñ”?w +^¢o>_ôù Y]ÍO‡k—C“:"nŠ  à°¬²Ä8”V*‰¢¹çña£U…+E«ýö&ç+N™zê/­,S­ <µeÍT_á̲zAºšµEÛâq(¸ÍÞV&7øÿ$m ôATAEÉl|àS%æs.ëó7'3nN&³9×õ©œÀM‹wUÓMâA¨‡TšÅ4ÍT£ÅÅc2%8 .Å}>ày^RuÏ † %§Î è£ÜÁ¬ ›æ‹­ù†ñ—xrþ¢2ŸŸ´÷IßåóÓÚ¡„TY-ŽÛÜ>Ÿoëƒ&P¥üŠ±}(Å}/TŒÏÙІôpL…­N°$F‡ì)Ï£‚W!ŸßÍú|ß4q€Ò\¸Ö)_é•~Æ•ÚÔSÍággÙ½15ZóÒÑ$E¿íÉù \çÖ“¢/µ»5ç9÷ +ÆêJ?uÓ²HWi¨O[ZO«”x­6 T7pîFÄäÉÚÎÑÍ£ûˆÏ‡‚l¹´wº¾ +DÙ¥¢:y&¶˜·¼XÆçÃP¬ÔçÇٲ†}«©Èç/ÞŸŸL×_¨ù|‘ xDYè‹]jDQÄï]Ü„¢>JÅr·¿"lgJêvBÉü|ñ4¾ðo?)´Á|~#4îó=oÜø«÷px·KRE¤¥}TµçT$ g0œl{$Íiì’‘êÇF/®%ëÉl/ŽÔ¯šæzu#J–ƤŠ'„¥Ì©R4µô*­‹#k"Ò5 +”‚ôŸJÑ'¢‡0o–TRà|®ô“Tqrøü‹»ÇLžœ½~?">Ÿ°¶sÄ~<¿5¡®¯.7bŠ> žçÓ§ê>Ÿ›U×u“c)‡]a™Øbi±a¿ì(í0Õù|Ñá‹n?ÙÅ|„ð|û,]ÏC?ȨPôù¢ô}*ü^b÷¨>JáŽø®Üí«RlÇA û A dÿêyôOo/ΟZ\,´DÏo„Æ}~Íñ×Õò¨q¯ÒöœØJ•¾m4tãP%ß [cz¶ÁMÕ!MÑ7ÍõfX‹ÂaRÅZ ”îqhé.¡–²Ô² ψe—Aé^Œ–¦^㱞æÒõ°u<<ÑÆ;"‚(Ϧö?>„Rר¤xç]“ÞÉõ +YîÔÓþù5 Qúâ•©8J¡pöŠ­´E|>û ´ 2 àº4ȳ·dÓñýbO?dþfèû˺VšNœY¹©¹‹ñù ™C³¬J[@úú_ƒ‚¨š*”¾i®·ÂÓÁÔóÆЖR ]i'žUÞ®p˜t5¨(I®‹‹Ð–ÚÝVãûÞ)±õPe`À9®{KºXµÚØhpwÍ®W t¤)úé#¢WðW×ÜoÊ%¾Ãæðù'ó‡ÜÏßž>¸´wñù×îœLfsþã愸UÁ»’õfR| ®(á›äþnH<ÏK;P‚hQbéôE|>ÿ¬ã81¥?r½\J «íTçóB"tê& Tñ.›Xiðq©Aö©û| â†ÆŠ…mÛ΢±‘–:Èaâðñ–§Èí{ùÊe&[ZOë'¼;`p&ÿÊ.þÄ»Ð'wðtÕ硆zêàóƒ`Ú`~/ž[unsm”«ô]÷ÙE}€¾hÊw)9_eA¨(ÂhÛ£NÚݶÏ&ènÅUfYVð7 gЃ*¿í›ÂOo|ƒ@PŠ>A§í>¸vçäüÖäâî1|óè>âó×vŽàœ³×Øì#DEˆ’w+CüeVnsì489&Þ‹øü˜§…Y} |ß•Þ7*õù<‡<µÁSÅ»èâLÓ„Xßá^]Zlbæ<¿(ä±`Dª_ÊpBÉ™RÄsŠS Ú‡54¯yj ­Ïˆ+Cê(bå/¼}àôÃÇ>ÿÝ"—#Ÿß[Ÿ¿½®V—~&¡•&6×>&÷ú“–ß7¤[Ñ$êRr>_¤Þµ\».Í¿íLT±ÀxF[²Lã«G*ÝRøÓÜuoUwi<¼Ïú–6©4ç¡ÒV%‚Њ0 UW¾ï—˜«œÏçÇ@|þÙëpÂÅÝcöãù­ €Já³IŸ% }¾iš©þ¤ˆÏ_¤yZ˲báƒÞR©Ï‡^àIæÛg‰wX‹#M8_Êç/;^1XR²ò±ká° Rê+â9¡@¾a!õ¢©¶>#­¬Æ‰þÁÞ`ÇÊÊõ"—ëªÏ_)@ õÔÄçK³|+J?ƒ·`üºËBwœee h«–&7ö©….]v/9Ÿ!ì†q¥ÄIÚqAkœ¥‚¡¶=‚©!ͩ•JõꞪ †ªv·wCADx6æ²öFÔA¥¤q–âó/Œ¥?™ÍoOœ½~à]Ýßœh´ëàà`}}}{{{>ïÚ–íÁ``Û¶˜® ýëº.>ÞàS«(žç!% ‡CvZî'0¼á㢨1 nDºêpW¦ÎYF‘“Ù/S–$¹Âð.Nþ ~ã8Ž(«aøÁoTƒX¬zWÂÉ0¤ÅÑWd£ ýðk!àu^ªý³&T[Œ^Á0¹:±*eVòÀ ²=ÇöW>ÿöKEêÜUŸ¯y=5ñù ™Ôª"O^jíªÛÐ ¾‰MmW˜®‡›…F†šŽV'ˆöèY|<—î|ðÄãVg•K#_¶=*åBž7®çBDñù…oæ*å¨Tw×ÞPÅ…ÃpÖHV@=àwG>Ÿ ˆ^!戦ʱTƒ7´eeÍ•âó/§ˆÏ¿vçDÏ^ØØØXÌññ1ÉVC]I]It¯+ù^¶ÔÝ"¿ä pÿ½÷žÏ?|ËûŸEêL>¿-TäóñHøRúà6²í¯ÿD‘¦û~TÖµ¤á°Vï戢¹TÞoL•«Ð*¤A0•n¦(xtc¾ñ ž¼õ_´Æ 2zÞ˜¦'A½BLdeɇ®ë²ÔP–2mÛ¶˜Ì ß—’œ¿(Éçßž>@|þÚΑž]póæM¦›f3úOµÝPWv†íímèÇ êJêJÑ®gn^¸¶jþfÈ|þïœú_ó%·¼!Wì@Ï_–(š×):ðð%¼m$¦ø¨.1g´:9Ÿ Ž´1 ¦RKwT±/‰(ô¸4j–ûèÌCGš*_Åþ¯F6Ôܪ©÷Ø=AKE‘mÛ§–Ç4Í ˜²)ÅçÞÕý,ŸÒ¶ŽIvêJêJ¢{]麮eY™Éù‹ÅÎËÎ{Éù‹ÿj¾T°ÂäóÛBE>!³[%&õe½‹Çpx—–¢uàIªe)ân'çs¤æZ;wá*ÁÒt-e9Ûu©»ñ¹Ïúr/‡GߪØß×°hÄþu«ŽA´ß÷Å×RÃ0à½53M1eùü £C$Eÿöôõ5AQ.ƒÏÿÊç¿â|³`iäóÛBu>_*¸Êrì•j:‚h(šã±*økÚw>9Ÿ!M3.’i,]…|?¢ñ¬-ƒÁ¾4(¬rÀdÇMñ)©aûà«P¹Á |6uéíæycÛÁßPÈ " CÏóÇWTÃ0bÙøðKx]õ}¿ŠK—åó/§ˆÏ‡¿R/AåbÿÇè=Ÿÿó_ ¾[°4òù2 àF kÄ_Vçóµ$õù~„ Ú½N´Ïã#¼à<êIr>cuu¿Ù|û†pÛ ¬„4’5'™,½¬Æïvf5Þ8%®Ò¸[÷Â%A„”åóoO >ÿÂèšš ‚(Ãøerþïœúá÷ý( +•Ö1Ÿ·³ú˜VßS÷±»¨ÔçK5WÁsiö2¥ÅÀ4׫ÛêbÛ#<Ö·Æô¼ñ²«´Ìn›ÞÎ]iYêf‡ã씵ÑLs\÷Vé°¢ÐAQeù|À»ºŸåóáOÔÔAD¢(bIÚžç…a(þéÔ©ŸŸ:µøð'ÞýwŸ¿÷ôóGýãéú/ÿïý§,AÇ|~7¨ßç/döluu¯Háø‹?½ûÝ@šBŸ{œKSa ÎÐ66¦a\Y*Î(Íù‡eŠÆp‹pœß·HqmkEm‚ B¤DŸatˆ¤èßž> Ö&‚ –b0†qJÀu]þ×uúò^ŽÄgÍêöÿð¿½Ey®E>_Cñù¸ì*’ýÓr½Ahü•Z› ‚PÇ÷ýSi0¥‹˜ÌçÇÿøVž2ù| iÄçGѼ + XÖFßR‹‰Þ"õƦ¹¾¬7îar>_”ð`E3 hÛ#¼ÏÓèm#A0uœ˜V0T˜Æ§¸ .Û™o‡v+r !ˆµ¬ezÞ ùŠ%mqÝ[åê÷~&ç3¤f‰ÀïáãÒ\eZ…ˆî! „Á˜Ï½nH7ÎІ;‚ ¢: +úüÉlî]ÝÿêÛï\Ü=†Ï^?Ȳ+pµ6A¡H©2ÿ /á™rîFô«GYOœÕäyâÏצ|~Lñ—ôe3úà¥^j†Ã»ÔãD—f•Ã_Õ}Wo“ó9R!ŸLöýHªi":Œ4’‡mr”,W„¥ö'‚ ª£ Ï¿<žŠº~mçIÑ¿=}À>5™Íù÷ 2ŸÏÇãñññ1 ƒ¶ÓÛ®Œ¢h8AЙ; +Ãpmmmk ûnÙuÝ•ÇÀ7ð‘Š* ; VßÃ÷ýê®E³2 tnRæhå?ðgÊ—Ö'NŽ+’Ïצ|þB¦Îgg©Òl{„¿ø/[ A´iV¹úÈ—zé'ç3¤ .äƒ`꺷¤1ÄR¬&AhŽÊΔe£Ò• 8‡Ÿ ‚¨Ž‚>ÿöô¨ë¯Ý9AìÊ¥½{ì#bJƒloo¯?æää¤íýÈåÆp8Ì}²hHÇQ¹®iš5H•^ueŽ~ ü7\HªÌ謓ù²@«Ô ÿH¾Å„ñ£ýJ8}úô/~ñ‹ÔàfùUØ톡2ìÕ‰¢Z@Û"–e‰ ã” (Ú*«ÂâÌÎA* Åg%ôlòöÿèÏ^@ž2üøëËyÔ(ù|mW¹F|¾ôm]]ú~„eW:¯"‰ÞbYÅsÂ¥©þ=‰ˆ­®îáišëp,¥ñsì• ˆ«‡Ê¤€'µb*2&µÀä<—ÇÓÉlŽ–ó[8ÿÒÞ=1¥¿A677™nê@^wé>ß0 i9Aˆž­AŸß¥®TÇ÷ý¤o/Ýç*ùÿ¢z-âó766>ùÉOB!®ë&ÿE\Ȳ,ø†ý& CøQ1è Ül–ɱm›×Aä”2©!3ŸÏà +©ÐèÊ"³’ ï$_Z{[Åç¿~9ÌqQòùÕ1Ì õ¦|þâQÌz÷‡*^Å$PÑééÿ–µ!-Dê±ûã¢óéúÒó“ ¢EÁTÅÀÃiÒ¢Td>M(‚ ¢Šûü £CæOàøñìõıÀ 7î‹)ý Þûáááöööîînú±tŸø¾—㺮&>¿K]©3Û±äüE5>?U­‹ÄÔkŸ]ÉRôSãìB±‘É2öU‚R X`Âó<î¡Y˜ZäF=Y‚øÙ$±HA²aù„ÂSKˆ)}‡èÁÁÌʽ½½¥Ú߶mÇq`xÃ7I™ÿOþ¶ŠÌ‡ãÆFžÕ€|~uœ*FS>_ªáõÎÁ­¾ëÞ YYÙ¢BtÛåi…ál8¼ëûÌ2JÎçHã#9Ó\§-BD·Qñð–µOE™/-‡ ‚ ŠSÜçÇòí×vŽÇróèþâý)ýÔ¥P…ÏO͉ÉÉ}~ogn2/½ +Ÿ/Í~‡¡R–Ï L–Ã*–z*#‡‡HØ-gèy2æ¥68 CÑTÃËNd±±hNgÖ±Øä|ô?¯"óÿûÚF¾ +ϯŽ–ú|xWysG¬¾JN`òŠ‰Þƒ\:‰ß÷#¥M8` Êú¸¢Ì‡ÕŒëAD ÷ù±|ûkwNÍriïÞBHé?¿5¡.(…r}>ó†a …A žL>¿NÂ0dmîy^ìOåú|Þ¹xö;Óàüäâ>Ÿ._Í®EQÁ‹ò¨„eYxilG@ªW´Á<ëAʼn\|ÝÖÞé¬ R¥îç^zUÅçÿõ•wòÕ|~u¬‰>WýèQ÷fLHÆ>nYø§VW÷ôê*‚¨jØ+=«¼‡ÉùŒ(šã–ÊÌ'™Obm‘ÎetÔ<ª Èíýa|àô¯«È|8®Žþ%_Èç·…:}¾J‚}LŽÁ[?û¬ç¥'So=¡DM;\þûŠŠ4ô…ãì´ÎäÍçsšM¥ó½ï}ïàà€¢¬+ŠÓd>AQ'¥øüó[fQÖvŽàdz×Ór2(:ÿÍ íG+r}~EìÇq² +aÂͲ,nÀ’R%îè8†aÀ™mqŒ‚÷N¹>Nzu1¸€\Ú󼤤…3³F,œ i¸T’í Àe~†©ù½1x| +ó"r!ß÷EÕÉ€–WÙéÐì¨f½‰$çøŸQôù{?#Ÿßqêôù/·•#åÕóÆRi0Þ¥Þ$úƒb‚ëRLÏÞ¶gŽ¥ Ûñ˜cë¸zõêÑÑM%¢*azÑÌÃ7*!’ùADÍ”âó/íÝcåìõG‘ýµ#Ä´0Ï? )×çÃ÷,íÙ0ŒÔ‚ àÉÉY>Ÿ ÏTLÓ¤\ý|ð†M5´¥û|îÕ³²Ö™†eZ;µ´(Š² -¢ãx +zR°û¾Ï. +’Ž"$Þ$ÂkˆìIQAÑóËÅZUq"óÐIìBÉðY,z¢ÿ¨fõL­ÿÓÏ“=5V°Q +*±E˜20_HæAÚRŠÏ¿ytŸ»øqs2CdËÅÝc8¾Š!¢ ¥û|®×Rõ&OfÃ0Õ—Âï™q…¯pòð=àž¤mYu\X¨…5~ò¯¥û|îÕSÓàaxˆÁ…ÔÒøhßÃil$À7¢|Nfl¨Ä‚J¬4(J1¤èó˲¸*åˆ ’o"óé)–ÀûÚÚø%\Ž§¾ã{„8à›ä>Æç^zUÅçÿý›Û¹«A>¿-ÔìóäûÛÅAä`8¼KÉù%²ºº'Ý+亷ÂvCÄûpœ•†d>A¡-¥ø|àÜè«o¿s~kߟÌ"²… |ÑùOfM¿ÒÞòo:‹‹+Z?q·‡YwÀå†ã8«2¸.C|>ONfG/Þ­LȧúRn,“ZRÌÖ.˜ ­ÔîƸÎÔP¥=XÓemàÝ}$ ܨ#>ñžk…“—ã%@·.Ò|>H©+ ÷Ò©Á¹àIìlcHê˜Ìîz¹Ï­àHcjƒ‹ñ,Öh©sñùð'îç=Ïã¿gÝJ íÆ?’ükãðý>l£GÖþ‚â3ð¼øÒÚÁ^ŽGÌ7îX(Èç·ƒú}þãáq^íËòƒÁ>õ#ÑOT4%ç«cÛ£TÁíLŽ‘ JÙ.D2Ÿ ‚hŠ²|> jy¦÷³v&ÿñæÑÿgßÜ£âªÎþŸ?»Þµº^úÇûG»Ö»Þù½ï]ËÚMâ-ÈÜu !$$“û ¹z‰bÔÞMÆK¶VÆKÒX'*jm©£F£fLˆ¤Da A,r ad~ÏœÍl7ç²çÀœ3ÃÀ÷³ž•3‡3ûìËs2Ÿýœ+©ì‚3%‘ÃcÒ&jý†!Ê ëH|~$fSõÞ˜Ë7æ }©æTx!q²ê*#Ôt y—ðÎ7[°¢´ŽÜçÓ@k¼:‡Ybš*ìWýÙâêt¾¹#ÉNÜZÓ+ô‰•F˜iêAùüÄӠŧ«Ðwf$ÞÆœ×ëåÝÅvÄ«–_‚d‹-åð]!êñ© =Þ….Ïd¿äæRrì˾6,àóÓ…”øüØ$±Á꣨ŒfB¡+%¯Ø³NII3“Ô±nwm   Oˆ‹¢„ÏEXnR…>_äxÓ%‰r9ÙÝÅ®hìdåúÝá¾”]’N2Ÿâ¨qý°>Ÿ×Nkªè¹ …B‘x>?ɦŌŒtòùrÈ{›+t³lôù4Ðý6Õëãû24UØ+Ÿïr¹Ø„±ßGà³H2ÏÍ4õðôùfM²¾õ;q»bxŸà`»ò«>–9gQäæò豄j5áóÓ…úüØTIÈê‡B=D0š))iZ,­;·»–þ‹8Á`v¤)ùü‹]½åRVÛ>®½µµµá£§ÓÌç6¶L\nø|¾Êxð_¹ÏçžÍãñˆ‡¹\.z‘NÂ~5ô¥|/€I­2¬F¶q(«ªªêêêÂá°þÝô’ùˬ™ÂâÃAÝw&pa.÷ù‘X= ½x·¯¼JÜðllÂðêë@  ˜WP‹C©×ì4‹Ì®e¸Õ盵“š!ÖØkZeÑç»Ýnýæˆ(ÃéZƒƒÝ@IæªÔw>ë ÉUS¿Èž·³SrsÙ±ÿr"m†ÏORîócf(V¿¤¤ #€DéÓ²¢ðz/Ð1ô_Zh°÷‡ðû[ ó¤#ù|ÂwºÅL¹Ð[ÃáÚ«‰OßaõùVJsÍÖø|Âív3 Ë_ ƒ|〽bæK Kmé#œpû4’U*úwÓ«>_èlÙ‚ëó­¬h³ƒõ>Ÿ›qìhbhž0<ý ;RÄårº}q(‡ Ù³upyNŸ¨—]A³a1,Ú`ÞŸÔ3bXÙ˜3;'GÜ)àçO•Û—¯J±ÙlzÐ|з_äÁ¯Ð»»¼Uâó7nUi3|~º0L|~lÚ Âê»\UŠÆ‰Þ|{|¾æ’’&ú—Öú|<žzÈ|i‡s>¿¬¶]b]:®¤üÚªªªš+6¥“Ï¿0¼‡|>/³ú?×ëõ²W¸”Ô?Ó[lGÀPìÛhõÙP==\~:ù|j­•›dŸÏ7Mö +M öŠ_h±ÙG+ŠBçä…úá,^K]]cuu5 å|þ˜AÂ/p°—®ˆo +6 æ‹k° Ù3+îñx$OFØŽ8”q;“²Ÿcf(óL¹ñÉm¥èˆò”ïX"m†ÏO†•ÏMž»\Uq Œ%0ÜÈ̬†Ì^8çóÏ|Ý-/Ãáò;;;£®ébeäLIµÓ‡|¾¢(ܲW˜’ÍÌÌäÇH|>?I  wEÃD®5ÃýCi](µnøGÜÑK•ÏÄü3¯`çÏ_ˆŠ8îGƒAŸÏG«qû|›@Êdú|>9E».og Ùçeâ>ŸA+Ëï÷S¯jܾ¸r&ËW¥¾WhˆÛíV^vO(è’ÜV¦¯oU^žH›áóÓ…aèóô_bõÝîZŒ0ÜP”pFƧùÒç|~[OX"^JÏ)è|qÈç¬À>###¢ÊXv€ÏçãÄõù"Š¢ˆõâÅV žO•Ïçͬ )Á,«ø‡ƒJ&tQáêKLJàó%×(ŸŸüê,~ðD3‡‡‰Ï …Btul¼¬oX$ÃÇ7DgëYôTáÙc_ TDNxi|~º0l}>ÃÐêgfV+Jc C‚Á.È|púº]¢’ îðz½Ù*ÌMZœóùDé9Eâ^ºÃ}˜ÏváœÏ÷ûý\rû*ÖÕúR¶Héo @îܬÙðÞÖˆtý¶û|>j4 xuºfˆõgãÛìY ^篟º|î%âë,ú|~uVßØÒ¬…È`|>ßÕûpÈ>Ÿš!¿3ÚÒ™ÎÁg”!*ÔU’Jɱï¬}‘Z¿-ë >˜S°8ÿÿþÇ5äøàĉ$4’¾õ»ÝµÙÙçé_`˜C7k‰Ì÷xêÑE†5*cHÎãDdZ÷§fµ¢±S¢_Î|ÝùlÎù|EQØ‹‡Ðfffj–›~I²#YU¿!ðùC#îVˆs>?SÐ4¸\ÂkŠêõgãY|¦ÃÊg‰o™ý­¬??Â/Šæ­dŸ—.™«xúÉ×ón¡Ïû0Ÿoq£gxú|±ÜZË'ÿ;î°ä†Rx ½rï5‘ÎP"Í€ÏOÒÂç ½ðxê!óÀ!¬ø|+ßÇáó5ýé„Y­ië‘è—òúÌg»pÎçn·›‰GC¹jè ¹54±ôbâžvÔÂÂl¯ÄQŸÏŽµA¯ŽõgãžÙåriäDuã’­6ñˆDž¢²î±ycX{ Ÿ.¡³‰Çè¯(î݇®…¯}«¹1ñ†v—-éâß?og©ä†2v~säõÌ[ŸŸ.ÀçÀ ôJßë½€n€ÄÏw¨?ª”–èßi<~nŽú|^KÌ…B⻆¾TttZ:{d†~àŸb¨CA\¸˜Õ „f8œðùïª7Þ†gëÞ½^/~Š~æ›D†ù<îSVT]z0äMbM½]¢B­åeù’þ1ƒAó¨K$±“¸N©ÏëgŸÏÇUÿð|"FÜà0“ùDÑ‘JÉ eåüÒÈ'Þ[ŸŸ.ÀçÀ!*+ÿ]RÒÄ"êA‡€-Àç;ÔŸyž²Úv‰¹ØÕ‹)m Žú|EQ$ÒÌ—jv4˜éPÞ±fäÎù|BtÚfÕéš³Ñaâ_éñx<ú¶ñ½Ãw­3(ŸÏ>—/‰‡7›½Öe¾×ëMp!ë‘‹qjö0ÜA£&‰{(¾óÝÿœºp)ýð½ü·äV²»¼u磕ý½!Á{ +|~ºPýÙgœ81ähooG@Ò€Ïw¨?íòùÝá¾ÃçÛ~qê_Ç›.ѯ'›»$†Çëõf«X‘äfó×%¢wÈt³·hqéÕhFF†Çã1¬-VàþÓívëßåÃa¨‹-Ì£0œNü-3møµ™R^ÛfffîJD„m‹@ HwIæ§úPþ„½(?Ov#ÙøûÞþ»äØt§XûÄѱóó%·t÷I¤1ðù€íÀç;ÔŸvùü†Ž+\­Ð¯»zs/ ]¨Œš|[àeØÃÓÐJ…B|2ÈÏJú].WjL36§.õ-ïça¾w¦ß}àL(XÏo…ž‘ÜJJŽ}É~(«M¨î>°ø|‡úÓ.ŸßÖ接¦­‡^9x¶UâaºÃ}tÌ™¯»égßé–†Ž+I»öp8ÜÒÒÒÙÙ‰e•îÐP677ž¡ …BlÙú|¾9”ï¾û.»ÀAÕƒ´[•¢?×ÃþÚ'ŽZ‘ù'›»i3|>`;ðùõ§]>?"üŠÆ¨É)¯ï¨æüŸoc¿ÒÁI»öººº*•îîn¬¬´f¥×ëåë å-·ÜboRÃdUúý~š´4²ìé þ¤‰žï|÷?ùmBîóÅhë 'Òføütáþ}÷,ÎrTöú’|¾Cýi£:ã¿ôœB¿Ö´õHô øì׃g[“ví555L7¡D?Ý…C©(JFFÆÈ«`¯®®~óÍ7‘œGÆPjV%Ÿ´ìÑþ˜‰!cçç[ôù¼>?ñÛGÊ}>uõ ÝŽyG™!ù/Ðh `qþÿýkÈñÁ‰X¡4àóêO}þ™¯»¹ié÷QHT 30 Wø+»z“sííííuuuXVéÎèÊ@ 0òJôi(,X@×åõz1±ÓšÖÖVZ•MMMü~»!‚Á ø«ž…ûaw„¢#•»ËOY)ÎgO„%Bj}>õ -ç1րχÏ€t>ß¡þ´Ñç‹¿¦­‡^)=§H$L[O˜Žá¿žlîÂ<À +,¤}V³‘‘¡( +Æw$!ç³Û¼½äØìŽp×s/[)Îç·›DH¡Ïû>?.ðùFÀç;ÔŸ6úüˆ ðËë;è×ãM—$B† ü²Úvöëáóm˜çXAQÊ`Á`pÄ\Q(¢+¢1¸# ±Ÿ†Øï÷KdõUÙ³ù ¢ìØ3}~âL¡Ï÷z½ìs].u–€ÑçÓÏù|ƒŠ .  iÀç;ÔŸöúüŠÆN&Xžm¥_/võJ„LYm;s²¹‹¿ÒîÃT€ƒ¦8Ÿß‚ Y¸ï‘þ;ȇ§J߯”Ü>v—‡ÄûH‚¤Ðç»\.&óñdŠDŸÿχ€á |¾Cýi¯Ï¯iëá¾¥­'L¯øN·Hœ @‡ñ_éÏ1Õ`d )΃c¤ì.?Åîw=sÚŠÌçÏy%H +}>ûP¿ß? +§G(òx<™™™Ôô¿‘¸'Àç@ŸïPÚëó»Ã}\³4t\¡WÊë;$Z† üƒg[Ù¯t0¦:ŒB¡¦8ßãñHd>Ão ÷Énwªã;Ålã8ARîóGáHü~?Ÿø|Iˆþ¹Äþ•°Äöl;|¾C>Ÿ(«m5Ë™¯»%Z¦¢±“Ž¡Ù¯϶bªÀÀív‹ÅùŠ¢èý­ˆßïg÷‚]‡ë ´Kno~úÕÅ®ÞãM—ìz¤+…>ŸÕQ57B¡ïpÇS©âõzãþa‚>ÿÅ^ ¿B ,>8ñCk}‹@ #/ðí04D]o ðùùüîp_CÇ^3I?H´ ø5m=üLõQ-F¶Ýæ÷ûEA‡€Ä¡‰T#nÑïÈ# ú|>ZSôoJ.Ÿ +ÛH¼›xFFFÿ_žð¸Ç$w’c-Á`»í)(U>Ÿ’ž7âaRÊÃIÐç‹Ž@ ò=èÐGß"ÄÈ‹Ñö} +`ðùõg4Bé9E"g.võòcè_LõAáõz³U‚Áàæ¯>k†Äãñð?ñûýCn¿¢(™™™­7Êצ€fñÒ˜²á°âÇ̦¡äÃÊl\hÂð?¬šs‚P(DÍàÏa‰óŠ•Ç]f¸Ýn‰»Î ú[ævÜŠn.K9¾¤WÔpŸO=¯¨È‹óé–ÔŸžr]•Ý#¹eøÊöM¿ú|‚åÀá°|’Ÿ ƒÝÀ…ÏG àóŸH#àóêÏ$øüãM—$ræds;Œ‰}0(˜Ù³8ŸÍæ¯.Wü;u(2qC€‰GŸÏǬ5,33“ @ ®Ô9ÌW‹ãÈ…¤•mv°&ÍZ©ëÍyÊkŒ­Ü&hÊÎ.qÈ1ô®ÖïPôA No6|Ôó†çaõÞt™løè_·Û’[^ à[ôƒ¼[ú'Û…€½gá¾É-cìüË••—ímjj}>ßÖdÛ£•RFÀÃ&üBW=Ø¿…ÏG àóŸ£–dúü‹]½9sø|[’¯½µµµººº®®.§û8Úî󉸥þ>ŸÏ.ŸÏÄ£ø ++ëµXó?’†Ò:LjV®>?nQ7¯ÁN<™ÐPVUU%2”š¢tjLI ·Û-‡gffêM¸uŸ¯Ÿ´‘Aî86` ßpéÑ[ú]9öxBÒ¬f(5;€²þ<áq ì.o•Ü2¾ó]꼑ãóÙƒ!ò‡ìʷÄA%+ 6úüŽýÑfŒ¿zÆøçŒÿIÎøŸª‘™3þš™ã¯9~ìÌñã¢1nü¬h\§Æõ³ÆÝ0{ܳÇޤƄÙc'RÌ;iÎØÉs®¥Èšsmöœk§ÌÆÔ¹×PL›{ÍtŠyј¡FN42gª1k~4fÏÏœ£ÆÜhü”bÞÍ?‹›Õ¸E 7Å-?¡¸U±ÈÃ…Ñø1‹E±Èb1[£‘¯‹%ѸÚ, +îqËÀ¸™Ç æˆ%óÆÜ1g`̳ÆÌ‘30f1Ý ò£ñ“hLSÆ”‘=0²„˜¬‹Ic¢úc1‹›DÞM?e±hB,T#W (&RdÞªÆsO>æÐ2ÏɺvF,¦ŒiÙј‹)Ñ›‹,Š)ј‹I±˜¨ÆŠ©ã(nŠÅ±¸AëYLw],ÆGc¼ã(¦‹kcqM,2cñS5~‹ÇâêéÑBñ#5®šq ö+{ëêœh†añ!Õ°l™ÑœÃÒε±ä3VHAãfõg!<]KJ7Ì{c,nÏQ,MMRÓOVY±”•=·?k©‰ëÛÜÕŸ¾bLŸÇ4©Œe³Ù&9MŸÖÌ2Û­²ÌfœÓX*Ò—Qš²š…ÔD4Ø\do:Òd¤¸IÉƼd˜$©IŸÌ”>G¦©Üþ4õm¦¢pÇâ–XÜL1©?æÇb^\37s(&÷ÇìXÌŠÅÌXäPdQ\+É]†é‹g0yÓç1ÃT¦Ïf† í:]BëÏi&iM’Ùâæ·«&fÂçÀp#™>Ÿðn‘ø™îp_2¯½ºººJ¥³³3ÝÇÑ ŸoX~,ÂJI÷KÌêÍëÖÏ9’†Ò"\jÑ Ÿ·zVStH2Ip(Å–¸ÝnÃfñêô“\¾”E¡‰*®ÍaüäfS7 Š HÐÊòÔ_©ÙÕ%íé ýPj¶ZL‹ó‰2¾ÿCÙþoÑ%óªÛÛœBŸ?¨$ø|}þ5[æM{sÏÌ¿ì™ó×Ýó+vßZ±sáßv.~kgAåŽÂ··{Ž¯9V¼þïÆw¼[ßÝæ}·hû{E»ßÛzÛû[ï<±åî6ßóÁæû>Üüó7ýêäÆß|´ñÀGúxÃ#Ÿl8øÉúÇO­{âÔÚ'ƒkŸútí3Ÿ®=tzÍ‘Ó«Ÿ;½ú…3«ÊªV=»ê•³+_=»òõ³ž?æùKõŠŠs+Þ:·¢òÜòwÎ-?þ÷Â÷j +OÔ,ûðü²Î/ûøü²Sç—~úùÒÓŸ/­ú¢àìÕµKÎÕ.©©]r¾vÉuKjëòëBùõ¡ü†úÅê7Ö/þ²>¯©>ïŸõyÍ ÑøWC^Ë?Q|ýEÊŠ…mþ[Ž ¹r/5F£«1·[Ë_F£çËÜ+ÑXÐÛÔa5¾Q£/·j"b_Þi¼5ráÖ>Š,èkXÐW¯FhA_Ý‚¾Z5¾XÐ÷ù‚¾ó¹}5¹}Ïí;§Fuî7Ÿå~sVªÜoNÇâÓÜo‚¹ßœÊ ’þ87üQ,N.  Æ‰…½ï/ì}Owö_ØûŽÇõ¾½¨·R·õþmQo…]Ôû—E½o.ºòfÞ•?ç]y#ïÊëj¼–w¥<ïÊ«Ñèy9¯çh,y=/åõ”åõ¼˜×óBÞåçcñÜâËGÔøãâˇ_>¤Æ³‹/?³øòÓj<•ÙŸ¹4ÝOæwÿ!¿û 5~Ÿßý»üîÇ—Dã±%]Æâ·KºYÒõ𒮇–t=¸¤Ë·ä‹K.=Ðüû‚öýÊþ‚ÖK[,ý—oéW¾e;eÿô-kò-k|pÙ…—ýã¡Âú‡ +CÖ>\øÅÃË?xùù‡—·|ph™}ríK¥kËJ×¾PºîùÒuò¯;â_ÿGÿúCO­ö© Ï<½áé§7øŸÞPúô†?<½á‰g6üþ™?»ñ±g7<´é·‡6=rhÓÇ6?xx³ïðæ‡7?ðÇÍ¿ùãæ_ÙüË#[~qdËÏl¹ï¹­ûžÛzÏŸŠJþTt×óE{Ÿ/ºãù¢ÛŸ/ºí…m{^ضëÅm;_ܶýEoq™×[æ-*+ÞZV¼ù¥âM/o|©xC xÝÑâµG·¯>º}ÕÑí+îXñòŽå/ï(|eçÒWv¼²sÉ«;¿º3ïÕ‹^Ý™[¾kAù.÷k»nym÷ͯïžÿúï™óúžY¯ï™ùÆžœ7öLÿóžiÞ3åÍÛXPb™þæžœ¿DÓˬ¿F3̼Šh’¹¹b—»b¥š‹f›¼·¢‘_¹cI厥•;–Un_þööoo_ùvñªcÅ«¯}‡RPñ5 m>¾mËñmEïnÛönQñ{Ñt´ã½¢ïíyoëž÷·ÞþþÖ;NlÙ{bË]'6³ìt/%¨6ßÿá&ÊQ¿8MS¿þhãmØÿÑJV¾7W3[ˆe¶Ëlߦµ¯(­©9­õ‹(›µ«ÙŒ¥².5ƒQîb)«O’…bYÈZ"êã‰È,iÒÑÉÜð‡æé¨?#©éh°éµþŒMJ¯y‰'%5/]æyéO&y闞ΗšòYjú6;ýv`ve§ýÆ JÙ¿ôk£%¤©eõj¦ª‹fªå_¨iŠâï¬8§Æg¿]qö·+ª]qZࣞSz>yÔóÑAŠ•>¶òƒÇVžxlÕ{GãÝÇW½£ÆÛ¿[Uù»UoýnuÅï£ñ—'V¿ùÄš??±æu5^ûÃÚWÕxùɵ”¸OFWYéºþÜUÍ]ÑôõÔ€ôõ”š¾¢ì™o3X4‰Úô¨Ä:ÔŸÄöÿ±?ýú¥²þ<ö³#[îWSÙ½ÑT¶•RÙݱlv§šÐn{¾ˆ²Ùn]BÛf”ÓÖGÓÚv1­y^îÏlË„Ì–¯f6Š…±ävëkÑüvókÑä6/–ßf«ùbÒC«àó`¸‘dŸ_^ß!Q45m=ɼö††¦›zz’ú¹N`¯Ïg¢^_Ü+Â}2·úCöKŠ¢PK4…ÊLõX¬ÏIC9¨×›v{}>\C1Ρ©"œH2©««£q¬®®ÂPŠ2V>sè]3!oq)ñÃ4åîq}>ƒ?Û’‘‘‘àL`Ý®ïsj¿fÔh‰%³>_3”VŠóy*»§¯¿$¹YL(èº'wS¤5ho›S^Ÿo‹¹qx"yŒÅbö€Ï‡Ï‡Ï‡Ï‡Ï‡Ï‡Ï‡Ï‡Ï‡Ï€QK’}~M[DÑ”×w$ùò;;;G†¶×çsÙ ÍNÂá?ØX/J ËPÑHþÑ0”ûÇÌZÛëóÅQ6; MÍÁ &“!%ŸÀq-‰µâ¿mq)y×Å]4½ã®2+ð½ yƒC¡3ÿVR„-„Ãaq(­ç³Rϸ³*‹Ž(’›Å÷Øüùÿ‹ô(ö¶9…>TŸŸŸŸŸŸŸŸŸŸ`È$Ùçw‡û$ŠÆwº#24ìõù¼’VâEy ?7`z©(Šßï§ÓruIÇ»ÝnI#飙÷£?IÐsŽ`¨Yé÷;ìõùt¯½7; MÍ´1ühMY^ÃÏ£²²eS©"Ÿ|[Áâ6?^óŠÅ¥·ëâú|³쪡ã 7&Ĩ1ìl©*ê¶RœÏ·HˆïýàkÉbwy«ë¿>ŒTØÏ…>?ú4D `ø½Îg©ÐÙø ¥…ÊÓ>|>|>|>|>|>|>|>|>|>|>`dC_ékc‰ +}?¥/’èN’}>qø|›DÔ\ìêÅ  {}~DÐõ†g…¿™Ï§uÇT°!n·[#]éWf†322,jÞÑ ÷·Ô‡úwm÷ù¢®7<‰(üÍ>šŸD ·™NäX¹"Þf3­mxùŒ!,%®"5{^ úüÁ®Ûß!ôïR;™É§nIá½ÏJq>ï1c~0vþç’ÛļÞYû"ç|¶·sú|6“iÖi&îC$îRZoá¿ðùðùðùðùðùðùðùðùðùðù€4…Õ1z½^ú2hXvÈ‹KõtÃê3’ïóO6wIDÍñ¦K”!`»ÏçºÒ°ZR|×ÐçÓÚäK/33³$† ìxW®1aòãÂ=›ÏÈbÙîóy»áÇiÞ5<Ÿ-4èl&Ð|†Ä}ÃÊñ©• r´²”èöÁ‹ç5·‹>Ÿoʈ~°«FßÃâ}ÎÆþÐív§ö~g¥8_<Æã).<ð‰ä6qUvO ø¦HkÐö¦ŽBŸÏ&‰f^‰3œ¦"Ÿ~loÃçÃçÃçÃçÃçÃçÃçÃçÃçÃçF ¼ìÐLžV—‰E¡ëÙ$ßç·õ„%¢¦ôœ’üNèS”ÞÊÊá}æ"…ûZ•ñ`µ÷rŸ/Vàë?N¬Þ7ôù\0ê%0­;¾rù¤:º$»Ã} W†P;ã^ /Æ6Î|8¨KãÎ>LŸX¯AS½ox66ÜúàˆP¶mø¬ÇJŽÒOª¡!_J@€.™–~Ù¢Ïç.öê`W~ÐE+ˆÆp§;ÉX)Ρy"¹G”kÉø†ÈQG¾J$ÍçÓ Òœ·/i¤Jƒ•­[+î‚ñáàS‘ïÜÙ8£àóáóáóáóáóáóáóáóáóáó£ +½ÐȱºL¢ôQ œ|ŸO<Û*Ñ5m=ádö@8T22ZÇŒþAí ›¸J±‚×:Ÿ(í5‹KTý†>_s* |¯ý 3Evé)=»z}§[$Snøµ“Z+¿^Âmø®($­#÷ùi¯o —Òú³Në—cvZ³c×°Ö—’¡Øä]G7)Ã=:@|jLô¨ƒZ5†—/®VºÁÉ÷’ƒ•â|ºSkÿwÜ„ïÿðjúµ¦­G²F +´çו}üNÜ•2’æóùÿO¸0l·kpõ÷6ú-<öÿ.Ã'Dìmø|ø|ø|ø|ø|ø|ø|ø|ø|ø|Àˆ‡1Šf^£VDáOßI¹3aEq¶#N_’ãó/võ>ßVVÛÎ\}Ec§Dלùº;™=.2ŸÅ¿M†É ŸÏš¦XóºÜçZzEQ˜Ûd~X¿¢í]¡¥ç”´ù,žm•_ŽÜ7:áóyi®¦n\ÿºÄç›e: › q/y¸ù|ºïè éy×YA£Fµjä—χ&îXÛˆ_Eó¢•â|êÆy;ïgóÿd}sy}‡Ôçeq¥ äû|þTª|>k‰8p|kF“½nãüχχχχχχχχχÏŒxå÷!z¹AÇð\.—¾Ÿ]E‰~r|þáómÌÀT4vÒ¯òò˲Úö¤]~8L#™ÏÂðB¸ ¢Q^,÷ùš:|Ž¦nßÐç‹V“þC_·¯?›˜±éÏý~ÿRnJ|¾ÙRr»Ýâ=H³:¬û|½Ôª1k6û+³A7|¬ÀÆ[‰x]’mqG#:W}Á&ÿñ¦Kò§i¶>þñðù4 +4‹hEðµC¯” »hbÔ¶0iÈØô¦ ‡>>>>ß:ðùðùðùðùðùðùÀ ï¼ü붙—qáJÓ!¹‘.$ÇçózËÒs +{E¢k|§[Ø1¬ŒÿàÙÖîpŸC û&J/™¯è C^Ùkñ`ÏèÔ}ÄHòú|EQØߊÅÌt~:fP–ÒÒÎçK&|\6(Efv°ÞçëÕ}ÄHòžMLÚ\ì{<C·oh5%;¼…ܱ'¸Ekq)‰î]ì1£š™XºC62‘U3¨ `;¢·w»ÝúVIŠó©7®ÊžÍ'ÿÉæ.ÉÒ¸û•O~xJܶ—¤ùüá¿d6Ùø:Òï71ó¯y¨Ä–†Ï‡Ï‡Ï‡Ï‡Ï‡Ï‡Ï‡Ï‡Ï‡ÏŒlÄâI³c¸zÊ0‘Ÿ„Ïç‹{žÑ@r|¾XßÖ¦WÊjÛ%Ò†Žöds—­ +‡Ã---_]}ùüK‹õëÂ^ŸÏ— ׉úW }~D•“ôŠXÉ,ZJzËÆGcØPvvû=¶1”.!>%U>Ÿ [_Lé_‰˜ÒÓyÌÔ.½.ÎøجÊ}B›ïˆBÞúyøÓ †O¦èu¨†¼jRèó©I|\Ì ú}Ãâ|·Û]xà^r/_­÷=úWþsCÇÛ¯eú|q&‹;núQfÓÒÆø|ø|ø|ø|ø|ø|ø|ø|ø|ø|À(Á°$R/q 5$òEr$‘ŸßîãæÌ×Ýô +ý+‘6¬ðòðù6+†sÈÔÕÕUUU}öþûJA’‘1ÌM~›ËÕenòùúj|}ž™Ïçús½§¥SÙ¥ôÙPÝÝ݆oºtðlë07ù¾Ó-4óåO£¤ÊçGtÕø†ûò¦#}>¥eQÿjž“š4iÒÐ|>oϲÜã'ç¡õ¥Ä¯7AŸ?äU“BŸ/Ú`~Õ\ÿÊ‹óéÈüÂåâÖ­|î|ºV󗽤ÐçƒAútÉl… ËífÛFl¶Ó»6îÃÂçÃçÃçÃçÃçÃçÃçÃçÃçÃçF¼"TRx,\ìŒÂ2<=Éñùœoë K¤ÍÁ³­tÌÉæ.þŠMª©©aج®;pÈçG +|½ÞXðù"@ÀãñpÑ缇ñC)'…>_#ð5zŸaý£™Ûç{¯<¥¿ôÒK¥*o¼ñFe ®²+upÿÉíº¸Ù$WkŽ·¾” {Ï.Ÿ?ØU“*ŸÏ»]Ó|¶È‹ó#÷vÅ'¹ôQt¤~ÿ‰²ŸËë;]_ÉÿA+Ó†­'˜EE±wvÁçÃçÃçÃçÃçÃçÃçÃçÃçÃçFV¾ý‰ßǃÁ älðù‘$ú|.çy]eé9E¢nÚz»zù¯ WloR{{{]]]ccãGç|¾Ïçã«IüY¿âD¿Ä\«Ù´ý阑4”q‘[kç|>ßN¥i þ¬o›x¶P(Ä&ƒYY¯f6²¡ljj’ŸÖn¼yµ¿•U ñ¢Ö—_âƒ`‰øüDV ß±±|:.4¸¼Ïé¾·"Þ… ˼ù ôã`EÍYÉMaÿß.hžó²´ðùìÈðh!|>|>|>|>|>|>|>|>|>|>`4`åÛ×)q¿ÃçG’èóõr¾¢±S¢nN6wÑ1϶²_7]Âü—àœÏkòÅZ}ýªM³|’Jéä̺ 7¨†ï:çó#BM¾¦V_2¬\z›9v³ÏÂl᧢.’oæòV‰byPK‰þŠõ†æÒñù‰¬šäßΨø&ø[âë†ðm ñA­3åù¥ïWJn +÷má?w‡ûœ¸¨4ªÏ‡Ï‡Ï‡Ï‡Ï‡Ï‡Ï‡Ï‡Ï‡Ï‡Ï‡Ï¤V¾ýq#ÿ†È-%|~ÒÌ*—ó‘†_eµítLy}Géæ9ó_‚s>?ÓGÜ^z½^ÃU)š(·Û-iÿÍ©À ÆZãÒ5}ë„Ï矋}Í õgã•üfíá—#),·xE¢aÎÈÈ0[ ➯Og­,%z‹F¿'âó‡¼jøí,™Ž—·Vó„ß+1Cœ6ü¹-Šæ²«%w„ÝåMOžúJ¼;8Á0÷ù4ÃùûÜèä4vÔ ùŽ¡½-™·~¿ŸÞÕÏy}þU3®»eÞø­ó®ß:÷†­so*š3±hΤms²¶ÍÎöΞâ=Ý;k†wVŽw֬♳‹gÎÝž3_[väܺ#gÁŽœ…;)fäíš±x׌%»¦ìž¾t÷ôe»§bÏ4Ïž©«ÔX½gêÚÛ¦¬»mÊúÛ¦l¸}ÊÆÛ§lº={óÙ[îÈÞzGÖ6Š;³¼wfß™µýά{³vîÍÚµ7k÷Þ¬=wM¦¸í®É·ß5ùŽ»&Ýy÷¤½wOºëîIwGc"EÉÝïQc_ÉÄ{K&ÞW2ñþ’ ?cqÏ„Ÿ«ñ‹{nú¥¿Ú_«ñ›hÜøŽßÆþXˆ…/ˆ¼/Å{c±O{nŒF‰wRÜ¥Æ^5îŒÅjÜ®Æmjì»ÕØ‹7EcÇM>ŠíjÇÂ+ĶX©±U-Ñ8°yBlRc£b±^uj¬Æ~Š5j¬¦˜UB¬TËj,W£Pe±XÚP¨±$ùj,ž¼X,ŠÆoÔøuÞ¤_åMúeÞdŠ_äMþùâÉ?‹Åý‹³îËϺ7?kŸ÷äg•,ɺ[·^ô;´Ì7.ŸF±aù´õ+¢±nÅ´µ+¦¯Y1}µ'«ÔX©†gåô+g,_9£Pe«f,휂U9KVåä¯ÊY¬FÞªœE«r®îÜÕ9 (Öäܺ&ǽ&ç–53o¦X;s¾óÔ˜»vÖœu³f¯›5K™ëf嬧˜M1cýìéfOÛ0{ªS6ÌÎÞ0;kã“7Ι¤ÆÄs&lœ{Óƹ7nœ{æþ¸>ó®Û4oüæyã6ϫƵ[æ]³%úïX5Æm¦—ëb&Eso,Š¦Š ”p¶EÎd5çDÃÛŸy¦ª1Í;‹¥ –…rŠgÎ,žÉrÑœh:Šf¤y±¤DqóŽhjrDzӂ9¹j‚¢XD±«?SåïšÎ’ËWjÊšN)‹by⚶rÏÔ•BúZË`ýIì¶hS#[HeÙEwd© Í{gˆ9Í0­‰™MLn,³í˜ÙÄ´&æ4–Íx*ÛK\ÑLeœ…,'¢½‘<iÒËEšt´Ý(y¦#ž‘Ô¤t`ËÀŒ¤IJ&%!/í—&šæ¥•ó’&5jSSüì´x@vÒ$¨_Å”>Gݟߟ¦î¥)1SQÜ¥ÆÞ‚¬;Õ¸£ ëvŠ¥Ù·-ÍÞ‹ÝjìZš½séŠK§lW£xÙo,¶©QT8•bkáÔ-jl.œº‰bùT–¸ús×rž» ÒË`!ƒ±$¶l@›Á’˜>-ZmœÊx6»eí·ÙL“ÐxN›©Ëi<­M‹¥5}f›Ël<¹EóÛ&ãüF‘™?> ô}Sþ][<@þ½8èÝÂ($™>_/ç}§[$§;Üwæën§ 2GŽú| ÓT>ú|þbFF½ÎÍ3ý@¿r_dh¤Å5+VDë{Þ ŸÏå¼™ 7<›¸Ç*¶™~æoy<I;­_µÏ.–ÞéZ*cÐÏ|[ÊìCy“èo³Ï ï¢D|þW ¿ áC‡†8¨£ø^ ý ö¿!b¡{Kï[o˜»¦Ir;øÍ¡jÍÓ[NdŸwïC‚Ù/Cn‰~àÄhÖÑ@Ó1öÎ"¶¦ 7vÅ]3ýÚ·Ñç#ˆ‡|:”åз1òbø_ O¸K1ô–ô ×L³hðx¿¦­‡ ö +7ü†AÇ·õ„Å_1ÿÍpÔ狳hª‘#&>_\bÉñQ£®RÍ$˜s>?"d`C±lx6c7,Ø–çGãóÙÇq (ÁìÙ¾ +âbø@">È«†?7¡Ùksîíé_qìâ¶_Óíü¡­«²{ŠŽ(’ÛÁËÇÿÅ÷é¾àÐu%Ùçk6ȬcoŸ?,ÛÝØÚ7ÜFtö°»ûÀç#ðù€Ï¤5\~ŸåßCåUdâwöQ.“éó»Ã}LÈпì±ü^åõ¡€³¢±óß G}>Á©Þ‚šù|6» E®ËåJš‘0±¦ß[‰8ïó¹ú3ÌÀfÍ +q Í$¥t¹Ì Òç3|>Ÿ¦žãv»%Ë$®Ï§)Mg ‡a³ôùC[5lyÎç…BÔb'ˆ7V³®ÓtÚÅ®ÞÃÁOŸ=üè÷~ðä^PrìËP¨>Þt©¡ãŠs•dŸ¸Afe ‰æ§oðúÚbàë°hÚ'ó>Uàóø|@ÀçÒ±T˜Õnñ·ÄÊ@IÕ½X,jïÃãéH2}>ÑÖ>ÙÜÅ«+»Ã}‡sðl+SÑØÉ~=|¾ ó?íP¥²²²$†ÏçKZ ñ†º1Éõض@­õûý|2¸&ßÞOÔø瑱jxwÒD«Y›ãªiãÝóŠì{rï™PÐ%¹Ü´19W‘|ŸÏaIÉDö'Íöœa°ÿ-¸Ýî$·Ð Ÿÿ¾{é ‚EÙ /8´~Ñ·1òbø™ [ÄgÃÙ÷Pú®§)hÔ—_*ŠDçâüHÒ}¾^~o»z:® >Êf,ãI6.Á(ÝÔô¥ï)i†ã[Lg(rxŒë¿B…Ú%7‚9+{’s£Ð糇;4~H|~òÿ«à„Ï|Øsßfè·ÖòÃF!)÷ùÇ›.I4ÎÉ殈ZÕ±«ƒ€få¦Üâ‚ÔÂwv|)Uš@`L<Œ18SR¹7û;ß•=¨Ur¬e̘Ëɹú|ö ‰¾ÁiØÅjÒ|>'0Tôf–^0d¾¦gRåó/võJLÎáóm# q¹\))èÖÀi&¤° ¡PHó|œÓYzÔå™ì;ÿ²ä.°p_‡ËÕœœkI¡ÏOm±âóYý›äÂçÀH" +ù|>úv™­âõzÍjÛDŸŸ™™©y´|4“rŸOøN·HdNw¸Ï¡Ïmmm­®®®«« ‡Ã˜ iÍèJæGX‰> eUUV¥xq~ò‹ºEè–*—ù.—‹MÑ`0èñxèNÝ?c[ƒÊÿ¡h—ÜÆοì]ûa2×Ô¨òùÌÒûý~ñE}ðÉ–ü Dø|ЗtúJßXC¡zCd8øüòú‰Ì©iëqès««««T:;;1ÒšQ;”g„•ècUZ‡eïÔ>köÿÙ7ûà6ª{ïëOÊ 3âþhfîTÓçÎô™¹£ççÂ-5}á5¡KH€„„n)ÜR¨!ô¦´æ¥o’JHÀ"“@J‚ LE0o /Â/ØØoLŒ¯C­ŒËŠ…õü¼':9ìJÇ+k­]IßÏ|ÇcÉ«ÝÕžõ9»Ÿýp8ì›gŸ}–-L£ {Ge6\:é”iIÿO¡¢«O¯Ì×ñ‚ÏÇãÔ² R‚Á Sÿõt]$>saXohÚ½ +ø|@Ä >¿óHZ"sZŽÏÓv™9Ìd29PÍÔmSêºNÿÂj é¬jÇžžüWÎ +µ;µ¾‹³3Dû]ŒÅ‹³¦æglÃYúw2’þå†1ÿÉ}¹ÝÊ#Wþù#Yqð)^ `JŸOôí{n8× ´ Út±'ðù€ˆ|~:+«ÏlêNÌߦS©´am€¦DSÑu]UÕH$"YÀï÷Ës0eËsSMŸbÏ t}ÒçË-¹S6?ëôE“¡³ïͽ®Ì·vÑçÓ1¡ÃeÇäÓbt0¹{/Ÿx<Λ2p{O—Š¢ð?Ñ/ŽçG£Qö4cÝ|> âŸO4÷ê¥321…–€Ê ºåbJßN%9w³´kay,ö™Ï÷^ã¾QIçÒ)ÓÑÕgæFb•ùâ.ú|>+ŠÂ\=;¢·WUÕï÷MÓœÝ:µ”üimÔq™ÏˆXç›Ì·ÏÿäËáø‘5œKJâx:l¤ÓœO)]_O·ýÓ„ôé=žO(S’3é3ÒŸÏ'F>Mö:6“FŒhcý R¾ìûÌÈ¡/û†Œ|>Þ7<þ1åÆ?ÿøpj&_¤>þWªw4Õ{„r´7q´W?Ú›<Ú36ÑóåDÏøDOj¢çhú£‰ôGéôG“鎥»§&»³“Ý_MvOgºs™®šJöð|um5v ê$“ÅÒ=“´½LHst¶¤º§g͸4_Ζ1IJ£Ï–„4GldT–¯(ÿbù¨p¾°—ÃÒŒHó?ö2,Íç³eÈFÍ–ÏÇ‚{%ÀÜ {ÛFGqü¾¸ºðˆÏo>*Q:ûOàÌ€ +`*W ÉR>pHà+ù€°¡Éï5<.éùoÚ®ûOÌíôWì»»èó™½b«ÏÏíó7^G"ëc:¨¹­šÝ©CMçfDß®à’ÖG eú|ñã‚< Þ?O=Ž-‚ Hí·K€¹aG#”„ƒ“Ö«úxºëóG&¦$V§¥?‰3æ›x<ÎÝ;s¹V‘+ÛCQ¾¼X†m¶{v·Kzþ³–O„ξ7÷v¨b_ßEŸo ÁŽ›Uq³§-Õ·ƒ§AÌÀqÏ¡3DòÀhVàó>AÏTðùót<Ýõù„Ú1*;éì4N~˜?"‘Ȭ2ß$ü øECN£L_2ÓÒŸlJ±¿Ê»ýo~gê·Ûö?ÛÙ921U™#àºÏ/HØè‡MK²÷C!gs°‰Šâs„J~ß9gø|ÏGAàóU„Éç7”uw}ÏÊûü‘‰©æ^Â\MëÁq‰ØéKfpòÀ<‡Mös“ù&)Ø›ôAMÓ¸À?Ö÷ÅaIŸÓö‘…k>g¿ÓèP™ƒà¢ÏgV21µëãAIŸ¿~ÃÃMÿü€ýÎëùç}>kõëjší‰©xžµ‚SCv0dS**ùeùqö‚Ïÿ÷+ÎùÞƒ×Ô@δæ¯39ËFþCÈ÷çjÊÙùü€òЉ4äseãÕ?4ò£!–ùÉÆйWQÎÛ¸ê|–¦U4­º°iÕEMW-Ü4“E›®ºxÓJŠòðL.yxåâGV^úÈÊ¥F.Û¼âòÍ+–ÍäÊ囯\±ùÊ•[®¼jËòУ˯~tù5.ûÙcË~þز뚗]ß¼ìÍWÜÐ|ÅÍWü*ry8rù-_¶æñËnÛºô×Û–®Û¶ôömKŸXrÇKî~òÒ?<¹øÏ-‹ïyê’û¶_¢nWØ®<´CiÚñÓGž¹øÑg.Žì\´mç–gnßµpçs=½pOô‚Öèßs~ÛÞóc{Ïko=÷­ÖŸ¼S[êß6Oÿì5v ê+ÏÙ+dO>»ó‰Zò\>»fòö³Bv²œ{"Ïäót>;òÙ~î[¦åé{n¨üü,}>;VŠ¢ˆoÒU BûFW8¼±ÔÒ%vAØ,¢2—Oš¦ÑOŒXž’&K:èóÿÏ/6¼ôk/çœòò×nó#!?¶ä'/ϹFÎrþ+ÇsÁ+·]øÊZ–‹(mk¶­]4“[)·ÝúÓ¶[#—´­YüêšK,yuÍÒ¬¹ìk.ÿÇš+bk–ÅnY»åÊØ-+b7¯ŒÝ|Õk7¯zíæ«_[};Õÿ¹oõµ¯Ïäº×Ã׿¾¡ò«ßøÕ¯Þ¸iõ7ÝüæMkÞ¼éÖ7o¼í­×½õËÛßþåoß¹¡ñîz熻ÿyÃÿù‹{öÿ×½ïþ×}ï^¯¾{ýƒï]¿ñýëþàç›?¸ö±øµxíþì©Žÿ|ºóšg»®ÙÝ}ÍóÝW¿ðQ襞U¯ö®Ú×{Õ¯|§Å{ý+>üäÊîO—|`ÙeƒÚ埼ì‹Áˇ–ŽZ2ùù¥_ /Î _RSß1_ÿó5v ê$Ÿ2rh&Ó,Ÿ-žÉ ‘ƒB´|Œò©‘OŒô³\:“>#éÒ“ÏG—~EéÒe¤ÓH‡Ä|0“,ËûFÞËç]!ûüsÉLÞ9‘©·¼eäM!oi7òº}Kgòš‘Ø×ó#¯iòŠ‘—¼4“c/]6“¿yÑÈ Bþ–O«‘ç…ì½,CÙcd·¨‘çŒìò¬‘3™¤<#äi#;.ŸÉv!Oi1ò¤'Œl3²UÌ“‰i>‘ôcF5²EÈf#y˜eÙñl2Ò´l‚²QÈCFþjäA!¹ßˆ:“£<ŒÜgä/È\òZø"ø|€SÐ-!ÝBì—‹>dbJ¬Õ¤wZú“½CËì?<Á~oîÕÑvP>4h²Q sªŠ¢Ì*ói=º®›>HC ÈlµÔoóùVƒ½’Þþw{?nkû½øÀ·2¸èó骆m—öA|“·Î¬‡zΰ§´Î +\8™¦XJÉχχχÏGàóáóáóáóáóÕ Ä~™¸èó µc”›¶¡½äº¾`è¯}É ™ÌdËÜz6›M¥R8 ª4e-5åáÇє•$‰PÿOÃe1EÌ«Äå2ßô,ÀÔ”ÔcóÞ»óHº¹S“ôöϼ¬5}p€ËÿŠ +}>këózǤô­‡º|èJ)°g:áp¸±8âã†9ŸŸŸŸÀçÃçÃçÃçÃçGÓ4º e7¤ûöq×ç·gƦ©;‘ûzž5-ýÉtvZ4Ben}`` Ë Nç@5ƒ¦DS‚y‚VŸ "‘ˆ¼)©Ç>1Ùê_ŸHºzÊkí‡øï}ÉLž¬»>¿º®«ªª( + Óô‹ƒ•ù­ÓW +tÍààqžó…|>|>|>|>ŸŸŸŸŸ¨%âñ8ľ}ÜõùÖzû¦î„Dò¤³ÓͽºSE›}}}L7¡¸ÚASÖ ===hJï`§2¿ Ì·6å®c¬ën~/þn׋’~þ/Ïõ· ¥ØïjÇh%¿¯7}þ¼ŸŸŸŸŸÀçÃçÃç#ðùï ûlF¹ã3Ö«w}>ÁÎþÃ9¡b¿`ú’™öá£bI9Œ á4¨vД5C"‘ ¦Æ¡p›2Ÿ³Ó”jÇ(ëºÛ_^ÛôÏ$ýü‡ï÷:øܶ$êÐçG"‘ÆR Cäàq†Ï‡Ï‡Ï‡ÏGàóáóáóáóáó  r±_çVßuŸ¢h³WÏ}½bßšÖƒãƒãÇøË‘‰)œÞà8eÊ|b¿}×;$|ã¾Ïµ¾Qñn%¿uú|W€Ï‡Ï‡Ï‡ÏGàóáóáóáóáóÀ&ž#ÅfÕ‹ë>¿óHš«›d&›ÎNKT«É7•ôp +]×mÊü`0hs|^Uã¾Ñ…kR’N~ÏîvêØùK*ùÝ=âói7f-›¯êKø|ø|ø|ø|>>>>>ìFM¦>ß]Ÿ/ +üÁñcôNKRb{F&¦xI?Óû¬P÷N{8¶ÿ]׃Á M™O Û\í»½¬Ó^rçxã¾QI¯uõóbþÖƒã>b®û|j2¿ßoçøÓ’Õ{fÂçÃçÃçÃç#ðùðùðùðùðù0+Lã¼M†Ïw×ççŸÌdé¥Xœi ýU,陘Âé "4ä‰3Ñlsöe> ¦š¦•°C;ý¿¹ûÁ³–ž¾hRÒ½?ÔúÁ´ñŒ`püuõ.ÎϹíómN‹€ÏÏÁçÃçÃçÃç#ðùðùðùðùðù€ÚE¢ñ@8ŽÇãu~ˆ¼àóÓÙéÁñcLæ#SáÓÒŸ¤eÔŽãžíÃGqž#‰Pgnïì¸w ÅGr™_ÚÐy ’kñN[çó^r縤{_ÿä»GÏEŸO '^ŸÐ¥K£§JèB¨¡h?<Îðùðùðùðù|>|>|>|>|>0 ñíãŸo¥©;!q>´@ÛPŠý>8~ ‘HÄ*äƒÁ ñKŸ-8bÚ”ù4àÒRt`}!¹î ŸoóI§LK:vÊ© ¾*]Í:‰‹>ŸÏŒP+{¬O*0/>>>>χχχχÏ4þð¦Ïo=(«áìKfh™Áñc#ShA@CݸÕäÓ;6K©iÜ´érƒÁ ®ë¦ÓØ*DFb¹_ð[«}¾O_4)éØoÚ®û|ô]&]<’.ú|¶Q:˜Þ®}ŸOgêóáóáóáóKn>>>>>Š_ÞôùGÒíÓ6”BÃ@îë +Z4ùVñnEÓ4^>7™Oã/_@Q”ÛاÄnÿ_>ßzŸ¯ûÚ-IIÇ~Öò ŸvÉ+³Â›fµ3™ÂYè)&EUUv}åHe¾é8ÃçÃçÃçÃç#ðùðùðùðùðù€º‚nBÃá°µ(¿$¼éóÓÙi‰öiêN á ÷u í—OÓ >·/óiåk _ +¹ûåŒÏ·þÔG%½:å¤S¦ƒßz'—Ñ=r0+¼iö`%zð£¦g»§–nÎåÇ>>>>χχχχÏÔš¦Aã;ˆ7}>ÑÜ«KÌO2“-‰D¢§§g`` ›Ízê»4e=7eWWš²$TU¥ž¼¤ÒnÞóÛF«Ì§wÄØú5åÏ·Åù[ÏZ>!éÒWnóùr‘ëB¹‘˜‹GÒEŸOXtŽƒ ++vX4'fPØñù´!É)í Ïÿ÷+ÎùÞƒ×Ô@δæ¯39ËFþCÈ÷çjÊÙùü€òЉ4äseãÕ?4ò£!–ùÉÆйWQÎÛ¸ê|–¦U4­º°iÕEMW-Ü4“E›®ºxÓJŠòðL.yxåâGV^úÈÊ¥F.Û¼âòÍ+–ÍäÊ囯\±ùÊ•[®¼jËòУ˯~tù5.ûÙcË~þز뚗]ß¼ìÍWÜÐ|ÅÍWü*ry8rù-_¶æñËnÛºô×Û–®Û¶ôömKŸXrÇKî~òÒ?<¹øÏ-‹ïyê’û¶_¢nWØ®<´CiÚñÓGž¹øÑg.Žì\´mç–gnßµpçs=½pOô‚Öèßs~ÛÞóc{Ïko=÷­ÖŸ¼S[êß6O]G¨úÊóFö +Ù“Ïî|¢–<—Ï®™¼ý¬,çžÈ3ù<ÏŽ|¶Ÿû–)Oia9o&OyBȶãy“gk>çɧù|s3ò¨-ùl¶ä‘|6²IH“‘…ò‘¿žÈyÀ’û…¨F6äsŸ%¹àDÖ¹WÈ=Fþ|<í<ÊçBþ`ä÷–Ü=“×Yî2r§;X.<žF!¿3ò[!·ù%ëX.šÉùõEûXn³d­[¬rËL^s³‘Õù„‘Ò²yE|> |¬ß‘ãé5Ÿß>,+æì<’.===]©T +gBUƒ¦DS›Äb±‚Ä‹ +…¬+áÛ’eXSþô§O>ÿ͵­ I—~ú¢Iÿɺþx nëósùý‚Ó 8X¢/ñùš¦ÑgŽÐKëã$}>‚ ¨÷ÏS¿c‹ R{Áý`n˜|¾¢(åáH±Y O¯ùüÁñcù³ëÀ˜›dæ0“Éà?«ªASÖ ÔŽ===hÊX,fÕ˜å@k ‡Ã¾R å ®G”ùÅÆÖ” <äó­?uA»¤?oÜ7êóåBgGro‡\?æ.ú|:°t0y•‚üÒ¥¤éŽÀöÍ‘KºîbßÂ:­ƒþD_ŸÞ× Ø´ëFáó>AÏTÖúü2©üM±7§×|>¡vŒó?ô'G6‘J¥  k4emÍfë¹)u]F£¼>™~:¥ôK-˧M[]+ƒv/ ‹í!kÊo|Åç[ú¢$>Éã>_.ºZÉÄÜ=þîúü\)W8´d…÷?¸T0QŠ¢ÐvM¥ðùŸ ‚Àçªøüy:žôù»ŒIÐàø1ü;jMÓTUeõÏŽP´rfDí ãñxÁµE";2_$´tÓÊ Ý’Îü» ™ÀiZn·ûwîú|qÖƒ×|>o÷P¨Òs(ØUŠé>AàóAø|@A7• ŽRÌZÔ ^öùGÒÔ6”¿ zÑu=KÊæm +sÉú©‡g¥þöQE²QîuíÎÈèÓÖ5î+:ÙŠþäóåÂ竹^ÕõqÑ竪*¶;R*VŠ@gd›µ1Сp¼>¨^¼ì󓙬Äç7÷êh>@õR° ŸëÜ2Ÿ5ÏÁäª 5JËØÙ½‘‰©]Æz¥û» »%=ùÊ c'2ý‡è‡ô{ûðQw[ÄEŸÏŠó©É¢Ñ¨NÂbgfå…Ž‰u»ðùê¯ùüd&ÛÔP;Fû’zÙÜ«KDP:;T)&ß®(Šªª¦:ä9‰D$5ÿÅ q¶ä{×±|þç’nüêköÞ|ÛÓü¥»-â¢Ïg¥¹ÂÛµïóËœ-27Ø%Šõ|>€ºÅk>¿}ø¨X~ß6”’ˆ Î#iþÁd&KAƒª…H$Bo(rª${n&Ÿ=Jp\Õª£’Þ›'Ñôo-oìöȬ+×}¾³Tì0«Ïƒž¢%A¥ ­[ÿŸ nñšÏïKf¸çIf²âKkZŽ›>Ūú ~Ðuzò¹™|¿ß?ªvdbÊŽÌß²7–|æßøËý‡'Ü=’.ú|æÕ]ÑæÞ$ÓÉYlR|>‹ÅÂápƒ¢(š¦9¾¯ùütvÚT~/qAjÇ(ûTK’½³ëÀÎ@@ƒB(òûý¾9ACŒãeùŒý‡'ìøü—žòÝö?ñ—Ôÿ»{<]ôù‘HÄ;±ëÈe~>PÓPHãÑ< Ð`Î4Ðý{Á¿Òõ+Õ³Bï;kõ½æós9O?%:hdb*÷uw”Ìdq‚j›h4ª(Šo®X,æünˆäzÕ\F—÷ÛdbJ4<âKkZú“ìS¦ª~; t¤Óiœ“U šMYÛP‡¯ªªX³77Eqv†× 2zn§Ÿùü‘¿/´Sœÿôs¯· ¥ØïjǨŽ³‹>¿Ø¤¼bØ1ðö·kgmlI:…\9¦=„ÏÔl––”èx„b +=‰ð‹7Õr‹‹Å¸ÕwêžÚƒ>ŸhêN0ÉÓ6”_L:;³TõÛ¡¯¯™CW;hÊš¡§§§š’n½©kUËÖŒñxÜô0wÎPo§¢;Ò’4¾”lxq~‹ïÝ®íøü×^ý˜—ñ·÷BÃÁçϺ¤G.àóµG±À© Y LŠ)tEQŠÉ|†®ëÜí8R­áMŸßzpœIž¦î„ø²`ú’Z&™ÉšÞ™•±±±¡¡!œÕš²fH$Ô”ÃÃÃÕûâñ8/¤Ÿ›Ò§;÷p8\~5>ƒ† ›*€6:G]lçGWÿoÿÉwN[wß«‡ìøü—^îá¿LLy¡í\ôù‘H¤±œÒ;6}>?2ðù0Oˆ£°È|M¬%Rì¾Øï÷Óû@@òÙh4ê`µ†7}~_2Ã=O2“_Zà ;MUýPaâñ8ëÆKõùº®G"‘P($~¼Lh(¡uÚÙº¦i¦Y4ДðµßçZ|ÓÖù|ë)û>ŸUæ¯ß½÷sñ¹­pÑçW:+ò𫎆âˆç†ê yŸ¨=h,¶^85#”O1…ÎއÒÏêº>—úÉ"xÓ秳Ó\ûtI‹/­á.¨m(å5;¨"‘ˆx'Nꬳ¨èæ]UUV#í ´B›&?g<#w›~·ÿÙRZ®Å¹î &ómúügZ»G&¦ÔŽQÖÉ{¤ëÄç‹_³$èÜpdb`ùÀçjêŸÅÙy¡PÈ#½.ÈÍæógõ5ïó‰]Ƙö™˜¢—-ýI‰Jf²9KU?N3@ňD"¢ù¤{ðY—ïÙ‚¶[ÒÔ­p8,~< ÆãñÒ¾y[ƒXœOùæw[¹¡{mkBÒi¿Öþ…±N|~.?°$EÑ4Í#ûŸ¨ah ¦ñ&ÀkSèlV;êóƒãǸ–o>*QCûO°Åø;ôYœf€Ê`’ùòΙnÒYWï ~¿? +•¤[­»1—:ÀCÑ\‹O]ù}.óóy±qßh±›þt$®y®=ãói7è2€ÏÚô»ªªº&‹ø9À£äG<ó|>€ +SL¡³RIºy—|–‹£h4ZþžxÙç‹ŒLLI|~s¯ÎcÚŸ^¦³Ó8ÍÀTâN]t±%u]…BΚü`0H[,Õôjšfz Ùm»ú–oøO¾Ëäó¿}F\Òc¯Ü0VÊ‚ÊáºÏ§vä¿àSÕiwÍ6çHy@%Ï€*BÓ´˜£¸2™‘ß›‡ÃaºæõoôíèMúS±{vÚÛ@ À>^R)f1ªÅçjǨDñJ~¨¼ UæS¯ÎºwG €†9¢¸ƒs/Ànñ…ξÜRœ¿~ášÏ%Ýõé‹&ÝxK;,•ß:ïvÎP(äàFÙD€9>Íqø|¨"Lò¤|bn” J ¿·–ßÓ;Á`ÐYý^E>¿õà¸Dµ ¥ðߨ0¼šZRâN£ ïºË„¶ +…ʶt]W…Fœ2 ³ãÛ~a•ù>ß曶ë’îúœ ¿òfkºëóÅs‰ÚE|ÈB;&Îì¨:ýî8ðùPEԆϧoA÷æüæ½ &ÍbZxîå”EŽ§÷}~_2#DMÝ üw*L4õ듳 Ö‡¼®ÓаÃêóO]Ð*é«oÚ®—÷ aqÑçG"¶]EQŠM¤sŒ=ñ§ŸuþŸ¨a¨·wk +9À_„®Öhè^ž¾ÝÈso/ñùÖæU‘Ï'ÔŽQ‰&™˜Â?À#°ør†§`0‡zzë8±Øg…Šóן¾è=IG½pMÊíQWò\óù¬ü>ÈßÃùx¸C+o”Bg£G¦ÀçjêÛi à#õº°ú¨yølt¿ßO×?tgªiÿ+ýN×Hô>+oóøŒuºxw>—÷ùôÓÙÕåóÛ†RMD-im‰D¢§§g`` ›ÍâߧªAS¢)½F<ƒsÓøÔ«ªj<ˆ¦% úü•I:êoŸq̳ßÈEŸÏŽËöˆ.fÜ:] ðK#9Þ˜\Ÿ¨=èÊÁÚë:ÛÛx ºÚá&D^É@åæßËJß]ãÍG…Fuùü‘‰)‰&jêN”´¶žžž.ƒT*åýïДhÊj!Ú´£Zž&ú`uUâÅbŸ56¾Xp¯èó÷HER/×|¾ý ƒlÔvpÈæWDv@}>ÌÅzc”è VÑ4]ðƒA›×<ü’Éû5óJuù|¢©;!Qú#SöW588ÈÌa&“Á?QUƒ¦¬¨{zzª·)y§jßä;åHiøSU•:óJ–óÅZ_eþ7¿ó˜¤‹^¹aÌËòµ}>{lÓ@€ÖL;Àæ•Ð‰ËÃfÐOï8%ø|@íÁæb[qvj6€wàþ$ÚüÝ–²„B!º*òùmC)‰,¢¿–´¶T*\ )kƒl6[½MIÃJ±›ñb„ÃaG©¦i4–‰“*vûÿƒÿ÷gÑ矵üo’.úôE“ñ¸w[ÐEŸÏÎ;b˜owê‘ Ûn àç!{Çtþ°K…J>'’Ÿ¨=ødsu^{€†+”9|Šnc]Üsºe…B´\ªÏZ¨É ¼#;Pu>dbJ"‹šºøwT]×™hµ u¹q'Ôv4-ø!^on*Χ¬Ü𾤋>ó’ÉÁñcžmD}>‹ý~¿ÜÛðrzûÕ rØ3 UPâ¬ßú<ˆ]¨Ä½ñ<>P{Pÿ/>—gPŸŒ#€Z¥Ÿ_ùÛvN±2Œ`0(¹e®sŸO4u'$¾¨/‰"m@E¡›?–º[Ÿõ¹­-ÒRp£Ô™W¾8ÿ¤S8}Q”"éœç<‘ªb¸èó5Mã§G±æSU•-#–Ó—‰u6»* Ÿ¦%Ù‹GJôáó5 õÆâÈ +…œêí<7ó%UŽñw÷¹˜ð)výV‡>?™É6u'ÔŽQæêÛ†RSÔzpÿ€òá–^®ßi1kA]1‚Á`ù÷æÑh´à¨A7þòêng‰<ôKKÒ›-î¢ÏÏ Ã1+ÈTU5–‡þ$§Šós…|>›`½$`»ç‘Kø|@ C×Ô-Ãä æáwÁ¡PÈæGøm{0¬ü³ûe.Òé%íÝ¡Óþ‹ïË¿¬³‡ÎË>¿}ø(³@ͽ:½™˜’˜"µc”0™ÉRð(S/]l±’d¾ýJŽ8R°jmêÉç÷Æ?¥ÍD@×'ýþ¹Ï_ÛªÙ÷ùÔ¥{³ÑÝõùÖ–-Hù“;DXi¸N:‘ +H°%áó8Ýu–t«+ë¤ò + ‹ím,ãû¦ºK­CŸßy$ÍEóóͽºD±2~ú)¾›˜´j±a"Ú—ùjX¶]Vï`©vQDr-¾™:±­;nmá2ÿÔ›ìË|ÊÈÄ”7ÛÝuŸÏW,Å7=¸q¼¹Ãá°õIS÷t‚±º}]×ù¥-ï…–‚Ï€€Ý~òHMÓ +.ÆnK¹¡_\™Ì(WètÃ.Ù½:ôùéì4AGÒôÎþÃYÔzpŸhéO2´ëÀ½Lf²³ú"kU?HˆÇãâ0á÷û‹•CÛ—ùÔµÚyj¬išjàÊ#æ¢dôÜ Áã2Ÿ2co7œõ°èóWnxß¾ÏgÏ[½‰w|~%¡Ë :ñL¢¾àîà“2Ï€Ú@×uEQ¼_0Éäi}>‰À´ŸõéóyA>¯ílîÕ%ʨ/™±Võ@1¨Cæ½.Šüyë¬XÈš MÐÚh[ö?RQÞçZ|ñ?.PÎ….¸M×'é½è“/‹2Ÿb_æ{¼7vÑç³R|:j ºå¤›b¹É…B.Ö@Úñù9¡:ÎdÚëÓçLL‰®>'~I (wþ¬ªßD6›M¥Rø¯©vДhÊ2‰F£¦é]ÅÆ>‘ùš¦ªEñJcˆäZ|ú–oN[Ǽ½ª¾§ë“÷Š2ÿ» O—äóÓÙiÏž~.úüªˆ½|> &¡kºx`RéR¤Ø$A€Z….‡"‘H8nhll¤ë"M>ß7vç>k%]ȱ%Å˹úôùDSw‚é ¶¡×—Ìd%ÊHíMg§Eço]áÀÀ@—A:êýêM‰¦,Q­óð4vÈ‹¨Å#­‡w¼V™ïÖÄ13‰x®ÅGQÎqu‰tݱîSqþÂ5ûìËüæ^Ý˧Ÿ‹>ŸÍ.ôûýè쟨=ÄÙÙv.'@… ìÎ]þp»Z’KžºõùmC)f„šºì^~_0GÒ¢ógUý"}}}Ì¢®»ÚASÖ ===®4%ï ‹Ý8S_Í°ÎJ$)¶!êÕYÿoš2æ…gÍ'HÄs;ý¹_äº3¸·ohØ¡õ šd>em«fßç·õòéç¢Ï§!žm—NEwý 4x¹¥àóµG8.8¯GÀ#pw éöY²$¿´ãJ¿n}~_2Ã¥P2“¥wÄò{kZŽç„ª~öRdlll```hh'dµƒ¦¬‰5åððpå7M¬¦iÅþd-™›ƒÌ'Lë¡ÞCŸ‘Ñs»¹_ü ü'ߍ½ßÿ ¦%• #&™ê‚Möe>edbÊ˧Ÿ‹>Ÿ 3‡tV;ç 6gÄtršˆF£Þ)…ÏÔÅæÊojvãI7§Š¢4pÁB¿ðBww÷P¼qƒ¡P¨`9œ©(4dPŸ>ŸàRhÿá z)–ß[£vŒæ„ª~öJ¾̧Åh葯¯Šº\/ FèUs->}Ë7§­ãÞ>ý$Öúºµ8ÿÛgeáš}×né—ôÃk[ M¯ŠævÑç+Ë,FÁ€9@\æ³Çü ÜC”èÃçjq ‹¾pdPÛHª(M>Ÿ¹× +{ú î³dIú +¦oçÈ>T—Ï'Çq™Oì?P“ð>™Pœ€ÚF×uQwÓpÃï|M~F¼uÚ º~›õöœ¾c$¡¯ÀÊõÙtÕù|ÉLVâ‘š{uZ¦óHš~oêNÐÂøOÌ +u¶öý*uÈ´|Í|wU}‹ú`p«®OF6·Kd>åÇ×i’~ø–û&«å»»èóãñx¬œšcÈÎsÓåGÁ#À®¿T /N6lÒŠ}mŸ¨U¨{gw…ÑhG5õbá=¿7ïUéMnþ@·j÷ù9¡ü¾`àð%Çih°)ó©ç¬%™Ÿ›Þd–ÞïPÓ’Zß ÿ令>óµ[’’Nxõº¯ªå»»èóÝ‚]™Dze|¾¦iÖ§f6? ŸÕÝr™/Þ–ôù¹¯ósù_«Ð—eeawÓ+V¬X´h‘d%Ùlvtt4•JÉ·E Ðb´p%Wõü'£•Ôy$íÊ^aUXVå‘UE£Ñ‚unWE#‚8ÕKN(ª½Ã·Rè—\F§_äÅù>ß‹’xmkÂ4ÆzùXµµµÕ›Ï/øe ¾‡ôùtÙÆÿÑèZm0´¿ò2}þ³;wÒ§ayçíw橇Á±E©½ÔÉE2 2¨ªZÐÛóù9CÚ°?)ŠRÛÇZÿf¥«««££C²’.ƒt:]l™T*Å–¬äª^éøDb“žüè°+{…UaUX•VÅ$¤ÕO\Ÿ¯dZsÍö;Ö½0›Ì_ÿ|@Ò/¹s\Óæå ҟ쬊þjU[·n­7ŸÏ®ìÔçƒAñ´/>§’®Áø ûS]ÊôùâÇy@½žz[AÚK\$*ݲCÓ=©ÄççòÓÌï‘ìÔšvuu HVÒÓÓÃt‡¤Êqtt”-SùUýåƒ/$BÉ­½Âª°*¬ÊÅU½õÖ[gžy¦ØÑIV¥ë:Œv'v% ;{Õ××7ëôÔªb/uÎ*óC¡/½í¨¤û½ôÆ´g¿ uUÍÍÍõæóÙ/>Ó„a=üjÊ‘)ôïÆ+óí;|ø|ÏGAàóÕ/A7½/÷ùÅ>åeâñxC›¡»ï†â:ÍÍÍkÖ¬‘¬$‘H I–Éf³ƒƒƒ´˜D›ÌÓªv“¥}½]Ù+¬ +«ÂªÜZÕž={N9åîfý~¿ÉCŠ«ÒuÕÛVF­«¢-.X°@RÀìñÃNË‹ïëúd`Á½r™ nU”îk·$%Ýïêu_Ü«±±±9ìÕ|¯jïÞ½®û|:QEaC³„‚W5s@Ó4¶BU°â¦#@ÿŸ}³’¢¼÷ýþ­JÝηêƪS™:§NYÇœh+˜_`xµ£øÆ‹´ ¢Øˆb≎c£¶r_0Û®q±MÜ@<‡ã\B¼$\“,îÞÅ°Í!ìÉ:=›v˜0÷7ýì>ôÎKOÏìÌÎtÏ÷S¿¢všž~yúy~Ïô§ÍŽ§lýžÿmVö ’ðù|>@ àó~§q|>?£J6µ Ûš÷uÈþφ\„RÛá¼ßŠÅbÝÝÝ.žø\J\J'ªª:Íg(ÊzuË w•^E1ï¦h¡óM¨\é:­hq¾®ÚÔô‘Kî]Ó{î¹>ÊŠÏ°%QRW¬”ÏO”賟š¦qÃωvÄûv¥vÊx”½Á +úü '|ù¢_ F|yÆå—L¿ü²é—_>íò¯M›ø©¯š2aÒ” áð„©á˦O¾lÆäË®™té¬I—^7éÒ믾töÕâ W‹7^%Þt•(]%~ó*ñæ«.¹ùÊKn‰9vÜÊãŠKn·ÇÅUˆÌöoµ€ Û7íã¼ÉŽ탟}uæDèt®µÏ‹Înæ¤Ké4§Ä´ðetîS™F˜l·ÆÕS&P³\9eÂS3MDñõ©©¹¾:m"µÅÄé—O°›±h\ê9Doq‰·¸Ø[|Å[üëôË7¼ùZ•ÒšÿÇTV\^øW/1Ý-¾Rz\ì9¼ôÉ¢}»èqh +ÇDgL;——™±Ÿ_ã1u8¾žßÈWŒŽ+1…"“²âêÑ1itLæÎDxtL9”è2éÎÓx8²bnÌpÄÌáÈäÒk1Ë×:â:v6æ1{8D6Ñ°¸‘ÇH&¿id’F¦!7çLI·äLOÎjôÄtq=Ÿ+³çPgÜz…c¶uœàœ-iœ‘¶â ˜™GæG{Š¯Ï™%3¥}­³fIê]|Šdó#u{63ÒøºøÊKàóUB–evoH÷¡Îåî>Ÿ×›ùèLáóó2”:ëâ”6ˆåýVGGG»{ý*¨p)q)9|:àÀ.ź®;=¼;…6•%ó Õç×û#é]R:fúíµÝEe¾ª~LñßvɽsÖ|ðA—Fe }>u-ï]±²>?wÔä…Ö©ÔîêÊç_zÿìðß +FÌØñè7ùÈ‚_¬^¦¯ZýŽòøÛ+ŸÞ|¿Úºâ•Ÿ,×Z–ýT[º­ùÞ÷__òÁ¦{>|uñîWýöå»?Þx÷7È^ZØùï ®¿ëÐú»¿¸àÈ‹ó½0ÿ¸:ÿ„:¿WÿWu^ßóó>{~žõÅÜøssûŸ›û·g‡c w&ì8Y¹ ÍÒ¾h¿t~aþ‘t¯_@GHÇIG»oƒüûòï^¾ûÿ¼²èׯ,Š¾ºhçk‹µéž_¾¾äç?^ònó’·›ïݬ-}ëeo´,ûñ›Ë^ýÉò oÝ·þ­û¨5žÝ¼â›ïjËkö5Ñco¯|tëƒÔ\Ê6åþwW-×W-yï¡Eï=´ðç«yÜÅâ«dâaŠù£cžsߎ;sâ;n‰ÛFÇ­#1§â‘[râf;¾IñËLH£bÍM#q#Åö57äÄ쑸>^7:®Ýþè[ÿ³J™mÊxuþ)Œ_‹©Ùñ(ibº{ìÈÄŒÑ1st\S(¶?:Ë×:âº|q}&ØE?ײ»ë6vðŽ4ªƒ±Ž7Ò oÎêœï?2‡ú­£;;6ëí¬ó;‡ÃÜ_d‚ç8ZðóÕ F†›sÊï­¾ÛŽEöØd±ø½‡î±cÉHÜ«¯¢Xª¯Z64œ—¿»ê>;VŒÄýÛV=°mÕÊ‘xp›BAÃÕH<ôŽ²:>lÇ#ï<¸fk&µã[[W~ëí•ß¶SÅ¿Ùñ·W>nÇo¯Œü,Of"“dÖmyà»#ñÔæ¾·ùþ§íøþæû)ýÐŽg6¯xæ§+~ôÓÏÚñ\ëŠç[W¨v¼ÐºâÅ·V¬ÏÄ}ÿþÖ}/½uß;6¾ußË?YþŠ¯¾¹üµ7—ozsÅë-Ëší œOٯŎ7[–ýäeo½A)qi«¶t³[´¥?k¾÷m;¶6ß»-™ä©ÿxÉ{?Î$Ò_¼¾ä};Ú^_²}Å=;6ÝCi–fÿØ´ø?_[LY÷¿^[L³ eàÿýê¢]v6¦øÍ+‹>²c=ËP¢Þ»ñîÿ›‰LÞþÃÙØ Ó¼³oÃÂý¶¿”I韼´°ãß3ÓÐÿ³g"Š?Ùó¥}óÅ4+õÐÄôÂü£/d¦š›øôôßê|š&(bö •™žì‰©²óQI‘pÄÀpd&Ê¿9‚²ßžL)¬áÈœÂgö¹PüõùyÿmŸ`¯}¦ì”ÿl·µCÝ&Ô8ÔDŸÚÍEM×a·$5é7,¤F¦§–ßc_>KÒµ£ëH×”.ñ;Í÷nÉÌ’K©Ÿ¼þæ2êH/ÙS$õCêŸÔ©WS·§A£†Æ—ôÜ]ðù€*¡iZÞ{CŸÏ+Ðüå±é°##TdƒÁðùDs§å¢•N žÉýJOO3‡ÉdƒÈ×àR†îînºŽå]Ê,-éž'ùÄá…B–>ë‰@gUHZéátkS&ÞËÿkÜøÍïŠÊüpxK:£ O-^û.‰÷†e+ûRÖ„ú|>Sw¢¿³ŠÆêÉ…Þ CRKwæ…;’þà?i¨ñ½o>>>>>>>>>>àwxaýk_îâóùí$Ý]6rÓÆçï>~ÒE+ííÌû­D" p)ƒA*•*ûR:ý<ÍîzÐKA2ßT¡i"ë‰@½Ëü˜‘qøLæSlsW1Œ^AXï.óiË:•YûD´õ7ï¹$^å™ÄßOù¨ûÕÐçó¿a*m–fù¢/P ЯI’Â6´¾®ë.o¸” +ÿé5Æ7àóáóáóáóáóáóáóáóáóáóÀYÛÆ5N^Ÿoš&¿£¤;h´[0|þ‰Á3.Z©¹Ó Øp»î.Ei +EÑ»Ì/´©,™_Ô”Ö˜C7ùÖ¦óoº4£÷GcY§Ä~²hq~4z„òmÏÀéôþˆKÖõcϯö#!UUiûÔó³–S÷¦³·×h˜Ð þ"ý¡¤â +ø|ø|ø|ø|ø|ø|ø|ø|ø|ø|@0pÖ}I’¤Úð{d^uæ40%½ßH|íó·êÿþþÚz0Î>n<sÑJC©³#Êù”Ó\䤮ëìe./ˆ¢X¨29«¼¿ÞßóÚ#s™¯-È´|$òѨu’–(¶•ùŠòaW<É]}QŸOá£þSCŸÏºeI5ê%Áæú܉žýpªÞ~]f,û…χχχχχχχχχÏ˲²t½{Õe:…èhª½G_û|âIúØvxÀÅ)íÿlˆ}k(u¶gàt<™Â q ìª(J“gdY.$ó ÃðÌOZéí"—ùʬ¹™‡·8W”çþ´¨ÌÅ–ôȃTú|°_/Õ{˃•7侓ŸŸŸŸŸŸŸŸŸŸŸ¨9š¦ñW¹ A7°†aÔÉÓ‘°7Ð]=°× \ŠNËÆ×>Ÿä· ¼j4o°uø·Ô}}¨Ø A 4+Š¢w™ï®U)óä\×/yÅŒôV™|kÓyáYæ”óšÖÎW|ò‘Ö¢2_ÖF/­LÉÓ»Ïßy,á£~RCŸÏvM¿^ +=EûજËáóáóáóáóáóáóáóáóáóáóáóu‚®ëtÓš%pè¾UQ”ú1ù¦iºhüB%£•µú¾öù;%˜2R÷õ¥íÂ{­ÄÖI;ªúyÅ> Àhš&‚÷4ë¥Þ>Rò¬Æ3ÖJ²Kb2ßxú‚Ðÿ|ÌiæuýSGû´•ùì+îMsƒ½<åjèó öþH–o¯ ü÷ ÚKĆÕ?ÐE¼Q‘XðùðùðùðùðùðùðùðùðùðùàG Ã(I19Ëõ+øHÂ×>ÿÄà™,k´íP¿‹Yê8Më4wZYû€ ÂiM²kíÙI·6iK' +ç¯ãZ^[X™=Ãøð/2ŸóSÚ,Éçûë5¨qðù–eE Ô»(Šš¦E])ãYRÙ¿:œT¤’>>>>>>>>>>|݉;o«%Ibeo¹*‰Ö¤åªªÒ:ÕN¾öùÄÆ1§œßÛ;èb–vKÐ:»ŸÌªØ˲JzJÅ@É|›ï|©å%I·¬Sü?pªþB!Ë;øW(mz—ùÍ–¿šk|¾sãïÕé…,Ëðùðùðùðùðùðùðùðùðùðùðù€šcFØFÓ4_¡5ÙWj"pø µ$IÞ«ì,ËâV¿RúÝï>籄SÎÇ“©¢rÉYÕÏ*öƒ{(òn))µR‚ X#(ʇN-‰|äü_Mk÷"ó%Iç_éŠ'K*ÎgP}Dà}>ƒ½#±aÄ~D¼A_{#ÀçÃçÃçÃçÃçÃçÃçÃçÃçÃç¿Aö~o8öÛɱÀŠóEQ,㻼â´"O"üîór¾+ž¤%Í–‹_Š'SiG‰éûŸö%>3N —T*ÕׇKðKÉ^VòòTÓ4ç PEQK÷¾ ÞÂœ¼ ¬×õOG7Q{Q“O!Š-¬žß0zé¶Ã%ùüß™'ü5*ÇÁçóòƒ1â½z¡X' ÿ!ø|ø|ø|ø|ø|ø|ø|ø|ø|ø|(Ãçó +ùñ÷ùt;Ïv]Þý8ÿzE”ß}>±ñ@Œ¹£¶ÃiGÅ~ÞØÛ;Hëp+µÁøK{{ûÐБ¯éîîn·Á¥ ê¥Ôu)zú×} <§y! +Õä­ñ!S/¬ÅÃèÍZîEæÓw™Ì—åì#ê1þÐþ‰¿Få8øüzCQ” +>ð|>|>|>|>|>|>|>|>|>|> ᯊ3¸œ÷øÎ8ÝÀVä¥õ²žíºì÷Ö+xäðù\à«ûúècÏÀi¿ÔÜiÑ:û?:gø÷w ®Ûïtuu1 ŒKéw:::r/¥3c»ˆV˲$Iò.óiâ ¯4Z {—ùì)€ª~Ì–\þYI2Ÿ=-õרl@Ÿ_àóáóáóáóáóáóáóáóáóáó HI˜îèº>ÎÏAy»¶, >ßɉÁ3Ü õ œ¦%îE¤ñdj(u–üõ¡¿`@ùþþþîîîcÇŽ¡)üN,£KyüøqöÑ4MQ³$|Þ/RbÌZÓA\ +’)+R>ÿ©að(ó)týÓtæu°^AXÏ–\9÷—^4þ÷ÚºYþøÈ_—ÒÀçðùðùðùðùðùðùðùðùðùðù€¤R>¿&› yI’Êøº¦i|ŸOl;ÔÏkÃ.ºioï ­Óz0Î>Òw1 ¨C(Å ‚àE—$óiMÃ0 +픿í<£ûäcÛ=Ê|Mkg_žpËc×µ}ztÃÞøœµn öÍöoÕÐçSߦž©SÓ¦iR …B¾~µ>>>>>>>>>>ЀÐoØ79t“ö†$I.õ™Õ†°Zâ}¨a\pUäv>>?‹®xÒE71í¿·w}l=Ç€ ÞPÅ£„/IæS¢+”9³¶C™¶®(i¥wI™H˜E×µ¬S’¤—*óey_¨Ìº1ÝÚ”>U”ô’Mq—»cû_ýÛëjèóé7‰Ëë'NèwNM^-¬ uåó/šñÕK˜¸bö˯/¿næÒY×/™%Ý3sÎâ™w.š¹àîwËÓïY8mÙ]ÓV,˜ºrÁTeþ”Õó¦<2/üè¼ð·çNþ·¹“¿sòwN~òŽÉkîŽÉOÝ>ù{·O¢xúöIß¿-?¸mÒ3qõ3,n½úGŽx¶ÒAÛ¤}Ñ~鞺}ÛöAÒÑ>6wò·æ…×Ì Ó)Љ¬š?…ΈÎëþSï»kêò»¦-]8mÉÂé‹åé‹äéòÝÓïº{ÆüE3æ-šA­qû¢™·.δÌÍ÷̤&ºqÉ57,¹æú%×\{ï¬kî5séµ3–^;uÙµSf±œÅu“½Å¤œ¸:'®Ê×_™W8ã¾ë¿‘/¾î!¾–‰ÙYñÕûfoúek•{™Ërc…טPJL,%./öÅÊ_+™‹þuo‘·_}#«ûåtÎ|}xT'Ïn£†µÑbª#¦9bº#f,=3³ƒ†ö¬k–fÆ8Ŭ‘¸Ö×%O;®™=7äÄ#qÓ=,2É„Å7G‚2ÌÍ‹gÞ2sFe¡[eâ6;n‰;ì¸s$æÚ1/3xP6›÷ŒvÜeÇÂáȤ;Yž~·‹±ØŽ{2A&–dbÚ½vP¶\zWfv X~.2¹ô¾SWØA©õ;VÚñ …uyP~h^&VÛñ°ØYz=Ñð Ôým{ÞyÌÊçß±ƒæ 6 ±ˆØó›’جô];ì¹éÜôÄf¨ ÏPÃÓS5¦¤²'²¼Aè3#GûÃá>‹Ü6<ç²³ûž#èÜY#¬³Û„µOd¤Å¨õ¾c·ç·íùñÑ‘)òaûº(ŽYr…=KÒå¦>°xáð,I}‰O‘l~¤ŽM]ýºÌ´8‹Æ×·M†ÏT ~^ö½á8CwâN¿¤iZQ9o†³pTQ”ŠI }>¡îës1Nñdj(u¶õ`|ãXW<‰@ýëç)õÊ”™Þô‚KÚ4M3Kæ»Ôðמ„™Þ.f;Åž"Ø0zeöe~$ò_(~i•µé¼ôVöû¿þá¬Kjìê«ÐÔTjèóY7öRfÀ~ øå×N^êÊç#ˆÕª4ØѶ¼ðño}@ýá;ŸŸ¹%Ï*@ ‡Ã‘ÑÐj´×äó5+RœŸ®Ïo;<à"ööbÔPŸð¤Ä¼º‹át¾¯äNIÛqy .ˆµÎd>Åïݺ®*ëK•ùô_(œ¿Îxú‚ÌŽŽfJÂ/ +»½ý4g퀇óú¥†>Ÿí”Àãñõ”mšfÔ†þ(o ðù|>@ àó~‡n ™ýör/\?¨ªêQF9‘$©R2?\Ÿßw“NÍVN€ A‰Ñ‹W/Iæ»lGÓ´,™_Á[y²dþv1,x´Î{÷„õÑè‘‘†íuþ×°Ìß%¥3¡ÓsÖº=*½(œôP`^¿Àç×ôÓ®ÐÈ…ÏG àóŸhL4M£ûb­¦ö=‰…BM~ÅXÕçê¾>ïO¦0¨C,ËRm\¼ºw™ïîç)ÿ;W–뼸Ü!óµ¥™o×õOóµá)IÒ½Ë|Ãèåß ‡·œ«Ø_:1³»÷Bì© ¤×´Å\òêç>¶Ü‚뺠†>Ÿý ðòƒ„½ÜTŸ¶Ñuÿ.¢?r­þ}þSk×Ѫ“¯¼Šá¥_¹¸Ú»CT$èJñ«FW°qN|ÛÖwª4¢ÑÕ§cœ}íuEקuœ_Aú"0¥Ö[ò'(À_Ð=#+ݬ‡ƒ¡ÛUö|A’¤°ºsgïT©d4À>¿í°[éÞÞA üˆ®ëe¾»Ÿ§¬ë\YQ”º>í|2Ÿ"ù(kEÓŒ‹bKy2?ÑÅ;Ø=yËÌÌîh§´ë̳ô/<ã’T—l¢ýú»kÕÐçÓÔïe"¦_¬óÓÜÈÑM- ØÐ0gW„}Ìú 4FŸ?ÐQ9}Q /Vð¨ÿ~Ð@N9ÿÛ={Š®Oë ÌØw`J€FÀ4MfÅ‹¢(J­nÛëŠûü®xÒE=5wZ/øŽ¬Šú²e~z´Ï¯í‹ZÅ) ósëó£Ñ#‚°¾l™OXÝ¿¥]諾Ìv—>4Ü2’”ž¾ô¤KR½rî`?)J }>ïØî]‘ÿtaº;x°B 竈ªªæ6 |>¨P¸ÁwÀç7˜R ðp5]¡PCOåöù„º¯ÏÅ>Å“)Œ|DeþpŠPUI’œò°I˜…d¾¦µ>=š| +Ql±¬Syv·K6ù*_LSÄÊÍ–KFýâ…gê¼!‹RCŸOЯ¶kµ€;â2?À¿[˜ÏϽ(Yï#Àçƒj… Ð||~#€)‚®ëMeQïe™U&Ø>¿íð€‹}ú¯?õvtttww§Rûþ&‹áRþR:_ªªˆÌ÷ '¢Ee¾e’åÞe>­\pw{äa™¿gT3¾ülÌ%®i‹ ‚ïGem}¾ógL(¢Ù9:u~nû\œŸ†Ï5 + 3øøüFS*ç­®(ŠtKÈ—ÐáAà«Ñ ²iš ÞnÁöù]ñ¤‹€Ú`ü¥Ý&‘H`ùšŽŽ\Ê:GÓ4–“Ýe{¡KIßò(ó³¼_HZéí¢‹Ì7͸(¶x—ùYUýyv·?â¬Ìgüñ÷.étÎÚIòý¨¬­ÏO{{…~º8QÀ烅 Ð||~#€) ¿Á0 ¾œÝŠ¢è\Y×ufõ³–7&Áöù„º¯ÏÅAíÝŸ1NÉd=Á×ôôô0sˆKYo˜¦IIÆù ÕÝ”vwwÓuìèèp^Jï2?¨ï[iZ{!!o½‚°Þ£É§5iýòŽÁýu§‹Âɬ¶Ï{)뜚û|v ì§K.¡P(À•ù ø|PC p:ƒï€Ïo0¥@€áR:ëŽ/·,˹Ü0ŒÀVr–ÛtAòùñdªgà4ûÛÝAí>ƒ‰D—²®ˆF£y=¼{ªI¥RÎKI©[Å—ù†Ñ[HæGÛ~-œ¿Î£ÌÅË:å}¿C©³”?)(£¦‹=ìÊüïÞÞÁB—Ò/¶æ>ä¢4;óW éïÀ›||>¨!P¸ÁwÀç7˜R ÀH’ÄnÀÅùi»Ÿ-§ûÁ¬¯pmšf#7]ð|~ÏÀiæ—vKÐÇ®xÒÅA5wZ>TMÓòJxZX’r§|žUØ߀2?ñ™GòÊü¬¢}÷å¥îw÷ñ“,On;ÔbðŒK"åÑz0î󦮟߰À烅 Ð||~#€) 9=k9¿7Ï­Ã7M“ý—ÚØ?Ò‚çó¹ƒR÷õ±%îe¥¬ôt(u¶gà4ûP6ykòiaîCUw4MóhòA(uã¾#ù(Þ¢ëŸ:Ú§™¯ª—±Sž9Y•¾Ÿ¿íP¿¯Û>¿æ(Š’õkÄ0 Z’õÀΩÚÊ/ÎgŒ@>ø(\€Îà;àóL©` +ù|˲ØrºCÌýV( +’Ç.àù|giÏÀiZân¢ööÒ:ÄØ#€¡ÔY (ʆgcfÚ)ÔñTÞ‡…d~ÖkY Jþ’$ÑÁäý_¿ã]æ ÂúhôÈè–9¥ªG"Ñ.»ØÿÙ3‘º?åAßòuÃÂçûø|Pí~…‹Î€Îà àóL©`¸AÊG.²ºÐS€†"x>?="ç)vKÐÇ®xÒE@5wZ´ÿH+c@P6š¦ ‚ ŠbV=­G,Ë¢ïŽQæÓBú¯àe¶‘ö*óE±Å4ãÎïÒGZÈþW–w¸ì¥õ`œ¥DJ§î)Ô~ +ŸïàóAµû.::ƒ/€Ïo0¥@€áR:× 15$Bî·àóÓõù¼ ã[â^\O¦š;-ö7} +€šF¹‡/ +åv˲r7Â(ðÕdYR©êÇe¾,ïȪÀ7Œ^AXï\¡Ð^(%:ß`rÅ)ëÙ¨ß{ |¾/€ÏÕîWP¸è è ¾>¿À” +Æ0ŒBåš’$±ÿÒuݹܲ,ܶ§êóÕ¤ñd*í0üycoïàÎc ö·º¯ +'”TUU-¯ÞÞ#”EiòŒ‹Ìw®&ËrÞÕꎄ™>-º–,ïð(óUõ㜖UÕ/þó“Y¶ß O˜”)…º?å±ûøI¿wuø|¿ÐñÉ'¿Ý³§ìèïï¯öB>ø(\€Îà;àóL©lB¡¿ ‡Ã\=q½C+8ÅŽ,ËÁóØeHŸO8]}z´áÏÖƒñƒgøGZ +48ÌáK’ä¬uW«sK«ëº3…ŽÊ‹ÌWÅm}HK·6eâ÷nì]ækZ»ûwåI·[›ÎKïÉÿæÂPê,øm‡ö6äEæSPõ{·‡Ï•òÁ@átߟß`J€`ã¼ wÚi˲¸¢?E‰D"¢(ò5«ZtZÿÕço;ÔÏ]=[â^b:”:»ñ@ŒýMßÅ€¥JJ†”!)é”.*¾Sþ +•G +C–Ì÷Mbé­Â°ÏßY0 —-ó-ë”(¶8Wxò–™î»s +üƒgx.uÊŸðù R@>ø(\€Îà;àóL©x4MãêÞi§UU-¤†DQlðF ªÏw*©¡ÔYZÒvxÀEFÑú»ŸÌú +ð ©Tª¯¯/‘H )ʆ¿²äRošf÷¨ëº³ø¿(´2}%廬 ó)i.'™/ë£Ñ#Î/Fo(ôÚ¹Î_§¯úò¹ÝÍߘÍKƒOüÊúÁ³g=çS‚ À¨„Ï•òÁ@átߟß`J€FÀ²,UU%IRŹœ>æÚ¡p8Lë7x‹ÕçÇ“)§«§%]ñ¤‹ŒÚv¨?÷+À/tww·Û á•InY¾ ´RD4­ì¾hƒ.ozöjFÞ­™¦éw™o¾ð…è+«-ëTîZÞe¾aôæ\Ó-|ñK«Œ§/6ù´ß˜Qè¸xœpÃ) +—´ù@ó¹Ò}J°•ðù R8åÃ¥_¹xîíw ê?èJñ«¶lɽèÆŒÓçO¾ò*ŒŽº1ú|4 /‚Æ |>42¦i*Š¶‘e¹Pg£TŸŸvT™î>~’>¥Ü +MÕ}}ίl;Ô¾á#ººº˜9D‰¾˲¢Ñ¨Ç§–”C¡Kªª’çc„òpÑò¾àrN뙟´ÒÛEfק/Î_×Ôô£P赬µÆ"ó IÒÙ +ÒDÙÚtް̧ý&ݺKƒ+7[MMé%›â.i³eÛ ¶2ý›»ŽŽßJø|P)œ>áÇ€2jp²D1ÂQ†ÏG 9>%À>¿+žT÷õm<‹'SlɶCý.nŠÖßÛ;È?òoú§¿¿¿»»ûرchŠh4ªªª,Ë¢(òÊöz80˲ò¾'UÊQE7Nç +…ü(ó­Mç‰_ZÅÍüè““ÌOgžžÄŸ¼ãVuÁÕÃ&Ÿbì.óÓö£ÏžÓŸûüÙ/\ðw—„IñÉÎnZŸVλX,F£òøñãþ>ðù "ÀçC_ŸŸ@rê™ûü\ö6äâ¦Ú8køO žA÷õiš4Š?%úU‚öNG(B©&? +E£Ñ^³™O!M”¹™W”ù*c—ùöGΙ| +úè MK75¥¯œ;è’0<ß_ÓnUàóA¥€Ï‡2¾>>ä Ô3 åóãÉ”‹žÚx –¶ëÁøîã'Ñ7@ýcšfQ+.IR­¯l“O(ŠbϧG9ö'o™Éͼ(¶ðU*#ó‰]Ò𾶠+飺÷c¤Ù ©)½r³å’0'Üpªv=«ZÀçƒJñÛ={^TÕ‰5«vÊ–`œÔ;[·¢72Ô‚=l'_y•S㤎=ZôÊÒ:HÈHÎ@h(ŸO4wº*ÔäáÔAh8+Š¢ëz­”¸iš²,—gò[–ÏØfŽ]_õe§™·¬Sìÿ+&󉘑ÙÝ.)ó‡g ##ó¿pÁß]RedW­¼I>€2ȪwEƒPÿ8_@xQUÑ  @ÝÂýs¥²8*¥=Äçïít‘T;%0Ä@m1 CUUMÓ<®/IR(¢ñKcY×uÓ4k{üÌä—é,‚Y–Ï9ª§· +ÆÓç¯ãrž›ùJÊür‘åŒÏŸýpÂ%UÎY;@ëOÀçPÐGøøü ‚„  nϯR{6ˆÏ?1xÆER5wZb`œ1MSÓ4EQh :S“ê·Û+:‹¬S( Q Ãh„+nY§B¡×¸œ×´v¶¼d¾e¥!ãó×´Å\RåEá$­¼ËŸ@@à;àóƒ +2€º>¿JíÙ >ŸØxÀÍSÅ“)Œ2Pm,Ë¢¡GƒN—Ju_œ‹išŠ¢¸œHQ軾{x1Âá-\Î+ʇ™EI«d>Aס©)ýÅ Ýž{FvõÑ:¡ Þ#ÂçPÐGøøü ‚„  n1M3ZY–¥ž‘HDÓ4þ¿¬––;Ë_i¹eYÜž èówK¸¨ª½½ƒe ÚH’䮸iÊuu~º®¥ Ÿ™|JA–„¹œ‡·d>'-ù¦ï—!ó5­×öW +šššÒ³vK’ô¿´Ž¢ðÒÀçPÐGøøü ‚„ ÀwhšÆ‘{É=ý/³ú´¦a Þn èó{N»¨ªÖƒqŒ&Pmr58%%EQ(ÕRÒu]–å±ä3h#ŸY¨ª$í/Š-MM?¢-ë”w™ +½æ”ù¼ž_U?®à±ÉrÆç¯is{‰é‹ž¡uêþqS9ÀçPÐGøøü ‚„ À_X–ÅäýëEÑú\é£>¿Ñ|>¡îës±UC©³SÀ;ÑhT×õˆûÃDŽa’$ɲÌÞòÅiVJã³lãñ±ÏÕÌÿ¨ÏÉÈütZžûS/2Xþ·É©px ÿ¯Hä£ +XÊ0ZÂßvIkÚbMMiQ ìX†Ï T ððùA €¿PU•Ý€kšæñ+¦i²¯D"‘FnºÆôùm‡\„Õþφ0¦üE,ëèèèîîN¥RUÝå ¦îeY¦!“+·iI–Η²«$IM‚Íýù…óR† +…øwé0ÖoßøáKeÈ|VÞÏBÖ;‹öÇΙhtóóoº¤ÇÙ'ššÒ^nýÇmTVø|ÊúߟTø ®›J*¶geŸbP ½Ñ˜>¿+žtVÛõcLù‹ŽŽŽv›D"Q½½8]Ÿ ~oLÊ¢¬ßéÒÇmÐKM>¿”mmmÎÇ%”¨ö.•ñî3c”ùâ—VO_îTÇr»Ÿ¤Œwbð ûO¦\r#Å/:×O$…d¾³Ì»Y[Ë mŠ% Qi¼Ð1ÐñÐKJ;õ9‚$I^Ú§ h³´ýR§¯¯oÉ’%Y‚Ö¹iâ—VUFæSü^)û@6ˆeù|u_ŸKb|èñ¿<þîpæl=wßx*•*4*ëyPÀçP*ÐGøøü ‚„ À_(ŠÂnÀ#‘ˆÇ¯˜¦É¾ +5ôLÇ}¾ eT,³Æ»â}SYUÓ¹¨žpjšÍãïþši¨çö˜ôñ»?Þ⢭Ú°íœ<Óz0N#…1 ÃãQÑšQW¼ËO^s>öM9*ï zqݯ ÇÎàQÂ{iy§ s1Ï>uò%Aç¨ë:°MÕ„¶O°Œ#¤ šõ‚€êë{ÌùNÌ'Ý^1™¿§ü‡¼8Ÿ‚½¸ä\’‘]}Ñ>ãw?¼1Ÿ@@à;àóƒ +2¡ë:÷r^ŸeYÜ°ø³¸Ï/¯bÙ‹,­ì¦¼\_Z'÷‹n¸ƒ›¨/\ð.æJÝ×Ç6Õz0ΖÐ×]ŽÊ‹ Î{Tå‰e/ºÛ㦼•ÇÿÎàeSÎÁ +…ø“øüE€e>š¦it²üu¤êA]Žv4–Æt>h ­•÷P .HZéíbÆ·ïýÞSÌИ^’Ì·‡Ã‘ŠË|¢¹ÓbÉmãXÖ’¼ñÝ–£NáO¦‚7^àó(è#||~PABà;¸­*jè†ÝYÚu¹.¸øüq¶Á7UvIöç>ÿ?¸‰š¾t -yâW†‹¼:1x&íðù ž³~u}nª‚Á²¬¼þÙù‰÷÷>ñtø ʨ´Gºjcß|sŠpþº¢>_×?ÍݤñáÑïüS¥d~Úñ¤’ç·pɇo:|¸÷ïY‚|>e}€ï€Ï*HÈüˆa%Õ£Bæ§>ߣþõ5]ñ¤³üžÂÅ_1ÍO¦¯°€‰F£”ÁdY.úd§þ5~ HZé­Â°u§?#­Ô©†ÿeYQ™‰|”³|›•ùÎRüÝÇOÒ’¡ÔY÷âüWßèu>ܤõƒ:¬àó(è#||~PABàS,ËŠD"E+TC¡÷¢ñ`ÓP>ŸP÷õ9Ëï7ˆ¹(¬žÓ´Ns§Å>n;ÔjE >AIU’$MÓ ñ‹°K:'Þ;UË:e½é„];¡¨Ì—$½àf+'óÓŽâ|ʇÌÌï>~Ò%®i‹uV#dBø|ÊúߟTø˲4MË_ápXQ˜|'æóÛ8ËïwK¸X,Z™Öi„ªTP‡ÔVàó´@)Â0 \OÕω÷]’e„õQÿ ¥hq¾(¶Ðú·|HK \ No newline at end of file diff --git a/libs/zlibng/test/example.c b/libs/zlibng/test/example.c index 964a380d7..97ca0029b 100644 --- a/libs/zlibng/test/example.c +++ b/libs/zlibng/test/example.c @@ -3,20 +3,20 @@ * For conditions of distribution and use, see copyright notice in zlib.h */ -/* @(#) $Id$ */ - #include "zbuild.h" #ifdef ZLIB_COMPAT # include "zlib.h" #else # include "zlib-ng.h" #endif +#include "deflate.h" #include #include #include #include +#include #define TESTFILE "foo.gz" @@ -40,7 +40,7 @@ void test_compress (unsigned char *compr, z_size_t comprLen,unsigned char * void test_gzio (const char *fname, unsigned char *uncompr, z_size_t uncomprLen); void test_deflate (unsigned char *compr, size_t comprLen); void test_inflate (unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen); -void test_large_deflate (unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen); +void test_large_deflate (unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen, int zng_params); void test_large_inflate (unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen); void test_flush (unsigned char *compr, z_size_t *comprLen); void test_sync (unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen); @@ -55,8 +55,7 @@ static free_func zfree = NULL; /* =========================================================================== * Test compress() and uncompress() */ -void test_compress(unsigned char *compr, z_size_t comprLen, unsigned char *uncompr, z_size_t uncomprLen) -{ +void test_compress(unsigned char *compr, z_size_t comprLen, unsigned char *uncompr, z_size_t uncomprLen) { int err; size_t len = strlen(hello)+1; @@ -79,21 +78,24 @@ void test_compress(unsigned char *compr, z_size_t comprLen, unsigned char *uncom /* =========================================================================== * Test read/write of .gz files */ -void test_gzio(const char *fname, unsigned char *uncompr, z_size_t uncomprLen) -{ +void test_gzio(const char *fname, unsigned char *uncompr, z_size_t uncomprLen) { #ifdef NO_GZCOMPRESS fprintf(stderr, "NO_GZCOMPRESS -- gz* functions cannot compress\n"); #else int err; - int len = (int)strlen(hello)+1; + size_t read; + size_t len = strlen(hello)+1; gzFile file; - z_off_t pos; + z_off64_t pos; + z_off64_t comprLen; + /* Write gz file with test data */ file = PREFIX(gzopen)(fname, "wb"); if (file == NULL) { fprintf(stderr, "gzopen error\n"); exit(1); } + /* Write hello, hello! using gzputs and gzprintf */ PREFIX(gzputc)(file, 'h'); if (PREFIX(gzputs)(file, "ello") != 4) { fprintf(stderr, "gzputs err: %s\n", PREFIX(gzerror)(file, &err)); @@ -103,17 +105,42 @@ void test_gzio(const char *fname, unsigned char *uncompr, z_size_t uncomprLen) fprintf(stderr, "gzprintf err: %s\n", PREFIX(gzerror)(file, &err)); exit(1); } - PREFIX(gzseek)(file, 1L, SEEK_CUR); /* add one zero byte */ + /* Write string null-teriminator using gzseek */ + if (PREFIX(gzseek)(file, 1L, SEEK_CUR) < 0) + { + fprintf(stderr, "gzseek error, gztell=%ld\n", (long)PREFIX(gztell)(file)); + exit(1); + } + /* Write hello, hello! using gzfwrite using best compression level */ + if (PREFIX(gzsetparams)(file, Z_BEST_COMPRESSION, Z_DEFAULT_STRATEGY) != Z_OK) { + fprintf(stderr, "gzsetparams err: %s\n", PREFIX(gzerror)(file, &err)); + exit(1); + } + if (PREFIX(gzfwrite)(hello, len, 1, file) == 0) { + fprintf(stderr, "gzfwrite err: %s\n", PREFIX(gzerror)(file, &err)); + exit(1); + } + /* Flush compressed bytes to file */ + if (PREFIX(gzflush)(file, Z_SYNC_FLUSH) != Z_OK) { + fprintf(stderr, "gzflush err: %s\n", PREFIX(gzerror)(file, &err)); + exit(1); + } + comprLen = PREFIX(gzoffset)(file); + if (comprLen <= 0) { + fprintf(stderr, "gzoffset err: %s\n", PREFIX(gzerror)(file, &err)); + exit(1); + } PREFIX(gzclose)(file); + /* Open gz file we previously wrote */ file = PREFIX(gzopen)(fname, "rb"); if (file == NULL) { fprintf(stderr, "gzopen error\n"); exit(1); } - strcpy((char*)uncompr, "garbage"); - - if (PREFIX(gzread)(file, uncompr, (unsigned)uncomprLen) != len) { + /* Read uncompressed data - hello, hello! string twice */ + strcpy((char*)uncompr, "garbages"); + if (PREFIX(gzread)(file, uncompr, (unsigned)uncomprLen) != (int)(len + len)) { fprintf(stderr, "gzread err: %s\n", PREFIX(gzerror)(file, &err)); exit(1); } @@ -123,24 +150,28 @@ void test_gzio(const char *fname, unsigned char *uncompr, z_size_t uncomprLen) } else { printf("gzread(): %s\n", (char*)uncompr); } - - pos = PREFIX(gzseek)(file, -8L, SEEK_CUR); + /* Check position at the end of the gz file */ + if (PREFIX(gzeof)(file) != 1) { + fprintf(stderr, "gzeof err: not reporting end of stream\n"); + exit(1); + } + /* Seek backwards mid-string and check char reading with gzgetc and gzungetc */ + pos = PREFIX(gzseek)(file, -22L, SEEK_CUR); if (pos != 6 || PREFIX(gztell)(file) != pos) { fprintf(stderr, "gzseek error, pos=%ld, gztell=%ld\n", (long)pos, (long)PREFIX(gztell)(file)); exit(1); } - if (PREFIX(gzgetc)(file) != ' ') { fprintf(stderr, "gzgetc error\n"); exit(1); } - if (PREFIX(gzungetc)(' ', file) != ' ') { fprintf(stderr, "gzungetc error\n"); exit(1); } - + /* Read first hello, hello! string with gzgets */ + strcpy((char*)uncompr, "garbages"); PREFIX(gzgets)(file, (char*)uncompr, (int)uncomprLen); if (strlen((char*)uncompr) != 7) { /* " hello!" */ fprintf(stderr, "gzgets err after gzseek: %s\n", PREFIX(gzerror)(file, &err)); @@ -152,19 +183,63 @@ void test_gzio(const char *fname, unsigned char *uncompr, z_size_t uncomprLen) } else { printf("gzgets() after gzseek: %s\n", (char*)uncompr); } + /* Seek to second hello, hello! string */ + pos = PREFIX(gzseek)(file, 14L, SEEK_SET); + if (pos != 14 || PREFIX(gztell)(file) != pos) { + fprintf(stderr, "gzseek error, pos=%ld, gztell=%ld\n", + (long)pos, (long)PREFIX(gztell)(file)); + exit(1); + } + /* Check position not at end of file */ + if (PREFIX(gzeof)(file) != 0) { + fprintf(stderr, "gzeof err: reporting end of stream\n"); + exit(1); + } + /* Read first hello, hello! string with gzfread */ + strcpy((char*)uncompr, "garbages"); + read = PREFIX(gzfread)(uncompr, uncomprLen, 1, file); + if (strcmp((const char *)uncompr, hello) != 0) { + fprintf(stderr, "bad gzgets\n"); + exit(1); + } else { + printf("gzgets(): %s\n", (char*)uncompr); + } + pos = PREFIX(gzoffset)(file); + if (pos < 0 || pos != (comprLen + 10)) { + fprintf(stderr, "gzoffset err: wrong offset at end\n"); + exit(1); + } + /* Trigger an error and clear it with gzclearerr */ + PREFIX(gzfread)(uncompr, (size_t)-1, (size_t)-1, file); + PREFIX(gzerror)(file, &err); + if (err == 0) { + fprintf(stderr, "gzerror err: no error returned\n"); + exit(1); + } + PREFIX(gzclearerr)(file); + PREFIX(gzerror)(file, &err); + if (err != 0) { + fprintf(stderr, "gzclearerr err: not zero %d\n", err); + exit(1); + } PREFIX(gzclose)(file); + + if (PREFIX(gzclose)(NULL) != Z_STREAM_ERROR) { + fprintf(stderr, "gzclose unexpected return when handle null\n"); + exit(1); + } + (void)read; #endif } /* =========================================================================== * Test deflate() with small buffers */ -void test_deflate(unsigned char *compr, size_t comprLen) -{ +void test_deflate(unsigned char *compr, size_t comprLen) { PREFIX3(stream) c_stream; /* compression stream */ int err; - unsigned long len = (unsigned long)strlen(hello)+1; + size_t len = strlen(hello)+1; c_stream.zalloc = zalloc; c_stream.zfree = zfree; @@ -175,7 +250,7 @@ void test_deflate(unsigned char *compr, size_t comprLen) err = PREFIX(deflateInit)(&c_stream, Z_DEFAULT_COMPRESSION); CHECK_ERR(err, "deflateInit"); - c_stream.next_in = (const unsigned char *)hello; + c_stream.next_in = (z_const unsigned char *)hello; c_stream.next_out = compr; while (c_stream.total_in != len && c_stream.total_out < comprLen) { @@ -198,8 +273,7 @@ void test_deflate(unsigned char *compr, size_t comprLen) /* =========================================================================== * Test inflate() with small buffers */ -void test_inflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) -{ +void test_inflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) { int err; PREFIX3(stream) d_stream; /* decompression stream */ @@ -241,10 +315,22 @@ static unsigned int diff; /* =========================================================================== * Test deflate() with large buffers and dynamic change of compression level */ -void test_large_deflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) -{ +void test_large_deflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen, int zng_params) { PREFIX3(stream) c_stream; /* compression stream */ int err; +#ifndef ZLIB_COMPAT + int level = -1; + int strategy = -1; + zng_deflate_param_value params[2]; + + params[0].param = Z_DEFLATE_LEVEL; + params[0].buf = &level; + params[0].size = sizeof(level); + + params[1].param = Z_DEFLATE_STRATEGY; + params[1].buf = &strategy; + params[1].size = sizeof(strategy); +#endif c_stream.zalloc = zalloc; c_stream.zfree = zfree; @@ -269,7 +355,27 @@ void test_large_deflate(unsigned char *compr, size_t comprLen, unsigned char *un } /* Feed in already compressed data and switch to no compression: */ - PREFIX(deflateParams)(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY); + if (zng_params) { +#ifndef ZLIB_COMPAT + zng_deflateGetParams(&c_stream, params, sizeof(params) / sizeof(params[0])); + if (level != Z_BEST_SPEED) { + fprintf(stderr, "Expected compression level Z_BEST_SPEED, got %d\n", level); + exit(1); + } + if (strategy != Z_DEFAULT_STRATEGY) { + fprintf(stderr, "Expected compression strategy Z_DEFAULT_STRATEGY, got %d\n", strategy); + exit(1); + } + level = Z_NO_COMPRESSION; + strategy = Z_DEFAULT_STRATEGY; + zng_deflateSetParams(&c_stream, params, sizeof(params) / sizeof(params[0])); +#else + fprintf(stderr, "test_large_deflate() called with zng_params=1 in compat mode\n"); + exit(1); +#endif + } else { + PREFIX(deflateParams)(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY); + } c_stream.next_in = compr; diff = (unsigned int)(c_stream.next_out - compr); c_stream.avail_in = diff; @@ -277,7 +383,29 @@ void test_large_deflate(unsigned char *compr, size_t comprLen, unsigned char *un CHECK_ERR(err, "deflate"); /* Switch back to compressing mode: */ - PREFIX(deflateParams)(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED); + if (zng_params) { +#ifndef ZLIB_COMPAT + level = -1; + strategy = -1; + zng_deflateGetParams(&c_stream, params, sizeof(params) / sizeof(params[0])); + if (level != Z_NO_COMPRESSION) { + fprintf(stderr, "Expected compression level Z_NO_COMPRESSION, got %d\n", level); + exit(1); + } + if (strategy != Z_DEFAULT_STRATEGY) { + fprintf(stderr, "Expected compression strategy Z_DEFAULT_STRATEGY, got %d\n", strategy); + exit(1); + } + level = Z_BEST_COMPRESSION; + strategy = Z_FILTERED; + zng_deflateSetParams(&c_stream, params, sizeof(params) / sizeof(params[0])); +#else + fprintf(stderr, "test_large_deflate() called with zng_params=1 in compat mode\n"); + exit(1); +#endif + } else { + PREFIX(deflateParams)(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED); + } c_stream.next_in = uncompr; c_stream.avail_in = (unsigned int)uncomprLen; err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH); @@ -295,8 +423,7 @@ void test_large_deflate(unsigned char *compr, size_t comprLen, unsigned char *un /* =========================================================================== * Test inflate() with large buffers */ -void test_large_inflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) -{ +void test_large_inflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) { int err; PREFIX3(stream) d_stream; /* decompression stream */ @@ -326,7 +453,7 @@ void test_large_inflate(unsigned char *compr, size_t comprLen, unsigned char *un CHECK_ERR(err, "inflateEnd"); if (d_stream.total_out != 2*uncomprLen + diff) { - fprintf(stderr, "bad large inflate: %zu\n", d_stream.total_out); + fprintf(stderr, "bad large inflate: %" PRIu64 "\n", (uint64_t)d_stream.total_out); exit(1); } else { printf("large_inflate(): OK\n"); @@ -336,8 +463,7 @@ void test_large_inflate(unsigned char *compr, size_t comprLen, unsigned char *un /* =========================================================================== * Test deflate() with full flush */ -void test_flush(unsigned char *compr, z_size_t *comprLen) -{ +void test_flush(unsigned char *compr, z_size_t *comprLen) { PREFIX3(stream) c_stream; /* compression stream */ int err; unsigned int len = (unsigned int)strlen(hello)+1; @@ -349,7 +475,7 @@ void test_flush(unsigned char *compr, z_size_t *comprLen) err = PREFIX(deflateInit)(&c_stream, Z_DEFAULT_COMPRESSION); CHECK_ERR(err, "deflateInit"); - c_stream.next_in = (const unsigned char *)hello; + c_stream.next_in = (z_const unsigned char *)hello; c_stream.next_out = compr; c_stream.avail_in = 3; c_stream.avail_out = (unsigned int)*comprLen; @@ -372,8 +498,7 @@ void test_flush(unsigned char *compr, z_size_t *comprLen) /* =========================================================================== * Test inflateSync() */ -void test_sync(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) -{ +void test_sync(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) { int err; PREFIX3(stream) d_stream; /* decompression stream */ @@ -400,9 +525,8 @@ void test_sync(unsigned char *compr, size_t comprLen, unsigned char *uncompr, si CHECK_ERR(err, "inflateSync"); err = PREFIX(inflate)(&d_stream, Z_FINISH); - if (err != Z_DATA_ERROR) { - fprintf(stderr, "inflate should report DATA_ERROR\n"); - /* Because of incorrect adler32 */ + if (err != Z_STREAM_END) { + fprintf(stderr, "inflate should report Z_STREAM_END\n"); exit(1); } err = PREFIX(inflateEnd)(&d_stream); @@ -414,8 +538,7 @@ void test_sync(unsigned char *compr, size_t comprLen, unsigned char *uncompr, si /* =========================================================================== * Test deflate() with preset dictionary */ -void test_dict_deflate(unsigned char *compr, size_t comprLen) -{ +void test_dict_deflate(unsigned char *compr, size_t comprLen) { PREFIX3(stream) c_stream; /* compression stream */ int err; @@ -435,7 +558,7 @@ void test_dict_deflate(unsigned char *compr, size_t comprLen) c_stream.next_out = compr; c_stream.avail_out = (unsigned int)comprLen; - c_stream.next_in = (const unsigned char *)hello; + c_stream.next_in = (z_const unsigned char *)hello; c_stream.avail_in = (unsigned int)strlen(hello)+1; err = PREFIX(deflate)(&c_stream, Z_FINISH); @@ -450,8 +573,7 @@ void test_dict_deflate(unsigned char *compr, size_t comprLen) /* =========================================================================== * Test inflate() with a preset dictionary */ -void test_dict_inflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) -{ +void test_dict_inflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) { int err; PREFIX3(stream) d_stream; /* decompression stream */ @@ -495,12 +617,392 @@ void test_dict_inflate(unsigned char *compr, size_t comprLen, unsigned char *unc } } +/* =========================================================================== + * Test deflateBound() with small buffers + */ +void test_deflate_bound(void) { + PREFIX3(stream) c_stream; /* compression stream */ + int err; + unsigned int len = (unsigned int)strlen(hello)+1; + int estimateLen = 0; + unsigned char *outBuf = NULL; + + c_stream.zalloc = zalloc; + c_stream.zfree = zfree; + c_stream.opaque = (voidpf)0; + c_stream.avail_in = len; + c_stream.next_in = (z_const unsigned char *)hello; + c_stream.avail_out = 0; + c_stream.next_out = outBuf; + + err = PREFIX(deflateInit)(&c_stream, Z_DEFAULT_COMPRESSION); + CHECK_ERR(err, "deflateInit"); + + /* calculate actual output length and update structure */ + estimateLen = PREFIX(deflateBound)(&c_stream, len); + outBuf = malloc(estimateLen); + + if (outBuf != NULL) { + /* update zlib configuration */ + c_stream.avail_out = estimateLen; + c_stream.next_out = outBuf; + + /* do the compression */ + err = PREFIX(deflate)(&c_stream, Z_FINISH); + if (err == Z_STREAM_END) { + printf("deflateBound(): OK\n"); + } else { + CHECK_ERR(err, "deflate"); + } + } + + err = PREFIX(deflateEnd)(&c_stream); + CHECK_ERR(err, "deflateEnd"); + + free(outBuf); +} + +/* =========================================================================== + * Test deflateCopy() with small buffers + */ +void test_deflate_copy(unsigned char *compr, size_t comprLen) { + PREFIX3(stream) c_stream, c_stream_copy; /* compression stream */ + int err; + size_t len = strlen(hello)+1; + + memset(&c_stream, 0, sizeof(c_stream)); + + c_stream.zalloc = zalloc; + c_stream.zfree = zfree; + c_stream.opaque = (voidpf)0; + + err = PREFIX(deflateInit)(&c_stream, Z_DEFAULT_COMPRESSION); + CHECK_ERR(err, "deflateInit"); + + c_stream.next_in = (z_const unsigned char *)hello; + c_stream.next_out = compr; + + while (c_stream.total_in != len && c_stream.total_out < comprLen) { + c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */ + err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH); + CHECK_ERR(err, "deflate"); + } + + /* Finish the stream, still forcing small buffers: */ + for (;;) { + c_stream.avail_out = 1; + err = PREFIX(deflate)(&c_stream, Z_FINISH); + if (err == Z_STREAM_END) break; + CHECK_ERR(err, "deflate"); + } + + err = PREFIX(deflateCopy)(&c_stream_copy, &c_stream); + CHECK_ERR(err, "deflate_copy"); + + if (c_stream.state->status == c_stream_copy.state->status) { + printf("deflate_copy(): OK\n"); + } + + err = PREFIX(deflateEnd)(&c_stream); + CHECK_ERR(err, "deflateEnd original"); + + err = PREFIX(deflateEnd)(&c_stream_copy); + CHECK_ERR(err, "deflateEnd copy"); +} + +/* =========================================================================== + * Test deflateGetDictionary() with small buffers + */ +void test_deflate_get_dict(unsigned char *compr, size_t comprLen) { + PREFIX3(stream) c_stream; /* compression stream */ + int err; + unsigned char *dictNew = NULL; + unsigned int *dictLen; + + c_stream.zalloc = zalloc; + c_stream.zfree = zfree; + c_stream.opaque = (voidpf)0; + + err = PREFIX(deflateInit)(&c_stream, Z_BEST_COMPRESSION); + CHECK_ERR(err, "deflateInit"); + + c_stream.next_out = compr; + c_stream.avail_out = (uInt)comprLen; + + c_stream.next_in = (z_const unsigned char *)hello; + c_stream.avail_in = (unsigned int)strlen(hello)+1; + + err = PREFIX(deflate)(&c_stream, Z_FINISH); + + if (err != Z_STREAM_END) { + fprintf(stderr, "deflate should report Z_STREAM_END\n"); + exit(1); + } + + dictNew = calloc(256, 1); + dictLen = (unsigned int *)calloc(4, 1); + err = PREFIX(deflateGetDictionary)(&c_stream, dictNew, dictLen); + + CHECK_ERR(err, "deflateGetDictionary"); + if (err == Z_OK) { + printf("deflateGetDictionary(): %s\n", dictNew); + } + + err = PREFIX(deflateEnd)(&c_stream); + CHECK_ERR(err, "deflateEnd"); + + free(dictNew); + free(dictLen); +} + +/* =========================================================================== + * Test deflatePending() with small buffers + */ +void test_deflate_pending(unsigned char *compr, size_t comprLen) { + PREFIX3(stream) c_stream; /* compression stream */ + int err; + int *bits = calloc(256, 1); + unsigned *ped = calloc(256, 1); + size_t len = strlen(hello)+1; + + + c_stream.zalloc = zalloc; + c_stream.zfree = zfree; + c_stream.opaque = (voidpf)0; + + err = PREFIX(deflateInit)(&c_stream, Z_DEFAULT_COMPRESSION); + CHECK_ERR(err, "deflateInit"); + + c_stream.next_in = (z_const unsigned char *)hello; + c_stream.next_out = compr; + + while (c_stream.total_in != len && c_stream.total_out < comprLen) { + c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */ + err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH); + CHECK_ERR(err, "deflate"); + } + + err = PREFIX(deflatePending)(&c_stream, ped, bits); + CHECK_ERR(err, "deflatePending"); + + if (*bits >= 0 && *bits <= 7) { + printf("deflatePending(): OK\n"); + } else { + printf("deflatePending(): error\n"); + } + + /* Finish the stream, still forcing small buffers: */ + for (;;) { + c_stream.avail_out = 1; + err = PREFIX(deflate)(&c_stream, Z_FINISH); + if (err == Z_STREAM_END) break; + CHECK_ERR(err, "deflate"); + } + + err = PREFIX(deflateEnd)(&c_stream); + CHECK_ERR(err, "deflateEnd"); + + free(bits); + free(ped); +} + +/* =========================================================================== + * Test deflatePrime() wrapping gzip around deflate stream + */ +void test_deflate_prime(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) { + PREFIX3(stream) c_stream; /* compression stream */ + PREFIX3(stream) d_stream; /* decompression stream */ + int err; + size_t len = strlen(hello)+1; + uint32_t crc = 0; + + + c_stream.zalloc = zalloc; + c_stream.zfree = zfree; + c_stream.opaque = (voidpf)0; + + /* Raw deflate windowBits is -15 */ + err = PREFIX(deflateInit2)(&c_stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, -MAX_WBITS, 8, Z_DEFAULT_STRATEGY); + CHECK_ERR(err, "deflateInit2"); + + /* Gzip magic number */ + err = PREFIX(deflatePrime)(&c_stream, 16, 0x8b1f); + CHECK_ERR(err, "deflatePrime"); + /* Gzip compression method (deflate) */ + err = PREFIX(deflatePrime)(&c_stream, 8, 0x08); + CHECK_ERR(err, "deflatePrime"); + /* Gzip flags (one byte, using two odd bit calls) */ + err = PREFIX(deflatePrime)(&c_stream, 3, 0x0); + CHECK_ERR(err, "deflatePrime"); + err = PREFIX(deflatePrime)(&c_stream, 5, 0x0); + CHECK_ERR(err, "deflatePrime"); + /* Gzip modified time */ + err = PREFIX(deflatePrime)(&c_stream, 32, 0x0); + CHECK_ERR(err, "deflatePrime"); + /* Gzip extra flags */ + err = PREFIX(deflatePrime)(&c_stream, 8, 0x0); + CHECK_ERR(err, "deflatePrime"); + /* Gzip operating system */ + err = PREFIX(deflatePrime)(&c_stream, 8, 255); + CHECK_ERR(err, "deflatePrime"); + + c_stream.next_in = (z_const unsigned char *)hello; + c_stream.avail_in = (uint32_t)len; + c_stream.next_out = compr; + c_stream.avail_out = (uint32_t)comprLen; + + err = PREFIX(deflate)(&c_stream, Z_FINISH); + if (err != Z_STREAM_END) + CHECK_ERR(err, "deflate"); + + /* Gzip uncompressed data crc32 */ + crc = PREFIX(crc32)(0, (const uint8_t *)hello, (uint32_t)len); + err = PREFIX(deflatePrime)(&c_stream, 32, crc); + CHECK_ERR(err, "deflatePrime"); + /* Gzip uncompressed data length */ + err = PREFIX(deflatePrime)(&c_stream, 32, (uint32_t)len); + CHECK_ERR(err, "deflatePrime"); + + err = PREFIX(deflateEnd)(&c_stream); + CHECK_ERR(err, "deflateEnd"); + + d_stream.zalloc = zalloc; + d_stream.zfree = zfree; + d_stream.opaque = (void *)0; + + d_stream.next_in = compr; + d_stream.avail_in = (uint32_t)c_stream.total_out; + d_stream.next_out = uncompr; + d_stream.avail_out = (uint32_t)uncomprLen; + d_stream.total_in = 0; + d_stream.total_out = 0; + + /* Inflate with gzip header */ + err = PREFIX(inflateInit2)(&d_stream, MAX_WBITS + 32); + CHECK_ERR(err, "inflateInit"); + + err = PREFIX(inflate)(&d_stream, Z_FINISH); + if (err != Z_BUF_ERROR) { + CHECK_ERR(err, "inflate"); + } + + err = PREFIX(inflateEnd)(&d_stream); + CHECK_ERR(err, "inflateEnd"); + + if (strcmp((const char *)uncompr, hello) != 0) { + fprintf(stderr, "bad deflatePrime\n"); + exit(1); + } + + if (err == Z_OK) { + printf("deflatePrime(): OK\n"); + } +} + +/* =========================================================================== + * Test deflateSetHeader() with small buffers + */ +void test_deflate_set_header(unsigned char *compr, size_t comprLen) { + PREFIX(gz_header) *head = calloc(1, sizeof(PREFIX(gz_header))); + PREFIX3(stream) c_stream; /* compression stream */ + int err; + size_t len = strlen(hello)+1; + + + if (head == NULL) { + printf("out of memory\n"); + exit(1); + } + + c_stream.zalloc = zalloc; + c_stream.zfree = zfree; + c_stream.opaque = (voidpf)0; + + /* gzip */ + err = PREFIX(deflateInit2)(&c_stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, MAX_WBITS + 16, 8, Z_DEFAULT_STRATEGY); + CHECK_ERR(err, "deflateInit2"); + + head->text = 1; + err = PREFIX(deflateSetHeader)(&c_stream, head); + CHECK_ERR(err, "deflateSetHeader"); + if (err == Z_OK) { + printf("deflateSetHeader(): OK\n"); + } + + c_stream.next_in = (unsigned char *)hello; + c_stream.next_out = compr; + + while (c_stream.total_in != len && c_stream.total_out < comprLen) { + c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */ + err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH); + CHECK_ERR(err, "deflate"); + } + + /* Finish the stream, still forcing small buffers: */ + for (;;) { + c_stream.avail_out = 1; + err = PREFIX(deflate)(&c_stream, Z_FINISH); + if (err == Z_STREAM_END) break; + CHECK_ERR(err, "deflate"); + } + + err = PREFIX(deflateEnd)(&c_stream); + CHECK_ERR(err, "deflateEnd"); + + free(head); +} + +/* =========================================================================== + * Test deflateTune() with small buffers + */ +void test_deflate_tune(unsigned char *compr, size_t comprLen) { + PREFIX3(stream) c_stream; /* compression stream */ + int err; + int good_length = 3; + int max_lazy = 5; + int nice_length = 18; + int max_chain = 6; + size_t len = strlen(hello)+1; + + + c_stream.zalloc = zalloc; + c_stream.zfree = zfree; + c_stream.opaque = (voidpf)0; + + err = PREFIX(deflateInit)(&c_stream, Z_BEST_COMPRESSION); + CHECK_ERR(err, "deflateInit"); + + err = PREFIX(deflateTune)(&c_stream,(uInt)good_length,(uInt)max_lazy,nice_length,(uInt)max_chain); + CHECK_ERR(err, "deflateTune"); + if (err == Z_OK) { + printf("deflateTune(): OK\n"); + } + + c_stream.next_in = (z_const unsigned char *)hello; + c_stream.next_out = compr; + + while (c_stream.total_in != len && c_stream.total_out < comprLen) { + c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */ + err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH); + CHECK_ERR(err, "deflate"); + } + + /* Finish the stream, still forcing small buffers: */ + for (;;) { + c_stream.avail_out = 1; + err = PREFIX(deflate)(&c_stream, Z_FINISH); + if (err == Z_STREAM_END) break; + CHECK_ERR(err, "deflate"); + } + + err = PREFIX(deflateEnd)(&c_stream); + CHECK_ERR(err, "deflateEnd"); +} + /* =========================================================================== * Usage: example [output.gz [input.gz]] */ - -int main(int argc, char *argv[]) -{ +int main(int argc, char *argv[]) { unsigned char *compr, *uncompr; z_size_t comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */ z_size_t uncomprLen = comprLen; @@ -535,9 +1037,14 @@ int main(int argc, char *argv[]) test_deflate(compr, comprLen); test_inflate(compr, comprLen, uncompr, uncomprLen); - test_large_deflate(compr, comprLen, uncompr, uncomprLen); + test_large_deflate(compr, comprLen, uncompr, uncomprLen, 0); test_large_inflate(compr, comprLen, uncompr, uncomprLen); +#ifndef ZLIB_COMPAT + test_large_deflate(compr, comprLen, uncompr, uncomprLen, 1); + test_large_inflate(compr, comprLen, uncompr, uncomprLen); +#endif + test_flush(compr, &comprLen); test_sync(compr, comprLen, uncompr, uncomprLen); comprLen = uncomprLen; @@ -545,6 +1052,14 @@ int main(int argc, char *argv[]) test_dict_deflate(compr, comprLen); test_dict_inflate(compr, comprLen, uncompr, uncomprLen); + test_deflate_bound(); + test_deflate_copy(compr, comprLen); + test_deflate_get_dict(compr, comprLen); + test_deflate_set_header(compr, comprLen); + test_deflate_tune(compr, comprLen); + test_deflate_pending(compr, comprLen); + test_deflate_prime(compr, comprLen, uncompr, uncomprLen); + free(compr); free(uncompr); diff --git a/libs/zlibng/test/fuzz/checksum_fuzzer.c b/libs/zlibng/test/fuzz/checksum_fuzzer.c index 10fc138fb..ef9942111 100644 --- a/libs/zlibng/test/fuzz/checksum_fuzzer.c +++ b/libs/zlibng/test/fuzz/checksum_fuzzer.c @@ -14,60 +14,73 @@ #endif int LLVMFuzzerTestOneInput(const uint8_t *data, size_t dataLen) { - uint32_t crc0 = PREFIX(crc32)(0L, NULL, 0); - uint32_t crc1 = crc0; - uint32_t crc2 = crc0; - uint32_t adler0 = PREFIX(adler32)(0L, NULL, 0); - uint32_t adler1 = adler0; - uint32_t adler2 = adler0; - /* Checksum with a buffer of size equal to the first byte in the input. */ - uint32_t buffSize = data[0]; - uint32_t offset = 0; - uint32_t op[32]; + uint32_t crc0 = PREFIX(crc32)(0L, NULL, 0); + uint32_t crc1 = crc0; + uint32_t crc2 = crc0; + uint32_t adler0 = PREFIX(adler32)(0L, NULL, 0); + uint32_t adler1 = adler0; + uint32_t adler2 = adler0; + uint32_t combine1, combine2; + /* Checksum with a buffer of size equal to the first byte in the input. */ + uint32_t buffSize = data[0]; + uint32_t offset = 0; + uint32_t op[32]; - /* Discard inputs larger than 1Mb. */ - static size_t kMaxSize = 1024 * 1024; - if (dataLen < 1 || dataLen > kMaxSize) + /* Discard inputs larger than 1Mb. */ + static size_t kMaxSize = 1024 * 1024; + if (dataLen < 1 || dataLen > kMaxSize) + return 0; + + /* Make sure the buffer has at least a byte. */ + if (buffSize == 0) + ++buffSize; + + /* CRC32 */ + PREFIX(crc32_combine_gen)(op, buffSize); + for (offset = 0; offset + buffSize <= dataLen; offset += buffSize) { + uint32_t crc3 = PREFIX(crc32_z)(crc0, data + offset, buffSize); + uint32_t crc4 = PREFIX(crc32_combine_op)(crc1, crc3, op); + crc1 = PREFIX(crc32_z)(crc1, data + offset, buffSize); + assert(crc1 == crc4); + (void)crc1; + (void)crc4; + } + crc1 = PREFIX(crc32_z)(crc1, data + offset, dataLen % buffSize); + + crc2 = PREFIX(crc32_z)(crc2, data, dataLen); + + assert(crc1 == crc2); + (void)crc1; + (void)crc2; + combine1 = PREFIX(crc32_combine)(crc1, crc2, (z_off_t)dataLen); + combine2 = PREFIX(crc32_combine)(crc1, crc1, (z_off_t)dataLen); + assert(combine1 == combine2); + + /* Fast CRC32 combine. */ + PREFIX(crc32_combine_gen)(op, (z_off_t)dataLen); + combine1 = PREFIX(crc32_combine_op)(crc1, crc2, op); + combine2 = PREFIX(crc32_combine_op)(crc2, crc1, op); + assert(combine1 == combine2); + combine1 = PREFIX(crc32_combine)(crc1, crc2, (z_off_t)dataLen); + combine2 = PREFIX(crc32_combine_op)(crc2, crc1, op); + assert(combine1 == combine2); + + /* Adler32 */ + for (offset = 0; offset + buffSize <= dataLen; offset += buffSize) + adler1 = PREFIX(adler32_z)(adler1, data + offset, buffSize); + adler1 = PREFIX(adler32_z)(adler1, data + offset, dataLen % buffSize); + + adler2 = PREFIX(adler32_z)(adler2, data, dataLen); + + assert(adler1 == adler2); + (void)adler1; + (void)adler2; + combine1 = PREFIX(adler32_combine)(adler1, adler2, (z_off_t)dataLen); + combine2 = PREFIX(adler32_combine)(adler1, adler1, (z_off_t)dataLen); + assert(combine1 == combine2); + (void)combine1; + (void)combine2; + + /* This function must return 0. */ return 0; - - /* Make sure the buffer has at least a byte. */ - if (buffSize == 0) - ++buffSize; - - /* CRC32 */ - PREFIX(crc32_combine_gen)(op, buffSize); - for (offset = 0; offset + buffSize <= dataLen; offset += buffSize) { - uint32_t crc3 = PREFIX(crc32_z)(crc0, data + offset, buffSize); - uint32_t crc4 = PREFIX(crc32_combine_op)(crc1, crc3, op); - crc1 = PREFIX(crc32_z)(crc1, data + offset, buffSize); - assert(crc1 == crc4); - } - crc1 = PREFIX(crc32_z)(crc1, data + offset, dataLen % buffSize); - - crc2 = PREFIX(crc32_z)(crc2, data, dataLen); - - assert(crc1 == crc2); - assert(PREFIX(crc32_combine)(crc1, crc2, dataLen) == - PREFIX(crc32_combine)(crc1, crc1, dataLen)); - - /* Fast CRC32 combine. */ - PREFIX(crc32_combine_gen)(op, dataLen); - assert(PREFIX(crc32_combine_op)(crc1, crc2, op) == - PREFIX(crc32_combine_op)(crc2, crc1, op)); - assert(PREFIX(crc32_combine)(crc1, crc2, dataLen) == - PREFIX(crc32_combine_op)(crc2, crc1, op)); - - /* Adler32 */ - for (offset = 0; offset + buffSize <= dataLen; offset += buffSize) - adler1 = PREFIX(adler32_z)(adler1, data + offset, buffSize); - adler1 = PREFIX(adler32_z)(adler1, data + offset, dataLen % buffSize); - - adler2 = PREFIX(adler32_z)(adler2, data, dataLen); - - assert(adler1 == adler2); - assert(PREFIX(adler32_combine)(adler1, adler2, dataLen) == - PREFIX(adler32_combine)(adler1, adler1, dataLen)); - - /* This function must return 0. */ - return 0; } diff --git a/libs/zlibng/test/fuzz/compress_fuzzer.c b/libs/zlibng/test/fuzz/compress_fuzzer.c index e2ccf7177..9712e882a 100644 --- a/libs/zlibng/test/fuzz/compress_fuzzer.c +++ b/libs/zlibng/test/fuzz/compress_fuzzer.c @@ -16,72 +16,72 @@ static const uint8_t *data; static size_t dataLen; -static void check_compress_level(uint8_t *compr, size_t comprLen, - uint8_t *uncompr, size_t uncomprLen, +static void check_compress_level(uint8_t *compr, z_size_t comprLen, + uint8_t *uncompr, z_size_t uncomprLen, int level) { - PREFIX(compress2)(compr, &comprLen, data, dataLen, level); - PREFIX(uncompress)(uncompr, &uncomprLen, compr, comprLen); + PREFIX(compress2)(compr, &comprLen, data, dataLen, level); + PREFIX(uncompress)(uncompr, &uncomprLen, compr, comprLen); - /* Make sure compress + uncompress gives back the input data. */ - assert(dataLen == uncomprLen); - assert(0 == memcmp(data, uncompr, dataLen)); + /* Make sure compress + uncompress gives back the input data. */ + assert(dataLen == uncomprLen); + assert(0 == memcmp(data, uncompr, dataLen)); } #define put_byte(s, i, c) {s[i] = (unsigned char)(c);} static void write_zlib_header(uint8_t *s) { - unsigned level_flags = 0; /* compression level (0..3) */ - unsigned w_bits = 8; /* window size log2(w_size) (8..16) */ - unsigned int header = (Z_DEFLATED + ((w_bits-8)<<4)) << 8; - header |= (level_flags << 6); + unsigned level_flags = 0; /* compression level (0..3) */ + unsigned w_bits = 8; /* window size log2(w_size) (8..16) */ + unsigned int header = (Z_DEFLATED + ((w_bits-8)<<4)) << 8; + header |= (level_flags << 6); - header += 31 - (header % 31); + header += 31 - (header % 31); - /* s is guaranteed to be longer than 2 bytes. */ - put_byte(s, 0, (unsigned char)(header >> 8)); - put_byte(s, 1, (unsigned char)(header & 0xff)); + /* s is guaranteed to be longer than 2 bytes. */ + put_byte(s, 0, (header >> 8)); + put_byte(s, 1, (header & 0xff)); } static void check_decompress(uint8_t *compr, size_t comprLen) { - /* We need to write a valid zlib header of size two bytes. Copy the input data - in a larger buffer. Do not modify the input data to avoid libFuzzer error: - fuzz target overwrites its const input. */ - size_t copyLen = dataLen + 2; - uint8_t *copy = (uint8_t *)malloc(copyLen); - memcpy(copy + 2, data, dataLen); - write_zlib_header(copy); + /* We need to write a valid zlib header of size two bytes. Copy the input data + in a larger buffer. Do not modify the input data to avoid libFuzzer error: + fuzz target overwrites its const input. */ + size_t copyLen = dataLen + 2; + uint8_t *copy = (uint8_t *)malloc(copyLen); + memcpy(copy + 2, data, dataLen); + write_zlib_header(copy); - PREFIX(uncompress)(compr, &comprLen, copy, copyLen); - free(copy); + PREFIX(uncompress)(compr, &comprLen, copy, copyLen); + free(copy); } int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size) { - /* compressBound does not provide enough space for low compression levels. */ - size_t comprLen = 100 + 2 * PREFIX(compressBound)(size); - size_t uncomprLen = size; - uint8_t *compr, *uncompr; + /* compressBound does not provide enough space for low compression levels. */ + z_size_t comprLen = 100 + 2 * PREFIX(compressBound)(size); + z_size_t uncomprLen = (z_size_t)size; + uint8_t *compr, *uncompr; - /* Discard inputs larger than 1Mb. */ - static size_t kMaxSize = 1024 * 1024; + /* Discard inputs larger than 1Mb. */ + static size_t kMaxSize = 1024 * 1024; - if (size < 1 || size > kMaxSize) + if (size < 1 || size > kMaxSize) + return 0; + + data = d; + dataLen = size; + compr = (uint8_t *)calloc(1, comprLen); + uncompr = (uint8_t *)calloc(1, uncomprLen); + + check_compress_level(compr, comprLen, uncompr, uncomprLen, 1); + check_compress_level(compr, comprLen, uncompr, uncomprLen, 3); + check_compress_level(compr, comprLen, uncompr, uncomprLen, 6); + check_compress_level(compr, comprLen, uncompr, uncomprLen, 7); + + check_decompress(compr, comprLen); + + free(compr); + free(uncompr); + + /* This function must return 0. */ return 0; - - data = d; - dataLen = size; - compr = (uint8_t *)calloc(1, comprLen); - uncompr = (uint8_t *)calloc(1, uncomprLen); - - check_compress_level(compr, comprLen, uncompr, uncomprLen, 1); - check_compress_level(compr, comprLen, uncompr, uncomprLen, 3); - check_compress_level(compr, comprLen, uncompr, uncomprLen, 6); - check_compress_level(compr, comprLen, uncompr, uncomprLen, 7); - - check_decompress(compr, comprLen); - - free(compr); - free(uncompr); - - /* This function must return 0. */ - return 0; } diff --git a/libs/zlibng/test/fuzz/example_dict_fuzzer.c b/libs/zlibng/test/fuzz/example_dict_fuzzer.c index b19101173..027c9a806 100644 --- a/libs/zlibng/test/fuzz/example_dict_fuzzer.c +++ b/libs/zlibng/test/fuzz/example_dict_fuzzer.c @@ -24,14 +24,13 @@ static const uint8_t *data; static size_t dataLen; static alloc_func zalloc = NULL; static free_func zfree = NULL; -static size_t dictionaryLen = 0; +static unsigned int dictionaryLen = 0; static unsigned long dictId; /* Adler32 value of the dictionary */ /* =========================================================================== * Test deflate() with preset dictionary */ -void test_dict_deflate(unsigned char **compr, size_t *comprLen) -{ +void test_dict_deflate(unsigned char **compr, size_t *comprLen) { PREFIX3(stream) c_stream; /* compression stream */ int err; int level = data[0] % 11 - 1; /* [-1..9] @@ -58,7 +57,7 @@ void test_dict_deflate(unsigned char **compr, size_t *comprLen) /* deflate would fail for no-compression or for speed levels. */ if (level == 0 || level == 1) - level = -1; + level = -1; c_stream.zalloc = zalloc; c_stream.zfree = zfree; @@ -73,15 +72,15 @@ void test_dict_deflate(unsigned char **compr, size_t *comprLen) CHECK_ERR(err, "deflateSetDictionary"); /* deflateBound does not provide enough space for low compression levels. */ - *comprLen = 100 + 2 * PREFIX(deflateBound)(&c_stream, dataLen); + *comprLen = 100 + 2 * PREFIX(deflateBound)(&c_stream, (unsigned long)dataLen); *compr = (uint8_t *)calloc(1, *comprLen); dictId = c_stream.adler; c_stream.next_out = *compr; c_stream.avail_out = (unsigned int)(*comprLen); - c_stream.next_in = data; - c_stream.avail_in = dataLen; + c_stream.next_in = (z_const unsigned char *)data; + c_stream.avail_in = (uint32_t)dataLen; err = PREFIX(deflate)(&c_stream, Z_FINISH); if (err != Z_STREAM_END) { @@ -96,75 +95,75 @@ void test_dict_deflate(unsigned char **compr, size_t *comprLen) * Test inflate() with a preset dictionary */ void test_dict_inflate(unsigned char *compr, size_t comprLen) { - int err; - PREFIX3(stream) d_stream; /* decompression stream */ - unsigned char *uncompr; + int err; + PREFIX3(stream) d_stream; /* decompression stream */ + unsigned char *uncompr; - d_stream.zalloc = zalloc; - d_stream.zfree = zfree; - d_stream.opaque = (void *)0; + d_stream.zalloc = zalloc; + d_stream.zfree = zfree; + d_stream.opaque = (void *)0; - d_stream.next_in = compr; - d_stream.avail_in = (unsigned int)comprLen; + d_stream.next_in = compr; + d_stream.avail_in = (unsigned int)comprLen; - err = PREFIX(inflateInit)(&d_stream); - CHECK_ERR(err, "inflateInit"); + err = PREFIX(inflateInit)(&d_stream); + CHECK_ERR(err, "inflateInit"); - uncompr = (uint8_t *)calloc(1, dataLen); - d_stream.next_out = uncompr; - d_stream.avail_out = (unsigned int)dataLen; + uncompr = (uint8_t *)calloc(1, dataLen); + d_stream.next_out = uncompr; + d_stream.avail_out = (unsigned int)dataLen; - for (;;) { - err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH); - if (err == Z_STREAM_END) - break; - if (err == Z_NEED_DICT) { - if (d_stream.adler != dictId) { - fprintf(stderr, "unexpected dictionary"); - exit(1); - } - err = PREFIX(inflateSetDictionary)( - &d_stream, (const unsigned char *)data, dictionaryLen); + for (;;) { + err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH); + if (err == Z_STREAM_END) + break; + if (err == Z_NEED_DICT) { + if (d_stream.adler != dictId) { + fprintf(stderr, "unexpected dictionary"); + exit(1); + } + err = PREFIX(inflateSetDictionary)( + &d_stream, (const unsigned char *)data, dictionaryLen); + } + CHECK_ERR(err, "inflate with dict"); } - CHECK_ERR(err, "inflate with dict"); - } - err = PREFIX(inflateEnd)(&d_stream); - CHECK_ERR(err, "inflateEnd"); + err = PREFIX(inflateEnd)(&d_stream); + CHECK_ERR(err, "inflateEnd"); - if (memcmp(uncompr, data, dataLen)) { - fprintf(stderr, "bad inflate with dict\n"); - exit(1); - } + if (memcmp(uncompr, data, dataLen)) { + fprintf(stderr, "bad inflate with dict\n"); + exit(1); + } - free(uncompr); + free(uncompr); } int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size) { - size_t comprLen = 0; - uint8_t *compr; + size_t comprLen = 0; + uint8_t *compr; - /* Discard inputs larger than 100Kb. */ - static size_t kMaxSize = 100 * 1024; + /* Discard inputs larger than 100Kb. */ + static size_t kMaxSize = 100 * 1024; - if (size < 1 || size > kMaxSize) + if (size < 1 || size > kMaxSize) + return 0; + + data = d; + dataLen = size; + + /* Set up the contents of the dictionary. The size of the dictionary is + intentionally selected to be of unusual size. To help cover more corner + cases, the size of the dictionary is read from the input data. */ + dictionaryLen = data[0]; + if (dictionaryLen > dataLen) + dictionaryLen = (unsigned int)dataLen; + + test_dict_deflate(&compr, &comprLen); + test_dict_inflate(compr, comprLen); + + free(compr); + + /* This function must return 0. */ return 0; - - data = d; - dataLen = size; - - /* Set up the contents of the dictionary. The size of the dictionary is - intentionally selected to be of unusual size. To help cover more corner - cases, the size of the dictionary is read from the input data. */ - dictionaryLen = data[0]; - if (dictionaryLen > dataLen) - dictionaryLen = dataLen; - - test_dict_deflate(&compr, &comprLen); - test_dict_inflate(compr, comprLen); - - free(compr); - - /* This function must return 0. */ - return 0; } diff --git a/libs/zlibng/test/fuzz/example_flush_fuzzer.c b/libs/zlibng/test/fuzz/example_flush_fuzzer.c index f9f2d3646..81ec7e36d 100644 --- a/libs/zlibng/test/fuzz/example_flush_fuzzer.c +++ b/libs/zlibng/test/fuzz/example_flush_fuzzer.c @@ -29,98 +29,96 @@ static free_func zfree = NULL; * Test deflate() with full flush */ void test_flush(unsigned char *compr, z_size_t *comprLen) { - PREFIX3(stream) c_stream; /* compression stream */ - int err; - unsigned int len = dataLen; + PREFIX3(stream) c_stream; /* compression stream */ + int err; + unsigned int len = (unsigned int)dataLen; - c_stream.zalloc = zalloc; - c_stream.zfree = zfree; - c_stream.opaque = (void *)0; + c_stream.zalloc = zalloc; + c_stream.zfree = zfree; + c_stream.opaque = (void *)0; - err = PREFIX(deflateInit)(&c_stream, Z_DEFAULT_COMPRESSION); - CHECK_ERR(err, "deflateInit"); + err = PREFIX(deflateInit)(&c_stream, Z_DEFAULT_COMPRESSION); + CHECK_ERR(err, "deflateInit"); - c_stream.next_in = (const unsigned char *)data; - c_stream.next_out = compr; - c_stream.avail_in = 3; - c_stream.avail_out = (unsigned int)*comprLen; - err = PREFIX(deflate)(&c_stream, Z_FULL_FLUSH); - CHECK_ERR(err, "deflate flush 1"); + c_stream.next_in = (z_const unsigned char *)data; + c_stream.next_out = compr; + c_stream.avail_in = 3; + c_stream.avail_out = (unsigned int)*comprLen; + err = PREFIX(deflate)(&c_stream, Z_FULL_FLUSH); + CHECK_ERR(err, "deflate flush 1"); - compr[3]++; /* force an error in first compressed block */ - c_stream.avail_in = len - 3; + compr[3]++; /* force an error in first compressed block */ + c_stream.avail_in = len - 3; - err = PREFIX(deflate)(&c_stream, Z_FINISH); - if (err != Z_STREAM_END) { - CHECK_ERR(err, "deflate flush 2"); - } - err = PREFIX(deflateEnd)(&c_stream); - CHECK_ERR(err, "deflateEnd"); + err = PREFIX(deflate)(&c_stream, Z_FINISH); + if (err != Z_STREAM_END) { + CHECK_ERR(err, "deflate flush 2"); + } + err = PREFIX(deflateEnd)(&c_stream); + CHECK_ERR(err, "deflateEnd"); - *comprLen = (z_size_t)c_stream.total_out; + *comprLen = (z_size_t)c_stream.total_out; } /* =========================================================================== * Test inflateSync() */ -void test_sync(unsigned char *compr, size_t comprLen, unsigned char *uncompr, - size_t uncomprLen) { - int err; - PREFIX3(stream) d_stream; /* decompression stream */ +void test_sync(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) { + int err; + PREFIX3(stream) d_stream; /* decompression stream */ - d_stream.zalloc = zalloc; - d_stream.zfree = zfree; - d_stream.opaque = (void *)0; + d_stream.zalloc = zalloc; + d_stream.zfree = zfree; + d_stream.opaque = (void *)0; - d_stream.next_in = compr; - d_stream.avail_in = 2; /* just read the zlib header */ + d_stream.next_in = compr; + d_stream.avail_in = 2; /* just read the zlib header */ - err = PREFIX(inflateInit)(&d_stream); - CHECK_ERR(err, "inflateInit"); + err = PREFIX(inflateInit)(&d_stream); + CHECK_ERR(err, "inflateInit"); - d_stream.next_out = uncompr; - d_stream.avail_out = (unsigned int)uncomprLen; + d_stream.next_out = uncompr; + d_stream.avail_out = (unsigned int)uncomprLen; - err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH); - CHECK_ERR(err, "inflate"); + err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH); + CHECK_ERR(err, "inflate"); - d_stream.avail_in = (unsigned int)comprLen - 2; /* read all compressed data */ - err = PREFIX(inflateSync)(&d_stream); /* but skip the damaged part */ - CHECK_ERR(err, "inflateSync"); + d_stream.avail_in = (unsigned int)comprLen - 2; /* read all compressed data */ + err = PREFIX(inflateSync)(&d_stream); /* but skip the damaged part */ + CHECK_ERR(err, "inflateSync"); - err = PREFIX(inflate)(&d_stream, Z_FINISH); - if (err != Z_DATA_ERROR) { - fprintf(stderr, "inflate should report DATA_ERROR\n"); - /* Because of incorrect adler32 */ - exit(1); - } - err = PREFIX(inflateEnd)(&d_stream); - CHECK_ERR(err, "inflateEnd"); + err = PREFIX(inflate)(&d_stream, Z_FINISH); + if (err != Z_STREAM_END) { + fprintf(stderr, "inflate should report Z_STREAM_END\n"); + exit(1); + } + err = PREFIX(inflateEnd)(&d_stream); + CHECK_ERR(err, "inflateEnd"); } int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size) { - size_t comprLen = 100 + 2 * PREFIX(compressBound)(size); - size_t uncomprLen = size; - uint8_t *compr, *uncompr; + z_size_t comprLen = 100 + 2 * PREFIX(compressBound)(size); + z_size_t uncomprLen = (z_size_t)size; + uint8_t *compr, *uncompr; - /* Discard inputs larger than 1Mb. */ - static size_t kMaxSize = 1024 * 1024; + /* Discard inputs larger than 1Mb. */ + static size_t kMaxSize = 1024 * 1024; - // This test requires at least 3 bytes of input data. - if (size <= 3 || size > kMaxSize) + // This test requires at least 3 bytes of input data. + if (size <= 3 || size > kMaxSize) + return 0; + + data = d; + dataLen = size; + compr = (uint8_t *)calloc(1, comprLen); + uncompr = (uint8_t *)calloc(1, uncomprLen); + + test_flush(compr, &comprLen); + test_sync(compr, comprLen, uncompr, uncomprLen); + + free(compr); + free(uncompr); + + /* This function must return 0. */ return 0; - - data = d; - dataLen = size; - compr = (uint8_t *)calloc(1, comprLen); - uncompr = (uint8_t *)calloc(1, uncomprLen); - - test_flush(compr, &comprLen); - test_sync(compr, comprLen, uncompr, uncomprLen); - - free(compr); - free(uncompr); - - /* This function must return 0. */ - return 0; } diff --git a/libs/zlibng/test/fuzz/example_large_fuzzer.c b/libs/zlibng/test/fuzz/example_large_fuzzer.c index 1e8fedc22..bd27a84f1 100644 --- a/libs/zlibng/test/fuzz/example_large_fuzzer.c +++ b/libs/zlibng/test/fuzz/example_large_fuzzer.c @@ -29,115 +29,113 @@ static unsigned int diff; /* =========================================================================== * Test deflate() with large buffers and dynamic change of compression level */ -void test_large_deflate(unsigned char *compr, size_t comprLen, - unsigned char *uncompr, size_t uncomprLen) { - PREFIX3(stream) c_stream; /* compression stream */ - int err; +void test_large_deflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) { + PREFIX3(stream) c_stream; /* compression stream */ + int err; - c_stream.zalloc = zalloc; - c_stream.zfree = zfree; - c_stream.opaque = (void *)0; + c_stream.zalloc = zalloc; + c_stream.zfree = zfree; + c_stream.opaque = (void *)0; - err = PREFIX(deflateInit)(&c_stream, Z_BEST_COMPRESSION); - CHECK_ERR(err, "deflateInit"); + err = PREFIX(deflateInit)(&c_stream, Z_BEST_COMPRESSION); + CHECK_ERR(err, "deflateInit"); - c_stream.next_out = compr; - c_stream.avail_out = (unsigned int)comprLen; + c_stream.next_out = compr; + c_stream.avail_out = (unsigned int)comprLen; - /* At this point, uncompr is still mostly zeroes, so it should compress - * very well: - */ - c_stream.next_in = uncompr; - c_stream.avail_in = (unsigned int)uncomprLen; - err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH); - CHECK_ERR(err, "deflate large 1"); - if (c_stream.avail_in != 0) { - fprintf(stderr, "deflate not greedy\n"); - exit(1); - } + /* At this point, uncompr is still mostly zeroes, so it should compress + * very well: + */ + c_stream.next_in = uncompr; + c_stream.avail_in = (unsigned int)uncomprLen; + err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH); + CHECK_ERR(err, "deflate large 1"); + if (c_stream.avail_in != 0) { + fprintf(stderr, "deflate not greedy\n"); + exit(1); + } - /* Feed in already compressed data and switch to no compression: */ - PREFIX(deflateParams)(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY); - c_stream.next_in = compr; - diff = (unsigned int)(c_stream.next_out - compr); - c_stream.avail_in = diff; - err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH); - CHECK_ERR(err, "deflate large 2"); + /* Feed in already compressed data and switch to no compression: */ + PREFIX(deflateParams)(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY); + c_stream.next_in = compr; + diff = (unsigned int)(c_stream.next_out - compr); + c_stream.avail_in = diff; + err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH); + CHECK_ERR(err, "deflate large 2"); - /* Switch back to compressing mode: */ - PREFIX(deflateParams)(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED); - c_stream.next_in = uncompr; - c_stream.avail_in = (unsigned int)uncomprLen; - err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH); - CHECK_ERR(err, "deflate large 3"); + /* Switch back to compressing mode: */ + PREFIX(deflateParams)(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED); + c_stream.next_in = uncompr; + c_stream.avail_in = (unsigned int)uncomprLen; + err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH); + CHECK_ERR(err, "deflate large 3"); - err = PREFIX(deflate)(&c_stream, Z_FINISH); - if (err != Z_STREAM_END) { - fprintf(stderr, "deflate large should report Z_STREAM_END\n"); - exit(1); - } - err = PREFIX(deflateEnd)(&c_stream); - CHECK_ERR(err, "deflateEnd"); + err = PREFIX(deflate)(&c_stream, Z_FINISH); + if (err != Z_STREAM_END) { + fprintf(stderr, "deflate large should report Z_STREAM_END\n"); + exit(1); + } + err = PREFIX(deflateEnd)(&c_stream); + CHECK_ERR(err, "deflateEnd"); } /* =========================================================================== * Test inflate() with large buffers */ -void test_large_inflate(unsigned char *compr, size_t comprLen, - unsigned char *uncompr, size_t uncomprLen) { - int err; - PREFIX3(stream) d_stream; /* decompression stream */ +void test_large_inflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) { + int err; + PREFIX3(stream) d_stream; /* decompression stream */ - d_stream.zalloc = zalloc; - d_stream.zfree = zfree; - d_stream.opaque = (void *)0; + d_stream.zalloc = zalloc; + d_stream.zfree = zfree; + d_stream.opaque = (void *)0; - d_stream.next_in = compr; - d_stream.avail_in = (unsigned int)comprLen; + d_stream.next_in = compr; + d_stream.avail_in = (unsigned int)comprLen; - err = PREFIX(inflateInit)(&d_stream); - CHECK_ERR(err, "inflateInit"); + err = PREFIX(inflateInit)(&d_stream); + CHECK_ERR(err, "inflateInit"); - for (;;) { - d_stream.next_out = uncompr; /* discard the output */ - d_stream.avail_out = (unsigned int)uncomprLen; - err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH); - if (err == Z_STREAM_END) - break; - CHECK_ERR(err, "large inflate"); - } + for (;;) { + d_stream.next_out = uncompr; /* discard the output */ + d_stream.avail_out = (unsigned int)uncomprLen; + err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH); + if (err == Z_STREAM_END) + break; + CHECK_ERR(err, "large inflate"); + } - err = PREFIX(inflateEnd)(&d_stream); - CHECK_ERR(err, "inflateEnd"); + err = PREFIX(inflateEnd)(&d_stream); + CHECK_ERR(err, "inflateEnd"); - if (d_stream.total_out != 2 * uncomprLen + diff) { - fprintf(stderr, "bad large inflate: %zu\n", d_stream.total_out); - exit(1); - } + if (d_stream.total_out != 2 * uncomprLen + diff) { + fprintf(stderr, "bad large inflate: %" PRIu64 "\n", (uint64_t)d_stream.total_out); + exit(1); + } } int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size) { - size_t comprLen = 100 + 3 * size; - size_t uncomprLen = comprLen; - uint8_t *compr, *uncompr; + size_t comprLen = 100 + 3 * size; + size_t uncomprLen = comprLen; + uint8_t *compr, *uncompr; - /* Discard inputs larger than 512Kb. */ - static size_t kMaxSize = 512 * 1024; + /* Discard inputs larger than 512Kb. */ + static size_t kMaxSize = 512 * 1024; - if (size < 1 || size > kMaxSize) + if (size < 1 || size > kMaxSize) + return 0; + + data = d; + dataLen = size; + compr = (uint8_t *)calloc(1, comprLen); + uncompr = (uint8_t *)calloc(1, uncomprLen); + + test_large_deflate(compr, comprLen, uncompr, uncomprLen); + test_large_inflate(compr, comprLen, uncompr, uncomprLen); + + free(compr); + free(uncompr); + + /* This function must return 0. */ return 0; - - data = d; - dataLen = size; - compr = (uint8_t *)calloc(1, comprLen); - uncompr = (uint8_t *)calloc(1, uncomprLen); - - test_large_deflate(compr, comprLen, uncompr, uncomprLen); - test_large_inflate(compr, comprLen, uncompr, uncomprLen); - - free(compr); - free(uncompr); - - /* This function must return 0. */ - return 0; } diff --git a/libs/zlibng/test/fuzz/example_small_fuzzer.c b/libs/zlibng/test/fuzz/example_small_fuzzer.c index d965c2db8..d02a812de 100644 --- a/libs/zlibng/test/fuzz/example_small_fuzzer.c +++ b/libs/zlibng/test/fuzz/example_small_fuzzer.c @@ -29,96 +29,95 @@ static free_func zfree = NULL; * Test deflate() with small buffers */ void test_deflate(unsigned char *compr, size_t comprLen) { - PREFIX3(stream) c_stream; /* compression stream */ - int err; - unsigned long len = dataLen; + PREFIX3(stream) c_stream; /* compression stream */ + int err; + unsigned long len = (unsigned long)dataLen; - c_stream.zalloc = zalloc; - c_stream.zfree = zfree; - c_stream.opaque = (void *)0; + c_stream.zalloc = zalloc; + c_stream.zfree = zfree; + c_stream.opaque = (void *)0; - err = PREFIX(deflateInit)(&c_stream, Z_DEFAULT_COMPRESSION); - CHECK_ERR(err, "deflateInit"); + err = PREFIX(deflateInit)(&c_stream, Z_DEFAULT_COMPRESSION); + CHECK_ERR(err, "deflateInit"); - c_stream.next_in = (const unsigned char *)data; - c_stream.next_out = compr; + c_stream.next_in = (z_const unsigned char *)data; + c_stream.next_out = compr; - while (c_stream.total_in != len && c_stream.total_out < comprLen) { - c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */ - err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH); - CHECK_ERR(err, "deflate small 1"); - } - /* Finish the stream, still forcing small buffers: */ - for (;;) { - c_stream.avail_out = 1; - err = PREFIX(deflate)(&c_stream, Z_FINISH); - if (err == Z_STREAM_END) - break; - CHECK_ERR(err, "deflate small 2"); - } + while (c_stream.total_in != len && c_stream.total_out < comprLen) { + c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */ + err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH); + CHECK_ERR(err, "deflate small 1"); + } + /* Finish the stream, still forcing small buffers: */ + for (;;) { + c_stream.avail_out = 1; + err = PREFIX(deflate)(&c_stream, Z_FINISH); + if (err == Z_STREAM_END) + break; + CHECK_ERR(err, "deflate small 2"); + } - err = PREFIX(deflateEnd)(&c_stream); - CHECK_ERR(err, "deflateEnd"); + err = PREFIX(deflateEnd)(&c_stream); + CHECK_ERR(err, "deflateEnd"); } /* =========================================================================== * Test inflate() with small buffers */ -void test_inflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, - size_t uncomprLen) { - int err; - PREFIX3(stream) d_stream; /* decompression stream */ +void test_inflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) { + int err; + PREFIX3(stream) d_stream; /* decompression stream */ - d_stream.zalloc = zalloc; - d_stream.zfree = zfree; - d_stream.opaque = (void *)0; + d_stream.zalloc = zalloc; + d_stream.zfree = zfree; + d_stream.opaque = (void *)0; - d_stream.next_in = compr; - d_stream.avail_in = 0; - d_stream.next_out = uncompr; + d_stream.next_in = compr; + d_stream.avail_in = 0; + d_stream.next_out = uncompr; - err = PREFIX(inflateInit)(&d_stream); - CHECK_ERR(err, "inflateInit"); + err = PREFIX(inflateInit)(&d_stream); + CHECK_ERR(err, "inflateInit"); - while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) { - d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */ - err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH); - if (err == Z_STREAM_END) - break; - CHECK_ERR(err, "inflate"); - } + while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) { + d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */ + err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH); + if (err == Z_STREAM_END) + break; + CHECK_ERR(err, "inflate"); + } - err = PREFIX(inflateEnd)(&d_stream); - CHECK_ERR(err, "inflateEnd"); + err = PREFIX(inflateEnd)(&d_stream); + CHECK_ERR(err, "inflateEnd"); - if (memcmp(uncompr, data, dataLen)) { - fprintf(stderr, "bad inflate\n"); - exit(1); - } + if (memcmp(uncompr, data, dataLen)) { + fprintf(stderr, "bad inflate\n"); + exit(1); + } } int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size) { - size_t comprLen = PREFIX(compressBound)(size); - size_t uncomprLen = size; - uint8_t *compr, *uncompr; + size_t comprLen = PREFIX(compressBound)(size); + size_t uncomprLen = size; + uint8_t *compr, *uncompr; - /* Discard inputs larger than 1Mb. */ - static size_t kMaxSize = 1024 * 1024; + /* Discard inputs larger than 1Mb. */ + static size_t kMaxSize = 1024 * 1024; - if (size < 1 || size > kMaxSize) + if (size < 1 || size > kMaxSize) + return 0; + + data = d; + dataLen = size; + compr = (uint8_t *)calloc(1, comprLen); + uncompr = (uint8_t *)calloc(1, uncomprLen); + + test_deflate(compr, comprLen); + test_inflate(compr, comprLen, uncompr, uncomprLen); + + free(compr); + free(uncompr); + + /* This function must return 0. */ return 0; - - data = d; - dataLen = size; - compr = (uint8_t *)calloc(1, comprLen); - uncompr = (uint8_t *)calloc(1, uncomprLen); - - test_deflate(compr, comprLen); - test_inflate(compr, comprLen, uncompr, uncomprLen); - - free(compr); - free(uncompr); - - /* This function must return 0. */ - return 0; } diff --git a/libs/zlibng/test/fuzz/minigzip_fuzzer.c b/libs/zlibng/test/fuzz/minigzip_fuzzer.c index d0c35571f..1f19126f4 100644 --- a/libs/zlibng/test/fuzz/minigzip_fuzzer.c +++ b/libs/zlibng/test/fuzz/minigzip_fuzzer.c @@ -12,13 +12,14 @@ * real thing. */ -/* @(#) $Id$ */ +#define _POSIX_SOURCE 1 /* This file needs POSIX for fileno(). */ +#define _POSIX_C_SOURCE 200112 /* For snprintf(). */ #include "zbuild.h" #ifdef ZLIB_COMPAT -# include "zlib.h" +# include "zlib.h" #else -# include "zlib-ng.h" +# include "zlib-ng.h" #endif #include #include @@ -35,7 +36,7 @@ # include #endif -#if defined(WIN32) || defined(__CYGWIN__) +#if defined(_WIN32) || defined(__CYGWIN__) # include # include # define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY) @@ -48,8 +49,8 @@ #endif #if !defined(Z_HAVE_UNISTD_H) && !defined(_LARGEFILE64_SOURCE) -#ifndef WIN32 /* unlink already in stdio.h for WIN32 */ - extern int unlink (const char *); +#ifndef _WIN32 /* unlink already in stdio.h for Win32 */ +extern int unlink (const char *); #endif #endif @@ -62,23 +63,22 @@ #define BUFLENW (BUFLEN * 3) /* write buffer size */ #define MAX_NAME_LEN 1024 -static char *prog; +static const char *prog = "minigzip_fuzzer"; void error (const char *msg); -void gz_compress (FILE *in, gzFile out); +void gz_compress (FILE *in, gzFile out); #ifdef USE_MMAP -int gz_compress_mmap (FILE *in, gzFile out); +int gz_compress_mmap (FILE *in, gzFile out); #endif -void gz_uncompress (gzFile in, FILE *out); -void file_compress (char *file, char *mode); -void file_uncompress (char *file); +void gz_uncompress (gzFile in, FILE *out); +void file_compress (char *file, char *mode); +void file_uncompress (char *file); int main (int argc, char *argv[]); /* =========================================================================== * Display error message and exit */ -void error(const char *msg) -{ +void error(const char *msg) { fprintf(stderr, "%s: %s\n", prog, msg); exit(1); } @@ -87,8 +87,7 @@ void error(const char *msg) * Compress input to output then close both files. */ -void gz_compress(FILE *in, gzFile out) -{ +void gz_compress(FILE *in, gzFile out) { char buf[BUFLEN]; int len; int err; @@ -121,12 +120,11 @@ void gz_compress(FILE *in, gzFile out) /* Try compressing the input file at once using mmap. Return Z_OK if * if success, Z_ERRNO otherwise. */ -int gz_compress_mmap(FILE *in, gzFile out) -{ +int gz_compress_mmap(FILE *in, gzFile out) { int len; int err; int ifd = fileno(in); - caddr_t buf; /* mmap'ed buffer for the entire input file */ + char *buf; /* mmap'ed buffer for the entire input file */ off_t buf_len; /* length of the input file */ struct stat sb; @@ -136,8 +134,8 @@ int gz_compress_mmap(FILE *in, gzFile out) if (buf_len <= 0) return Z_ERRNO; /* Now do the actual mmap: */ - buf = mmap((caddr_t) 0, buf_len, PROT_READ, MAP_SHARED, ifd, (off_t)0); - if (buf == (caddr_t)(-1)) return Z_ERRNO; + buf = mmap((void *)0, buf_len, PROT_READ, MAP_SHARED, ifd, (off_t)0); + if (buf == (char *)(-1)) return Z_ERRNO; /* Compress the whole file at once: */ len = PREFIX(gzwrite)(out, (char *)buf, (unsigned)buf_len); @@ -154,8 +152,7 @@ int gz_compress_mmap(FILE *in, gzFile out) /* =========================================================================== * Uncompress input to output then close both files. */ -void gz_uncompress(gzFile in, FILE *out) -{ +void gz_uncompress(gzFile in, FILE *out) { char buf[BUFLENW]; int len; int err; @@ -179,10 +176,9 @@ void gz_uncompress(gzFile in, FILE *out) * Compress the given file: create a corresponding .gz file and remove the * original. */ -void file_compress(char *file, char *mode) -{ +void file_compress(char *file, char *mode) { char outfile[MAX_NAME_LEN]; - FILE *in; + FILE *in; gzFile out; if (strlen(file) + strlen(GZ_SUFFIX) >= sizeof(outfile)) { @@ -211,11 +207,10 @@ void file_compress(char *file, char *mode) /* =========================================================================== * Uncompress the given file and remove the original. */ -void file_uncompress(char *file) -{ +void file_uncompress(char *file) { char buf[MAX_NAME_LEN]; char *infile, *outfile; - FILE *out; + FILE *out; gzFile in; size_t len = strlen(file); @@ -252,75 +247,75 @@ void file_uncompress(char *file) } int LLVMFuzzerTestOneInput(const uint8_t *data, size_t dataLen) { - char *inFileName = "/tmp/minigzip_fuzzer.out"; - char *outFileName = "/tmp/minigzip_fuzzer.out.gz"; - char outmode[20]; - FILE *in; - char buf[BUFLEN]; - uint32_t offset = 0; + char *inFileName = "minigzip_fuzzer.out"; + char *outFileName = "minigzip_fuzzer.out.gz"; + char outmode[20]; + FILE *in; + char buf[BUFLEN]; + uint32_t offset = 0; - /* Discard inputs larger than 1Mb. */ - static size_t kMaxSize = 1024 * 1024; - if (dataLen < 1 || dataLen > kMaxSize) - return 0; + /* Discard inputs larger than 1Mb. */ + static size_t kMaxSize = 1024 * 1024; + if (dataLen < 1 || dataLen > kMaxSize) + return 0; - in = fopen(inFileName, "w"); - if (fwrite(data, 1, (unsigned)dataLen, in) != dataLen) - error("failed fwrite"); - if (fclose(in)) - error("failed fclose"); + in = fopen(inFileName, "wb"); + if (fwrite(data, 1, (unsigned)dataLen, in) != dataLen) + error("failed fwrite"); + if (fclose(in)) + error("failed fclose"); - memset(outmode, 0, sizeof(outmode)); - snprintf(outmode, sizeof(outmode), "%s", "wb"); + memset(outmode, 0, sizeof(outmode)); + snprintf(outmode, sizeof(outmode), "%s", "wb"); - /* Compression level: [0..9]. */ - outmode[2] = data[0] % 10; + /* Compression level: [0..9]. */ + outmode[2] = data[0] % 10; - switch (data[0] % 4) { - default: - case 0: - outmode[3] = 0; - break; - case 1: - /* compress with Z_FILTERED */ - outmode[3] = 'f'; - break; - case 2: - /* compress with Z_HUFFMAN_ONLY */ - outmode[3] = 'h'; - break; - case 3: - /* compress with Z_RLE */ - outmode[3] = 'R'; - break; - } - - file_compress(inFileName, outmode); - file_uncompress(outFileName); - - /* Check that the uncompressed file matches the input data. */ - in = fopen(inFileName, "rb"); - if (in == NULL) { - perror(inFileName); - exit(1); - } - - memset(buf, 0, sizeof(buf)); - for (;;) { - int len = (int)fread(buf, 1, sizeof(buf), in); - if (ferror(in)) { - perror("fread"); - exit(1); + switch (data[0] % 4) { + default: + case 0: + outmode[3] = 0; + break; + case 1: + /* compress with Z_FILTERED */ + outmode[3] = 'f'; + break; + case 2: + /* compress with Z_HUFFMAN_ONLY */ + outmode[3] = 'h'; + break; + case 3: + /* compress with Z_RLE */ + outmode[3] = 'R'; + break; } - if (len == 0) - break; - assert(0 == memcmp(data + offset, buf, len)); - offset += len; - } - if (fclose(in)) - error("failed fclose"); + file_compress(inFileName, outmode); + file_uncompress(outFileName); - /* This function must return 0. */ - return 0; + /* Check that the uncompressed file matches the input data. */ + in = fopen(inFileName, "rb"); + if (in == NULL) { + perror(inFileName); + exit(1); + } + + memset(buf, 0, sizeof(buf)); + for (;;) { + int len = (int)fread(buf, 1, sizeof(buf), in); + if (ferror(in)) { + perror("fread"); + exit(1); + } + if (len == 0) + break; + assert(0 == memcmp(data + offset, buf, len)); + offset += len; + } + + if (fclose(in)) + error("failed fclose"); + + /* This function must return 0. */ + return 0; } diff --git a/libs/zlibng/test/fuzz/standalone_fuzz_target_runner.c b/libs/zlibng/test/fuzz/standalone_fuzz_target_runner.c index 5a5c75096..a291b4882 100644 --- a/libs/zlibng/test/fuzz/standalone_fuzz_target_runner.c +++ b/libs/zlibng/test/fuzz/standalone_fuzz_target_runner.c @@ -5,31 +5,32 @@ extern int LLVMFuzzerTestOneInput(const unsigned char *data, size_t size); int main(int argc, char **argv) { - int i; - fprintf(stderr, "StandaloneFuzzTargetMain: running %d inputs\n", argc - 1); + int i; + fprintf(stderr, "StandaloneFuzzTargetMain: running %d inputs\n", argc - 1); - for (i = 1; i < argc; i++) { - size_t len, n_read, err; - unsigned char *buf; - FILE *f = fopen(argv[i], "rb+"); - if (!f) { - /* Failed to open this file: it may be a directory. */ - fprintf(stderr, "Skipping: %s\n", argv[i]); - continue; + for (i = 1; i < argc; i++) { + size_t len, n_read, err; + unsigned char *buf; + FILE *f = fopen(argv[i], "rb+"); + if (!f) { + /* Failed to open this file: it may be a directory. */ + fprintf(stderr, "Skipping: %s\n", argv[i]); + continue; + } + fprintf(stderr, "Running: %s %s\n", argv[0], argv[i]); + fseek(f, 0, SEEK_END); + len = ftell(f); + fseek(f, 0, SEEK_SET); + buf = (unsigned char *)malloc(len); + n_read = fread(buf, 1, len, f); + assert(n_read == len); + LLVMFuzzerTestOneInput(buf, len); + free(buf); + err = fclose(f); + assert(err == 0); + (void)err; + fprintf(stderr, "Done: %s: (%d bytes)\n", argv[i], (int)n_read); } - fprintf(stderr, "Running: %s %s\n", argv[0], argv[i]); - fseek(f, 0, SEEK_END); - len = ftell(f); - fseek(f, 0, SEEK_SET); - buf = (unsigned char *)malloc(len); - n_read = fread(buf, 1, len, f); - assert(n_read == len); - LLVMFuzzerTestOneInput(buf, len); - free(buf); - err = fclose(f); - assert(err == 0); - fprintf(stderr, "Done: %s: (%d bytes)\n", argv[i], (int)n_read); - } - return 0; + return 0; } diff --git a/libs/zlibng/test/infcover.c b/libs/zlibng/test/infcover.c index 2b8ff974a..3466b202d 100644 --- a/libs/zlibng/test/infcover.c +++ b/libs/zlibng/test/infcover.c @@ -8,13 +8,20 @@ #include #include #include +#undef NDEBUG #include -#include "zlib.h" +#include +#include /* get definition of internal structure so we can mess with it (see pull()), and so we can call inflate_trees() (see cover5()) */ #define ZLIB_INTERNAL #include "zbuild.h" +#ifdef ZLIB_COMPAT +# include "zlib.h" +#else +# include "zlib-ng.h" +#endif #include "inftrees.h" #include "inflate.h" @@ -28,7 +35,7 @@ They are used as follows: - z_stream strm; + PREFIX3(stream) strm; mem_setup(&strm) initializes the memory tracking and sets the zalloc, zfree, and opaque members of strm to use memory tracking for all zlib operations on strm @@ -67,8 +74,7 @@ struct mem_zone { }; /* memory allocation routine to pass to zlib */ -static void *mem_alloc(void *mem, unsigned count, unsigned size) -{ +static void *mem_alloc(void *mem, unsigned count, unsigned size) { void *ptr; struct mem_item *item; struct mem_zone *zone = mem; @@ -108,8 +114,7 @@ static void *mem_alloc(void *mem, unsigned count, unsigned size) } /* memory free routine to pass to zlib */ -static void mem_free(void *mem, void *ptr) -{ +static void mem_free(void *mem, void *ptr) { struct mem_item *item, *next; struct mem_zone *zone = mem; @@ -154,8 +159,7 @@ static void mem_free(void *mem, void *ptr) /* set up a controlled memory allocation space for monitoring, set the stream parameters to the controlled routines, with opaque pointing to the space */ -static void mem_setup(z_stream *strm) -{ +static void mem_setup(PREFIX3(stream) *strm) { struct mem_zone *zone; zone = malloc(sizeof(struct mem_zone)); @@ -172,32 +176,28 @@ static void mem_setup(z_stream *strm) } /* set a limit on the total memory allocation, or 0 to remove the limit */ -static void mem_limit(z_stream *strm, size_t limit) -{ +static void mem_limit(PREFIX3(stream) *strm, size_t limit) { struct mem_zone *zone = strm->opaque; zone->limit = limit; } /* show the current total requested allocations in bytes */ -static void mem_used(z_stream *strm, char *prefix) -{ +static void mem_used(PREFIX3(stream) *strm, char *prefix) { struct mem_zone *zone = strm->opaque; - fprintf(stderr, "%s: %zu allocated\n", prefix, zone->total); + fprintf(stderr, "%s: %" PRIu64 " allocated\n", prefix, (uint64_t)zone->total); } /* show the high water allocation in bytes */ -static void mem_high(z_stream *strm, char *prefix) -{ +static void mem_high(PREFIX3(stream) *strm, char *prefix) { struct mem_zone *zone = strm->opaque; - fprintf(stderr, "%s: %zu high water mark\n", prefix, zone->highwater); + fprintf(stderr, "%s: %" PRIu64 " high water mark\n", prefix, (uint64_t)zone->highwater); } /* release the memory allocation zone -- if there are any surprises, notify */ -static void mem_done(z_stream *strm, char *prefix) -{ +static void mem_done(PREFIX3(stream) *strm, char *prefix) { int count = 0; struct mem_item *item, *next; struct mem_zone *zone = strm->opaque; @@ -217,8 +217,8 @@ static void mem_done(z_stream *strm, char *prefix) /* issue alerts about anything unexpected */ if (count || zone->total) - fprintf(stderr, "** %s: %zu bytes in %d blocks not freed\n", - prefix, zone->total, count); + fprintf(stderr, "** %s: %" PRIu64 " bytes in %d blocks not freed\n", + prefix, (uint64_t)zone->total, count); if (zone->notlifo) fprintf(stderr, "** %s: %d frees not LIFO\n", prefix, zone->notlifo); if (zone->rogue) @@ -241,12 +241,14 @@ static void mem_done(z_stream *strm, char *prefix) by a delimiter, where that single digit writes a byte. The returned data is allocated and must eventually be freed. NULL is returned if out of memory. If the length is not needed, then len can be NULL. */ -static unsigned char *h2b(const char *hex, unsigned *len) -{ +static unsigned char *h2b(const char *hex, unsigned *len) { unsigned char *in, *re; unsigned next, val; + size_t inlen; - in = malloc((strlen(hex) + 1) >> 1); + inlen = (strlen(hex) + 1) >> 1; + assert(inlen != 0); /* tell static analyzer we won't call malloc(0) */ + in = malloc(inlen); if (in == NULL) return NULL; next = 0; @@ -267,6 +269,7 @@ static unsigned char *h2b(const char *hex, unsigned *len) } while (*hex++); /* go through the loop with the terminating null */ if (len != NULL) *len = next; + assert(next != 0); /* tell static analyzer we won't call realloc(in, 0) */ re = realloc(in, next); return re == NULL ? in : re; } @@ -280,18 +283,17 @@ static unsigned char *h2b(const char *hex, unsigned *len) header information is collected with inflateGetHeader(). If a zlib stream is looking for a dictionary, then an empty dictionary is provided. inflate() is run until all of the input data is consumed. */ -static void inf(char *hex, char *what, unsigned step, int win, unsigned len, int err) -{ +static void inf(char *hex, char *what, unsigned step, int win, unsigned len, int err) { int ret; unsigned have; unsigned char *in, *out; - z_stream strm, copy; - gz_header head; + PREFIX3(stream) strm, copy; + PREFIX(gz_header) head; mem_setup(&strm); strm.avail_in = 0; strm.next_in = NULL; - ret = inflateInit2(&strm, win); + ret = PREFIX(inflateInit2)(&strm, win); if (ret != Z_OK) { mem_done(&strm, what); return; @@ -304,7 +306,8 @@ static void inf(char *hex, char *what, unsigned step, int win, unsigned len, int head.name_max = len; head.comment = out; head.comm_max = len; - ret = inflateGetHeader(&strm, &head); assert(ret == Z_OK); + ret = PREFIX(inflateGetHeader)(&strm, &head); + assert(ret == Z_OK); } in = h2b(hex, &have); assert(in != NULL); if (step == 0 || step > have) @@ -315,23 +318,26 @@ static void inf(char *hex, char *what, unsigned step, int win, unsigned len, int do { strm.avail_out = len; strm.next_out = out; - ret = inflate(&strm, Z_NO_FLUSH); assert(err == 9 || ret == err); + ret = PREFIX(inflate)(&strm, Z_NO_FLUSH); + assert(err == 9 || ret == err); if (ret != Z_OK && ret != Z_BUF_ERROR && ret != Z_NEED_DICT) break; if (ret == Z_NEED_DICT) { - ret = inflateSetDictionary(&strm, in, 1); + ret = PREFIX(inflateSetDictionary)(&strm, in, 1); assert(ret == Z_DATA_ERROR); mem_limit(&strm, 1); - ret = inflateSetDictionary(&strm, out, 0); + ret = PREFIX(inflateSetDictionary)(&strm, out, 0); assert(ret == Z_MEM_ERROR); mem_limit(&strm, 0); ((struct inflate_state *)strm.state)->mode = DICT; - ret = inflateSetDictionary(&strm, out, 0); + ret = PREFIX(inflateSetDictionary)(&strm, out, 0); assert(ret == Z_OK); - ret = inflate(&strm, Z_NO_FLUSH); assert(ret == Z_BUF_ERROR); + ret = PREFIX(inflate)(&strm, Z_NO_FLUSH); + assert(ret == Z_BUF_ERROR); } - ret = inflateCopy(©, &strm); assert(ret == Z_OK); - ret = inflateEnd(©); assert(ret == Z_OK); + ret = PREFIX(inflateCopy)(©, &strm); + assert(ret == Z_OK); + ret = PREFIX(inflateEnd)(©); assert(ret == Z_OK); err = 9; /* don't care next time around */ have += strm.avail_in; strm.avail_in = step > have ? have : step; @@ -339,27 +345,27 @@ static void inf(char *hex, char *what, unsigned step, int win, unsigned len, int } while (strm.avail_in); free(in); free(out); - ret = inflateReset2(&strm, -8); assert(ret == Z_OK); - ret = inflateEnd(&strm); assert(ret == Z_OK); + ret = PREFIX(inflateReset2)(&strm, -8); assert(ret == Z_OK); + ret = PREFIX(inflateEnd)(&strm); assert(ret == Z_OK); mem_done(&strm, what); + (void)err; } /* cover all of the lines in inflate.c up to inflate() */ -static void cover_support(void) -{ +static void cover_support(void) { int ret; - z_stream strm; + PREFIX3(stream) strm; mem_setup(&strm); strm.avail_in = 0; strm.next_in = NULL; - ret = inflateInit(&strm); assert(ret == Z_OK); + ret = PREFIX(inflateInit)(&strm); assert(ret == Z_OK); mem_used(&strm, "inflate init"); - ret = inflatePrime(&strm, 5, 31); assert(ret == Z_OK); - ret = inflatePrime(&strm, -1, 0); assert(ret == Z_OK); - ret = inflateSetDictionary(&strm, NULL, 0); + ret = PREFIX(inflatePrime)(&strm, 5, 31); assert(ret == Z_OK); + ret = PREFIX(inflatePrime)(&strm, -1, 0); assert(ret == Z_OK); + ret = PREFIX(inflateSetDictionary)(&strm, NULL, 0); assert(ret == Z_STREAM_ERROR); - ret = inflateEnd(&strm); assert(ret == Z_OK); + ret = PREFIX(inflateEnd)(&strm); assert(ret == Z_OK); mem_done(&strm, "prime"); inf("63 0", "force window allocation", 0, -15, 1, Z_OK); @@ -371,27 +377,27 @@ static void cover_support(void) mem_setup(&strm); strm.avail_in = 0; strm.next_in = NULL; - ret = inflateInit_(&strm, ZLIB_VERSION + 1, (int)sizeof(z_stream)); + ret = PREFIX(inflateInit_)(&strm, &PREFIX2(VERSION)[1], (int)sizeof(PREFIX3(stream))); assert(ret == Z_VERSION_ERROR); mem_done(&strm, "wrong version"); strm.avail_in = 0; strm.next_in = NULL; - ret = inflateInit(&strm); assert(ret == Z_OK); - ret = inflateEnd(&strm); assert(ret == Z_OK); + ret = PREFIX(inflateInit)(&strm); assert(ret == Z_OK); + ret = PREFIX(inflateEnd)(&strm); assert(ret == Z_OK); fputs("inflate built-in memory routines\n", stderr); + (void)ret; } /* cover all inflate() header and trailer cases and code after inflate() */ -static void cover_wrap(void) -{ +static void cover_wrap(void) { int ret; - z_stream strm, copy; + PREFIX3(stream) strm, copy; unsigned char dict[257]; - ret = inflate(NULL, 0); assert(ret == Z_STREAM_ERROR); - ret = inflateEnd(NULL); assert(ret == Z_STREAM_ERROR); - ret = inflateCopy(NULL, NULL); assert(ret == Z_STREAM_ERROR); + ret = PREFIX(inflate)(NULL, 0); assert(ret == Z_STREAM_ERROR); + ret = PREFIX(inflateEnd)(NULL); assert(ret == Z_STREAM_ERROR); + ret = PREFIX(inflateCopy)(NULL, NULL); assert(ret == Z_STREAM_ERROR); fputs("inflate bad parameters\n", stderr); inf("1f 8b 0 0", "bad gzip method", 0, 31, 0, Z_DATA_ERROR); @@ -411,39 +417,43 @@ static void cover_wrap(void) mem_setup(&strm); strm.avail_in = 0; strm.next_in = NULL; - ret = inflateInit2(&strm, -8); + ret = PREFIX(inflateInit2)(&strm, -8); strm.avail_in = 2; strm.next_in = (void *)"\x63"; strm.avail_out = 1; strm.next_out = (void *)&ret; mem_limit(&strm, 1); - ret = inflate(&strm, Z_NO_FLUSH); assert(ret == Z_MEM_ERROR); - ret = inflate(&strm, Z_NO_FLUSH); assert(ret == Z_MEM_ERROR); + ret = PREFIX(inflate)(&strm, Z_NO_FLUSH); assert(ret == Z_MEM_ERROR); + ret = PREFIX(inflate)(&strm, Z_NO_FLUSH); assert(ret == Z_MEM_ERROR); mem_limit(&strm, 0); memset(dict, 0, 257); - ret = inflateSetDictionary(&strm, dict, 257); + ret = PREFIX(inflateSetDictionary)(&strm, dict, 257); assert(ret == Z_OK); mem_limit(&strm, (sizeof(struct inflate_state) << 1) + 256); - ret = inflatePrime(&strm, 16, 0); assert(ret == Z_OK); + ret = PREFIX(inflatePrime)(&strm, 16, 0); assert(ret == Z_OK); strm.avail_in = 2; strm.next_in = (void *)"\x80"; - ret = inflateSync(&strm); assert(ret == Z_DATA_ERROR); - ret = inflate(&strm, Z_NO_FLUSH); assert(ret == Z_STREAM_ERROR); + ret = PREFIX(inflateSync)(&strm); assert(ret == Z_DATA_ERROR); + ret = PREFIX(inflate)(&strm, Z_NO_FLUSH); assert(ret == Z_STREAM_ERROR); strm.avail_in = 4; strm.next_in = (void *)"\0\0\xff\xff"; - ret = inflateSync(&strm); assert(ret == Z_OK); - (void)inflateSyncPoint(&strm); - ret = inflateCopy(©, &strm); assert(ret == Z_MEM_ERROR); + ret = PREFIX(inflateSync)(&strm); assert(ret == Z_OK); + (void)PREFIX(inflateSyncPoint)(&strm); + ret = PREFIX(inflateCopy)(©, &strm); assert(ret == Z_MEM_ERROR); mem_limit(&strm, 0); - ret = inflateUndermine(&strm, 1); assert(ret == Z_DATA_ERROR); - (void)inflateMark(&strm); - ret = inflateEnd(&strm); assert(ret == Z_OK); + ret = PREFIX(inflateUndermine)(&strm, 1); +#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR + assert(ret == Z_OK); +#else + assert(ret == Z_DATA_ERROR); +#endif + (void)PREFIX(inflateMark)(&strm); + ret = PREFIX(inflateEnd)(&strm); assert(ret == Z_OK); mem_done(&strm, "miscellaneous, force memory errors"); } /* input and output functions for inflateBack() */ -static unsigned pull(void *desc, const unsigned char **buf) -{ +static unsigned pull(void *desc, z_const unsigned char **buf) { static unsigned int next = 0; static unsigned char dat[] = {0x63, 0, 2, 0}; struct inflate_state *state; @@ -452,63 +462,65 @@ static unsigned pull(void *desc, const unsigned char **buf) next = 0; return 0; /* no input (already provided at next_in) */ } - state = (void *)((z_stream *)desc)->state; + state = (void *)((PREFIX3(stream) *)desc)->state; if (state != NULL) state->mode = SYNC; /* force an otherwise impossible situation */ return next < sizeof(dat) ? (*buf = dat + next++, 1) : 0; } -static int push(void *desc, unsigned char *buf, unsigned len) -{ +static int push(void *desc, unsigned char *buf, unsigned len) { buf += len; + (void)buf; return desc != NULL; /* force error if desc not null */ } /* cover inflateBack() up to common deflate data cases and after those */ -static void cover_back(void) -{ +static void cover_back(void) { int ret; - z_stream strm; + PREFIX3(stream) strm; unsigned char win[32768]; - ret = inflateBackInit_(NULL, 0, win, 0, 0); + ret = PREFIX(inflateBackInit_)(NULL, 0, win, 0, 0); assert(ret == Z_VERSION_ERROR); - ret = inflateBackInit(NULL, 0, win); assert(ret == Z_STREAM_ERROR); - ret = inflateBack(NULL, NULL, NULL, NULL, NULL); + ret = PREFIX(inflateBackInit)(NULL, 0, win); assert(ret == Z_STREAM_ERROR); - ret = inflateBackEnd(NULL); assert(ret == Z_STREAM_ERROR); + ret = PREFIX(inflateBack)(NULL, NULL, NULL, NULL, NULL); + assert(ret == Z_STREAM_ERROR); + ret = PREFIX(inflateBackEnd)(NULL); assert(ret == Z_STREAM_ERROR); fputs("inflateBack bad parameters\n", stderr); mem_setup(&strm); - ret = inflateBackInit(&strm, 15, win); assert(ret == Z_OK); + ret = PREFIX(inflateBackInit)(&strm, 15, win); + assert(ret == Z_OK); strm.avail_in = 2; strm.next_in = (void *)"\x03"; - ret = inflateBack(&strm, pull, NULL, push, NULL); + ret = PREFIX(inflateBack)(&strm, pull, NULL, push, NULL); assert(ret == Z_STREAM_END); /* force output error */ strm.avail_in = 3; strm.next_in = (void *)"\x63\x00"; - ret = inflateBack(&strm, pull, NULL, push, &strm); + ret = PREFIX(inflateBack)(&strm, pull, NULL, push, &strm); assert(ret == Z_BUF_ERROR); /* force mode error by mucking with state */ - ret = inflateBack(&strm, pull, &strm, push, NULL); + ret = PREFIX(inflateBack)(&strm, pull, &strm, push, NULL); assert(ret == Z_STREAM_ERROR); - ret = inflateBackEnd(&strm); assert(ret == Z_OK); + ret = PREFIX(inflateBackEnd)(&strm); assert(ret == Z_OK); mem_done(&strm, "inflateBack bad state"); - ret = inflateBackInit(&strm, 15, win); assert(ret == Z_OK); - ret = inflateBackEnd(&strm); assert(ret == Z_OK); + ret = PREFIX(inflateBackInit)(&strm, 15, win); + assert(ret == Z_OK); + ret = PREFIX(inflateBackEnd)(&strm); assert(ret == Z_OK); fputs("inflateBack built-in memory routines\n", stderr); + (void)ret; } /* do a raw inflate of data in hexadecimal with both inflate and inflateBack */ -static int try(char *hex, char *id, int err) -{ +static int try(char *hex, char *id, int err) { int ret; unsigned len, size; unsigned char *in, *out, *win; char *prefix; - z_stream strm; + PREFIX3(stream) strm; /* convert to hex */ in = h2b(hex, &len); @@ -529,14 +541,14 @@ static int try(char *hex, char *id, int err) mem_setup(&strm); strm.avail_in = 0; strm.next_in = NULL; - ret = inflateInit2(&strm, err < 0 ? 47 : -15); + ret = PREFIX(inflateInit2)(&strm, err < 0 ? 47 : -15); assert(ret == Z_OK); strm.avail_in = len; strm.next_in = in; do { strm.avail_out = size; strm.next_out = out; - ret = inflate(&strm, Z_TREES); + ret = PREFIX(inflate)(&strm, Z_TREES); assert(ret != Z_STREAM_ERROR && ret != Z_MEM_ERROR); if (ret == Z_DATA_ERROR || ret == Z_NEED_DICT) break; @@ -545,7 +557,7 @@ static int try(char *hex, char *id, int err) assert(ret == Z_DATA_ERROR); assert(strcmp(id, strm.msg) == 0); } - inflateEnd(&strm); + PREFIX(inflateEnd)(&strm); mem_done(&strm, prefix); /* then with inflateBack */ @@ -553,17 +565,17 @@ static int try(char *hex, char *id, int err) strcpy(prefix, id); strcat(prefix, "-back"); mem_setup(&strm); - ret = inflateBackInit(&strm, 15, win); + ret = PREFIX(inflateBackInit)(&strm, 15, win); assert(ret == Z_OK); strm.avail_in = len; strm.next_in = in; - ret = inflateBack(&strm, pull, NULL, push, NULL); + ret = PREFIX(inflateBack)(&strm, pull, NULL, push, NULL); assert(ret != Z_STREAM_ERROR); - if (err) { + if (err && ret != Z_BUF_ERROR) { assert(ret == Z_DATA_ERROR); assert(strcmp(id, strm.msg) == 0); } - inflateBackEnd(&strm); + PREFIX(inflateBackEnd)(&strm); mem_done(&strm, prefix); } @@ -576,8 +588,7 @@ static int try(char *hex, char *id, int err) } /* cover deflate data cases in both inflate() and inflateBack() */ -static void cover_inflate(void) -{ +static void cover_inflate(void) { try("0 0 0 0 0", "invalid stored block lengths", 1); try("3 0", "fixed", 0); try("6", "invalid block type", 1); @@ -592,7 +603,11 @@ static void cover_inflate(void) try("4 80 49 92 24 49 92 24 f b4 ff ff c3 84", "invalid distances set", 1); try("4 c0 81 8 0 0 0 0 20 7f eb b 0 0", "invalid literal/length code", 1); try("2 7e ff ff", "invalid distance code", 1); +#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR + try("c c0 81 0 0 0 0 0 90 ff 6b 4 0", "invalid distance too far back", 0); +#else try("c c0 81 0 0 0 0 0 90 ff 6b 4 0", "invalid distance too far back", 1); +#endif /* also trailer mismatch just in inflate() */ try("1f 8b 8 0 0 0 0 0 0 0 3 0 0 0 0 1", "incorrect data check", -1); @@ -612,8 +627,7 @@ static void cover_inflate(void) } /* cover remaining lines in inftrees.c */ -static void cover_trees(void) -{ +static void cover_trees(void) { int ret; unsigned bits; uint16_t lens[16], work[16]; @@ -626,18 +640,18 @@ static void cover_trees(void) lens[15] = 15; next = table; bits = 15; - ret = inflate_table(DISTS, lens, 16, &next, &bits, work); + ret = zng_inflate_table(DISTS, lens, 16, &next, &bits, work); assert(ret == 1); next = table; bits = 1; - ret = inflate_table(DISTS, lens, 16, &next, &bits, work); + ret = zng_inflate_table(DISTS, lens, 16, &next, &bits, work); assert(ret == 1); fputs("inflate_table not enough errors\n", stderr); + (void)ret; } /* cover remaining inffast.c decoding and window copying */ -static void cover_fast(void) -{ +static void cover_fast(void) { inf("e5 e0 81 ad 6d cb b2 2c c9 01 1e 59 63 ae 7d ee fb 4d fd b5 35 41 68" " ff 7f 0f 0 0 0", "fast length extra bits", 0, -8, 258, Z_DATA_ERROR); inf("25 fd 81 b5 6d 59 b6 6a 49 ea af 35 6 34 eb 8c b9 f6 b9 1e ef 67 49" @@ -656,9 +670,8 @@ static void cover_fast(void) Z_STREAM_END); } -int main(void) -{ - fprintf(stderr, "%s\n", zlibVersion()); +int main(void) { + fprintf(stderr, "%s\n", zVersion()); cover_support(); cover_wrap(); cover_back(); diff --git a/libs/zlibng/test/minideflate.c b/libs/zlibng/test/minideflate.c new file mode 100644 index 000000000..392516852 --- /dev/null +++ b/libs/zlibng/test/minideflate.c @@ -0,0 +1,307 @@ +/* minideflate.c -- test deflate/inflate under specific conditions + * Copyright (C) 2020 Nathan Moinvaziri + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "zbuild.h" +#ifdef ZLIB_COMPAT +# include "zlib.h" +#else +# include "zlib-ng.h" +#endif + +#if defined(_WIN32) || defined(__CYGWIN__) +# include +# include +# define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY) +#else +# define SET_BINARY_MODE(file) +#endif + +#if MAX_MEM_LEVEL >= 8 +# define DEF_MEM_LEVEL 8 +#else +# define DEF_MEM_LEVEL MAX_MEM_LEVEL +#endif + +#define CHECK_ERR(err, msg) { \ + if (err != Z_OK) { \ + fprintf(stderr, "%s error: %d\n", msg, err); \ + exit(1); \ + } \ +} + +/* =========================================================================== + * deflate() using specialized parameters + */ +void deflate_params(FILE *fin, FILE *fout, int32_t read_buf_size, int32_t write_buf_size, int32_t level, + int32_t window_bits, int32_t mem_level, int32_t strategy, int32_t flush) { + PREFIX3(stream) c_stream; /* compression stream */ + uint8_t *read_buf; + uint8_t *write_buf; + int32_t read; + int err; + + read_buf = (uint8_t *)malloc(read_buf_size); + if (read_buf == NULL) { + fprintf(stderr, "failed to create read buffer (%d)\n", read_buf_size); + return; + } + write_buf = (uint8_t *)malloc(write_buf_size); + if (write_buf == NULL) { + fprintf(stderr, "failed to create write buffer (%d)\n", write_buf_size); + free(read_buf); + return; + } + + c_stream.zalloc = NULL; + c_stream.zfree = NULL; + c_stream.opaque = (void *)0; + c_stream.total_in = 0; + c_stream.total_out = 0; + + err = PREFIX(deflateInit2)(&c_stream, level, Z_DEFLATED, window_bits, mem_level, strategy); + CHECK_ERR(err, "deflateInit2"); + + /* Process input using our read buffer and flush type, + * output to stdout only once write buffer is full */ + do { + read = (int32_t)fread(read_buf, 1, read_buf_size, fin); + if (read <= 0) + break; + + c_stream.next_in = (z_const uint8_t *)read_buf; + c_stream.next_out = write_buf; + c_stream.avail_in = read; + + do { + c_stream.avail_out = write_buf_size; + err = PREFIX(deflate)(&c_stream, flush); + if (err == Z_STREAM_END) break; + CHECK_ERR(err, "deflate"); + + if (c_stream.next_out == write_buf + write_buf_size) { + fwrite(write_buf, 1, write_buf_size, fout); + c_stream.next_out = write_buf; + } + } while (c_stream.next_in < read_buf + read); + } while (err == Z_OK); + + /* Finish the stream if necessary */ + if (flush != Z_FINISH) { + c_stream.avail_in = 0; + do { + if (c_stream.next_out == write_buf + write_buf_size) { + fwrite(write_buf, 1, write_buf_size, fout); + c_stream.next_out = write_buf; + } + + c_stream.avail_out = write_buf_size; + err = PREFIX(deflate)(&c_stream, Z_FINISH); + if (err == Z_STREAM_END) break; + CHECK_ERR(err, "deflate"); + } while (err == Z_OK); + } + + /* Output remaining data in write buffer */ + if (c_stream.next_out != write_buf) { + fwrite(write_buf, 1, c_stream.next_out - write_buf, fout); + } + + err = PREFIX(deflateEnd)(&c_stream); + CHECK_ERR(err, "deflateEnd"); + + free(read_buf); + free(write_buf); +} + +/* =========================================================================== + * inflate() using specialized parameters + */ +void inflate_params(FILE *fin, FILE *fout, int32_t read_buf_size, int32_t write_buf_size, int32_t window_bits, + int32_t flush) { + PREFIX3(stream) d_stream; /* decompression stream */ + uint8_t *read_buf; + uint8_t *write_buf; + int32_t read; + int err; + + + read_buf = (uint8_t *)malloc(read_buf_size); + if (read_buf == NULL) { + fprintf(stderr, "failed to create read buffer (%d)\n", read_buf_size); + return; + } + write_buf = (uint8_t *)malloc(write_buf_size); + if (write_buf == NULL) { + fprintf(stderr, "failed to create write buffer (%d)\n", write_buf_size); + free(read_buf); + return; + } + + d_stream.zalloc = NULL; + d_stream.zfree = NULL; + d_stream.opaque = (void *)0; + d_stream.total_in = 0; + d_stream.total_out = 0; + + err = PREFIX(inflateInit2)(&d_stream, window_bits); + CHECK_ERR(err, "inflateInit2"); + + /* Process input using our read buffer and flush type, + * output to stdout only once write buffer is full */ + do { + read = (int32_t)fread(read_buf, 1, read_buf_size, fin); + if (read <= 0) + break; + + d_stream.next_in = (z_const uint8_t *)read_buf; + d_stream.next_out = write_buf; + d_stream.avail_in = read; + + do { + d_stream.avail_out = write_buf_size; + err = PREFIX(inflate)(&d_stream, flush); + if (err == Z_STREAM_END) break; + CHECK_ERR(err, "deflate"); + + if (d_stream.next_out == write_buf + write_buf_size) { + fwrite(write_buf, 1, write_buf_size, fout); + d_stream.next_out = write_buf; + } + } while (d_stream.next_in < read_buf + read); + } while (err == Z_OK); + + /* Finish the stream if necessary */ + if (flush != Z_FINISH) { + d_stream.avail_in = 0; + do { + if (d_stream.next_out == write_buf + write_buf_size) { + fwrite(write_buf, 1, write_buf_size, fout); + d_stream.next_out = write_buf; + } + + d_stream.avail_out = write_buf_size; + err = PREFIX(inflate)(&d_stream, Z_FINISH); + if (err == Z_STREAM_END) break; + CHECK_ERR(err, "inflate"); + } while (err == Z_OK); + } + + /* Output remaining data in write buffer */ + if (d_stream.next_out != write_buf) { + fwrite(write_buf, 1, d_stream.next_out - write_buf, fout); + } + + err = PREFIX(inflateEnd)(&d_stream); + CHECK_ERR(err, "inflateEnd"); + + free(read_buf); + free(write_buf); +} + +void show_help(void) { + printf("Usage: minideflate [-c] [-f|-h|-R|-F] [-m level] [-r/-t size] [-s flush] [-w bits] [-0 to -9] [input file]\n\n" \ + " -c : write to standard output\n" \ + " -d : decompress\n" \ + " -f : compress with Z_FILTERED\n" \ + " -h : compress with Z_HUFFMAN_ONLY\n" \ + " -R : compress with Z_RLE\n" \ + " -F : compress with Z_FIXED\n" \ + " -m : memory level (1 to 8)\n" \ + " -w : window bits (8 to 15 for gzip, -8 to -15 for zlib)\n" \ + " -s : flush type (0 to 5)\n" \ + " -r : read buffer size\n" \ + " -t : write buffer size\n" \ + " -0 to -9 : compression level\n\n"); +} + +int main(int argc, char **argv) { + int32_t i; + int32_t mem_level = DEF_MEM_LEVEL; + int32_t window_bits = MAX_WBITS; + int32_t strategy = Z_DEFAULT_STRATEGY; + int32_t level = Z_DEFAULT_COMPRESSION; + int32_t read_buf_size = 4096; + int32_t write_buf_size = 4096; + int32_t flush = Z_NO_FLUSH; + uint8_t copyout = 0; + uint8_t uncompr = 0; + char out_file[320]; + FILE *fin = stdin; + FILE *fout = stdout; + + for (i = 1; i < argc; i++) { + if ((strcmp(argv[i], "-m") == 0) && (i + 1 < argc)) + mem_level = atoi(argv[++i]); + else if ((strcmp(argv[i], "-w") == 0) && (i + 1 < argc)) + window_bits = atoi(argv[++i]); + else if ((strcmp(argv[i], "-r") == 0) && (i + 1 < argc)) + read_buf_size = atoi(argv[++i]); + else if ((strcmp(argv[i], "-t") == 0) && (i + 1 < argc)) + write_buf_size = atoi(argv[++i]); + else if ((strcmp(argv[i], "-s") == 0) && (i + 1 < argc)) + flush = atoi(argv[++i]); + else if (strcmp(argv[i], "-c") == 0) + copyout = 1; + else if (strcmp(argv[i], "-d") == 0) + uncompr = 1; + else if (strcmp(argv[i], "-f") == 0) + strategy = Z_FILTERED; + else if (strcmp(argv[i], "-h") == 0) + strategy = Z_HUFFMAN_ONLY; + else if (strcmp(argv[i], "-R") == 0) + strategy = Z_RLE; + else if (argv[i][0] == '-' && argv[i][1] >= '0' && argv[i][1] <= '9' && argv[i][2] == 0) + level = argv[i][1] - '0'; + else if (strcmp(argv[i], "--help") == 0) { + show_help(); + return 0; + } else if (argv[i][0] == '-') { + show_help(); + return 64; /* EX_USAGE */ + } else + break; + } + + SET_BINARY_MODE(stdin); + SET_BINARY_MODE(stdout); + if (i != argc) { + fin = fopen(argv[i], "rb+"); + if (fin == NULL) { + fprintf(stderr, "Failed to open file: %s\n", argv[i]); + exit(1); + } + if (!copyout) { + snprintf(out_file, sizeof(out_file), "%s%s", argv[i], (window_bits < 0) ? ".zz" : ".gz"); + fout = fopen(out_file, "wb"); + if (fout == NULL) { + fprintf(stderr, "Failed to open file: %s\n", out_file); + exit(1); + } + } + } + + if (uncompr) { + inflate_params(fin, fout, read_buf_size, write_buf_size, window_bits, flush); + } else { + deflate_params(fin, fout, read_buf_size, write_buf_size, level, window_bits, mem_level, strategy, flush); + } + + if (fin != stdin) { + fclose(fin); + } + if (fout != stdout) { + fclose(fout); + } + + return 0; +} diff --git a/libs/zlibng/test/minigzip.c b/libs/zlibng/test/minigzip.c index ebbed9ae3..2e4ef8e2a 100644 --- a/libs/zlibng/test/minigzip.c +++ b/libs/zlibng/test/minigzip.c @@ -12,16 +12,14 @@ * real thing. */ -/* @(#) $Id$ */ - #define _POSIX_SOURCE 1 /* This file needs POSIX for fdopen(). */ #define _POSIX_C_SOURCE 200112 /* For snprintf(). */ #include "zbuild.h" #ifdef ZLIB_COMPAT -# include "zlib.h" +# include "zlib.h" #else -# include "zlib-ng.h" +# include "zlib-ng.h" #endif #include @@ -38,7 +36,7 @@ # include #endif -#if defined(WIN32) || defined(__CYGWIN__) +#if defined(_WIN32) || defined(__CYGWIN__) # include # include # define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY) @@ -51,8 +49,8 @@ #endif #if !defined(Z_HAVE_UNISTD_H) && !defined(_LARGEFILE64_SOURCE) -#ifndef WIN32 /* unlink already in stdio.h for WIN32 */ - extern int unlink (const char *); +#ifndef _WIN32 /* unlink already in stdio.h for Win32 */ +extern int unlink (const char *); #endif #endif @@ -61,10 +59,8 @@ #endif #define SUFFIX_LEN (sizeof(GZ_SUFFIX)-1) -#if defined(S390_DFLTCC_DEFLATE) || defined(S390_DFLTCC_INFLATE) -#define BUFLEN 262144 /* DFLTCC works faster with larger buffers */ -#else -#define BUFLEN 16384 /* read buffer size */ +#ifndef BUFLEN +# define BUFLEN 16384 /* read buffer size */ #endif #define BUFLENW (BUFLEN * 3) /* write buffer size */ #define MAX_NAME_LEN 1024 @@ -72,20 +68,19 @@ static char *prog; void error (const char *msg); -void gz_compress (FILE *in, gzFile out); +void gz_compress (FILE *in, gzFile out); #ifdef USE_MMAP -int gz_compress_mmap (FILE *in, gzFile out); +int gz_compress_mmap (FILE *in, gzFile out); #endif -void gz_uncompress (gzFile in, FILE *out); -void file_compress (char *file, char *mode); -void file_uncompress (char *file); +void gz_uncompress (gzFile in, FILE *out); +void file_compress (char *file, char *mode, int keep); +void file_uncompress (char *file, int keep); int main (int argc, char *argv[]); /* =========================================================================== * Display error message and exit */ -void error(const char *msg) -{ +void error(const char *msg) { fprintf(stderr, "%s: %s\n", prog, msg); exit(1); } @@ -94,9 +89,8 @@ void error(const char *msg) * Compress input to output then close both files. */ -void gz_compress(FILE *in, gzFile out) -{ - char buf[BUFLEN]; +void gz_compress(FILE *in, gzFile out) { + char *buf; int len; int err; @@ -106,12 +100,16 @@ void gz_compress(FILE *in, gzFile out) */ if (gz_compress_mmap(in, out) == Z_OK) return; #endif - /* Clear out the contents of buf before reading from the file to avoid - MemorySanitizer: use-of-uninitialized-value warnings. */ - memset(buf, 0, sizeof(buf)); + buf = (char *)calloc(BUFLEN, 1); + if (buf == NULL) { + perror("out of memory"); + exit(1); + } + for (;;) { - len = (int)fread(buf, 1, sizeof(buf), in); + len = (int)fread(buf, 1, BUFLEN, in); if (ferror(in)) { + free(buf); perror("fread"); exit(1); } @@ -119,6 +117,7 @@ void gz_compress(FILE *in, gzFile out) if (PREFIX(gzwrite)(out, buf, (unsigned)len) != len) error(PREFIX(gzerror)(out, &err)); } + free(buf); fclose(in); if (PREFIX(gzclose)(out) != Z_OK) error("failed gzclose"); } @@ -128,12 +127,11 @@ void gz_compress(FILE *in, gzFile out) /* Try compressing the input file at once using mmap. Return Z_OK if * if success, Z_ERRNO otherwise. */ -int gz_compress_mmap(FILE *in, gzFile out) -{ +int gz_compress_mmap(FILE *in, gzFile out) { int len; int err; int ifd = fileno(in); - caddr_t buf; /* mmap'ed buffer for the entire input file */ + char *buf; /* mmap'ed buffer for the entire input file */ off_t buf_len; /* length of the input file */ struct stat sb; @@ -143,11 +141,11 @@ int gz_compress_mmap(FILE *in, gzFile out) if (buf_len <= 0) return Z_ERRNO; /* Now do the actual mmap: */ - buf = mmap((caddr_t) 0, buf_len, PROT_READ, MAP_SHARED, ifd, (off_t)0); - if (buf == (caddr_t)(-1)) return Z_ERRNO; + buf = mmap((void *)0, buf_len, PROT_READ, MAP_SHARED, ifd, (off_t)0); + if (buf == (char *)(-1)) return Z_ERRNO; /* Compress the whole file at once: */ - len = PREFIX(gzwrite)(out, (char *)buf, (unsigned)buf_len); + len = PREFIX(gzwrite)(out, buf, (unsigned)buf_len); if (len != (int)buf_len) error(PREFIX(gzerror)(out, &err)); @@ -161,21 +159,27 @@ int gz_compress_mmap(FILE *in, gzFile out) /* =========================================================================== * Uncompress input to output then close both files. */ -void gz_uncompress(gzFile in, FILE *out) -{ - char buf[BUFLENW]; +void gz_uncompress(gzFile in, FILE *out) { + char *buf = (char *)malloc(BUFLENW); int len; int err; + if (buf == NULL) error("out of memory"); + for (;;) { - len = PREFIX(gzread)(in, buf, sizeof(buf)); - if (len < 0) error (PREFIX(gzerror)(in, &err)); + len = PREFIX(gzread)(in, buf, BUFLENW); + if (len < 0) { + free(buf); + error(PREFIX(gzerror)(in, &err)); + } if (len == 0) break; if ((int)fwrite(buf, 1, (unsigned)len, out) != len) { + free(buf); error("failed fwrite"); } } + free(buf); if (fclose(out)) error("failed fclose"); if (PREFIX(gzclose)(in) != Z_OK) error("failed gzclose"); @@ -186,10 +190,9 @@ void gz_uncompress(gzFile in, FILE *out) * Compress the given file: create a corresponding .gz file and remove the * original. */ -void file_compress(char *file, char *mode) -{ +void file_compress(char *file, char *mode, int keep) { char outfile[MAX_NAME_LEN]; - FILE *in; + FILE *in; gzFile out; if (strlen(file) + strlen(GZ_SUFFIX) >= sizeof(outfile)) { @@ -211,18 +214,18 @@ void file_compress(char *file, char *mode) } gz_compress(in, out); - unlink(file); + if (!keep) + unlink(file); } /* =========================================================================== * Uncompress the given file and remove the original. */ -void file_uncompress(char *file) -{ +void file_uncompress(char *file, int keep) { char buf[MAX_NAME_LEN]; char *infile, *outfile; - FILE *out; + FILE *out; gzFile in; size_t len = strlen(file); @@ -255,63 +258,75 @@ void file_uncompress(char *file) gz_uncompress(in, out); - unlink(infile); + if (!keep) + unlink(infile); } +void show_help(void) { + printf("Usage: minigzip [-c] [-d] [-k] [-f|-h|-R|-F|-T] [-A] [-0 to -9] [files...]\n\n" \ + " -c : write to standard output\n" \ + " -d : decompress\n" \ + " -k : keep input files\n" \ + " -f : compress with Z_FILTERED\n" \ + " -h : compress with Z_HUFFMAN_ONLY\n" \ + " -R : compress with Z_RLE\n" \ + " -F : compress with Z_FIXED\n" \ + " -T : stored raw\n" \ + " -A : auto detect type\n" \ + " -0 to -9 : compression level\n\n"); +} -/* =========================================================================== - * Usage: minigzip [-c] [-d] [-f] [-h] [-r] [-1 to -9] [files...] - * -c : write to standard output - * -d : decompress - * -f : compress with Z_FILTERED - * -h : compress with Z_HUFFMAN_ONLY - * -r : compress with Z_RLE - * -0 to -9 : compression level - */ - -int main(int argc, char *argv[]) -{ +int main(int argc, char *argv[]) { int copyout = 0; int uncompr = 0; + int keep = 0; + int i = 0; gzFile file; char *bname, outmode[20]; + char *strategy = ""; + char *level = "6"; + char *type = "b"; - snprintf(outmode, sizeof(outmode), "%s", "wb6 "); - - prog = argv[0]; - bname = strrchr(argv[0], '/'); + prog = argv[i]; + bname = strrchr(argv[i], '/'); if (bname) - bname++; + bname++; else - bname = argv[0]; - argc--, argv++; + bname = argv[i]; if (!strcmp(bname, "gunzip")) - uncompr = 1; - else if (!strcmp(bname, "zcat")) - copyout = uncompr = 1; - - while (argc > 0) { - if (strcmp(*argv, "-c") == 0) - copyout = 1; - else if (strcmp(*argv, "-d") == 0) uncompr = 1; - else if (strcmp(*argv, "-f") == 0) - outmode[3] = 'f'; - else if (strcmp(*argv, "-h") == 0) - outmode[3] = 'h'; - else if (strcmp(*argv, "-r") == 0) - outmode[3] = 'R'; - else if ((*argv)[0] == '-' && (*argv)[1] >= '0' && (*argv)[1] <= '9' && - (*argv)[2] == 0) - outmode[2] = (*argv)[1]; - else - break; - argc--, argv++; + else if (!strcmp(bname, "zcat")) + copyout = uncompr = 1; + + for (i = 1; i < argc; i++) { + if (strcmp(argv[i], "-c") == 0) + copyout = 1; + else if (strcmp(argv[i], "-d") == 0) + uncompr = 1; + else if (strcmp(argv[i], "-k") == 0) + keep = 1; + else if (strcmp(argv[i], "-A") == 0) + type = ""; + else if (argv[i][0] == '-' && (argv[i][1] == 'f' || argv[i][1] == 'h' || + argv[i][1] == 'R' || argv[i][1] == 'F' || argv[i][1] == 'T') && argv[i][2] == 0) + strategy = argv[i] + 1; + else if (argv[i][0] == '-' && argv[i][1] >= '0' && argv[i][1] <= '9' && argv[i][2] == 0) + level = argv[i] + 1; + else if (strcmp(argv[i], "--help") == 0) { + show_help(); + return 0; + } else if (argv[i][0] == '-') { + show_help(); + return 64; /* EX_USAGE */ + } else { + break; + } } - if (outmode[3] == ' ') - outmode[3] = 0; - if (argc == 0) { + + snprintf(outmode, sizeof(outmode), "w%s%s%s", type, strategy, level); + + if (i == argc) { SET_BINARY_MODE(stdin); SET_BINARY_MODE(stdout); if (uncompr) { @@ -330,20 +345,20 @@ int main(int argc, char *argv[]) do { if (uncompr) { if (copyout) { - file = PREFIX(gzopen)(*argv, "rb"); + file = PREFIX(gzopen)(argv[i], "rb"); if (file == NULL) - fprintf(stderr, "%s: can't gzopen %s\n", prog, *argv); + fprintf(stderr, "%s: can't gzopen %s\n", prog, argv[i]); else gz_uncompress(file, stdout); } else { - file_uncompress(*argv); + file_uncompress(argv[i], keep); } } else { if (copyout) { - FILE * in = fopen(*argv, "rb"); + FILE * in = fopen(argv[i], "rb"); if (in == NULL) { - perror(*argv); + perror(argv[i]); } else { file = PREFIX(gzdopen)(fileno(stdout), outmode); if (file == NULL) error("can't gzdopen stdout"); @@ -352,10 +367,10 @@ int main(int argc, char *argv[]) } } else { - file_compress(*argv, outmode); + file_compress(argv[i], outmode, keep); } } - } while (argv++, --argc); + } while (++i < argc); } return 0; } diff --git a/libs/zlibng/test/pkgcheck.sh b/libs/zlibng/test/pkgcheck.sh new file mode 100644 index 000000000..4c757dff1 --- /dev/null +++ b/libs/zlibng/test/pkgcheck.sh @@ -0,0 +1,176 @@ +#!/bin/sh + +usage() { + cat <<"_EOF_" +Usage: sh test/pkgcheck.sh [--zlib-compat] + +Verifies that the various build systems produce identical results on a Unixlike system. +If --zlib-compat, tests with zlib compatible builds. + +To build the 32 bit version for the current 64 bit arch: + +$ sudo apt install ninja-build diffoscope gcc-multilib +$ export CMAKE_ARGS="-DCMAKE_C_FLAGS=-m32" CFLAGS=-m32 LDFLAGS=-m32 +$ sh test/pkgcheck.sh + +To cross-build, install the appropriate qemu and gcc packages, +and set the environment variables used by configure or cmake. +On Ubuntu, for example (values taken from .github/workflows/pkgconf.yml): + +arm HF: +$ sudo apt install ninja-build diffoscope qemu gcc-arm-linux-gnueabihf libc6-dev-armhf-cross +$ export CHOST=arm-linux-gnueabihf +$ export CMAKE_ARGS="-DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-arm.cmake -DCMAKE_C_COMPILER_TARGET=${CHOST}" + +aarch64: +$ sudo apt install ninja-build diffoscope qemu gcc-aarch64-linux-gnu libc6-dev-arm64-cross +$ export CHOST=aarch64-linux-gnu +$ export CMAKE_ARGS="-DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-aarch64.cmake -DCMAKE_C_COMPILER_TARGET=${CHOST}" + +ppc (32 bit big endian): +$ sudo apt install ninja-build diffoscope qemu gcc-powerpc-linux-gnu libc6-dev-powerpc-cross +$ export CHOST=powerpc-linux-gnu +$ export CMAKE_ARGS="-DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-powerpc.cmake" + +ppc64le: +$ sudo apt install ninja-build diffoscope qemu gcc-powerpc64le-linux-gnu libc6-dev-ppc64el-cross +$ export CHOST=powerpc64le-linux-gnu +$ export CMAKE_ARGS="-DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-powerpc64le.cmake" + +then: +$ export CC=${CHOST}-gcc +$ sh test/pkgcheck.sh [--zlib-compat] + +Note: on Mac, you may also need to do 'sudo xcode-select -r' to get cmake to match configure/make's behavior (i.e. omit -isysroot). +_EOF_ +} + +set -ex + +# Caller can also set CMAKE_ARGS or CONFIGURE_ARGS if desired +CMAKE_ARGS=${CMAKE_ARGS} +CONFIGURE_ARGS=${CONFIGURE_ARGS} + +case "$1" in +--zlib-compat) + suffix="" + CMAKE_ARGS="$CMAKE_ARGS -DZLIB_COMPAT=ON" + CONFIGURE_ARGS="$CONFIGURE_ARGS --zlib-compat" + ;; +"") + suffix="-ng" + ;; +*) + echo "Unknown arg '$1'" + usage + exit 1 + ;; +esac + +if ! test -f "configure" +then + echo "Please run from top of source tree" + exit 1 +fi + +# Tell GNU's ld etc. to use Jan 1 1970 when embedding timestamps +# Probably only needed on older systems (ubuntu 14.04, BSD?) +export SOURCE_DATE_EPOCH=0 +case $(uname) in +Darwin) + # Tell Apple's ar etc. to use zero timestamps + export ZERO_AR_DATE=1 + # What CPU are we running on, exactly? + sysctl -n machdep.cpu.brand_string + sysctl -n machdep.cpu.features + sysctl -n machdep.cpu.leaf7_features + sysctl -n machdep.cpu.extfeatures + ;; +esac + +# Use same compiler for make and cmake builds +if test "$CC"x = ""x +then + if clang --version + then + export CC=clang + elif gcc --version + then + export CC=gcc + fi +fi + +# New build system +# Happens to delete top-level zconf.h +# (which itself is a bug, https://github.com/madler/zlib/issues/162 ) +# which triggers another bug later in configure, +# https://github.com/madler/zlib/issues/499 +rm -rf btmp2 pkgtmp2 +mkdir btmp2 pkgtmp2 +export DESTDIR=$(pwd)/pkgtmp2 +cd btmp2 + cmake -G Ninja ${CMAKE_ARGS} .. + ninja -v + ninja install +cd .. + +# Original build system +rm -rf btmp1 pkgtmp1 +mkdir btmp1 pkgtmp1 +export DESTDIR=$(pwd)/pkgtmp1 +cd btmp1 + case $(uname) in + Darwin) + export LDFLAGS="-Wl,-headerpad_max_install_names" + ;; + esac + ../configure $CONFIGURE_ARGS + make + make install +cd .. + +repack_ar() { + if ! cmp --silent pkgtmp1/usr/local/lib/libz$suffix.a pkgtmp2/usr/local/lib/libz$suffix.a + then + echo "libz$suffix.a does not match. Probably filenames differ (.o vs .c.o). Unpacking and renaming..." + # Note: %% is posix shell syntax meaning "Remove Largest Suffix Pattern", see + # https://pubs.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html#tag_02_06_02 + cd pkgtmp1; ar x usr/local/lib/libz$suffix.a; rm usr/local/lib/libz$suffix.a; cd .. + cd pkgtmp2; ar x usr/local/lib/libz$suffix.a; rm usr/local/lib/libz$suffix.a; for a in *.c.o; do mv $a ${a%%.c.o}.o; done; cd .. + # Also, remove __.SYMDEF SORTED if present, as it has those funky .c.o names embedded in it. + rm -f pkgtmp[12]/__.SYMDEF\ SORTED + fi +} + +case $(uname) in +Darwin) + # Remove the build uuid. + dylib1=$(find pkgtmp1 -type f -name '*.dylib*') + dylib2=$(find pkgtmp2 -type f -name '*.dylib*') + strip -x -no_uuid "$dylib1" + strip -x -no_uuid "$dylib2" + ;; +esac + +# The ar on newer systems defaults to -D (i.e. deterministic), +# but FreeBSD 12.1, Debian 8, and Ubuntu 14.04 seem to not do that. +# I had trouble passing -D safely to the ar inside CMakeLists.txt, +# so punt and unpack the archive if needed before comparing. +# Also, cmake uses different .o suffix anyway... +repack_ar + +if diff -Nur pkgtmp1 pkgtmp2 +then + echo pkgcheck-cmake-bits-identical PASS +else + echo pkgcheck-cmake-bits-identical FAIL + dylib1=$(find pkgtmp1 -type f -name '*.dylib*' -print -o -type f -name '*.so.*' -print) + dylib2=$(find pkgtmp2 -type f -name '*.dylib*' -print -o -type f -name '*.so.*' -print) + diffoscope $dylib1 $dylib2 | cat + exit 1 +fi + +rm -rf btmp1 btmp2 pkgtmp1 pkgtmp2 + +# any failure would have caused an early exit already +echo "pkgcheck: PASS" diff --git a/libs/zlibng/test/switchlevels.c b/libs/zlibng/test/switchlevels.c new file mode 100644 index 000000000..0f850113e --- /dev/null +++ b/libs/zlibng/test/switchlevels.c @@ -0,0 +1,169 @@ +/* Compresses a user-specified number of chunks from stdin into stdout as a single gzip stream. + * Each chunk is compressed with a user-specified level. + */ + +#include "zbuild.h" +#ifdef ZLIB_COMPAT +# include "zlib.h" +#else +# include "zlib-ng.h" +#endif + +#include +#include +#include + +#if defined(_WIN32) || defined(__CYGWIN__) +# include +# include +# define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY) +#else +# define SET_BINARY_MODE(file) +#endif + +static int read_all(unsigned char *buf, size_t size) { + size_t total_read = 0; + while (total_read < size) { + size_t n_read = fread(buf + total_read, 1, size - total_read, stdin); + if (ferror(stdin)) { + perror("fread\n"); + return 1; + } + if (n_read == 0) { + fprintf(stderr, "Premature EOF\n"); + return 1; + } + total_read += n_read; + } + return 0; +} + +static int write_all(unsigned char *buf, size_t size) { + size_t total_written = 0; + while (total_written < size) { + size_t n_written = fwrite(buf + total_written, 1, size - total_written, stdout); + if (ferror(stdout)) { + perror("fwrite\n"); + return 1; + } + total_written += n_written; + } + return 0; +} + +static int compress_chunk(PREFIX3(stream) *strm, int level, int size, int last) { + int ret = 1; + int err = 0; + unsigned long compsize; + unsigned char *buf; + + if (size <= 0) { + fprintf(stderr, "compress_chunk() invalid size %d\n", size); + goto done; + } + if (level < 0 || level > 9) { + fprintf(stderr, "compress_chunk() invalid level %d\n", level); + goto done; + } + + compsize = 100 + 2 * PREFIX(deflateBound)(strm, size); + buf = malloc(size + compsize); + if (buf == NULL) { + fprintf(stderr, "Out of memory\n"); + goto done; + } + if (read_all(buf, size) != 0) { + goto free_buf; + } + + /* Provide only output buffer to deflateParams(). It might need some space to flush the leftovers from the last + * deflate(), but we don't want it to compress anything new. */ + strm->next_in = NULL; + strm->avail_in = 0; + strm->next_out = buf + size; + strm->avail_out = compsize; + err = PREFIX(deflateParams)(strm, level, Z_DEFAULT_STRATEGY); + if (err != Z_OK) { + fprintf(stderr, "deflateParams() failed with code %d\n", err); + goto free_buf; + } + + /* Provide input buffer to deflate(). */ + strm->next_in = buf; + strm->avail_in = size; + err = PREFIX(deflate)(strm, last ? Z_FINISH : Z_SYNC_FLUSH); + if ((!last && err != Z_OK) || (last && err != Z_STREAM_END)) { + fprintf(stderr, "deflate() failed with code %d\n", err); + goto free_buf; + } + if (strm->avail_in != 0) { + fprintf(stderr, "deflate() did not consume %d bytes of input\n", strm->avail_in); + goto free_buf; + } + if (write_all(buf + size, compsize - strm->avail_out) != 0) { + goto free_buf; + } + ret = 0; + +free_buf: + free(buf); +done: + return ret; +} + +void show_help(void) +{ + printf("Usage: switchlevels [-w bits] level1 size1 [level2 size2 ...]\n\n" \ + " -w : window bits (8 to 15 for gzip, -8 to -15 for zlib)\n\n"); +} + +int main(int argc, char **argv) { + int ret = EXIT_FAILURE; + int err = 0; + int size = 0; + int level = Z_DEFAULT_COMPRESSION; + int level_arg = 1; + int window_bits = MAX_WBITS + 16; + PREFIX3(stream) strm; + + + if ((argc == 1) || (argc == 2 && strcmp(argv[1], "--help") == 0)) { + show_help(); + return 0; + } + + SET_BINARY_MODE(stdin); + SET_BINARY_MODE(stdout); + + memset(&strm, 0, sizeof(strm)); + + for (int i = 1; i < argc - 1; i++) { + if (strcmp(argv[i], "-w") == 0 && i+1 < argc) { + window_bits = atoi(argv[++i]); + } else { + level_arg = i; + level = atoi(argv[i]); + break; + } + } + + err = PREFIX(deflateInit2)(&strm, level, Z_DEFLATED, window_bits, 8, Z_DEFAULT_STRATEGY); + if (err != Z_OK) { + fprintf(stderr, "deflateInit() failed with code %d\n", err); + goto done; + } + + for (int i = level_arg; i < argc - 1; i += 2) { + level = atoi(argv[i]); + size = atoi(argv[i + 1]); + if (compress_chunk(&strm, level, size, i + 2 >= argc - 1) != 0) { + goto deflate_end; + } + } + ret = EXIT_SUCCESS; + +deflate_end: + PREFIX(deflateEnd)(&strm); +done: + return ret; +} diff --git a/libs/zlibng/test/testCVEinputs.sh b/libs/zlibng/test/testCVEinputs.sh index 8f23438d7..84f6b31c5 100644 --- a/libs/zlibng/test/testCVEinputs.sh +++ b/libs/zlibng/test/testCVEinputs.sh @@ -15,17 +15,16 @@ CVEs="CVE-2002-0059 CVE-2004-0797 CVE-2005-1849 CVE-2005-2096" for CVE in $CVEs; do fail=0 for testcase in ${TESTDIR}/${CVE}/*.gz; do - ${QEMU_RUN} ../minigzip${EXE} -d < "$testcase" - # we expect that a 1 error code is OK - # for a vulnerable failure we'd expect 134 or similar - if [ $? -ne 1 ] && [ $? -ne 0 ]; then - fail=1 - fi + ${QEMU_RUN} ../minigzip${EXE} -d < "$testcase" + # we expect that a 1 error code is OK + # for a vulnerable failure we'd expect 134 or similar + if [ $? -ne 1 ] && [ $? -ne 0 ]; then + fail=1 + fi done if [ $fail -eq 0 ]; then - echo " --- zlib not vulnerable to $CVE ---"; + echo " --- zlib not vulnerable to $CVE ---"; else - echo " --- zlib VULNERABLE to $CVE ---"; exit 1; + echo " --- zlib VULNERABLE to $CVE ---"; exit 1; fi done - diff --git a/libs/zlibng/tools/codecov-upload.sh b/libs/zlibng/tools/codecov-upload.sh new file mode 100644 index 000000000..e3a48aab7 --- /dev/null +++ b/libs/zlibng/tools/codecov-upload.sh @@ -0,0 +1,9 @@ +#!/bin/sh +set -ux +cd "$CODECOV_DIR" +python -m codecov --required --flags "$CODECOV_FLAGS" --name "$CODECOV_NAME" --gcov-exec="$CODECOV_EXEC" +if [ $? -ne 0 ]; then + sleep 30 + python -m codecov --required --flags "$CODECOV_FLAGS" --name "$CODECOV_NAME" --gcov-exec="$CODECOV_EXEC" --tries=25 +fi +exit $? diff --git a/libs/zlibng/tools/config.sub b/libs/zlibng/tools/config.sub new file mode 100644 index 000000000..dba175ae3 --- /dev/null +++ b/libs/zlibng/tools/config.sub @@ -0,0 +1,17 @@ +#!/bin/sh +# Canonicalize CHOST. +# In particular, converts Debian multiarch tuples into GNU triplets. +# See also +# https://wiki.debian.org/Multiarch/Tuples +# https://wiki.gentoo.org/wiki/CHOST +# If you need an architecture not listed here, file a bug at github.com/zlib-ng/zlib-ng +# and work around the problem by dropping libtool's much more comprehensive config.sub +# on top of this file, see +# https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub + +case "$1" in +*-*-linux-gnu*) echo $1;; +i686-linux-gnu*|x86_64-linux-gnu*) echo $1 | sed 's/-linux-gnu/-pc-linux-gnu/';; +*-linux-gnu*) echo $1 | sed 's/-linux-gnu/-unknown-linux-gnu/';; +*) echo $1;; +esac diff --git a/libs/zlibng/tools/makecrct.c b/libs/zlibng/tools/makecrct.c new file mode 100644 index 000000000..323d0c03d --- /dev/null +++ b/libs/zlibng/tools/makecrct.c @@ -0,0 +1,177 @@ +/* crc32.c -- output crc32 tables + * Copyright (C) 1995-2006, 2010, 2011, 2012, 2016, 2018 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h +*/ + +#include +#include +#include "zbuild.h" +#include "deflate.h" +#include "crc32_p.h" + +static uint32_t crc_table[8][256]; +static uint32_t crc_comb[GF2_DIM][GF2_DIM]; + +static void gf2_matrix_square(uint32_t *square, const uint32_t *mat); +static void make_crc_table(void); +static void make_crc_combine_table(void); +static void print_crc_table(void); +static void print_crc_combine_table(void); +static void write_table(const uint32_t *, int); + + +/* ========================================================================= */ +static void gf2_matrix_square(uint32_t *square, const uint32_t *mat) { + int n; + + for (n = 0; n < GF2_DIM; n++) + square[n] = gf2_matrix_times(mat, mat[n]); +} + +/* ========================================================================= + Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: + x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1. + + Polynomials over GF(2) are represented in binary, one bit per coefficient, + with the lowest powers in the most significant bit. Then adding polynomials + is just exclusive-or, and multiplying a polynomial by x is a right shift by + one. If we call the above polynomial p, and represent a byte as the + polynomial q, also with the lowest power in the most significant bit (so the + byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, + where a mod b means the remainder after dividing a by b. + + This calculation is done using the shift-register method of multiplying and + taking the remainder. The register is initialized to zero, and for each + incoming bit, x^32 is added mod p to the register if the bit is a one (where + x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by + x (which is shifting right by one and adding x^32 mod p if the bit shifted + out is a one). We start with the highest power (least significant bit) of + q and repeat for all eight bits of q. + + The first table is simply the CRC of all possible eight bit values. This is + all the information needed to generate CRCs on data a byte at a time for all + combinations of CRC register values and incoming bytes. The remaining tables + allow for word-at-a-time CRC calculation for both big-endian and little- + endian machines, where a word is four bytes. +*/ +static void make_crc_table(void) { + int n, k; + uint32_t c; + uint32_t poly; /* polynomial exclusive-or pattern */ + /* terms of polynomial defining this crc (except x^32): */ + static const unsigned char p[] = {0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26}; + + /* make exclusive-or pattern from polynomial (0xedb88320) */ + poly = 0; + for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++) + poly |= (uint32_t)1 << (31 - p[n]); + + /* generate a crc for every 8-bit value */ + for (n = 0; n < 256; n++) { + c = (uint32_t)n; + for (k = 0; k < 8; k++) + c = c & 1 ? poly ^ (c >> 1) : c >> 1; + crc_table[0][n] = c; + } + + /* generate crc for each value followed by one, two, and three zeros, + and then the byte reversal of those as well as the first table */ + for (n = 0; n < 256; n++) { + c = crc_table[0][n]; + crc_table[4][n] = ZSWAP32(c); + for (k = 1; k < 4; k++) { + c = crc_table[0][c & 0xff] ^ (c >> 8); + crc_table[k][n] = c; + crc_table[k + 4][n] = ZSWAP32(c); + } + } +} + +static void make_crc_combine_table(void) { + int n, k; + /* generate zero operators table for crc32_combine() */ + + /* generate the operator to apply a single zero bit to a CRC -- the + first row adds the polynomial if the low bit is a 1, and the + remaining rows shift the CRC right one bit */ + k = GF2_DIM - 3; + crc_comb[k][0] = 0xedb88320UL; /* CRC-32 polynomial */ + uint32_t row = 1; + for (n = 1; n < GF2_DIM; n++) { + crc_comb[k][n] = row; + row <<= 1; + } + /* generate operators that apply 2, 4, and 8 zeros to a CRC, putting + the last one, the operator for one zero byte, at the 0 position */ + gf2_matrix_square(crc_comb[k + 1], crc_comb[k]); + gf2_matrix_square(crc_comb[k + 2], crc_comb[k + 1]); + gf2_matrix_square(crc_comb[0], crc_comb[k + 2]); + + /* generate operators for applying 2^n zero bytes to a CRC, filling out + the remainder of the table -- the operators repeat after GF2_DIM + values of n, so the table only needs GF2_DIM entries, regardless of + the size of the length being processed */ + for (n = 1; n < k; n++) + gf2_matrix_square(crc_comb[n], crc_comb[n - 1]); +} + +static void write_table(const uint32_t *table, int k) { + int n; + + for (n = 0; n < k; n++) + printf("%s0x%08" PRIx32 "%s", n % 5 ? "" : " ", + (uint32_t)(table[n]), + n == k - 1 ? "\n" : (n % 5 == 4 ? ",\n" : ", ")); +} + +static void print_crc_table(void) { + int k; + printf("#ifndef CRC32_TBL_H_\n"); + printf("#define CRC32_TBL_H_\n\n"); + printf("/* crc32_tbl.h -- tables for rapid CRC calculation\n"); + printf(" * Generated automatically by makecrct.c\n */\n\n"); + + /* print CRC table */ + printf("static const uint32_t "); + printf("crc_table[8][256] =\n{\n {\n"); + write_table(crc_table[0], 256); + for (k = 1; k < 8; k++) { + printf(" },\n {\n"); + write_table(crc_table[k], 256); + } + printf(" }\n};\n\n"); + + printf("#endif /* CRC32_TBL_H_ */\n"); +} + +static void print_crc_combine_table(void) { + int k; + printf("#ifndef CRC32_COMB_TBL_H_\n"); + printf("#define CRC32_COMB_TBL_H_\n\n"); + printf("/* crc32_comb_tbl.h -- zero operators table for CRC combine\n"); + printf(" * Generated automatically by makecrct.c\n */\n\n"); + + /* print zero operator table */ + printf("static const uint32_t "); + printf("crc_comb[%d][%d] =\n{\n {\n", GF2_DIM, GF2_DIM); + write_table(crc_comb[0], GF2_DIM); + for (k = 1; k < GF2_DIM; k++) { + printf(" },\n {\n"); + write_table(crc_comb[k], GF2_DIM); + } + printf(" }\n};\n\n"); + + printf("#endif /* CRC32_COMB_TBL_H_ */\n"); +} + +// The output of this application can be piped out to recreate crc32.h +int main(int argc, char *argv[]) { + if (argc > 1 && strcmp(argv[1], "-c") == 0) { + make_crc_combine_table(); + print_crc_combine_table(); + } else { + make_crc_table(); + print_crc_table(); + } + return 0; +} diff --git a/libs/zlibng/tools/makefixed.c b/libs/zlibng/tools/makefixed.c new file mode 100644 index 000000000..7fe71e75e --- /dev/null +++ b/libs/zlibng/tools/makefixed.c @@ -0,0 +1,89 @@ +#include +#include "zbuild.h" +#include "zutil.h" +#include "inftrees.h" +#include "inflate.h" + +// Build and return state with length and distance decoding tables and index sizes set to fixed code decoding. +void Z_INTERNAL buildfixedtables(struct inflate_state *state) { + static code *lenfix, *distfix; + static code fixed[544]; + + // build fixed huffman tables + unsigned sym, bits; + static code *next; + + // literal/length table + sym = 0; + while (sym < 144) state->lens[sym++] = 8; + while (sym < 256) state->lens[sym++] = 9; + while (sym < 280) state->lens[sym++] = 7; + while (sym < 288) state->lens[sym++] = 8; + next = fixed; + lenfix = next; + bits = 9; + zng_inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); + + // distance table + sym = 0; + while (sym < 32) state->lens[sym++] = 5; + distfix = next; + bits = 5; + zng_inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); + + state->lencode = lenfix; + state->lenbits = 9; + state->distcode = distfix; + state->distbits = 5; +} + + +// Create fixed tables on the fly and write out a inffixed_tbl.h file that is #include'd above. +// makefixed() writes those tables to stdout, which would be piped to inffixed_tbl.h. +void makefixed(void) { + unsigned low, size; + struct inflate_state state; + + memset(&state, 0, sizeof(state)); + buildfixedtables(&state); + puts("/* inffixed_tbl.h -- table for decoding fixed codes"); + puts(" * Generated automatically by makefixed()."); + puts(" */"); + puts(""); + puts("/* WARNING: this file should *not* be used by applications."); + puts(" * It is part of the implementation of this library and is"); + puts(" * subject to change. Applications should only use zlib.h."); + puts(" */"); + puts(""); + size = 1U << 9; + printf("static const code lenfix[%u] = {", size); + low = 0; + for (;;) { + if ((low % 7) == 0) + printf("\n "); + printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op, + state.lencode[low].bits, state.lencode[low].val); + if (++low == size) + break; + putchar(','); + } + puts("\n};"); + size = 1U << 5; + printf("\nstatic const code distfix[%u] = {", size); + low = 0; + for (;;) { + if ((low % 6) == 0) + printf("\n "); + printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, state.distcode[low].val); + if (++low == size) + break; + putchar(','); + } + puts("\n};"); +} + +// The output of this application can be piped out to recreate inffixed_tbl.h +int main(void) { + makefixed(); + return 0; +} diff --git a/libs/zlibng/tools/maketrees.c b/libs/zlibng/tools/maketrees.c new file mode 100644 index 000000000..337f2fc07 --- /dev/null +++ b/libs/zlibng/tools/maketrees.c @@ -0,0 +1,147 @@ +/* maketrees.c -- output static huffman trees + * Copyright (C) 1995-2017 Jean-loup Gailly + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include +#include "zbuild.h" +#include "deflate.h" +#include "trees.h" + +static ct_data static_ltree[L_CODES+2]; +/* The static literal tree. Since the bit lengths are imposed, there is no + * need for the L_CODES extra codes used during heap construction. However + * The codes 286 and 287 are needed to build a canonical tree (see zng_tr_init). + */ + +static ct_data static_dtree[D_CODES]; +/* The static distance tree. (Actually a trivial tree since all codes use 5 bits.) + */ + +static unsigned char dist_code[DIST_CODE_LEN]; +/* Distance codes. The first 256 values correspond to the distances 3 .. 258, + * the last 256 values correspond to the top 8 bits of the 15 bit distances. + */ + +static unsigned char length_code[MAX_MATCH-MIN_MATCH+1]; +/* length code for each normalized match length (0 == MIN_MATCH) */ + +static int base_length[LENGTH_CODES]; +/* First normalized length for each code (0 = MIN_MATCH) */ + +static int base_dist[D_CODES]; +/* First normalized distance for each code (0 = distance of 1) */ + + +static void tr_static_init(void) { + int n; /* iterates over tree elements */ + int bits; /* bit counter */ + int length; /* length value */ + int code; /* code value */ + int dist; /* distance index */ + uint16_t bl_count[MAX_BITS+1]; + /* number of codes at each bit length for an optimal tree */ + + /* Initialize the mapping length (0..255) -> length code (0..28) */ + length = 0; + for (code = 0; code < LENGTH_CODES-1; code++) { + base_length[code] = length; + for (n = 0; n < (1 << extra_lbits[code]); n++) { + length_code[length++] = (unsigned char)code; + } + } + Assert(length == 256, "tr_static_init: length != 256"); + /* Note that the length 255 (match length 258) can be represented in two different + * ways: code 284 + 5 bits or code 285, so we overwrite length_code[255] to use the best encoding: + */ + length_code[length-1] = (unsigned char)code; + + /* Initialize the mapping dist (0..32K) -> dist code (0..29) */ + dist = 0; + for (code = 0; code < 16; code++) { + base_dist[code] = dist; + for (n = 0; n < (1 << extra_dbits[code]); n++) { + dist_code[dist++] = (unsigned char)code; + } + } + Assert(dist == 256, "tr_static_init: dist != 256"); + dist >>= 7; /* from now on, all distances are divided by 128 */ + for ( ; code < D_CODES; code++) { + base_dist[code] = dist << 7; + for (n = 0; n < (1 << (extra_dbits[code]-7)); n++) { + dist_code[256 + dist++] = (unsigned char)code; + } + } + Assert(dist == 256, "tr_static_init: 256+dist != 512"); + + /* Construct the codes of the static literal tree */ + for (bits = 0; bits <= MAX_BITS; bits++) + bl_count[bits] = 0; + n = 0; + while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++; + while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++; + while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++; + while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++; + /* Codes 286 and 287 do not exist, but we must include them in the tree construction + * to get a canonical Huffman tree (longest code all ones) + */ + gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count); + + /* The static distance tree is trivial: */ + for (n = 0; n < D_CODES; n++) { + static_dtree[n].Len = 5; + static_dtree[n].Code = (uint16_t)bi_reverse((unsigned)n, 5); + } +} + +# define SEPARATOR(i, last, width) \ + ((i) == (last)? "\n};\n\n" : \ + ((i) % (width) == (width)-1 ? ",\n" : ", ")) + +static void gen_trees_header() { + int i; + + printf("#ifndef TREES_TBL_H_\n"); + printf("#define TREES_TBL_H_\n\n"); + + printf("/* header created automatically with maketrees.c */\n\n"); + + printf("Z_INTERNAL const ct_data static_ltree[L_CODES+2] = {\n"); + for (i = 0; i < L_CODES+2; i++) { + printf("{{%3u},{%u}}%s", static_ltree[i].Code, static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5)); + } + + printf("Z_INTERNAL const ct_data static_dtree[D_CODES] = {\n"); + for (i = 0; i < D_CODES; i++) { + printf("{{%2u},{%u}}%s", static_dtree[i].Code, static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5)); + } + + printf("const unsigned char Z_INTERNAL zng_dist_code[DIST_CODE_LEN] = {\n"); + for (i = 0; i < DIST_CODE_LEN; i++) { + printf("%2u%s", dist_code[i], SEPARATOR(i, DIST_CODE_LEN-1, 20)); + } + + printf("const unsigned char Z_INTERNAL zng_length_code[MAX_MATCH-MIN_MATCH+1] = {\n"); + for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) { + printf("%2u%s", length_code[i], SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20)); + } + + printf("Z_INTERNAL const int base_length[LENGTH_CODES] = {\n"); + for (i = 0; i < LENGTH_CODES; i++) { + printf("%d%s", base_length[i], SEPARATOR(i, LENGTH_CODES-1, 20)); + } + + printf("Z_INTERNAL const int base_dist[D_CODES] = {\n"); + for (i = 0; i < D_CODES; i++) { + printf("%5d%s", base_dist[i], SEPARATOR(i, D_CODES-1, 10)); + } + + printf("#endif /* TREES_TBL_H_ */\n"); +} + +// The output of this application can be piped out to recreate trees.h +int main(void) { + tr_static_init(); + gen_trees_header(); + return 0; +} diff --git a/libs/zlibng/treebuild.xml b/libs/zlibng/treebuild.xml deleted file mode 100644 index fd75525f9..000000000 --- a/libs/zlibng/treebuild.xml +++ /dev/null @@ -1,116 +0,0 @@ - - - - zip compression library - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/libs/zlibng/trees.c b/libs/zlibng/trees.c index 53c73bde1..efd4d49fb 100644 --- a/libs/zlibng/trees.c +++ b/libs/zlibng/trees.c @@ -30,44 +30,12 @@ * Addison-Wesley, 1983. ISBN 0-201-06672-6. */ -/* @(#) $Id$ */ - -/* #define GEN_TREES_H */ - #include "zbuild.h" #include "deflate.h" +#include "trees.h" +#include "trees_emit.h" +#include "trees_tbl.h" -#ifdef ZLIB_DEBUG -# include -#endif - -/* =========================================================================== - * Constants - */ - -#define MAX_BL_BITS 7 -/* Bit length codes must not exceed MAX_BL_BITS bits */ - -#define REP_3_6 16 -/* repeat previous bit length 3-6 times (2 bits of repeat count) */ - -#define REPZ_3_10 17 -/* repeat a zero length 3-10 times (3 bits of repeat count) */ - -#define REPZ_11_138 18 -/* repeat a zero length 11-138 times (7 bits of repeat count) */ - -static const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */ - = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0}; - -static const int extra_dbits[D_CODES] /* extra bits for each distance code */ - = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; - -static const int extra_blbits[BL_CODES] /* extra bits for each bit length code */ - = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7}; - -static const unsigned char bl_order[BL_CODES] - = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15}; /* The lengths of the bit length codes are sent in order of decreasing * probability, to avoid transmitting the lengths for unused bit length codes. */ @@ -76,42 +44,6 @@ static const unsigned char bl_order[BL_CODES] * Local data. These are initialized only once. */ -#define DIST_CODE_LEN 512 /* see definition of array dist_code below */ - -#if defined(GEN_TREES_H) -/* non ANSI compilers may not accept trees.h */ - -ZLIB_INTERNAL ct_data static_ltree[L_CODES+2]; -/* The static literal tree. Since the bit lengths are imposed, there is no - * need for the L_CODES extra codes used during heap construction. However - * The codes 286 and 287 are needed to build a canonical tree (see _tr_init - * below). - */ - -static ct_data static_dtree[D_CODES]; -/* The static distance tree. (Actually a trivial tree since all codes use - * 5 bits.) - */ - -unsigned char _dist_code[DIST_CODE_LEN]; -/* Distance codes. The first 256 values correspond to the distances - * 3 .. 258, the last 256 values correspond to the top 8 bits of - * the 15 bit distances. - */ - -unsigned char _length_code[MAX_MATCH-MIN_MATCH+1]; -/* length code for each normalized match length (0 == MIN_MATCH) */ - -static int base_length[LENGTH_CODES]; -/* First normalized length for each code (0 = MIN_MATCH) */ - -static int base_dist[D_CODES]; -/* First normalized distance for each code (0 = distance of 1) */ - -#else -# include "trees.h" -#endif /* GEN_TREES_H */ - struct static_tree_desc_s { const ct_data *static_tree; /* static tree or NULL */ const int *extra_bits; /* extra bits for each code or NULL */ @@ -133,11 +65,9 @@ static const static_tree_desc static_bl_desc = * Local (static) routines in this file. */ -static void tr_static_init (void); static void init_block (deflate_state *s); static void pqdownheap (deflate_state *s, ct_data *tree, int k); static void gen_bitlen (deflate_state *s, tree_desc *desc); -static void gen_codes (ct_data *tree, int max_code, uint16_t *bl_count); static void build_tree (deflate_state *s, tree_desc *desc); static void scan_tree (deflate_state *s, ct_data *tree, int max_code); static void send_tree (deflate_state *s, ct_data *tree, int max_code); @@ -147,159 +77,10 @@ static void compress_block (deflate_state *s, const ct_data *ltree, const ct_d static int detect_data_type (deflate_state *s); static void bi_flush (deflate_state *s); -#ifdef GEN_TREES_H -static void gen_trees_header (void); -#endif - -/* =========================================================================== - * Initialize the various 'constant' tables. - */ -static void tr_static_init(void) { -#if defined(GEN_TREES_H) - static int static_init_done = 0; - int n; /* iterates over tree elements */ - int bits; /* bit counter */ - int length; /* length value */ - int code; /* code value */ - int dist; /* distance index */ - uint16_t bl_count[MAX_BITS+1]; - /* number of codes at each bit length for an optimal tree */ - - if (static_init_done) - return; - - /* For some embedded targets, global variables are not initialized: */ -#ifdef NO_INIT_GLOBAL_POINTERS - static_l_desc.static_tree = static_ltree; - static_l_desc.extra_bits = extra_lbits; - static_d_desc.static_tree = static_dtree; - static_d_desc.extra_bits = extra_dbits; - static_bl_desc.extra_bits = extra_blbits; -#endif - - /* Initialize the mapping length (0..255) -> length code (0..28) */ - length = 0; - for (code = 0; code < LENGTH_CODES-1; code++) { - base_length[code] = length; - for (n = 0; n < (1 << extra_lbits[code]); n++) { - _length_code[length++] = (unsigned char)code; - } - } - Assert(length == 256, "tr_static_init: length != 256"); - /* Note that the length 255 (match length 258) can be represented - * in two different ways: code 284 + 5 bits or code 285, so we - * overwrite length_code[255] to use the best encoding: - */ - _length_code[length-1] = (unsigned char)code; - - /* Initialize the mapping dist (0..32K) -> dist code (0..29) */ - dist = 0; - for (code = 0 ; code < 16; code++) { - base_dist[code] = dist; - for (n = 0; n < (1 << extra_dbits[code]); n++) { - _dist_code[dist++] = (unsigned char)code; - } - } - Assert(dist == 256, "tr_static_init: dist != 256"); - dist >>= 7; /* from now on, all distances are divided by 128 */ - for ( ; code < D_CODES; code++) { - base_dist[code] = dist << 7; - for (n = 0; n < (1 << (extra_dbits[code]-7)); n++) { - _dist_code[256 + dist++] = (unsigned char)code; - } - } - Assert(dist == 256, "tr_static_init: 256+dist != 512"); - - /* Construct the codes of the static literal tree */ - for (bits = 0; bits <= MAX_BITS; bits++) - bl_count[bits] = 0; - n = 0; - while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++; - while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++; - while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++; - while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++; - /* Codes 286 and 287 do not exist, but we must include them in the - * tree construction to get a canonical Huffman tree (longest code - * all ones) - */ - gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count); - - /* The static distance tree is trivial: */ - for (n = 0; n < D_CODES; n++) { - static_dtree[n].Len = 5; - static_dtree[n].Code = bi_reverse((unsigned)n, 5); - } - static_init_done = 1; - -# ifdef GEN_TREES_H - gen_trees_header(); -# endif -#endif /* defined(GEN_TREES_H) */ -} - -/* =========================================================================== - * Genererate the file trees.h describing the static trees. - */ -#ifdef GEN_TREES_H -# ifndef ZLIB_DEBUG -# include -# endif - -# define SEPARATOR(i, last, width) \ - ((i) == (last)? "\n};\n\n" : \ - ((i) % (width) == (width)-1 ? ",\n" : ", ")) - -void gen_trees_header() { - FILE *header = fopen("trees.h", "w"); - int i; - - Assert(header != NULL, "Can't open trees.h"); - fprintf(header, "#ifndef TREES_H_\n"); - fprintf(header, "#define TREES_H_\n\n"); - - fprintf(header, "/* header created automatically with -DGEN_TREES_H */\n\n"); - - fprintf(header, "ZLIB_INTERNAL const ct_data static_ltree[L_CODES+2] = {\n"); - for (i = 0; i < L_CODES+2; i++) { - fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code, static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5)); - } - - fprintf(header, "static const ct_data static_dtree[D_CODES] = {\n"); - for (i = 0; i < D_CODES; i++) { - fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code, static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5)); - } - - fprintf(header, "const unsigned char ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {\n"); - for (i = 0; i < DIST_CODE_LEN; i++) { - fprintf(header, "%2u%s", _dist_code[i], SEPARATOR(i, DIST_CODE_LEN-1, 20)); - } - - fprintf(header, "const unsigned char ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {\n"); - for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) { - fprintf(header, "%2u%s", _length_code[i], SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20)); - } - - fprintf(header, "static const int base_length[LENGTH_CODES] = {\n"); - for (i = 0; i < LENGTH_CODES; i++) { - fprintf(header, "%d%s", base_length[i], SEPARATOR(i, LENGTH_CODES-1, 20)); - } - - fprintf(header, "static const int base_dist[D_CODES] = {\n"); - for (i = 0; i < D_CODES; i++) { - fprintf(header, "%5d%s", base_dist[i], SEPARATOR(i, D_CODES-1, 10)); - } - - fprintf(header, "#endif /* TREES_H_ */\n"); - fclose(header); -} -#endif /* GEN_TREES_H */ - /* =========================================================================== * Initialize the tree data structures for a new zlib stream. */ -void ZLIB_INTERNAL _tr_init(deflate_state *s) { - tr_static_init(); - +void Z_INTERNAL zng_tr_init(deflate_state *s) { s->l_desc.dyn_tree = s->dyn_ltree; s->l_desc.stat_desc = &static_l_desc; @@ -425,11 +206,13 @@ static void gen_bitlen(deflate_state *s, tree_desc *desc) { */ tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */ - for (h = s->heap_max+1; h < HEAP_SIZE; h++) { + for (h = s->heap_max + 1; h < HEAP_SIZE; h++) { n = s->heap[h]; - bits = tree[tree[n].Dad].Len + 1; - if (bits > max_length) - bits = max_length, overflow++; + bits = tree[tree[n].Dad].Len + 1u; + if (bits > max_length){ + bits = max_length; + overflow++; + } tree[n].Len = (uint16_t)bits; /* We overwrite tree[n].Dad which is no longer needed */ @@ -453,11 +236,11 @@ static void gen_bitlen(deflate_state *s, tree_desc *desc) { /* Find the first bit length which could increase: */ do { - bits = max_length-1; + bits = max_length - 1; while (s->bl_count[bits] == 0) bits--; - s->bl_count[bits]--; /* move one leaf down the tree */ - s->bl_count[bits+1] += 2; /* move one overflow item as its brother */ + s->bl_count[bits]--; /* move one leaf down the tree */ + s->bl_count[bits+1] += 2u; /* move one overflow item as its brother */ s->bl_count[max_length]--; /* The brother of the overflow item also moves one step up, * but this does not affect bl_count[max_length] @@ -495,7 +278,7 @@ static void gen_bitlen(deflate_state *s, tree_desc *desc) { * OUT assertion: the field code is set for all tree elements of non * zero code length. */ -static void gen_codes(ct_data *tree, int max_code, uint16_t *bl_count) { +Z_INTERNAL void gen_codes(ct_data *tree, int max_code, uint16_t *bl_count) { /* tree: the tree to decorate */ /* max_code: largest code with non zero frequency */ /* bl_count: number of codes at each bit length */ @@ -550,7 +333,8 @@ static void build_tree(deflate_state *s, tree_desc *desc) { * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. * heap[0] is not used. */ - s->heap_len = 0, s->heap_max = HEAP_SIZE; + s->heap_len = 0; + s->heap_max = HEAP_SIZE; for (n = 0; n < elems; n++) { if (tree[n].Freq != 0) { @@ -632,12 +416,12 @@ static void scan_tree(deflate_state *s, ct_data *tree, int max_code) { int prevlen = -1; /* last emitted length */ int curlen; /* length of current code */ int nextlen = tree[0].Len; /* length of next code */ - int count = 0; /* repeat count of the current code */ - int max_count = 7; /* max repeat count */ - int min_count = 4; /* min repeat count */ + uint16_t count = 0; /* repeat count of the current code */ + uint16_t max_count = 7; /* max repeat count */ + uint16_t min_count = 4; /* min repeat count */ if (nextlen == 0) - max_count = 138, min_count = 3; + max_count = 138, min_count = 3; tree[max_code+1].Len = (uint16_t)0xffff; /* guard */ @@ -688,6 +472,10 @@ static void send_tree(deflate_state *s, ct_data *tree, int max_code) { if (nextlen == 0) max_count = 138, min_count = 3; + // Temp local variables + uint32_t bi_valid = s->bi_valid; + uint64_t bi_buf = s->bi_buf; + for (n = 0; n <= max_code; n++) { curlen = nextlen; nextlen = tree[n+1].Len; @@ -695,25 +483,25 @@ static void send_tree(deflate_state *s, ct_data *tree, int max_code) { continue; } else if (count < min_count) { do { - send_code(s, curlen, s->bl_tree); + send_code(s, curlen, s->bl_tree, bi_buf, bi_valid); } while (--count != 0); } else if (curlen != 0) { if (curlen != prevlen) { - send_code(s, curlen, s->bl_tree); + send_code(s, curlen, s->bl_tree, bi_buf, bi_valid); count--; } Assert(count >= 3 && count <= 6, " 3_6?"); - send_code(s, REP_3_6, s->bl_tree); - send_bits(s, count-3, 2); + send_code(s, REP_3_6, s->bl_tree, bi_buf, bi_valid); + send_bits(s, count-3, 2, bi_buf, bi_valid); } else if (count <= 10) { - send_code(s, REPZ_3_10, s->bl_tree); - send_bits(s, count-3, 3); + send_code(s, REPZ_3_10, s->bl_tree, bi_buf, bi_valid); + send_bits(s, count-3, 3, bi_buf, bi_valid); } else { - send_code(s, REPZ_11_138, s->bl_tree); - send_bits(s, count-11, 7); + send_code(s, REPZ_11_138, s->bl_tree, bi_buf, bi_valid); + send_bits(s, count-11, 7, bi_buf, bi_valid); } count = 0; prevlen = curlen; @@ -725,6 +513,10 @@ static void send_tree(deflate_state *s, ct_data *tree, int max_code) { max_count = 7, min_count = 4; } } + + // Store back temp variables + s->bi_buf = bi_buf; + s->bi_valid = bi_valid; } /* =========================================================================== @@ -769,16 +561,25 @@ static void send_all_trees(deflate_state *s, int lcodes, int dcodes, int blcodes Assert(lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); Assert(lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, "too many codes"); + + // Temp local variables + uint32_t bi_valid = s->bi_valid; + uint64_t bi_buf = s->bi_buf; + Tracev((stderr, "\nbl counts: ")); - send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */ - send_bits(s, dcodes-1, 5); - send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */ + send_bits(s, lcodes-257, 5, bi_buf, bi_valid); /* not +255 as stated in appnote.txt */ + send_bits(s, dcodes-1, 5, bi_buf, bi_valid); + send_bits(s, blcodes-4, 4, bi_buf, bi_valid); /* not -3 as stated in appnote.txt */ for (rank = 0; rank < blcodes; rank++) { Tracev((stderr, "\nbl code %2u ", bl_order[rank])); - send_bits(s, s->bl_tree[bl_order[rank]].Len, 3); + send_bits(s, s->bl_tree[bl_order[rank]].Len, 3, bi_buf, bi_valid); } Tracev((stderr, "\nbl tree: sent %lu", s->bits_sent)); + // Store back temp variables + s->bi_buf = bi_buf; + s->bi_valid = bi_valid; + send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */ Tracev((stderr, "\nlit tree: sent %lu", s->bits_sent)); @@ -789,29 +590,29 @@ static void send_all_trees(deflate_state *s, int lcodes, int dcodes, int blcodes /* =========================================================================== * Send a stored block */ -void ZLIB_INTERNAL _tr_stored_block(deflate_state *s, char *buf, unsigned long stored_len, int last) { +void Z_INTERNAL zng_tr_stored_block(deflate_state *s, char *buf, uint32_t stored_len, int last) { /* buf: input block */ /* stored_len: length of input block */ /* last: one if this is the last block for a file */ - send_bits(s, (STORED_BLOCK << 1)+last, 3); /* send block type */ - bi_windup(s); /* align on byte boundary */ + zng_tr_emit_tree(s, STORED_BLOCK, last); /* send block type */ + zng_tr_emit_align(s); /* align on byte boundary */ + cmpr_bits_align(s); put_short(s, (uint16_t)stored_len); put_short(s, (uint16_t)~stored_len); - if (stored_len) + cmpr_bits_add(s, 32); + sent_bits_add(s, 32); + if (stored_len) { memcpy(s->pending_buf + s->pending, (unsigned char *)buf, stored_len); - s->pending += stored_len; -#ifdef ZLIB_DEBUG - s->compressed_len = (s->compressed_len + 3 + 7) & (unsigned long)~7L; - s->compressed_len += (stored_len + 4) << 3; - s->bits_sent += 2*16; - s->bits_sent += stored_len<<3; -#endif + s->pending += stored_len; + cmpr_bits_add(s, stored_len << 3); + sent_bits_add(s, stored_len << 3); + } } /* =========================================================================== * Flush the bits in the bit buffer to pending output (leaves at most 7 bits) */ -void ZLIB_INTERNAL _tr_flush_bits(deflate_state *s) { +void Z_INTERNAL zng_tr_flush_bits(deflate_state *s) { bi_flush(s); } @@ -819,12 +620,9 @@ void ZLIB_INTERNAL _tr_flush_bits(deflate_state *s) { * Send one empty static block to give enough lookahead for inflate. * This takes 10 bits, of which 7 may remain in the bit buffer. */ -void ZLIB_INTERNAL _tr_align(deflate_state *s) { - send_bits(s, STATIC_TREES << 1, 3); - send_code(s, END_BLOCK, static_ltree); -#ifdef ZLIB_DEBUG - s->compressed_len += 10L; /* 3 for block type, 7 for EOB */ -#endif +void Z_INTERNAL zng_tr_align(deflate_state *s) { + zng_tr_emit_tree(s, STATIC_TREES, 0); + zng_tr_emit_end_block(s, static_ltree, 0); bi_flush(s); } @@ -832,7 +630,7 @@ void ZLIB_INTERNAL _tr_align(deflate_state *s) { * Determine the best encoding for the current block: dynamic trees, static * trees or store, and write out the encoded block. */ -void ZLIB_INTERNAL _tr_flush_block(deflate_state *s, char *buf, unsigned long stored_len, int last) { +void Z_INTERNAL zng_tr_flush_block(deflate_state *s, char *buf, uint32_t stored_len, int last) { /* buf: input block, or NULL if too old */ /* stored_len: length of input block */ /* last: one if this is the last block for a file */ @@ -840,7 +638,11 @@ void ZLIB_INTERNAL _tr_flush_block(deflate_state *s, char *buf, unsigned long st int max_blindex = 0; /* index of last bit length code of non zero freq */ /* Build the Huffman trees unless a stored block is forced */ - if (s->level > 0) { + if (UNLIKELY(s->sym_next == 0)) { + /* Emit an empty static tree block with no codes */ + opt_lenb = static_lenb = 0; + s->static_len = 7; + } else if (s->level > 0) { /* Check if the file is binary or text */ if (s->strm->data_type == Z_UNKNOWN) s->strm->data_type = detect_data_type(s); @@ -864,7 +666,7 @@ void ZLIB_INTERNAL _tr_flush_block(deflate_state *s, char *buf, unsigned long st opt_lenb = (s->opt_len+3+7) >> 3; static_lenb = (s->static_len+3+7) >> 3; - Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", + Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %u lit %u ", opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, s->sym_next / 3)); @@ -876,37 +678,25 @@ void ZLIB_INTERNAL _tr_flush_block(deflate_state *s, char *buf, unsigned long st opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ } -#ifdef FORCE_STORED - if (buf != NULL) { /* force stored block */ -#else if (stored_len+4 <= opt_lenb && buf != NULL) { - /* 4: two words for the lengths */ -#endif - /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. + /* 4: two words for the lengths + * The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. * Otherwise we can't have processed more than WSIZE input bytes since * the last block flush, because compression would have been * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to * transform a block into a stored block. */ - _tr_stored_block(s, buf, stored_len, last); + zng_tr_stored_block(s, buf, stored_len, last); -#ifdef FORCE_STATIC - } else if (static_lenb >= 0) { /* force static trees */ -#else } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) { -#endif - send_bits(s, (STATIC_TREES << 1)+last, 3); + zng_tr_emit_tree(s, STATIC_TREES, last); compress_block(s, (const ct_data *)static_ltree, (const ct_data *)static_dtree); -#ifdef ZLIB_DEBUG - s->compressed_len += 3 + s->static_len; -#endif + cmpr_bits_add(s, s->static_len); } else { - send_bits(s, (DYN_TREES << 1)+last, 3); + zng_tr_emit_tree(s, DYN_TREES, last); send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1, max_blindex+1); compress_block(s, (const ct_data *)s->dyn_ltree, (const ct_data *)s->dyn_dtree); -#ifdef ZLIB_DEBUG - s->compressed_len += 3 + s->opt_len; -#endif + cmpr_bits_add(s, s->opt_len); } Assert(s->compressed_len == s->bits_sent, "bad compressed size"); /* The above check is made mod 2^32, for files larger than 512 MB @@ -915,41 +705,11 @@ void ZLIB_INTERNAL _tr_flush_block(deflate_state *s, char *buf, unsigned long st init_block(s); if (last) { - bi_windup(s); -#ifdef ZLIB_DEBUG - s->compressed_len += 7; /* align on byte boundary */ -#endif + zng_tr_emit_align(s); } Tracev((stderr, "\ncomprlen %lu(%lu) ", s->compressed_len>>3, s->compressed_len-7*last)); } -/* =========================================================================== - * Save the match info and tally the frequency counts. Return true if - * the current block must be flushed. - */ -int ZLIB_INTERNAL _tr_tally(deflate_state *s, unsigned dist, unsigned lc) { - /* dist: distance of matched string */ - /* lc: match length-MIN_MATCH or unmatched char (if dist==0) */ - s->sym_buf[s->sym_next++] = dist; - s->sym_buf[s->sym_next++] = dist >> 8; - s->sym_buf[s->sym_next++] = lc; - if (dist == 0) { - /* lc is the unmatched char */ - s->dyn_ltree[lc].Freq++; - } else { - s->matches++; - /* Here, lc is the match length - MIN_MATCH */ - dist--; /* dist = match distance - 1 */ - Assert((uint16_t)dist < (uint16_t)MAX_DIST(s) && - (uint16_t)lc <= (uint16_t)(MAX_MATCH-MIN_MATCH) && - (uint16_t)d_code(dist) < (uint16_t)D_CODES, "_tr_tally: bad match"); - - s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++; - s->dyn_dtree[d_code(dist)].Freq++; - } - return (s->sym_next == s->sym_end); -} - /* =========================================================================== * Send the block data compressed using the given Huffman trees */ @@ -959,8 +719,6 @@ static void compress_block(deflate_state *s, const ct_data *ltree, const ct_data unsigned dist; /* distance of matched string */ int lc; /* match length or unmatched char (if dist == 0) */ unsigned sx = 0; /* running index in sym_buf */ - int code; /* the code to send */ - int extra; /* number of extra bits to send */ if (s->sym_next != 0) { do { @@ -968,35 +726,17 @@ static void compress_block(deflate_state *s, const ct_data *ltree, const ct_data dist += (unsigned)(s->sym_buf[sx++] & 0xff) << 8; lc = s->sym_buf[sx++]; if (dist == 0) { - send_code(s, lc, ltree); /* send a literal byte */ - Tracecv(isgraph(lc), (stderr, " '%c' ", lc)); + zng_emit_lit(s, ltree, lc); } else { - /* Here, lc is the match length - MIN_MATCH */ - code = _length_code[lc]; - send_code(s, code+LITERALS+1, ltree); /* send the length code */ - extra = extra_lbits[code]; - if (extra != 0) { - lc -= base_length[code]; - send_bits(s, lc, extra); /* send the extra length bits */ - } - dist--; /* dist is now the match distance - 1 */ - code = d_code(dist); - Assert(code < D_CODES, "bad d_code"); - - send_code(s, code, dtree); /* send the distance code */ - extra = extra_dbits[code]; - if (extra != 0) { - dist -= (unsigned int)base_dist[code]; - send_bits(s, dist, extra); /* send the extra distance bits */ - } + zng_emit_dist(s, ltree, dtree, lc, dist); } /* literal or match pair ? */ /* Check that the overlay between pending_buf and sym_buf is ok: */ - Assert(s->pending < s->lit_bufsize + sx, "pendingBuf overflow"); + Assert(s->pending < s->lit_bufsize + sx, "pending_buf overflow"); } while (sx < s->sym_next); } - send_code(s, END_BLOCK, ltree); + zng_emit_end_block(s, ltree, 0); } /* =========================================================================== @@ -1038,49 +778,45 @@ static int detect_data_type(deflate_state *s) { return Z_BINARY; } +/* =========================================================================== + * Flush the bit buffer, keeping at most 7 bits in it. + */ +static void bi_flush(deflate_state *s) { + if (s->bi_valid == 64) { + put_uint64(s, s->bi_buf); + s->bi_buf = 0; + s->bi_valid = 0; + } else { + if (s->bi_valid >= 32) { + put_uint32(s, (uint32_t)s->bi_buf); + s->bi_buf >>= 32; + s->bi_valid -= 32; + } + if (s->bi_valid >= 16) { + put_short(s, (uint16_t)s->bi_buf); + s->bi_buf >>= 16; + s->bi_valid -= 16; + } + if (s->bi_valid >= 8) { + put_byte(s, s->bi_buf); + s->bi_buf >>= 8; + s->bi_valid -= 8; + } + } +} + /* =========================================================================== * Reverse the first len bits of a code, using straightforward code (a faster * method would use a table) * IN assertion: 1 <= len <= 15 */ -ZLIB_INTERNAL unsigned bi_reverse(unsigned code, int len) { +Z_INTERNAL unsigned bi_reverse(unsigned code, int len) { /* code: the value to invert */ /* len: its bit length */ - register unsigned res = 0; + Z_REGISTER unsigned res = 0; do { res |= code & 1; code >>= 1, res <<= 1; } while (--len > 0); return res >> 1; } - -/* =========================================================================== - * Flush the bit buffer, keeping at most 7 bits in it. - */ -static void bi_flush(deflate_state *s) { - if (s->bi_valid == 16) { - put_short(s, s->bi_buf); - s->bi_buf = 0; - s->bi_valid = 0; - } else if (s->bi_valid >= 8) { - put_byte(s, (unsigned char)s->bi_buf); - s->bi_buf >>= 8; - s->bi_valid -= 8; - } -} - -/* =========================================================================== - * Flush the bit buffer and align the output on a byte boundary - */ -ZLIB_INTERNAL void bi_windup(deflate_state *s) { - if (s->bi_valid > 8) { - put_short(s, s->bi_buf); - } else if (s->bi_valid > 0) { - put_byte(s, (unsigned char)s->bi_buf); - } - s->bi_buf = 0; - s->bi_valid = 0; -#ifdef ZLIB_DEBUG - s->bits_sent = (s->bits_sent+7) & ~7; -#endif -} diff --git a/libs/zlibng/trees.h b/libs/zlibng/trees.h index 6fc1c8485..e57f92648 100644 --- a/libs/zlibng/trees.h +++ b/libs/zlibng/trees.h @@ -1,132 +1,40 @@ #ifndef TREES_H_ #define TREES_H_ -/* header created automatically with -DGEN_TREES_H */ +/* Constants */ -ZLIB_INTERNAL const ct_data static_ltree[L_CODES+2] = { -{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}}, -{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}}, -{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}}, -{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}}, -{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}}, -{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}}, -{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}}, -{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}}, -{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}}, -{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}}, -{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}}, -{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}}, -{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}}, -{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}}, -{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}}, -{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}}, -{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}}, -{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}}, -{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}}, -{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}}, -{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}}, -{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}}, -{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}}, -{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}}, -{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}}, -{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}}, -{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}}, -{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}}, -{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}}, -{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}}, -{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}}, -{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}}, -{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}}, -{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}}, -{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}}, -{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}}, -{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}}, -{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}}, -{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}}, -{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}}, -{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}}, -{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}}, -{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}}, -{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}}, -{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}}, -{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}}, -{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}}, -{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}}, -{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}}, -{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}}, -{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}}, -{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}}, -{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}}, -{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}}, -{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}}, -{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}}, -{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}}, -{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}} -}; +#define DIST_CODE_LEN 512 +/* see definition of array dist_code in trees.c */ -static const ct_data static_dtree[D_CODES] = { -{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}}, -{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}}, -{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}}, -{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}}, -{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}}, -{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}} -}; +#define MAX_BL_BITS 7 +/* Bit length codes must not exceed MAX_BL_BITS bits */ -const unsigned char ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = { - 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, - 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, -10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, -11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, -12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, -13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, -13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, -14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, -15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, -18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, -23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, -24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, -26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, -26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, -27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, -27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, -28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, -28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, -28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, -29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, -29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, -29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 -}; +#define REP_3_6 16 +/* repeat previous bit length 3-6 times (2 bits of repeat count) */ -const unsigned char ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= { - 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, -13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, -17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, -19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, -21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, -22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, -23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, -24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, -25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, -25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, -26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, -26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, -27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 -}; +#define REPZ_3_10 17 +/* repeat a zero length 3-10 times (3 bits of repeat count) */ -static const int base_length[LENGTH_CODES] = { -0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, -64, 80, 96, 112, 128, 160, 192, 224, 0 -}; +#define REPZ_11_138 18 +/* repeat a zero length 11-138 times (7 bits of repeat count) */ -static const int base_dist[D_CODES] = { - 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, - 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, - 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576 -}; +static const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */ + = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0}; -#endif /* TREES_H_ */ +static const int extra_dbits[D_CODES] /* extra bits for each distance code */ + = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static const int extra_blbits[BL_CODES] /* extra bits for each bit length code */ + = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7}; + +static const unsigned char bl_order[BL_CODES] + = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15}; + /* The lengths of the bit length codes are sent in order of decreasing + * probability, to avoid transmitting the lengths for unused bit length codes. + */ + + +/* Function definitions */ +void gen_codes (ct_data *tree, int max_code, uint16_t *bl_count); + +#endif diff --git a/libs/zlibng/trees_emit.h b/libs/zlibng/trees_emit.h new file mode 100644 index 000000000..118dbb2d8 --- /dev/null +++ b/libs/zlibng/trees_emit.h @@ -0,0 +1,228 @@ +#ifndef TREES_EMIT_H_ +#define TREES_EMIT_H_ + +#include "zbuild.h" +#include "trees.h" + +#ifdef ZLIB_DEBUG +# include +# include +# include +#endif + + +/* trees.h */ +extern Z_INTERNAL const ct_data static_ltree[L_CODES+2]; +extern Z_INTERNAL const ct_data static_dtree[D_CODES]; + +extern const unsigned char Z_INTERNAL zng_dist_code[DIST_CODE_LEN]; +extern const unsigned char Z_INTERNAL zng_length_code[MAX_MATCH-MIN_MATCH+1]; + +extern Z_INTERNAL const int base_length[LENGTH_CODES]; +extern Z_INTERNAL const int base_dist[D_CODES]; + +/* Bit buffer and deflate code stderr tracing */ +#ifdef ZLIB_DEBUG +# define send_bits_trace(s, value, length) { \ + Tracevv((stderr, " l %2d v %4llx ", (int)(length), (long long)(value))); \ + Assert(length > 0 && length <= BIT_BUF_SIZE, "invalid length"); \ + } +# define send_code_trace(s, c) \ + if (z_verbose > 2) { \ + fprintf(stderr, "\ncd %3d ", (c)); \ + } +#else +# define send_bits_trace(s, value, length) +# define send_code_trace(s, c) +#endif + +/* If not enough room in bi_buf, use (valid) bits from bi_buf and + * (64 - bi_valid) bits from value, leaving (width - (64-bi_valid)) + * unused bits in value. + */ +#define send_bits(s, t_val, t_len, bi_buf, bi_valid) {\ + uint64_t val = (uint64_t)t_val;\ + uint32_t len = (uint32_t)t_len;\ + uint32_t total_bits = bi_valid + len;\ + send_bits_trace(s, val, len);\ + sent_bits_add(s, len);\ + if (total_bits < BIT_BUF_SIZE) {\ + bi_buf |= val << bi_valid;\ + bi_valid = total_bits;\ + } else if (bi_valid == BIT_BUF_SIZE) {\ + put_uint64(s, bi_buf);\ + bi_buf = val;\ + bi_valid = len;\ + } else {\ + bi_buf |= val << bi_valid;\ + put_uint64(s, bi_buf);\ + bi_buf = val >> (BIT_BUF_SIZE - bi_valid);\ + bi_valid = total_bits - BIT_BUF_SIZE;\ + }\ +} + +/* Send a code of the given tree. c and tree must not have side effects */ +#ifdef ZLIB_DEBUG +# define send_code(s, c, tree, bi_buf, bi_valid) { \ + send_code_trace(s, c); \ + send_bits(s, tree[c].Code, tree[c].Len, bi_buf, bi_valid); \ +} +#else +# define send_code(s, c, tree, bi_buf, bi_valid) \ + send_bits(s, tree[c].Code, tree[c].Len, bi_buf, bi_valid) +#endif + +/* =========================================================================== + * Flush the bit buffer and align the output on a byte boundary + */ +static void bi_windup(deflate_state *s) { + if (s->bi_valid > 56) { + put_uint64(s, s->bi_buf); + } else { + if (s->bi_valid > 24) { + put_uint32(s, (uint32_t)s->bi_buf); + s->bi_buf >>= 32; + s->bi_valid -= 32; + } + if (s->bi_valid > 8) { + put_short(s, (uint16_t)s->bi_buf); + s->bi_buf >>= 16; + s->bi_valid -= 16; + } + if (s->bi_valid > 0) { + put_byte(s, s->bi_buf); + } + } + s->bi_buf = 0; + s->bi_valid = 0; +} + +/* =========================================================================== + * Emit literal code + */ +static inline uint32_t zng_emit_lit(deflate_state *s, const ct_data *ltree, unsigned c) { + uint32_t bi_valid = s->bi_valid; + uint64_t bi_buf = s->bi_buf; + + send_code(s, c, ltree, bi_buf, bi_valid); + + s->bi_valid = bi_valid; + s->bi_buf = bi_buf; + + Tracecv(isgraph(c), (stderr, " '%c' ", c)); + + return ltree[c].Len; +} + +/* =========================================================================== + * Emit match distance/length code + */ +static inline uint32_t zng_emit_dist(deflate_state *s, const ct_data *ltree, const ct_data *dtree, + uint32_t lc, uint32_t dist) { + uint32_t c, extra; + uint8_t code; + uint64_t match_bits; + uint32_t match_bits_len; + uint32_t bi_valid = s->bi_valid; + uint64_t bi_buf = s->bi_buf; + + /* Send the length code, len is the match length - MIN_MATCH */ + code = zng_length_code[lc]; + c = code+LITERALS+1; + Assert(c < L_CODES, "bad l_code"); + send_code_trace(s, c); + + match_bits = ltree[c].Code; + match_bits_len = ltree[c].Len; + extra = extra_lbits[code]; + if (extra != 0) { + lc -= base_length[code]; + match_bits |= ((uint64_t)lc << match_bits_len); + match_bits_len += extra; + } + + dist--; /* dist is now the match distance - 1 */ + code = d_code(dist); + Assert(code < D_CODES, "bad d_code"); + send_code_trace(s, code); + + /* Send the distance code */ + match_bits |= ((uint64_t)dtree[code].Code << match_bits_len); + match_bits_len += dtree[code].Len; + extra = extra_dbits[code]; + if (extra != 0) { + dist -= base_dist[code]; + match_bits |= ((uint64_t)dist << match_bits_len); + match_bits_len += extra; + } + + send_bits(s, match_bits, match_bits_len, bi_buf, bi_valid); + + s->bi_valid = bi_valid; + s->bi_buf = bi_buf; + + return match_bits_len; +} + +/* =========================================================================== + * Emit end block + */ +static inline void zng_emit_end_block(deflate_state *s, const ct_data *ltree, const int last) { + uint32_t bi_valid = s->bi_valid; + uint64_t bi_buf = s->bi_buf; + send_code(s, END_BLOCK, ltree, bi_buf, bi_valid); + s->bi_valid = bi_valid; + s->bi_buf = bi_buf; + Tracev((stderr, "\n+++ Emit End Block: Last: %u Pending: %u Total Out: %" PRIu64 "\n", + last, s->pending, (uint64_t)s->strm->total_out)); + (void)last; +} + +/* =========================================================================== + * Emit literal and count bits + */ +static inline void zng_tr_emit_lit(deflate_state *s, const ct_data *ltree, unsigned c) { + cmpr_bits_add(s, zng_emit_lit(s, ltree, c)); +} + +/* =========================================================================== + * Emit match and count bits + */ +static inline void zng_tr_emit_dist(deflate_state *s, const ct_data *ltree, const ct_data *dtree, + uint32_t lc, uint32_t dist) { + cmpr_bits_add(s, zng_emit_dist(s, ltree, dtree, lc, dist)); +} + +/* =========================================================================== + * Emit start of block + */ +static inline void zng_tr_emit_tree(deflate_state *s, int type, const int last) { + uint32_t bi_valid = s->bi_valid; + uint64_t bi_buf = s->bi_buf; + uint32_t header_bits = (type << 1) + last; + send_bits(s, header_bits, 3, bi_buf, bi_valid); + cmpr_bits_add(s, 3); + s->bi_valid = bi_valid; + s->bi_buf = bi_buf; + Tracev((stderr, "\n--- Emit Tree: Last: %u\n", last)); +} + +/* =========================================================================== + * Align bit buffer on a byte boundary and count bits + */ +static inline void zng_tr_emit_align(deflate_state *s) { + bi_windup(s); /* align on byte boundary */ + sent_bits_align(s); +} + +/* =========================================================================== + * Emit an end block and align bit buffer if last block + */ +static inline void zng_tr_emit_end_block(deflate_state *s, const ct_data *ltree, const int last) { + zng_emit_end_block(s, ltree, last); + cmpr_bits_add(s, 7); + if (last) + zng_tr_emit_align(s); +} + +#endif diff --git a/libs/zlibng/trees_tbl.h b/libs/zlibng/trees_tbl.h new file mode 100644 index 000000000..a4c68a566 --- /dev/null +++ b/libs/zlibng/trees_tbl.h @@ -0,0 +1,132 @@ +#ifndef TREES_TBL_H_ +#define TREES_TBL_H_ + +/* header created automatically with maketrees.c */ + +Z_INTERNAL const ct_data static_ltree[L_CODES+2] = { +{{ 12},{8}}, {{140},{8}}, {{ 76},{8}}, {{204},{8}}, {{ 44},{8}}, +{{172},{8}}, {{108},{8}}, {{236},{8}}, {{ 28},{8}}, {{156},{8}}, +{{ 92},{8}}, {{220},{8}}, {{ 60},{8}}, {{188},{8}}, {{124},{8}}, +{{252},{8}}, {{ 2},{8}}, {{130},{8}}, {{ 66},{8}}, {{194},{8}}, +{{ 34},{8}}, {{162},{8}}, {{ 98},{8}}, {{226},{8}}, {{ 18},{8}}, +{{146},{8}}, {{ 82},{8}}, {{210},{8}}, {{ 50},{8}}, {{178},{8}}, +{{114},{8}}, {{242},{8}}, {{ 10},{8}}, {{138},{8}}, {{ 74},{8}}, +{{202},{8}}, {{ 42},{8}}, {{170},{8}}, {{106},{8}}, {{234},{8}}, +{{ 26},{8}}, {{154},{8}}, {{ 90},{8}}, {{218},{8}}, {{ 58},{8}}, +{{186},{8}}, {{122},{8}}, {{250},{8}}, {{ 6},{8}}, {{134},{8}}, +{{ 70},{8}}, {{198},{8}}, {{ 38},{8}}, {{166},{8}}, {{102},{8}}, +{{230},{8}}, {{ 22},{8}}, {{150},{8}}, {{ 86},{8}}, {{214},{8}}, +{{ 54},{8}}, {{182},{8}}, {{118},{8}}, {{246},{8}}, {{ 14},{8}}, +{{142},{8}}, {{ 78},{8}}, {{206},{8}}, {{ 46},{8}}, {{174},{8}}, +{{110},{8}}, {{238},{8}}, {{ 30},{8}}, {{158},{8}}, {{ 94},{8}}, +{{222},{8}}, {{ 62},{8}}, {{190},{8}}, {{126},{8}}, {{254},{8}}, +{{ 1},{8}}, {{129},{8}}, {{ 65},{8}}, {{193},{8}}, {{ 33},{8}}, +{{161},{8}}, {{ 97},{8}}, {{225},{8}}, {{ 17},{8}}, {{145},{8}}, +{{ 81},{8}}, {{209},{8}}, {{ 49},{8}}, {{177},{8}}, {{113},{8}}, +{{241},{8}}, {{ 9},{8}}, {{137},{8}}, {{ 73},{8}}, {{201},{8}}, +{{ 41},{8}}, {{169},{8}}, {{105},{8}}, {{233},{8}}, {{ 25},{8}}, +{{153},{8}}, {{ 89},{8}}, {{217},{8}}, {{ 57},{8}}, {{185},{8}}, +{{121},{8}}, {{249},{8}}, {{ 5},{8}}, {{133},{8}}, {{ 69},{8}}, +{{197},{8}}, {{ 37},{8}}, {{165},{8}}, {{101},{8}}, {{229},{8}}, +{{ 21},{8}}, {{149},{8}}, {{ 85},{8}}, {{213},{8}}, {{ 53},{8}}, +{{181},{8}}, {{117},{8}}, {{245},{8}}, {{ 13},{8}}, {{141},{8}}, +{{ 77},{8}}, {{205},{8}}, {{ 45},{8}}, {{173},{8}}, {{109},{8}}, +{{237},{8}}, {{ 29},{8}}, {{157},{8}}, {{ 93},{8}}, {{221},{8}}, +{{ 61},{8}}, {{189},{8}}, {{125},{8}}, {{253},{8}}, {{ 19},{9}}, +{{275},{9}}, {{147},{9}}, {{403},{9}}, {{ 83},{9}}, {{339},{9}}, +{{211},{9}}, {{467},{9}}, {{ 51},{9}}, {{307},{9}}, {{179},{9}}, +{{435},{9}}, {{115},{9}}, {{371},{9}}, {{243},{9}}, {{499},{9}}, +{{ 11},{9}}, {{267},{9}}, {{139},{9}}, {{395},{9}}, {{ 75},{9}}, +{{331},{9}}, {{203},{9}}, {{459},{9}}, {{ 43},{9}}, {{299},{9}}, +{{171},{9}}, {{427},{9}}, {{107},{9}}, {{363},{9}}, {{235},{9}}, +{{491},{9}}, {{ 27},{9}}, {{283},{9}}, {{155},{9}}, {{411},{9}}, +{{ 91},{9}}, {{347},{9}}, {{219},{9}}, {{475},{9}}, {{ 59},{9}}, +{{315},{9}}, {{187},{9}}, {{443},{9}}, {{123},{9}}, {{379},{9}}, +{{251},{9}}, {{507},{9}}, {{ 7},{9}}, {{263},{9}}, {{135},{9}}, +{{391},{9}}, {{ 71},{9}}, {{327},{9}}, {{199},{9}}, {{455},{9}}, +{{ 39},{9}}, {{295},{9}}, {{167},{9}}, {{423},{9}}, {{103},{9}}, +{{359},{9}}, {{231},{9}}, {{487},{9}}, {{ 23},{9}}, {{279},{9}}, +{{151},{9}}, {{407},{9}}, {{ 87},{9}}, {{343},{9}}, {{215},{9}}, +{{471},{9}}, {{ 55},{9}}, {{311},{9}}, {{183},{9}}, {{439},{9}}, +{{119},{9}}, {{375},{9}}, {{247},{9}}, {{503},{9}}, {{ 15},{9}}, +{{271},{9}}, {{143},{9}}, {{399},{9}}, {{ 79},{9}}, {{335},{9}}, +{{207},{9}}, {{463},{9}}, {{ 47},{9}}, {{303},{9}}, {{175},{9}}, +{{431},{9}}, {{111},{9}}, {{367},{9}}, {{239},{9}}, {{495},{9}}, +{{ 31},{9}}, {{287},{9}}, {{159},{9}}, {{415},{9}}, {{ 95},{9}}, +{{351},{9}}, {{223},{9}}, {{479},{9}}, {{ 63},{9}}, {{319},{9}}, +{{191},{9}}, {{447},{9}}, {{127},{9}}, {{383},{9}}, {{255},{9}}, +{{511},{9}}, {{ 0},{7}}, {{ 64},{7}}, {{ 32},{7}}, {{ 96},{7}}, +{{ 16},{7}}, {{ 80},{7}}, {{ 48},{7}}, {{112},{7}}, {{ 8},{7}}, +{{ 72},{7}}, {{ 40},{7}}, {{104},{7}}, {{ 24},{7}}, {{ 88},{7}}, +{{ 56},{7}}, {{120},{7}}, {{ 4},{7}}, {{ 68},{7}}, {{ 36},{7}}, +{{100},{7}}, {{ 20},{7}}, {{ 84},{7}}, {{ 52},{7}}, {{116},{7}}, +{{ 3},{8}}, {{131},{8}}, {{ 67},{8}}, {{195},{8}}, {{ 35},{8}}, +{{163},{8}}, {{ 99},{8}}, {{227},{8}} +}; + +Z_INTERNAL const ct_data static_dtree[D_CODES] = { +{{ 0},{5}}, {{16},{5}}, {{ 8},{5}}, {{24},{5}}, {{ 4},{5}}, +{{20},{5}}, {{12},{5}}, {{28},{5}}, {{ 2},{5}}, {{18},{5}}, +{{10},{5}}, {{26},{5}}, {{ 6},{5}}, {{22},{5}}, {{14},{5}}, +{{30},{5}}, {{ 1},{5}}, {{17},{5}}, {{ 9},{5}}, {{25},{5}}, +{{ 5},{5}}, {{21},{5}}, {{13},{5}}, {{29},{5}}, {{ 3},{5}}, +{{19},{5}}, {{11},{5}}, {{27},{5}}, {{ 7},{5}}, {{23},{5}} +}; + +const unsigned char Z_INTERNAL zng_dist_code[DIST_CODE_LEN] = { + 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, + 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, +10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, +11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, +12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, +13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, +13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, +18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, +23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 +}; + +const unsigned char Z_INTERNAL zng_length_code[MAX_MATCH-MIN_MATCH+1] = { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, +13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, +17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, +19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, +21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, +22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, +23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 +}; + +Z_INTERNAL const int base_length[LENGTH_CODES] = { +0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, +64, 80, 96, 112, 128, 160, 192, 224, 0 +}; + +Z_INTERNAL const int base_dist[D_CODES] = { + 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, + 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, + 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576 +}; + +#endif /* TREES_TBL_H_ */ diff --git a/libs/zlibng/uncompr.c b/libs/zlibng/uncompr.c index 9f0ac2a0c..1435fab97 100644 --- a/libs/zlibng/uncompr.c +++ b/libs/zlibng/uncompr.c @@ -3,14 +3,12 @@ * For conditions of distribution and use, see copyright notice in zlib.h */ -/* @(#) $Id$ */ - -#define ZLIB_INTERNAL +#define Z_INTERNAL #include "zbuild.h" #ifdef ZLIB_COMPAT -# include "zlib.h" +# include "zlib.h" #else -# include "zlib-ng.h" +# include "zlib-ng.h" #endif /* =========================================================================== @@ -29,7 +27,7 @@ Z_DATA_ERROR if the input data was corrupted, including if the input data is an incomplete zlib stream. */ -int ZEXPORT PREFIX(uncompress2)(unsigned char *dest, z_size_t *destLen, const unsigned char *source, z_size_t *sourceLen) { +int Z_EXPORT PREFIX(uncompress2)(unsigned char *dest, z_size_t *destLen, const unsigned char *source, z_size_t *sourceLen) { PREFIX3(stream) stream; int err; const unsigned int max = (unsigned int)-1; @@ -40,13 +38,12 @@ int ZEXPORT PREFIX(uncompress2)(unsigned char *dest, z_size_t *destLen, const un if (*destLen) { left = *destLen; *destLen = 0; - } - else { + } else { left = 1; dest = buf; } - stream.next_in = (const unsigned char *)source; + stream.next_in = (z_const unsigned char *)source; stream.avail_in = 0; stream.zalloc = NULL; stream.zfree = NULL; @@ -83,7 +80,6 @@ int ZEXPORT PREFIX(uncompress2)(unsigned char *dest, z_size_t *destLen, const un err; } -int ZEXPORT PREFIX(uncompress)(unsigned char *dest, z_size_t *destLen, const unsigned char *source, z_size_t sourceLen) -{ +int Z_EXPORT PREFIX(uncompress)(unsigned char *dest, z_size_t *destLen, const unsigned char *source, z_size_t sourceLen) { return PREFIX(uncompress2)(dest, destLen, source, &sourceLen); } diff --git a/libs/zlibng/win32/DLL_FAQ.txt b/libs/zlibng/win32/DLL_FAQ.txt index 12c009018..c21298596 100644 --- a/libs/zlibng/win32/DLL_FAQ.txt +++ b/libs/zlibng/win32/DLL_FAQ.txt @@ -83,7 +83,7 @@ in the zlib distribution, or at the following location: an old ZLIB.DLL, that was built from zlib-1.1.4 or earlier? - In principle, you can do it by assigning calling convention - keywords to the macros ZEXPORT and ZEXPORTVA. In practice, + keywords to the macros Z_EXPORT and Z_EXPORTVA. In practice, it depends on what you mean by "an old ZLIB.DLL", because the old DLL exists in several mutually-incompatible versions. You have to find out first what kind of calling convention is diff --git a/libs/zlibng/win32/Makefile.a64 b/libs/zlibng/win32/Makefile.a64 new file mode 100644 index 000000000..a2f2e6a60 --- /dev/null +++ b/libs/zlibng/win32/Makefile.a64 @@ -0,0 +1,208 @@ +# Makefile for zlib using Microsoft (Visual) C +# zlib is copyright (C) 1995-2006 Jean-loup Gailly and Mark Adler +# +# Usage: +# nmake -f win32/Makefile.a64 (standard build) +# nmake -f win32/Makefile.a64 LOC=-DFOO (nonstandard build) + +# The toplevel directory of the source tree. +# +TOP = . + +# optional build flags +LOC = + +# variables +STATICLIB = zlib.lib +SHAREDLIB = zlib1.dll +IMPLIB = zdll.lib + +CC = cl +LD = link +AR = lib +RC = rc +CP = copy /y +CFLAGS = -nologo -MD -W3 -O2 -Oy- -Zi -Fd"zlib" $(LOC) +WFLAGS = \ + -D_CRT_SECURE_NO_DEPRECATE \ + -D_CRT_NONSTDC_NO_DEPRECATE \ + -DUNALIGNED_OK \ + -DUNALIGNED64_OK \ + -D_ARM64_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE=1 \ + -DARM_FEATURES \ + # +LDFLAGS = -nologo -debug -incremental:no -opt:ref -manifest +ARFLAGS = -nologo +RCFLAGS = /dARM64 /r +DEFFILE = zlib.def +RCFILE = zlib1.rc +RESFILE = zlib1.res +WITH_GZFILEOP = yes +ZLIB_COMPAT = +SUFFIX = + +OBJS = \ + adler32.obj \ + armfeature.obj \ + chunkset.obj \ + compare258.obj \ + compress.obj \ + crc32.obj \ + crc32_comb.obj \ + deflate.obj \ + deflate_fast.obj \ + deflate_slow.obj \ + deflate_quick.obj \ + deflate_medium.obj \ + functable.obj \ + infback.obj \ + inflate.obj \ + inftrees.obj \ + inffast.obj \ + insert_string.obj \ + trees.obj \ + uncompr.obj \ + zutil.obj \ + # +!if "$(ZLIB_COMPAT)" != "" +WITH_GZFILEOP = yes +WFLAGS = $(WFLAGS) -DZLIB_COMPAT +DEFFILE = zlibcompat.def +!else +STATICLIB = zlib-ng.lib +SHAREDLIB = zlib-ng1.dll +IMPLIB = zngdll.lib +DEFFILE = zlib-ng.def +RCFILE = zlib-ng1.rc +RESFILE = zlib-ng1.res +SUFFIX = -ng +!endif + +!if "$(WITH_GZFILEOP)" != "" +WFLAGS = $(WFLAGS) -DWITH_GZFILEOP +OBJS = $(OBJS) gzlib.obj gzread.obj gzwrite.obj +!endif + +WFLAGS = $(WFLAGS) \ + -DARM_ACLE_CRC_HASH \ + -D__ARM_NEON__=1 \ + -DARM_NEON_ADLER32 \ + -DARM_NEON_CHUNKSET \ + -DARM_NEON_SLIDEHASH \ + -DARM_NOCHECK_NEON \ + # +OBJS = $(OBJS) crc32_acle.obj insert_string_acle.obj adler32_neon.obj chunkset_neon.obj slide_neon.obj + +# targets +all: $(STATICLIB) $(SHAREDLIB) $(IMPLIB) \ + example.exe minigzip.exe example_d.exe minigzip_d.exe + +zconf: $(TOP)/zconf$(SUFFIX).h.in + $(CP) $(TOP)\zconf$(SUFFIX).h.in $(TOP)\zconf$(SUFFIX).h + +$(STATICLIB): zconf $(OBJS) + $(AR) $(ARFLAGS) -out:$@ $(OBJS) + +$(IMPLIB): $(SHAREDLIB) + +$(SHAREDLIB): zconf $(TOP)/win32/$(DEFFILE) $(OBJS) $(RESFILE) + $(LD) $(LDFLAGS) -def:$(TOP)/win32/$(DEFFILE) -dll -implib:$(IMPLIB) \ + -out:$@ -base:0x55A4C0000 $(OBJS) $(RESFILE) + if exist $@.manifest \ + mt -nologo -manifest $@.manifest -outputresource:$@;2 + +example.exe: example.obj gzlib2.obj gzread2.obj gzwrite2.obj $(STATICLIB) + $(LD) $(LDFLAGS) example.obj gzlib2.obj gzread2.obj gzwrite2.obj $(STATICLIB) + if exist $@.manifest \ + mt -nologo -manifest $@.manifest -outputresource:$@;1 + +minigzip.exe: minigzip.obj gzlib2.obj gzread2.obj gzwrite2.obj $(STATICLIB) + $(LD) $(LDFLAGS) minigzip.obj gzlib2.obj gzread2.obj gzwrite2.obj $(STATICLIB) + if exist $@.manifest \ + mt -nologo -manifest $@.manifest -outputresource:$@;1 + +example_d.exe: example.obj gzlib2.obj gzread2.obj gzwrite2.obj $(IMPLIB) + $(LD) $(LDFLAGS) -out:$@ example.obj gzlib2.obj gzread2.obj gzwrite2.obj $(IMPLIB) + if exist $@.manifest \ + mt -nologo -manifest $@.manifest -outputresource:$@;1 + +minigzip_d.exe: minigzip.obj gzlib2.obj gzread2.obj gzwrite2.obj $(IMPLIB) + $(LD) $(LDFLAGS) -out:$@ minigzip.obj gzlib2.obj gzread2.obj gzwrite2.obj $(IMPLIB) + if exist $@.manifest \ + mt -nologo -manifest $@.manifest -outputresource:$@;1 + +{$(TOP)}.c.obj: + $(CC) -c $(WFLAGS) $(CFLAGS) $< + +gzlib2.obj: gzlib.c + $(CC) -c $(WFLAGS) $(CFLAGS) -DWITH_GZFILEOP -Fogzlib2.obj gzlib.c + +gzread2.obj: gzread.c + $(CC) -c $(WFLAGS) $(CFLAGS) -DWITH_GZFILEOP -Fogzread2.obj gzread.c + +gzwrite2.obj: gzwrite.c + $(CC) -c $(WFLAGS) $(CFLAGS) -DWITH_GZFILEOP -Fogzwrite2.obj gzwrite.c + +{$(TOP)/arch/arm}.c.obj: + $(CC) -c -I$(TOP) $(WFLAGS) $(CFLAGS) $< + +{$(TOP)/test}.c.obj: + $(CC) -c -I$(TOP) $(WFLAGS) $(CFLAGS) -DWITH_GZFILEOP $< + +$(TOP)/zconf$(SUFFIX).h: zconf + +SRCDIR = $(TOP) +# Keep the dependences in sync with top-level Makefile.in +adler32.obj: $(SRCDIR)/adler32.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/functable.h $(SRCDIR)/adler32_p.h +chunkset.obj: $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h +functable.obj: $(SRCDIR)/functable.c $(SRCDIR)/zbuild.h $(SRCDIR)/functable.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/zendian.h $(SRCDIR)/arch/x86/x86.h +gzlib.obj: $(SRCDIR)/gzlib.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzguts.h $(SRCDIR)/zutil_p.h +gzread.obj: $(SRCDIR)/gzread.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzguts.h $(SRCDIR)/zutil_p.h +gzwrite.obj: $(SRCDIR)/gzwrite.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzguts.h $(SRCDIR)/zutil_p.h +compress.obj: $(SRCDIR)/compress.c $(SRCDIR)/zbuild.h $(SRCDIR)/zlib$(SUFFIX).h +uncompr.obj: $(SRCDIR)/uncompr.c $(SRCDIR)/zbuild.h $(SRCDIR)/zlib$(SUFFIX).h +crc32.obj: $(SRCDIR)/crc32.c $(SRCDIR)/zbuild.h $(SRCDIR)/zendian.h $(SRCDIR)/deflate.h $(SRCDIR)/functable.h $(SRCDIR)/crc32_tbl.h +crc32_comb.obj: $(SRCDIR)/crc32_comb.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/crc32_comb_tbl.h +deflate.obj: $(SRCDIR)/deflate.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/functable.h +deflate_quick.obj: $(SRCDIR)/deflate_quick.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/functable.h $(SRCDIR)/trees_emit.h +deflate_fast.obj: $(SRCDIR)/deflate_fast.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/functable.h +deflate_medium.obj: $(SRCDIR)/deflate_medium.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/functable.h +deflate_slow.obj: $(SRCDIR)/deflate_slow.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/functable.h +infback.obj: $(SRCDIR)/infback.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/inftrees.h $(SRCDIR)/inflate.h $(SRCDIR)/inffast.h +inffast.obj: $(SRCDIR)/inffast.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/inftrees.h $(SRCDIR)/inflate.h $(SRCDIR)/inffast.h $(SRCDIR)/functable.h +inflate.obj: $(SRCDIR)/inflate.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/inftrees.h $(SRCDIR)/inflate.h $(SRCDIR)/inffast.h $(SRCDIR)/functable.h $(SRCDIR)/functable.h +inftrees.obj: $(SRCDIR)/inftrees.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/inftrees.h +trees.obj: $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/trees_tbl.h +zutil.obj: $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/zutil_p.h + +example.obj: $(TOP)/test/example.c $(TOP)/zbuild.h $(TOP)/zlib$(SUFFIX).h + +minigzip.obj: $(TOP)/test/minigzip.c $(TOP)/zbuild.h $(TOP)/zlib$(SUFFIX).h + +$(RESFILE): $(TOP)/win32/$(RCFILE) + $(RC) $(RCFLAGS) /fo$@ $(TOP)/win32/$(RCFILE) + +# testing +test: example.exe minigzip.exe + example + echo hello world | minigzip | minigzip -d + +testdll: example_d.exe minigzip_d.exe + example_d + echo hello world | minigzip_d | minigzip_d -d + + +# cleanup +clean: + -del $(STATICLIB) + -del $(SHAREDLIB) + -del $(IMPLIB) + -del *.obj + -del *.res + -del *.exp + -del *.exe + -del *.pdb + -del *.manifest + +distclean: clean + -del zconf$(SUFFIX).h diff --git a/libs/zlibng/win32/Makefile.arm b/libs/zlibng/win32/Makefile.arm index 0b3f94064..5ed53f5f3 100644 --- a/libs/zlibng/win32/Makefile.arm +++ b/libs/zlibng/win32/Makefile.arm @@ -23,26 +23,53 @@ AR = lib RC = rc CP = copy /y CFLAGS = -nologo -MD -W3 -O2 -Oy- -Zi -Fd"zlib" $(LOC) -WFLAGS = -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE -DUNALIGNED_OK -D_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE=1 +WFLAGS = \ + -D_CRT_SECURE_NO_DEPRECATE \ + -D_CRT_NONSTDC_NO_DEPRECATE \ + -DUNALIGNED_OK \ + -D_ARM_WINAPI_PARTITION_DESKTOP_SDK_AVAILABLE=1 \ + -DARM_FEATURES \ + # LDFLAGS = -nologo -debug -incremental:no -opt:ref -manifest ARFLAGS = -nologo RCFLAGS = /dARM /r DEFFILE = zlib.def RCFILE = zlib1.rc RESFILE = zlib1.res -WITH_GZFILEOP = +WITH_GZFILEOP = yes +ZLIB_COMPAT = WITH_ACLE = WITH_NEON = WITH_VFPV3 = NEON_ARCH = /arch:VFPv4 SUFFIX = -OBJS = adler32.obj armfeature.obj compress.obj crc32.obj deflate.obj deflate_fast.obj deflate_slow.obj \ - deflate_medium.obj \ - functable.obj infback.obj inflate.obj inftrees.obj inffast.obj trees.obj uncompr.obj zutil.obj fill_window_arm.obj -!if "$(WITH_GZFILEOP)" != "" -WFLAGS = $(WFLAGS) -DWITH_GZFILEOP -OBJS = $(OBJS) gzclose.obj gzlib.obj gzread.obj gzwrite.obj +OBJS = \ + adler32.obj \ + armfeature.obj \ + chunkset.obj \ + compare258.obj \ + compress.obj \ + crc32.obj \ + crc32_comb.obj \ + deflate.obj \ + deflate_fast.obj \ + deflate_slow.obj \ + deflate_quick.obj \ + deflate_medium.obj \ + functable.obj \ + infback.obj \ + inflate.obj \ + inftrees.obj \ + inffast.obj \ + insert_string.obj \ + trees.obj \ + uncompr.obj \ + zutil.obj \ + # +!if "$(ZLIB_COMPAT)" != "" +WITH_GZFILEOP = yes +WFLAGS = $(WFLAGS) -DZLIB_COMPAT DEFFILE = zlibcompat.def !else STATICLIB = zlib-ng.lib @@ -53,6 +80,12 @@ RCFILE = zlib-ng1.rc RESFILE = zlib-ng1.res SUFFIX = -ng !endif + +!if "$(WITH_GZFILEOP)" != "" +WFLAGS = $(WFLAGS) -DWITH_GZFILEOP +OBJS = $(OBJS) gzlib.obj gzread.obj gzwrite.obj +!endif + !if "$(WITH_ACLE)" != "" WFLAGS = $(WFLAGS) -DARM_ACLE_CRC_HASH OBJS = $(OBJS) crc32_acle.obj insert_string_acle.obj @@ -62,8 +95,14 @@ NEON_ARCH = /arch:VFPv3 !endif !if "$(WITH_NEON)" != "" CFLAGS = $(CFLAGS) $(NEON_ARCH) -WFLAGS = $(WFLAGS) -D__ARM_NEON__=1 -DARM_NEON_ADLER32 -DARM_NOCHECK_NEON -OBJS = $(OBJS) adler32_neon.obj +WFLAGS = $(WFLAGS) \ + -D__ARM_NEON__=1 \ + -DARM_NEON_ADLER32 \ + -DARM_NEON_CHUNKSET \ + -DARM_NEON_SLIDEHASH \ + -DARM_NOCHECK_NEON \ + # +OBJS = $(OBJS) adler32_neon.obj chunkset_neon.obj slide_neon.obj !endif # targets @@ -84,58 +123,69 @@ $(SHAREDLIB): zconf $(TOP)/win32/$(DEFFILE) $(OBJS) $(RESFILE) if exist $@.manifest \ mt -nologo -manifest $@.manifest -outputresource:$@;2 -example.exe: example.obj $(STATICLIB) - $(LD) $(LDFLAGS) example.obj $(STATICLIB) +example.exe: example.obj gzlib2.obj gzread2.obj gzwrite2.obj $(STATICLIB) + $(LD) $(LDFLAGS) example.obj gzlib2.obj gzread2.obj gzwrite2.obj $(STATICLIB) if exist $@.manifest \ mt -nologo -manifest $@.manifest -outputresource:$@;1 -minigzip.exe: minigzip.obj $(STATICLIB) - $(LD) $(LDFLAGS) minigzip.obj $(STATICLIB) +minigzip.exe: minigzip.obj gzlib2.obj gzread2.obj gzwrite2.obj $(STATICLIB) + $(LD) $(LDFLAGS) minigzip.obj gzlib2.obj gzread2.obj gzwrite2.obj $(STATICLIB) if exist $@.manifest \ mt -nologo -manifest $@.manifest -outputresource:$@;1 -example_d.exe: example.obj $(IMPLIB) - $(LD) $(LDFLAGS) -out:$@ example.obj $(IMPLIB) +example_d.exe: example.obj gzlib2.obj gzread2.obj gzwrite2.obj $(IMPLIB) + $(LD) $(LDFLAGS) -out:$@ example.obj gzlib2.obj gzread2.obj gzwrite2.obj $(IMPLIB) if exist $@.manifest \ mt -nologo -manifest $@.manifest -outputresource:$@;1 -minigzip_d.exe: minigzip.obj $(IMPLIB) - $(LD) $(LDFLAGS) -out:$@ minigzip.obj $(IMPLIB) +minigzip_d.exe: minigzip.obj gzlib2.obj gzread2.obj gzwrite2.obj $(IMPLIB) + $(LD) $(LDFLAGS) -out:$@ minigzip.obj gzlib2.obj gzread2.obj gzwrite2.obj $(IMPLIB) if exist $@.manifest \ mt -nologo -manifest $@.manifest -outputresource:$@;1 {$(TOP)}.c.obj: $(CC) -c $(WFLAGS) $(CFLAGS) $< +gzlib2.obj: gzlib.c + $(CC) -c $(WFLAGS) $(CFLAGS) -DWITH_GZFILEOP -Fogzlib2.obj gzlib.c + +gzread2.obj: gzread.c + $(CC) -c $(WFLAGS) $(CFLAGS) -DWITH_GZFILEOP -Fogzread2.obj gzread.c + +gzwrite2.obj: gzwrite.c + $(CC) -c $(WFLAGS) $(CFLAGS) -DWITH_GZFILEOP -Fogzwrite2.obj gzwrite.c + {$(TOP)/arch/arm}.c.obj: $(CC) -c -I$(TOP) $(WFLAGS) $(CFLAGS) $< {$(TOP)/test}.c.obj: - $(CC) -c -I$(TOP) $(WFLAGS) $(CFLAGS) $< + $(CC) -c -I$(TOP) $(WFLAGS) $(CFLAGS) -DWITH_GZFILEOP $< $(TOP)/zconf$(SUFFIX).h: zconf SRCDIR = $(TOP) # Keep the dependences in sync with top-level Makefile.in adler32.obj: $(SRCDIR)/adler32.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/functable.h $(SRCDIR)/adler32_p.h -functable.obj: $(SRCDIR)/functable.c $(SRCDIR)/zbuild.h $(SRCDIR)/functable.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/gzendian.h $(SRCDIR)/arch/x86/x86.h -gzclose.obj: $(SRCDIR)/gzclose.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzguts.h -gzlib.obj: $(SRCDIR)/gzlib.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzguts.h -gzread.obj: $(SRCDIR)/gzread.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzguts.h -gzwrite.obj: $(SRCDIR)/gzwrite.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzguts.h +functable.obj: $(SRCDIR)/functable.c $(SRCDIR)/zbuild.h $(SRCDIR)/functable.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/zendian.h $(SRCDIR)/arch/x86/x86.h +gzlib.obj: $(SRCDIR)/gzlib.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzguts.h $(SRCDIR)/zutil_p.h +gzread.obj: $(SRCDIR)/gzread.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzguts.h $(SRCDIR)/zutil_p.h +gzwrite.obj: $(SRCDIR)/gzwrite.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzguts.h $(SRCDIR)/zutil_p.h compress.obj: $(SRCDIR)/compress.c $(SRCDIR)/zbuild.h $(SRCDIR)/zlib$(SUFFIX).h uncompr.obj: $(SRCDIR)/uncompr.c $(SRCDIR)/zbuild.h $(SRCDIR)/zlib$(SUFFIX).h -crc32.obj: $(SRCDIR)/crc32.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzendian.h $(SRCDIR)/deflate.h $(SRCDIR)/functable.h $(SRCDIR)/crc32.h +chunkset.obj: $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h +crc32.obj: $(SRCDIR)/crc32.c $(SRCDIR)/zbuild.h $(SRCDIR)/zendian.h $(SRCDIR)/deflate.h $(SRCDIR)/functable.h $(SRCDIR)/crc32_tbl.h +crc32_comb.obj: $(SRCDIR)/crc32_comb.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/crc32_comb_tbl.h deflate.obj: $(SRCDIR)/deflate.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/functable.h -deflate_fast.obj: $(SRCDIR)/deflate_fast.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/match_p.h $(SRCDIR)/functable.h -deflate_medium.obj: $(SRCDIR)/deflate_medium.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/match_p.h $(SRCDIR)/functable.h -deflate_slow.obj: $(SRCDIR)/deflate_slow.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/match_p.h $(SRCDIR)/functable.h +deflate_fast.obj: $(SRCDIR)/deflate_fast.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/functable.h +deflate_medium.obj: $(SRCDIR)/deflate_medium.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/functable.h +deflate_quick.obj: $(SRCDIR)/deflate_quick.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/functable.h $(SRCDIR)/trees_emit.h +deflate_slow.obj: $(SRCDIR)/deflate_slow.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/functable.h infback.obj: $(SRCDIR)/infback.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/inftrees.h $(SRCDIR)/inflate.h $(SRCDIR)/inffast.h -inffast.obj: $(SRCDIR)/inffast.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/inftrees.h $(SRCDIR)/inflate.h $(SRCDIR)/inffast.h $(SRCDIR)/memcopy.h -inflate.obj: $(SRCDIR)/inflate.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/inftrees.h $(SRCDIR)/inflate.h $(SRCDIR)/inffast.h $(SRCDIR)/memcopy.h $(SRCDIR)/functable.h +inffast.obj: $(SRCDIR)/inffast.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/inftrees.h $(SRCDIR)/inflate.h $(SRCDIR)/inffast.h $(SRCDIR)/functable.h +inflate.obj: $(SRCDIR)/inflate.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/inftrees.h $(SRCDIR)/inflate.h $(SRCDIR)/inffast.h $(SRCDIR)/functable.h $(SRCDIR)/functable.h inftrees.obj: $(SRCDIR)/inftrees.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/inftrees.h -trees.obj: $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/trees.h -zutil.obj: $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/gzguts.h +trees.obj: $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/trees_tbl.h +zutil.obj: $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/zutil_p.h example.obj: $(TOP)/test/example.c $(TOP)/zbuild.h $(TOP)/zlib$(SUFFIX).h diff --git a/libs/zlibng/win32/Makefile.msc b/libs/zlibng/win32/Makefile.msc index 9f4b884c3..85d27b9d7 100644 --- a/libs/zlibng/win32/Makefile.msc +++ b/libs/zlibng/win32/Makefile.msc @@ -23,21 +23,61 @@ AR = lib RC = rc CP = copy /y CFLAGS = -nologo -MD -W3 -O2 -Oy- -Zi -Fd"zlib" $(LOC) -WFLAGS = -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE -DX86_PCLMULQDQ_CRC -DX86_SSE2 -DX86_CPUID -DX86_SSE4_2_CRC_HASH -DUNALIGNED_OK -DX86_QUICK_STRATEGY +WFLAGS = \ + -D_CRT_SECURE_NO_DEPRECATE \ + -D_CRT_NONSTDC_NO_DEPRECATE \ + -DX86_FEATURES \ + -DX86_PCLMULQDQ_CRC \ + -DX86_SSE2 \ + -DX86_SSE42_CRC_INTRIN \ + -DX86_SSE42_CRC_HASH \ + -DX86_AVX2 \ + -DX86_AVX_CHUNKSET \ + -DX86_SSE2_CHUNKSET \ + -DUNALIGNED_OK \ + -DUNALIGNED64_OK \ + # LDFLAGS = -nologo -debug -incremental:no -opt:ref -manifest ARFLAGS = -nologo RCFLAGS = /dWIN32 /r DEFFILE = zlib.def RCFILE = zlib1.rc RESFILE = zlib1.res -WITH_GZFILEOP = +WITH_GZFILEOP = yes ZLIB_COMPAT = SUFFIX = -OBJS = adler32.obj compress.obj crc32.obj deflate.obj deflate_fast.obj deflate_quick.obj deflate_slow.obj \ - deflate_medium.obj \ - functable.obj infback.obj inflate.obj inftrees.obj inffast.obj trees.obj uncompr.obj zutil.obj \ - x86.obj fill_window_sse.obj insert_string_sse.obj crc_folding.obj +OBJS = \ + adler32.obj \ + chunkset.obj \ + chunkset_avx.obj \ + chunkset_sse.obj \ + compare258.obj \ + compare258_avx.obj \ + compare258_sse.obj \ + compress.obj \ + crc32.obj \ + crc32_comb.obj \ + crc_folding.obj \ + deflate.obj \ + deflate_fast.obj \ + deflate_quick.obj \ + deflate_slow.obj \ + deflate_medium.obj \ + functable.obj \ + infback.obj \ + inflate.obj \ + inftrees.obj \ + inffast.obj \ + insert_string.obj \ + insert_string_sse.obj \ + slide_avx.obj \ + slide_sse.obj \ + trees.obj \ + uncompr.obj \ + zutil.obj \ + x86.obj \ + # !if "$(ZLIB_COMPAT)" != "" WITH_GZFILEOP = yes WFLAGS = $(WFLAGS) -DZLIB_COMPAT @@ -54,7 +94,7 @@ SUFFIX = -ng !if "$(WITH_GZFILEOP)" != "" WFLAGS = $(WFLAGS) -DWITH_GZFILEOP -OBJS = $(OBJS) gzclose.obj gzlib.obj gzread.obj gzwrite.obj +OBJS = $(OBJS) gzlib.obj gzread.obj gzwrite.obj !endif # targets @@ -75,59 +115,72 @@ $(SHAREDLIB): zconf $(TOP)/win32/$(DEFFILE) $(OBJS) $(RESFILE) if exist $@.manifest \ mt -nologo -manifest $@.manifest -outputresource:$@;2 -example.exe: example.obj $(STATICLIB) - $(LD) $(LDFLAGS) example.obj $(STATICLIB) +example.exe: example.obj gzlib2.obj gzread2.obj gzwrite2.obj $(STATICLIB) + $(LD) $(LDFLAGS) example.obj gzlib2.obj gzread2.obj gzwrite2.obj $(STATICLIB) if exist $@.manifest \ mt -nologo -manifest $@.manifest -outputresource:$@;1 -minigzip.exe: minigzip.obj $(STATICLIB) - $(LD) $(LDFLAGS) minigzip.obj $(STATICLIB) +minigzip.exe: minigzip.obj gzlib2.obj gzread2.obj gzwrite2.obj $(STATICLIB) + $(LD) $(LDFLAGS) minigzip.obj gzlib2.obj gzread2.obj gzwrite2.obj $(STATICLIB) if exist $@.manifest \ mt -nologo -manifest $@.manifest -outputresource:$@;1 -example_d.exe: example.obj $(IMPLIB) - $(LD) $(LDFLAGS) -out:$@ example.obj $(IMPLIB) +example_d.exe: example.obj gzlib2.obj gzread2.obj gzwrite2.obj $(IMPLIB) + $(LD) $(LDFLAGS) -out:$@ example.obj gzlib2.obj gzread2.obj gzwrite2.obj $(IMPLIB) if exist $@.manifest \ mt -nologo -manifest $@.manifest -outputresource:$@;1 -minigzip_d.exe: minigzip.obj $(IMPLIB) - $(LD) $(LDFLAGS) -out:$@ minigzip.obj $(IMPLIB) +minigzip_d.exe: minigzip.obj gzlib2.obj gzread2.obj gzwrite2.obj $(IMPLIB) + $(LD) $(LDFLAGS) -out:$@ minigzip.obj gzlib2.obj gzread2.obj gzwrite2.obj $(IMPLIB) if exist $@.manifest \ mt -nologo -manifest $@.manifest -outputresource:$@;1 {$(TOP)}.c.obj: $(CC) -c $(WFLAGS) $(CFLAGS) $< +gzlib2.obj: gzlib.c + $(CC) -c $(WFLAGS) $(CFLAGS) -DWITH_GZFILEOP -Fogzlib2.obj gzlib.c + +gzread2.obj: gzread.c + $(CC) -c $(WFLAGS) $(CFLAGS) -DWITH_GZFILEOP -Fogzread2.obj gzread.c + +gzwrite2.obj: gzwrite.c + $(CC) -c $(WFLAGS) $(CFLAGS) -DWITH_GZFILEOP -Fogzwrite2.obj gzwrite.c + {$(TOP)/arch/x86}.c.obj: $(CC) -c -I$(TOP) $(WFLAGS) $(CFLAGS) $< {$(TOP)/test}.c.obj: - $(CC) -c -I$(TOP) $(WFLAGS) $(CFLAGS) $< + $(CC) -c -I$(TOP) $(WFLAGS) $(CFLAGS) -DWITH_GZFILEOP $< $(TOP)/zconf$(SUFFIX).h: zconf SRCDIR = $(TOP) # Keep the dependences in sync with top-level Makefile.in adler32.obj: $(SRCDIR)/adler32.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/functable.h $(SRCDIR)/adler32_p.h -functable.obj: $(SRCDIR)/functable.c $(SRCDIR)/zbuild.h $(SRCDIR)/functable.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/gzendian.h $(SRCDIR)/arch/x86/x86.h -gzclose.obj: $(SRCDIR)/gzclose.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzguts.h -gzlib.obj: $(SRCDIR)/gzlib.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzguts.h -gzread.obj: $(SRCDIR)/gzread.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzguts.h -gzwrite.obj: $(SRCDIR)/gzwrite.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzguts.h +functable.obj: $(SRCDIR)/functable.c $(SRCDIR)/zbuild.h $(SRCDIR)/functable.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/zendian.h $(SRCDIR)/arch/x86/x86.h +gzlib.obj: $(SRCDIR)/gzlib.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzguts.h $(SRCDIR)/zutil_p.h +gzread.obj: $(SRCDIR)/gzread.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzguts.h $(SRCDIR)/zutil_p.h +gzwrite.obj: $(SRCDIR)/gzwrite.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzguts.h $(SRCDIR)/zutil_p.h compress.obj: $(SRCDIR)/compress.c $(SRCDIR)/zbuild.h $(SRCDIR)/zlib$(SUFFIX).h uncompr.obj: $(SRCDIR)/uncompr.c $(SRCDIR)/zbuild.h $(SRCDIR)/zlib$(SUFFIX).h -crc32.obj: $(SRCDIR)/crc32.c $(SRCDIR)/zbuild.h $(SRCDIR)/gzendian.h $(SRCDIR)/deflate.h $(SRCDIR)/functable.h $(SRCDIR)/crc32.h +chunkset.obj: $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h +chunkset_avx.obj: $(SRCDIR)/arch/x86/chunkset_avx.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h +chunkset_sse.obj: $(SRCDIR)/arch/x86/chunkset_sse.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h +crc32.obj: $(SRCDIR)/crc32.c $(SRCDIR)/zbuild.h $(SRCDIR)/zendian.h $(SRCDIR)/deflate.h $(SRCDIR)/functable.h $(SRCDIR)/crc32_tbl.h +crc32_comb.obj: $(SRCDIR)/crc32_comb.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/crc32_comb_tbl.h deflate.obj: $(SRCDIR)/deflate.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/functable.h -deflate_fast.obj: $(SRCDIR)/deflate_fast.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/match_p.h $(SRCDIR)/functable.h -deflate_medium.obj: $(SRCDIR)/deflate_medium.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/match_p.h $(SRCDIR)/functable.h -deflate_quick.obj: $(SRCDIR)/arch/x86/deflate_quick.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/memcopy.h -deflate_slow.obj: $(SRCDIR)/deflate_slow.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/match_p.h $(SRCDIR)/functable.h +deflate_fast.obj: $(SRCDIR)/deflate_fast.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/functable.h +deflate_medium.obj: $(SRCDIR)/deflate_medium.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/functable.h +deflate_quick.obj: $(SRCDIR)/deflate_quick.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/functable.h $(SRCDIR)/trees_emit.h +deflate_slow.obj: $(SRCDIR)/deflate_slow.c $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/deflate_p.h $(SRCDIR)/functable.h infback.obj: $(SRCDIR)/infback.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/inftrees.h $(SRCDIR)/inflate.h $(SRCDIR)/inffast.h -inffast.obj: $(SRCDIR)/inffast.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/inftrees.h $(SRCDIR)/inflate.h $(SRCDIR)/inffast.h $(SRCDIR)/memcopy.h -inflate.obj: $(SRCDIR)/inflate.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/inftrees.h $(SRCDIR)/inflate.h $(SRCDIR)/inffast.h $(SRCDIR)/memcopy.h $(SRCDIR)/functable.h +inffast.obj: $(SRCDIR)/inffast.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/inftrees.h $(SRCDIR)/inflate.h $(SRCDIR)/inffast.h $(SRCDIR)/functable.h +inflate.obj: $(SRCDIR)/inflate.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/inftrees.h $(SRCDIR)/inflate.h $(SRCDIR)/inffast.h $(SRCDIR)/functable.h $(SRCDIR)/functable.h inftrees.obj: $(SRCDIR)/inftrees.c $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/inftrees.h -trees.obj: $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/trees.h -zutil.obj: $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/gzguts.h +slide_sse.obj: $(SRCDIR)/arch/x86/slide_sse.c $(SRCDIR)/deflate.h +trees.obj: $(SRCDIR)/zbuild.h $(SRCDIR)/deflate.h $(SRCDIR)/trees_tbl.h +zutil.obj: $(SRCDIR)/zbuild.h $(SRCDIR)/zutil.h $(SRCDIR)/zutil_p.h example.obj: $(TOP)/test/example.c $(TOP)/zbuild.h $(TOP)/zlib$(SUFFIX).h diff --git a/libs/zlibng/win32/VisualC.txt b/libs/zlibng/win32/VisualC.txt deleted file mode 100644 index 579a5fc9e..000000000 --- a/libs/zlibng/win32/VisualC.txt +++ /dev/null @@ -1,3 +0,0 @@ - -To build zlib using the Microsoft Visual C++ environment, -use the appropriate project from the projects/ directory. diff --git a/libs/zlibng/win32/zlib-ng.def b/libs/zlibng/win32/zlib-ng.def index fd1047f44..467d79009 100644 --- a/libs/zlibng/win32/zlib-ng.def +++ b/libs/zlibng/win32/zlib-ng.def @@ -17,6 +17,8 @@ EXPORTS zng_deflatePending zng_deflatePrime zng_deflateSetHeader + zng_deflateSetParams + zng_deflateGetParams zng_inflateSetDictionary zng_inflateGetDictionary zng_inflateSync @@ -35,9 +37,6 @@ EXPORTS zng_compressBound zng_uncompress zng_uncompress2 -; large file functions - zng_adler32_combine64 - zng_crc32_combine64 ; checksum functions zng_adler32 zng_adler32_z diff --git a/libs/zlibng/zbuild.h b/libs/zlibng/zbuild.h index f375f2e68..3bd4f4898 100644 --- a/libs/zlibng/zbuild.h +++ b/libs/zlibng/zbuild.h @@ -3,21 +3,25 @@ /* This has to be first include that defines any types */ #if defined(_MSC_VER) -# include - typedef SSIZE_T ssize_t; -# define __thread __declspec(thread) +# if defined(_WIN64) + typedef __int64 ssize_t; +# else + typedef long ssize_t; +# endif #endif #if defined(ZLIB_COMPAT) # define PREFIX(x) x # define PREFIX2(x) ZLIB_ ## x # define PREFIX3(x) z_ ## x +# define PREFIX4(x) x ## 64 # define zVersion zlibVersion # define z_size_t unsigned long #else # define PREFIX(x) zng_ ## x # define PREFIX2(x) ZLIBNG_ ## x # define PREFIX3(x) zng_ ## x +# define PREFIX4(x) zng_ ## x # define zVersion zlibng_version # define z_size_t size_t #endif diff --git a/libs/zlibng/zconf-ng.h.in b/libs/zlibng/zconf-ng.h.in index 5d0928de5..7d54668d3 100644 --- a/libs/zlibng/zconf-ng.h.in +++ b/libs/zlibng/zconf-ng.h.in @@ -3,18 +3,11 @@ * For conditions of distribution and use, see copyright notice in zlib.h */ -/* @(#) $Id$ */ - #ifndef ZCONFNG_H #define ZCONFNG_H -#if defined(_WINDOWS) && !defined(WINDOWS) -# define WINDOWS -#endif -#if defined(_WIN32) || defined(__WIN32__) -# ifndef WIN32 -# define WIN32 -# endif +#if !defined(_WIN32) && defined(__WIN32__) +# define _WIN32 #endif #ifdef __STDC_VERSION__ @@ -25,6 +18,16 @@ # endif #endif +/* Clang macro for detecting declspec support + * https://clang.llvm.org/docs/LanguageExtensions.html#has-declspec-attribute + */ +#ifndef __has_declspec_attribute +# define __has_declspec_attribute(x) 0 +#endif + +/* Always define z_const as const */ +#define z_const const + /* Maximum value for memLevel in deflateInit2 */ #ifndef MAX_MEM_LEVEL # define MAX_MEM_LEVEL 9 @@ -52,43 +55,43 @@ for small objects. */ - /* Type declarations */ +/* Type declarations */ +#ifdef ZLIB_INTERNAL +# define Z_INTERNAL ZLIB_INTERNAL +#endif -#if defined(WINDOWS) || defined(WIN32) - /* If building or using zlib as a DLL, define ZLIB_DLL. - * This is not mandatory, but it offers a little performance increase. - */ -# ifdef ZLIB_DLL -# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) -# ifdef ZLIB_INTERNAL -# define ZEXTERN extern __declspec(dllexport) -# else -# define ZEXTERN extern __declspec(dllimport) -# endif -# endif -# endif /* ZLIB_DLL */ - /* If building or using zlib with the WINAPI/WINAPIV calling convention, - * define ZLIB_WINAPI. - * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. - */ -# ifdef ZLIB_WINAPI -# include - /* No need for _export, use ZLIB.DEF instead. */ - /* For complete Windows compatibility, use WINAPI, not __stdcall. */ -# define ZEXPORT WINAPI -# define ZEXPORTVA WINAPIV +/* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ +#if defined(ZLIB_DLL) && (defined(_WIN32) || (__has_declspec_attribute(dllexport) && __has_declspec_attribute(dllimport))) +# ifdef Z_INTERNAL +# define Z_EXTERN extern __declspec(dllexport) +# else +# define Z_EXTERN extern __declspec(dllimport) # endif #endif -#ifndef ZEXTERN -# define ZEXTERN extern +/* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ +#if defined(ZLIB_WINAPI) && defined(_WIN32) +# include + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define Z_EXPORT WINAPI +# define Z_EXPORTVA WINAPIV #endif -#ifndef ZEXPORT -# define ZEXPORT + +#ifndef Z_EXTERN +# define Z_EXTERN extern #endif -#ifndef ZEXPORTVA -# define ZEXPORTVA +#ifndef Z_EXPORT +# define Z_EXPORT +#endif +#ifndef Z_EXPORTVA +# define Z_EXPORTVA #endif /* Fallback for something that includes us. */ @@ -107,11 +110,11 @@ typedef void const *voidpc; typedef void *voidpf; typedef void *voidp; -#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ +#ifdef HAVE_UNISTD_H /* may be set to #if 1 by configure/cmake/etc */ # define Z_HAVE_UNISTD_H #endif -#ifdef NEED_PTRDIFF_T /* may be set to #if 1 by ./configure */ +#ifdef NEED_PTRDIFF_T /* may be set to #if 1 by configure/cmake/etc */ typedef PTRDIFF_TYPE ptrdiff_t; #endif @@ -159,12 +162,12 @@ typedef PTRDIFF_TYPE ptrdiff_t; # define z_off_t long #endif -#if !defined(WIN32) && defined(Z_LARGE64) +#if !defined(_WIN32) && defined(Z_LARGE64) # define z_off64_t off64_t #else # if defined(__MSYS__) # define z_off64_t _off64_t -# elif defined(WIN32) && !defined(__GNUC__) +# elif defined(_WIN32) && !defined(__GNUC__) # define z_off64_t __int64 # else # define z_off64_t z_off_t diff --git a/libs/zlibng/zconf.h.in b/libs/zlibng/zconf.h.in index 79e4cc49c..fcbcbb6b1 100644 --- a/libs/zlibng/zconf.h.in +++ b/libs/zlibng/zconf.h.in @@ -3,18 +3,11 @@ * For conditions of distribution and use, see copyright notice in zlib.h */ -/* @(#) $Id$ */ - #ifndef ZCONF_H #define ZCONF_H -#if defined(_WINDOWS) && !defined(WINDOWS) -# define WINDOWS -#endif -#if defined(_WIN32) || defined(__WIN32__) -# ifndef WIN32 -# define WIN32 -# endif +#if !defined(_WIN32) && defined(__WIN32__) +# define _WIN32 #endif #ifdef __STDC_VERSION__ @@ -25,6 +18,19 @@ # endif #endif +/* Clang macro for detecting declspec support + * https://clang.llvm.org/docs/LanguageExtensions.html#has-declspec-attribute + */ +#ifndef __has_declspec_attribute +# define __has_declspec_attribute(x) 0 +#endif + +#if defined(ZLIB_CONST) && !defined(z_const) +# define z_const const +#else +# define z_const +#endif + /* Maximum value for memLevel in deflateInit2 */ #ifndef MAX_MEM_LEVEL # define MAX_MEM_LEVEL 9 @@ -52,43 +58,48 @@ for small objects. */ - /* Type declarations */ +/* Type declarations */ -#if defined(WINDOWS) || defined(WIN32) - /* If building or using zlib as a DLL, define ZLIB_DLL. - * This is not mandatory, but it offers a little performance increase. - */ -# ifdef ZLIB_DLL -# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) -# ifdef ZLIB_INTERNAL -# define ZEXTERN extern __declspec(dllexport) -# else -# define ZEXTERN extern __declspec(dllimport) -# endif -# endif -# endif /* ZLIB_DLL */ - /* If building or using zlib with the WINAPI/WINAPIV calling convention, - * define ZLIB_WINAPI. - * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. - */ -# ifdef ZLIB_WINAPI -# include - /* No need for _export, use ZLIB.DEF instead. */ - /* For complete Windows compatibility, use WINAPI, not __stdcall. */ -# define ZEXPORT WINAPI -# define ZEXPORTVA WINAPIV +#ifndef OF /* function prototypes */ +# define OF(args) args +#endif + +#ifdef ZLIB_INTERNAL +# define Z_INTERNAL ZLIB_INTERNAL +#endif + +/* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ +#if defined(ZLIB_DLL) && (defined(_WIN32) || (__has_declspec_attribute(dllexport) && __has_declspec_attribute(dllimport))) +# ifdef Z_INTERNAL +# define Z_EXTERN extern __declspec(dllexport) +# else +# define Z_EXTERN extern __declspec(dllimport) # endif #endif -#ifndef ZEXTERN -# define ZEXTERN extern +/* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ +#if defined(ZLIB_WINAPI) && defined(_WIN32) +# include + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define Z_EXPORT WINAPI +# define Z_EXPORTVA WINAPIV #endif -#ifndef ZEXPORT -# define ZEXPORT + +#ifndef Z_EXTERN +# define Z_EXTERN extern #endif -#ifndef ZEXPORTVA -# define ZEXPORTVA +#ifndef Z_EXPORT +# define Z_EXPORT +#endif +#ifndef Z_EXPORTVA +# define Z_EXPORTVA #endif /* Fallback for something that includes us. */ @@ -107,11 +118,11 @@ typedef void const *voidpc; typedef void *voidpf; typedef void *voidp; -#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ +#ifdef HAVE_UNISTD_H /* may be set to #if 1 by configure/cmake/etc */ # define Z_HAVE_UNISTD_H #endif -#ifdef NEED_PTRDIFF_T /* may be set to #if 1 by ./configure */ +#ifdef NEED_PTRDIFF_T /* may be set to #if 1 by configure/cmake/etc */ typedef PTRDIFF_TYPE ptrdiff_t; #endif @@ -159,12 +170,12 @@ typedef PTRDIFF_TYPE ptrdiff_t; # define z_off_t long #endif -#if !defined(WIN32) && defined(Z_LARGE64) +#if !defined(_WIN32) && defined(Z_LARGE64) # define z_off64_t off64_t #else # if defined(__MSYS__) # define z_off64_t _off64_t -# elif defined(WIN32) && !defined(__GNUC__) +# elif defined(_WIN32) && !defined(__GNUC__) # define z_off64_t __int64 # else # define z_off64_t z_off_t diff --git a/libs/zlibng/zendian.h b/libs/zlibng/zendian.h new file mode 100644 index 000000000..54718ed14 --- /dev/null +++ b/libs/zlibng/zendian.h @@ -0,0 +1,60 @@ +/* zendian.h -- define BYTE_ORDER for endian tests + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#ifndef ENDIAN_H_ +#define ENDIAN_H_ + +/* First check whether the compiler knows the target __BYTE_ORDER__. */ +#if defined(__BYTE_ORDER__) +# if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +# if !defined(LITTLE_ENDIAN) +# define LITTLE_ENDIAN __ORDER_LITTLE_ENDIAN__ +# endif +# if !defined(BYTE_ORDER) +# define BYTE_ORDER LITTLE_ENDIAN +# endif +# elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ +# if !defined(BIG_ENDIAN) +# define BIG_ENDIAN __ORDER_BIG_ENDIAN__ +# endif +# if !defined(BYTE_ORDER) +# define BYTE_ORDER BIG_ENDIAN +# endif +# endif +#elif defined(__MINGW32__) +# include +#elif defined(_WIN32) +# define LITTLE_ENDIAN 1234 +# define BIG_ENDIAN 4321 +# if defined(_M_IX86) || defined(_M_AMD64) || defined(_M_IA64) || defined (_M_ARM) || defined (_M_ARM64) +# define BYTE_ORDER LITTLE_ENDIAN +# else +# error Unknown endianness! +# endif +#elif defined(__linux__) +# include +#elif defined(__APPLE__) || defined(__arm__) || defined(__aarch64__) +# include +#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__DragonFly__) +# include +#elif defined(__sun) || defined(sun) +# include +# if !defined(LITTLE_ENDIAN) +# define LITTLE_ENDIAN 4321 +# endif +# if !defined(BIG_ENDIAN) +# define BIG_ENDIAN 1234 +# endif +# if !defined(BYTE_ORDER) +# if defined(_BIG_ENDIAN) +# define BYTE_ORDER BIG_ENDIAN +# else +# define BYTE_ORDER LITTLE_ENDIAN +# endif +# endif +#else +# include +#endif + +#endif diff --git a/libs/zlibng/zlib-ng.h b/libs/zlibng/zlib-ng.h index 3d972a0c5..275ded703 100644 --- a/libs/zlibng/zlib-ng.h +++ b/libs/zlibng/zlib-ng.h @@ -1,7 +1,6 @@ #ifndef ZNGLIB_H_ #define ZNGLIB_H_ -/* zlib-ng.h -- interface of the 'zlib-ng' compression library - Forked from and compatible with zlib 1.2.11 +/* zlib-ng.h -- interface of the 'zlib-ng' compression library, forked from zlib. Copyright (C) 1995-2016 Jean-loup Gailly and Mark Adler @@ -37,11 +36,11 @@ extern "C" { #endif -#define ZLIBNG_VERSION "1.9.9" -#define ZLIBNG_VERNUM 0x1990 -#define ZLIBNG_VER_MAJOR 1 -#define ZLIBNG_VER_MINOR 9 -#define ZLIBNG_VER_REVISION 9 +#define ZLIBNG_VERSION "2.0.0-RC2" +#define ZLIBNG_VERNUM 0x2000 +#define ZLIBNG_VER_MAJOR 2 +#define ZLIBNG_VER_MINOR 0 +#define ZLIBNG_VER_REVISION 0 #define ZLIBNG_VER_SUBREVISION 0 /* @@ -84,11 +83,11 @@ typedef void (*free_func) (void *opaque, void *address); struct internal_state; typedef struct zng_stream_s { - const unsigned char *next_in; /* next input byte */ + const uint8_t *next_in; /* next input byte */ uint32_t avail_in; /* number of bytes available at next_in */ size_t total_in; /* total number of input bytes read so far */ - unsigned char *next_out; /* next output byte will go here */ + uint8_t *next_out; /* next output byte will go here */ uint32_t avail_out; /* remaining free space at next_out */ size_t total_out; /* total number of bytes output so far */ @@ -112,19 +111,19 @@ typedef zng_stream *zng_streamp; /* Obsolete type, retained for compatibility o for more details on the meanings of these fields. */ typedef struct zng_gz_header_s { - int text; /* true if compressed data believed to be text */ + int32_t text; /* true if compressed data believed to be text */ unsigned long time; /* modification time */ - int xflags; /* extra flags (not used when writing a gzip file) */ - int os; /* operating system */ - unsigned char *extra; /* pointer to extra field or NULL if none */ - unsigned int extra_len; /* extra field length (valid if extra != NULL) */ - unsigned int extra_max; /* space at extra (only when reading header) */ - unsigned char *name; /* pointer to zero-terminated file name or NULL */ - unsigned int name_max; /* space at name (only when reading header) */ - unsigned char *comment; /* pointer to zero-terminated comment or NULL */ - unsigned int comm_max; /* space at comment (only when reading header) */ - int hcrc; /* true if there was or will be a header crc */ - int done; /* true when done reading gzip header (not used when writing a gzip file) */ + int32_t xflags; /* extra flags (not used when writing a gzip file) */ + int32_t os; /* operating system */ + uint8_t *extra; /* pointer to extra field or NULL if none */ + uint32_t extra_len; /* extra field length (valid if extra != NULL) */ + uint32_t extra_max; /* space at extra (only when reading header) */ + uint8_t *name; /* pointer to zero-terminated file name or NULL */ + uint32_t name_max; /* space at name (only when reading header) */ + uint8_t *comment; /* pointer to zero-terminated comment or NULL */ + uint32_t comm_max; /* space at comment (only when reading header) */ + int32_t hcrc; /* true if there was or will be a header crc */ + int32_t done; /* true when done reading gzip header (not used when writing a gzip file) */ } zng_gz_header; typedef zng_gz_header *zng_gz_headerp; @@ -204,7 +203,8 @@ typedef zng_gz_header *zng_gz_headerp; /* basic functions */ -ZEXTERN const char * ZEXPORT zlibng_version(void); +Z_EXTERN Z_EXPORT +const char *zlibng_version(void); /* The application can compare zlibng_version and ZLIBNG_VERSION for consistency. If the first character differs, the library code actually used is not compatible with the zlib-ng.h header file used by the application. This check @@ -212,7 +212,8 @@ ZEXTERN const char * ZEXPORT zlibng_version(void); */ /* -ZEXTERN int ZEXPORT zng_deflateInit (zng_stream *strm, int level); +Z_EXTERN Z_EXPORT +int zng_deflateInit(zng_stream *strm, int level); Initializes the internal stream state for compression. The fields zalloc, zfree and opaque must be initialized before by the caller. If @@ -234,7 +235,8 @@ ZEXTERN int ZEXPORT zng_deflateInit (zng_stream *strm, int level); */ -ZEXTERN int ZEXPORT zng_deflate(zng_stream *strm, int flush); +Z_EXTERN Z_EXPORT +int32_t zng_deflate(zng_stream *strm, int32_t flush); /* deflate compresses as much data as possible, and stops when the input buffer becomes empty or the output buffer becomes full. It may introduce @@ -347,7 +349,8 @@ ZEXTERN int ZEXPORT zng_deflate(zng_stream *strm, int flush); */ -ZEXTERN int ZEXPORT zng_deflateEnd(zng_stream *strm); +Z_EXTERN Z_EXPORT +int32_t zng_deflateEnd(zng_stream *strm); /* All dynamically allocated data structures for this stream are freed. This function discards any unprocessed input and does not flush any pending @@ -362,7 +365,8 @@ ZEXTERN int ZEXPORT zng_deflateEnd(zng_stream *strm); /* -ZEXTERN int ZEXPORT zng_inflateInit (zng_stream *strm); +Z_EXTERN Z_EXPORT +int zng_inflateInit(zng_stream *strm); Initializes the internal stream state for decompression. The fields next_in, avail_in, zalloc, zfree and opaque must be initialized before by @@ -384,7 +388,8 @@ ZEXTERN int ZEXPORT zng_inflateInit (zng_stream *strm); */ -ZEXTERN int ZEXPORT zng_inflate(zng_stream *strm, int flush); +Z_EXTERN Z_EXPORT +int32_t zng_inflate(zng_stream *strm, int32_t flush); /* inflate decompresses as much data as possible, and stops when the input buffer becomes empty or the output buffer becomes full. It may introduce @@ -504,7 +509,8 @@ ZEXTERN int ZEXPORT zng_inflate(zng_stream *strm, int flush); */ -ZEXTERN int ZEXPORT zng_inflateEnd(zng_stream *strm); +Z_EXTERN Z_EXPORT +int32_t zng_inflateEnd(zng_stream *strm); /* All dynamically allocated data structures for this stream are freed. This function discards any unprocessed input and does not flush any pending @@ -522,12 +528,8 @@ ZEXTERN int ZEXPORT zng_inflateEnd(zng_stream *strm); */ /* -ZEXTERN int ZEXPORT zng_deflateInit2 (zng_stream *strm, - int level, - int method, - int windowBits, - int memLevel, - int strategy); +Z_EXTERN Z_EXPORT +int zng_deflateInit2(zng_stream *strm, int level, int method, int windowBits, int memLevel, int strategy); This is another version of deflateInit with more compression options. The fields zalloc, zfree and opaque must be initialized before by the caller. @@ -594,9 +596,8 @@ ZEXTERN int ZEXPORT zng_deflateInit2 (zng_stream *strm, compression: this will be done by deflate(). */ -ZEXTERN int ZEXPORT zng_deflateSetDictionary(zng_stream *strm, - const unsigned char *dictionary, - unsigned int dictLength); +Z_EXTERN Z_EXPORT +int32_t zng_deflateSetDictionary(zng_stream *strm, const uint8_t *dictionary, uint32_t dictLength); /* Initializes the compression dictionary from the given byte sequence without producing any compressed output. When using the zlib format, this @@ -638,7 +639,8 @@ ZEXTERN int ZEXPORT zng_deflateSetDictionary(zng_stream *strm, not perform any compression: this will be done by deflate(). */ -ZEXTERN int ZEXPORT zng_deflateGetDictionary (zng_stream *strm, unsigned char *dictionary, unsigned int *dictLength); +Z_EXTERN Z_EXPORT +int32_t zng_deflateGetDictionary(zng_stream *strm, uint8_t *dictionary, uint32_t *dictLength); /* Returns the sliding dictionary being maintained by deflate. dictLength is set to the number of bytes in the dictionary, and that many bytes are copied @@ -658,7 +660,8 @@ ZEXTERN int ZEXPORT zng_deflateGetDictionary (zng_stream *strm, unsigned char *d stream state is inconsistent. */ -ZEXTERN int ZEXPORT zng_deflateCopy(zng_stream *dest, zng_stream *source); +Z_EXTERN Z_EXPORT +int32_t zng_deflateCopy(zng_stream *dest, zng_stream *source); /* Sets the destination stream as a complete copy of the source stream. @@ -675,7 +678,8 @@ ZEXTERN int ZEXPORT zng_deflateCopy(zng_stream *dest, zng_stream *source); destination. */ -ZEXTERN int ZEXPORT zng_deflateReset(zng_stream *strm); +Z_EXTERN Z_EXPORT +int32_t zng_deflateReset(zng_stream *strm); /* This function is equivalent to deflateEnd followed by deflateInit, but does not free and reallocate the internal compression state. The stream @@ -686,7 +690,8 @@ ZEXTERN int ZEXPORT zng_deflateReset(zng_stream *strm); stream state was inconsistent (such as zalloc or state being NULL). */ -ZEXTERN int ZEXPORT zng_deflateParams(zng_stream *strm, int level, int strategy); +Z_EXTERN Z_EXPORT +int32_t zng_deflateParams(zng_stream *strm, int32_t level, int32_t strategy); /* Dynamically update the compression level and compression strategy. The interpretation of level and strategy is as in deflateInit2(). This can be @@ -722,7 +727,8 @@ ZEXTERN int ZEXPORT zng_deflateParams(zng_stream *strm, int level, int strategy) retried with more output space. */ -ZEXTERN int ZEXPORT zng_deflateTune(zng_stream *strm, int good_length, int max_lazy, int nice_length, int max_chain); +Z_EXTERN Z_EXPORT +int32_t zng_deflateTune(zng_stream *strm, int32_t good_length, int32_t max_lazy, int32_t nice_length, int32_t max_chain); /* Fine tune deflate's internal compression parameters. This should only be used by someone who understands the algorithm used by zlib's deflate for @@ -735,7 +741,8 @@ ZEXTERN int ZEXPORT zng_deflateTune(zng_stream *strm, int good_length, int max_l returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. */ -ZEXTERN unsigned long ZEXPORT zng_deflateBound(zng_stream *strm, unsigned long sourceLen); +Z_EXTERN Z_EXPORT +unsigned long zng_deflateBound(zng_stream *strm, unsigned long sourceLen); /* deflateBound() returns an upper bound on the compressed size after deflation of sourceLen bytes. It must be called after deflateInit() or @@ -749,7 +756,8 @@ ZEXTERN unsigned long ZEXPORT zng_deflateBound(zng_stream *strm, unsigned long s than Z_FINISH or Z_NO_FLUSH are used. */ -ZEXTERN int ZEXPORT zng_deflatePending(zng_stream *strm, uint32_t *pending, int *bits); +Z_EXTERN Z_EXPORT +int32_t zng_deflatePending(zng_stream *strm, uint32_t *pending, int32_t *bits); /* deflatePending() returns the number of bytes and bits of output that have been generated, but not yet provided in the available output. The bytes not @@ -762,7 +770,8 @@ ZEXTERN int ZEXPORT zng_deflatePending(zng_stream *strm, uint32_t *pending, int stream state was inconsistent. */ -ZEXTERN int ZEXPORT zng_deflatePrime(zng_stream *strm, int bits, int value); +Z_EXTERN Z_EXPORT +int32_t zng_deflatePrime(zng_stream *strm, int32_t bits, int32_t value); /* deflatePrime() inserts bits in the deflate output stream. The intent is that this function is used to start off the deflate output with the bits @@ -777,7 +786,8 @@ ZEXTERN int ZEXPORT zng_deflatePrime(zng_stream *strm, int bits, int value); source stream state was inconsistent. */ -ZEXTERN int ZEXPORT zng_deflateSetHeader(zng_stream *strm, zng_gz_headerp head); +Z_EXTERN Z_EXPORT +int32_t zng_deflateSetHeader(zng_stream *strm, zng_gz_headerp head); /* deflateSetHeader() provides gzip header information for when a gzip stream is requested by deflateInit2(). deflateSetHeader() may be called @@ -801,7 +811,8 @@ ZEXTERN int ZEXPORT zng_deflateSetHeader(zng_stream *strm, zng_gz_headerp head); */ /* -ZEXTERN int ZEXPORT zng_inflateInit2(zng_stream *strm, int windowBits); +Z_EXTERN Z_EXPORT +int zng_inflateInit2(zng_stream *strm, int windowBits); This is another version of inflateInit with an extra parameter. The fields next_in, avail_in, zalloc, zfree and opaque must be initialized @@ -854,7 +865,8 @@ ZEXTERN int ZEXPORT zng_inflateInit2(zng_stream *strm, int windowBits); deferred until inflate() is called. */ -ZEXTERN int ZEXPORT zng_inflateSetDictionary(zng_stream *strm, const unsigned char *dictionary, unsigned int dictLength); +Z_EXTERN Z_EXPORT +int32_t zng_inflateSetDictionary(zng_stream *strm, const uint8_t *dictionary, uint32_t dictLength); /* Initializes the decompression dictionary from the given uncompressed byte sequence. This function must be called immediately after a call of inflate, @@ -875,7 +887,8 @@ ZEXTERN int ZEXPORT zng_inflateSetDictionary(zng_stream *strm, const unsigned ch inflate(). */ -ZEXTERN int ZEXPORT zng_inflateGetDictionary(zng_stream *strm, unsigned char *dictionary, unsigned int *dictLength); +Z_EXTERN Z_EXPORT +int32_t zng_inflateGetDictionary(zng_stream *strm, uint8_t *dictionary, uint32_t *dictLength); /* Returns the sliding dictionary being maintained by inflate. dictLength is set to the number of bytes in the dictionary, and that many bytes are copied @@ -888,7 +901,8 @@ ZEXTERN int ZEXPORT zng_inflateGetDictionary(zng_stream *strm, unsigned char *di stream state is inconsistent. */ -ZEXTERN int ZEXPORT zng_inflateSync(zng_stream *strm); +Z_EXTERN Z_EXPORT +int32_t zng_inflateSync(zng_stream *strm); /* Skips invalid compressed data until a possible full flush point (see above for the description of deflate with Z_FULL_FLUSH) can be found, or until all @@ -907,7 +921,8 @@ ZEXTERN int ZEXPORT zng_inflateSync(zng_stream *strm); input each time, until success or end of the input data. */ -ZEXTERN int ZEXPORT zng_inflateCopy(zng_stream *dest, zng_stream *source); +Z_EXTERN Z_EXPORT +int32_t zng_inflateCopy(zng_stream *dest, zng_stream *source); /* Sets the destination stream as a complete copy of the source stream. @@ -922,7 +937,8 @@ ZEXTERN int ZEXPORT zng_inflateCopy(zng_stream *dest, zng_stream *source); destination. */ -ZEXTERN int ZEXPORT zng_inflateReset(zng_stream *strm); +Z_EXTERN Z_EXPORT +int32_t zng_inflateReset(zng_stream *strm); /* This function is equivalent to inflateEnd followed by inflateInit, but does not free and reallocate the internal decompression state. The @@ -932,7 +948,8 @@ ZEXTERN int ZEXPORT zng_inflateReset(zng_stream *strm); stream state was inconsistent (such as zalloc or state being NULL). */ -ZEXTERN int ZEXPORT zng_inflateReset2(zng_stream *strm, int windowBits); +Z_EXTERN Z_EXPORT +int32_t zng_inflateReset2(zng_stream *strm, int32_t windowBits); /* This function is the same as inflateReset, but it also permits changing the wrap and window size requests. The windowBits parameter is interpreted @@ -945,7 +962,8 @@ ZEXTERN int ZEXPORT zng_inflateReset2(zng_stream *strm, int windowBits); the windowBits parameter is invalid. */ -ZEXTERN int ZEXPORT zng_inflatePrime(zng_stream *strm, int bits, int value); +Z_EXTERN Z_EXPORT +int32_t zng_inflatePrime(zng_stream *strm, int32_t bits, int32_t value); /* This function inserts bits in the inflate input stream. The intent is that this function is used to start inflating at a bit position in the @@ -964,7 +982,8 @@ ZEXTERN int ZEXPORT zng_inflatePrime(zng_stream *strm, int bits, int value); stream state was inconsistent. */ -ZEXTERN long ZEXPORT zng_inflateMark(zng_stream *strm); +Z_EXTERN Z_EXPORT +long zng_inflateMark(zng_stream *strm); /* This function returns two values, one in the lower 16 bits of the return value, and the other in the remaining upper bits, obtained by shifting the @@ -992,7 +1011,8 @@ ZEXTERN long ZEXPORT zng_inflateMark(zng_stream *strm); source stream state was inconsistent. */ -ZEXTERN int ZEXPORT zng_inflateGetHeader(zng_stream *strm, zng_gz_headerp head); +Z_EXTERN Z_EXPORT +int32_t zng_inflateGetHeader(zng_stream *strm, zng_gz_headerp head); /* inflateGetHeader() requests that gzip header information be stored in the provided zng_gz_header structure. inflateGetHeader() may be called after @@ -1032,7 +1052,8 @@ ZEXTERN int ZEXPORT zng_inflateGetHeader(zng_stream *strm, zng_gz_headerp head); */ /* -ZEXTERN int ZEXPORT zng_inflateBackInit (zng_stream *strm, int windowBits, unsigned char *window); +Z_EXTERN Z_EXPORT +int zng_inflateBackInit(zng_stream *strm, int windowBits, unsigned char *window); Initialize the internal stream state for decompression using inflateBack() calls. The fields zalloc, zfree and opaque in strm must be initialized @@ -1052,10 +1073,11 @@ ZEXTERN int ZEXPORT zng_inflateBackInit (zng_stream *strm, int windowBits, unsig the version of the header file. */ -typedef uint32_t (*in_func) (void *, const unsigned char * *); -typedef int (*out_func) (void *, unsigned char *, uint32_t); +typedef uint32_t (*in_func) (void *, const uint8_t * *); +typedef int32_t (*out_func) (void *, uint8_t *, uint32_t); -ZEXTERN int ZEXPORT zng_inflateBack(zng_stream *strm, in_func in, void *in_desc, out_func out, void *out_desc); +Z_EXTERN Z_EXPORT +int32_t zng_inflateBack(zng_stream *strm, in_func in, void *in_desc, out_func out, void *out_desc); /* inflateBack() does a raw inflate with a single call using a call-back interface for input and output. This is potentially more efficient than @@ -1123,7 +1145,8 @@ ZEXTERN int ZEXPORT zng_inflateBack(zng_stream *strm, in_func in, void *in_desc, cannot return Z_OK. */ -ZEXTERN int ZEXPORT zng_inflateBackEnd(zng_stream *strm); +Z_EXTERN Z_EXPORT +int32_t zng_inflateBackEnd(zng_stream *strm); /* All memory allocated by inflateBackInit() is freed. @@ -1131,7 +1154,8 @@ ZEXTERN int ZEXPORT zng_inflateBackEnd(zng_stream *strm); state was inconsistent. */ -ZEXTERN unsigned long ZEXPORT zng_zlibCompileFlags(void); +Z_EXTERN Z_EXPORT +unsigned long zng_zlibCompileFlags(void); /* Return flags indicating compile-time options. Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: @@ -1147,7 +1171,7 @@ ZEXTERN unsigned long ZEXPORT zng_zlibCompileFlags(void); 11: 0 (reserved) One-time table building (smaller code, but not thread-safe if true): - 12: BUILDFIXED -- build static block decoding tables when needed + 12: BUILDFIXED -- build static block decoding tables when needed (not supported by zlib-ng) 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed 14,15: 0 (reserved) @@ -1183,7 +1207,8 @@ ZEXTERN unsigned long ZEXPORT zng_zlibCompileFlags(void); you need special options. */ -ZEXTERN int ZEXPORT zng_compress(unsigned char *dest, size_t *destLen, const unsigned char *source, size_t sourceLen); +Z_EXTERN Z_EXPORT +int32_t zng_compress(uint8_t *dest, size_t *destLen, const uint8_t *source, size_t sourceLen); /* Compresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size @@ -1197,8 +1222,8 @@ ZEXTERN int ZEXPORT zng_compress(unsigned char *dest, size_t *destLen, const uns buffer. */ -ZEXTERN int ZEXPORT zng_compress2(unsigned char *dest, size_t *destLen, const unsigned char *source, - size_t sourceLen, int level); +Z_EXTERN Z_EXPORT +int32_t zng_compress2(uint8_t *dest, size_t *destLen, const uint8_t *source, size_t sourceLen, int32_t level); /* Compresses the source buffer into the destination buffer. The level parameter has the same meaning as in deflateInit. sourceLen is the byte @@ -1212,14 +1237,16 @@ ZEXTERN int ZEXPORT zng_compress2(unsigned char *dest, size_t *destLen, const un Z_STREAM_ERROR if the level parameter is invalid. */ -ZEXTERN size_t ZEXPORT zng_compressBound(size_t sourceLen); +Z_EXTERN Z_EXPORT +size_t zng_compressBound(size_t sourceLen); /* compressBound() returns an upper bound on the compressed size after compress() or compress2() on sourceLen bytes. It would be used before a compress() or compress2() call to allocate the destination buffer. */ -ZEXTERN int ZEXPORT zng_uncompress(unsigned char *dest, size_t *destLen, const unsigned char *source, size_t sourceLen); +Z_EXTERN Z_EXPORT +int32_t zng_uncompress(uint8_t *dest, size_t *destLen, const uint8_t *source, size_t sourceLen); /* Decompresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size @@ -1237,8 +1264,8 @@ ZEXTERN int ZEXPORT zng_uncompress(unsigned char *dest, size_t *destLen, const u */ -ZEXTERN int ZEXPORT zng_uncompress2 (unsigned char *dest, size_t *destLen, - const unsigned char *source, size_t *sourceLen); +Z_EXTERN Z_EXPORT +int32_t zng_uncompress2(uint8_t *dest, size_t *destLen, const uint8_t *source, size_t *sourceLen); /* Same as uncompress, except that sourceLen is a pointer, where the length of the source is *sourceLen. On return, *sourceLen is the number of @@ -1258,9 +1285,9 @@ ZEXTERN int ZEXPORT zng_uncompress2 (unsigned char *dest, size_t *destLe typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */ +Z_EXTERN Z_EXPORT +gzFile zng_gzopen(const char *path, const char *mode); /* -ZEXTERN gzFile ZEXPORT zng_gzopen(const char *path, const char *mode); - Opens a gzip (.gz) file for reading or writing. The mode parameter is as in fopen ("rb" or "wb") but can also include a compression level ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only @@ -1296,7 +1323,8 @@ ZEXTERN gzFile ZEXPORT zng_gzopen(const char *path, const char *mode); file could not be opened. */ -ZEXTERN gzFile ZEXPORT zng_gzdopen(int fd, const char *mode); +Z_EXTERN Z_EXPORT +gzFile zng_gzdopen(int fd, const char *mode); /* gzdopen associates a gzFile with the file descriptor fd. File descriptors are obtained from calls like open, dup, creat, pipe or fileno (if the file @@ -1319,7 +1347,8 @@ ZEXTERN gzFile ZEXPORT zng_gzdopen(int fd, const char *mode); will not detect if fd is invalid (unless fd is -1). */ -ZEXTERN int ZEXPORT zng_gzbuffer(gzFile file, unsigned size); +Z_EXTERN Z_EXPORT +int32_t zng_gzbuffer(gzFile file, uint32_t size); /* Set the internal buffer size used by this library's functions. The default buffer size is 8192 bytes. This function must be called after @@ -1335,7 +1364,8 @@ ZEXTERN int ZEXPORT zng_gzbuffer(gzFile file, unsigned size); too late. */ -ZEXTERN int ZEXPORT zng_gzsetparams(gzFile file, int level, int strategy); +Z_EXTERN Z_EXPORT +int32_t zng_gzsetparams(gzFile file, int32_t level, int32_t strategy); /* Dynamically update the compression level or strategy. See the description of deflateInit2 for the meaning of these parameters. Previously provided @@ -1346,7 +1376,8 @@ ZEXTERN int ZEXPORT zng_gzsetparams(gzFile file, int level, int strategy); or Z_MEM_ERROR if there is a memory allocation error. */ -ZEXTERN int ZEXPORT zng_gzread(gzFile file, void *buf, unsigned len); +Z_EXTERN Z_EXPORT +int32_t zng_gzread(gzFile file, void *buf, uint32_t len); /* Reads the given number of uncompressed bytes from the compressed file. If the input file is not in gzip format, gzread copies the given number of @@ -1376,7 +1407,8 @@ ZEXTERN int ZEXPORT zng_gzread(gzFile file, void *buf, unsigned len); Z_STREAM_ERROR. */ -ZEXTERN size_t ZEXPORT zng_gzfread (void *buf, size_t size, size_t nitems, gzFile file); +Z_EXTERN Z_EXPORT +size_t zng_gzfread(void *buf, size_t size, size_t nitems, gzFile file); /* Read up to nitems items of size size from file to buf, otherwise operating as gzread() does. This duplicates the interface of stdio's fread(), with @@ -1399,14 +1431,16 @@ ZEXTERN size_t ZEXPORT zng_gzfread (void *buf, size_t size, size_t nitems, gzFil file, reseting and retrying on end-of-file, when size is not 1. */ -ZEXTERN int ZEXPORT zng_gzwrite(gzFile file, void const *buf, unsigned len); +Z_EXTERN Z_EXPORT +int32_t zng_gzwrite(gzFile file, void const *buf, uint32_t len); /* Writes the given number of uncompressed bytes into the compressed file. gzwrite returns the number of uncompressed bytes written or 0 in case of error. */ -ZEXTERN size_t ZEXPORT zng_gzfwrite(void const *buf, size_t size, size_t nitems, gzFile file); +Z_EXTERN Z_EXPORT +size_t zng_gzfwrite(void const *buf, size_t size, size_t nitems, gzFile file); /* gzfwrite() writes nitems items of size size from buf to file, duplicating the interface of stdio's fwrite(), with size_t request and return types. @@ -1417,7 +1451,8 @@ ZEXTERN size_t ZEXPORT zng_gzfwrite(void const *buf, size_t size, size_t nitems, is returned, and the error state is set to Z_STREAM_ERROR. */ -ZEXTERN int ZEXPORTVA zng_gzprintf(gzFile file, const char *format, ...); +Z_EXTERN Z_EXPORTVA +int32_t zng_gzprintf(gzFile file, const char *format, ...); /* Converts, formats, and writes the arguments to the compressed file under control of the format string, as in fprintf. gzprintf returns the number of @@ -1432,7 +1467,8 @@ ZEXTERN int ZEXPORTVA zng_gzprintf(gzFile file, const char *format, ...); This can be determined using zlibCompileFlags(). */ -ZEXTERN int ZEXPORT zng_gzputs(gzFile file, const char *s); +Z_EXTERN Z_EXPORT +int32_t zng_gzputs(gzFile file, const char *s); /* Writes the given null-terminated string to the compressed file, excluding the terminating null character. @@ -1440,7 +1476,8 @@ ZEXTERN int ZEXPORT zng_gzputs(gzFile file, const char *s); gzputs returns the number of characters written, or -1 in case of error. */ -ZEXTERN char * ZEXPORT zng_gzgets(gzFile file, char *buf, int len); +Z_EXTERN Z_EXPORT +char * zng_gzgets(gzFile file, char *buf, int32_t len); /* Reads bytes from the compressed file until len-1 characters are read, or a newline character is read and transferred to buf, or an end-of-file @@ -1453,13 +1490,15 @@ ZEXTERN char * ZEXPORT zng_gzgets(gzFile file, char *buf, int len); buf are indeterminate. */ -ZEXTERN int ZEXPORT zng_gzputc(gzFile file, int c); +Z_EXTERN Z_EXPORT +int32_t zng_gzputc(gzFile file, int32_t c); /* Writes c, converted to an unsigned char, into the compressed file. gzputc returns the value that was written, or -1 in case of error. */ -ZEXTERN int ZEXPORT zng_gzgetc(gzFile file); +Z_EXTERN Z_EXPORT +int32_t zng_gzgetc(gzFile file); /* Reads one byte from the compressed file. gzgetc returns this byte or -1 in case of end of file or error. This is implemented as a macro for speed. @@ -1468,7 +1507,8 @@ ZEXTERN int ZEXPORT zng_gzgetc(gzFile file); points to has been clobbered or not. */ -ZEXTERN int ZEXPORT zng_gzungetc(int c, gzFile file); +Z_EXTERN Z_EXPORT +int32_t zng_gzungetc(int32_t c, gzFile file); /* Push one character back onto the stream to be read as the first character on the next read. At least one character of push-back is allowed. @@ -1480,7 +1520,8 @@ ZEXTERN int ZEXPORT zng_gzungetc(int c, gzFile file); gzseek() or gzrewind(). */ -ZEXTERN int ZEXPORT zng_gzflush(gzFile file, int flush); +Z_EXTERN Z_EXPORT +int32_t zng_gzflush(gzFile file, int32_t flush); /* Flushes all pending output into the compressed file. The parameter flush is as in the deflate() function. The return value is the zlib error number @@ -1495,9 +1536,9 @@ ZEXTERN int ZEXPORT zng_gzflush(gzFile file, int flush); degrade compression if called too often. */ +Z_EXTERN Z_EXPORT +z_off64_t zng_gzseek(gzFile file, z_off64_t offset, int whence); /* -ZEXTERN z_off_t ZEXPORT zng_gzseek (gzFile file, z_off_t offset, int whence); - Sets the starting position for the next gzread or gzwrite on the given compressed file. The offset represents a number of bytes in the uncompressed data stream. The whence parameter is defined as in lseek(2); @@ -1514,16 +1555,17 @@ ZEXTERN z_off_t ZEXPORT zng_gzseek (gzFile file, z_off_t offset, int whence); would be before the current position. */ -ZEXTERN int ZEXPORT zng_gzrewind(gzFile file); +Z_EXTERN Z_EXPORT +int32_t zng_gzrewind(gzFile file); /* Rewinds the given file. This function is supported only for reading. gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) */ +Z_EXTERN Z_EXPORT +z_off64_t zng_gztell(gzFile file); /* -ZEXTERN z_off_t ZEXPORT zng_gztell(gzFile file); - Returns the starting position for the next gzread or gzwrite on the given compressed file. This position represents a number of bytes in the uncompressed data stream, and is zero when starting, even if appending or @@ -1532,9 +1574,9 @@ ZEXTERN z_off_t ZEXPORT zng_gztell(gzFile file); gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) */ +Z_EXTERN Z_EXPORT +z_off64_t zng_gzoffset(gzFile file); /* -ZEXTERN z_off_t ZEXPORT zng_gzoffset(gzFile file); - Returns the current offset in the file being read or written. This offset includes the count of bytes that precede the gzip stream, for example when appending or when using gzdopen() for reading. When reading, the offset @@ -1542,7 +1584,8 @@ ZEXTERN z_off_t ZEXPORT zng_gzoffset(gzFile file); for a progress indicator. On error, gzoffset() returns -1. */ -ZEXTERN int ZEXPORT zng_gzeof(gzFile file); +Z_EXTERN Z_EXPORT +int32_t zng_gzeof(gzFile file); /* Returns true (1) if the end-of-file indicator has been set while reading, false (0) otherwise. Note that the end-of-file indicator is set only if the @@ -1557,7 +1600,8 @@ ZEXTERN int ZEXPORT zng_gzeof(gzFile file); has grown since the previous end of file was detected. */ -ZEXTERN int ZEXPORT zng_gzdirect(gzFile file); +Z_EXTERN Z_EXPORT +int32_t zng_gzdirect(gzFile file); /* Returns true (1) if file is being copied directly while reading, or false (0) if file is a gzip stream being decompressed. @@ -1578,7 +1622,8 @@ ZEXTERN int ZEXPORT zng_gzdirect(gzFile file); gzip file reading and decompression, which may not be desired.) */ -ZEXTERN int ZEXPORT zng_gzclose(gzFile file); +Z_EXTERN Z_EXPORT +int32_t zng_gzclose(gzFile file); /* Flushes all pending output if necessary, closes the compressed file and deallocates the (de)compression state. Note that once file is closed, you @@ -1591,8 +1636,10 @@ ZEXTERN int ZEXPORT zng_gzclose(gzFile file); last read ended in the middle of a gzip stream, or Z_OK on success. */ -ZEXTERN int ZEXPORT zng_gzclose_r(gzFile file); -ZEXTERN int ZEXPORT zng_gzclose_w(gzFile file); +Z_EXTERN Z_EXPORT +int32_t zng_gzclose_r(gzFile file); +Z_EXTERN Z_EXPORT +int32_t zng_gzclose_w(gzFile file); /* Same as gzclose(), but gzclose_r() is only for use when reading, and gzclose_w() is only for use when writing or appending. The advantage to @@ -1603,7 +1650,8 @@ ZEXTERN int ZEXPORT zng_gzclose_w(gzFile file); zlib library. */ -ZEXTERN const char * ZEXPORT zng_gzerror(gzFile file, int *errnum); +Z_EXTERN Z_EXPORT +const char * zng_gzerror(gzFile file, int32_t *errnum); /* Returns the error message for the last error which occurred on the given compressed file. errnum is set to zlib error number. If an error occurred @@ -1619,7 +1667,8 @@ ZEXTERN const char * ZEXPORT zng_gzerror(gzFile file, int *errnum); functions above that do not distinguish those cases in their return values. */ -ZEXTERN void ZEXPORT zng_gzclearerr(gzFile file); +Z_EXTERN Z_EXPORT +void zng_gzclearerr(gzFile file); /* Clears the error and end-of-file flags for file. This is analogous to the clearerr() function in stdio. This is useful for continuing to read a gzip @@ -1636,7 +1685,8 @@ ZEXTERN void ZEXPORT zng_gzclearerr(gzFile file); library. */ -ZEXTERN uint32_t ZEXPORT zng_adler32(uint32_t adler, const unsigned char *buf, uint32_t len); +Z_EXTERN Z_EXPORT +uint32_t zng_adler32(uint32_t adler, const uint8_t *buf, uint32_t len); /* Update a running Adler-32 checksum with the bytes buf[0..len-1] and return the updated checksum. If buf is NULL, this function returns the @@ -1655,14 +1705,15 @@ ZEXTERN uint32_t ZEXPORT zng_adler32(uint32_t adler, const unsigned char *buf, u if (adler != original_adler) error(); */ -ZEXTERN uint32_t ZEXPORT zng_adler32_z (uint32_t adler, const unsigned char *buf, size_t len); +Z_EXTERN Z_EXPORT +uint32_t zng_adler32_z(uint32_t adler, const uint8_t *buf, size_t len); /* Same as adler32(), but with a size_t length. */ +Z_EXTERN Z_EXPORT +uint32_t zng_adler32_combine(uint32_t adler1, uint32_t adler2, z_off64_t len2); /* -ZEXTERN uint32_t ZEXPORT zng_adler32_combine(uint32_t adler1, uint32_t adler2, z_off_t len2); - Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of @@ -1671,7 +1722,8 @@ ZEXTERN uint32_t ZEXPORT zng_adler32_combine(uint32_t adler1, uint32_t adler2, z negative, the result has no meaning or utility. */ -ZEXTERN uint32_t ZEXPORT zng_crc32(uint32_t crc, const unsigned char *buf, uint32_t len); +Z_EXTERN Z_EXPORT +uint32_t zng_crc32(uint32_t crc, const uint8_t *buf, uint32_t len); /* Update a running CRC-32 with the bytes buf[0..len-1] and return the updated CRC-32. If buf is NULL, this function returns the required @@ -1688,14 +1740,16 @@ ZEXTERN uint32_t ZEXPORT zng_crc32(uint32_t crc, const unsigned char *buf, uint3 if (crc != original_crc) error(); */ -ZEXTERN uint32_t ZEXPORT zng_crc32_z (uint32_t crc, const unsigned char *buf, size_t len); +Z_EXTERN Z_EXPORT +uint32_t zng_crc32_z(uint32_t crc, const uint8_t *buf, size_t len); /* Same as crc32(), but with a size_t length. */ -/* -ZEXTERN uint32_t ZEXPORT zng_crc32_combine(uint32_t crc1, uint32_t crc2, z_off64_t len2); +Z_EXTERN Z_EXPORT +uint32_t zng_crc32_combine(uint32_t crc1, uint32_t crc2, z_off64_t len2); +/* Combine two CRC-32 check values into one. For two sequences of bytes, seq1 and seq2 with lengths len1 and len2, CRC-32 check values were calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 @@ -1703,16 +1757,17 @@ ZEXTERN uint32_t ZEXPORT zng_crc32_combine(uint32_t crc1, uint32_t crc2, z_off64 len2. */ -/* -ZEXTERN void ZEXPORT zng_crc32_combine_gen(uint32_t op[32], z_off_t len2); +Z_EXTERN Z_EXPORT +void zng_crc32_combine_gen(uint32_t op[32], z_off64_t len2); +/* Generate the operator op corresponding to length len2, to be used with crc32_combine_op(). op must have room for 32 uint32_t values. (32 is the number of bits in the CRC.) */ -ZEXTERN uint32_t ZEXPORT zng_crc32_combine_op(uint32_t crc1, uint32_t crc2, - const uint32_t *op); +Z_EXTERN Z_EXPORT +uint32_t zng_crc32_combine_op(uint32_t crc1, uint32_t crc2, const uint32_t *op); /* Give the same result as crc32_combine(), using op in place of len2. op is is generated from len2 by crc32_combine_gen(). This will be faster than @@ -1724,21 +1779,22 @@ ZEXTERN uint32_t ZEXPORT zng_crc32_combine_op(uint32_t crc1, uint32_t crc2, /* zng_deflateInit and zng_inflateInit are macros to allow checking the zlib version * and the compiler's view of zng_stream: */ -ZEXTERN int ZEXPORT zng_deflateInit_(zng_stream *strm, int level, const char *version, int stream_size); -ZEXTERN int ZEXPORT zng_inflateInit_(zng_stream *strm, const char *version, int stream_size); -ZEXTERN int ZEXPORT zng_deflateInit2_(zng_stream *strm, int level, int method, int windowBits, int memLevel, - int strategy, const char *version, int stream_size); -ZEXTERN int ZEXPORT zng_inflateInit2_(zng_stream *strm, int windowBits, const char *version, int stream_size); -ZEXTERN int ZEXPORT zng_inflateBackInit_(zng_stream *strm, int windowBits, unsigned char *window, - const char *version, int stream_size); -#define zng_deflateInit(strm, level) zng_deflateInit_((strm), (level), ZLIBNG_VERSION, (int)sizeof(zng_stream)) -#define zng_inflateInit(strm) zng_inflateInit_((strm), ZLIBNG_VERSION, (int)sizeof(zng_stream)) +Z_EXTERN Z_EXPORT int32_t zng_deflateInit_(zng_stream *strm, int32_t level, const char *version, int32_t stream_size); +Z_EXTERN Z_EXPORT int32_t zng_inflateInit_(zng_stream *strm, const char *version, int32_t stream_size); +Z_EXTERN Z_EXPORT int32_t zng_deflateInit2_(zng_stream *strm, int32_t level, int32_t method, int32_t windowBits, int32_t memLevel, + int32_t strategy, const char *version, int32_t stream_size); +Z_EXTERN Z_EXPORT int32_t zng_inflateInit2_(zng_stream *strm, int32_t windowBits, const char *version, int32_t stream_size); +Z_EXTERN Z_EXPORT int32_t zng_inflateBackInit_(zng_stream *strm, int32_t windowBits, uint8_t *window, + const char *version, int32_t stream_size); + +#define zng_deflateInit(strm, level) zng_deflateInit_((strm), (level), ZLIBNG_VERSION, (int32_t)sizeof(zng_stream)) +#define zng_inflateInit(strm) zng_inflateInit_((strm), ZLIBNG_VERSION, (int32_t)sizeof(zng_stream)) #define zng_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ zng_deflateInit2_((strm), (level), (method), (windowBits), (memLevel), \ - (strategy), ZLIBNG_VERSION, (int)sizeof(zng_stream)) -#define zng_inflateInit2(strm, windowBits) zng_inflateInit2_((strm), (windowBits), ZLIBNG_VERSION, (int)sizeof(zng_stream)) + (strategy), ZLIBNG_VERSION, (int32_t)sizeof(zng_stream)) +#define zng_inflateInit2(strm, windowBits) zng_inflateInit2_((strm), (windowBits), ZLIBNG_VERSION, (int32_t)sizeof(zng_stream)) #define zng_inflateBackInit(strm, windowBits, window) \ - zng_inflateBackInit_((strm), (windowBits), (window), ZLIBNG_VERSION, (int)sizeof(zng_stream)) + zng_inflateBackInit_((strm), (windowBits), (window), ZLIBNG_VERSION, (int32_t)sizeof(zng_stream)) #ifdef WITH_GZFILEOP @@ -1754,85 +1810,75 @@ struct gzFile_s { unsigned char *next; z_off64_t pos; }; -ZEXTERN int ZEXPORT zng_gzgetc_(gzFile file); /* backward compatibility */ +Z_EXTERN Z_EXPORT int32_t zng_gzgetc_(gzFile file); /* backward compatibility */ # define zng_gzgetc(g) ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (zng_gzgetc)(g)) -/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or - * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if - * both are true, the application gets the *64 functions, and the regular - * functions are changed to 64 bits) -- in case these are set on systems - * without large file support, _LFS64_LARGEFILE must also be true - */ -#ifdef Z_LARGE64 - ZEXTERN gzFile ZEXPORT zng_gzopen64(const char *, const char *); - ZEXTERN z_off64_t ZEXPORT zng_gzseek64(gzFile, z_off64_t, int); - ZEXTERN z_off64_t ZEXPORT zng_gztell64(gzFile); - ZEXTERN z_off64_t ZEXPORT zng_gzoffset64(gzFile); -#endif - -#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) -# define zng_gzopen zng_gzopen64 -# define zng_gzseek zng_gzseek64 -# define zng_gztell zng_gztell64 -# define zng_gzoffset zng_gzoffset64 -# ifndef Z_LARGE64 - ZEXTERN gzFile ZEXPORT zng_gzopen64(const char *, const char *); - ZEXTERN z_off_t ZEXPORT zng_gzseek64(gzFile, z_off_t, int); - ZEXTERN z_off_t ZEXPORT zng_gztell64(gzFile); - ZEXTERN z_off_t ZEXPORT zng_gzoffset64(gzFile); -# endif -#else - ZEXTERN gzFile ZEXPORT zng_gzopen(const char *, const char *); - ZEXTERN z_off_t ZEXPORT zng_gzseek(gzFile, z_off_t, int); - ZEXTERN z_off_t ZEXPORT zng_gztell(gzFile); - ZEXTERN z_off_t ZEXPORT zng_gzoffset(gzFile); -#endif #endif /* WITH_GZFILEOP */ -/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or - * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if - * both are true, the application gets the *64 functions, and the regular - * functions are changed to 64 bits) -- in case these are set on systems - * without large file support, _LFS64_LARGEFILE must also be true - */ -#ifdef Z_LARGE64 - ZEXTERN uint32_t ZEXPORT zng_adler32_combine64(uint32_t, uint32_t, z_off64_t); - ZEXTERN uint32_t ZEXPORT zng_crc32_combine64(uint32_t, uint32_t, z_off64_t); - ZEXTERN void ZEXPORT zng_crc32_combine_gen64(uint32_t *op, z_off64_t); -#endif +typedef enum { + Z_DEFLATE_LEVEL = 0, /* compression level, represented as an int */ + Z_DEFLATE_STRATEGY = 1, /* compression strategy, represented as an int */ + Z_DEFLATE_REPRODUCIBLE = 2, + /* + Whether reproducible compression results are required. Represented as an int, where 0 means that it is allowed + to trade reproducibility for e.g. improved performance or compression ratio, and non-0 means that + reproducibility is strictly required. Reproducibility is guaranteed only when using an identical zlib-ng build. + Default is 0. + */ +} zng_deflate_param; -#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) -# define zng_adler32_combine zng_adler32_combine64 -# define zng_crc32_combine zng_crc32_combine64 -# define zng_crc32_combine_gen zng_crc32_combine_gen64 -# ifndef Z_LARGE64 - ZEXTERN uint32_t ZEXPORT zng_adler32_combine64(uint32_t, uint32_t, z_off_t); - ZEXTERN uint32_t ZEXPORT zng_crc32_combine64(uint32_t, uint32_t, z_off_t); - ZEXTERN void ZEXPORT zng_crc32_combine_gen64(uint32_t *op, z_off64_t); -# endif -#else - ZEXTERN uint32_t ZEXPORT zng_adler32_combine(uint32_t, uint32_t, z_off_t); - ZEXTERN uint32_t ZEXPORT zng_crc32_combine(uint32_t, uint32_t, z_off_t); - ZEXTERN void ZEXPORT zng_crc32_combine_gen(uint32_t *op, z_off_t); -#endif +typedef struct { + zng_deflate_param param; /* parameter ID */ + void *buf; /* parameter value */ + size_t size; /* parameter value size */ + int32_t status; /* result of the last set/get call */ +} zng_deflate_param_value; +Z_EXTERN Z_EXPORT +int32_t zng_deflateSetParams(zng_stream *strm, zng_deflate_param_value *params, size_t count); +/* + Sets the values of the given zlib-ng deflate stream parameters. All the buffers are copied internally, so the + caller still owns them after this function returns. Returns Z_OK if success. + + If the size of at least one of the buffers is too small to hold the entire value of the corresponding parameter, + or if the same parameter is specified multiple times, Z_BUF_ERROR is returned. The caller may inspect status fields + in order to determine which of the parameters caused this error. No other changes are performed. + + If the stream state is inconsistent or if at least one of the values cannot be updated, Z_STREAM_ERROR is + returned. The caller may inspect status fields in order to determine which of the parameters caused this error. + Parameters, whose status field is equal to Z_OK, have been applied successfully. If all status fields are not equal + to Z_STREAM_ERROR, then the error was caused by a stream state inconsistency. + + If there are no other errors, but at least one parameter is not supported by the current zlib-ng version, + Z_VERSION_ERROR is returned. The caller may inspect status fields in order to determine which of the parameters + caused this error. +*/ + +Z_EXTERN Z_EXPORT +int32_t zng_deflateGetParams(zng_stream *strm, zng_deflate_param_value *params, size_t count); +/* + Copies the values of the given zlib-ng deflate stream parameters into the user-provided buffers. Returns Z_OK if + success, Z_VERSION_ERROR if at least one parameter is not supported by the current zlib-ng version, Z_STREAM_ERROR + if the stream state is inconsistent, and Z_BUF_ERROR if the size of at least one buffer is too small to hold the + entire value of the corresponding parameter. +*/ /* undocumented functions */ -ZEXTERN const char * ZEXPORT zng_zError (int); -ZEXTERN int ZEXPORT zng_inflateSyncPoint (zng_stream *); -ZEXTERN const uint32_t * ZEXPORT zng_get_crc_table (void); -ZEXTERN int ZEXPORT zng_inflateUndermine (zng_stream *, int); -ZEXTERN int ZEXPORT zng_inflateValidate (zng_stream *, int); -ZEXTERN unsigned long ZEXPORT zng_inflateCodesUsed (zng_stream *); -ZEXTERN int ZEXPORT zng_inflateResetKeep (zng_stream *); -ZEXTERN int ZEXPORT zng_deflateResetKeep (zng_stream *); +Z_EXTERN Z_EXPORT const char * zng_zError (int32_t); +Z_EXTERN Z_EXPORT int32_t zng_inflateSyncPoint (zng_stream *); +Z_EXTERN Z_EXPORT const uint32_t * zng_get_crc_table (void); +Z_EXTERN Z_EXPORT int32_t zng_inflateUndermine (zng_stream *, int32_t); +Z_EXTERN Z_EXPORT int32_t zng_inflateValidate (zng_stream *, int32_t); +Z_EXTERN Z_EXPORT unsigned long zng_inflateCodesUsed (zng_stream *); +Z_EXTERN Z_EXPORT int32_t zng_inflateResetKeep (zng_stream *); +Z_EXTERN Z_EXPORT int32_t zng_deflateResetKeep (zng_stream *); #ifdef WITH_GZFILEOP -# if (defined(WIN32) || defined(__MINGW__)) - ZEXTERN gzFile ZEXPORT zng_gzopen_w(const wchar_t *path, const char *mode); -# endif -ZEXTERN int ZEXPORTVA zng_gzvprintf(gzFile file, const char *format, va_list va); +# if defined(_WIN32) + Z_EXTERN Z_EXPORT gzFile zng_gzopen_w(const wchar_t *path, const char *mode); +# endif +Z_EXTERN Z_EXPORTVA int32_t zng_gzvprintf(gzFile file, const char *format, va_list va); #endif #ifdef __cplusplus diff --git a/libs/zlibng/zlib-ng.map b/libs/zlibng/zlib-ng.map index 107d06958..b0046034c 100644 --- a/libs/zlibng/zlib-ng.map +++ b/libs/zlibng/zlib-ng.map @@ -1,16 +1,14 @@ -ZLIB_NG_1.9.9 { +ZLIB_NG_2.0.0 { global: zng_adler32; zng_adler32_c; zng_adler32_combine; - zng_adler32_combine64; zng_adler32_z; zng_compress; zng_compress2; zng_compressBound; zng_crc32; zng_crc32_combine; - zng_crc32_combine64; zng_crc32_combine_gen; zng_crc32_combine_op; zng_crc32_z; @@ -19,6 +17,7 @@ ZLIB_NG_1.9.9 { zng_deflateCopy; zng_deflateEnd; zng_deflateGetDictionary; + zng_deflateGetParams; zng_deflateInit_; zng_deflateInit2_; zng_deflateParams; @@ -28,6 +27,7 @@ ZLIB_NG_1.9.9 { zng_deflateResetKeep; zng_deflateSetDictionary; zng_deflateSetHeader; + zng_deflateSetParams; zng_deflateTune; zng_get_crc_table; zng_inflate; @@ -70,7 +70,7 @@ ZLIB_NG_1.9.9 { _*; }; -ZLIB_NG_GZ_1.9.9 { +ZLIB_NG_GZ_2.0.0 { global: zng_gzbuffer; zng_gzclearerr; diff --git a/libs/zlibng/zlib.3.pdf b/libs/zlibng/zlib.3.pdf deleted file mode 100644 index 6fa519c5b..000000000 Binary files a/libs/zlibng/zlib.3.pdf and /dev/null differ diff --git a/libs/zlibng/zlib.h b/libs/zlibng/zlib.h index 891350013..688fe440e 100644 --- a/libs/zlibng/zlib.h +++ b/libs/zlibng/zlib.h @@ -32,17 +32,17 @@ #include #include -#include "zconf.h" +#include "zconf-ng.h" #ifdef __cplusplus extern "C" { #endif -#define ZLIBNG_VERSION "1.9.9" -#define ZLIBNG_VERNUM 0x1990 -#define ZLIBNG_VER_MAJOR 1 -#define ZLIBNG_VER_MINOR 9 -#define ZLIBNG_VER_REVISION 9 +#define ZLIBNG_VERSION "2.0.0-RC2" +#define ZLIBNG_VERNUM 0x2000 +#define ZLIBNG_VER_MAJOR 2 +#define ZLIBNG_VER_MINOR 0 +#define ZLIBNG_VER_REVISION 0 #define ZLIBNG_VER_SUBREVISION 0 #define ZLIB_VERSION "1.2.11.zlib-ng" @@ -92,15 +92,15 @@ typedef void (*free_func) (void *opaque, void *address); struct internal_state; typedef struct z_stream_s { - const unsigned char *next_in; /* next input byte */ + z_const unsigned char *next_in; /* next input byte */ uint32_t avail_in; /* number of bytes available at next_in */ - size_t total_in; /* total number of input bytes read so far */ + unsigned long total_in; /* total number of input bytes read so far */ unsigned char *next_out; /* next output byte will go here */ uint32_t avail_out; /* remaining free space at next_out */ - size_t total_out; /* total number of bytes output so far */ + unsigned long total_out; /* total number of bytes output so far */ - const char *msg; /* last error message, NULL if no error */ + z_const char *msg; /* last error message, NULL if no error */ struct internal_state *state; /* not visible by applications */ alloc_func zalloc; /* used to allocate the internal state */ @@ -215,7 +215,7 @@ typedef gz_header *gz_headerp; /* basic functions */ -ZEXTERN const char * ZEXPORT zlibVersion(void); +Z_EXTERN const char * Z_EXPORT zlibVersion(void); /* The application can compare zlibVersion and ZLIB_VERSION for consistency. If the first character differs, the library code actually used is not compatible with the zlib.h header file used by the application. This check @@ -223,7 +223,7 @@ ZEXTERN const char * ZEXPORT zlibVersion(void); */ /* -ZEXTERN int ZEXPORT deflateInit (z_stream *strm, int level); +Z_EXTERN int Z_EXPORT deflateInit (z_stream *strm, int level); Initializes the internal stream state for compression. The fields zalloc, zfree and opaque must be initialized before by the caller. If @@ -245,7 +245,7 @@ ZEXTERN int ZEXPORT deflateInit (z_stream *strm, int level); */ -ZEXTERN int ZEXPORT deflate(z_stream *strm, int flush); +Z_EXTERN int Z_EXPORT deflate(z_stream *strm, int flush); /* deflate compresses as much data as possible, and stops when the input buffer becomes empty or the output buffer becomes full. It may introduce @@ -358,7 +358,7 @@ ZEXTERN int ZEXPORT deflate(z_stream *strm, int flush); */ -ZEXTERN int ZEXPORT deflateEnd(z_stream *strm); +Z_EXTERN int Z_EXPORT deflateEnd(z_stream *strm); /* All dynamically allocated data structures for this stream are freed. This function discards any unprocessed input and does not flush any pending @@ -373,7 +373,7 @@ ZEXTERN int ZEXPORT deflateEnd(z_stream *strm); /* -ZEXTERN int ZEXPORT inflateInit (z_stream *strm); +Z_EXTERN int Z_EXPORT inflateInit (z_stream *strm); Initializes the internal stream state for decompression. The fields next_in, avail_in, zalloc, zfree and opaque must be initialized before by @@ -395,7 +395,7 @@ ZEXTERN int ZEXPORT inflateInit (z_stream *strm); */ -ZEXTERN int ZEXPORT inflate(z_stream *strm, int flush); +Z_EXTERN int Z_EXPORT inflate(z_stream *strm, int flush); /* inflate decompresses as much data as possible, and stops when the input buffer becomes empty or the output buffer becomes full. It may introduce @@ -515,7 +515,7 @@ ZEXTERN int ZEXPORT inflate(z_stream *strm, int flush); */ -ZEXTERN int ZEXPORT inflateEnd(z_stream *strm); +Z_EXTERN int Z_EXPORT inflateEnd(z_stream *strm); /* All dynamically allocated data structures for this stream are freed. This function discards any unprocessed input and does not flush any pending @@ -533,7 +533,7 @@ ZEXTERN int ZEXPORT inflateEnd(z_stream *strm); */ /* -ZEXTERN int ZEXPORT deflateInit2 (z_stream *strm, +Z_EXTERN int Z_EXPORT deflateInit2 (z_stream *strm, int level, int method, int windowBits, @@ -605,7 +605,7 @@ ZEXTERN int ZEXPORT deflateInit2 (z_stream *strm, compression: this will be done by deflate(). */ -ZEXTERN int ZEXPORT deflateSetDictionary(z_stream *strm, +Z_EXTERN int Z_EXPORT deflateSetDictionary(z_stream *strm, const unsigned char *dictionary, unsigned int dictLength); /* @@ -649,7 +649,7 @@ ZEXTERN int ZEXPORT deflateSetDictionary(z_stream *strm, not perform any compression: this will be done by deflate(). */ -ZEXTERN int ZEXPORT deflateGetDictionary (z_stream *strm, unsigned char *dictionary, unsigned int *dictLength); +Z_EXTERN int Z_EXPORT deflateGetDictionary (z_stream *strm, unsigned char *dictionary, unsigned int *dictLength); /* Returns the sliding dictionary being maintained by deflate. dictLength is set to the number of bytes in the dictionary, and that many bytes are copied @@ -669,7 +669,7 @@ ZEXTERN int ZEXPORT deflateGetDictionary (z_stream *strm, unsigned char *diction stream state is inconsistent. */ -ZEXTERN int ZEXPORT deflateCopy(z_stream *dest, z_stream *source); +Z_EXTERN int Z_EXPORT deflateCopy(z_stream *dest, z_stream *source); /* Sets the destination stream as a complete copy of the source stream. @@ -686,7 +686,7 @@ ZEXTERN int ZEXPORT deflateCopy(z_stream *dest, z_stream *source); destination. */ -ZEXTERN int ZEXPORT deflateReset(z_stream *strm); +Z_EXTERN int Z_EXPORT deflateReset(z_stream *strm); /* This function is equivalent to deflateEnd followed by deflateInit, but does not free and reallocate the internal compression state. The stream @@ -697,7 +697,7 @@ ZEXTERN int ZEXPORT deflateReset(z_stream *strm); stream state was inconsistent (such as zalloc or state being NULL). */ -ZEXTERN int ZEXPORT deflateParams(z_stream *strm, int level, int strategy); +Z_EXTERN int Z_EXPORT deflateParams(z_stream *strm, int level, int strategy); /* Dynamically update the compression level and compression strategy. The interpretation of level and strategy is as in deflateInit2(). This can be @@ -733,7 +733,7 @@ ZEXTERN int ZEXPORT deflateParams(z_stream *strm, int level, int strategy); retried with more output space. */ -ZEXTERN int ZEXPORT deflateTune(z_stream *strm, int good_length, int max_lazy, int nice_length, int max_chain); +Z_EXTERN int Z_EXPORT deflateTune(z_stream *strm, int good_length, int max_lazy, int nice_length, int max_chain); /* Fine tune deflate's internal compression parameters. This should only be used by someone who understands the algorithm used by zlib's deflate for @@ -746,7 +746,7 @@ ZEXTERN int ZEXPORT deflateTune(z_stream *strm, int good_length, int max_lazy, i returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. */ -ZEXTERN unsigned long ZEXPORT deflateBound(z_stream *strm, unsigned long sourceLen); +Z_EXTERN unsigned long Z_EXPORT deflateBound(z_stream *strm, unsigned long sourceLen); /* deflateBound() returns an upper bound on the compressed size after deflation of sourceLen bytes. It must be called after deflateInit() or @@ -760,7 +760,7 @@ ZEXTERN unsigned long ZEXPORT deflateBound(z_stream *strm, unsigned long sourceL than Z_FINISH or Z_NO_FLUSH are used. */ -ZEXTERN int ZEXPORT deflatePending(z_stream *strm, uint32_t *pending, int *bits); +Z_EXTERN int Z_EXPORT deflatePending(z_stream *strm, uint32_t *pending, int *bits); /* deflatePending() returns the number of bytes and bits of output that have been generated, but not yet provided in the available output. The bytes not @@ -773,7 +773,7 @@ ZEXTERN int ZEXPORT deflatePending(z_stream *strm, uint32_t *pending, int *bits) stream state was inconsistent. */ -ZEXTERN int ZEXPORT deflatePrime(z_stream *strm, int bits, int value); +Z_EXTERN int Z_EXPORT deflatePrime(z_stream *strm, int bits, int value); /* deflatePrime() inserts bits in the deflate output stream. The intent is that this function is used to start off the deflate output with the bits @@ -788,7 +788,7 @@ ZEXTERN int ZEXPORT deflatePrime(z_stream *strm, int bits, int value); source stream state was inconsistent. */ -ZEXTERN int ZEXPORT deflateSetHeader(z_stream *strm, gz_headerp head); +Z_EXTERN int Z_EXPORT deflateSetHeader(z_stream *strm, gz_headerp head); /* deflateSetHeader() provides gzip header information for when a gzip stream is requested by deflateInit2(). deflateSetHeader() may be called @@ -812,7 +812,7 @@ ZEXTERN int ZEXPORT deflateSetHeader(z_stream *strm, gz_headerp head); */ /* -ZEXTERN int ZEXPORT inflateInit2(z_stream *strm, int windowBits); +Z_EXTERN int Z_EXPORT inflateInit2(z_stream *strm, int windowBits); This is another version of inflateInit with an extra parameter. The fields next_in, avail_in, zalloc, zfree and opaque must be initialized @@ -865,7 +865,7 @@ ZEXTERN int ZEXPORT inflateInit2(z_stream *strm, int windowBits); deferred until inflate() is called. */ -ZEXTERN int ZEXPORT inflateSetDictionary(z_stream *strm, const unsigned char *dictionary, unsigned int dictLength); +Z_EXTERN int Z_EXPORT inflateSetDictionary(z_stream *strm, const unsigned char *dictionary, unsigned int dictLength); /* Initializes the decompression dictionary from the given uncompressed byte sequence. This function must be called immediately after a call of inflate, @@ -886,7 +886,7 @@ ZEXTERN int ZEXPORT inflateSetDictionary(z_stream *strm, const unsigned char *di inflate(). */ -ZEXTERN int ZEXPORT inflateGetDictionary(z_stream *strm, unsigned char *dictionary, unsigned int *dictLength); +Z_EXTERN int Z_EXPORT inflateGetDictionary(z_stream *strm, unsigned char *dictionary, unsigned int *dictLength); /* Returns the sliding dictionary being maintained by inflate. dictLength is set to the number of bytes in the dictionary, and that many bytes are copied @@ -899,7 +899,7 @@ ZEXTERN int ZEXPORT inflateGetDictionary(z_stream *strm, unsigned char *dictiona stream state is inconsistent. */ -ZEXTERN int ZEXPORT inflateSync(z_stream *strm); +Z_EXTERN int Z_EXPORT inflateSync(z_stream *strm); /* Skips invalid compressed data until a possible full flush point (see above for the description of deflate with Z_FULL_FLUSH) can be found, or until all @@ -918,7 +918,7 @@ ZEXTERN int ZEXPORT inflateSync(z_stream *strm); input each time, until success or end of the input data. */ -ZEXTERN int ZEXPORT inflateCopy(z_stream *dest, z_stream *source); +Z_EXTERN int Z_EXPORT inflateCopy(z_stream *dest, z_stream *source); /* Sets the destination stream as a complete copy of the source stream. @@ -933,7 +933,7 @@ ZEXTERN int ZEXPORT inflateCopy(z_stream *dest, z_stream *source); destination. */ -ZEXTERN int ZEXPORT inflateReset(z_stream *strm); +Z_EXTERN int Z_EXPORT inflateReset(z_stream *strm); /* This function is equivalent to inflateEnd followed by inflateInit, but does not free and reallocate the internal decompression state. The @@ -943,7 +943,7 @@ ZEXTERN int ZEXPORT inflateReset(z_stream *strm); stream state was inconsistent (such as zalloc or state being NULL). */ -ZEXTERN int ZEXPORT inflateReset2(z_stream *strm, int windowBits); +Z_EXTERN int Z_EXPORT inflateReset2(z_stream *strm, int windowBits); /* This function is the same as inflateReset, but it also permits changing the wrap and window size requests. The windowBits parameter is interpreted @@ -956,7 +956,7 @@ ZEXTERN int ZEXPORT inflateReset2(z_stream *strm, int windowBits); the windowBits parameter is invalid. */ -ZEXTERN int ZEXPORT inflatePrime(z_stream *strm, int bits, int value); +Z_EXTERN int Z_EXPORT inflatePrime(z_stream *strm, int bits, int value); /* This function inserts bits in the inflate input stream. The intent is that this function is used to start inflating at a bit position in the @@ -975,7 +975,7 @@ ZEXTERN int ZEXPORT inflatePrime(z_stream *strm, int bits, int value); stream state was inconsistent. */ -ZEXTERN long ZEXPORT inflateMark(z_stream *strm); +Z_EXTERN long Z_EXPORT inflateMark(z_stream *strm); /* This function returns two values, one in the lower 16 bits of the return value, and the other in the remaining upper bits, obtained by shifting the @@ -1003,7 +1003,7 @@ ZEXTERN long ZEXPORT inflateMark(z_stream *strm); source stream state was inconsistent. */ -ZEXTERN int ZEXPORT inflateGetHeader(z_stream *strm, gz_headerp head); +Z_EXTERN int Z_EXPORT inflateGetHeader(z_stream *strm, gz_headerp head); /* inflateGetHeader() requests that gzip header information be stored in the provided gz_header structure. inflateGetHeader() may be called after @@ -1043,7 +1043,7 @@ ZEXTERN int ZEXPORT inflateGetHeader(z_stream *strm, gz_headerp head); */ /* -ZEXTERN int ZEXPORT inflateBackInit (z_stream *strm, int windowBits, unsigned char *window); +Z_EXTERN int Z_EXPORT inflateBackInit (z_stream *strm, int windowBits, unsigned char *window); Initialize the internal stream state for decompression using inflateBack() calls. The fields zalloc, zfree and opaque in strm must be initialized @@ -1063,10 +1063,10 @@ ZEXTERN int ZEXPORT inflateBackInit (z_stream *strm, int windowBits, unsigned ch the version of the header file. */ -typedef uint32_t (*in_func) (void *, const unsigned char * *); +typedef uint32_t (*in_func) (void *, z_const unsigned char * *); typedef int (*out_func) (void *, unsigned char *, uint32_t); -ZEXTERN int ZEXPORT inflateBack(z_stream *strm, in_func in, void *in_desc, out_func out, void *out_desc); +Z_EXTERN int Z_EXPORT inflateBack(z_stream *strm, in_func in, void *in_desc, out_func out, void *out_desc); /* inflateBack() does a raw inflate with a single call using a call-back interface for input and output. This is potentially more efficient than @@ -1134,7 +1134,7 @@ ZEXTERN int ZEXPORT inflateBack(z_stream *strm, in_func in, void *in_desc, out_f cannot return Z_OK. */ -ZEXTERN int ZEXPORT inflateBackEnd(z_stream *strm); +Z_EXTERN int Z_EXPORT inflateBackEnd(z_stream *strm); /* All memory allocated by inflateBackInit() is freed. @@ -1142,7 +1142,7 @@ ZEXTERN int ZEXPORT inflateBackEnd(z_stream *strm); state was inconsistent. */ -ZEXTERN unsigned long ZEXPORT zlibCompileFlags(void); +Z_EXTERN unsigned long Z_EXPORT zlibCompileFlags(void); /* Return flags indicating compile-time options. Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: @@ -1158,7 +1158,7 @@ ZEXTERN unsigned long ZEXPORT zlibCompileFlags(void); 11: 0 (reserved) One-time table building (smaller code, but not thread-safe if true): - 12: BUILDFIXED -- build static block decoding tables when needed + 12: BUILDFIXED -- build static block decoding tables when needed (not supported by zlib-ng) 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed 14,15: 0 (reserved) @@ -1194,7 +1194,7 @@ ZEXTERN unsigned long ZEXPORT zlibCompileFlags(void); you need special options. */ -ZEXTERN int ZEXPORT compress(unsigned char *dest, unsigned long *destLen, const unsigned char *source, unsigned long sourceLen); +Z_EXTERN int Z_EXPORT compress(unsigned char *dest, unsigned long *destLen, const unsigned char *source, unsigned long sourceLen); /* Compresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size @@ -1208,7 +1208,7 @@ ZEXTERN int ZEXPORT compress(unsigned char *dest, unsigned long *destLen, const buffer. */ -ZEXTERN int ZEXPORT compress2(unsigned char *dest, unsigned long *destLen, const unsigned char *source, +Z_EXTERN int Z_EXPORT compress2(unsigned char *dest, unsigned long *destLen, const unsigned char *source, unsigned long sourceLen, int level); /* Compresses the source buffer into the destination buffer. The level @@ -1223,14 +1223,14 @@ ZEXTERN int ZEXPORT compress2(unsigned char *dest, unsigned long *destLen, const Z_STREAM_ERROR if the level parameter is invalid. */ -ZEXTERN unsigned long ZEXPORT compressBound(unsigned long sourceLen); +Z_EXTERN unsigned long Z_EXPORT compressBound(unsigned long sourceLen); /* compressBound() returns an upper bound on the compressed size after compress() or compress2() on sourceLen bytes. It would be used before a compress() or compress2() call to allocate the destination buffer. */ -ZEXTERN int ZEXPORT uncompress(unsigned char *dest, unsigned long *destLen, const unsigned char *source, unsigned long sourceLen); +Z_EXTERN int Z_EXPORT uncompress(unsigned char *dest, unsigned long *destLen, const unsigned char *source, unsigned long sourceLen); /* Decompresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total size @@ -1248,7 +1248,7 @@ ZEXTERN int ZEXPORT uncompress(unsigned char *dest, unsigned long *destLen, cons */ -ZEXTERN int ZEXPORT uncompress2 (unsigned char *dest, unsigned long *destLen, +Z_EXTERN int Z_EXPORT uncompress2 (unsigned char *dest, unsigned long *destLen, const unsigned char *source, unsigned long *sourceLen); /* Same as uncompress, except that sourceLen is a pointer, where the @@ -1269,7 +1269,7 @@ ZEXTERN int ZEXPORT uncompress2 (unsigned char *dest, unsigned long *des typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */ /* -ZEXTERN gzFile ZEXPORT gzopen(const char *path, const char *mode); +Z_EXTERN gzFile Z_EXPORT gzopen(const char *path, const char *mode); Opens a gzip (.gz) file for reading or writing. The mode parameter is as in fopen ("rb" or "wb") but can also include a compression level ("wb9") or @@ -1306,7 +1306,7 @@ ZEXTERN gzFile ZEXPORT gzopen(const char *path, const char *mode); file could not be opened. */ -ZEXTERN gzFile ZEXPORT gzdopen(int fd, const char *mode); +Z_EXTERN gzFile Z_EXPORT gzdopen(int fd, const char *mode); /* gzdopen associates a gzFile with the file descriptor fd. File descriptors are obtained from calls like open, dup, creat, pipe or fileno (if the file @@ -1329,7 +1329,7 @@ ZEXTERN gzFile ZEXPORT gzdopen(int fd, const char *mode); will not detect if fd is invalid (unless fd is -1). */ -ZEXTERN int ZEXPORT gzbuffer(gzFile file, unsigned size); +Z_EXTERN int Z_EXPORT gzbuffer(gzFile file, unsigned size); /* Set the internal buffer size used by this library's functions. The default buffer size is 8192 bytes. This function must be called after @@ -1345,7 +1345,7 @@ ZEXTERN int ZEXPORT gzbuffer(gzFile file, unsigned size); too late. */ -ZEXTERN int ZEXPORT gzsetparams(gzFile file, int level, int strategy); +Z_EXTERN int Z_EXPORT gzsetparams(gzFile file, int level, int strategy); /* Dynamically update the compression level or strategy. See the description of deflateInit2 for the meaning of these parameters. Previously provided @@ -1356,7 +1356,7 @@ ZEXTERN int ZEXPORT gzsetparams(gzFile file, int level, int strategy); or Z_MEM_ERROR if there is a memory allocation error. */ -ZEXTERN int ZEXPORT gzread(gzFile file, void *buf, unsigned len); +Z_EXTERN int Z_EXPORT gzread(gzFile file, void *buf, unsigned len); /* Reads the given number of uncompressed bytes from the compressed file. If the input file is not in gzip format, gzread copies the given number of @@ -1386,7 +1386,7 @@ ZEXTERN int ZEXPORT gzread(gzFile file, void *buf, unsigned len); Z_STREAM_ERROR. */ -ZEXTERN size_t ZEXPORT gzfread (void *buf, size_t size, size_t nitems, gzFile file); +Z_EXTERN size_t Z_EXPORT gzfread (void *buf, size_t size, size_t nitems, gzFile file); /* Read up to nitems items of size size from file to buf, otherwise operating as gzread() does. This duplicates the interface of stdio's fread(), with @@ -1409,14 +1409,14 @@ ZEXTERN size_t ZEXPORT gzfread (void *buf, size_t size, size_t nitems, gzFile fi file, reseting and retrying on end-of-file, when size is not 1. */ -ZEXTERN int ZEXPORT gzwrite(gzFile file, void const *buf, unsigned len); +Z_EXTERN int Z_EXPORT gzwrite(gzFile file, void const *buf, unsigned len); /* Writes the given number of uncompressed bytes into the compressed file. gzwrite returns the number of uncompressed bytes written or 0 in case of error. */ -ZEXTERN size_t ZEXPORT gzfwrite(void const *buf, size_t size, size_t nitems, gzFile file); +Z_EXTERN size_t Z_EXPORT gzfwrite(void const *buf, size_t size, size_t nitems, gzFile file); /* gzfwrite() writes nitems items of size size from buf to file, duplicating the interface of stdio's fwrite(), with size_t request and return types. @@ -1427,7 +1427,7 @@ ZEXTERN size_t ZEXPORT gzfwrite(void const *buf, size_t size, size_t nitems, gzF is returned, and the error state is set to Z_STREAM_ERROR. */ -ZEXTERN int ZEXPORTVA gzprintf(gzFile file, const char *format, ...); +Z_EXTERN int Z_EXPORTVA gzprintf(gzFile file, const char *format, ...); /* Converts, formats, and writes the arguments to the compressed file under control of the format string, as in fprintf. gzprintf returns the number of @@ -1442,7 +1442,7 @@ ZEXTERN int ZEXPORTVA gzprintf(gzFile file, const char *format, ...); This can be determined using zlibCompileFlags(). */ -ZEXTERN int ZEXPORT gzputs(gzFile file, const char *s); +Z_EXTERN int Z_EXPORT gzputs(gzFile file, const char *s); /* Writes the given null-terminated string to the compressed file, excluding the terminating null character. @@ -1450,7 +1450,7 @@ ZEXTERN int ZEXPORT gzputs(gzFile file, const char *s); gzputs returns the number of characters written, or -1 in case of error. */ -ZEXTERN char * ZEXPORT gzgets(gzFile file, char *buf, int len); +Z_EXTERN char * Z_EXPORT gzgets(gzFile file, char *buf, int len); /* Reads bytes from the compressed file until len-1 characters are read, or a newline character is read and transferred to buf, or an end-of-file @@ -1463,13 +1463,13 @@ ZEXTERN char * ZEXPORT gzgets(gzFile file, char *buf, int len); buf are indeterminate. */ -ZEXTERN int ZEXPORT gzputc(gzFile file, int c); +Z_EXTERN int Z_EXPORT gzputc(gzFile file, int c); /* Writes c, converted to an unsigned char, into the compressed file. gzputc returns the value that was written, or -1 in case of error. */ -ZEXTERN int ZEXPORT gzgetc(gzFile file); +Z_EXTERN int Z_EXPORT gzgetc(gzFile file); /* Reads one byte from the compressed file. gzgetc returns this byte or -1 in case of end of file or error. This is implemented as a macro for speed. @@ -1478,7 +1478,7 @@ ZEXTERN int ZEXPORT gzgetc(gzFile file); points to has been clobbered or not. */ -ZEXTERN int ZEXPORT gzungetc(int c, gzFile file); +Z_EXTERN int Z_EXPORT gzungetc(int c, gzFile file); /* Push one character back onto the stream to be read as the first character on the next read. At least one character of push-back is allowed. @@ -1490,7 +1490,7 @@ ZEXTERN int ZEXPORT gzungetc(int c, gzFile file); gzseek() or gzrewind(). */ -ZEXTERN int ZEXPORT gzflush(gzFile file, int flush); +Z_EXTERN int Z_EXPORT gzflush(gzFile file, int flush); /* Flushes all pending output into the compressed file. The parameter flush is as in the deflate() function. The return value is the zlib error number @@ -1506,7 +1506,7 @@ ZEXTERN int ZEXPORT gzflush(gzFile file, int flush); */ /* -ZEXTERN z_off_t ZEXPORT gzseek (gzFile file, z_off_t offset, int whence); +Z_EXTERN z_off_t Z_EXPORT gzseek (gzFile file, z_off_t offset, int whence); Sets the starting position for the next gzread or gzwrite on the given compressed file. The offset represents a number of bytes in the @@ -1524,7 +1524,7 @@ ZEXTERN z_off_t ZEXPORT gzseek (gzFile file, z_off_t offset, int whence); would be before the current position. */ -ZEXTERN int ZEXPORT gzrewind(gzFile file); +Z_EXTERN int Z_EXPORT gzrewind(gzFile file); /* Rewinds the given file. This function is supported only for reading. @@ -1532,7 +1532,7 @@ ZEXTERN int ZEXPORT gzrewind(gzFile file); */ /* -ZEXTERN z_off_t ZEXPORT gztell(gzFile file); +Z_EXTERN z_off_t Z_EXPORT gztell(gzFile file); Returns the starting position for the next gzread or gzwrite on the given compressed file. This position represents a number of bytes in the @@ -1543,7 +1543,7 @@ ZEXTERN z_off_t ZEXPORT gztell(gzFile file); */ /* -ZEXTERN z_off_t ZEXPORT gzoffset(gzFile file); +Z_EXTERN z_off_t Z_EXPORT gzoffset(gzFile file); Returns the current offset in the file being read or written. This offset includes the count of bytes that precede the gzip stream, for example when @@ -1552,7 +1552,7 @@ ZEXTERN z_off_t ZEXPORT gzoffset(gzFile file); for a progress indicator. On error, gzoffset() returns -1. */ -ZEXTERN int ZEXPORT gzeof(gzFile file); +Z_EXTERN int Z_EXPORT gzeof(gzFile file); /* Returns true (1) if the end-of-file indicator has been set while reading, false (0) otherwise. Note that the end-of-file indicator is set only if the @@ -1567,7 +1567,7 @@ ZEXTERN int ZEXPORT gzeof(gzFile file); has grown since the previous end of file was detected. */ -ZEXTERN int ZEXPORT gzdirect(gzFile file); +Z_EXTERN int Z_EXPORT gzdirect(gzFile file); /* Returns true (1) if file is being copied directly while reading, or false (0) if file is a gzip stream being decompressed. @@ -1588,7 +1588,7 @@ ZEXTERN int ZEXPORT gzdirect(gzFile file); gzip file reading and decompression, which may not be desired.) */ -ZEXTERN int ZEXPORT gzclose(gzFile file); +Z_EXTERN int Z_EXPORT gzclose(gzFile file); /* Flushes all pending output if necessary, closes the compressed file and deallocates the (de)compression state. Note that once file is closed, you @@ -1601,8 +1601,8 @@ ZEXTERN int ZEXPORT gzclose(gzFile file); last read ended in the middle of a gzip stream, or Z_OK on success. */ -ZEXTERN int ZEXPORT gzclose_r(gzFile file); -ZEXTERN int ZEXPORT gzclose_w(gzFile file); +Z_EXTERN int Z_EXPORT gzclose_r(gzFile file); +Z_EXTERN int Z_EXPORT gzclose_w(gzFile file); /* Same as gzclose(), but gzclose_r() is only for use when reading, and gzclose_w() is only for use when writing or appending. The advantage to @@ -1613,7 +1613,7 @@ ZEXTERN int ZEXPORT gzclose_w(gzFile file); zlib library. */ -ZEXTERN const char * ZEXPORT gzerror(gzFile file, int *errnum); +Z_EXTERN const char * Z_EXPORT gzerror(gzFile file, int *errnum); /* Returns the error message for the last error which occurred on the given compressed file. errnum is set to zlib error number. If an error occurred @@ -1629,7 +1629,7 @@ ZEXTERN const char * ZEXPORT gzerror(gzFile file, int *errnum); functions above that do not distinguish those cases in their return values. */ -ZEXTERN void ZEXPORT gzclearerr(gzFile file); +Z_EXTERN void Z_EXPORT gzclearerr(gzFile file); /* Clears the error and end-of-file flags for file. This is analogous to the clearerr() function in stdio. This is useful for continuing to read a gzip @@ -1645,7 +1645,7 @@ ZEXTERN void ZEXPORT gzclearerr(gzFile file); library. */ -ZEXTERN uint32_t ZEXPORT adler32(uint32_t adler, const unsigned char *buf, uint32_t len); +Z_EXTERN unsigned long Z_EXPORT adler32(unsigned long adler, const unsigned char *buf, unsigned int len); /* Update a running Adler-32 checksum with the bytes buf[0..len-1] and return the updated checksum. If buf is NULL, this function returns the @@ -1664,13 +1664,13 @@ ZEXTERN uint32_t ZEXPORT adler32(uint32_t adler, const unsigned char *buf, uint3 if (adler != original_adler) error(); */ -ZEXTERN uint32_t ZEXPORT adler32_z (uint32_t adler, const unsigned char *buf, size_t len); +Z_EXTERN unsigned long Z_EXPORT adler32_z(unsigned long adler, const unsigned char *buf, size_t len); /* Same as adler32(), but with a size_t length. */ /* -ZEXTERN uint32_t ZEXPORT adler32_combine(uint32_t adler1, uint32_t adler2, z_off_t len2); +Z_EXTERN unsigned long Z_EXPORT adler32_combine(unsigned long adler1, unsigned long adler2, z_off_t len2); Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for @@ -1680,7 +1680,7 @@ ZEXTERN uint32_t ZEXPORT adler32_combine(uint32_t adler1, uint32_t adler2, z_off negative, the result has no meaning or utility. */ -ZEXTERN uint32_t ZEXPORT crc32(uint32_t crc, const unsigned char *buf, uint32_t len); +Z_EXTERN unsigned long Z_EXPORT crc32(unsigned long crc, const unsigned char *buf, unsigned int len); /* Update a running CRC-32 with the bytes buf[0..len-1] and return the updated CRC-32. If buf is NULL, this function returns the required @@ -1697,13 +1697,13 @@ ZEXTERN uint32_t ZEXPORT crc32(uint32_t crc, const unsigned char *buf, uint32_t if (crc != original_crc) error(); */ -ZEXTERN uint32_t ZEXPORT crc32_z (uint32_t crc, const unsigned char *buf, size_t len); +Z_EXTERN unsigned long Z_EXPORT crc32_z(unsigned long crc, const unsigned char *buf, size_t len); /* Same as crc32(), but with a size_t length. */ /* -ZEXTERN uint32_t ZEXPORT crc32_combine(uint32_t crc1, uint32_t crc2, z_off64_t len2); +Z_EXTERN unsigned long Z_EXPORT crc32_combine(unsigned long crc1, unsigned long crc2, z_off64_t len2); Combine two CRC-32 check values into one. For two sequences of bytes, seq1 and seq2 with lengths len1 and len2, CRC-32 check values were @@ -1713,14 +1713,14 @@ ZEXTERN uint32_t ZEXPORT crc32_combine(uint32_t crc1, uint32_t crc2, z_off64_t l */ /* -ZEXTERN void ZEXPORT crc32_combine_gen(uint32_t op[32], z_off_t len2); +Z_EXTERN void Z_EXPORT crc32_combine_gen(uint32_t op[32], z_off_t len2); Generate the operator op corresponding to length len2, to be used with crc32_combine_op(). op must have room for 32 z_crc_t values. (32 is the number of bits in the CRC.) */ -ZEXTERN uint32_t ZEXPORT crc32_combine_op(uint32_t crc1, uint32_t crc2, +Z_EXTERN uint32_t Z_EXPORT crc32_combine_op(uint32_t crc1, uint32_t crc2, const uint32_t *op); /* Give the same result as crc32_combine(), using op in place of len2. op is @@ -1734,12 +1734,12 @@ ZEXTERN uint32_t ZEXPORT crc32_combine_op(uint32_t crc1, uint32_t crc2, /* deflateInit and inflateInit are macros to allow checking the zlib version * and the compiler's view of z_stream: */ -ZEXTERN int ZEXPORT deflateInit_(z_stream *strm, int level, const char *version, int stream_size); -ZEXTERN int ZEXPORT inflateInit_(z_stream *strm, const char *version, int stream_size); -ZEXTERN int ZEXPORT deflateInit2_(z_stream *strm, int level, int method, int windowBits, int memLevel, +Z_EXTERN int Z_EXPORT deflateInit_(z_stream *strm, int level, const char *version, int stream_size); +Z_EXTERN int Z_EXPORT inflateInit_(z_stream *strm, const char *version, int stream_size); +Z_EXTERN int Z_EXPORT deflateInit2_(z_stream *strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size); -ZEXTERN int ZEXPORT inflateInit2_(z_stream *strm, int windowBits, const char *version, int stream_size); -ZEXTERN int ZEXPORT inflateBackInit_(z_stream *strm, int windowBits, unsigned char *window, +Z_EXTERN int Z_EXPORT inflateInit2_(z_stream *strm, int windowBits, const char *version, int stream_size); +Z_EXTERN int Z_EXPORT inflateBackInit_(z_stream *strm, int windowBits, unsigned char *window, const char *version, int stream_size); #define deflateInit(strm, level) deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) #define inflateInit(strm) inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) @@ -1763,7 +1763,7 @@ struct gzFile_s { unsigned char *next; z_off64_t pos; }; -ZEXTERN int ZEXPORT gzgetc_(gzFile file); /* backward compatibility */ +Z_EXTERN int Z_EXPORT gzgetc_(gzFile file); /* backward compatibility */ # define gzgetc(g) ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g)) /* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or @@ -1773,10 +1773,13 @@ ZEXTERN int ZEXPORT gzgetc_(gzFile file); /* backward compatibility */ * without large file support, _LFS64_LARGEFILE must also be true */ #ifdef Z_LARGE64 - ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *); - ZEXTERN z_off64_t ZEXPORT gzseek64(gzFile, z_off64_t, int); - ZEXTERN z_off64_t ZEXPORT gztell64(gzFile); - ZEXTERN z_off64_t ZEXPORT gzoffset64(gzFile); + Z_EXTERN gzFile Z_EXPORT gzopen64(const char *, const char *); + Z_EXTERN z_off64_t Z_EXPORT gzseek64(gzFile, z_off64_t, int); + Z_EXTERN z_off64_t Z_EXPORT gztell64(gzFile); + Z_EXTERN z_off64_t Z_EXPORT gzoffset64(gzFile); + Z_EXTERN unsigned long Z_EXPORT adler32_combine64(unsigned long, unsigned long, z_off64_t); + Z_EXTERN unsigned long Z_EXPORT crc32_combine64(unsigned long, unsigned long, z_off64_t); + Z_EXTERN void Z_EXPORT crc32_combine_gen64(uint32_t *op, z_off64_t); #endif #if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) @@ -1784,62 +1787,42 @@ ZEXTERN int ZEXPORT gzgetc_(gzFile file); /* backward compatibility */ # define gzseek gzseek64 # define gztell gztell64 # define gzoffset gzoffset64 -# ifndef Z_LARGE64 - ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *); - ZEXTERN z_off_t ZEXPORT gzseek64(gzFile, z_off_t, int); - ZEXTERN z_off_t ZEXPORT gztell64(gzFile); - ZEXTERN z_off_t ZEXPORT gzoffset64(gzFile); -# endif -#else - ZEXTERN gzFile ZEXPORT gzopen(const char *, const char *); - ZEXTERN z_off_t ZEXPORT gzseek(gzFile, z_off_t, int); - ZEXTERN z_off_t ZEXPORT gztell(gzFile); - ZEXTERN z_off_t ZEXPORT gzoffset(gzFile); -#endif - - -/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or - * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if - * both are true, the application gets the *64 functions, and the regular - * functions are changed to 64 bits) -- in case these are set on systems - * without large file support, _LFS64_LARGEFILE must also be true - */ -#ifdef Z_LARGE64 - ZEXTERN uint32_t ZEXPORT adler32_combine64(uint32_t, uint32_t, z_off64_t); - ZEXTERN uint32_t ZEXPORT crc32_combine64(uint32_t, uint32_t, z_off64_t); - ZEXTERN void ZEXPORT crc32_combine_gen64(uint32_t *op, z_off64_t); -#endif - -#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) # define adler32_combine adler32_combine64 # define crc32_combine crc32_combine64 # define crc32_combine_gen crc32_combine_gen64 # ifndef Z_LARGE64 - ZEXTERN uint32_t ZEXPORT adler32_combine64(uint32_t, uint32_t, z_off_t); - ZEXTERN uint32_t ZEXPORT crc32_combine64(uint32_t, uint32_t, z_off_t); - ZEXTERN void ZEXPORT crc32_combine_gen64(uint32_t *op, z_off64_t); + Z_EXTERN gzFile Z_EXPORT gzopen64(const char *, const char *); + Z_EXTERN z_off_t Z_EXPORT gzseek64(gzFile, z_off_t, int); + Z_EXTERN z_off_t Z_EXPORT gztell64(gzFile); + Z_EXTERN z_off_t Z_EXPORT gzoffset64(gzFile); + Z_EXTERN unsigned long Z_EXPORT adler32_combine64(unsigned long, unsigned long, z_off_t); + Z_EXTERN unsigned long Z_EXPORT crc32_combine64(unsigned long, unsigned long, z_off_t); + Z_EXTERN void Z_EXPORT crc32_combine_gen64(uint32_t *op, z_off64_t); # endif #else - ZEXTERN uint32_t ZEXPORT adler32_combine(uint32_t, uint32_t, z_off_t); - ZEXTERN uint32_t ZEXPORT crc32_combine(uint32_t, uint32_t, z_off_t); - ZEXTERN void ZEXPORT crc32_combine_gen(uint32_t *op, z_off_t); + Z_EXTERN gzFile Z_EXPORT gzopen(const char *, const char *); + Z_EXTERN z_off_t Z_EXPORT gzseek(gzFile, z_off_t, int); + Z_EXTERN z_off_t Z_EXPORT gztell(gzFile); + Z_EXTERN z_off_t Z_EXPORT gzoffset(gzFile); + Z_EXTERN unsigned long Z_EXPORT adler32_combine(unsigned long, unsigned long, z_off_t); + Z_EXTERN unsigned long Z_EXPORT crc32_combine(unsigned long, unsigned long, z_off_t); + Z_EXTERN void Z_EXPORT crc32_combine_gen(uint32_t *op, z_off_t); #endif - /* undocumented functions */ -ZEXTERN const char * ZEXPORT zError (int); -ZEXTERN int ZEXPORT inflateSyncPoint (z_stream *); -ZEXTERN const uint32_t * ZEXPORT get_crc_table (void); -ZEXTERN int ZEXPORT inflateUndermine (z_stream *, int); -ZEXTERN int ZEXPORT inflateValidate (z_stream *, int); -ZEXTERN unsigned long ZEXPORT inflateCodesUsed (z_stream *); -ZEXTERN int ZEXPORT inflateResetKeep (z_stream *); -ZEXTERN int ZEXPORT deflateResetKeep (z_stream *); +Z_EXTERN const char * Z_EXPORT zError (int); +Z_EXTERN int Z_EXPORT inflateSyncPoint (z_stream *); +Z_EXTERN const uint32_t * Z_EXPORT get_crc_table (void); +Z_EXTERN int Z_EXPORT inflateUndermine (z_stream *, int); +Z_EXTERN int Z_EXPORT inflateValidate (z_stream *, int); +Z_EXTERN unsigned long Z_EXPORT inflateCodesUsed (z_stream *); +Z_EXTERN int Z_EXPORT inflateResetKeep (z_stream *); +Z_EXTERN int Z_EXPORT deflateResetKeep (z_stream *); -#if (defined(WIN32) || defined(__MINGW__)) - ZEXTERN gzFile ZEXPORT gzopen_w(const wchar_t *path, const char *mode); +#if defined(_WIN32) + Z_EXTERN gzFile Z_EXPORT gzopen_w(const wchar_t *path, const char *mode); #endif -ZEXTERN int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va); +Z_EXTERN int Z_EXPORTVA gzvprintf(gzFile file, const char *format, va_list va); #ifdef __cplusplus } diff --git a/libs/zlibng/zlib.map b/libs/zlibng/zlib.map index 28436d47e..f608f2bd5 100644 --- a/libs/zlibng/zlib.map +++ b/libs/zlibng/zlib.map @@ -91,6 +91,10 @@ ZLIB_1.2.9 { deflateGetDictionary; adler32_z; crc32_z; - crc32_combine_gen; - crc32_combine_op; } ZLIB_1.2.7.1; + +ZLIB_1.2.12 { + crc32_combine_gen; + crc32_combine_gen64; + crc32_combine_op; +} ZLIB_1.2.9; diff --git a/libs/zlibng/zlib.pc.cmakein b/libs/zlibng/zlib.pc.cmakein index 0635b6e35..9b64252dc 100644 --- a/libs/zlibng/zlib.pc.cmakein +++ b/libs/zlibng/zlib.pc.cmakein @@ -1,12 +1,12 @@ prefix=@CMAKE_INSTALL_PREFIX@ -exec_prefix=@CMAKE_INSTALL_PREFIX@ -libdir=@INSTALL_LIB_DIR@ -sharedlibdir=@INSTALL_LIB_DIR@ -includedir=@INSTALL_INC_DIR@ +exec_prefix=${prefix} +libdir=@PC_LIB_INSTALL_DIR@ +sharedlibdir=${libdir} +includedir=@PC_INC_INSTALL_DIR@ Name: zlib@SUFFIX@ Description: zlib-ng compression library -Version: @zlib_VERSION@ +Version: @ZLIB_FULL_VERSION@ Requires: Libs: -L${libdir} -L${sharedlibdir} -lz@SUFFIX@ diff --git a/libs/zlibng/zutil.c b/libs/zlibng/zutil.c index 4373586bd..ba36e93f9 100644 --- a/libs/zlibng/zutil.c +++ b/libs/zlibng/zutil.c @@ -3,47 +3,37 @@ * For conditions of distribution and use, see copyright notice in zlib.h */ -/* @(#) $Id$ */ - #include "zbuild.h" #include "zutil.h" -#ifdef WITH_GZFILEOP -# include "gzguts.h" -#endif -#ifndef UNALIGNED_OK -# include "malloc.h" -#endif +#include "zutil_p.h" -const char * const z_errmsg[10] = { - (const char *)"need dictionary", /* Z_NEED_DICT 2 */ - (const char *)"stream end", /* Z_STREAM_END 1 */ - (const char *)"", /* Z_OK 0 */ - (const char *)"file error", /* Z_ERRNO (-1) */ - (const char *)"stream error", /* Z_STREAM_ERROR (-2) */ - (const char *)"data error", /* Z_DATA_ERROR (-3) */ - (const char *)"insufficient memory", /* Z_MEM_ERROR (-4) */ - (const char *)"buffer error", /* Z_BUF_ERROR (-5) */ - (const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */ - (const char *)"" +z_const char * const PREFIX(z_errmsg)[10] = { + (z_const char *)"need dictionary", /* Z_NEED_DICT 2 */ + (z_const char *)"stream end", /* Z_STREAM_END 1 */ + (z_const char *)"", /* Z_OK 0 */ + (z_const char *)"file error", /* Z_ERRNO (-1) */ + (z_const char *)"stream error", /* Z_STREAM_ERROR (-2) */ + (z_const char *)"data error", /* Z_DATA_ERROR (-3) */ + (z_const char *)"insufficient memory", /* Z_MEM_ERROR (-4) */ + (z_const char *)"buffer error", /* Z_BUF_ERROR (-5) */ + (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */ + (z_const char *)"" }; const char zlibng_string[] = - " zlib-ng 1.9.9 forked from zlib 1.2.11 "; + " zlib-ng 2.0.0-RC2 forked from zlib"; #ifdef ZLIB_COMPAT -const char * ZEXPORT zlibVersion(void) -{ +const char * Z_EXPORT zlibVersion(void) { return ZLIB_VERSION; } #endif -const char * ZEXPORT zlibng_version(void) -{ +const char * Z_EXPORT zlibng_version(void) { return ZLIBNG_VERSION; } -unsigned long ZEXPORT PREFIX(zlibCompileFlags)(void) -{ +unsigned long Z_EXPORT PREFIX(zlibCompileFlags)(void) { unsigned long flags; flags = 0; @@ -77,12 +67,7 @@ unsigned long ZEXPORT PREFIX(zlibCompileFlags)(void) #ifdef ZLIB_WINAPI flags += 1 << 10; #endif -#ifdef BUILDFIXED - flags += 1 << 12; -#endif -#ifdef DYNAMIC_CRC_TABLE - flags += 1 << 13; -#endif + /* Bit 13 reserved for DYNAMIC_CRC_TABLE */ #ifdef NO_GZCOMPRESS flags += 1L << 16; #endif @@ -96,15 +81,13 @@ unsigned long ZEXPORT PREFIX(zlibCompileFlags)(void) } #ifdef ZLIB_DEBUG -#include +# include # ifndef verbose # define verbose 0 # endif -int ZLIB_INTERNAL z_verbose = verbose; +int Z_INTERNAL z_verbose = verbose; -void ZLIB_INTERNAL z_error (m) - char *m; -{ +void Z_INTERNAL z_error(char *m) { fprintf(stderr, "%s\n", m); exit(1); } @@ -113,28 +96,16 @@ void ZLIB_INTERNAL z_error (m) /* exported to allow conversion of error code to string for compress() and * uncompress() */ -const char * ZEXPORT PREFIX(zError)(int err) -{ +const char * Z_EXPORT PREFIX(zError)(int err) { return ERR_MSG(err); } -#ifndef MY_ZCALLOC /* Any system without a special alloc function */ - -void ZLIB_INTERNAL *zcalloc (void *opaque, unsigned items, unsigned size) -{ +void Z_INTERNAL *zng_calloc(void *opaque, unsigned items, unsigned size) { (void)opaque; -#ifndef UNALIGNED_OK - return memalign(16, items * size); -#else - return sizeof(unsigned int) > 2 ? (void *)malloc(items * size) : - (void *)calloc(items, size); -#endif + return zng_alloc((size_t)items * (size_t)size); } -void ZLIB_INTERNAL zcfree (void *opaque, void *ptr) -{ +void Z_INTERNAL zng_cfree(void *opaque, void *ptr) { (void)opaque; - free(ptr); + zng_free(ptr); } - -#endif /* MY_ZCALLOC */ diff --git a/libs/zlibng/zutil.h b/libs/zlibng/zutil.h index 8d8ae92ee..497cb22b4 100644 --- a/libs/zlibng/zutil.h +++ b/libs/zlibng/zutil.h @@ -10,14 +10,22 @@ subject to change. Applications should only use zlib.h. */ -/* @(#) $Id$ */ - -#if defined(HAVE_INTERNAL) -# define ZLIB_INTERNAL __attribute__((visibility ("internal"))) -#elif defined(HAVE_HIDDEN) -# define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) +#if defined(HAVE_VISIBILITY_INTERNAL) +# define Z_INTERNAL __attribute__((visibility ("internal"))) +#elif defined(HAVE_VISIBILITY_HIDDEN) +# define Z_INTERNAL __attribute__((visibility ("hidden"))) #else -# define ZLIB_INTERNAL +# define Z_INTERNAL +#endif + +#ifndef __cplusplus +# define Z_REGISTER register +#else +# define Z_REGISTER +#endif + +#ifndef Z_TLS +# define Z_TLS #endif #include @@ -25,19 +33,20 @@ #include #include #ifdef ZLIB_COMPAT -# include "zlib.h" +# include "zlib.h" #else -# include "zlib-ng.h" +# include "zlib-ng.h" #endif +#include "zbuild.h" typedef unsigned char uch; /* Included for compatibility with external code only */ typedef uint16_t ush; /* Included for compatibility with external code only */ -typedef unsigned long ulg; +typedef unsigned long ulg; -extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ +extern z_const char * const PREFIX(z_errmsg)[10]; /* indexed by 2-zlib_error */ /* (size given to avoid silly warnings with Visual C++) */ -#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)] +#define ERR_MSG(err) PREFIX(z_errmsg)[Z_NEED_DICT-(err)] #define ERR_RETURN(strm, err) return (strm->msg = ERR_MSG(err), (err)) /* To be used only when the state is known to be valid */ @@ -67,6 +76,8 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ #define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */ +#define ADLER32_INITIAL_VALUE 1 /* initial adler-32 hash value */ + /* target dependencies */ #ifdef AMIGA @@ -89,9 +100,6 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ #ifdef OS2 # define OS_CODE 6 -# if defined(M_I86) && !defined(Z_SOLO) -# include -# endif #endif #if defined(MACOS) || defined(TARGET_OS_MAC) @@ -102,7 +110,7 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ # define OS_CODE 13 #endif -#if defined(WIN32) && !defined(__CYGWIN__) +#if defined(_WIN32) && !defined(__CYGWIN__) # define OS_CODE 10 #endif @@ -114,16 +122,9 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ # define fdopen(fd, type) _fdopen(fd, type) #endif -/* provide prototypes for these when building zlib without LFS */ -#if !defined(WIN32) && !defined(__MSYS__) && (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0) -# include "zbuild.h" /* For PREFIX() */ - ZEXTERN uint32_t ZEXPORT PREFIX(adler32_combine64)(uint32_t, uint32_t, z_off_t); - ZEXTERN uint32_t ZEXPORT PREFIX(crc32_combine64)(uint32_t, uint32_t, z_off_t); -#endif - /* MS Visual Studio does not allow inline in C, only C++. But it provides __inline instead, so use that. */ -#if defined(_MSC_VER) && !defined(inline) +#if defined(_MSC_VER) && !defined(inline) && !defined(__cplusplus) # define inline __inline #endif @@ -131,51 +132,47 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ #ifndef OS_CODE # define OS_CODE 3 /* assume Unix */ -#endif - -#ifndef F_OPEN -# define F_OPEN(name, mode) fopen((name), (mode)) #endif /* functions */ /* Diagnostic functions */ #ifdef ZLIB_DEBUG -# include - extern int ZLIB_INTERNAL z_verbose; - extern void ZLIB_INTERNAL z_error(char *m); -# define Assert(cond, msg) {if(!(cond)) z_error(msg);} -# define Trace(x) {if (z_verbose >= 0) fprintf x;} -# define Tracev(x) {if (z_verbose > 0) fprintf x;} -# define Tracevv(x) {if (z_verbose > 1) fprintf x;} -# define Tracec(c, x) {if (z_verbose > 0 && (c)) fprintf x;} -# define Tracecv(c, x) {if (z_verbose > 1 && (c)) fprintf x;} +# include + extern int Z_INTERNAL z_verbose; + extern void Z_INTERNAL z_error(char *m); +# define Assert(cond, msg) {if (!(cond)) z_error(msg);} +# define Trace(x) {if (z_verbose >= 0) fprintf x;} +# define Tracev(x) {if (z_verbose > 0) fprintf x;} +# define Tracevv(x) {if (z_verbose > 1) fprintf x;} +# define Tracec(c, x) {if (z_verbose > 0 && (c)) fprintf x;} +# define Tracecv(c, x) {if (z_verbose > 1 && (c)) fprintf x;} #else -# define Assert(cond, msg) -# define Trace(x) -# define Tracev(x) -# define Tracevv(x) -# define Tracec(c, x) -# define Tracecv(c, x) +# define Assert(cond, msg) +# define Trace(x) +# define Tracev(x) +# define Tracevv(x) +# define Tracec(c, x) +# define Tracecv(c, x) #endif -void ZLIB_INTERNAL *zcalloc(void *opaque, unsigned items, unsigned size); -void ZLIB_INTERNAL zcfree(void *opaque, void *ptr); +void Z_INTERNAL *zng_calloc(void *opaque, unsigned items, unsigned size); +void Z_INTERNAL zng_cfree(void *opaque, void *ptr); #define ZALLOC(strm, items, size) (*((strm)->zalloc))((strm)->opaque, (items), (size)) #define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (void *)(addr)) -#define TRY_FREE(s, p) {if (p) ZFREE(s, p);} +#define TRY_FREE(s, p) {if (p) ZFREE(s, p);} /* Reverse the bytes in a value. Use compiler intrinsics when possible to take advantage of hardware implementations. */ -#if defined(WIN32) && (_MSC_VER >= 1300) +#if defined(_MSC_VER) && (_MSC_VER >= 1300) # pragma intrinsic(_byteswap_ulong) # define ZSWAP16(q) _byteswap_ushort(q) # define ZSWAP32(q) _byteswap_ulong(q) # define ZSWAP64(q) _byteswap_uint64(q) #elif defined(__Clang__) || (defined(__GNUC__) && \ - (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))) + (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))) # define ZSWAP16(q) __builtin_bswap16(q) # define ZSWAP32(q) __builtin_bswap32(q) # define ZSWAP64(q) __builtin_bswap64(q) @@ -201,7 +198,7 @@ void ZLIB_INTERNAL zcfree(void *opaque, void *ptr); #else # define ZSWAP16(q) ((((q) & 0xff) << 8) | (((q) & 0xff00) >> 8)) # define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \ - (((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) + (((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) # define ZSWAP64(q) \ ((q & 0xFF00000000000000u) >> 56u) | \ ((q & 0x00FF000000000000u) >> 40u) | \ @@ -215,33 +212,43 @@ void ZLIB_INTERNAL zcfree(void *opaque, void *ptr); /* Only enable likely/unlikely if the compiler is known to support it */ #if (defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__INTEL_COMPILER) || defined(__Clang__) -# ifndef likely -# define likely(x) __builtin_expect(!!(x), 1) -# endif -# ifndef unlikely -# define unlikely(x) __builtin_expect(!!(x), 0) -# endif +# define LIKELY_NULL(x) __builtin_expect((x) != 0, 0) +# define LIKELY(x) __builtin_expect(!!(x), 1) +# define UNLIKELY(x) __builtin_expect(!!(x), 0) +# define PREFETCH_L1(addr) __builtin_prefetch(addr, 0, 3) +# define PREFETCH_L2(addr) __builtin_prefetch(addr, 0, 2) +# define PREFETCH_RW(addr) __builtin_prefetch(addr, 1, 2) +#elif defined(__WIN__) +# include +# define LIKELY_NULL(x) x +# define LIKELY(x) x +# define UNLIKELY(x) x +# define PREFETCH_L1(addr) _mm_prefetch((char *) addr, _MM_HINT_T0) +# define PREFETCH_L2(addr) _mm_prefetch((char *) addr, _MM_HINT_T1) +# define PREFETCH_RW(addr) _mm_prefetch((char *) addr, _MM_HINT_T1) #else -# ifndef likely -# define likely(x) x -# endif -# ifndef unlikely -# define unlikely(x) x -# endif +# define LIKELY_NULL(x) x +# define LIKELY(x) x +# define UNLIKELY(x) x +# define PREFETCH_L1(addr) addr +# define PREFETCH_L2(addr) addr +# define PREFETCH_RW(addr) addr #endif /* (un)likely */ #if defined(_MSC_VER) -#define ALIGNED_(x) __declspec(align(x)) +# define ALIGNED_(x) __declspec(align(x)) #else -#if defined(__GNUC__) -#define ALIGNED_(x) __attribute__ ((aligned(x))) -#endif +# if defined(__GNUC__) +# define ALIGNED_(x) __attribute__ ((aligned(x))) +# endif #endif -#if defined(X86_CPUID) -# include "arch/x86/x86.h" -#elif defined(__aarch64__) || defined(__arm__) || defined(_M_ARM) -# include "arch/arm/arm.h" +#if defined(X86_FEATURES) +# include "arch/x86/x86.h" +#elif defined(ARM_FEATURES) +# include "arch/arm/arm.h" +#elif defined(POWER_FEATURES) +# include "arch/power/power.h" #endif #endif /* ZUTIL_H_ */ diff --git a/libs/zlibng/zutil_p.h b/libs/zlibng/zutil_p.h new file mode 100644 index 000000000..a5f2e525d --- /dev/null +++ b/libs/zlibng/zutil_p.h @@ -0,0 +1,34 @@ +/* zutil_p.h -- Private inline functions used internally in zlib-ng + * + */ + +#ifndef ZUTIL_P_H +#define ZUTIL_P_H + +#ifdef __APPLE__ +# include +#else +# include +#endif + +/* Function to allocate 16 or 64-byte aligned memory */ +static inline void *zng_alloc(size_t size) { +#if defined(_WIN32) + return (void *)_aligned_malloc(size, 64); +#elif defined(__APPLE__) + return (void *)malloc(size); /* MacOS always aligns to 16 bytes */ +#else + return (void *)memalign(64, size); +#endif +} + +/* Function that can free aligned memory */ +static inline void zng_free(void *ptr) { +#if defined(_WIN32) + _aligned_free(ptr); +#else + free(ptr); +#endif +} + +#endif