89 files changed, 7837 insertions(+), 0 deletions(-)

A .gitignore
A LICENSE.txt
A README.md
A common/Cargo.lock
A common/Cargo.toml
A common/src/lib.rs
A plot.py
A plots/c-dc-canterbury large.png
A plots/c-dc-canterbury.png
A plots/c-dc-silesia.png
A plots/compression-canterbury large.png
A plots/compression-canterbury.png
A plots/compression-silesia.png
A plots/cs-ds-canterbury large.png
A plots/cs-ds-canterbury.png
A plots/cs-ds-silesia.png
A plots/d-dc-canterbury large.png
A plots/d-dc-canterbury.png
A plots/d-dc-silesia.png
A plots/throughput-canterbury large.png
A plots/throughput-canterbury.png
A plots/throughput-silesia.png
A results.csv
A schemes/brotli/Cargo.lock
A schemes/brotli/Cargo.toml
A schemes/brotli/src/main.rs
A schemes/brotlic/Cargo.lock
A schemes/brotlic/Cargo.toml
A schemes/brotlic/src/main.rs
A schemes/bzip2/Cargo.lock
A schemes/bzip2/Cargo.toml
A schemes/bzip2/src/main.rs
A schemes/clean.sh
A schemes/deflate/Cargo.lock
A schemes/deflate/Cargo.toml
A schemes/deflate/src/main.rs
A schemes/flate2-rust/Cargo.lock
A schemes/flate2-rust/Cargo.toml
A schemes/flate2-rust/src/main.rs
A schemes/flate2-zlib-ng/Cargo.lock
A schemes/flate2-zlib-ng/Cargo.toml
A schemes/flate2-zlib-ng/src/main.rs
A schemes/lz4_flex/Cargo.lock
A schemes/lz4_flex/Cargo.toml
A schemes/lz4_flex/src/main.rs
A schemes/lz4_flex_unsafe/Cargo.lock
A schemes/lz4_flex_unsafe/Cargo.toml
A schemes/lz4_flex_unsafe/src/main.rs
A schemes/lzma-rs/Cargo.lock
A schemes/lzma-rs/Cargo.toml
A schemes/lzma-rs/src/main.rs
A schemes/lzo1x/Cargo.lock
A schemes/lzo1x/Cargo.toml
A schemes/lzo1x/src/main.rs
A schemes/lzss/Cargo.lock
A schemes/lzss/Cargo.toml
A schemes/lzss/src/main.rs
A schemes/lzzzz/Cargo.lock
A schemes/lzzzz/Cargo.toml
A schemes/lzzzz/src/main.rs
A schemes/run.sh
A schemes/rust-lzma/Cargo.lock
A schemes/rust-lzma/Cargo.toml
A schemes/rust-lzma/src/main.rs
A schemes/snap/Cargo.lock
A schemes/snap/Cargo.toml
A schemes/snap/src/main.rs
A schemes/tetsy-snappy/Cargo.lock
A schemes/tetsy-snappy/Cargo.toml
A schemes/tetsy-snappy/src/main.rs
A schemes/uncompressed/Cargo.lock
A schemes/uncompressed/Cargo.toml
A schemes/uncompressed/src/main.rs
A schemes/xsnappy/Cargo.lock
A schemes/xsnappy/Cargo.toml
A schemes/xsnappy/src/main.rs
A schemes/yazi/Cargo.lock
A schemes/yazi/Cargo.toml
A schemes/yazi/src/main.rs
A schemes/zopfli-rs/Cargo.lock
A schemes/zopfli-rs/Cargo.toml
A schemes/zopfli-rs/src/main.rs
A schemes/zopfli/Cargo.lock
A schemes/zopfli/Cargo.toml
A schemes/zopfli/src/main.rs
A schemes/zstd/Cargo.lock
A schemes/zstd/Cargo.toml
A schemes/zstd/src/main.rs
A setup-corpora.sh

@@ 1,5 @@
+common/target
+schemes/*/target
+corpora
+*.tar.gz
+*.zip

@@ 1,1 @@
+¯\_(ツ)_/¯<
\ No newline at end of file

@@ 1,293 @@
+Comparison of compression crates available for Rust
+===================================================
+
+Procedure
+---------
+
+I compress three different corpora using various compression methods available as Rust crates.
+Only lossless general-purpose compression algorithms are considered.
+Where available, bulk compression/decompression APIs are used rather than streaming APIs.
+Executable code size and use of main memory (internal buffers etc.) is not considered.
+Details on the corpora and the choice of compression schemes can be found below.
+
+The test was automated (except for the figures), the source code can be found in this repository.
+A rough overview of the test procedure follows.
+
+- For each compression algorithm:
+  - For each corpus:
+    - Load all files from the file system
+    - Concatenate the files into a single array
+      - For each compression setting:
+        - Repeat 10 times:
+          - compress the array (allocating a new vector) and record the time required
+          - record the size of the decompressed data
+          - preallocate a buffer for the decompressed data
+          - decompress the data to this buffer and record the time required
+          - verify that the roundtripped data equals the original data
+        - Combine the results and record average and empirical standard deviation
+
+The source code is laid out as follows.
+The directory `common` contains a library crate with common functionality: Reading the corpora, `Compress` and `Decompress` traits as a common abstraction for all schemes, recording runtime, and statistical summary of the results.
+The directory `schemes` contains a binary crate for each of the compression schemes.
+Each of those crates can be run with `cargo run --release` to perform the test for that scheme.
+The output is a headerless csv with the following columns in order: scheme name, compression settings, corpus, average compression speed (MB/s), empirical standard deviation of compression speed (MB/s), average decompression speed (MB/s), empirical standard deviation of decompression speed (MB/s), compression ratio.
+The folder `schemes` also contains a simple shell script that runs each benchmark.
+
+
+Summary of results
+------------------
+
+For raw data, see [`results.csv`](./results.csv) (this CSV includes a header line).
+Note: speed of compression and decompression is always measured by the throughput of _uncompressed_ data.
+For additional plots not shown here, see the [plots](./plots) directory.
+
+Generally, all schemes compress the canterbury corpus (2.8 MB) best in terms of both size and throughput (i.e. compression & decompression speed), followed by the "large" canterbury corpus (11 MB), followed by the Silesia corpus (212 MB).
+
+![Size reduction of the Canterbury corpus by compression scheme](plots/compression-canterbury.png)
+![Size reduction of the Silesia corpus by compression scheme](plots/compression-canterbury.png)
+
+![Compression and decompression speed for the Canterbury corpus by compression scheme](plots/throughput-canterbury.png)
+![Compression and decompression speed for the Silesia corpus by compression scheme](plots/throughput-canterbury.png)
+
+Note that compression and decompression speed are depicted with error bars (depicting the square root of the sample variance) but they are almost always smaller than the markers.
+
+The smallest compressed sizes (of the Silesia corpus) are achieved, by:
+
+- the lzma group
+- the brotli group
+- zstd
+- bzip2
+- zopfli
+- Other DEFLATE encoders
+- LZ4 (C bindings)
+- LZSS
+- LZ4 (Rust)
+- lzox1-1
+- snappy implementations
+
+(Order is from best to worst.)
+
+The following graphics depict the throughput (compression and decompression speed) of each scheme and all tested settings against the achieved size reduction (i.e. quality of the compression) for the Silesia corpus.
+For the smaller corpora, the shape is roughly the same when accounting for the previously stated fact that they are generally compressed better in all metrics.
+
+![Compression speed by size reduction for the Silesia corpus](plots/c-dc-silesia.png)
+![Compression speed by size reduction for the Silesia corpus](plots/c-dc-silesia.png)
+
+At the highest range of compression (smallest compressed sizes, >70% size reduction), there are four contenders: rust-lzma, brotli/brotlic (which have similar overall performance), bzip2, and zstd.
+rust-lzma achieves the best compression and, at a given speed, generally compresses faster than zstd and brotli.
+brotli decompresses faster than rust-lzma and zstd decompresses faster than brotli.
+zstd compresses about as fast or faster than brotli but doesn't quite reach the same top size reduction.
+bzip2 compresses faster than rust-lzma but has the slowest decompression speed.
+
+In the upper middle range (50% to 70% size reduction), zstd compresses faster than anything else.
+It also decompresses faster than most other algorithms except lzzzz, which has the fastest decompression speed in its entire range of supported compression qualities.
+In this range, brotlic performs similarly to most DEFLATE implementations, but brotli can also achieve smaller file sizes (at reduced throughput).
+brotli (the Rust implementation) has slower decompression speed than the DEFLATE decoders.
+zopfli and zopfli-rs achieve marginally better compression than the other DEFLATE encoders but have absolutely terrible compression throughput.
+lzss has very low compression speed and can't achieve very high size reduction, but it decompresses at a similar rate as the DEFLATE decoders.
+The variants with compile-time parameters are only faster than the one with run-time parameters when decompressing, not when compressing.
+
+In the mid-range (~50% size reduction), the snappy implementations, lz4\_flex, and lzo1x-1 have similar compressed sizes and compression speed.
+lz4\_flex has a much higher decompression speed.
+
+For worse compression quality (bigger compressed sizes), lzzzz achieves the fastest compression and decompression speed.
+zstd has similar compression speed, but decompression is slower by a varying factor of up to ~2.
+
+
+Recommendations
+---------------
+
+Use zstd.
+At compression level 5 zstd compresses at ~100 MB/s and decompresses at ~1 GB/s while reducing file size by 70-75%.
+It doesn't achieve the best size reduction or the fastest throughput overall, but it's competitive for a wide range of speed/size tradeoffs.
+It also supports pre-training dictionaries to achieve better compression and throughput for many instances of small similar data (though this is not tested here).
+
+If you need the smallest compressed size with no regard for speed, use rust-lzma at the highest compression settings.
+Be aware however that the file size reduction is only a little better than zstd while decompression takes an order of magnitude longer.
+
+If you need something in pure Rust with no FFI, use either lz4\_flex or yazi.
+lz4\_flex decompresses extremely fast (2+ GB/s), compresses only slightly slower (350 MB/s) than the fastest Rust compressor overall and achieves a middling size reduction (50-55% depending on corpus).
+yazi achieves significantly better compression (70-75%) at the cost of disproportionately lower throughput.
+
+If you have requirements which haven't been considered here or a particular kind of data, do your own research. 🙂
+
+
+Compression schemes
+-------------------
+
+Unless noted otherwise, all compression schemes are used with default features.
+Settings are mostly combinations of parameters that get special mention in the documentation.
+For example, brotli allows setting a block buffer size, but doesn't make note of valid or suggested values, so I only used the setting `4096` (which appears in the documentation).
+As another example, flate2 documents that valid compression levels are 0-9 inclusive, and the entire range is tested.
+
+Note that some compression algorithms (e.g. zstd) have provisions for compressing many instances of small but similar data.
+These algorithms may (or may not) perform much better on the canterbury corpus and smaller data than it appears here.
+
+The automated benchmarks were compiled using stable Rust 1.69 (2023-04-20) in release mode (no custom settings).
+Compression and decompression were performed sequentially.
+Benchmarks were run sequentially.
+
+There are a few groups of compression schemes/crates:
+
+- uncompressed:
+  "compression" via `.to_vec()`, "decompression" via `.copy_from_slice()`.
+  Serves as a baseline comparison.
+- DEFLATE:
+  - [flate2](https://docs.rs/flate2/latest/flate2/):
+    Common API for various deflate/zlib/gzip encoders/decoders.
+    The [miniz\_oxide](https://docs.rs/miniz_oxide/latest/miniz_oxide/) (a pure Rust implementation) and `zlib-ng` backends are tested.
+    Does not support `no_std`, but `miniz_oxide` does.
+    Settings are: format (deflate/zlib/gzip) and compression level (0 to 10 inclusive, 0 being no compression, 10 being high/slow compression).
+  - [yazi](https://docs.rs/yazi/0.1.6/yazi/):
+    Rust implementation of DEFLATE.
+    Does not require heap allocation (but does require std).
+    Only raw format is tested (zlib is also supported).
+    Compression levels: none, best speed, default, best size, and specific levels (1 to 10 inclusive).
+    It also supports different compression strategies, but only the default is tested.
+- DEFLATE compressors (no decompression):
+  - [deflate](https://docs.rs/deflate/1.0.0/deflate/)
+    Safe Rust implementation of DEFLATE compression, optionally in zlib/gzip formats.
+    "In maintenance mode".
+    "fast", "high", and default compression options are tested, but there are more tunable parameters.
+  - [zopfli](https://docs.rs/zopfli/0.7.2/zopfli/):
+    Rust reimplementation of zopfli.
+    The settings recommended for big files is tested (iteration count = 5, maximum block splits = 15).
+  - [zopfli-rs](https://docs.rs/zopfli-rs/0.1.1/zopfli_rs/):
+    Rust bindings to zopfli.
+    A dependency contains code that will be rejected by a future version of Rust.
+    Tested with the same settings as the rust implementation.
+    I wouldn't include this but I make an exception because it's interesting to compare the performance between the C and Rust versions.
+- lz4:
+  - [lzzzz](https://docs.rs/lzzzz/1.0.4/lzzzz/):
+    Rust bindings to liblz4.
+    The block format is tested in normal and high compression mode at several acceleration factors ranging from 0 to 65535.
+    For the frame format, default, high, and max settings are tested.
+  - [lz4\_flex](https://docs.rs/lz4_flex/0.10.0/lz4_flex/):
+    Rust lz4 compression.
+    No tunable parameters.
+    Safe by default, unsafe optimizations available (block format only) - all combinations are tested.
+    Supports `no_std` (block format only).
+- lzma:
+  - [rust-lzma](https://docs.rs/rust-lzma/latest/lzma/):
+    Rust bindings to liblzma (implements XZ compression).
+    Compression levels 0 to 9 (inclusive) in a "normal" and an EXTREME variant are tested.
+  - [lzma-rs](https://docs.rs/lzma-rs/0.3.0/lzma_rs/):
+    Rust implementation of lzma/lzma2/xz formats.
+    Compression is implemented but only the lzma compresser actually attempts compression.
+    No tunable parameters.
+- snappy:
+  - [tetsy\_snappy](https://docs.rs/tetsy-snappy/0.1.0/tetsy_snappy/):
+    Rust bindings to the snappy compression library.
+    No tunable parameters.
+  - [snap](https://docs.rs/snap/1.1.0/snap/):
+    Rust implementation of snappy.
+    No tunable parameters.
+  - [xsnappy](https://docs.rs/xsnappy/0.1.0/xsnappy/):
+    Rust implementation of snappy.
+    No tunable parameters.
+- brotli:
+  - [brotlic](https://docs.rs/brotlic/0.8.1/brotlic/):
+    Rust bindings to the brotli library.
+    Has a billion tunable parameters.
+    I test quality levels 0 to 11 (inclusive), window sizes 20 to 22 (inclusive) and a buffer size of 4096.
+    All other parameters are defaults.
+  - [brotli](https://docs.rs/brotli/latest/brotli/):
+    Rust port of brotli.
+    Has `no_std` Support.
+    The documentation is bad, but I make an exception because it's popular.
+    Same settings as for the bindings.
+- [zstd](https://docs.rs/zstd/0.12.3+zstd.1.5.2/zstd/):
+  Rust bindings to `libzstd`.
+  The full range of positive quality levels from 0 to 22 (inclusive) are tested, as well as a few negative (fast) quality levels down to -50 are tested.
+- [lzo1x-1](https://docs.rs/lzo1x-1/0.1.0/lzo1x_1/):
+  Port of LZO1X-1 (a variant of LZO used in the Linux kernel) to safe Rust.
+  Seems to supports `no_std`?
+  No tunable parameters.
+- [lzss](https://docs.rs/lzss/latest/lzss/index.html):
+  Rust implementation of LZSS.
+  Supports `no_std`.
+  Intended for embedded systems, claims small code size and little RAM/CPU use.
+  Both dynamic (runtime parameters) and generic (compile-time parameters) are tested.
+  Parameters are the number of bits in the offset (range 10 to 13 inclusive is tested), the number of bits in the length (4 and 5 bits are tested), and the initial fill byte of the compression buffer (0x20).
+- [bzip2](https://docs.rs/bzip2/0.4.4/bzip2/):
+  Rust bindings to bzip2
+  Compression levels 1 to 10 (inclusive) are tested.
+
+Excluded schemes
+----------------
+
+The following compression schemes / crates are categorically excluded:
+
+- archive formats, e.g. zip, 7z
+- lossy schemes, e.g. bloom filters
+- schemes tailored to specific content types, e.g. PNG, FLAC
+- schemes based solely run-length encoding (since it's outperformed by anything else in the general case)
+- crates which have no/bad documentation
+- crates that appear to be written by like one person just for fun
+
+I have purposefully excluded the following schemes from consideration (again, in no particular order):
+
+- [rust\_lzo](https://docs.rs/rust-lzo/latest/rust_lzo/): LZO algorithm, automatically translated to Rust from C source
+- [lz4](https://docs.rs/lz4/1.24.0/lz4/): liblz4 binding less ergonomic than lzzzz.
+- [lz4\_compression](https://docs.rs/lz4-compression/0.7.0/lz4_compression/): lz4 in unsafe Rust. "Only [...] passively maintained" and not recommended over lz4_fear.
+- [lz4\_compress](https://docs.rs/lz4-compress/0.1.1/lz4_compress/): unmaintained and likely superseded by `lz4_compression`.
+- [lz-fear](https://docs.rs/lz-fear/0.1.1/lz_fear/): Safe Rust lz4 compression. Last update is 3 years old at time of writing. I couldn't figure out how to use this.
+- [banzai](https://docs.rs/banzai/0.3.1/banzai/): bzip2 encoder written in safe Rust. Alpha stage, no decoder.
+- [flate3](https://docs.rs/flate3/0.1.21/flate3/): I couldn't find a source repository.
+- [gzip](https://docs.rs/gzip/0.1.2/gzip/): I couldn't find a source repository.
+- [lzma](https://docs.rs/rust-lzma/latest/lzma://docs.rs/lzma/0.2.2/lzma/): Rust bindings to liblzma. Project may or may not be dead.
+- [snappy](https://docs.rs/snappy/0.4.0/snappy/): Bindings to the snappy library. Limited API.
+- [bzip2-rs](https://docs.rs/bzip2-rs/0.1.2/bzip2_rs/): Safe Rust bzip2 decompressor - no compressor available.
+- [redux](https://docs.rs/redux/0.2.0/redux/): Adaptive arithmetic compression in Rust - seems too low-level for general use.
+- [compress](https://docs.rs/compress/0.2.1/compress/): Decompression (not compression) for various algorithms in Rust. Proof of concept, not production-quality, no activity in 3 years.
+- [lzokay](https://docs.rs/lzokay/1.0.1/lzokay/): Rust bindings to lzokay which implements LZO. Has support for `no_std`. Build failed when I tried it.
+- [bzip3](https://docs.rs/bzip3/0.5.1/bzip3/): Rust bindings to bzip3. Requires nightly rust (try blocks)
+- [lzfse\_rust](https://docs.rs/lzfse_rust/0.2.0/lzfse_rust/): Rust LZFSE implementation. Appears to be made by one person for fun.
+
+There are many more crates which I don't note here, probably many more that I haven't noticed, and some of them may be good.
+
+Corpora
+-------
+
+- [Canterbury](https://corpus.canterbury.ac.nz/descriptions/) - total size 2.8 MB
+  - alice29.txt: 152 kB English text
+  - asyoulik.txt: 125 kB English text
+  - cp.html: 25 kB English HTML
+  - fields.c: 11 kB C source code
+  - grammar.lsp: 4 kB LISP source code
+  - kennedy.xls: 1.0 MB Excel spreadsheet
+  - lcet10.txt: 427 kB English text
+  - plrabn12.txt: 482 kB English text
+  - ptt5: 513 kB, I'll be honest I don't know what this is
+  - sum: 38 kB SPARC executable
+  - xargs.1: 4 kB English ROFF
+- [Canterbury large](https://corpus.canterbury.ac.nz/descriptions/) - total size 11 MB
+  - E.coli: 4.6 MB genome of E.coli
+  - bible.txt: 4.0 MB English text
+  - world192.txt: 2.5 MB English text
+- [Silesia](https://sun.aei.polsl.pl/~sdeor/index.php?page=silesia) - total size 212 MB
+  - dickens: 10 MB English text
+  - mozilla: 51 MB release tar (Mozilla project)
+  - mr: 10 MB image
+  - nci: 33 MB database of chemical structures
+  - ooffice: 6 MB windows dll
+  - osdb: 10 MB MySQL database
+  - reymont: 6 MB Polish PDF
+  - samba: 21 MB source code tar (Samba project)
+  - sao: 7 MB star catalog
+  - webster: 41 MB English dictionary
+  - xml: 5 MB tar of XML files
+  - x-ray: 8 MB image
+
+If you want to run the comparison yourself, you can download the corpora at the above URLs.
+To set up the file structure used by the test runner, place the archived corpora, `cantrbry.tar.gz`, `large.tar.gz`, and `silesia.zip` at the root of the project folder and run `setup-corpora.sh`.
+This should unpack the data to the `corpora` subdirectory.
+You can delete the archives afterwards.
+
+Test hardware
+-------------
+
+- PC workstation from 2018
+- CPU: AMD Ryzen 7 2700X
+- OS: Archlinux with standard kernel, up to date at time of testing (May 2023)
+- RAM: 2 times 8 GiB DDR4, 1467 MT/s

@@ 1,151 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "anyhow"
+version = "1.0.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c7d0618f0e0b7e8ff11427422b64564d5fb0be1940354bfe2e0529b18a9d9b8"
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "average"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843ec791d3f24503bbf72bbd5e49a3ab4dbb4bcd0a8ef6b0c908efa73caa27b1"
+dependencies = [
+ "easy-cast",
+ "float-ord",
+ "num-traits",
+]
+
+[[package]]
+name = "common"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "average",
+ "csv",
+ "serde",
+]
+
+[[package]]
+name = "csv"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b015497079b9a9d69c02ad25de6c0a6edef051ea6360a327d0bd05802ef64ad"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "easy-cast"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bd102ee8c418348759919b83b81cdbdc933ffe29740b903df448b4bafaa348e"
+
+[[package]]
+name = "float-ord"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ce81f49ae8a0482e4c55ea62ebbd7e5a686af544c00b9d090bba3ff9be97b3d"
+
+[[package]]
+name = "itoa"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "num-traits"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4ec6d5fe0b140acb27c9a0444118cf55bfbb4e0b259739429abb4521dd67c16"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f4f29d145265ec1c483c7c654450edde0bfe043d3938d6972630663356d9500"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
+
+[[package]]
+name = "serde"
+version = "1.0.163"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2113ab51b87a539ae008b5c6c02dc020ffa39afd2d83cffcb3f4eb2722cebec2"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.163"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c805777e3930c8883389c602315a24224bcc738b63905ef87cd1420353ea93e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6f671d4b5ffdb8eadec19c0ae67fe2639df8684bd7bc4b83d986b8db549cf01"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"

@@ 1,12 @@
+[package]
+name = "common"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1.0.71"
+average = { version = "0.13.1", default-features = false, features = ["std"] }
+csv = "1.2.1"
+serde = { version = "1.0.163", features = ["serde_derive"] }

@@ 1,305 @@
+use anyhow::Context as _;
+use average::Estimate as _;
+use std::borrow::BorrowMut as _;
+
+pub const SAMPLES: std::num::NonZeroU64 = match std::num::NonZeroU64::new(10) {
+    Some(v) => v,
+    None => [][0],
+}; // see https://stackoverflow.com/a/66838483 for the source of this monstrosity
+
+pub trait Compressor {
+    fn compress(&self, data: &[u8]) -> anyhow::Result<std::vec::Vec<u8>>;
+}
+
+pub trait Decompressor {
+    fn decompress_to(&self, src: &[u8], dst: &mut [u8]) -> anyhow::Result<()>;
+}
+
+pub trait DescribeScheme {
+    fn name(&self) -> String;
+    fn settings(&self) -> Option<String>;
+}
+
+pub struct Corpus {
+    pub name: &'static str,
+    pub data: std::vec::Vec<u8>,
+}
+
+pub fn read_corpus_data<P: AsRef<std::path::Path>, I: IntoIterator<Item = P>>(
+    base: P,
+    files: I,
+) -> anyhow::Result<std::vec::Vec<u8>> {
+    let mut result = vec![];
+    for filename in files {
+        let path = base.as_ref().join(filename);
+        let mut reader = std::fs::File::open(&path)
+            .with_context(|| format!("couldn't open file {}", path.display()))?;
+        std::io::copy(&mut reader, &mut result)
+            .with_context(|| format!("couldn't read from file {}", path.display()))?;
+    }
+    Ok(result)
+}
+
+pub fn read_corpora() -> anyhow::Result<std::vec::Vec<Corpus>> {
+    let base = "../../corpora/";
+    let canterbury = Corpus {
+        name: "canterbury",
+        data: read_corpus_data(
+            base,
+            [
+                "canterbury/alice29.txt",
+                "canterbury/asyoulik.txt",
+                "canterbury/cp.html",
+                "canterbury/fields.c",
+                "canterbury/grammar.lsp",
+                "canterbury/kennedy.xls",
+                "canterbury/lcet10.txt",
+                "canterbury/plrabn12.txt",
+                "canterbury/ptt5",
+                "canterbury/sum",
+                "canterbury/xargs.1",
+            ],
+        )
+        .context("couldn't read canterbury corpus")?,
+    };
+    anyhow::ensure!(
+        canterbury.data.len() == 2_810_784,
+        "canterbury corpus has unexpected size"
+    );
+
+    let canterbury_large = Corpus {
+        name: "canterbury large",
+        data: read_corpus_data(
+            base,
+            [
+                "canterbury-large/E.coli",
+                "canterbury-large/bible.txt",
+                "canterbury-large/world192.txt",
+            ],
+        )
+        .context("couldn't read canterbury large corpus")?,
+    };
+    anyhow::ensure!(
+        canterbury_large.data.len() == 11_159_482,
+        "canterbury large corpus has unexpected size"
+    );
+
+    let silesia = Corpus {
+        name: "silesia",
+        data: read_corpus_data(
+            base,
+            [
+                "silesia/dickens",
+                "silesia/mozilla",
+                "silesia/mr",
+                "silesia/nci",
+                "silesia/ooffice",
+                "silesia/osdb",
+                "silesia/reymont",
+                "silesia/samba",
+                "silesia/sao",
+                "silesia/webster",
+                "silesia/xml",
+                "silesia/x-ray",
+            ],
+        )
+        .context("couldn't read silesia corpus")?,
+    };
+    anyhow::ensure!(
+        silesia.data.len() == 211_938_580,
+        "silesia corpus has unexpected size"
+    );
+
+    Ok(vec![canterbury, canterbury_large, silesia])
+}
+
+#[derive(serde::Serialize)]
+pub struct Result {
+    pub scheme: String,
+    pub settings: Option<String>,
+    pub corpus: &'static str,
+    pub compression_speed: f64,
+    pub compression_speed_std: f64,
+    pub decompression_speed: Option<f64>,
+    pub decompression_speed_std: Option<f64>,
+    pub compression_ratio: f64,
+}
+
+pub fn print_result<W: std::io::Write, R: std::borrow::Borrow<Result>>(
+    f: &mut W,
+    result: R,
+) -> anyhow::Result<()> {
+    let mut writer = csv::WriterBuilder::new()
+        .quote_style(csv::QuoteStyle::Necessary)
+        .has_headers(false)
+        .from_writer(f.borrow_mut());
+    writer.serialize(result.borrow())?;
+    Ok(())
+}
+
+fn time<F, R>(f: F) -> anyhow::Result<(R, std::time::Duration)>
+where
+    F: FnOnce() -> anyhow::Result<R>,
+{
+    let time = std::time::Instant::now();
+    let result = f()?;
+    let duration = time.elapsed();
+    Ok((result, duration))
+}
+
+fn benchmark_scheme<C: Compressor + Decompressor + DescribeScheme + ?Sized>(
+    scheme: &C,
+    corpus: &Corpus,
+    samples: std::num::NonZeroU64,
+) -> anyhow::Result<Result> {
+    let mut compressed_size = None;
+    let corpus_size_mb: f64 = corpus.data.len() as f64 / 1_000_000.0f64;
+    let mut compression_speed_mbps = average::MeanWithError::new();
+    let mut decompression_speed_mbps = average::MeanWithError::new();
+    for _ in 0..samples.get() {
+        // compress
+        let (compressed, t) =
+            time(|| scheme.compress(&corpus.data)).context("couldn't time compression")?;
+        if let Some(size) = compressed_size {
+            anyhow::ensure!(
+                size == compressed.len(),
+                "compressed data size changed during runs"
+            );
+        } else {
+            compressed_size = Some(compressed.len());
+        }
+        compression_speed_mbps.add(corpus_size_mb / t.as_secs_f64());
+
+        // decompress
+        let mut decompressed = vec![0u8; corpus.data.len()];
+        let ((), t) = time(|| scheme.decompress_to(&compressed, &mut decompressed[..]))
+            .context("couldn't time decompression")?;
+        anyhow::ensure!(
+            decompressed == corpus.data,
+            "CRITICAL BUG: decompress(compress(x)) != x"
+        );
+        decompression_speed_mbps.add(corpus_size_mb / t.as_secs_f64());
+    }
+
+    let compressed_size = compressed_size.expect("must be set because sample size is nonzero");
+
+    Ok(Result {
+        scheme: scheme.name(),
+        settings: scheme.settings(),
+        corpus: corpus.name,
+        compression_speed: compression_speed_mbps.mean(),
+        compression_speed_std: compression_speed_mbps.sample_variance().sqrt(),
+        decompression_speed: Some(decompression_speed_mbps.mean()),
+        decompression_speed_std: Some(decompression_speed_mbps.sample_variance().sqrt()),
+        compression_ratio: (corpus.data.len() as f64) / (compressed_size as f64),
+    })
+}
+
+pub fn benchmark<
+    W: std::io::Write,
+    F: std::borrow::BorrowMut<W>,
+    C: Compressor + Decompressor + DescribeScheme + ?Sized,
+    S: std::borrow::Borrow<C>,
+    I: IntoIterator<Item = S>,
+>(
+    mut f: F,
+    schemes: I,
+) -> anyhow::Result<()> {
+    let corpora = read_corpora().context("couldn't read corpora")?;
+    for scheme in schemes {
+        for corpus in corpora.iter() {
+            let result =
+                benchmark_scheme(scheme.borrow(), &corpus, SAMPLES).with_context(|| {
+                    if let Some(settings) = scheme.borrow().settings() {
+                        format!(
+                            "benchmark failed for scheme {} (settings '{}') with corpus {}",
+                            scheme.borrow().name(),
+                            settings,
+                            corpus.name
+                        )
+                    } else {
+                        format!(
+                            "benchmark failed for scheme {} with corpus {}",
+                            scheme.borrow().name(),
+                            corpus.name
+                        )
+                    }
+                })?;
+            print_result(f.borrow_mut(), result).context("couldn't print result to stdout")?;
+        }
+    }
+    Ok(())
+}
+
+fn benchmark_compression_scheme<C: Compressor + DescribeScheme>(
+    scheme: &C,
+    corpus: &Corpus,
+    samples: std::num::NonZeroU64,
+) -> anyhow::Result<Result> {
+    let mut compressed_size = None;
+    let corpus_size_mb: f64 = corpus.data.len() as f64 / 1_000_000.0f64;
+    let mut compression_speed_mbps = average::MeanWithError::new();
+    for _ in 0..samples.get() {
+        // compress
+        let (compressed, t) =
+            time(|| scheme.compress(&corpus.data)).context("couldn't time compression")?;
+        if let Some(size) = compressed_size {
+            anyhow::ensure!(
+                size == compressed.len(),
+                "compressed data size changed during runs"
+            );
+        } else {
+            compressed_size = Some(compressed.len());
+        }
+        compression_speed_mbps.add(corpus_size_mb / t.as_secs_f64());
+    }
+
+    let compressed_size = compressed_size.expect("must be set because sample size is nonzero");
+
+    Ok(Result {
+        scheme: scheme.name(),
+        settings: scheme.settings(),
+        corpus: corpus.name,
+        compression_speed: compression_speed_mbps.mean(),
+        compression_speed_std: compression_speed_mbps.sample_variance().sqrt(),
+        decompression_speed: None,
+        decompression_speed_std: None,
+        compression_ratio: (corpus.data.len() as f64) / (compressed_size as f64),
+    })
+}
+
+pub fn benchmark_compression_only<
+    W: std::io::Write,
+    F: std::borrow::BorrowMut<W>,
+    C: Compressor + DescribeScheme,
+    S: std::borrow::Borrow<C>,
+    I: IntoIterator<Item = S>,
+>(
+    mut f: F,
+    schemes: I,
+) -> anyhow::Result<()> {
+    let corpora = read_corpora().context("couldn't read corpora")?;
+    for scheme in schemes {
+        for corpus in corpora.iter() {
+            let result = benchmark_compression_scheme(scheme.borrow(), &corpus, SAMPLES)
+                .with_context(|| {
+                    if let Some(settings) = scheme.borrow().settings() {
+                        format!(
+                            "benchmark failed for scheme {} (settings '{}') with corpus {}",
+                            scheme.borrow().name(),
+                            settings,
+                            corpus.name
+                        )
+                    } else {
+                        format!(
+                            "benchmark failed for scheme {} with corpus {}",
+                            scheme.borrow().name(),
+                            corpus.name
+                        )
+                    }
+                })?;
+            print_result(f.borrow_mut(), result).context("couldn't print result to stdout")?;
+        }
+    }
+    Ok(())
+}

@@ 1,442 @@
+import csv
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import random
+from math import log
+
+plt.style.use("bmh")
+
+with open("results.csv") as f:
+    all_results = list(csv.DictReader(f))
+
+# silesia is the hardest corpus to compress
+# for each scheme, check what the highest achieved compression for this corpus is
+compression_ratio_by_scheme = {}
+for row in all_results:
+    if row["corpus"] == "silesia":  # the hardest to compress
+        compression_ratio_by_scheme[row["scheme"]] = max(
+            compression_ratio_by_scheme.get(row["scheme"], 1),
+            float(row["compression ratio"]),
+        )
+compression_ratio_by_scheme["uncompressed"] = 0
+
+# for easier comparison and better visualization, we group the schemes by what format they implement
+scheme_groups = [
+    ["uncompressed"],
+    ["flate2 (rust)", "flate2 (zlib-ng)", "yazi"],
+    ["deflate", "zopfli", "zopfli-rs"],
+    ["lzzzz", "lz4_flex"],
+    ["rust-lzma", "lzma-rs"],
+    ["tetsy_snappy", "xsnappy", "snap"],
+    ["brotlic", "brotli"],
+    ["zstd"],
+    ["lzo1x-1"],
+    ["lzss (dyn)", "lzss (static)"],
+    ["bzip2"],
+]
+
+# sort members of each group by highest compression ratio and groups by highest compression ratio within the group
+# this way
+scheme_groups = sorted(
+    [
+        sorted(
+            group, key=lambda scheme: compression_ratio_by_scheme.get(scheme, 1)
+        )  # TODO: no get
+        for group in scheme_groups
+    ],
+    key=lambda group: max(
+        compression_ratio_by_scheme.get(scheme, 1) for scheme in group
+    ),
+)
+
+for group in scheme_groups:
+    print(group)
+
+schemes = [scheme for group in scheme_groups for scheme in group]
+
+# check that all schemes are accounted for
+for row in all_results:
+    if row["scheme"] not in schemes:
+        print(f'error: unexpected scheme "{scheme}"')
+        exit()
+
+
+# corpora = ["canterbury", "canterbury large", "silesia"]
+corpora = list(reversed(["canterbury", "canterbury large", "silesia"]))
+
+# base colors from colorbrewer: https://colorbrewer2.org/#type=qualitative&scheme=Paired&n=10
+colors = {
+    "uncompressed": "#000000",
+    **{x: "#1f78b4" for x in ["flate2 (rust)", "flate2 (zlib-ng)", "yazi"]},
+    **{x: "#33a02c" for x in ["deflate", "zopfli", "zopfli-rs"]},
+    **{x: "#e31a1c" for x in ["lzzzz", "lz4_flex"]},
+    **{x: "#a6cee3" for x in ["rust-lzma", "lzma-rs"]},
+    **{x: "#b2df8a" for x in ["tetsy_snappy", "xsnappy", "snap"]},
+    **{x: "#fdbf6f" for x in ["brotlic", "brotli"]},
+    **{x: "#fb9a99" for x in ["zstd"]},
+    **{x: "#cab2d6" for x in ["lzo1x-1"]},
+    **{x: "#ff7f00" for x in ["lzss (dyn)", "lzss (static)"]},
+    **{x: "#6a3d9a" for x in ["bzip2"]},
+}
+"""
+colors = {
+    "uncompressed": "#000000",
+    **{x: "#1f78b4" for x in ["flate2 (rust)", "flate2 (zlib-ng)", "yazi"]},
+    **{x: "#33a02c" for x in ["deflate", "zopfli", "zopfli-rs"]},
+    "lzzzz": "#e31a1c",
+    "lz4_flex": "#b00808",
+    "rust-lzma": "#a6cee3",
+    "lzma-rs": "#c2d6ff",
+    **{x: "#b2df8a" for x in ["tetsy_snappy", "xsnappy", "snap"]},
+    "lzss (dyn)": "#ff7f00",
+    "lzss (static)": "#ffaf33",
+    "brotli": "#d09749",
+    "brotlic": "#fdbf6f",
+    **{x: "#fb9a99" for x in ["zstd"]},
+    **{x: "#cab2d6" for x in ["lzo1x-1"]},
+    **{x: "#6a3d9a" for x in ["bzip2"]},
+}
+"""
+markers = {
+    "uncompressed": "o",
+    "flate2 (rust)": "s",
+    "flate2 (zlib-ng)": "d",
+    "yazi": "o",
+    "deflate": "o",
+    "zopfli": "d",
+    "zopfli-rs": "s",
+    "lzzzz": "d",
+    "lz4_flex": "o",
+    "rust-lzma": "o",
+    "lzma-rs": "s",
+    "tetsy_snappy": "o",
+    "xsnappy": "s",
+    "snap": "d",
+    "brotlic": "o",
+    "brotli": "s",
+    "zstd": "o",
+    "lzo1x-1": "o",
+    "lzss (dyn)": "o",
+    "lzss (static)": "s",
+    "bzip2": "o",
+}
+
+
+mpl.rcParams.update({"font.size": 14})
+figsize = (30 / 2.54, 20 / 2.54)
+
+
+def plot_compression_by_schemes(corpus):
+    results = [row for row in all_results if row["corpus"] == corpus]
+    plt.clf()
+    plt.close()
+    fig, ax = plt.subplots(figsize=figsize)
+
+    ax.set_yticks([i / 10 for i in range(0, 11, 1)])
+    ax.yaxis.set_minor_locator(mpl.ticker.MultipleLocator(0.025))
+
+    plt.grid(visible=True, which="major", axis="both", linestyle="-")
+    plt.grid(visible=True, which="minor", axis="both", linestyle=":")
+    ax.set_axisbelow(True)
+
+    for i, scheme in enumerate(schemes, 1):
+        ax.scatter(
+            [i for row in results if row["scheme"] == scheme],
+            [
+                1 - 1 / float(row["compression ratio"])
+                for row in results
+                if row["scheme"] == scheme
+            ],
+            label=scheme,
+            color=colors[scheme],
+            marker=markers[scheme],
+            s=40,
+        )
+
+    # ax.legend(loc="upper left", fontsize="small", ncols=3)
+
+    ax.text(
+        0.925,
+        0.975,
+        f"corpus: {corpus}",
+        size="large",
+        horizontalalignment="right",
+        verticalalignment="top",
+        transform=ax.transAxes,
+    )
+
+    ax.set_xlabel("scheme")
+    ax.set_ylabel("1 - compressed size / decompressed size\n(higher is better)")
+
+    ax.set_ylim(-0.025, 1.025)
+
+    plt.xticks(rotation=30, horizontalalignment="right")
+    ax.set_xticks([i + 1 for i in range(0, len(schemes))])
+    ax.set_xticklabels(schemes)
+
+    plt.tight_layout()
+    plt.savefig(f"plots/compression-{corpus}.png", dpi=300)
+
+
+def plot_throughput_by_scheme(corpus):
+    results = [row for row in all_results if row["corpus"] == corpus]
+
+    # plot compression and decompression speed for all schemes
+    plt.clf()
+    plt.close()
+    fig, ax = plt.subplots(figsize=figsize)
+
+    ax.set_yticks([i / 10 for i in range(0, 11, 1)])
+    ax.set_yscale("log")
+
+    plt.grid(visible=True, which="major", axis="both", linestyle="-")
+    plt.grid(visible=True, which="minor", axis="both", linestyle=":")
+    ax.set_axisbelow(True)
+
+    for i, scheme in enumerate(schemes, 1):
+        ax.errorbar(
+            [i - 0.1 for row in results if row["scheme"] == scheme],
+            [
+                float(row["compression speed (MB/s)"])
+                for row in results
+                if row["scheme"] == scheme
+            ],
+            yerr=[
+                float(row["compression speed standard deviation (MB/s)"])
+                for row in results
+                if row["scheme"] == scheme
+            ],
+            # label = scheme,
+            color=colors[scheme],
+            marker="v",
+            linestyle="none",
+            # markersize = 40,
+        )
+        ax.errorbar(
+            [
+                i + 0.1
+                for row in results
+                if row["scheme"] == scheme and row["decompression speed (MB/s)"]
+            ],
+            [
+                float(row["decompression speed (MB/s)"])
+                for row in results
+                if row["scheme"] == scheme and row["decompression speed (MB/s)"]
+            ],
+            yerr=[
+                float(row["compression speed standard deviation (MB/s)"])
+                for row in results
+                if row["scheme"] == scheme and row["decompression speed (MB/s)"]
+            ],
+            # label = scheme,
+            color=colors[scheme],
+            marker="^",
+            linestyle="none",
+            # markersize = 40,
+        )
+
+    # TODO: legend with black v and ^ (compression/decompression)
+    ax.legend(
+        handles=[
+            mpl.lines.Line2D([], [], color="black", label="compression", marker="v"),
+            mpl.lines.Line2D([], [], color="black", label="decompression", marker="^"),
+        ],
+        loc="upper right",
+        fontsize="small",
+        ncols=1,
+    )
+
+    ax.text(
+        0.025,
+        0.025,
+        f"corpus: {corpus}",
+        size="large",
+        horizontalalignment="left",
+        verticalalignment="bottom",
+        transform=ax.transAxes,
+    )
+
+    ax.set_xlabel("scheme")
+    ax.set_ylabel("throughput (higher is better)")
+
+    plt.xticks(rotation=30, horizontalalignment="right")
+    ax.set_xticks([i + 1 for i in range(0, len(schemes))])
+    ax.set_xticklabels(schemes)
+
+    ax.set_ylim(0.1, 10_000)
+
+    ax.set_yticks([0.1, 1, 10, 100, 1000, 10_000])
+    ax.set_yticklabels(
+        [
+            *[f"{n} KB/s" for n in [100]],
+            *[f"{n} MB/s" for n in [1, 10, 100]],
+            *[f"{n} GB/s" for n in [1, 10]],
+        ]
+    )
+
+    plt.tight_layout()
+    plt.savefig(f"plots/throughput-{corpus}.png", dpi=300)
+
+
+def plot_throughput_by_compression(corpus, which):
+    results = [row for row in all_results if row["corpus"] == corpus]
+
+    # plot compression speed versus compression quality
+    plt.clf()
+    plt.close()
+    fig, ax = plt.subplots(figsize=figsize)
+
+    ax.set_yticks([i / 10 for i in range(0, 11, 1)])
+    ax.set_yscale("log")
+
+    plt.grid(visible=True, which="major", axis="both", linestyle="-")
+    plt.grid(visible=True, which="minor", axis="both", linestyle=":")
+    ax.set_axisbelow(True)
+
+    for i, scheme in enumerate(schemes, 1):
+        ax.errorbar(
+            [
+                1 - 1 / float(row["compression ratio"])
+                for row in results
+                if row["scheme"] == scheme and row[f"{which} speed (MB/s)"]
+            ],
+            [
+                float(row[f"{which} speed (MB/s)"])
+                for row in results
+                if row["scheme"] == scheme and row[f"{which} speed (MB/s)"]
+            ],
+            yerr=[
+                float(row[f"{which} speed standard deviation (MB/s)"])
+                for row in results
+                if row["scheme"] == scheme and row[f"{which} speed (MB/s)"]
+            ],
+            label=scheme,
+            color=colors[scheme],
+            marker=markers[scheme],
+            # marker="v" if which == "compression" else "^",
+            linestyle="none",
+            # markersize = 40,
+        )
+
+    ax.legend(loc="lower left", fontsize="small", ncols=3)
+
+    ax.text(
+        0.975,
+        0.975,
+        f"corpus: {corpus}",
+        size="large",
+        horizontalalignment="right",
+        verticalalignment="top",
+        transform=ax.transAxes,
+    )
+
+    ax.set_xlabel("1 - compressed size / uncompressed size (higher is better)")
+    ax.set_ylabel(f"{which} speed (higher is better)")
+
+    ax.set_xticks([float(i) / 10 for i in range(0, 11)])
+
+    ax.set_xlim(-0.025, 1.025)
+    ax.set_ylim(0.1, 10_000)
+
+    ax.set_yticks([0.1, 1, 10, 100, 1000, 10_000])
+    ax.set_yticklabels(
+        [
+            *[f"{n} KB/s" for n in [100]],
+            *[f"{n} MB/s" for n in [1, 10, 100]],
+            *[f"{n} GB/s" for n in [1, 10]],
+        ]
+    )
+
+    plt.tight_layout()
+    plt.savefig(f"plots/{which[0]}-dc-{corpus}.png", dpi=300)
+
+
+def plot_decompression_speed_versus_compression_speed(corpus):
+    results = [row for row in all_results if row["corpus"] == corpus]
+
+    # plot compression speed versus compression quality
+    plt.clf()
+    plt.close()
+    fig, ax = plt.subplots(figsize=(figsize[0], figsize[0]))
+
+    ax.set_xscale("log")
+    ax.set_yscale("log")
+
+    plt.grid(visible=True, which="major", axis="both", linestyle="-")
+    plt.grid(visible=True, which="minor", axis="both", linestyle=":")
+    ax.set_axisbelow(True)
+
+    for i, scheme in enumerate(schemes, 1):
+        ax.errorbar(
+            [
+                float(row["compression speed (MB/s)"])
+                for row in results
+                if row["scheme"] == scheme and row["decompression speed (MB/s)"]
+            ],
+            [
+                float(row["decompression speed (MB/s)"])
+                for row in results
+                if row["scheme"] == scheme and row["decompression speed (MB/s)"]
+            ],
+            xerr=[
+                float(row["compression speed standard deviation (MB/s)"])
+                for row in results
+                if row["scheme"] == scheme and row["decompression speed (MB/s)"]
+            ],
+            yerr=[
+                float(row["decompression speed standard deviation (MB/s)"])
+                for row in results
+                if row["scheme"] == scheme and row["decompression speed (MB/s)"]
+            ],
+            label=scheme,
+            color=colors[scheme],
+            marker=markers[scheme],
+            linestyle="none",
+            # markersize = 40,
+        )
+
+    ax.legend(loc="lower right", fontsize="small", ncols=3)
+
+    ax.text(
+        0.025,
+        0.025,
+        f"corpus: {corpus}",
+        size="large",
+        horizontalalignment="left",
+        verticalalignment="bottom",
+        transform=ax.transAxes,
+    )
+
+    ax.set_xlabel("compression speed (higher is better)")
+    ax.set_ylabel("decompression speed (higher is better)")
+
+    ax.set_ylim(0.1, 10_000)
+    ax.set_xlim(0.1, 10_000)
+
+    ax.set_xticks([0.1, 1, 10, 100, 1000, 10_000])
+    ax.set_xticklabels(
+        [
+            *[f"{n} KB/s" for n in [100]],
+            *[f"{n} MB/s" for n in [1, 10, 100]],
+            *[f"{n} GB/s" for n in [1, 10]],
+        ]
+    )
+    ax.set_yticks([0.1, 1, 10, 100, 1000, 10_000])
+    ax.set_yticklabels(
+        [
+            *[f"{n} KB/s" for n in [100]],
+            *[f"{n} MB/s" for n in [1, 10, 100]],
+            *[f"{n} GB/s" for n in [1, 10]],
+        ]
+    )
+
+    plt.tight_layout()
+    plt.savefig(f"plots/cs-ds-{corpus}.png", dpi=300)
+
+
+for corpus in corpora:
+    plot_compression_by_schemes(corpus=corpus)
+    plot_throughput_by_scheme(corpus=corpus)
+    plot_throughput_by_compression(corpus=corpus, which="compression")
+    plot_throughput_by_compression(corpus=corpus, which="decompression")
+    plot_decompression_speed_versus_compression_speed(corpus=corpus)

@@ 1,829 @@
+scheme,settings,corpus,compression speed (MB/s),compression speed standard deviation (MB/s),decompression speed (MB/s),decompression speed standard deviation (MB/s),compression ratio
+uncompressed,,canterbury,4164.440841500847,639.5416477178397,6515.560195119592,1235.3270263615684,1.0
+uncompressed,,canterbury large,5739.743378902008,311.7875523753849,6689.18957631729,565.4761958298044,1.0
+uncompressed,,silesia,7534.398973038962,140.26062956374165,7593.257824316383,257.18431154395165,1.0
+lzzzz,frame / Default,canterbury,623.8153263725517,19.372942058745384,2588.067416400629,318.4315437142167,2.2883790908632027
+lzzzz,frame / Default,canterbury large,490.1103457920519,4.963218994539521,1569.7676566008913,101.72164817831101,1.9238827687268338
+lzzzz,frame / Default,silesia,612.9868270232616,8.745845869728251,2145.5619034199485,63.086869014309904,2.1002172640462584
+lzzzz,frame / High,canterbury,21.087875734576862,0.1270181151802685,2652.7546070663484,152.32624887622964,3.010129849267757
+lzzzz,frame / High,canterbury large,9.292881737236137,0.12079339637651386,1930.080320208087,32.81368218160897,2.836708096559315
+lzzzz,frame / High,silesia,24.575174788491577,0.187372353368188,2161.5119567579463,67.24145181680699,2.7301780358784176
+lzzzz,frame / Max,canterbury,2.7121990765389836,0.0157769159413226,2606.6545340378457,90.6833098557654,3.0223288882007213
+lzzzz,frame / Max,canterbury large,3.8188351132965925,0.018711013596965115,1939.0677192067494,143.06117073895905,2.960389686011695
+lzzzz,frame / Max,silesia,12.002838123286203,0.1523482386425125,2085.3608128126125,128.49878428404287,2.741990107939835
+lzzzz,block / normal / acceleration 0,canterbury,619.8701414653664,6.721265313322311,3604.137708740356,559.1292900704276,2.2892457451045387
+lzzzz,block / normal / acceleration 0,canterbury large,492.019188306746,5.879744723362355,2022.257639316957,66.48571360378479,1.924378751182315
+lzzzz,block / normal / acceleration 0,silesia,647.5183363090717,4.206746288731495,2808.165753364755,29.894770543243,2.100897586107615
+lzzzz,block / hc / acceleration 0,canterbury,18.960431210747558,0.2149743922819091,3660.5392258577986,549.3191963747214,3.0018005779791235
+lzzzz,block / hc / acceleration 0,canterbury large,6.1508883825993745,0.04681789604774399,2393.59465087879,81.18076461914582,2.849173918227466
+lzzzz,block / hc / acceleration 0,silesia,34.74448699411864,0.29586491774806783,2724.5903530104074,55.06809873832803,2.721217431069306
+lzzzz,block / normal / acceleration 1,canterbury,605.0169740922926,24.600134968730263,3596.8927836648795,511.35403717206356,2.2892457451045387
+lzzzz,block / normal / acceleration 1,canterbury large,491.7698649683692,8.986722237293067,2044.4121752590015,57.53952690464472,1.924378751182315
+lzzzz,block / normal / acceleration 1,silesia,626.6996285852748,11.660506847662294,2768.2843801144822,53.25479811273431,2.100897586107615
+lzzzz,block / hc / acceleration 1,canterbury,130.33382262261946,2.570440876682612,3474.4807688146893,486.72904814213484,2.7793825361070623
+lzzzz,block / hc / acceleration 1,canterbury large,99.93889217589893,2.0455089060530574,1903.6612684770764,89.77018710310432,2.151800780276095
+lzzzz,block / hc / acceleration 1,silesia,113.53122430319569,1.3043009509792622,2636.2022743762805,49.79832887306084,2.529008828929926
+lzzzz,block / normal / acceleration 2,canterbury,643.9892971647702,13.763735572982169,3685.1993708274026,647.0178775267808,2.2062807301772698
+lzzzz,block / normal / acceleration 2,canterbury large,515.1851802772563,6.85143000851711,2100.7431710298456,20.111841930945666,1.8795547000227881
+lzzzz,block / normal / acceleration 2,silesia,709.6568264382006,9.773605226216235,2852.60372108097,100.19249212224479,2.0364035369820335
+lzzzz,block / hc / acceleration 2,canterbury,132.6399400789758,2.5724480944826547,3500.8679443726974,496.7930837208158,2.7793825361070623
+lzzzz,block / hc / acceleration 2,canterbury large,101.83297263179712,0.8900508116727587,1968.7579798136203,76.39804709776858,2.151800780276095
+lzzzz,block / hc / acceleration 2,silesia,113.5966278013148,1.4010932943964798,2649.405770743175,25.3961256545055,2.529008828929926
+lzzzz,block / normal / acceleration 4,canterbury,688.0070260733232,31.841320015180568,3591.0613389367813,618.8558101216778,2.0777435936860127
+lzzzz,block / normal / acceleration 4,canterbury large,521.9665402429549,9.868975764823332,1962.8391638214086,155.9506353402498,1.7950027762711493
+lzzzz,block / normal / acceleration 4,silesia,766.6910133816036,4.451804111839617,2929.3634843517907,31.25376959700432,1.9437668535363606
+lzzzz,block / hc / acceleration 4,canterbury,79.38816532428496,0.5254554218397255,3623.1914753393216,541.7406766674015,2.9323168021832884
+lzzzz,block / hc / acceleration 4,canterbury large,57.061532460124056,0.42369144743165793,2201.1801235732273,40.79623033238381,2.4251513779780383
+lzzzz,block / hc / acceleration 4,silesia,79.94393295704204,1.1124290435411348,2692.913857800181,96.04300383220739,2.6556335218226774
+lzzzz,block / normal / acceleration 8,canterbury,799.7093086604158,37.938560368573555,3540.987595566459,594.1281344517454,1.9073089270410146
+lzzzz,block / normal / acceleration 8,canterbury large,569.9267680481123,11.343383009586343,1955.2571895316564,113.66668136708698,1.6597754528935795
+lzzzz,block / normal / acceleration 8,silesia,867.5064630146147,9.583530045344622,2943.7807231864026,34.540433336135486,1.7986393695075849
+lzzzz,block / hc / acceleration 8,canterbury,22.923820346104026,0.3150267852791529,3683.8065666467555,557.6865764714876,2.9991453219447393
+lzzzz,block / hc / acceleration 8,canterbury large,9.878443540596457,0.16339693574464803,2382.2273767432284,69.16421531194527,2.792661765434552
+lzzzz,block / hc / acceleration 8,silesia,40.50144293332492,0.26136219847806885,2760.331872261774,134.2404622540853,2.7186686443956947
+lzzzz,block / normal / acceleration 16,canterbury,1028.2475959724572,16.404147741576917,3920.465184903705,640.50208573608,1.73759818400545
+lzzzz,block / normal / acceleration 16,canterbury large,642.595616727327,20.15215684095611,1884.5042790569203,107.99829734928564,1.5066271721212432
+lzzzz,block / normal / acceleration 16,silesia,1045.2657304777294,7.514999410480037,3044.2139350278417,53.69321474756278,1.6304632144409141
+lzzzz,block / hc / acceleration 16,canterbury,2.688018552643311,0.025960188864119584,3477.505792901206,513.5751004441655,3.0236846606403476
+lzzzz,block / hc / acceleration 16,canterbury large,3.8533662298938025,0.031233707606806615,2462.3346325215325,32.556776996375774,2.9617017730429636
+lzzzz,block / hc / acceleration 16,silesia,12.069822512731909,0.0549030853798655,2677.303682703163,81.28535639760625,2.7431183915128172
+lzzzz,block / normal / acceleration 128,canterbury,2544.5665824412317,163.79555823443067,7716.407858527613,1898.0062260132206,1.268798827794382
+lzzzz,block / normal / acceleration 128,canterbury large,1142.0827183163299,23.145850902155587,2515.338196148341,211.7350030156205,1.2267785652048782
+lzzzz,block / normal / acceleration 128,silesia,2514.5387601773245,99.32032852904501,4262.908291663429,176.07549270458264,1.2135312492345236
+lzzzz,block / hc / acceleration 128,canterbury,2.597807115197102,0.03617640713329794,3388.8376357057327,498.24662766892703,3.0236846606403476
+lzzzz,block / hc / acceleration 128,canterbury large,3.7582212640407135,0.03686890601786048,2323.1167664562768,43.394285754472214,2.9617017730429636
+lzzzz,block / hc / acceleration 128,silesia,12.133922857986924,0.08067298827918631,2652.520780535478,120.088185908808,2.7431183915128172
+lzzzz,block / normal / acceleration 1024,canterbury,10258.25554470586,1567.9105704791057,15420.596332255931,4494.772013213803,1.0744086093844247
+lzzzz,block / normal / acceleration 1024,canterbury large,4673.690849718084,381.28959373601487,4340.231210943569,388.75902602686114,0.9964203099528883
+lzzzz,block / normal / acceleration 1024,silesia,3881.460125115549,187.50936263789976,4649.538685778478,245.29928717964393,1.0340965442105314
+lzzzz,block / hc / acceleration 1024,canterbury,2.6215137451099744,0.03108060834201315,3425.998661027151,550.9059261596386,3.0236846606403476
+lzzzz,block / hc / acceleration 1024,canterbury large,3.7137214168438573,0.029626547586707824,2300.5061493029766,83.05322540752483,2.9617017730429636
+lzzzz,block / hc / acceleration 1024,silesia,12.018167347375657,0.13200383917068925,2654.518977367775,75.59588335510027,2.7431183915128172
+lzzzz,block / normal / acceleration 8192,canterbury,13299.282683694262,3009.19226048347,15765.862023411817,5848.452308719793,1.026306276832614
+lzzzz,block / normal / acceleration 8192,canterbury large,4779.191252231437,463.9345369387373,4408.840401959888,153.36933208552315,0.9960963884027934
+lzzzz,block / normal / acceleration 8192,silesia,4739.908641179492,136.61803216551266,4885.493262778484,278.40756559445026,0.9994849557359696
+lzzzz,block / hc / acceleration 8192,canterbury,2.615551579878865,0.031877510175675375,3330.0144400084537,521.0845309710345,3.0236846606403476
+lzzzz,block / hc / acceleration 8192,canterbury large,3.7791601972214948,0.02743817557719238,2281.7634622750015,116.25002991488967,2.9617017730429636
+lzzzz,block / hc / acceleration 8192,silesia,12.028901639203962,0.09786144256236003,2683.0028220079043,83.66864090975606,2.7431183915128172
+lzzzz,block / normal / acceleration 65535,canterbury,10806.63251412425,2281.9052304994907,12488.390061254111,4439.675494720391,0.9971502229481375
+lzzzz,block / normal / acceleration 65535,canterbury large,5107.306456545756,695.3037397375238,4804.056458970787,688.9367615818668,0.9960936321491111
+lzzzz,block / normal / acceleration 65535,silesia,6359.71466032046,202.93351290321897,6339.531879329434,421.5364759324713,0.9960937438497179
+lzzzz,block / hc / acceleration 65535,canterbury,2.635360053966557,0.017005928278714492,3397.646160132054,509.41952712710855,3.0236846606403476
+lzzzz,block / hc / acceleration 65535,canterbury large,3.7368578755199473,0.051835673898879074,2157.5529243689916,221.14148998880924,2.9617017730429636
+lzzzz,block / hc / acceleration 65535,silesia,12.029948642287176,0.07328624608323919,2636.484622360351,107.73871938422657,2.7431183915128172
+lz4_flex,safe / Block,canterbury,451.5186074144129,30.511635063577447,2617.081941160739,461.28674722344414,2.288520692715415
+lz4_flex,safe / Block,canterbury large,354.9847419482249,24.15655425254297,2253.5135655225963,220.32611544915773,1.9240323659334602
+lz4_flex,safe / Block,silesia,420.25202241432703,7.580272052164649,2124.028595644954,98.944127445847,2.097079729132742
+lz4_flex,safe / Frame,canterbury,391.0550152791179,22.383063026215737,2069.9580590090127,278.13736809079336,2.244128171841093
+lz4_flex,safe / Frame,canterbury large,349.8116536184844,14.10564622818527,1629.7444323394745,91.03035042068062,1.8659103916804625
+lz4_flex,safe / Frame,silesia,413.04891876444526,9.469772876856576,1770.145986139355,51.61182397925445,2.0364756624057656
+lz4_flex,unsafe,canterbury,365.3352691805641,32.95881174800099,2625.5217066282034,528.154111446505,2.288520692715415
+lz4_flex,unsafe,canterbury large,335.22876178276886,22.063836260305262,2239.113442408286,248.2278738171094,1.9240323659334602
+lz4_flex,unsafe,silesia,407.8949377045794,8.475121001558472,2243.729733799745,69.60139301395073,2.097079729132742
+deflate,Fast,canterbury,116.87161155083227,3.25360742104487,,,3.2367872849317183
+deflate,Fast,canterbury large,94.85045580257047,4.802455456084906,,,2.721009238937889
+deflate,Fast,silesia,100.89795451774089,2.087532355042092,,,2.626566198493865
+deflate,Default,canterbury,19.540631553757937,0.22372171847743444,,,3.845889876774294
+deflate,Default,canterbury large,11.99883480695804,0.1258987729941595,,,3.427385652531116
+deflate,Default,silesia,25.600995937258894,0.3758952696544876,,,3.1126622993149895
+deflate,Best,canterbury,5.952323280146369,0.06330261269539718,,,3.819897883605793
+deflate,Best,canterbury large,3.543404777621002,0.050651854189998353,,,3.4894885223018686
+deflate,Best,silesia,13.029085649274942,0.10850098642171446,,,3.1303390240138964
+flate2 (rust),deflate / level 0,canterbury,99.71356709127748,3.9468839518933994,6444.951762501587,1769.1263488446837,0.9998417062430702
+flate2 (rust),deflate / level 0,canterbury large,100.08188951367153,2.0664145906705746,4522.98708436383,439.07988595517,0.999842311456019
+flate2 (rust),deflate / level 0,silesia,96.34618920000037,2.2865551154091746,4008.800833947673,204.88800937643933,0.9998425027573812
+flate2 (rust),zlib / level 0,canterbury,94.4118777543201,5.119836736153296,3473.0273582560862,683.1936526114731,0.9998395722876244
+flate2 (rust),zlib / level 0,canterbury large,96.74576275781612,3.4845331888495115,2924.708606693919,169.01797312160082,0.9998417739664955
+flate2 (rust),zlib / level 0,silesia,97.02153109106196,1.6573149318328078,2478.240457772497,103.49500378062564,0.9998424744562101
+flate2 (rust),gzip / level 0,canterbury,97.12509446873871,3.8403182585969833,4666.0772554832565,653.4981772641883,0.9998353044040599
+flate2 (rust),gzip / level 0,canterbury large,96.1666760571661,4.004091751141926,3371.077544644325,469.6906783642465,0.9998406989891823
+flate2 (rust),gzip / level 0,silesia,97.11550977110134,2.201873616689589,3146.3591901038712,121.23576059614284,0.9998424178538727
+flate2 (rust),deflate / level 1,canterbury,171.32551524326962,9.58071934241296,321.2711268113564,16.34891970157,2.819705548354995
+flate2 (rust),deflate / level 1,canterbury large,137.2377127334984,2.72004155743075,247.58885314577356,4.9466865625041825,2.333223636067123
+flate2 (rust),deflate / level 1,silesia,167.64533250887334,3.9607917530181767,316.23357427644,6.430418606980417,2.419111763872108
+flate2 (rust),zlib / level 1,canterbury,172.5391417596748,2.717848288400227,312.29378831496024,4.545084274328746,2.819688576524665
+flate2 (rust),zlib / level 1,canterbury large,137.6675808080862,0.9824728758858903,242.0298366782098,1.6728472090732434,2.3332207090894874
+flate2 (rust),zlib / level 1,silesia,165.19704907352855,1.6703426654383147,303.4781647088728,3.637389664005675,2.4191115981986
+flate2 (rust),gzip / level 1,canterbury,170.3680710692104,4.366201170640128,313.24824351899343,6.3640413683080155,2.8196546334769184
+flate2 (rust),gzip / level 1,canterbury large,138.3328655448488,1.1009579754574002,244.86439712371958,1.1478593917935218,2.333214855156247
+flate2 (rust),gzip / level 1,silesia,163.62807211088034,3.776210742535391,306.66092799090336,6.459522233216522,2.419111266851653
+flate2 (rust),deflate / level 2,canterbury,119.26804331114852,9.550616848402965,399.95736193775303,18.48073344605365,3.446302939943158
+flate2 (rust),deflate / level 2,canterbury large,107.10731116523318,0.6833728512899837,316.2789172614368,1.5725019719932483,2.9719895623994974
+flate2 (rust),deflate / level 2,silesia,100.8513853668148,2.137866489735556,371.5843260150597,5.138486146500388,2.839840270040953
+flate2 (rust),zlib / level 2,canterbury,117.86700636806637,6.982687909352586,381.7183109600083,4.5510947473397065,3.4462775870524767
+flate2 (rust),zlib / level 2,canterbury large,104.53634224151153,1.206260113440541,297.17673897509025,10.95664956890044,2.971984813411411
+flate2 (rust),zlib / level 2,silesia,100.20393136416207,1.7105903102497277,353.9342483397695,3.341818560872779,2.839840041728804
+flate2 (rust),gzip / level 2,canterbury,122.93096728864178,6.920869882307994,371.9071382853372,47.273631648572334,3.4462268823901563
+flate2 (rust),gzip / level 2,canterbury large,103.12447388863703,1.9980326308075123,305.462752071299,2.008510685909117,2.9719753154807687
+flate2 (rust),gzip / level 2,silesia,101.54880853591916,1.298139239627054,363.5278121867247,8.280767567446818,2.839839585104616
+flate2 (rust),deflate / level 3,canterbury,71.86595895380493,2.549473085939531,452.70913618949976,31.742068571730915,3.569530553516594
+flate2 (rust),deflate / level 3,canterbury large,56.169335046608786,0.2737644918711232,388.8322588080243,10.487286841584623,3.2872193987938645
+flate2 (rust),deflate / level 3,silesia,65.49443378495087,0.8132350621392992,401.7232931702999,12.742608379986164,3.0160182608506694
+flate2 (rust),zlib / level 3,canterbury,66.47348522088073,4.032450482086583,411.37262274083105,17.868639361717307,3.569503355159224
+flate2 (rust),zlib / level 3,canterbury large,55.4646129013975,1.5756429426961662,365.4594180492305,18.035382434336466,3.2872135889584557
+flate2 (rust),zlib / level 3,silesia,65.05324193462994,1.1204226581768493,380.9662081227749,10.419937058714845,3.0160180033317587
+flate2 (rust),gzip / level 3,canterbury,74.11541747314848,3.414516125265502,449.0088072921861,6.481937607212619,3.5694489596879064
+flate2 (rust),gzip / level 3,canterbury large,58.32612503716705,0.6424037062113355,390.28109367187153,14.508828511529659,3.287201969349248
+flate2 (rust),gzip / level 3,silesia,64.69551742225869,1.319397372554765,391.5044278208585,7.889690883461018,3.0160174882940693
+flate2 (rust),deflate / level 4,canterbury,61.90065900866499,2.0553288570597332,432.89802945082215,29.16516807221668,3.720551970614514
+flate2 (rust),deflate / level 4,canterbury large,46.520359873533934,1.2465385188794857,357.0134798508163,14.62139818973197,3.274079907101005
+flate2 (rust),deflate / level 4,silesia,58.840067011100366,1.1167898101080236,404.4898133484233,12.18253722536347,3.0397121097683915
+flate2 (rust),zlib / level 4,canterbury,62.979857581781715,1.3970811246902022,424.1638126447687,9.335079772685313,3.720522422139008
+flate2 (rust),zlib / level 4,canterbury large,46.434521508188894,2.3796745624407323,345.6863426695034,12.18841260765492,3.274074143618237
+flate2 (rust),zlib / level 4,silesia,58.69785056160215,0.6111870841399853,388.3591001992744,8.217756166958104,3.0397118481874488
+flate2 (rust),gzip / level 4,canterbury,64.89241253235318,1.1559258652746274,423.4070112778738,42.257702497094584,3.7204633265960108
+flate2 (rust),gzip / level 4,canterbury large,48.90802037525376,0.425744692729696,362.44643610724916,11.058285590741113,3.2740626167135747
+flate2 (rust),gzip / level 4,silesia,59.424277066898014,0.780777911041652,402.5059763868742,4.406868592134624,3.0397113250256993
+flate2 (rust),deflate / level 5,canterbury,48.236994727902115,0.986064582766283,463.29359797652893,6.577398372916509,3.752440074493862
+flate2 (rust),deflate / level 5,canterbury large,34.73866129567197,0.6170608151154501,389.4271239761909,6.742580523303619,3.3435988981191684
+flate2 (rust),deflate / level 5,silesia,47.01501476579946,0.5440102079061108,414.65170934225205,5.843746691059559,3.0736704455295873
+flate2 (rust),zlib / level 5,canterbury,46.19636323462768,0.42091053550243585,435.39803402672413,4.672412172775598,3.752410017341712
+flate2 (rust),zlib / level 5,canterbury large,33.64745844771692,0.4101829079166609,359.8371368659093,14.009832690137829,3.343592887284529
+flate2 (rust),zlib / level 5,silesia,46.90708959258232,0.7638971003546178,394.717589278465,7.054816466107982,3.073670178071463
+flate2 (rust),gzip / level 5,canterbury,46.88854533439057,0.837275049369446,447.472216771829,6.948956557471067,3.7523499044819397
+flate2 (rust),gzip / level 5,canterbury large,34.374651729226834,0.4066717743191175,379.80760824317,5.3580728054518625,3.3435808656800847
+flate2 (rust),gzip / level 5,silesia,47.26063765047179,0.8549438186208733,409.85455483188514,6.458136146812809,3.0736696431553536
+flate2 (rust),deflate / level 6,canterbury,22.614951734646336,1.1996423460296861,463.5929549454076,31.71996598335449,3.7990652310836346
+flate2 (rust),deflate / level 6,canterbury large,14.840178367195778,0.2737014357927831,405.24560943122776,9.122271586936098,3.42251462840224
+flate2 (rust),deflate / level 6,silesia,29.493999904464154,0.29994558431264007,433.91611864324585,2.703861566669809,3.111715428678231
+flate2 (rust),zlib / level 6,canterbury,23.742027327852348,0.30835513553823024,453.9221608884993,13.31867891884207,3.7990344223564203
+flate2 (rust),zlib / level 6,canterbury large,15.144855860311683,0.15283909451932326,390.63710919300235,3.4693201750960054,3.4225083304836663
+flate2 (rust),zlib / level 6,silesia,29.141001904680433,0.3724571770481911,404.0425466827631,4.967768577481633,3.111715154558095
+flate2 (rust),gzip / level 6,canterbury,23.355654370557463,0.3548869885420082,452.8206299658017,7.95577093429309,3.798972806401038
+flate2 (rust),gzip / level 6,canterbury large,14.513818563770847,0.15453105930184213,384.998161182235,16.90328324172065,3.422495734716053
+flate2 (rust),gzip / level 6,silesia,29.007840205830313,0.18463971034915339,408.9657865223428,8.436103019915643,3.1117146063179684
+flate2 (rust),deflate / level 7,canterbury,18.250827959670342,0.2101778257315424,472.1206514549548,42.12102557331194,3.7831933089804917
+flate2 (rust),deflate / level 7,canterbury large,8.172930692703584,0.0572082997545363,406.29037081827806,9.728785319488534,3.4461980587369343
+flate2 (rust),deflate / level 7,silesia,23.030714738151804,0.295833755613089,432.80585571520504,4.456256216629718,3.1203269224667767
+flate2 (rust),zlib / level 7,canterbury,17.47434076919474,0.18233947440022732,429.3060438115222,40.01083294774911,3.783162757142934
+flate2 (rust),zlib / level 7,canterbury large,7.964937558602957,0.14289231487105009,374.88992564710094,17.640987299360503,3.4461916733550386
+flate2 (rust),zlib / level 7,silesia,22.87916448850082,0.1899790794240415,398.2754937678339,9.522916449866285,3.1203266468273183
+flate2 (rust),gzip / level 7,canterbury,17.345743926529444,0.3579998996453106,455.6130629426778,15.189879525546498,3.783101654948155
+flate2 (rust),gzip / level 7,canterbury large,8.192528808098643,0.14810016088460548,398.22068199582077,11.740257490684446,3.446178902662235
+flate2 (rust),gzip / level 7,silesia,23.275844795518587,0.23705685587411515,418.0839888306113,9.662511940097948,3.120326095548547
+flate2 (rust),deflate / level 8,canterbury,13.615485182262121,0.14929848655401082,484.2415332307683,9.719449294194817,3.79026914192554
+flate2 (rust),deflate / level 8,canterbury large,4.881989019382244,0.06813537260443081,408.9311188984593,6.959799235098672,3.473707081306262
+flate2 (rust),deflate / level 8,silesia,18.91648875835181,0.17276735611590371,435.5262697377839,3.7589677926154534,3.124130140099322
+flate2 (rust),zlib / level 8,canterbury,13.458584922157552,0.5093923596260204,452.22244648511605,15.146925876794601,3.790238475697324
+flate2 (rust),zlib / level 8,canterbury large,4.897349197204795,0.02872034573154608,390.2185585930831,4.85653016780553,3.473700593575908
+flate2 (rust),zlib / level 8,silesia,18.819919799767135,0.13851627402378563,402.61835933697836,10.9505308541525,3.1241298637875263
+flate2 (rust),gzip / level 8,canterbury,13.661877382212863,0.12031950887100332,472.24605655440376,18.274282717621187,3.79017714472955
+flate2 (rust),gzip / level 8,canterbury large,4.923148960456455,0.0420214805543753,399.2851786848904,18.757530376354797,3.473687618187902
+flate2 (rust),gzip / level 8,silesia,18.851204652347395,0.14716496569326026,419.19330785771774,6.824304985313037,3.1241293111640815
+flate2 (rust),deflate / level 9,canterbury,11.132710562378442,0.14214100120914633,482.56766425134447,14.073832221399101,3.7943982763927364
+flate2 (rust),deflate / level 9,canterbury large,4.249215622548352,0.033679496657965206,406.2322877422383,11.801657102625471,3.486031952402834
+flate2 (rust),deflate / level 9,silesia,17.248952495340145,0.15135837950647318,429.31113129490836,10.473752735315644,3.1259106023400474
+flate2 (rust),zlib / level 9,canterbury,11.099476382036688,0.17682677233673702,445.41803736820043,34.13574826456804,3.794367543312571
+flate2 (rust),zlib / level 9,canterbury large,4.275986346718523,0.03926730545965962,392.021213525157,10.915065310105824,3.486025418553326
+flate2 (rust),zlib / level 9,silesia,17.259167112962487,0.19599966215963216,408.2348328893254,9.060741699331533,3.1259103257132184
+flate2 (rust),gzip / level 9,canterbury,11.053021827516172,0.11627893298760406,458.9629032400649,34.39484246837452,3.79430607864577
+flate2 (rust),gzip / level 9,canterbury large,4.241207920628071,0.04258958196620511,399.8473265479386,3.54407244307794,3.486012350927788
+flate2 (rust),gzip / level 9,silesia,17.327051058130756,0.0972350400392245,421.42652669571123,3.215261376828201,3.125909772459707
+flate2 (rust),deflate / level 10,canterbury,7.821271121969027,0.12687010066587798,487.66711576300656,16.614129929778173,3.7949925471473938
+flate2 (rust),deflate / level 10,canterbury large,4.2304683650740955,0.02272088798336721,414.76622491905835,2.8310294712379496,3.487243315572358
+flate2 (rust),deflate / level 10,silesia,14.790192822995078,0.09877757019505869,430.3571885638025,4.553091130737563,3.127514477468353
+flate2 (rust),zlib / level 10,canterbury,7.817437345621273,0.039848120218775464,458.2639732010064,10.861805979075678,3.794961804439812
+flate2 (rust),zlib / level 10,canterbury large,4.185641422262137,0.05706885618696375,394.07632215812555,5.2121612918911815,3.487236777181163
+flate2 (rust),zlib / level 10,silesia,14.842568404212097,0.11174049213972194,408.9811971856754,9.390295261416396,3.127514200557582
+flate2 (rust),gzip / level 10,canterbury,7.922404623563737,0.08248186650344609,475.0824248143991,22.71996377528882,3.7949003205188787
+flate2 (rust),gzip / level 10,canterbury large,4.193665451924886,0.04764565202849778,403.3897158320012,5.015565470515999,3.4872237004723283
+flate2 (rust),gzip / level 10,silesia,14.73392623131491,0.034931824898660514,414.9877231454539,7.896333724575935,3.1275136467361864
+flate2 (zlib-ng),deflate / level 0,canterbury,5011.514994288971,1616.655419669453,9194.325425567367,2340.106813827387,0.9998488194936769
+flate2 (zlib-ng),deflate / level 0,canterbury large,4026.688249202339,960.9010205267292,4551.36756926068,694.709140372651,0.9998476863830372
+flate2 (zlib-ng),deflate / level 0,silesia,3393.8283885405276,145.1954561887232,4062.6979972877675,164.87829949114112,0.9998474554869945
+flate2 (zlib-ng),zlib / level 0,canterbury,3309.303414968333,584.7530121385134,4906.723091051259,731.1670166887407,0.9998466855078676
+flate2 (zlib-ng),zlib / level 0,canterbury large,3164.9901941195944,452.2321370901812,3298.1902851053546,271.66559211431394,0.9998471488877348
+flate2 (zlib-ng),zlib / level 0,silesia,2607.7656491546704,138.69467293608244,3035.5165384165903,200.4539828658991,0.9998474271855431
+flate2 (zlib-ng),gzip / level 0,canterbury,3582.3553993083747,636.5049408737042,5585.296987771945,665.0977580121188,0.9998424175635763
+flate2 (zlib-ng),gzip / level 0,canterbury large,3137.1962237783996,240.8742571743426,3448.594641094458,353.7155715391467,0.9998460738988639
+flate2 (zlib-ng),gzip / level 0,silesia,2574.8503027581583,87.70109562351404,3082.4207025317137,79.10821480838104,0.999847370582645
+flate2 (zlib-ng),deflate / level 1,canterbury,292.71551634162597,3.766675657905491,517.011907844053,9.153950515641712,2.4433483834065552
+flate2 (zlib-ng),deflate / level 1,canterbury large,253.4441553227499,1.570739820490599,438.28362266436795,5.690026598103796,1.9716733711384504
+flate2 (zlib-ng),deflate / level 1,silesia,226.92889535605596,2.220447696530071,468.81182316672124,25.940396404199422,2.2516528893923193
+flate2 (zlib-ng),zlib / level 1,canterbury,284.53232568231806,6.906300048268641,489.5236819746925,14.067948986065115,2.443335639801528
+flate2 (zlib-ng),zlib / level 1,canterbury large,246.46996208855558,2.5737181201228427,425.39923979621744,3.1365109071369,1.9716712809921006
+flate2 (zlib-ng),zlib / level 1,silesia,221.84858261296557,5.534423244112229,455.1007030665923,10.027155661509209,2.2516527458618567
+flate2 (zlib-ng),gzip / level 1,canterbury,277.87394123344103,4.756815477753415,475.794137514982,12.092412626937108,2.4433101529902643
+flate2 (zlib-ng),gzip / level 1,canterbury large,233.67357344646234,7.367222754503237,386.65854758391436,24.06710749660327,1.9716671007126954
+flate2 (zlib-ng),gzip / level 1,silesia,223.25782945237108,2.422135207443448,461.5383322234624,4.594147212374912,2.251652458800986
+flate2 (zlib-ng),deflate / level 2,canterbury,160.93151754971208,2.681929200952006,493.7504221456306,6.028732628905364,3.4326371053721054
+flate2 (zlib-ng),deflate / level 2,canterbury large,126.01680893384255,2.7523155663298824,480.3917793735679,8.493085092623158,2.9728691783604506
+flate2 (zlib-ng),deflate / level 2,silesia,126.02100184983755,1.8541366032291349,448.2873108242745,8.687305363697323,2.8149955875438812
+flate2 (zlib-ng),zlib / level 2,canterbury,157.16369583552887,5.682891984930985,476.0393626571636,11.02227894240336,3.432611953148757
+flate2 (zlib-ng),zlib / level 2,canterbury large,125.00329036878352,3.1730181033815588,467.4073485213857,6.74263162577988,2.972864426560846
+flate2 (zlib-ng),zlib / level 2,silesia,123.73200085730154,2.3102738359047854,433.6824872091501,5.328043417945245,2.8149953632090896
+flate2 (zlib-ng),gzip / level 2,canterbury,158.09801006072215,2.0966940288824643,476.4592911488109,7.231378464987494,3.4325616498078424
+flate2 (zlib-ng),gzip / level 2,canterbury large,125.2896208318589,3.348451335471943,465.3427389543568,16.922938400133372,2.9728549230072088
+flate2 (zlib-ng),gzip / level 2,silesia,123.99811704816955,0.9010795290550928,432.85513430134563,4.995805277301025,2.814994914539614
+flate2 (zlib-ng),deflate / level 3,canterbury,120.39218879420655,3.0130481675078125,533.1786111149456,11.617923901949025,3.585416908497874
+flate2 (zlib-ng),deflate / level 3,canterbury large,73.37178682385222,0.8626852253976702,564.8201358045646,8.705961995156411,3.1726941176203005
+flate2 (zlib-ng),deflate / level 3,silesia,103.55741041585644,1.7610908107728063,465.8144708196518,5.63853719819569,2.9236846293486187
+flate2 (zlib-ng),zlib / level 3,canterbury,120.75665056696297,1.072984222626035,519.0835543361736,6.8775853093430905,3.585389467507701
+flate2 (zlib-ng),zlib / level 3,canterbury large,72.78192202663692,1.6100283089716008,537.7217613974775,21.420742257613938,3.1726887055568413
+flate2 (zlib-ng),zlib / level 3,silesia,102.66285557141984,1.8804555272100894,443.79652148389386,12.25251464663756,2.9236843873559306
+flate2 (zlib-ng),gzip / level 3,canterbury,121.71905684433392,0.7720557796127921,512.1917177366049,11.595340173967482,3.585334586787454
+flate2 (zlib-ng),gzip / level 3,canterbury large,72.03649244957784,1.8558953591013363,536.4011725412068,10.801484624490802,3.1726778814853143
+flate2 (zlib-ng),gzip / level 3,silesia,101.59596400471227,1.4851024360086083,452.5180611230531,7.518997984204076,2.923683903370675
+flate2 (zlib-ng),deflate / level 4,canterbury,92.72312444253527,1.836388697712691,551.4804217249317,22.33274255770008,3.731953205597165
+flate2 (zlib-ng),deflate / level 4,canterbury large,73.99780386763396,1.9061025775700366,564.9268982495163,13.791526755428027,3.368642938365764
+flate2 (zlib-ng),deflate / level 4,silesia,83.02709984296544,0.9152201955129917,480.05543971919485,7.7448567588430635,3.0362099617005778
+flate2 (zlib-ng),zlib / level 4,canterbury,92.625840736963,1.1615232619395257,526.9318257986627,11.865098401594093,3.7319234757485997
+flate2 (zlib-ng),zlib / level 4,canterbury large,74.70418808517972,0.6558459286394209,545.8163690859323,8.367830019035765,3.3686368371499404
+flate2 (zlib-ng),zlib / level 4,silesia,82.1450277778674,1.0445382392129674,465.7245909940651,3.5076188261131236,3.0362097007220394
+flate2 (zlib-ng),gzip / level 4,canterbury,93.89959077703077,0.6321057691610542,541.3200226186835,5.175235649405385,3.731864017472467
+flate2 (zlib-ng),gzip / level 4,canterbury large,73.61957586369158,1.8354745810766724,536.7507751280335,23.43213134392585,3.3686246347845956
+flate2 (zlib-ng),gzip / level 4,silesia,81.76557460045782,1.1261817857257346,464.71680346665454,12.02044747546229,3.0362091787650973
+flate2 (zlib-ng),deflate / level 5,canterbury,85.69904701196205,0.7726724641771295,560.3461123312732,11.237551247346671,3.75306136346339
+flate2 (zlib-ng),deflate / level 5,canterbury large,60.37062140047066,0.5841398661763625,596.7225053195771,7.314541667027879,3.4081070903828588
+flate2 (zlib-ng),deflate / level 5,silesia,76.1622339747168,1.0270050591435806,483.2598131140644,9.656542605783274,3.061127945533916
+flate2 (zlib-ng),zlib / level 5,canterbury,84.35101713574768,2.827647170790014,542.1864215418725,12.295935077562847,3.7530312963573706
+flate2 (zlib-ng),zlib / level 5,canterbury large,56.731741940630194,1.709088429191644,549.3577686568979,26.481543999688277,3.4081008453765103
+flate2 (zlib-ng),zlib / level 5,silesia,76.4321489456157,1.1405688608178626,469.65666559661435,9.336276715206731,3.061127680254131
+flate2 (zlib-ng),gzip / level 5,canterbury,85.89512932166934,1.5758865666910802,540.3609480768989,23.896166446524525,3.7529711635905785
+flate2 (zlib-ng),gzip / level 5,canterbury large,60.02242750597171,1.0076789052454147,574.7496252095245,10.942596955634645,3.408088355432473
+flate2 (zlib-ng),gzip / level 5,silesia,76.36285450420162,0.4590264428677377,467.7325684763323,9.266084249414916,3.0611271496946992
+flate2 (zlib-ng),deflate / level 6,canterbury,71.87083834378573,1.6184577433014968,551.8142217705113,50.23479073328634,3.7700457510290963
+flate2 (zlib-ng),deflate / level 6,canterbury large,27.33878806912687,0.5983613504766486,567.0875041199598,32.53723486346352,3.457943444507037
+flate2 (zlib-ng),deflate / level 6,silesia,64.76636968482214,0.5788728629882741,486.6849534238484,6.061728368168537,3.0754240987313812
+flate2 (zlib-ng),zlib / level 6,canterbury,74.48306167956052,0.6537545545434484,553.1970650719051,15.388891425964266,3.7700154111724964
+flate2 (zlib-ng),zlib / level 6,canterbury large,28.700181212443503,0.18498689891473755,593.9333136349906,8.064198127959344,3.4579370155254945
+flate2 (zlib-ng),zlib / level 6,silesia,64.72159167170042,1.0879095809560282,471.08707995008297,11.928196174930203,3.0754238309679782
+flate2 (zlib-ng),gzip / level 6,canterbury,71.98181153180441,3.5454909162773,541.9921738142436,43.008471801731204,3.769954732924253
+flate2 (zlib-ng),gzip / level 6,canterbury large,27.90718101201432,0.7627030871658543,579.7978223499509,30.919751139515945,3.4579241576341246
+flate2 (zlib-ng),gzip / level 6,silesia,64.75413521565305,1.3519066823712713,475.3513730590486,12.355110903773884,3.0754232954413125
+flate2 (zlib-ng),deflate / level 7,canterbury,47.32135762048675,0.16504831760882083,559.2434132733669,5.715283011518015,3.834389656310791
+flate2 (zlib-ng),deflate / level 7,canterbury large,16.334709818963006,0.07010404100075394,578.9722516422887,7.4833903077703585,3.4914099818913806
+flate2 (zlib-ng),deflate / level 7,silesia,47.73542393422366,0.5482878657295112,488.35090771292,15.95953365078241,3.100033140474407
+flate2 (zlib-ng),zlib / level 7,canterbury,46.27237108090362,0.501231089536904,528.6947638629345,6.918588897957791,3.8343582719916185
+flate2 (zlib-ng),zlib / level 7,canterbury large,15.858908060609213,0.3852969654343472,540.4972138902808,31.88826066094324,3.491403427866322
+flate2 (zlib-ng),zlib / level 7,silesia,47.08815131713277,0.49816932406841924,472.9061913519998,10.514195011673353,3.1000328684086615
+flate2 (zlib-ng),gzip / level 7,canterbury,46.7975064133052,0.21121304398231494,531.8573156272637,12.3864100816747,3.834295504894525
+flate2 (zlib-ng),gzip / level 7,canterbury large,16.03469881960699,0.1498967442369141,552.3071151031013,4.917202458786821,3.4913903198900225
+flate2 (zlib-ng),gzip / level 7,silesia,47.44767859459713,0.519148626783543,472.3936957936831,13.420241123706251,3.100032324277314
+flate2 (zlib-ng),deflate / level 8,canterbury,14.443350682880824,0.07310770907638277,562.7350426167493,14.721388463337084,3.8550837938256315
+flate2 (zlib-ng),deflate / level 8,canterbury large,12.371254225183488,0.06497305781580204,567.0245883403777,7.785910743405789,3.4940926428401906
+flate2 (zlib-ng),deflate / level 8,silesia,31.593304831151293,0.4152799191637254,498.5908205331694,8.245496730542067,3.1082580049179267
+flate2 (zlib-ng),zlib / level 8,canterbury,14.323100369400183,0.10625644172774905,546.548886157404,5.21594147208268,3.8550520698324138
+flate2 (zlib-ng),zlib / level 8,canterbury large,12.391682138556865,0.08838223212734891,538.3650942265872,20.768134865159993,3.494086078739566
+flate2 (zlib-ng),zlib / level 8,silesia,31.384911244795166,0.3611826018462693,473.0638512304964,15.901810391623036,3.1082577314066016
+flate2 (zlib-ng),gzip / level 8,canterbury,14.106375289740566,0.13097528380294093,524.1005529694071,29.726419584535794,3.854988623412318
+flate2 (zlib-ng),gzip / level 8,canterbury large,12.117222283198267,0.11908364489097015,521.2969301629578,26.855113716431436,3.4940729506123054
+flate2 (zlib-ng),gzip / level 8,silesia,31.187398010058068,0.2631677045384719,471.3653759375736,7.734020816519624,3.1082571843840956
+flate2 (zlib-ng),deflate / level 9,canterbury,7.647788711461644,0.10739678355875817,563.8651915485844,5.519915317500596,3.8592176623233976
+flate2 (zlib-ng),deflate / level 9,canterbury large,12.412459678861804,0.15480595693174318,573.3133611828567,6.748115915751182,3.4941900132290664
+flate2 (zlib-ng),deflate / level 9,silesia,22.60494543994534,0.16142194339417176,486.2319889633294,8.904659898640364,3.1097304210719705
+flate2 (zlib-ng),zlib / level 9,canterbury,7.51151154690657,0.05580796216627281,529.2496203001855,10.733594313750764,3.8591858702576833
+flate2 (zlib-ng),zlib / level 9,canterbury large,12.219587169340377,0.13541547293313821,541.6244292240195,6.890427988577175,3.4941834487625916
+flate2 (zlib-ng),zlib / level 9,silesia,22.603868951350155,0.10141654455756755,473.87559554155985,10.53762360687271,3.109730147301453
+flate2 (zlib-ng),gzip / level 9,canterbury,7.593070878662069,0.11547403028422175,536.6882069147634,11.219752473063162,3.859122287697639
+flate2 (zlib-ng),gzip / level 9,canterbury large,12.247900616387016,0.16994747895912127,534.670940777629,16.834785840695297,3.4941703199036365
+flate2 (zlib-ng),gzip / level 9,silesia,22.47992898855488,0.13594172077355474,475.95641430449865,11.173143949239996,3.1097295997605636
+zstd,level -50,canterbury,1327.223545244802,57.47602433347919,2463.241359673541,173.88363461869764,1.240977935738805
+zstd,level -50,canterbury large,569.9715636203969,6.136254134640573,1352.8781700771458,22.748480849935792,1.459624341176606
+zstd,level -50,silesia,1371.8009785867778,35.70761748624558,2831.8412175864682,111.78203395629573,1.2659810420069828
+zstd,level -20,canterbury,987.7378780191478,58.38253345606829,2530.228746596225,300.9476722174514,1.4079163940946116
+zstd,level -20,canterbury large,428.04206672680846,20.287306894744823,1058.1380878950492,48.4966035222143,1.7856182574181
+zstd,level -20,silesia,911.3089779178333,10.811927432671961,2002.7934667749776,73.4954218412484,1.591103759015699
+zstd,level -15,canterbury,855.8870378263936,46.67767115040504,2200.8446837187043,221.25516212925805,1.5960334017373174
+zstd,level -15,canterbury large,409.37828452752444,12.0274261563551,1039.0804420294387,44.88186682595156,1.9056375336490419
+zstd,level -15,silesia,811.1737291413789,16.78674623664541,1865.171785773235,69.62926502307292,1.6763641589770835
+zstd,level -10,canterbury,627.7629984393334,15.64528168085751,1651.8573344047632,135.0311551470788,1.977310187201156
+zstd,level -10,canterbury large,382.1971235901217,1.7927217719849313,1022.2011948056722,24.449501396537865,2.0897471981387654
+zstd,level -10,silesia,733.7383475963551,10.48295599621087,1812.4599089316855,49.75033213952498,1.7986625258169082
+zstd,level -5,canterbury,519.1194800612609,9.913077877704765,1482.084047476889,133.79712530762325,2.1326162862159124
+zstd,level -5,canterbury large,341.20879616862396,2.636080496506749,943.1511948478028,39.475564764675774,2.359989552966355
+zstd,level -5,silesia,594.8760107210447,6.240310251316563,1582.0027507834993,44.414910138954966,2.0560476484716648
+zstd,level -2,canterbury,454.3338324292091,11.810631864032226,1393.4743365016207,162.92221577527434,2.7325935676551163
+zstd,level -2,canterbury large,319.61608096090083,0.3409473058158483,904.9992057145089,26.51353224235712,2.6154224747873056
+zstd,level -2,silesia,524.7512557009898,8.081440802374502,1478.1090342793887,28.18327048783475,2.342665274130703
+zstd,level -1,canterbury,427.7937652882644,42.95669532680754,1405.2540249138783,137.94403904843853,3.1314298955887008
+zstd,level -1,canterbury large,292.6340004230798,24.684589158863677,795.8920548846963,95.29255117861966,2.6993210989068936
+zstd,level -1,silesia,466.7783518497215,17.273895935879462,1319.2193688544835,81.00622646216172,2.436329486514888
+zstd,level 0,canterbury,249.36820293370516,22.300921860259436,1082.0955154100352,71.81399529849804,4.387483083243709
+zstd,level 0,canterbury large,226.1872535282129,5.222810586058273,899.1648192358072,41.19476974595092,3.4607101235431625
+zstd,level 0,silesia,248.76156724795027,12.043769705147968,1013.6607099078573,34.83874034650536,3.1859403393573826
+zstd,level 1,canterbury,411.85207748131376,13.165458219009466,1171.5980639783356,176.13200962207844,4.018557411455556
+zstd,level 1,canterbury large,303.87247490231596,9.82560343112557,920.2261097055965,61.87967482638835,3.2112841013339533
+zstd,level 1,silesia,441.42108270820984,6.086397275503121,1141.0209445200426,16.13272745650099,2.88661458830749
+zstd,level 2,canterbury,344.65217432806213,7.460811716086204,1097.4095354347069,77.01988197978736,4.266248964091543
+zstd,level 2,canterbury large,293.6225659769736,5.326918661972212,821.6280779962333,44.72684259816202,3.3236266619649264
+zstd,level 2,silesia,372.10054221797117,10.31704402606675,1067.8845282144198,38.0182803697212,3.049522174774821
+zstd,level 3,canterbury,236.36200103518198,20.280464348787127,1039.8592222802224,65.31909819393363,4.387483083243709
+zstd,level 3,canterbury large,219.09259753128126,8.204935929383392,861.2368312355146,39.41623107898493,3.4607101235431625
+zstd,level 3,silesia,253.54865736639857,11.177658309854928,1022.5259174522305,63.10636704920543,3.1859403393573826
+zstd,level 4,canterbury,234.16650178551598,27.40512915228496,1059.3069131790987,85.67128368801299,4.4117026619789055
+zstd,level 4,canterbury large,211.62121427054802,6.103387396485224,858.2504367742747,58.219291054834386,3.499081918689602
+zstd,level 4,silesia,214.90371527220486,9.703405069311536,995.3427633405436,67.7837863254244,3.2444605333317127
+zstd,level 5,canterbury,133.60730823038026,4.583939347485195,1088.2431729026341,9.922279140701738,4.5031841929452705
+zstd,level 5,canterbury large,88.85800810910246,3.330320784174671,854.6092249320533,13.570956941511374,3.6208772079534506
+zstd,level 5,silesia,104.17881658129313,2.409680321515121,1030.0821034903922,14.631306954022074,3.3620395117957234
+zstd,level 6,canterbury,75.75797126327467,5.15336695726651,1067.1397599379845,98.37020686048639,4.633600886238088
+zstd,level 6,canterbury large,56.39043731116707,1.5538241952570542,850.7123237764381,64.34239710156437,3.706327652580086
+zstd,level 6,silesia,78.5449351215255,1.5317917923766138,1083.3157737270576,33.97009198924831,3.444006991995287
+zstd,level 7,canterbury,64.11722995039362,4.598266381280746,1104.2466796953936,70.20122105874256,4.671443173036173
+zstd,level 7,canterbury large,49.69085955705142,0.7040500974373312,877.1048358514498,53.294109923050506,3.7747690975481465
+zstd,level 7,silesia,63.70480427428334,1.345717233011915,1071.2431206318404,37.36144017585489,3.50061769947886
+zstd,level 8,canterbury,51.108102709758676,2.678968591513762,1180.6645575408163,19.13221543507627,4.677864892347583
+zstd,level 8,canterbury large,37.85702997233084,0.8775925323577433,937.6380280614947,117.83393919780575,3.807481912768451
+zstd,level 8,silesia,54.68091349040518,1.296696242958401,1116.536395383344,31.296050789023404,3.531553384509374
+zstd,level 9,canterbury,50.261699636341156,1.2285806325887345,1184.3260130722233,27.687140459579194,4.678534512461238
+zstd,level 9,canterbury large,37.61958955592905,0.7588283110291547,1046.3922531673525,67.18223358606107,3.8137758885724264
+zstd,level 9,silesia,50.467637892306534,0.7330468757430252,1108.9136631532554,36.02934424036638,3.569615720562263
+zstd,level 10,canterbury,38.96695045111459,1.0050011735717512,1202.615839298007,11.195055521790856,4.697487628664397
+zstd,level 10,canterbury large,26.85638007170466,1.2416517620210326,1036.913379215882,98.37866721777203,3.8715803789190297
+zstd,level 10,silesia,34.791305451004796,1.0067700495662313,1042.6356060197352,62.228146632370844,3.6121547213116356
+zstd,level 11,canterbury,23.730343152873225,2.0860013488342792,1176.0034905670955,51.80436634481572,4.706761780367728
+zstd,level 11,canterbury large,17.46334787533101,0.7573276438223301,1112.0682523500313,106.97678769240669,3.915429120776947
+zstd,level 11,silesia,24.078806693578098,0.4166834241610925,1057.7748157160333,52.27770926807345,3.6377913683321053
+zstd,level 12,canterbury,22.355566828738706,1.1379985756954956,1158.7776842365809,51.950606101633866,4.706438655037248
+zstd,level 12,canterbury large,16.92701393922555,0.3623026200874341,1104.4891274633185,86.15352108311974,3.9171704641465737
+zstd,level 12,silesia,22.492520269157048,0.5866697237373059,1070.2566023292038,89.11565290370075,3.6412573613585923
+zstd,level 13,canterbury,14.524676571808213,1.0234860259075083,1085.2995558343114,188.8556842505444,4.736456837805593
+zstd,level 13,canterbury large,7.759619099134421,0.23524931635275317,1137.7686824258285,78.6973363254869,3.9393725022565955
+zstd,level 13,silesia,11.04324923893043,0.09724957896828508,1115.4593382842093,70.39175862844606,3.655105809503142
+zstd,level 14,canterbury,14.864802369413455,1.097221611065519,1166.4858102358285,134.90768538097055,4.740346977564681
+zstd,level 14,canterbury large,4.03188092573423,0.06329229100106581,1154.0193885754843,156.29631744768594,4.035799492463807
+zstd,level 14,silesia,9.116184047609728,0.1423558389200522,1122.4898168014067,59.8435527780136,3.6810879530596137
+zstd,level 15,canterbury,12.717233856687082,0.8371029326972916,1208.3459295509228,18.697771355096616,4.740586825519169
+zstd,level 15,canterbury large,3.432380492011614,0.08181218559781703,1163.739617585653,100.67199737592242,4.053228331928318
+zstd,level 15,silesia,7.1265025097021475,0.06467334915521429,1046.5870625995017,56.16278559313005,3.707334406952665
+zstd,level 16,canterbury,7.137362682591493,0.38974450184366044,872.3854879462597,95.70372353320808,5.32436210717736
+zstd,level 16,canterbury large,2.769698321252809,0.06760684528052725,1370.2777558678931,121.60607525574054,4.35171354724792
+zstd,level 16,silesia,5.018128708945305,0.042131180415675,1062.5445735924375,30.127598065656354,3.8304466740289187
+zstd,level 17,canterbury,6.591752718536426,0.11307941277341949,870.2119985909569,136.60780467556773,5.385530949543411
+zstd,level 17,canterbury large,2.4312632277519377,0.05389301947588422,1438.251803456262,36.83955393251378,4.359276529636058
+zstd,level 17,silesia,4.007558969663819,0.029211749920839004,992.7190527231069,44.52645724114276,3.904869633891238
+zstd,level 18,canterbury,4.335773483172369,0.2389775834939416,891.270512276843,27.421352263320493,5.378821773367906
+zstd,level 18,canterbury large,2.082616810248283,0.07403060078146262,1382.1368663103879,91.8609324006007,4.383304803869428
+zstd,level 18,silesia,3.0347323441534466,0.02352181481333779,874.0220052987924,46.037025122651066,3.967470715418349
+zstd,level 19,canterbury,3.0368200273594637,0.06890312139862344,818.4598137416149,143.45573191116662,5.402901759970475
+zstd,level 19,canterbury large,2.007809297482111,0.03169503645189214,1421.0606494051653,70.7074248935714,4.382311603886615
+zstd,level 19,silesia,2.4140086792371385,0.01808571212093964,843.6622321888592,57.379454775824186,3.9995735822865974
+zstd,level 20,canterbury,2.904371648331409,0.13998199169941472,882.4209046924085,41.100853953345464,5.402901759970475
+zstd,level 20,canterbury large,1.9496239916570157,0.035351416190471975,1404.6435044206864,85.54358568010689,4.382187700638706
+zstd,level 20,silesia,2.299706156260346,0.008600622184181578,869.8549940806774,46.49254972536846,4.031111779100137
+zstd,level 21,canterbury,2.810676543954867,0.14588333304252238,879.810689254439,52.05907276029601,5.403275663206459
+zstd,level 21,canterbury large,1.9855733891963308,0.03994018341006588,1359.1748557901356,156.595923464002,4.381822915091957
+zstd,level 21,silesia,2.076684124591406,0.011991967257030934,870.1498052844986,21.270922387163555,4.038898085020842
+zstd,level 22,canterbury,1.8155633995333202,0.0409268661733273,854.2106849026037,128.97065589690735,5.403483409588988
+zstd,level 22,canterbury large,1.9421795497298986,0.05174017203909077,1409.7698622411601,56.62144142197193,4.3841692713612455
+zstd,level 22,silesia,1.7966611759751139,0.01736356619113514,853.8718474928814,41.24744759765682,4.04017555837539
+lzma-rs,Lzma,canterbury,45.08562346041915,0.8088421393022583,26.326369702249274,0.26296265596108154,2.464990239256605
+lzma-rs,Lzma,canterbury large,41.070205588586774,1.6884130719126669,25.010958184512816,0.6608251322889568,2.34328491719589
+lzma-rs,Lzma,silesia,36.83663921521552,0.4395141632214569,23.43811245738209,0.23247567500610158,1.872226165588074
+lzma-rs,Lzma2,canterbury,10070.34894010728,2189.963125097715,10028.896489288296,904.6898945983124,0.9999537516978463
+lzma-rs,Lzma2,canterbury large,5869.83396164717,1798.7698186272537,4146.16585481724,470.96700443323596,0.9999539426358217
+lzma-rs,Lzma2,silesia,4346.225038810228,105.03578229448578,4159.418881441432,145.0525189872039,0.9999542199641221
+lzma-rs,Xz,canterbury,6477.728124284752,1087.0090260026986,3671.804086401676,388.10266071424957,0.9999345421221444
+lzma-rs,Xz,canterbury large,6320.929938670823,777.8695469102845,1764.157248730723,200.35392870850916,0.9999492833722579
+lzma-rs,Xz,silesia,4399.348984498784,163.8402511739866,2028.462161865748,55.54768625773797,0.9999539699146305
+snap,Raw,canterbury,569.9530316334728,19.41913923514639,1453.4521807760007,150.57456467752522,2.201268234691552
+snap,Raw,canterbury large,501.62349574893295,6.466839427739747,1336.3242300641234,93.56734067460769,2.0664264735591606
+snap,Raw,silesia,562.1102757541865,5.600587385986636,1456.4613675512921,26.721728205363082,2.0749337676684205
+snap,Frame,canterbury,535.4725985064981,27.670153311275552,1084.2307123286582,148.11965291654258,2.200442784091087
+snap,Frame,canterbury large,459.6197386263619,16.572874416132457,973.8817465392171,48.957013872251544,2.065704674928882
+snap,Frame,silesia,525.1179330779034,11.783781034163866,1179.836759863557,27.967986855776164,2.056819989225545
+tetsy_snappy,,canterbury,480.35495794084517,18.552035988728157,983.054906422915,124.7731938702944,2.201268234691552
+tetsy_snappy,,canterbury large,443.92782518089007,25.386839303513316,887.365708866809,50.52058004102968,2.0664264735591606
+tetsy_snappy,,silesia,551.8743264053089,10.545508184453725,904.3888452674312,17.42882258185808,2.0749337676684205
+xsnappy,,canterbury,440.0623432865805,50.071420233698845,801.128461585902,78.57567682879028,2.201268234691552
+xsnappy,,canterbury large,412.39495568921006,13.001242910669935,829.7260235042505,71.85154107122811,2.0664264735591606
+xsnappy,,silesia,472.4657006808561,5.171170025895395,858.7001033903474,25.180884273574318,2.0749337676684205
+brotlic,quality 0 / Worst window size / Worst block size,canterbury,78.55635854090475,2.042681579349955,183.89095558965354,9.576639439325678,2.334815513802719
+brotlic,quality 0 / Worst window size / Worst block size,canterbury large,77.51063600038724,1.1983313792834247,168.8517662681893,2.610487300310932,1.9691499635531537
+brotlic,quality 0 / Worst window size / Worst block size,silesia,67.35304018813125,0.5702319896312843,176.0274022323901,2.3900753755003765,1.7289538694412454
+brotlic,quality 0 / Worst window size / Best block size,canterbury,80.8008738626126,0.900599685726317,191.90635204031912,3.9378778511506156,2.334815513802719
+brotlic,quality 0 / Worst window size / Best block size,canterbury large,79.659789201059,0.8274479840264255,176.46947491470755,5.090180314133181,1.9691499635531537
+brotlic,quality 0 / Worst window size / Best block size,silesia,67.13531345796561,0.7815887445551072,175.02397377565055,2.9428644117446257,1.7289538694412454
+brotlic,quality 0 / Best window size / Worst block size,canterbury,379.7221394484737,15.797581404469398,356.70235538095164,9.668286271330748,3.323292144675407
+brotlic,quality 0 / Best window size / Worst block size,canterbury large,345.50462721984286,7.036857149314023,320.08913110973634,4.322623215001773,2.931823531760794
+brotlic,quality 0 / Best window size / Worst block size,silesia,380.5527928700847,3.0065690727559953,351.33597116181363,4.422359809307079,2.7087583317019623
+brotlic,quality 0 / Best window size / Best block size,canterbury,390.8330860325601,10.282283495281519,353.9319066075512,4.867235843051275,3.323292144675407
+brotlic,quality 0 / Best window size / Best block size,canterbury large,345.3617979967949,11.171439859454917,322.17079378058634,6.821335432695666,2.931823531760794
+brotlic,quality 0 / Best window size / Best block size,silesia,370.25302362704684,15.219216835660552,344.51245219235807,8.182195683408095,2.7087583317019623
+brotlic,quality 1 / Worst window size / Worst block size,canterbury,98.2480326697255,1.2488452896860553,192.45130984198678,5.040938342860215,2.5990065502587187
+brotlic,quality 1 / Worst window size / Worst block size,canterbury large,87.44155241357497,1.9176464862077875,162.60335219253744,5.836690802132114,2.0605900688612477
+brotlic,quality 1 / Worst window size / Worst block size,silesia,81.43917262148048,0.9901133706033941,179.86351075762778,2.445385935387577,1.8495415529643473
+brotlic,quality 1 / Worst window size / Best block size,canterbury,100.33794673719652,2.7686552766709522,190.89926265223713,5.7007074546025684,2.5990065502587187
+brotlic,quality 1 / Worst window size / Best block size,canterbury large,92.01077697744141,1.3827171410501133,171.08840373584755,4.570419011862849,2.0605900688612477
+brotlic,quality 1 / Worst window size / Best block size,silesia,81.85017438923393,0.9711939690001167,181.10875423633428,2.6528071937116504,1.8495415529643473
+brotlic,quality 1 / Best window size / Worst block size,canterbury,274.17487608693887,8.782282511561423,387.50918175124883,7.765491062148492,3.7868223007218553
+brotlic,quality 1 / Best window size / Worst block size,canterbury large,242.8221435455853,8.940587466086633,344.80528410791544,9.707528117724971,3.2213827763488725
+brotlic,quality 1 / Best window size / Worst block size,silesia,260.2627104686256,6.309579749310763,365.513981016075,7.717239011436056,2.888414606415575
+brotlic,quality 1 / Best window size / Best block size,canterbury,277.17679575482924,6.926162153290385,384.2009219851548,3.661797698341066,3.7868223007218553
+brotlic,quality 1 / Best window size / Best block size,canterbury large,241.11731907500916,6.789422902064679,341.5442786123166,7.9875524209870585,3.2213827763488725
+brotlic,quality 1 / Best window size / Best block size,silesia,257.54275891139093,4.866967596983935,368.20040475161875,3.9715239078132174,2.888414606415575
+brotlic,quality 2 / Worst window size / Worst block size,canterbury,131.9685803272555,6.802976595739093,381.75506573389157,17.135423364493874,3.4166520800513447
+brotlic,quality 2 / Worst window size / Worst block size,canterbury large,94.11790616431598,1.2567716462773573,274.2871270174957,4.9220764704375854,2.6438487506168675
+brotlic,quality 2 / Worst window size / Worst block size,silesia,130.80748855519292,2.650505712062312,299.08092723684706,5.161221380608324,2.363754155697026
+brotlic,quality 2 / Worst window size / Best block size,canterbury,141.2842356407035,1.5325599728553745,394.89220156018894,6.309069778711462,3.4166520800513447
+brotlic,quality 2 / Worst window size / Best block size,canterbury large,99.79048077874987,0.35507282983131466,286.28945949334894,3.4587253638966136,2.6438487506168675
+brotlic,quality 2 / Worst window size / Best block size,silesia,131.0502675591263,1.8133393377066898,294.8596290806428,7.095276305920204,2.363754155697026
+brotlic,quality 2 / Best window size / Worst block size,canterbury,153.44460442747214,3.0685227646783217,441.9704141550152,7.273240092096655,4.227976281802511
+brotlic,quality 2 / Best window size / Worst block size,canterbury large,123.91487020406265,3.394857215591031,330.40950811343805,11.650241875858319,3.3442652329212046
+brotlic,quality 2 / Best window size / Worst block size,silesia,147.0572347895638,5.092648401830754,396.18242256583284,13.058646509024646,3.115045299270495
+brotlic,quality 2 / Best window size / Best block size,canterbury,149.8750492258541,13.896275921497125,451.0300957954786,12.705520836679348,4.227976281802511
+brotlic,quality 2 / Best window size / Best block size,canterbury large,124.97496340299583,2.783087690624848,325.71753291072673,23.744397170067895,3.3442652329212046
+brotlic,quality 2 / Best window size / Best block size,silesia,147.26442091046664,4.529130824569719,404.28186253789266,4.114283398662847,3.115045299270495
+brotlic,quality 3 / Worst window size / Worst block size,canterbury,95.42585070801739,9.461600767476236,371.91882633227715,49.84387694084871,3.4507962854743583
+brotlic,quality 3 / Worst window size / Worst block size,canterbury large,69.47183792596067,2.955601333535497,276.50474275588647,10.282290290853313,2.656651387831496
+brotlic,quality 3 / Worst window size / Worst block size,silesia,96.62015217466562,2.23898976368754,304.2630154971133,3.941472906102116,2.3865784612406937
+brotlic,quality 3 / Worst window size / Best block size,canterbury,95.68389007331272,3.9706181297760494,394.6447916528745,9.602080339700978,3.4507962854743583
+brotlic,quality 3 / Worst window size / Best block size,canterbury large,68.13970521808767,2.3495318912880285,275.6126303204172,16.413550925906225,2.656651387831496
+brotlic,quality 3 / Worst window size / Best block size,silesia,96.19244635922155,1.303333495061928,300.2922602154155,4.693894739956739,2.3865784612406937
+brotlic,quality 3 / Best window size / Worst block size,canterbury,125.62396236697901,2.366393741090843,460.18055455251823,11.244902011055485,4.213569907012513
+brotlic,quality 3 / Best window size / Worst block size,canterbury large,100.68044605857033,3.386426496683416,342.7242994509781,13.990444190533614,3.334303991490557
+brotlic,quality 3 / Best window size / Worst block size,silesia,122.88284292386768,3.3887015401993597,418.4713986888609,5.024296038462421,3.146827354204993
+brotlic,quality 3 / Best window size / Best block size,canterbury,121.9264346013363,5.868473075972684,464.129897960056,15.231316423591355,4.213569907012513
+brotlic,quality 3 / Best window size / Best block size,canterbury large,100.08097727383513,7.297928926444963,341.9520061290956,13.31299523991172,3.334303991490557
+brotlic,quality 3 / Best window size / Best block size,silesia,122.58527170745373,5.0347254824819085,418.05978488995055,10.781044724403209,3.146827354204993
+brotlic,quality 4 / Worst window size / Worst block size,canterbury,79.31342539648583,3.8758067000659215,449.916182055049,7.662770589922602,3.2478054540979686
+brotlic,quality 4 / Worst window size / Worst block size,canterbury large,36.85050369831081,1.6653546458168718,334.18311945581235,3.7308295557486164,2.646073599353531
+brotlic,quality 4 / Worst window size / Worst block size,silesia,60.797218894376456,1.7289670399618775,315.7292153634511,5.566426355733297,2.3117319294465246
+brotlic,quality 4 / Worst window size / Best block size,canterbury,72.47785791189223,4.491537000232533,454.02227366543826,5.039746546026959,3.244671161764655
+brotlic,quality 4 / Worst window size / Best block size,canterbury large,34.486290024785774,1.8823780644115728,333.99445961294794,8.833168299268328,2.6538563797530847
+brotlic,quality 4 / Worst window size / Best block size,silesia,43.19319935286921,0.8525787160687871,326.9360430332019,4.259244343762598,2.269870812383467
+brotlic,quality 4 / Best window size / Worst block size,canterbury,65.43580406611663,3.6870792881015446,558.8321584139485,8.992583480618686,4.699553248976753
+brotlic,quality 4 / Best window size / Worst block size,canterbury large,46.73502097494069,2.0958757334877545,541.6358704905795,11.488736579887835,3.6268282045132056
+brotlic,quality 4 / Best window size / Worst block size,silesia,48.11778050815236,2.144781927915214,442.0483995967857,10.24932863915673,3.298453235443392
+brotlic,quality 4 / Best window size / Best block size,canterbury,69.79800340979016,8.147025658439249,523.013553143704,22.67515143052027,4.702139796944294
+brotlic,quality 4 / Best window size / Best block size,canterbury large,57.788424118589305,3.0258548011755355,530.167569516516,20.841655187991893,3.6274094056330823
+brotlic,quality 4 / Best window size / Best block size,silesia,49.32212636608359,2.11652515150317,435.3105354385574,14.062721753833072,3.264886965278941
+brotlic,quality 5 / Worst window size / Worst block size,canterbury,45.624716228561844,1.5679882761880646,291.7424102098539,7.314658544632572,3.8457583266176756
+brotlic,quality 5 / Worst window size / Worst block size,canterbury large,42.34627055522532,0.2917818684555881,236.67171235942575,1.0240028676061839,2.82151591714775
+brotlic,quality 5 / Worst window size / Worst block size,silesia,44.591440736140314,0.5516740352556321,244.33915805071302,2.600432172596187,2.6388944469763316
+brotlic,quality 5 / Worst window size / Best block size,canterbury,48.030208070769575,0.6383981447624871,287.824440961895,20.11231514457909,3.8557765645148017
+brotlic,quality 5 / Worst window size / Best block size,canterbury large,42.73092570481819,0.26932468089268713,238.52827393901975,2.6797614263408547,2.8377374553976473
+brotlic,quality 5 / Worst window size / Best block size,silesia,50.32356503786626,0.8590042916755212,268.40001052699847,4.198140319074139,2.598025842623671
+brotlic,quality 5 / Best window size / Worst block size,canterbury,35.5356442891246,0.7529901078596343,498.4405806176538,11.64177356579023,4.680170437232443
+brotlic,quality 5 / Best window size / Worst block size,canterbury large,24.81762578905932,0.479614769791183,437.3054862668413,5.5170843180082025,3.771248303957798
+brotlic,quality 5 / Best window size / Worst block size,silesia,32.80107516226273,0.7344432945074827,437.66974909789246,10.572174116502456,3.5509043917864354
+brotlic,quality 5 / Best window size / Best block size,canterbury,34.441745444460025,3.409483904484973,476.5125505505887,29.695099635353937,4.686881891838262
+brotlic,quality 5 / Best window size / Best block size,canterbury large,28.66160804292059,1.168675405899906,474.2445562452324,28.857473983727093,3.77193026337137
+brotlic,quality 5 / Best window size / Best block size,silesia,33.67195471951838,0.59079237136315,460.36220633176634,7.838835880632798,3.541656333842098
+brotlic,quality 6 / Worst window size / Worst block size,canterbury,40.34916636559724,3.042426098460132,276.33495551244016,14.196372204196804,3.8474059838536148
+brotlic,quality 6 / Worst window size / Worst block size,canterbury large,42.03221698665147,0.6842222639999502,239.78846085558789,3.1664571530519146,2.8223529602191624
+brotlic,quality 6 / Worst window size / Worst block size,silesia,43.61747605189058,0.9243422646407647,242.6791008166435,4.812357289690008,2.6391823754733164
+brotlic,quality 6 / Worst window size / Best block size,canterbury,45.39267590516329,1.1984320593181017,293.94462949303846,4.113521225938136,3.857094044304414
+brotlic,quality 6 / Worst window size / Best block size,canterbury large,42.41241706999588,0.20964660438425875,240.3242527301615,1.8225912339924233,2.8388563863750953
+brotlic,quality 6 / Worst window size / Best block size,silesia,49.20499342032795,1.0769427892277776,268.78020867904013,6.706210849487289,2.5997034792248517
+brotlic,quality 6 / Best window size / Worst block size,canterbury,27.69966764971859,0.9363800699116558,510.0466646584799,22.94755119267593,4.7337287673170785
+brotlic,quality 6 / Best window size / Worst block size,canterbury large,19.257373325138396,0.4304990786143088,519.7355313500916,8.262464232173869,3.8479260750125253
+brotlic,quality 6 / Best window size / Worst block size,silesia,20.731728870094518,0.7686900867648367,463.3997984163401,6.524968423439918,3.618294577793718
+brotlic,quality 6 / Best window size / Best block size,canterbury,32.83691777822696,0.6520052193520582,524.8753127524569,14.560116661267589,4.739403811036527
+brotlic,quality 6 / Best window size / Best block size,canterbury large,21.82176004618595,0.3497907853060044,515.575489945506,8.683792254703768,3.8480255884890417
+brotlic,quality 6 / Best window size / Best block size,silesia,21.866109146942648,0.7346069007822289,467.5285641705621,13.628464549225844,3.6143432713545653
+brotlic,quality 7 / Worst window size / Worst block size,canterbury,37.26146477794178,0.32837386583403694,288.194994784831,16.27950296290538,3.8484648086915447
+brotlic,quality 7 / Worst window size / Worst block size,canterbury large,37.83755761303082,0.6670732614085807,235.8000028791691,3.63756796528441,2.817065748469285
+brotlic,quality 7 / Worst window size / Worst block size,silesia,40.1342515375905,0.5797386503389099,242.02821540378866,4.092268972144584,2.638917480258445
+brotlic,quality 7 / Worst window size / Best block size,canterbury,39.44344517551314,0.7604405837558688,295.60375419279933,7.930490680199379,3.856559536354057
+brotlic,quality 7 / Worst window size / Best block size,canterbury large,37.782140159366435,0.5579249051996964,232.81953857921232,5.144667182960576,2.8335640577708263
+brotlic,quality 7 / Worst window size / Best block size,silesia,44.63253950581626,0.7519437168018758,268.04437898431115,5.442012531384943,2.6023922154036843
+brotlic,quality 7 / Best window size / Worst block size,canterbury,21.376739834467802,0.5388695646280403,507.8401743162775,42.74219264279007,4.76766895484869
+brotlic,quality 7 / Best window size / Worst block size,canterbury large,12.313539582553858,0.44047284198340303,480.44159087509007,34.6510101663041,3.9097540629520644
+brotlic,quality 7 / Best window size / Worst block size,silesia,10.720747752605904,0.13636338157550984,452.0647435241275,9.777746271439659,3.6724860093183413
+brotlic,quality 7 / Best window size / Best block size,canterbury,20.84489356550902,0.9255428085125269,515.4326325455391,16.90400951009648,4.768785215120807
+brotlic,quality 7 / Best window size / Best block size,canterbury large,13.491521192175659,0.19267194867413318,526.1930396322425,9.878076381244062,3.910322609581716
+brotlic,quality 7 / Best window size / Best block size,silesia,10.818189754154625,0.27554463810416513,464.12578835207955,11.437934555199977,3.671034257869488
+brotlic,quality 8 / Worst window size / Worst block size,canterbury,35.11485287623457,2.485915183463046,291.7880346422202,17.435240011837674,3.8538839331009767
+brotlic,quality 8 / Worst window size / Worst block size,canterbury large,38.959868748090145,0.6293233449949266,239.91344462675366,3.306626781772729,2.817087793719016
+brotlic,quality 8 / Worst window size / Worst block size,silesia,39.85186842286128,0.49291312028191,239.9073611160377,4.559483388180658,2.639149379794495
+brotlic,quality 8 / Worst window size / Best block size,canterbury,37.33715490429912,0.3508115071488621,290.6207836775556,3.4976415561148175,3.860797327589996
+brotlic,quality 8 / Worst window size / Best block size,canterbury large,38.13109484369347,0.622161243393203,236.35514421052648,1.8962034417111344,2.8335885204883544
+brotlic,quality 8 / Worst window size / Best block size,silesia,43.73615644491427,0.48006156816747736,264.21576559182876,5.042647894535941,2.5996444863604595
+brotlic,quality 8 / Best window size / Worst block size,canterbury,17.76193682549289,0.4166681707472771,494.34611991012196,47.67589852671647,4.777912821462993
+brotlic,quality 8 / Best window size / Worst block size,canterbury large,8.548685790921871,0.1519795596050947,475.13846036120145,15.650817856081146,3.9581179056044373
+brotlic,quality 8 / Best window size / Worst block size,silesia,5.4287550454616245,0.09965723005245788,451.5966525125312,12.477556082995832,3.716918736850878
+brotlic,quality 8 / Best window size / Best block size,canterbury,17.306028712517055,0.41513996427893923,515.6690800520405,22.86238853085622,4.779830320839519
+brotlic,quality 8 / Best window size / Best block size,canterbury large,9.11250243839262,0.1853827558433756,549.8169051708637,12.586822077646657,3.958115097824248
+brotlic,quality 8 / Best window size / Best block size,silesia,5.408983958995606,0.13057230743203158,456.5753866998881,18.047477847729493,3.7150544325555517
+brotlic,quality 9 / Worst window size / Worst block size,canterbury,33.20681057445384,0.6189461430795449,296.04159574723303,5.479621951302367,3.852098739714613
+brotlic,quality 9 / Worst window size / Worst block size,canterbury large,34.82918510045095,0.4913479936107853,237.39948119029083,3.2864797586853216,2.8137600260612667
+brotlic,quality 9 / Worst window size / Worst block size,silesia,34.47196471172634,0.4737655106767261,238.21668436078966,5.06242290235578,2.649183339452595
+brotlic,quality 9 / Worst window size / Best block size,canterbury,34.344186760188585,0.3797064263210012,299.8082148573838,5.775577938720112,3.86004974092695
+brotlic,quality 9 / Worst window size / Best block size,canterbury large,35.25870034692899,0.1923134818569406,239.14435827830226,3.3277038337084037,2.8296848735926674
+brotlic,quality 9 / Worst window size / Best block size,silesia,37.420287306319146,0.3340113009345118,266.5096643560923,2.4576016115553307,2.6123731023313113
+brotlic,quality 9 / Best window size / Worst block size,canterbury,14.045212825142777,0.4733810436149178,508.1603656818803,17.63737736956801,4.776183517417162
+brotlic,quality 9 / Best window size / Worst block size,canterbury large,5.327826924178193,0.11903107727191904,536.3338400926556,38.68678958859182,3.996784516397068
+brotlic,quality 9 / Best window size / Worst block size,silesia,2.5743905661731916,0.02881930760884872,434.21120915654154,24.992843793390744,3.7549134525096113
+brotlic,quality 9 / Best window size / Best block size,canterbury,14.116342249146353,0.4359055127235257,512.6972574640467,29.016542969432034,4.7844434912269955
+brotlic,quality 9 / Best window size / Best block size,canterbury large,5.500330906360289,0.14168518187614768,554.6388402487478,26.609763960338885,3.9979099561535025
+brotlic,quality 9 / Best window size / Best block size,silesia,2.584106928718233,0.02421944146505,443.08106923624695,18.39561444848893,3.751457695526085
+brotlic,quality 10 / Worst window size / Worst block size,canterbury,2.538078018450458,0.028442703183123922,268.845884615429,6.81302168516777,4.472252718403039
+brotlic,quality 10 / Worst window size / Worst block size,canterbury large,2.0427511594106114,0.01259563321798413,241.96857937528955,3.494489764685689,3.330023645458962
+brotlic,quality 10 / Worst window size / Worst block size,silesia,1.576023388200083,0.00393594506850457,206.8254927780547,4.310393669375309,3.001199326596256
+brotlic,quality 10 / Worst window size / Best block size,canterbury,2.3095908187899457,0.04882244517034004,287.54104233997157,4.565635529907229,4.3420319675967765
+brotlic,quality 10 / Worst window size / Best block size,canterbury large,1.8121814044368114,0.02345333088796893,183.1685267413534,7.839609432206828,3.2298391951654355
+brotlic,quality 10 / Worst window size / Best block size,silesia,0.8295703793877812,0.002782922017803392,211.20393291965829,2.9392428191799773,2.989112879539594
+brotlic,quality 10 / Best window size / Worst block size,canterbury,1.2512729038666794,0.03172381532815749,397.79945502638765,72.05002649550448,5.426999223827342
+brotlic,quality 10 / Best window size / Worst block size,canterbury large,1.1506704314753102,0.01888710357427953,365.0723453808807,8.440259345962048,4.389299366865309
+brotlic,quality 10 / Best window size / Worst block size,silesia,0.9294254914583866,0.003929418847108762,356.37313279910535,13.66922297958839,4.131077306376869
+brotlic,quality 10 / Best window size / Best block size,canterbury,1.3377779355900234,0.03486831591429619,398.25206903357207,9.21071630746393,5.427219277666754
+brotlic,quality 10 / Best window size / Best block size,canterbury large,1.168097188871384,0.024380402084925652,281.6446377842662,7.323228841308682,4.163261910429007
+brotlic,quality 10 / Best window size / Best block size,silesia,0.9612530730888429,0.00406003794575011,341.0706267522662,8.700182550894464,4.074303223926966
+brotlic,quality 11 / Worst window size / Worst block size,canterbury,0.8669367626484802,0.02383909669256715,288.37951859549116,5.632406440350857,4.589087548755659
+brotlic,quality 11 / Worst window size / Worst block size,canterbury large,0.7493694179965594,0.007736112558289102,247.19679429660255,4.774356039486007,3.3824627532948717
+brotlic,quality 11 / Worst window size / Worst block size,silesia,0.6144646169626391,0.0072127126183956025,208.526376407872,6.0177641115273754,3.0528697081100518
+brotlic,quality 11 / Worst window size / Best block size,canterbury,0.7846503071592943,0.019039338587165142,281.0628481244757,11.29627532219462,4.506021315070601
+brotlic,quality 11 / Worst window size / Best block size,canterbury large,0.6705582662199765,0.0029720931315525357,181.23004814213562,4.520201842609082,3.245039163276083
+brotlic,quality 11 / Worst window size / Best block size,silesia,0.4314013350885589,0.007614231670399484,215.7814805300745,5.850282798182687,3.0540905482382885
+brotlic,quality 11 / Best window size / Worst block size,canterbury,0.5958752451061351,0.007701047045544648,478.6900626615248,27.157244586943886,5.701133012319937
+brotlic,quality 11 / Best window size / Worst block size,canterbury large,0.5417784303927187,0.01282019037951642,387.990206118448,15.324849043046294,4.44593968460251
+brotlic,quality 11 / Best window size / Worst block size,silesia,0.4985065608139016,0.008921362071715004,379.2129947519828,30.62374108945709,4.264866784502328
+brotlic,quality 11 / Best window size / Best block size,canterbury,0.5333790357668134,0.006646312957921696,444.35518276037936,37.65764468668253,5.541930459299861
+brotlic,quality 11 / Best window size / Best block size,canterbury large,0.5002974475767124,0.00804231339841832,291.94147615279195,6.682010148455028,4.183446652768682
+brotlic,quality 11 / Best window size / Best block size,silesia,0.5487929288948116,0.016527457563557803,368.5277532566459,27.58426331229691,4.188217469738474
+rust-lzma,extreme 0,canterbury,2.380347425247497,0.04441289637140305,102.66264214960098,1.0531192236786941,5.744312468834046
+rust-lzma,extreme 0,canterbury large,3.1997841141605745,0.06424045003318019,89.65049283846082,0.6371875008748252,4.142119141190462
+rust-lzma,extreme 0,silesia,3.541690246781718,0.09794826772778188,70.79183912558238,1.149780662582811,4.001048805118054
+rust-lzma,extreme 1,canterbury,1.9174198363915966,0.04909316507293221,101.78752159518663,3.377951852620338,5.782126076903455
+rust-lzma,extreme 1,canterbury large,2.284398463092673,0.09383365565825522,98.44877843245291,2.3916645256068674,4.308680308880309
+rust-lzma,extreme 1,silesia,2.7239445856397353,0.02499773353918884,74.15039241782277,0.8339953693170632,4.1631112167468425
+rust-lzma,extreme 2,canterbury,1.85525434409369,0.06422604643916152,102.73091156330713,3.0771671964392193,5.812544977790277
+rust-lzma,extreme 2,canterbury large,1.9697143073226733,0.0590315608497843,100.69561777810026,2.3022140841678858,4.3561097665703805
+rust-lzma,extreme 2,silesia,2.621547594275378,0.07560925953269917,77.59375210494267,0.5476518640838612,4.231813482998715
+rust-lzma,extreme 3,canterbury,2.8827509131981195,0.049378075579396025,105.48658851913744,1.1563693245568918,5.8072609770005705
+rust-lzma,extreme 3,canterbury large,2.089390023969548,0.012709174325439568,103.55434482791767,1.2836100670688033,4.368736092602713
+rust-lzma,extreme 3,silesia,2.636349048762365,0.01810667876529013,79.10291703613811,0.8288289103775921,4.288570827535002
+rust-lzma,extreme 4,canterbury,2.1255426061406464,0.07253652183791712,106.25884626113637,1.4243383419096098,5.812112289292154
+rust-lzma,extreme 4,canterbury large,2.0705364435843956,0.10811879425445138,101.69643258934597,4.542482287811154,4.3703922726624755
+rust-lzma,extreme 4,silesia,2.375384196401571,0.05495159999303099,77.96359219590336,1.051899804488133,4.289789205057913
+rust-lzma,extreme 5,canterbury,2.59857787673331,0.30927875687122497,101.81712269050726,4.353338356821259,5.8072609770005705
+rust-lzma,extreme 5,canterbury large,2.0630166130506926,0.11721244802326536,103.23909673806511,2.6689132134494193,4.368503506708861
+rust-lzma,extreme 5,silesia,2.424477043016657,0.14419816191587154,78.04619058431454,2.828347073040615,4.333132670231878
+rust-lzma,extreme 6,canterbury,2.092963684370619,0.048405350129187466,106.43817446898029,1.771287323855599,5.812112289292154
+rust-lzma,extreme 6,canterbury large,2.1327605849130653,0.008323244642444785,105.23874434937821,0.9238489396142269,4.37021427575609
+rust-lzma,extreme 6,silesia,2.354876015883768,0.009161288813698964,80.62347724902162,0.5207734264913858,4.33491977378906
+rust-lzma,extreme 7,canterbury,2.102110358151694,0.037520638192367055,105.82145346629109,5.088298698903232,5.812112289292154
+rust-lzma,extreme 7,canterbury large,2.142476734596507,0.019004172754279777,105.44028563280112,0.9687218503225103,4.37021427575609
+rust-lzma,extreme 7,silesia,2.1999644512078946,0.10682247272477913,79.28510256871927,2.9054453829124465,4.3595549891794105
+rust-lzma,extreme 8,canterbury,2.0424566905815906,0.024502147001399494,106.16518031039125,1.962278608977175,5.812112289292154
+rust-lzma,extreme 8,canterbury large,2.0957844330512843,0.013828398581326092,103.17429312903711,1.3148056362163285,4.37021427575609
+rust-lzma,extreme 8,silesia,2.048368887321352,0.11500125272599172,77.75999376060821,2.520898539900885,4.375515201063641
+rust-lzma,extreme 9,canterbury,1.8016530691541366,0.04566327913413387,101.47731615665279,1.7961622290506254,5.812112289292154
+rust-lzma,extreme 9,canterbury large,1.862316476382013,0.01326729474640196,98.45504356782943,1.417739752697775,4.37021427575609
+rust-lzma,extreme 9,silesia,1.9263570841072333,0.07782687809310578,76.23784117261016,1.6251580367226666,4.378176957372624
+rust-lzma,preset 0,canterbury,22.688451450995306,0.4721093398834574,81.82742344742323,1.435175061263379,4.559556175583168
+rust-lzma,preset 0,canterbury large,16.066032663319003,0.4920195102506711,54.46420416866441,1.1734287254702822,3.227160418139103
+rust-lzma,preset 0,silesia,18.358810164932407,0.2645193256932101,59.743227924743685,0.6593985294168228,3.3862643735055777
+rust-lzma,preset 1,canterbury,18.803804766244088,0.3989892939539278,92.03089576443386,2.928250240603785,4.948040699926064
+rust-lzma,preset 1,canterbury large,14.374728811559821,0.5279826444435066,67.45838739576902,1.4728450338743728,3.577449608834531
+rust-lzma,preset 1,silesia,13.15699787521074,0.21553848147413335,66.27138044764409,0.9602410541814252,3.6280751283974704
+rust-lzma,preset 2,canterbury,12.518036362023192,0.5471163022447035,93.86641094192437,4.048578289281263,5.074093597232953
+rust-lzma,preset 2,canterbury large,9.574604589962448,0.3864747470857312,72.50188222397341,2.963189789571534,3.7214449213924987
+rust-lzma,preset 2,silesia,10.214637513264092,1.2853483649791697,72.46490429153795,1.8656180979653623,3.7368214187279447
+rust-lzma,preset 3,canterbury,12.46234161127442,0.40377708736444523,102.06950291455637,1.466172503241152,5.114533597298242
+rust-lzma,preset 3,canterbury large,7.404915879615743,0.1751689656167527,78.88184103302031,0.728523812070965,3.7919193031243332
+rust-lzma,preset 3,silesia,6.937098913667039,0.11110580063492588,75.64782782241794,0.5594683220354417,3.8013764109614967
+rust-lzma,preset 4,canterbury,4.2697102953211745,0.051807118023954886,103.76301935574517,0.967451485226064,5.719625255378204
+rust-lzma,preset 4,canterbury large,2.555204382629523,0.06498630955198954,98.53712916967288,1.9310940308165334,4.192028615304169
+rust-lzma,preset 4,silesia,4.454400674852369,0.09582516515574128,75.65101555531552,0.5902361667828747,4.066827437334286
+rust-lzma,preset 5,canterbury,3.96529328171426,0.08384447770653318,105.64218186517377,1.7783202619677452,5.7784648783777115
+rust-lzma,preset 5,canterbury large,2.2518052847748593,0.02777638300912084,103.42617189625798,1.779350053184127,4.338773640804406
+rust-lzma,preset 5,silesia,3.3785013313923047,0.0781045685082206,78.16340746485406,1.2554381016077112,4.241192472663396
+rust-lzma,preset 6,canterbury,3.499071586345901,0.1570239863136992,104.89378524605193,2.3159934024048887,5.7931375620372965
+rust-lzma,preset 6,canterbury large,2.1648758008548428,0.050152150962217625,103.11372450423485,3.4420138853705717,4.365714406430886
+rust-lzma,preset 6,silesia,2.9683662156369994,0.03688891470460148,79.1554565102719,1.1179460931029088,4.307575994450234
+rust-lzma,preset 7,canterbury,3.604444927557367,0.0630511549012117,106.09883681725691,1.1888443656570553,5.7931375620372965
+rust-lzma,preset 7,canterbury large,2.166088130842577,0.021325819295422196,104.15459551878493,2.666741378163136,4.365714406430886
+rust-lzma,preset 7,silesia,2.8337577138273553,0.07431220374244937,79.87047077131777,0.9661823235663313,4.33122948967009
+rust-lzma,preset 8,canterbury,3.518983405932836,0.04984954014411692,105.687961072694,1.0533044984182054,5.7931375620372965
+rust-lzma,preset 8,canterbury large,2.1423426373741794,0.01923495607978449,102.82175647230173,0.7839456202380527,4.365714406430886
+rust-lzma,preset 8,silesia,2.740726761877308,0.06848164140476387,79.40429858237638,1.9789615430117553,4.3446172508822745
+rust-lzma,preset 9,canterbury,3.1058134468906,0.1685884687195855,99.86175055962943,4.105895239377565,5.7931375620372965
+rust-lzma,preset 9,canterbury large,2.0262914660758224,0.05708234805230997,99.71231315970073,3.3838726492118782,4.365714406430886
+rust-lzma,preset 9,silesia,2.6541080884142527,0.03616612159769073,78.9105027030092,1.6026379890742122,4.347309663112217
+brotli,quality 0 / window size 20 / buffer size 4096,canterbury,175.67884746642582,1.693361291312023,176.36497816147835,2.9130540368638664,3.150336745433006
+brotli,quality 0 / window size 20 / buffer size 4096,canterbury large,168.2900332382826,2.946885307586403,190.0603983098248,4.2171560882369485,2.9422946006387924
+brotli,quality 0 / window size 20 / buffer size 4096,silesia,175.27685292219033,2.5640277425714064,171.4283824720107,1.5312223434423307,2.698690097677727
+brotli,quality 0 / window size 21 / buffer size 4096,canterbury,171.66861091264542,9.481716607136633,180.84859727289785,2.192697373336516,3.318517119244392
+brotli,quality 0 / window size 21 / buffer size 4096,canterbury large,167.23158593540018,4.650897509168992,190.95370329958226,4.903422871495689,2.9331404800322978
+brotli,quality 0 / window size 21 / buffer size 4096,silesia,173.94084201240995,2.7473434876578415,171.18012923934913,1.8207275132671816,2.7056440490891935
+brotli,quality 0 / window size 22 / buffer size 4096,canterbury,169.336004943541,8.731996477526875,177.95745845592845,5.409047621132522,3.323292144675407
+brotli,quality 0 / window size 22 / buffer size 4096,canterbury large,161.49015915291497,9.210387800408046,190.38337639297245,2.8993803441710253,2.9364739625819016
+brotli,quality 0 / window size 22 / buffer size 4096,silesia,172.79126937586187,4.449671214904589,170.12925928321067,2.3564426658827213,2.705769126793786
+brotli,quality 1 / window size 20 / buffer size 4096,canterbury,136.97213697952358,4.2172383884389335,185.91100317775766,6.863898034909045,3.767216133662683
+brotli,quality 1 / window size 20 / buffer size 4096,canterbury large,139.63466907476874,3.7510423271841065,202.0217016360686,1.4615716811418784,3.20230404418696
+brotli,quality 1 / window size 20 / buffer size 4096,silesia,143.2551419499983,2.5546456520269936,177.30196083554503,2.5428932351988935,2.869002503930116
+brotli,quality 1 / window size 21 / buffer size 4096,canterbury,130.2535664992574,11.939182916478785,185.4818650602454,2.0603473654108835,3.7688628583611226
+brotli,quality 1 / window size 21 / buffer size 4096,canterbury large,133.97978115228904,5.249618328670531,201.1173942088252,5.676153058635814,3.2114643086441035
+brotli,quality 1 / window size 21 / buffer size 4096,silesia,138.3480132393142,5.297013047796363,178.6599451802593,2.766562927702925,2.8789275180111105
+brotli,quality 1 / window size 22 / buffer size 4096,canterbury,117.48069943662385,11.8592488407631,172.42927055092923,10.924945770207682,3.7868223007218553
+brotli,quality 1 / window size 22 / buffer size 4096,canterbury large,138.01788074640803,5.309020149554176,200.56771232712575,6.985891319063166,3.218043217788877
+brotli,quality 1 / window size 22 / buffer size 4096,silesia,132.92739362370477,7.215928400117827,178.16956005516286,1.9943169953721918,2.8835691756063486
+brotli,quality 2 / window size 20 / buffer size 4096,canterbury,80.78572783474652,6.131063496488678,222.01600506907286,15.933614738809247,4.216129622574152
+brotli,quality 2 / window size 20 / buffer size 4096,canterbury large,63.65480414207198,4.574050972685588,186.36973804733617,13.720053629624566,3.179172943640561
+brotli,quality 2 / window size 20 / buffer size 4096,silesia,76.1616330550891,3.4414965657232526,179.45408988034487,3.840757648290625,2.9229809226428896
+brotli,quality 2 / window size 21 / buffer size 4096,canterbury,78.7410007706068,8.182874727224775,219.32537196015795,19.24138761835322,4.226723789215988
+brotli,quality 2 / window size 21 / buffer size 4096,canterbury large,63.62590946060869,4.232133125134023,181.6332976184389,7.950463273621684,3.178972796586149
+brotli,quality 2 / window size 21 / buffer size 4096,silesia,77.20784824734535,2.018217761073629,178.24271844272715,4.5097306572267275,2.924180475822292
+brotli,quality 2 / window size 22 / buffer size 4096,canterbury,81.61805983937461,1.7061275439591361,218.50895594657607,3.467768018622086,4.226711077360321
+brotli,quality 2 / window size 22 / buffer size 4096,canterbury large,66.61436024007772,5.024039592408235,184.71599940617097,14.580303884200118,3.236460829610699
+brotli,quality 2 / window size 22 / buffer size 4096,silesia,77.04337992319167,1.9216699746334998,178.13947200377558,3.419769184543458,2.9259740584444662
+brotli,quality 3 / window size 20 / buffer size 4096,canterbury,72.88392448077319,4.785751881066727,226.67210872277522,21.64901962943497,4.210748345382801
+brotli,quality 3 / window size 20 / buffer size 4096,canterbury large,58.33614198390317,2.676622518546265,199.46640624978704,5.211397906815959,3.2488331605976266
+brotli,quality 3 / window size 20 / buffer size 4096,silesia,67.44982825774721,1.8133212043717124,186.25734239683655,3.3461468875013827,3.039606216763496
+brotli,quality 3 / window size 21 / buffer size 4096,canterbury,68.76424386621636,4.56283712282492,216.20660778272298,15.447401902034805,4.213967880830445
+brotli,quality 3 / window size 21 / buffer size 4096,canterbury large,58.87211983765621,2.4008671767190717,199.25308255285614,5.116473103558215,3.249268298364226
+brotli,quality 3 / window size 21 / buffer size 4096,silesia,69.20482781232403,1.4185354793884135,185.8727012992705,4.363139599377779,3.0407057009582346
+brotli,quality 3 / window size 22 / buffer size 4096,canterbury,68.41499671690465,5.169950027377236,217.86115742565013,14.2356149593487,4.213967880830445
+brotli,quality 3 / window size 22 / buffer size 4096,canterbury large,55.161583713141205,2.5198329083476936,187.8573085429023,8.620077018957726,3.2756579432081394
+brotli,quality 3 / window size 22 / buffer size 4096,silesia,70.90098373619804,2.6582251707940965,187.3985671855663,4.279328481368109,3.0419364332931482
+brotli,quality 4 / window size 20 / buffer size 4096,canterbury,33.10846816290871,4.3249241021298745,241.49515717610106,10.396658753507921,4.686608375517717
+brotli,quality 4 / window size 20 / buffer size 4096,canterbury large,42.86646834156488,2.188689686095855,260.85247383756456,5.111230785040975,3.5578445985044245
+brotli,quality 4 / window size 20 / buffer size 4096,silesia,43.49491057581067,2.8524657149224955,207.17104105975605,3.435589190711749,3.1934046966778604
+brotli,quality 4 / window size 21 / buffer size 4096,canterbury,31.431301543095465,2.8332522148373984,234.69551902379325,3.5449113061615676,4.70112527931279
+brotli,quality 4 / window size 21 / buffer size 4096,canterbury large,38.80293250296149,0.5619574212017483,265.8624329025322,2.602515591017901,3.5682059372459016
+brotli,quality 4 / window size 21 / buffer size 4096,silesia,39.69947706982191,0.4991842928577393,213.42476803509268,2.7927508309100615,3.215184449726157
+brotli,quality 4 / window size 22 / buffer size 4096,canterbury,32.85815094934581,1.3621273698641911,237.43801304778506,6.126050043969307,4.700449177399989
+brotli,quality 4 / window size 22 / buffer size 4096,canterbury large,25.01901186877549,0.8476408532085271,262.7151135997734,6.690279632822417,3.5884459539197713
+brotli,quality 4 / window size 22 / buffer size 4096,silesia,34.0585042708324,2.2276132774362347,210.8311115259499,4.690916078769063,3.2220870698774178
+brotli,quality 5 / window size 20 / buffer size 4096,canterbury,23.625835388104875,0.8336606622805905,286.5289172444651,12.654917284699438,4.598081122862121
+brotli,quality 5 / window size 20 / buffer size 4096,canterbury large,24.252278433166328,0.44540180984750805,282.7316659565265,1.6947647315903074,3.7677887725486965
+brotli,quality 5 / window size 20 / buffer size 4096,silesia,28.515244928551382,1.6449573023470683,235.14735248277015,6.039923492206206,3.537384575447833
+brotli,quality 5 / window size 21 / buffer size 4096,canterbury,21.461476089721994,0.6620395399898958,300.4736139796662,9.272748588464678,4.616947849611611
+brotli,quality 5 / window size 21 / buffer size 4096,canterbury large,19.86664379639632,0.8980036392065464,267.99110965232626,18.102853833604023,3.7726915448232448
+brotli,quality 5 / window size 21 / buffer size 4096,silesia,26.420354878856177,1.6611114344102373,234.45977502337502,11.442600348441548,3.554264774845109
+brotli,quality 5 / window size 22 / buffer size 4096,canterbury,19.584308859353087,1.9938050202503286,285.24420943949815,18.24235523878321,4.616379140443311
+brotli,quality 5 / window size 22 / buffer size 4096,canterbury large,16.21088179629445,0.2726940771902769,285.6355195388243,3.489642632877188,3.772617571004398
+brotli,quality 5 / window size 22 / buffer size 4096,silesia,26.414953273058384,0.5111667493997986,238.0242854537494,4.565506414636814,3.5555988390625264
+brotli,quality 6 / window size 20 / buffer size 4096,canterbury,18.73050616038924,2.3050519250952664,288.51464465839285,19.47338647259154,4.649912900488188
+brotli,quality 6 / window size 20 / buffer size 4096,canterbury large,18.387918491008858,0.2795975617988006,300.9512388467164,4.414055808406366,3.8403780814356248
+brotli,quality 6 / window size 20 / buffer size 4096,silesia,20.117267979793912,2.3370379609103593,228.38580433520994,12.650686015554076,3.5881959987571084
+brotli,quality 6 / window size 21 / buffer size 4096,canterbury,13.913495134758884,0.859684082024168,285.78976813429733,17.213457446504464,4.684062298983125
+brotli,quality 6 / window size 21 / buffer size 4096,canterbury large,14.36269003491414,0.6481897570353626,277.54328680705817,12.234412356002123,3.8488086073839853
+brotli,quality 6 / window size 21 / buffer size 4096,silesia,16.335048526265158,1.7712965491768862,228.46604675563253,10.683723114025868,3.615525258871142
+brotli,quality 6 / window size 22 / buffer size 4096,canterbury,16.32333204209304,1.3325337646262752,288.5665090366807,22.969735588495944,4.683859356773871
+brotli,quality 6 / window size 22 / buffer size 4096,canterbury large,12.84724466558908,0.5893627966370891,300.8514211250527,3.7424359132079412,3.8488590500326616
+brotli,quality 6 / window size 22 / buffer size 4096,silesia,15.652447746505647,1.68895144329891,230.33357870580554,8.941938100817394,3.622144587498903
+brotli,quality 7 / window size 20 / buffer size 4096,canterbury,14.831496824312806,1.016099142835496,275.93874673892253,19.40023612108452,4.6836174101987735
+brotli,quality 7 / window size 20 / buffer size 4096,canterbury large,10.706907629756028,0.5750251194492106,292.5932285268355,19.010791053398375,3.895872731709582
+brotli,quality 7 / window size 20 / buffer size 4096,silesia,14.065347442853351,0.27237012258829424,226.6463120550714,6.912826340069666,3.6196542153302556
+brotli,quality 7 / window size 21 / buffer size 4096,canterbury,12.38278881905297,1.0256792533494197,276.42587228261084,30.1628494724295,4.726127522770723
+brotli,quality 7 / window size 21 / buffer size 4096,canterbury large,9.70777465501803,0.430718301198324,296.2552938813069,9.302951022329276,3.91056514844893
+brotli,quality 7 / window size 21 / buffer size 4096,silesia,11.936867558806778,1.17754246993885,231.3593237676611,11.951728570641254,3.654800865907693
+brotli,quality 7 / window size 22 / buffer size 4096,canterbury,15.666025819273674,0.2833178193328894,303.4198071775585,5.344947717410485,4.7258335154765705
+brotli,quality 7 / window size 22 / buffer size 4096,canterbury large,8.718572095657612,0.3946793807361709,299.9265234051099,18.42830632378247,3.9094609492934094
+brotli,quality 7 / window size 22 / buffer size 4096,silesia,8.876335983762182,0.8457236540476473,231.19985938292535,8.603711541857486,3.671876467227148
+brotli,quality 8 / window size 20 / buffer size 4096,canterbury,10.958381346910782,0.4041379465004656,278.3959617962591,21.239991574385794,4.6979979742400895
+brotli,quality 8 / window size 20 / buffer size 4096,canterbury large,6.860798440259852,0.25312413380630855,291.47284550500916,18.30869277908028,3.940120800672535
+brotli,quality 8 / window size 20 / buffer size 4096,silesia,11.400481148630679,0.1795488851819929,230.02291921382033,7.764053479733898,3.6401792187965727
+brotli,quality 8 / window size 21 / buffer size 4096,canterbury,8.672384296717025,0.5222101717924617,251.06119022461158,13.714766180689551,4.748282817362043
+brotli,quality 8 / window size 21 / buffer size 4096,canterbury large,6.2975459841025385,0.2232895234118486,293.73432025206705,22.576616452521954,3.958172658114347
+brotli,quality 8 / window size 21 / buffer size 4096,silesia,9.10253276125522,0.1430003633173445,223.2872149242473,6.587697070033526,3.6822175931364143
+brotli,quality 8 / window size 22 / buffer size 4096,canterbury,8.873969258586035,0.597544257158646,265.60683113965985,11.76774836113649,4.747721391555805
+brotli,quality 8 / window size 22 / buffer size 4096,canterbury large,5.398495415911185,0.2405697593005786,293.80398774360305,16.023875297358348,3.958574222809966
+brotli,quality 8 / window size 22 / buffer size 4096,silesia,5.925834300046786,0.11568212424951228,222.5427197340731,7.137330177355813,3.705645431454437
+brotli,quality 9 / window size 20 / buffer size 4096,canterbury,11.543860320150838,0.7167771815898082,289.6053772868056,31.108395552098045,4.782709457424489
+brotli,quality 9 / window size 20 / buffer size 4096,canterbury large,4.093532037203239,0.1120540772808104,296.0834018691432,19.688494376337044,3.927464527999617
+brotli,quality 9 / window size 20 / buffer size 4096,silesia,9.534658365746814,0.15627106899828452,225.1170513761602,8.406475672716018,3.6622398321793357
+brotli,quality 9 / window size 21 / buffer size 4096,canterbury,9.386796084469365,0.7705664943921492,291.1915193028729,16.97429637410003,4.773563532674505
+brotli,quality 9 / window size 21 / buffer size 4096,canterbury large,3.852888589688486,0.06716421064104355,300.9434413289155,11.082354953640515,3.945278985888963
+brotli,quality 9 / window size 21 / buffer size 4096,silesia,7.766023209895524,0.2144134785521062,229.9627511835084,11.749532051155285,3.703924721987951
+brotli,quality 9 / window size 22 / buffer size 4096,canterbury,8.838953472114422,1.0267883694686988,267.43701395747996,41.55021122067649,4.773117691610147
+brotli,quality 9 / window size 22 / buffer size 4096,canterbury large,3.6452695332359766,0.16014267606724175,297.1702335737472,12.587776400111524,3.946083948699942
+brotli,quality 9 / window size 22 / buffer size 4096,silesia,5.739737842690609,0.6285679472324041,234.0732153130327,12.775876670214366,3.7345547268706625
+brotli,quality 10 / window size 20 / buffer size 4096,canterbury,1.1296742233460093,0.027297692333910595,246.0405297699701,15.908150631276659,5.444111733921107
+brotli,quality 10 / window size 20 / buffer size 4096,canterbury large,0.9647196990836906,0.05437593159682223,191.25853343715488,7.276605742533668,4.339681384158183
+brotli,quality 10 / window size 20 / buffer size 4096,silesia,1.1513653784017728,0.02741609088009919,228.47895757182897,10.807677557011635,3.985351844013254
+brotli,quality 10 / window size 21 / buffer size 4096,canterbury,0.9944512369290658,0.02448275287325444,220.59236374666898,14.733880538230977,5.4317500623220925
+brotli,quality 10 / window size 21 / buffer size 4096,canterbury large,0.8703672497362324,0.014932540905742496,181.2658083403991,12.911750937310712,4.376645043886139
+brotli,quality 10 / window size 21 / buffer size 4096,silesia,1.0809294284044466,0.023780076038357016,227.68871713352107,5.899896427489914,4.046043342474951
+brotli,quality 10 / window size 22 / buffer size 4096,canterbury,1.0058356198250027,0.01751174411259428,238.9578819140768,17.9170700085957,5.4227378924359435
+brotli,quality 10 / window size 22 / buffer size 4096,canterbury large,0.8461968442452561,0.011082189929750743,181.4176286519933,7.0403272819017495,4.386112984597583
+brotli,quality 10 / window size 22 / buffer size 4096,silesia,0.9824442842478336,0.020526864992246843,223.23821355330458,7.518535794413982,4.098669961663043
+brotli,quality 11 / window size 20 / buffer size 4096,canterbury,0.5434572035218367,0.027957059974182512,249.72076283975954,20.13327398609765,5.628502314851898
+brotli,quality 11 / window size 20 / buffer size 4096,canterbury large,0.46622180560381715,0.003454952958679266,191.49801861453506,13.097141411997782,4.396300790267809
+brotli,quality 11 / window size 20 / buffer size 4096,silesia,0.5874177121427528,0.012642664478655896,249.57379490619505,7.121004289131931,4.078592231571063
+brotli,quality 11 / window size 21 / buffer size 4096,canterbury,0.5335931208107536,0.004848599502943149,262.25584418762355,6.509305259521758,5.666457677722921
+brotli,quality 11 / window size 21 / buffer size 4096,canterbury large,0.48214954331926196,0.002820701055633182,203.6054286857579,4.194145074777752,4.433904734962565
+brotli,quality 11 / window size 21 / buffer size 4096,silesia,0.582860801518312,0.012804413218670348,259.27863001045,7.733370685282467,4.144479875241599
+brotli,quality 11 / window size 22 / buffer size 4096,canterbury,0.5351694793600882,0.003155701229013204,279.0288491019928,10.109625811906735,5.668651822033813
+brotli,quality 11 / window size 22 / buffer size 4096,canterbury large,0.469707522621468,0.00289886186244592,198.84915148043385,4.2284597108137785,4.445071935038392
+brotli,quality 11 / window size 22 / buffer size 4096,silesia,0.5757880200318124,0.02935296739975031,263.1984735344019,19.8132752772325,4.198648392260909
+lzo1x-1,,canterbury,415.9408541864905,9.572979930093899,696.0885630862161,38.71538358048373,2.3328931675255573
+lzo1x-1,,canterbury large,367.51769505009827,3.6289186683649723,590.2165702743096,15.127372806551008,2.0017105015575862
+lzo1x-1,,silesia,434.152948566013,2.3075003431115486,774.4243979116058,2.815471278482619,2.0899311257863067
+lzss (static),ei=10/ej=4,canterbury,3.7067276453340274,0.08723457441376543,404.6374450084738,7.23056790578608,2.4976554356837624
+lzss (static),ei=10/ej=4,canterbury large,2.6136668803818317,0.020065255296621454,348.03598293717596,5.3875504581168006,2.1583238870045656
+lzss (static),ei=10/ej=4,silesia,4.007943750597499,0.0304547260396166,363.73739241773535,2.856177723466547,1.9993338590778285
+lzss (static),ei=11/ej=4,canterbury,2.2418666350429683,0.02966366189651066,455.7891118805911,3.952863115840996,2.5881869788813128
+lzss (static),ei=11/ej=4,canterbury large,1.603142642477365,0.013898573696525146,397.8039848217773,3.7620427347512693,2.281318892486835
+lzss (static),ei=11/ej=4,silesia,2.846652197581115,0.01633903659931006,387.81262219958523,3.442451151893791,2.0811102287832415
+lzss (static),ei=12/ej=4,canterbury,1.3654071180115424,0.005126313110962543,472.7282530298985,2.4756771592838533,2.525126535540451
+lzss (static),ei=12/ej=4,canterbury large,0.9105781358545926,0.001650153174657384,430.2549236809939,1.419683206599581,2.400573669087931
+lzss (static),ei=12/ej=4,silesia,1.68799856737777,0.004652272353513677,417.1720535320261,0.8952365022025356,2.174018448815032
+lzss (static),ei=13/ej=4,canterbury,0.7172305955763287,0.004806074338782867,489.24550974057973,2.264286249954911,2.8214604061769735
+lzss (static),ei=13/ej=4,canterbury large,0.47739999231255853,0.0022177158789237128,438.6206834284062,3.8060830768350593,2.610710492455258
+lzss (static),ei=13/ej=4,silesia,0.8325042142884731,0.0021988629591269083,442.0050310741219,3.8739070099557216,2.3592341554474556
+lzss (static),ei=10/ej=5,canterbury,4.214183700903353,0.04927363267843041,428.1162316744961,13.882661446482713,2.4193750801571037
+lzss (static),ei=10/ej=5,canterbury large,2.9834317126964542,0.02215805960995589,368.89049972734045,3.7986724889974686,2.0419097646242106
+lzss (static),ei=10/ej=5,silesia,5.251107483144371,0.03275523467605637,379.2515043758715,4.506786840629739,1.9747956283877852
+lzss (static),ei=11/ej=5,canterbury,2.3145921139049754,0.00798501898245472,460.1320729549771,2.3560476457750266,2.5182942016546224
+lzss (static),ei=11/ej=5,canterbury large,1.6909809282948673,0.012087215493380113,400.7639895191401,1.1398346760649094,2.16718722356642
+lzss (static),ei=11/ej=5,silesia,3.021251567517261,0.022423408411980462,397.3032971880443,4.19114537523928,2.0656795769743703
+lzss (static),ei=12/ej=5,canterbury,1.35820612350095,0.009816675431421742,441.7814985563586,3.6346515736098217,2.6795784416067265
+lzss (static),ei=12/ej=5,canterbury large,0.8647435256355045,0.006494056867977534,397.6370619806305,3.983422490196653,2.3490787857814355
+lzss (static),ei=12/ej=5,silesia,1.5755815857287039,0.01333666289718268,425.2394480307001,4.333927918872316,2.261583978188939
+lzss (static),ei=13/ej=5,canterbury,0.6328352232169467,0.003567104582262172,465.54463017597124,1.8485010327775415,2.779333067013673
+lzss (static),ei=13/ej=5,canterbury large,0.41431287170326414,0.0028964986095487686,409.4577203811086,1.5970032650278114,2.5143153647571252
+lzss (static),ei=13/ej=5,silesia,0.6882177580785783,0.004057762197512694,431.80436292407205,3.273241864465348,2.3906017162501207
+lzss (dyn),ei=10/ej=4,canterbury,4.105836785818278,0.010915126942091548,273.4133274338384,1.4731980012636043,2.4976554356837624
+lzss (dyn),ei=10/ej=4,canterbury large,2.8740378348876856,0.007842964289344735,235.40271896496728,2.2222850941407732,2.1583238870045656
+lzss (dyn),ei=10/ej=4,silesia,4.871247198738897,0.0646924860051601,226.75577650559194,8.037423887905174,1.9993338590778285
+lzss (dyn),ei=10/ej=5,canterbury,4.386879243323785,0.03658541249866707,287.10611623871677,1.1947670312654795,2.4193750801571037
+lzss (dyn),ei=10/ej=5,canterbury large,2.995937215643287,0.006257951914176787,251.16235294408514,1.0255971501945915,2.0419097646242106
+lzss (dyn),ei=10/ej=5,silesia,5.260456285991115,0.04832947314936032,228.75574739115555,6.638725662196922,1.9747956283877852
+lzss (dyn),ei=11/ej=4,canterbury,2.343814390081455,0.02233112180539557,299.65090594321896,3.2765996804710023,2.5881869788813128
+lzss (dyn),ei=11/ej=4,canterbury large,1.6387083830948574,0.012474923343362955,262.12309922230526,3.03123465897415,2.281318892486835
+lzss (dyn),ei=11/ej=4,silesia,2.86084882526826,0.01973440982187297,229.13070073165355,4.097324090953559,2.0811102287832415
+lzss (dyn),ei=11/ej=5,canterbury,2.386624577972734,0.02121078644732777,297.0481222888989,2.092594781651855,2.5182942016546224
+lzss (dyn),ei=11/ej=5,canterbury large,1.6357358045102184,0.012320554188901985,251.76772502383264,4.375295084384953,2.16718722356642
+lzss (dyn),ei=11/ej=5,silesia,3.0102363329916972,0.013620750984952756,226.29366160399667,7.930563498817813,2.0656795769743703
+lzss (dyn),ei=12/ej=4,canterbury,1.4031896058938536,0.008475494019136234,296.2199499172358,3.7034875471709467,2.525126535540451
+lzss (dyn),ei=12/ej=4,canterbury large,0.8870411374495196,0.0017387047684046411,265.217512020049,6.913494895119912,2.400573669087931
+lzss (dyn),ei=12/ej=4,silesia,1.650075138538477,0.009103646206289883,224.80767771602402,2.9434067400908557,2.174018448815032
+lzss (dyn),ei=12/ej=5,canterbury,1.2598633448005834,0.006600026458292114,303.9443260651484,2.3918680571737725,2.6795784416067265
+lzss (dyn),ei=12/ej=5,canterbury large,0.8621427178362183,0.004565741078114833,268.59731107325246,2.7797463809533323,2.3490787857814355
+lzss (dyn),ei=12/ej=5,silesia,1.522996684873301,0.011580131526356955,239.77246550458156,7.45959797048659,2.261583978188939
+lzss (dyn),ei=13/ej=4,canterbury,0.6723496888810729,0.006577288268501264,314.28196384245337,3.565855801034008,2.8214604061769735
+lzss (dyn),ei=13/ej=4,canterbury large,0.4700413763058926,0.0018448232886907007,277.14086974332963,5.855867205323338,2.610710492455258
+lzss (dyn),ei=13/ej=4,silesia,0.826009503599242,0.00836431730711691,235.38278557544987,5.417635650895018,2.3592341554474556
+lzss (dyn),ei=13/ej=5,canterbury,0.6921145929611822,0.0033904194237678103,319.20562744799787,1.6326025713257768,2.779333067013673
+lzss (dyn),ei=13/ej=5,canterbury large,0.48349176495006596,0.0017057983633840352,276.69021928749396,14.193091700459009,2.5143153647571252
+lzss (dyn),ei=13/ej=5,silesia,0.8842803446132316,0.0035228712139118118,236.4582332179539,6.277735819453437,2.3906017162501207
+yazi,None,canterbury,75.39594897306102,0.4187818921073165,15559.437530839485,4548.029364477853,0.9998417062430702
+yazi,None,canterbury large,75.93482424062998,1.0390873721663676,7964.9202971045725,1082.5471697174312,0.999842311456019
+yazi,None,silesia,76.92158221898534,0.6286749116712096,5596.180454841609,29.82991492811396,0.9998425027573812
+yazi,BestSpeed,canterbury,132.1346567173588,0.32165499319274443,414.87584901120067,2.4617462998714013,3.2428144393053313
+yazi,BestSpeed,canterbury large,108.25082252850157,0.7810297402002352,311.92005568795145,1.0802846721469959,2.7279567926343704
+yazi,BestSpeed,silesia,105.90313551824988,0.6680065614452982,382.7775648458418,1.0200214321750842,2.6401452331275443
+yazi,Default,canterbury,24.16789911629577,0.06215206809031409,594.356365224524,3.482903197324266,3.7990652310836346
+yazi,Default,canterbury large,15.508620726898569,0.022257134445887002,520.2384955997502,1.0924036965465533,3.42251462840224
+yazi,Default,silesia,29.926991215894205,0.055519061100775396,521.1864843841357,0.902769102255106,3.111715428678231
+yazi,BestSize,canterbury,11.578843331856582,0.023138719044753783,613.5071113722487,3.1651476345403755,3.7943982763927364
+yazi,BestSize,canterbury large,4.480329406732584,0.003803890368704384,550.5798384729779,1.691887592008035,3.486031952402834
+yazi,BestSize,silesia,17.74889637424419,0.012257901769302472,527.3580810888294,0.523567687535912,3.1259106023400474
+yazi,Specific(1),canterbury,131.5664764085604,0.41856855705592105,413.7603417395457,3.169266800782685,3.2428144393053313
+yazi,Specific(1),canterbury large,108.2417960531431,0.9150528970266882,310.9457175604362,0.8210026300027706,2.7279567926343704
+yazi,Specific(1),silesia,106.23699083224315,0.757891421953225,382.1873044290388,0.44883382177948544,2.6401452331275443
+yazi,Specific(2),canterbury,124.28971983430264,0.3866098157655546,472.658292624876,2.14546260178109,3.446302939943158
+yazi,Specific(2),canterbury large,102.77886104326785,0.9375546261579308,365.1661350269437,0.6873364661518769,2.9719895623994974
+yazi,Specific(2),silesia,99.73243793981844,0.6138002223021898,436.7929557821539,0.6952979852649609,2.839840270040953
+yazi,Specific(3),canterbury,74.17504801314014,0.3820217698354758,568.5207627824517,3.918136118941747,3.569530553516594
+yazi,Specific(3),canterbury large,58.24279558888969,0.2773385736262533,500.8329914594257,1.238566773088965,3.2872193987938645
+yazi,Specific(3),silesia,65.16949720909138,0.26476328187791387,492.8442001208529,0.9679961369274794,3.0160182608506694
+yazi,Specific(4),canterbury,64.40049646101933,0.19963591984277534,549.6462942229828,3.3235171147880243,3.720551970614514
+yazi,Specific(4),canterbury large,48.47766275912597,0.1866084229753029,464.35140956029346,2.625541418055909,3.274079907101005
+yazi,Specific(4),silesia,59.35589608282349,0.17493354221345891,497.4892541239623,0.7166591383588454,3.0397121097683915
+yazi,Specific(5),canterbury,48.548433927183424,0.07514821109194143,574.6577208176919,3.5816893516738957,3.752440074493862
+yazi,Specific(5),canterbury large,35.62398807366711,0.11461520507967589,487.00025956679264,1.2179232307688126,3.3435988981191684
+yazi,Specific(5),silesia,47.9690132933393,0.12634022461927488,507.9940980500787,0.9364685942511518,3.0736704455295873
+yazi,Specific(6),canterbury,24.27333073082525,0.06894140546695879,592.9917228912653,2.765475097186048,3.7990652310836346
+yazi,Specific(6),canterbury large,15.529745275579735,0.021035074951619333,522.3100165844537,1.1431454212286445,3.42251462840224
+yazi,Specific(6),silesia,29.907285234596724,0.06611500693192712,521.247674783204,0.8417652765562876,3.111715428678231
+yazi,Specific(7),canterbury,18.91948990529042,0.030732647580583965,606.5276983091695,3.122853819091863,3.7831933089804917
+yazi,Specific(7),canterbury large,8.531388333379095,0.00801377695993651,532.4762339623496,1.5462577578385686,3.4461980587369343
+yazi,Specific(7),silesia,23.631801623828952,0.03867947823164725,523.8572698836459,0.254815063731024,3.1203269224667767
+yazi,Specific(8),canterbury,14.153904852314536,0.03242458655904735,612.0636253021021,3.965783612327039,3.79026914192554
+yazi,Specific(8),canterbury large,5.134110484071748,0.0038425292552364924,544.752526004056,1.1940609568921907,3.473707081306262
+yazi,Specific(8),silesia,19.482907527887306,0.024525245966563948,527.2262688613023,0.6021746325615198,3.124130140099322
+yazi,Specific(9),canterbury,11.574580148196205,0.03016845554278293,611.7190786333678,2.9485365407878414,3.7943982763927364
+yazi,Specific(9),canterbury large,4.483637696138605,0.005004150565096892,550.1290312020296,1.2473257707521912,3.486031952402834
+yazi,Specific(9),silesia,17.74234182291946,0.026603190750523188,527.9725275541533,0.7475940565109793,3.1259106023400474
+yazi,Specific(10),canterbury,8.079775478480974,0.011352260320327533,616.8127104040568,2.475827574352441,3.7949925471473938
+yazi,Specific(10),canterbury large,4.396476087119166,0.0030445285985036207,551.233646467536,1.2787101085303854,3.487243315572358
+yazi,Specific(10),silesia,15.221637998771605,0.013784606869889648,527.7744229500968,0.8105331147536902,3.127514477468353
+zopfli,,canterbury,0.1398349265440101,0.0013626284114668823,,,4.192521792049258
+zopfli,,canterbury large,0.2610798945977926,0.002560434885237272,,,3.6757162874069254
+zopfli,,silesia,0.22843349991577405,0.0011637847936878181,,,3.271854506630011
+zopfli-rs,,canterbury,0.39000676765371495,0.001976029861491815,,,4.192690643361212
+zopfli-rs,,canterbury large,0.3591836560754621,0.0016374580178258442,,,3.675717498116766
+zopfli-rs,,silesia,0.36479624993032983,0.007857571831282151,,,3.2719705323686417
+bzip2,level 1,canterbury,22.13544251184874,0.11367193316288104,52.58556565321958,0.3913216919824649,4.816706052105308
+bzip2,level 1,canterbury large,16.489090509906156,0.08645650643939345,41.31387915622874,0.4503067310722664,3.797347654127238
+bzip2,level 1,silesia,15.998166145320283,0.21218108648624473,42.165239175274266,0.5064808838736435,3.50396324639658
+bzip2,level 2,canterbury,22.837311523823725,0.2716466819456363,52.16892442818931,0.5982853196654069,4.926567298119663
+bzip2,level 2,canterbury large,16.921632797832004,0.11144034799184077,40.3662619128288,0.2420239173521409,3.986366422663045
+bzip2,level 2,silesia,16.19000046539609,0.14118123668504737,41.19892697192032,0.3301757363426588,3.648138112542183
+bzip2,level 3,canterbury,22.8202946853204,0.21887905224530885,51.876287304946516,1.1510699119323025,5.0026234199856905
+bzip2,level 3,canterbury large,16.604085129361636,0.05288950751620401,39.37954531662194,0.18065538685347907,4.089762731443306
+bzip2,level 3,silesia,15.703477608453666,0.11971370924288555,40.25106372006059,0.34791933063840497,3.7187775397596816
+bzip2,level 4,canterbury,22.94069150908641,0.0896521576173739,52.965692145035995,0.0837784620806543,4.9631469935426455
+bzip2,level 4,canterbury large,16.506922904371148,0.19898491937128615,39.450434211908224,0.3447444337217565,4.146180451189277
+bzip2,level 4,silesia,15.577794878232437,0.11942672478311207,40.30666581270347,0.3413208364624649,3.7667739554539117
+bzip2,level 5,canterbury,23.094737896163863,0.16080333703831523,53.05743039062553,1.3141838952590512,4.949469621198247
+bzip2,level 5,canterbury large,16.13261043546253,0.5269313678995198,38.93424888849758,0.8094761492187778,4.1866876661059145
+bzip2,level 5,silesia,15.497393507273303,0.11301843256571173,41.02775998758767,0.3803282306455995,3.8035412724770308
+bzip2,level 6,canterbury,22.756388597722626,0.36331684353450905,52.87551027737787,0.6308817907446249,5.051478358385991
+bzip2,level 6,canterbury large,16.476665794962003,0.05624484125132578,39.821767774548306,0.2524175093736549,4.214630583322885
+bzip2,level 6,silesia,14.972485445549836,0.28235180575650903,40.25964368968811,0.5100797002652258,3.8264877489102362
+bzip2,level 7,canterbury,21.45475642198024,0.26683873017397425,51.07889690898017,0.34408615988257457,4.932489370028305
+bzip2,level 7,canterbury large,15.494240039529693,0.16813453048839233,38.52965885004933,0.5572433354778092,4.2530085906376875
+bzip2,level 7,silesia,14.72638387416395,0.14062099411089415,39.917153328766275,0.3760762926059529,3.850978104842373
+bzip2,level 8,canterbury,21.365991236997655,0.7972713816903169,51.224738678552235,1.7172081420208698,4.926662284737741
+bzip2,level 8,canterbury large,15.282616405342345,0.252571574178543,37.45846902928937,1.1742198266879351,4.277889415258974
+bzip2,level 8,silesia,14.6474274027788,0.3098860910173396,39.827250142059135,1.456737476028763,3.8766072439191923
+bzip2,level 9,canterbury,21.580527062215236,0.2822122063977986,50.76339255676241,0.50500911525351,4.9356507447066305
+bzip2,level 9,canterbury large,14.629719542061398,0.4016599296402542,36.12089536565475,1.4367289990167202,4.280940147300331
+bzip2,level 9,silesia,14.16945299878256,0.1671867976360087,38.71445093345231,0.9382650563338173,3.8834852081722535

@@ 1,196 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "alloc-no-stdlib"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
+
+[[package]]
+name = "alloc-stdlib"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
+dependencies = [
+ "alloc-no-stdlib",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c7d0618f0e0b7e8ff11427422b64564d5fb0be1940354bfe2e0529b18a9d9b8"
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "average"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843ec791d3f24503bbf72bbd5e49a3ab4dbb4bcd0a8ef6b0c908efa73caa27b1"
+dependencies = [
+ "easy-cast",
+ "float-ord",
+ "num-traits",
+]
+
+[[package]]
+name = "brotli"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "brotli 3.3.4",
+ "common",
+]
+
+[[package]]
+name = "brotli"
+version = "3.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1a0b1dbcc8ae29329621f8d4f0d835787c1c38bb1401979b49d13b0b305ff68"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
+]
+
+[[package]]
+name = "brotli-decompressor"
+version = "2.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b6561fd3f895a11e8f72af2cb7d22e08366bebc2b6b57f7744c4bda27034744"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+]
+
+[[package]]
+name = "common"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "average",
+ "csv",
+ "serde",
+]
+
+[[package]]
+name = "csv"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b015497079b9a9d69c02ad25de6c0a6edef051ea6360a327d0bd05802ef64ad"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "easy-cast"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bd102ee8c418348759919b83b81cdbdc933ffe29740b903df448b4bafaa348e"
+
+[[package]]
+name = "float-ord"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ce81f49ae8a0482e4c55ea62ebbd7e5a686af544c00b9d090bba3ff9be97b3d"
+
+[[package]]
+name = "itoa"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "num-traits"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4ec6d5fe0b140acb27c9a0444118cf55bfbb4e0b259739429abb4521dd67c16"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f4f29d145265ec1c483c7c654450edde0bfe043d3938d6972630663356d9500"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
+
+[[package]]
+name = "serde"
+version = "1.0.163"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2113ab51b87a539ae008b5c6c02dc020ffa39afd2d83cffcb3f4eb2722cebec2"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.163"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c805777e3930c8883389c602315a24224bcc738b63905ef87cd1420353ea93e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6f671d4b5ffdb8eadec19c0ae67fe2639df8684bd7bc4b83d986b8db549cf01"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"

@@ 1,9 @@
+[package]
+name = "brotli"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0.71"
+common = { path = "../../common" }
+brotli = "3.3.4"

@@ 1,60 @@
+use anyhow::Context as _;
+use common::{benchmark, Compressor, Decompressor, DescribeScheme};
+use std::io::Write;
+
+struct Brotli {
+    quality: u32,
+    window_size: u32,
+    buffer_size: usize,
+}
+
+impl DescribeScheme for Brotli {
+    fn name(&self) -> String {
+        "brotli".to_string()
+    }
+    fn settings(&self) -> Option<String> {
+        Some(format!(
+            "quality {} / window size {} / buffer size {}",
+            self.quality, self.window_size, self.buffer_size
+        ))
+    }
+}
+
+impl Compressor for Brotli {
+    fn compress(&self, data: &[u8]) -> anyhow::Result<std::vec::Vec<u8>> {
+        let mut compressor =
+            brotli::CompressorWriter::new(vec![], self.buffer_size, self.quality, self.window_size);
+        compressor
+            .write_all(data)
+            .context("brotli compression failed")?;
+        Ok(compressor.into_inner())
+    }
+}
+
+impl Decompressor for Brotli {
+    fn decompress_to(&self, src: &[u8], dst: &mut [u8]) -> anyhow::Result<()> {
+        let expected_len = dst.len();
+        let mut cursor = std::io::Cursor::new(dst);
+        brotli::BrotliDecompress(&mut std::io::Cursor::new(src), &mut cursor)
+            .context("brotli decompression failed")?;
+        let actual_len: usize = cursor.position().try_into().unwrap();
+        assert_eq!(actual_len, expected_len);
+        Ok(())
+    }
+}
+
+fn main() -> anyhow::Result<()> {
+    let mut schemes = vec![];
+    for quality in 0..=11 {
+        for window_size in [20, 21, 22] {
+            for buffer_size in [4096] {
+                schemes.push(Brotli {
+                    quality,
+                    window_size,
+                    buffer_size,
+                });
+            }
+        }
+    }
+    benchmark(std::io::stdout(), schemes).context("benchmark failed")
+}

@@ 1,184 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "anyhow"
+version = "1.0.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c7d0618f0e0b7e8ff11427422b64564d5fb0be1940354bfe2e0529b18a9d9b8"
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "average"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843ec791d3f24503bbf72bbd5e49a3ab4dbb4bcd0a8ef6b0c908efa73caa27b1"
+dependencies = [
+ "easy-cast",
+ "float-ord",
+ "num-traits",
+]
+
+[[package]]
+name = "brotlic"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "brotlic 0.8.1",
+ "common",
+]
+
+[[package]]
+name = "brotlic"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8d5a350a871e06f5274bc1206bcd0da426522b4d0fbfad5fcec92806d854e5b"
+dependencies = [
+ "brotlic-sys",
+]
+
+[[package]]
+name = "brotlic-sys"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "afdec5c62bc97b56349053cf66ba503af5c2448591be61c3ad70a5f11b57e574"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "cc"
+version = "1.0.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
+
+[[package]]
+name = "common"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "average",
+ "csv",
+ "serde",
+]
+
+[[package]]
+name = "csv"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b015497079b9a9d69c02ad25de6c0a6edef051ea6360a327d0bd05802ef64ad"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "easy-cast"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bd102ee8c418348759919b83b81cdbdc933ffe29740b903df448b4bafaa348e"
+
+[[package]]
+name = "float-ord"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ce81f49ae8a0482e4c55ea62ebbd7e5a686af544c00b9d090bba3ff9be97b3d"
+
+[[package]]
+name = "itoa"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "num-traits"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4ec6d5fe0b140acb27c9a0444118cf55bfbb4e0b259739429abb4521dd67c16"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f4f29d145265ec1c483c7c654450edde0bfe043d3938d6972630663356d9500"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
+
+[[package]]
+name = "serde"
+version = "1.0.163"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2113ab51b87a539ae008b5c6c02dc020ffa39afd2d83cffcb3f4eb2722cebec2"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.163"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c805777e3930c8883389c602315a24224bcc738b63905ef87cd1420353ea93e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6f671d4b5ffdb8eadec19c0ae67fe2639df8684bd7bc4b83d986b8db549cf01"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"

@@ 1,9 @@
+[package]
+name = "brotlic"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0.71"
+common = { path = "../../common" }
+brotlic = "0.8.1"

@@ 1,101 @@
+use anyhow::Context as _;
+use common::{benchmark, Compressor, Decompressor, DescribeScheme};
+use std::io::{Read, Write};
+
+struct Brotli {
+    quality: u8,
+    window: WindowSize,
+    block: BlockSize,
+}
+
+#[derive(Debug, Clone, Copy)]
+enum WindowSize {
+    Best,
+    Worst,
+}
+
+#[derive(Debug, Clone, Copy)]
+enum BlockSize {
+    Best,
+    Worst,
+}
+
+impl Into<brotlic::WindowSize> for WindowSize {
+    fn into(self) -> brotlic::WindowSize {
+        match self {
+            WindowSize::Best => brotlic::WindowSize::best(),
+            WindowSize::Worst => brotlic::WindowSize::worst(),
+        }
+    }
+}
+
+impl Into<brotlic::BlockSize> for BlockSize {
+    fn into(self) -> brotlic::BlockSize {
+        match self {
+            BlockSize::Best => brotlic::BlockSize::best(),
+            BlockSize::Worst => brotlic::BlockSize::worst(),
+        }
+    }
+}
+
+impl DescribeScheme for Brotli {
+    fn name(&self) -> String {
+        "brotlic".to_string()
+    }
+    fn settings(&self) -> Option<String> {
+        Some(format!(
+            "quality {} / {:?} window size / {:?} block size",
+            self.quality, self.window, self.block
+        ))
+    }
+}
+
+impl Compressor for Brotli {
+    fn compress(&self, data: &[u8]) -> anyhow::Result<std::vec::Vec<u8>> {
+        let mut compressor = brotlic::CompressorWriter::with_encoder(
+            brotlic::BrotliEncoderOptions::new()
+                .quality(brotlic::Quality::new(self.quality).unwrap())
+                .window_size(self.window.into())
+                .block_size(self.block.into())
+                .build()
+                .context("couldn't create brotli encoder")?,
+            vec![],
+        );
+        compressor
+            .write_all(data)
+            .context("brotli compression failed")?;
+        compressor.into_inner().context("brotli compression failed")
+    }
+}
+
+impl Decompressor for Brotli {
+    fn decompress_to(&self, src: &[u8], dst: &mut [u8]) -> anyhow::Result<()> {
+        let mut decompressor = brotlic::DecompressorReader::new(src);
+        decompressor
+            .read_exact(dst)
+            .context("brotli decompression error")?;
+        let mut tmp = [0u8];
+        match decompressor.read_exact(&mut tmp) {
+            Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => Ok(()),
+            _ => Err(anyhow::Error::msg(
+                "brotli decompression failed: dst too short",
+            )),
+        }
+    }
+}
+
+fn main() -> anyhow::Result<()> {
+    let mut schemes = vec![];
+    for quality in 0..=11 {
+        for window in [WindowSize::Worst, WindowSize::Best] {
+            for block in [BlockSize::Worst, BlockSize::Best] {
+                schemes.push(Brotli {
+                    quality,
+                    window,
+                    block,
+                });
+            }
+        }
+    }
+    benchmark(std::io::stdout(), schemes).context("benchmark failed")
+}

@@ 1,199 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "anyhow"
+version = "1.0.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c7d0618f0e0b7e8ff11427422b64564d5fb0be1940354bfe2e0529b18a9d9b8"
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "average"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843ec791d3f24503bbf72bbd5e49a3ab4dbb4bcd0a8ef6b0c908efa73caa27b1"
+dependencies = [
+ "easy-cast",
+ "float-ord",
+ "num-traits",
+]
+
+[[package]]
+name = "bzip2"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "bzip2 0.4.4",
+ "common",
+]
+
+[[package]]
+name = "bzip2"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bdb116a6ef3f6c3698828873ad02c3014b3c85cadb88496095628e3ef1e347f8"
+dependencies = [
+ "bzip2-sys",
+ "libc",
+]
+
+[[package]]
+name = "bzip2-sys"
+version = "0.1.11+1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "736a955f3fa7875102d57c82b8cac37ec45224a07fd32d58f9f7a186b6cd4cdc"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "cc"
+version = "1.0.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
+
+[[package]]
+name = "common"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "average",
+ "csv",
+ "serde",
+]
+
+[[package]]
+name = "csv"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b015497079b9a9d69c02ad25de6c0a6edef051ea6360a327d0bd05802ef64ad"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "easy-cast"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bd102ee8c418348759919b83b81cdbdc933ffe29740b903df448b4bafaa348e"
+
+[[package]]
+name = "float-ord"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ce81f49ae8a0482e4c55ea62ebbd7e5a686af544c00b9d090bba3ff9be97b3d"
+
+[[package]]
+name = "itoa"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
+
+[[package]]
+name = "libc"
+version = "0.2.144"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b00cc1c228a6782d0f076e7b232802e0c5689d41bb5df366f2a6b6621cfdfe1"
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "num-traits"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa1fb82fc0c281dd9671101b66b771ebbe1eaf967b96ac8740dcba4b70005ca8"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f4f29d145265ec1c483c7c654450edde0bfe043d3938d6972630663356d9500"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
+
+[[package]]
+name = "serde"
+version = "1.0.163"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2113ab51b87a539ae008b5c6c02dc020ffa39afd2d83cffcb3f4eb2722cebec2"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.163"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c805777e3930c8883389c602315a24224bcc738b63905ef87cd1420353ea93e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6f671d4b5ffdb8eadec19c0ae67fe2639df8684bd7bc4b83d986b8db549cf01"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"

@@ 1,9 @@
+[package]
+name = "bzip2"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0.71"
+common = { path = "../../common" }
+bzip2 = "0.4.4"

@@ 1,53 @@
+use anyhow::Context as _;
+use common::{benchmark, Compressor, Decompressor, DescribeScheme};
+use std::io::Read as _;
+
+struct Bzip2 {
+    compression: bzip2::Compression,
+}
+
+impl DescribeScheme for Bzip2 {
+    fn name(&self) -> String {
+        "bzip2".to_string()
+    }
+    fn settings(&self) -> Option<String> {
+        Some(format!("level {}", self.compression.level()))
+    }
+}
+
+impl Compressor for Bzip2 {
+    fn compress(&self, data: &[u8]) -> anyhow::Result<std::vec::Vec<u8>> {
+        let mut encoder = bzip2::read::BzEncoder::new(data, self.compression);
+        let mut vec = vec![];
+        encoder
+            .read_to_end(&mut vec)
+            .context("bzip2 compression error")?;
+        Ok(vec)
+    }
+}
+
+impl Decompressor for Bzip2 {
+    fn decompress_to(&self, src: &[u8], dst: &mut [u8]) -> anyhow::Result<()> {
+        let mut decoder = bzip2::read::MultiBzDecoder::new(src);
+        decoder
+            .read_exact(dst)
+            .context("bzip2 decompression error")?;
+        let mut tmp = [0u8];
+        match decoder.read_exact(&mut tmp) {
+            Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => Ok(()),
+            _ => Err(anyhow::Error::msg(
+                "bzip2 decompression error: dst too short",
+            )),
+        }
+    }
+}
+
+fn main() -> anyhow::Result<()> {
+    let mut schemes = vec![];
+    for level in 1..=9 {
+        schemes.push(Bzip2 {
+            compression: bzip2::Compression::new(level),
+        });
+    }
+    benchmark(std::io::stdout(), schemes).context("benchmark failed")
+}

@@ 1,8 @@
+#!/bin/sh
+set -e
+
+for scheme in $(find . -maxdepth 1 -type d -not -path "."); do
+  cd $scheme
+  cargo clean
+  cd ..
+done

@@ 1,175 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "adler32"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234"
+
+[[package]]
+name = "anyhow"
+version = "1.0.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c7d0618f0e0b7e8ff11427422b64564d5fb0be1940354bfe2e0529b18a9d9b8"
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "average"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843ec791d3f24503bbf72bbd5e49a3ab4dbb4bcd0a8ef6b0c908efa73caa27b1"
+dependencies = [
+ "easy-cast",
+ "float-ord",
+ "num-traits",
+]
+
+[[package]]
+name = "common"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "average",
+ "csv",
+ "serde",
+]
+
+[[package]]
+name = "csv"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b015497079b9a9d69c02ad25de6c0a6edef051ea6360a327d0bd05802ef64ad"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "deflate"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "common",
+ "deflate 1.0.0",
+]
+
+[[package]]
+name = "deflate"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c86f7e25f518f4b81808a2cf1c50996a61f5c2eb394b2393bd87f2a4780a432f"
+dependencies = [
+ "adler32",
+]
+
+[[package]]
+name = "easy-cast"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bd102ee8c418348759919b83b81cdbdc933ffe29740b903df448b4bafaa348e"
+
+[[package]]
+name = "float-ord"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ce81f49ae8a0482e4c55ea62ebbd7e5a686af544c00b9d090bba3ff9be97b3d"
+
+[[package]]
+name = "itoa"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "num-traits"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4ec6d5fe0b140acb27c9a0444118cf55bfbb4e0b259739429abb4521dd67c16"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f4f29d145265ec1c483c7c654450edde0bfe043d3938d6972630663356d9500"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
+
+[[package]]
+name = "serde"
+version = "1.0.163"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2113ab51b87a539ae008b5c6c02dc020ffa39afd2d83cffcb3f4eb2722cebec2"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.163"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c805777e3930c8883389c602315a24224bcc738b63905ef87cd1420353ea93e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6f671d4b5ffdb8eadec19c0ae67fe2639df8684bd7bc4b83d986b8db549cf01"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"

@@ 1,9 @@
+[package]
+name = "deflate"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0.71"
+common = { path = "../../common" }
+deflate = "1.0.0"

@@ 1,41 @@
+use anyhow::Context as _;
+use common::{benchmark_compression_only, Compressor, DescribeScheme};
+use std::io::Write as _;
+
+struct Deflate {
+    mode: deflate::Compression,
+}
+
+impl DescribeScheme for Deflate {
+    fn name(&self) -> String {
+        "deflate".to_string()
+    }
+    fn settings(&self) -> Option<String> {
+        Some(format!("{:?}", self.mode))
+    }
+}
+
+impl Compressor for Deflate {
+    fn compress(&self, data: &[u8]) -> anyhow::Result<std::vec::Vec<u8>> {
+        let mut encoder = deflate::write::DeflateEncoder::new(vec![], self.mode);
+        encoder
+            .write_all(data)
+            .context("deflate compression failed")?;
+        encoder.finish().context("deflate compression failed")
+    }
+}
+
+fn main() -> anyhow::Result<()> {
+    let schemes = [
+        Deflate {
+            mode: deflate::Compression::Fast,
+        },
+        Deflate {
+            mode: deflate::Compression::Default,
+        },
+        Deflate {
+            mode: deflate::Compression::Best,
+        },
+    ];
+    benchmark_compression_only(std::io::stdout(), schemes).context("benchmark failed")
+}

@@ 1,200 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
+name = "anyhow"
+version = "1.0.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c7d0618f0e0b7e8ff11427422b64564d5fb0be1940354bfe2e0529b18a9d9b8"
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "average"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843ec791d3f24503bbf72bbd5e49a3ab4dbb4bcd0a8ef6b0c908efa73caa27b1"
+dependencies = [
+ "easy-cast",
+ "float-ord",
+ "num-traits",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "common"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "average",
+ "csv",
+ "serde",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "csv"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b015497079b9a9d69c02ad25de6c0a6edef051ea6360a327d0bd05802ef64ad"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "easy-cast"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bd102ee8c418348759919b83b81cdbdc933ffe29740b903df448b4bafaa348e"
+
+[[package]]
+name = "flate2"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b9429470923de8e8cbd4d2dc513535400b4b3fef0319fb5c4e1f520a7bef743"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "flate2-miniz_oxide"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "common",
+ "flate2",
+]
+
+[[package]]
+name = "float-ord"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ce81f49ae8a0482e4c55ea62ebbd7e5a686af544c00b9d090bba3ff9be97b3d"
+
+[[package]]
+name = "itoa"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7"
+dependencies = [
+ "adler",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4ec6d5fe0b140acb27c9a0444118cf55bfbb4e0b259739429abb4521dd67c16"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f4f29d145265ec1c483c7c654450edde0bfe043d3938d6972630663356d9500"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
+
+[[package]]
+name = "serde"
+version = "1.0.163"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2113ab51b87a539ae008b5c6c02dc020ffa39afd2d83cffcb3f4eb2722cebec2"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.163"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c805777e3930c8883389c602315a24224bcc738b63905ef87cd1420353ea93e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6f671d4b5ffdb8eadec19c0ae67fe2639df8684bd7bc4b83d986b8db549cf01"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"

@@ 1,9 @@
+[package]
+name = "flate2-miniz_oxide"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0.71"
+common = { path = "../../common" }
+flate2 = { version = "1.0.26", default-features = false, features = ["rust_backend"] }

@@ 1,106 @@
+use anyhow::Context as _;
+use common::{benchmark, Compressor, Decompressor, DescribeScheme};
+use std::io::{Read, Write};
+
+enum Deflate {
+    Deflate(flate2::Compression),
+    Zlib(flate2::Compression),
+    GZip(flate2::Compression),
+}
+
+impl DescribeScheme for Deflate {
+    fn name(&self) -> String {
+        "flate2 (rust)".to_string()
+    }
+    fn settings(&self) -> Option<String> {
+        match self {
+            Deflate::Deflate(c) => Some(format!("deflate / level {}", c.level())),
+            Deflate::Zlib(c) => Some(format!("zlib / level {}", c.level())),
+            Deflate::GZip(c) => Some(format!("gzip / level {}", c.level())),
+        }
+    }
+}
+
+impl Compressor for Deflate {
+    fn compress(&self, data: &[u8]) -> anyhow::Result<std::vec::Vec<u8>> {
+        match self {
+            Deflate::Deflate(level) => {
+                let mut encoder = flate2::write::DeflateEncoder::new(vec![], *level);
+                encoder
+                    .write_all(data)
+                    .context("deflate compression failed")?;
+                encoder.finish().context("deflate compression failed")
+            }
+            Deflate::Zlib(level) => {
+                let mut encoder = flate2::write::ZlibEncoder::new(vec![], *level);
+                encoder
+                    .write_all(data)
+                    .context("deflate compression failed")?;
+                encoder.finish().context("zlib compression failed")
+            }
+            Deflate::GZip(level) => {
+                let mut encoder = flate2::write::GzEncoder::new(vec![], *level);
+                encoder
+                    .write_all(data)
+                    .context("deflate compression failed")?;
+                encoder.finish().context("gzip compression failed")
+            }
+        }
+    }
+}
+
+impl Decompressor for Deflate {
+    fn decompress_to(&self, src: &[u8], dst: &mut [u8]) -> anyhow::Result<()> {
+        match self {
+            Deflate::Deflate(_) => {
+                let mut decoder = flate2::read::DeflateDecoder::new(src);
+                decoder
+                    .read_exact(dst)
+                    .context("deflate decompression failed")?;
+                let mut tmp = [0u8];
+                match decoder.read_exact(&mut tmp) {
+                    Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => Ok(()),
+                    _ => Err(anyhow::Error::msg(
+                        "deflate decompression failed: dst too short",
+                    )),
+                }
+            }
+            Deflate::Zlib(_) => {
+                let mut decoder = flate2::read::ZlibDecoder::new(src);
+                decoder
+                    .read_exact(dst)
+                    .context("deflate decompression failed")?;
+                let mut tmp = [0u8];
+                match decoder.read_exact(&mut tmp) {
+                    Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => Ok(()),
+                    _ => Err(anyhow::Error::msg(
+                        "deflate decompression failed: dst too short",
+                    )),
+                }
+            }
+            Deflate::GZip(_) => {
+                let mut decoder = flate2::read::GzDecoder::new(src);
+                decoder
+                    .read_exact(dst)
+                    .context("deflate decompression failed")?;
+                let mut tmp = [0u8];
+                match decoder.read_exact(&mut tmp) {
+                    Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => Ok(()),
+                    _ => Err(anyhow::Error::msg(
+                        "deflate decompression failed: dst too short",
+                    )),
+                }
+            }
+        }
+    }
+}
+
+fn main() -> anyhow::Result<()> {
+    let mut schemes = vec![];
+    for level in 0..=10 {
+        schemes.push(Deflate::Deflate(flate2::Compression::new(level)));
+        schemes.push(Deflate::Zlib(flate2::Compression::new(level)));
+        schemes.push(Deflate::GZip(flate2::Compression::new(level)));
+    }
+    benchmark(std::io::stdout(), schemes).context("benchmark failed")
+}

@@ 1,232 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
+name = "anyhow"
+version = "1.0.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c7d0618f0e0b7e8ff11427422b64564d5fb0be1940354bfe2e0529b18a9d9b8"
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "average"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843ec791d3f24503bbf72bbd5e49a3ab4dbb4bcd0a8ef6b0c908efa73caa27b1"
+dependencies = [
+ "easy-cast",
+ "float-ord",
+ "num-traits",
+]
+
+[[package]]
+name = "cc"
+version = "1.0.79"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "cmake"
+version = "0.1.50"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a31c789563b815f77f4250caee12365734369f942439b7defd71e18a48197130"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "common"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "average",
+ "csv",
+ "serde",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "csv"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b015497079b9a9d69c02ad25de6c0a6edef051ea6360a327d0bd05802ef64ad"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "easy-cast"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bd102ee8c418348759919b83b81cdbdc933ffe29740b903df448b4bafaa348e"
+
+[[package]]
+name = "flate2"
+version = "1.0.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b9429470923de8e8cbd4d2dc513535400b4b3fef0319fb5c4e1f520a7bef743"
+dependencies = [
+ "crc32fast",
+ "libz-ng-sys",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "flate2-zlib-ng"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "common",
+ "flate2",
+]
+
+[[package]]
+name = "float-ord"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ce81f49ae8a0482e4c55ea62ebbd7e5a686af544c00b9d090bba3ff9be97b3d"
+
+[[package]]
+name = "itoa"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
+
+[[package]]
+name = "libc"
+version = "0.2.144"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b00cc1c228a6782d0f076e7b232802e0c5689d41bb5df366f2a6b6621cfdfe1"
+
+[[package]]
+name = "libz-ng-sys"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2468756f34903b582fe7154dc1ffdebd89d0562c4a43b53c621bb0f1b1043ccb"
+dependencies = [
+ "cmake",
+ "libc",
+]
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7"
+dependencies = [
+ "adler",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4ec6d5fe0b140acb27c9a0444118cf55bfbb4e0b259739429abb4521dd67c16"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f4f29d145265ec1c483c7c654450edde0bfe043d3938d6972630663356d9500"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
+
+[[package]]
+name = "serde"
+version = "1.0.163"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2113ab51b87a539ae008b5c6c02dc020ffa39afd2d83cffcb3f4eb2722cebec2"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.163"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c805777e3930c8883389c602315a24224bcc738b63905ef87cd1420353ea93e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6f671d4b5ffdb8eadec19c0ae67fe2639df8684bd7bc4b83d986b8db549cf01"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"

@@ 1,9 @@
+[package]
+name = "flate2-zlib-ng"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0.71"
+common = { path = "../../common" }
+flate2 = { version = "1.0.26", default-features = false, features = ["zlib-ng"] }

@@ 1,106 @@
+use anyhow::Context as _;
+use common::{benchmark, Compressor, Decompressor, DescribeScheme};
+use std::io::{Read, Write};
+
+enum Deflate {
+    Deflate(flate2::Compression),
+    Zlib(flate2::Compression),
+    GZip(flate2::Compression),
+}
+
+impl DescribeScheme for Deflate {
+    fn name(&self) -> String {
+        "flate2 (zlib-ng)".to_string()
+    }
+    fn settings(&self) -> Option<String> {
+        match self {
+            Deflate::Deflate(c) => Some(format!("deflate / level {}", c.level())),
+            Deflate::Zlib(c) => Some(format!("zlib / level {}", c.level())),
+            Deflate::GZip(c) => Some(format!("gzip / level {}", c.level())),
+        }
+    }
+}
+
+impl Compressor for Deflate {
+    fn compress(&self, data: &[u8]) -> anyhow::Result<std::vec::Vec<u8>> {
+        match self {
+            Deflate::Deflate(level) => {
+                let mut encoder = flate2::write::DeflateEncoder::new(vec![], *level);
+                encoder
+                    .write_all(data)
+                    .context("deflate compression failed")?;
+                encoder.finish().context("deflate compression failed")
+            }
+            Deflate::Zlib(level) => {
+                let mut encoder = flate2::write::ZlibEncoder::new(vec![], *level);
+                encoder
+                    .write_all(data)
+                    .context("deflate compression failed")?;
+                encoder.finish().context("zlib compression failed")
+            }
+            Deflate::GZip(level) => {
+                let mut encoder = flate2::write::GzEncoder::new(vec![], *level);
+                encoder
+                    .write_all(data)
+                    .context("deflate compression failed")?;
+                encoder.finish().context("gzip compression failed")
+            }
+        }
+    }
+}
+
+impl Decompressor for Deflate {
+    fn decompress_to(&self, src: &[u8], dst: &mut [u8]) -> anyhow::Result<()> {
+        match self {
+            Deflate::Deflate(_) => {
+                let mut decoder = flate2::read::DeflateDecoder::new(src);
+                decoder
+                    .read_exact(dst)
+                    .context("deflate decompression failed")?;
+                let mut tmp = [0u8];
+                match decoder.read_exact(&mut tmp) {
+                    Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => Ok(()),
+                    _ => Err(anyhow::Error::msg(
+                        "deflate decompression failed: dst too short",
+                    )),
+                }
+            }
+            Deflate::Zlib(_) => {
+                let mut decoder = flate2::read::ZlibDecoder::new(src);
+                decoder
+                    .read_exact(dst)
+                    .context("deflate decompression failed")?;
+                let mut tmp = [0u8];
+                match decoder.read_exact(&mut tmp) {
+                    Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => Ok(()),
+                    _ => Err(anyhow::Error::msg(
+                        "deflate decompression failed: dst too short",
+                    )),
+                }
+            }
+            Deflate::GZip(_) => {
+                let mut decoder = flate2::read::GzDecoder::new(src);
+                decoder
+                    .read_exact(dst)
+                    .context("deflate decompression failed")?;
+                let mut tmp = [0u8];
+                match decoder.read_exact(&mut tmp) {
+                    Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => Ok(()),
+                    _ => Err(anyhow::Error::msg(
+                        "deflate decompression failed: dst too short",
+                    )),
+                }
+            }
+        }
+    }
+}
+
+fn main() -> anyhow::Result<()> {
+    let mut schemes = vec![];
+    for level in 0..=9 {
+        schemes.push(Deflate::Deflate(flate2::Compression::new(level)));
+        schemes.push(Deflate::Zlib(flate2::Compression::new(level)));
+        schemes.push(Deflate::GZip(flate2::Compression::new(level)));
+    }
+    benchmark(std::io::stdout(), schemes).context("benchmark failed")
+}

@@ 1,191 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "anyhow"
+version = "1.0.71"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c7d0618f0e0b7e8ff11427422b64564d5fb0be1940354bfe2e0529b18a9d9b8"
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "average"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843ec791d3f24503bbf72bbd5e49a3ab4dbb4bcd0a8ef6b0c908efa73caa27b1"
+dependencies = [
+ "easy-cast",
+ "float-ord",
+ "num-traits",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "common"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "average",
+ "csv",
+ "serde",
+]
+
+[[package]]
+name = "csv"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b015497079b9a9d69c02ad25de6c0a6edef051ea6360a327d0bd05802ef64ad"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "easy-cast"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bd102ee8c418348759919b83b81cdbdc933ffe29740b903df448b4bafaa348e"
+
+[[package]]
+name = "float-ord"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ce81f49ae8a0482e4c55ea62ebbd7e5a686af544c00b9d090bba3ff9be97b3d"
+
+[[package]]
+name = "itoa"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
+
+[[package]]
+name = "lz4_flex"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "common",
+ "lz4_flex 0.10.0",
+]
+
+[[package]]
+name = "lz4_flex"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b8c72594ac26bfd34f2d99dfced2edfaddfe8a476e3ff2ca0eb293d925c4f83"
+dependencies = [
+ "twox-hash",
+]
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "num-traits"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.57"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4ec6d5fe0b140acb27c9a0444118cf55bfbb4e0b259739429abb4521dd67c16"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f4f29d145265ec1c483c7c654450edde0bfe043d3938d6972630663356d9500"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
+
+[[package]]
+name = "serde"
+version = "1.0.163"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2113ab51b87a539ae008b5c6c02dc020ffa39afd2d83cffcb3f4eb2722cebec2"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.163"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c805777e3930c8883389c602315a24224bcc738b63905ef87cd1420353ea93e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
+[[package]]
+name = "syn"
+version = "2.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6f671d4b5ffdb8eadec19c0ae67fe2639df8684bd7bc4b83d986b8db549cf01"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "twox-hash"
+version = "1.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
+dependencies = [
+ "cfg-if",
+ "static_assertions",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"