From d645114f7e3cbbfa19bb47ace2671fcac75e32ca Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Igor=20Anic=CC=81?= <igor.anic@gmail.com>
Date: Tue, 13 Feb 2024 22:14:40 +0100
Subject: [PATCH] add deflate implemented from first principles

Zig deflate compression/decompression implementation. It supports compression and decompression of gzip, zlib and raw deflate format.

Fixes #18062.

This PR replaces current compress/gzip and compress/zlib packages. Deflate package is renamed to flate. Flate is common name for deflate/inflate where deflate is compression and inflate decompression.

There are breaking change. Methods signatures are changed because of removal of the allocator, and I also unified API for all three namespaces (flate, gzip, zlib).

Currently I put old packages under v1 namespace they are still available as compress/v1/gzip, compress/v1/zlib, compress/v1/deflate. Idea is to give users of the current API little time to postpone analyzing what they had to change. Although that rises question when it is safe to remove that v1 namespace.

Here is current API in the compress package:

```Zig
// deflate
    fn compressor(allocator, writer, options) !Compressor(@TypeOf(writer))
    fn Compressor(comptime WriterType) type

    fn decompressor(allocator, reader, null) !Decompressor(@TypeOf(reader))
    fn Decompressor(comptime ReaderType: type) type

// gzip
    fn compress(allocator, writer, options) !Compress(@TypeOf(writer))
    fn Compress(comptime WriterType: type) type

    fn decompress(allocator, reader) !Decompress(@TypeOf(reader))
    fn Decompress(comptime ReaderType: type) type

// zlib
    fn compressStream(allocator, writer, options) !CompressStream(@TypeOf(writer))
    fn CompressStream(comptime WriterType: type) type

    fn decompressStream(allocator, reader) !DecompressStream(@TypeOf(reader))
    fn DecompressStream(comptime ReaderType: type) type

// xz
   fn decompress(allocator: Allocator, reader: anytype) !Decompress(@TypeOf(reader))
   fn Decompress(comptime ReaderType: type) type

// lzma
    fn decompress(allocator, reader) !Decompress(@TypeOf(reader))
    fn Decompress(comptime ReaderType: type) type

// lzma2
    fn decompress(allocator, reader, writer !void

// zstandard:
    fn DecompressStream(ReaderType, options) type
    fn decompressStream(allocator, reader) DecompressStream(@TypeOf(reader), .{})
    struct decompress
```

The proposed naming convention:
 - Compressor/Decompressor for functions which return type, like Reader/Writer/GeneralPurposeAllocator
 - compressor/compressor for functions which are initializers for that type, like reader/writer/allocator
 - compress/decompress for one shot operations, accepts reader/writer pair, like read/write/alloc

```Zig
/// Compress from reader and write compressed data to the writer.
fn compress(reader: anytype, writer: anytype, options: Options) !void

/// Create Compressor which outputs the writer.
fn compressor(writer: anytype, options: Options) !Compressor(@TypeOf(writer))

/// Compressor type
fn Compressor(comptime WriterType: type) type

/// Decompress from reader and write plain data to the writer.
fn decompress(reader: anytype, writer: anytype) !void

/// Create Decompressor which reads from reader.
fn decompressor(reader: anytype) Decompressor(@TypeOf(reader)

/// Decompressor type
fn Decompressor(comptime ReaderType: type) type

```

Comparing this implementation with the one we currently have in Zig's standard library (std).
Std is roughly 1.2-1.4 times slower in decompression, and 1.1-1.2 times slower in compression. Compressed sizes are pretty much same in both cases.
More resutls in [this](https://github.com/ianic/flate) repo.

This library uses static allocations for all structures, doesn't require allocator. That makes sense especially for deflate where all structures, internal buffers are allocated to the full size. Little less for inflate where we std version uses less memory by not preallocating to theoretical max size array which are usually not fully used.

For deflate this library allocates 395K while std 779K.
For inflate this library allocates 74.5K while std around 36K.

Inflate difference is because we here use 64K history instead of 32K in std.

If merged existing usage of compress gzip/zlib/deflate need some changes. Here is example with necessary changes in comments:

```Zig

const std = @import("std");

// To get this file:
// wget -nc -O war_and_peace.txt https://www.gutenberg.org/ebooks/2600.txt.utf-8
const data = @embedFile("war_and_peace.txt");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer std.debug.assert(gpa.deinit() == .ok);
    const allocator = gpa.allocator();

    try oldDeflate(allocator);
    try new(std.compress.flate, allocator);

    try oldZlib(allocator);
    try new(std.compress.zlib, allocator);

    try oldGzip(allocator);
    try new(std.compress.gzip, allocator);
}

pub fn new(comptime pkg: type, allocator: std.mem.Allocator) !void {
    var buf = std.ArrayList(u8).init(allocator);
    defer buf.deinit();

    // Compressor
    var cmp = try pkg.compressor(buf.writer(), .{});
    _ = try cmp.write(data);
    try cmp.finish();

    var fbs = std.io.fixedBufferStream(buf.items);
    // Decompressor
    var dcp = pkg.decompressor(fbs.reader());

    const plain = try dcp.reader().readAllAlloc(allocator, std.math.maxInt(usize));
    defer allocator.free(plain);
    try std.testing.expectEqualSlices(u8, data, plain);
}

pub fn oldDeflate(allocator: std.mem.Allocator) !void {
    const deflate = std.compress.v1.deflate;

    // Compressor
    var buf = std.ArrayList(u8).init(allocator);
    defer buf.deinit();
    // Remove allocator
    // Rename deflate -> flate
    var cmp = try deflate.compressor(allocator, buf.writer(), .{});
    _ = try cmp.write(data);
    try cmp.close(); // Rename to finish
    cmp.deinit(); // Remove

    // Decompressor
    var fbs = std.io.fixedBufferStream(buf.items);
    // Remove allocator and last param
    // Rename deflate -> flate
    // Remove try
    var dcp = try deflate.decompressor(allocator, fbs.reader(), null);
    defer dcp.deinit(); // Remove

    const plain = try dcp.reader().readAllAlloc(allocator, std.math.maxInt(usize));
    defer allocator.free(plain);
    try std.testing.expectEqualSlices(u8, data, plain);
}

pub fn oldZlib(allocator: std.mem.Allocator) !void {
    const zlib = std.compress.v1.zlib;

    var buf = std.ArrayList(u8).init(allocator);
    defer buf.deinit();

    // Compressor
    // Rename compressStream => compressor
    // Remove allocator
    var cmp = try zlib.compressStream(allocator, buf.writer(), .{});
    _ = try cmp.write(data);
    try cmp.finish();
    cmp.deinit(); // Remove

    var fbs = std.io.fixedBufferStream(buf.items);
    // Decompressor
    // decompressStream => decompressor
    // Remove allocator
    // Remove try
    var dcp = try zlib.decompressStream(allocator, fbs.reader());
    defer dcp.deinit(); // Remove

    const plain = try dcp.reader().readAllAlloc(allocator, std.math.maxInt(usize));
    defer allocator.free(plain);
    try std.testing.expectEqualSlices(u8, data, plain);
}

pub fn oldGzip(allocator: std.mem.Allocator) !void {
    const gzip = std.compress.v1.gzip;

    var buf = std.ArrayList(u8).init(allocator);
    defer buf.deinit();

    // Compressor
    // Rename compress => compressor
    // Remove allocator
    var cmp = try gzip.compress(allocator, buf.writer(), .{});
    _ = try cmp.write(data);
    try cmp.close(); // Rename to finisho
    cmp.deinit(); // Remove

    var fbs = std.io.fixedBufferStream(buf.items);
    // Decompressor
    // Rename decompress => decompressor
    // Remove allocator
    // Remove try
    var dcp = try gzip.decompress(allocator, fbs.reader());
    defer dcp.deinit(); // Remove

    const plain = try dcp.reader().readAllAlloc(allocator, std.math.maxInt(usize));
    defer allocator.free(plain);
    try std.testing.expectEqualSlices(u8, data, plain);
}

```
---
 build.zig                                     |   1 +
 lib/std/compress.zig                          |  23 +-
 lib/std/compress/deflate/compressor.zig       |   4 +-
 lib/std/compress/deflate/decompressor.zig     |   2 +-
 lib/std/compress/flate/CircularBuffer.zig     | 234 +++++
 lib/std/compress/flate/Lookup.zig             | 125 +++
 lib/std/compress/flate/SlidingWindow.zig      | 160 +++
 lib/std/compress/flate/Token.zig              | 327 ++++++
 lib/std/compress/flate/bit_reader.zig         | 333 ++++++
 lib/std/compress/flate/bit_writer.zig         |  99 ++
 lib/std/compress/flate/block_writer.zig       | 706 +++++++++++++
 lib/std/compress/flate/consts.zig             |  49 +
 lib/std/compress/flate/container.zig          | 205 ++++
 lib/std/compress/flate/deflate.zig            | 783 ++++++++++++++
 lib/std/compress/flate/flate.zig              | 236 +++++
 lib/std/compress/flate/gzip.zig               |  66 ++
 lib/std/compress/flate/huffman_decoder.zig    | 308 ++++++
 lib/std/compress/flate/huffman_encoder.zig    | 536 ++++++++++
 lib/std/compress/flate/inflate.zig            | 546 ++++++++++
 lib/std/compress/flate/root.zig               | 133 +++
 .../compress/flate/testdata/block_writer.zig  | 606 +++++++++++
 .../block_writer/huffman-null-max.dyn.expect  | Bin 0 -> 78 bytes
 .../huffman-null-max.dyn.expect-noinput       | Bin 0 -> 78 bytes
 .../block_writer/huffman-null-max.huff.expect | Bin 0 -> 8204 bytes
 .../block_writer/huffman-null-max.input       | Bin 0 -> 65535 bytes
 .../block_writer/huffman-null-max.wb.expect   | Bin 0 -> 78 bytes
 .../huffman-null-max.wb.expect-noinput        | Bin 0 -> 78 bytes
 .../block_writer/huffman-pi.dyn.expect        | Bin 0 -> 1696 bytes
 .../huffman-pi.dyn.expect-noinput             | Bin 0 -> 1696 bytes
 .../block_writer/huffman-pi.huff.expect       | Bin 0 -> 1606 bytes
 .../testdata/block_writer/huffman-pi.input    |   1 +
 .../block_writer/huffman-pi.wb.expect         | Bin 0 -> 1696 bytes
 .../block_writer/huffman-pi.wb.expect-noinput | Bin 0 -> 1696 bytes
 .../block_writer/huffman-rand-1k.dyn.expect   | Bin 0 -> 1005 bytes
 .../huffman-rand-1k.dyn.expect-noinput        | Bin 0 -> 1054 bytes
 .../block_writer/huffman-rand-1k.huff.expect  | Bin 0 -> 1005 bytes
 .../block_writer/huffman-rand-1k.input        | Bin 0 -> 1000 bytes
 .../block_writer/huffman-rand-1k.wb.expect    | Bin 0 -> 1005 bytes
 .../huffman-rand-1k.wb.expect-noinput         | Bin 0 -> 1054 bytes
 .../huffman-rand-limit.dyn.expect             | Bin 0 -> 229 bytes
 .../huffman-rand-limit.dyn.expect-noinput     | Bin 0 -> 229 bytes
 .../huffman-rand-limit.huff.expect            | Bin 0 -> 252 bytes
 .../block_writer/huffman-rand-limit.input     |   4 +
 .../block_writer/huffman-rand-limit.wb.expect | Bin 0 -> 186 bytes
 .../huffman-rand-limit.wb.expect-noinput      | Bin 0 -> 186 bytes
 .../block_writer/huffman-rand-max.huff.expect | Bin 0 -> 65540 bytes
 .../block_writer/huffman-rand-max.input       | Bin 0 -> 65535 bytes
 .../block_writer/huffman-shifts.dyn.expect    | Bin 0 -> 32 bytes
 .../huffman-shifts.dyn.expect-noinput         | Bin 0 -> 32 bytes
 .../block_writer/huffman-shifts.huff.expect   | Bin 0 -> 1812 bytes
 .../block_writer/huffman-shifts.input         |   2 +
 .../block_writer/huffman-shifts.wb.expect     | Bin 0 -> 32 bytes
 .../huffman-shifts.wb.expect-noinput          | Bin 0 -> 32 bytes
 .../huffman-text-shift.dyn.expect             | Bin 0 -> 231 bytes
 .../huffman-text-shift.dyn.expect-noinput     | Bin 0 -> 231 bytes
 .../huffman-text-shift.huff.expect            | Bin 0 -> 231 bytes
 .../block_writer/huffman-text-shift.input     |  14 +
 .../block_writer/huffman-text-shift.wb.expect | Bin 0 -> 231 bytes
 .../huffman-text-shift.wb.expect-noinput      | Bin 0 -> 231 bytes
 .../block_writer/huffman-text.dyn.expect      | Bin 0 -> 217 bytes
 .../huffman-text.dyn.expect-noinput           | Bin 0 -> 217 bytes
 .../block_writer/huffman-text.huff.expect     | Bin 0 -> 219 bytes
 .../testdata/block_writer/huffman-text.input  |  14 +
 .../block_writer/huffman-text.wb.expect       | Bin 0 -> 217 bytes
 .../huffman-text.wb.expect-noinput            | Bin 0 -> 217 bytes
 .../block_writer/huffman-zero.dyn.expect      | Bin 0 -> 17 bytes
 .../huffman-zero.dyn.expect-noinput           | Bin 0 -> 17 bytes
 .../block_writer/huffman-zero.huff.expect     | Bin 0 -> 51 bytes
 .../testdata/block_writer/huffman-zero.input  |   1 +
 .../block_writer/huffman-zero.wb.expect       | Bin 0 -> 6 bytes
 .../huffman-zero.wb.expect-noinput            | Bin 0 -> 6 bytes
 .../null-long-match.dyn.expect-noinput        | Bin 0 -> 206 bytes
 .../null-long-match.wb.expect-noinput         | Bin 0 -> 206 bytes
 .../flate/testdata/fuzz/deflate-stream.expect |  22 +
 .../flate/testdata/fuzz/deflate-stream.input  |   3 +
 .../fuzz/empty-distance-alphabet01.input      | Bin 0 -> 12 bytes
 .../fuzz/empty-distance-alphabet02.input      | Bin 0 -> 13 bytes
 .../flate/testdata/fuzz/end-of-stream.input   |   1 +
 .../compress/flate/testdata/fuzz/fuzz1.input  | Bin 0 -> 60 bytes
 .../compress/flate/testdata/fuzz/fuzz2.input  | Bin 0 -> 56 bytes
 .../compress/flate/testdata/fuzz/fuzz3.input  | Bin 0 -> 8 bytes
 .../compress/flate/testdata/fuzz/fuzz4.input  | Bin 0 -> 20 bytes
 .../testdata/fuzz/invalid-distance.input      | Bin 0 -> 6 bytes
 .../flate/testdata/fuzz/invalid-tree01.input  |   1 +
 .../flate/testdata/fuzz/invalid-tree02.input  | Bin 0 -> 14 bytes
 .../flate/testdata/fuzz/invalid-tree03.input  | Bin 0 -> 12 bytes
 .../testdata/fuzz/lengths-overflow.input      |   1 +
 .../flate/testdata/fuzz/out-of-codes.input    | Bin 0 -> 9 bytes
 .../compress/flate/testdata/fuzz/puff01.input | Bin 0 -> 5 bytes
 .../compress/flate/testdata/fuzz/puff02.input | Bin 0 -> 5 bytes
 .../compress/flate/testdata/fuzz/puff03.input | Bin 0 -> 6 bytes
 .../compress/flate/testdata/fuzz/puff04.input |   1 +
 .../compress/flate/testdata/fuzz/puff05.input |   1 +
 .../compress/flate/testdata/fuzz/puff06.input |   1 +
 .../compress/flate/testdata/fuzz/puff07.input | Bin 0 -> 14 bytes
 .../compress/flate/testdata/fuzz/puff08.input | Bin 0 -> 14 bytes
 .../compress/flate/testdata/fuzz/puff09.input | Bin 0 -> 3 bytes
 .../compress/flate/testdata/fuzz/puff10.input |   1 +
 .../compress/flate/testdata/fuzz/puff11.input | Bin 0 -> 12 bytes
 .../compress/flate/testdata/fuzz/puff12.input | Bin 0 -> 3 bytes
 .../compress/flate/testdata/fuzz/puff13.input | Bin 0 -> 4 bytes
 .../compress/flate/testdata/fuzz/puff14.input | Bin 0 -> 4 bytes
 .../compress/flate/testdata/fuzz/puff15.input |   1 +
 .../compress/flate/testdata/fuzz/puff16.input | Bin 0 -> 6 bytes
 .../compress/flate/testdata/fuzz/puff17.input | Bin 0 -> 6 bytes
 .../compress/flate/testdata/fuzz/puff18.input | Bin 0 -> 52 bytes
 .../compress/flate/testdata/fuzz/puff19.input | Bin 0 -> 65 bytes
 .../compress/flate/testdata/fuzz/puff20.input | Bin 0 -> 12 bytes
 .../compress/flate/testdata/fuzz/puff21.input | Bin 0 -> 64 bytes
 .../compress/flate/testdata/fuzz/puff22.input | Bin 0 -> 142 bytes
 .../compress/flate/testdata/fuzz/puff23.input | Bin 0 -> 404 bytes
 .../compress/flate/testdata/fuzz/puff24.input | Bin 0 -> 68 bytes
 .../compress/flate/testdata/fuzz/puff25.input | Bin 0 -> 64 bytes
 .../compress/flate/testdata/fuzz/puff26.input | Bin 0 -> 346 bytes
 .../compress/flate/testdata/fuzz/puff27.input | Bin 0 -> 49 bytes
 .../flate/testdata/fuzz/roundtrip1.input      | Bin 0 -> 370 bytes
 .../flate/testdata/fuzz/roundtrip2.input      | Bin 0 -> 371 bytes
 lib/std/compress/flate/testdata/rfc1951.txt   | 955 ++++++++++++++++++
 lib/std/compress/flate/zlib.zig               |  66 ++
 lib/std/compress/gzip.zig                     |   2 +-
 lib/std/compress/zlib.zig                     |   2 +-
 lib/std/debug.zig                             |   3 +-
 lib/std/http/Client.zig                       |  16 +-
 lib/std/http/Server.zig                       |  12 +-
 src/Package/Fetch.zig                         |   7 +-
 src/Package/Fetch/git.zig                     |   9 +-
 src/link/Elf/Object.zig                       |   4 +-
 src/objcopy.zig                               |   3 +-
 128 files changed, 6591 insertions(+), 39 deletions(-)
 create mode 100644 lib/std/compress/flate/CircularBuffer.zig
 create mode 100644 lib/std/compress/flate/Lookup.zig
 create mode 100644 lib/std/compress/flate/SlidingWindow.zig
 create mode 100644 lib/std/compress/flate/Token.zig
 create mode 100644 lib/std/compress/flate/bit_reader.zig
 create mode 100644 lib/std/compress/flate/bit_writer.zig
 create mode 100644 lib/std/compress/flate/block_writer.zig
 create mode 100644 lib/std/compress/flate/consts.zig
 create mode 100644 lib/std/compress/flate/container.zig
 create mode 100644 lib/std/compress/flate/deflate.zig
 create mode 100644 lib/std/compress/flate/flate.zig
 create mode 100644 lib/std/compress/flate/gzip.zig
 create mode 100644 lib/std/compress/flate/huffman_decoder.zig
 create mode 100644 lib/std/compress/flate/huffman_encoder.zig
 create mode 100644 lib/std/compress/flate/inflate.zig
 create mode 100644 lib/std/compress/flate/root.zig
 create mode 100644 lib/std/compress/flate/testdata/block_writer.zig
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-null-max.dyn.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-null-max.dyn.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-null-max.huff.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-null-max.input
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-null-max.wb.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-null-max.wb.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-pi.dyn.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-pi.dyn.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-pi.huff.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-pi.input
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-pi.wb.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-pi.wb.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.dyn.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.dyn.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.huff.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.input
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.wb.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.wb.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.dyn.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.dyn.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.huff.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.input
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.wb.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.wb.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-rand-max.huff.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-rand-max.input
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-shifts.dyn.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-shifts.dyn.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-shifts.huff.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-shifts.input
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-shifts.wb.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-shifts.wb.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-text-shift.dyn.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-text-shift.dyn.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-text-shift.huff.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-text-shift.input
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-text-shift.wb.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-text-shift.wb.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-text.dyn.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-text.dyn.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-text.huff.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-text.input
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-text.wb.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-text.wb.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-zero.dyn.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-zero.dyn.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-zero.huff.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-zero.input
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-zero.wb.expect
 create mode 100644 lib/std/compress/flate/testdata/block_writer/huffman-zero.wb.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/block_writer/null-long-match.dyn.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/block_writer/null-long-match.wb.expect-noinput
 create mode 100644 lib/std/compress/flate/testdata/fuzz/deflate-stream.expect
 create mode 100644 lib/std/compress/flate/testdata/fuzz/deflate-stream.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/empty-distance-alphabet01.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/empty-distance-alphabet02.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/end-of-stream.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/fuzz1.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/fuzz2.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/fuzz3.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/fuzz4.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/invalid-distance.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/invalid-tree01.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/invalid-tree02.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/invalid-tree03.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/lengths-overflow.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/out-of-codes.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff01.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff02.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff03.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff04.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff05.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff06.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff07.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff08.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff09.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff10.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff11.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff12.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff13.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff14.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff15.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff16.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff17.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff18.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff19.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff20.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff21.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff22.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff23.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff24.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff25.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff26.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/puff27.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/roundtrip1.input
 create mode 100644 lib/std/compress/flate/testdata/fuzz/roundtrip2.input
 create mode 100644 lib/std/compress/flate/testdata/rfc1951.txt
 create mode 100644 lib/std/compress/flate/zlib.zig

diff --git a/build.zig b/build.zig
index 5dcf8709e5..2d41df42d9 100644
--- a/build.zig
+++ b/build.zig
@@ -151,6 +151,7 @@ pub fn build(b: *std.Build) !void {
                 "rfc1952.txt",
                 "rfc8478.txt",
                 // exclude files from lib/std/compress/deflate/testdata
+                //                and lib/std/compress/flate/testdata
                 ".expect",
                 ".expect-noinput",
                 ".golden",
diff --git a/lib/std/compress.zig b/lib/std/compress.zig
index e56008cefe..b2aeabcbee 100644
--- a/lib/std/compress.zig
+++ b/lib/std/compress.zig
@@ -1,13 +1,21 @@
 const std = @import("std.zig");
 
-pub const deflate = @import("compress/deflate.zig");
-pub const gzip = @import("compress/gzip.zig");
 pub const lzma = @import("compress/lzma.zig");
 pub const lzma2 = @import("compress/lzma2.zig");
 pub const xz = @import("compress/xz.zig");
-pub const zlib = @import("compress/zlib.zig");
 pub const zstd = @import("compress/zstandard.zig");
 
+pub const flate = @import("compress/flate/root.zig").flate;
+pub const gzip = @import("compress/flate/root.zig").gzip;
+pub const zlib = @import("compress/flate/root.zig").zlib;
+
+// Version 1 interface
+pub const v1 = struct {
+    pub const deflate = @import("compress/deflate.zig");
+    pub const gzip = @import("compress/gzip.zig");
+    pub const zlib = @import("compress/zlib.zig");
+};
+
 pub fn HashedReader(
     comptime ReaderType: anytype,
     comptime HasherType: anytype,
@@ -69,11 +77,14 @@ pub fn hashedWriter(
 }
 
 test {
-    _ = deflate;
-    _ = gzip;
+    _ = v1.deflate;
+    _ = v1.gzip;
     _ = lzma;
     _ = lzma2;
     _ = xz;
-    _ = zlib;
+    _ = v1.zlib;
     _ = zstd;
+    _ = flate;
+    _ = gzip;
+    _ = zlib;
 }
diff --git a/lib/std/compress/deflate/compressor.zig b/lib/std/compress/deflate/compressor.zig
index 0326668793..5ce00dd6f1 100644
--- a/lib/std/compress/deflate/compressor.zig
+++ b/lib/std/compress/deflate/compressor.zig
@@ -327,7 +327,7 @@ pub fn Compressor(comptime WriterType: anytype) type {
                     }
                 }
             }
-            const n = std.compress.deflate.copy(self.window[self.window_end..], b);
+            const n = std.compress.v1.deflate.copy(self.window[self.window_end..], b);
             self.window_end += n;
             return @as(u32, @intCast(n));
         }
@@ -705,7 +705,7 @@ pub fn Compressor(comptime WriterType: anytype) type {
         }
 
         fn fillStore(self: *Self, b: []const u8) u32 {
-            const n = std.compress.deflate.copy(self.window[self.window_end..], b);
+            const n = std.compress.v1.deflate.copy(self.window[self.window_end..], b);
             self.window_end += n;
             return @as(u32, @intCast(n));
         }
diff --git a/lib/std/compress/deflate/decompressor.zig b/lib/std/compress/deflate/decompressor.zig
index 896f931a66..616984364d 100644
--- a/lib/std/compress/deflate/decompressor.zig
+++ b/lib/std/compress/deflate/decompressor.zig
@@ -450,7 +450,7 @@ pub fn Decompressor(comptime ReaderType: type) type {
         pub fn read(self: *Self, output: []u8) Error!usize {
             while (true) {
                 if (self.to_read.len > 0) {
-                    const n = std.compress.deflate.copy(output, self.to_read);
+                    const n = std.compress.v1.deflate.copy(output, self.to_read);
                     self.to_read = self.to_read[n..];
                     if (self.to_read.len == 0 and
                         self.err != null)
diff --git a/lib/std/compress/flate/CircularBuffer.zig b/lib/std/compress/flate/CircularBuffer.zig
new file mode 100644
index 0000000000..1e2f99dbb2
--- /dev/null
+++ b/lib/std/compress/flate/CircularBuffer.zig
@@ -0,0 +1,234 @@
+/// 64K buffer of uncompressed data created in inflate (decompression). Has enough
+/// history to support writing match<length, distance>; copying length of bytes
+/// from the position distance backward from current.
+///
+/// Reads can return less than available bytes if they are spread across
+/// different circles. So reads should repeat until get required number of bytes
+/// or until returned slice is zero length.
+///
+/// Note on deflate limits:
+///  * non-compressible block is limited to 65,535 bytes.
+///  * backward pointer is limited in distance to 32K bytes and in length to 258 bytes.
+///
+/// Whole non-compressed block can be written without overlap. We always have
+/// history of up to 64K, more then 32K needed.
+///
+const std = @import("std");
+const assert = std.debug.assert;
+const testing = std.testing;
+
+const consts = @import("consts.zig").match;
+
+const mask = 0xffff; // 64K - 1
+const buffer_len = mask + 1; // 64K buffer
+
+const Self = @This();
+
+buffer: [buffer_len]u8 = undefined,
+wp: usize = 0, // write position
+rp: usize = 0, // read position
+
+fn writeAll(self: *Self, buf: []const u8) void {
+    for (buf) |c| self.write(c);
+}
+
+// Write literal.
+pub fn write(self: *Self, b: u8) void {
+    assert(self.wp - self.rp < mask);
+    self.buffer[self.wp & mask] = b;
+    self.wp += 1;
+}
+
+// Write match (back-reference to the same data slice) starting at `distance`
+// back from current write position, and `length` of bytes.
+pub fn writeMatch(self: *Self, length: u16, distance: u16) !void {
+    if (self.wp < distance or
+        length < consts.base_length or length > consts.max_length or
+        distance < consts.min_distance or distance > consts.max_distance)
+    {
+        return error.InvalidMatch;
+    }
+    assert(self.wp - self.rp < mask);
+
+    var from: usize = self.wp - distance;
+    const from_end: usize = from + length;
+    var to: usize = self.wp;
+    const to_end: usize = to + length;
+
+    self.wp += length;
+
+    // Fast path using memcpy
+    if (length <= distance and // no overlapping buffers
+        (from >> 16 == from_end >> 16) and // start and and at the same circle
+        (to >> 16 == to_end >> 16))
+    {
+        @memcpy(self.buffer[to & mask .. to_end & mask], self.buffer[from & mask .. from_end & mask]);
+        return;
+    }
+
+    // Slow byte by byte
+    while (to < to_end) {
+        self.buffer[to & mask] = self.buffer[from & mask];
+        to += 1;
+        from += 1;
+    }
+}
+
+// Returns writable part of the internal buffer of size `n` at most. Advances
+// write pointer, assumes that returned buffer will be filled with data.
+pub fn getWritable(self: *Self, n: usize) []u8 {
+    const wp = self.wp & mask;
+    const len = @min(n, buffer_len - wp);
+    self.wp += len;
+    return self.buffer[wp .. wp + len];
+}
+
+// Read available data. Can return part of the available data if it is
+// spread across two circles. So read until this returns zero length.
+pub fn read(self: *Self) []const u8 {
+    return self.readAtMost(buffer_len);
+}
+
+// Read part of available data. Can return less than max even if there are
+// more than max decoded data.
+pub fn readAtMost(self: *Self, limit: usize) []const u8 {
+    const rb = self.readBlock(if (limit == 0) buffer_len else limit);
+    defer self.rp += rb.len;
+    return self.buffer[rb.head..rb.tail];
+}
+
+const ReadBlock = struct {
+    head: usize,
+    tail: usize,
+    len: usize,
+};
+
+// Returns position of continous read block data.
+fn readBlock(self: *Self, max: usize) ReadBlock {
+    const r = self.rp & mask;
+    const w = self.wp & mask;
+    const n = @min(
+        max,
+        if (w >= r) w - r else buffer_len - r,
+    );
+    return .{
+        .head = r,
+        .tail = r + n,
+        .len = n,
+    };
+}
+
+// Number of free bytes for write.
+pub fn free(self: *Self) usize {
+    return buffer_len - (self.wp - self.rp);
+}
+
+// Full if largest match can't fit. 258 is largest match length. That much bytes
+// can be produced in single decode step.
+pub fn full(self: *Self) bool {
+    return self.free() < 258 + 1;
+}
+
+// example from: https://youtu.be/SJPvNi4HrWQ?t=3558
+test "flate.CircularBuffer writeMatch" {
+    var cb: Self = .{};
+
+    cb.writeAll("a salad; ");
+    try cb.writeMatch(5, 9);
+    try cb.writeMatch(3, 3);
+
+    try testing.expectEqualStrings("a salad; a salsal", cb.read());
+}
+
+test "flate.CircularBuffer writeMatch overlap" {
+    var cb: Self = .{};
+
+    cb.writeAll("a b c ");
+    try cb.writeMatch(8, 4);
+    cb.write('d');
+
+    try testing.expectEqualStrings("a b c b c b c d", cb.read());
+}
+
+test "flate.CircularBuffer readAtMost" {
+    var cb: Self = .{};
+
+    cb.writeAll("0123456789");
+    try cb.writeMatch(50, 10);
+
+    try testing.expectEqualStrings("0123456789" ** 6, cb.buffer[cb.rp..cb.wp]);
+    for (0..6) |i| {
+        try testing.expectEqual(i * 10, cb.rp);
+        try testing.expectEqualStrings("0123456789", cb.readAtMost(10));
+    }
+    try testing.expectEqualStrings("", cb.readAtMost(10));
+    try testing.expectEqualStrings("", cb.read());
+}
+
+test "flate.CircularBuffer" {
+    var cb: Self = .{};
+
+    const data = "0123456789abcdef" ** (1024 / 16);
+    cb.writeAll(data);
+    try testing.expectEqual(@as(usize, 0), cb.rp);
+    try testing.expectEqual(@as(usize, 1024), cb.wp);
+    try testing.expectEqual(@as(usize, 1024 * 63), cb.free());
+
+    for (0..62 * 4) |_|
+        try cb.writeMatch(256, 1024); // write 62K
+
+    try testing.expectEqual(@as(usize, 0), cb.rp);
+    try testing.expectEqual(@as(usize, 63 * 1024), cb.wp);
+    try testing.expectEqual(@as(usize, 1024), cb.free());
+
+    cb.writeAll(data[0..200]);
+    _ = cb.readAtMost(1024); // make some space
+    cb.writeAll(data); // overflows write position
+    try testing.expectEqual(@as(usize, 200 + 65536), cb.wp);
+    try testing.expectEqual(@as(usize, 1024), cb.rp);
+    try testing.expectEqual(@as(usize, 1024 - 200), cb.free());
+
+    const rb = cb.readBlock(Self.buffer_len);
+    try testing.expectEqual(@as(usize, 65536 - 1024), rb.len);
+    try testing.expectEqual(@as(usize, 1024), rb.head);
+    try testing.expectEqual(@as(usize, 65536), rb.tail);
+
+    try testing.expectEqual(@as(usize, 65536 - 1024), cb.read().len); // read to the end of the buffer
+    try testing.expectEqual(@as(usize, 200 + 65536), cb.wp);
+    try testing.expectEqual(@as(usize, 65536), cb.rp);
+    try testing.expectEqual(@as(usize, 65536 - 200), cb.free());
+
+    try testing.expectEqual(@as(usize, 200), cb.read().len); // read the rest
+}
+
+test "flate.CircularBuffer write overlap" {
+    var cb: Self = .{};
+    cb.wp = cb.buffer.len - 15;
+    cb.rp = cb.wp;
+
+    cb.writeAll("0123456789");
+    cb.writeAll("abcdefghij");
+
+    try testing.expectEqual(cb.buffer.len + 5, cb.wp);
+    try testing.expectEqual(cb.buffer.len - 15, cb.rp);
+
+    try testing.expectEqualStrings("0123456789abcde", cb.read());
+    try testing.expectEqualStrings("fghij", cb.read());
+
+    try testing.expect(cb.wp == cb.rp);
+}
+
+test "flate.CircularBuffer writeMatch/read overlap" {
+    var cb: Self = .{};
+    cb.wp = cb.buffer.len - 15;
+    cb.rp = cb.wp;
+
+    cb.writeAll("0123456789");
+    try cb.writeMatch(15, 5);
+
+    try testing.expectEqualStrings("012345678956789", cb.read());
+    try testing.expectEqualStrings("5678956789", cb.read());
+
+    try cb.writeMatch(20, 25);
+    try testing.expectEqualStrings("01234567895678956789", cb.read());
+}
diff --git a/lib/std/compress/flate/Lookup.zig b/lib/std/compress/flate/Lookup.zig
new file mode 100644
index 0000000000..b5d1fd3c97
--- /dev/null
+++ b/lib/std/compress/flate/Lookup.zig
@@ -0,0 +1,125 @@
+/// Lookup of the previous locations for the same 4 byte data. Works on hash of
+/// 4 bytes data. Head contains position of the first match for each hash. Chain
+/// points to the previous position of the same hash given the current location.
+///
+const std = @import("std");
+const testing = std.testing;
+const expect = testing.expect;
+const consts = @import("consts.zig");
+
+const Self = @This();
+
+const prime4 = 0x9E3779B1; // 4 bytes prime number 2654435761
+const chain_len = 2 * consts.history.len;
+
+// Maps hash => first position
+head: [consts.lookup.len]u16 = [_]u16{0} ** consts.lookup.len,
+// Maps position => previous positions for the same hash value
+chain: [chain_len]u16 = [_]u16{0} ** (chain_len),
+
+// Calculates hash of the 4 bytes from data.
+// Inserts `pos` position of that hash in the lookup tables.
+// Returns previous location with the same hash value.
+pub fn add(self: *Self, data: []const u8, pos: u16) u16 {
+    if (data.len < 4) return 0;
+    const h = hash(data[0..4]);
+    return self.set(h, pos);
+}
+
+// Retruns previous location with the same hash value given the current
+// position.
+pub fn prev(self: *Self, pos: u16) u16 {
+    return self.chain[pos];
+}
+
+fn set(self: *Self, h: u32, pos: u16) u16 {
+    const p = self.head[h];
+    self.head[h] = pos;
+    self.chain[pos] = p;
+    return p;
+}
+
+// Slide all positions in head and chain for `n`
+pub fn slide(self: *Self, n: u16) void {
+    for (&self.head) |*v| {
+        v.* -|= n;
+    }
+    var i: usize = 0;
+    while (i < n) : (i += 1) {
+        self.chain[i] = self.chain[i + n] -| n;
+    }
+}
+
+// Add `len` 4 bytes hashes from `data` into lookup.
+// Position of the first byte is `pos`.
+pub fn bulkAdd(self: *Self, data: []const u8, len: u16, pos: u16) void {
+    if (len == 0 or data.len < consts.match.min_length) {
+        return;
+    }
+    var hb =
+        @as(u32, data[3]) |
+        @as(u32, data[2]) << 8 |
+        @as(u32, data[1]) << 16 |
+        @as(u32, data[0]) << 24;
+    _ = self.set(hashu(hb), pos);
+
+    var i = pos;
+    for (4..@min(len + 3, data.len)) |j| {
+        hb = (hb << 8) | @as(u32, data[j]);
+        i += 1;
+        _ = self.set(hashu(hb), i);
+    }
+}
+
+// Calculates hash of the first 4 bytes of `b`.
+fn hash(b: *const [4]u8) u32 {
+    return hashu(@as(u32, b[3]) |
+        @as(u32, b[2]) << 8 |
+        @as(u32, b[1]) << 16 |
+        @as(u32, b[0]) << 24);
+}
+
+fn hashu(v: u32) u32 {
+    return @intCast((v *% prime4) >> consts.lookup.shift);
+}
+
+test "flate.Lookup add/prev" {
+    const data = [_]u8{
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+        0x01, 0x02, 0x03,
+    };
+
+    var h: Self = .{};
+    for (data, 0..) |_, i| {
+        const p = h.add(data[i..], @intCast(i));
+        if (i >= 8 and i < 24) {
+            try expect(p == i - 8);
+        } else {
+            try expect(p == 0);
+        }
+    }
+
+    const v = Self.hash(data[2 .. 2 + 4]);
+    try expect(h.head[v] == 2 + 16);
+    try expect(h.chain[2 + 16] == 2 + 8);
+    try expect(h.chain[2 + 8] == 2);
+}
+
+test "flate.Lookup bulkAdd" {
+    const data = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
+
+    // one by one
+    var h: Self = .{};
+    for (data, 0..) |_, i| {
+        _ = h.add(data[i..], @intCast(i));
+    }
+
+    // in bulk
+    var bh: Self = .{};
+    bh.bulkAdd(data, data.len, 0);
+
+    try testing.expectEqualSlices(u16, &h.head, &bh.head);
+    try testing.expectEqualSlices(u16, &h.chain, &bh.chain);
+}
diff --git a/lib/std/compress/flate/SlidingWindow.zig b/lib/std/compress/flate/SlidingWindow.zig
new file mode 100644
index 0000000000..ceab98c0d3
--- /dev/null
+++ b/lib/std/compress/flate/SlidingWindow.zig
@@ -0,0 +1,160 @@
+/// Used in deflate (compression), holds uncompressed data form which Tokens are
+/// produces. In combination with Lookup it is used to find matches in history data.
+///
+const std = @import("std");
+const consts = @import("consts.zig");
+
+const expect = testing.expect;
+const assert = std.debug.assert;
+const testing = std.testing;
+
+const hist_len = consts.history.len;
+const buffer_len = 2 * hist_len;
+const min_lookahead = consts.match.min_length + consts.match.max_length;
+const max_rp = buffer_len - min_lookahead;
+
+const Self = @This();
+
+buffer: [buffer_len]u8 = undefined,
+wp: usize = 0, // write position
+rp: usize = 0, // read position
+fp: isize = 0, // last flush position, tokens are build from fp..rp
+
+// Returns number of bytes written, or 0 if buffer is full and need to slide.
+pub fn write(self: *Self, buf: []const u8) usize {
+    if (self.rp >= max_rp) return 0; // need to slide
+
+    const n = @min(buf.len, buffer_len - self.wp);
+    @memcpy(self.buffer[self.wp .. self.wp + n], buf[0..n]);
+    self.wp += n;
+    return n;
+}
+
+// Slide buffer for hist_len.
+// Drops old history, preserves between hist_len and hist_len - min_lookahead.
+// Returns number of bytes removed.
+pub fn slide(self: *Self) u16 {
+    assert(self.rp >= max_rp and self.wp >= self.rp);
+    const n = self.wp - hist_len;
+    @memcpy(self.buffer[0..n], self.buffer[hist_len..self.wp]);
+    self.rp -= hist_len;
+    self.wp -= hist_len;
+    self.fp -= hist_len;
+    return @intCast(n);
+}
+
+// Data from the current position (read position). Those part of the buffer is
+// not converted to tokens yet.
+fn lookahead(self: *Self) []const u8 {
+    assert(self.wp >= self.rp);
+    return self.buffer[self.rp..self.wp];
+}
+
+// Returns part of the lookahead buffer. If should_flush is set no lookahead is
+// preserved otherwise preserves enough data for the longest match. Returns
+// null if there is not enough data.
+pub fn activeLookahead(self: *Self, should_flush: bool) ?[]const u8 {
+    const min: usize = if (should_flush) 0 else min_lookahead;
+    const lh = self.lookahead();
+    return if (lh.len > min) lh else null;
+}
+
+// Advances read position, shrinks lookahead.
+pub fn advance(self: *Self, n: u16) void {
+    assert(self.wp >= self.rp + n);
+    self.rp += n;
+}
+
+// Returns writable part of the buffer, where new uncompressed data can be
+// written.
+pub fn writable(self: *Self) []u8 {
+    return self.buffer[self.wp..];
+}
+
+// Notification of what part of writable buffer is filled with data.
+pub fn written(self: *Self, n: usize) void {
+    self.wp += n;
+}
+
+// Finds match length between previous and current position.
+// Used in hot path!
+pub fn match(self: *Self, prev_pos: u16, curr_pos: u16, min_len: u16) u16 {
+    const max_len: usize = @min(self.wp - curr_pos, consts.match.max_length);
+    // lookahead buffers from previous and current positions
+    const prev_lh = self.buffer[prev_pos..][0..max_len];
+    const curr_lh = self.buffer[curr_pos..][0..max_len];
+
+    // If we alread have match (min_len > 0),
+    // test the first byte above previous len a[min_len] != b[min_len]
+    // and then all the bytes from that position to zero.
+    // That is likely positions to find difference than looping from first bytes.
+    var i: usize = min_len;
+    if (i > 0) {
+        if (max_len <= i) return 0;
+        while (true) {
+            if (prev_lh[i] != curr_lh[i]) return 0;
+            if (i == 0) break;
+            i -= 1;
+        }
+        i = min_len;
+    }
+    while (i < max_len) : (i += 1)
+        if (prev_lh[i] != curr_lh[i]) break;
+    return if (i >= consts.match.min_length) @intCast(i) else 0;
+}
+
+// Current position of non-compressed data. Data before rp are already converted
+// to tokens.
+pub fn pos(self: *Self) u16 {
+    return @intCast(self.rp);
+}
+
+// Notification that token list is cleared.
+pub fn flush(self: *Self) void {
+    self.fp = @intCast(self.rp);
+}
+
+// Part of the buffer since last flush or null if there was slide in between (so
+// fp becomes negative).
+pub fn tokensBuffer(self: *Self) ?[]const u8 {
+    assert(self.fp <= self.rp);
+    if (self.fp < 0) return null;
+    return self.buffer[@intCast(self.fp)..self.rp];
+}
+
+test "flate.SlidingWindow match" {
+    const data = "Blah blah blah blah blah!";
+    var win: Self = .{};
+    try expect(win.write(data) == data.len);
+    try expect(win.wp == data.len);
+    try expect(win.rp == 0);
+
+    // length between l symbols
+    try expect(win.match(1, 6, 0) == 18);
+    try expect(win.match(1, 11, 0) == 13);
+    try expect(win.match(1, 16, 0) == 8);
+    try expect(win.match(1, 21, 0) == 0);
+
+    // position 15 = "blah blah!"
+    // position 20 = "blah!"
+    try expect(win.match(15, 20, 0) == 4);
+    try expect(win.match(15, 20, 3) == 4);
+    try expect(win.match(15, 20, 4) == 0);
+}
+
+test "flate.SlidingWindow slide" {
+    var win: Self = .{};
+    win.wp = Self.buffer_len - 11;
+    win.rp = Self.buffer_len - 111;
+    win.buffer[win.rp] = 0xab;
+    try expect(win.lookahead().len == 100);
+    try expect(win.tokensBuffer().?.len == win.rp);
+
+    const n = win.slide();
+    try expect(n == 32757);
+    try expect(win.buffer[win.rp] == 0xab);
+    try expect(win.rp == Self.hist_len - 111);
+    try expect(win.wp == Self.hist_len - 11);
+    try expect(win.lookahead().len == 100);
+    try expect(win.tokensBuffer() == null);
+}
diff --git a/lib/std/compress/flate/Token.zig b/lib/std/compress/flate/Token.zig
new file mode 100644
index 0000000000..fd9dd1d1e3
--- /dev/null
+++ b/lib/std/compress/flate/Token.zig
@@ -0,0 +1,327 @@
+/// Token cat be literal: single byte of data or match; reference to the slice of
+/// data in the same stream represented with <length, distance>. Where length
+/// can be 3 - 258 bytes, and distance 1 - 32768 bytes.
+///
+const std = @import("std");
+const assert = std.debug.assert;
+const print = std.debug.print;
+const expect = std.testing.expect;
+const consts = @import("consts.zig").match;
+
+const Token = @This();
+
+pub const Kind = enum(u1) {
+    literal,
+    match,
+};
+
+// Distance range 1 - 32768, stored in dist as 0 - 32767 (fits u15)
+dist: u15 = 0,
+// Length range 3 - 258, stored in len_lit as 0 - 255 (fits u8)
+len_lit: u8 = 0,
+kind: Kind = .literal,
+
+pub fn literal(t: Token) u8 {
+    return t.len_lit;
+}
+
+pub fn distance(t: Token) u16 {
+    return @as(u16, t.dist) + consts.min_distance;
+}
+
+pub fn length(t: Token) u16 {
+    return @as(u16, t.len_lit) + consts.base_length;
+}
+
+pub fn initLiteral(lit: u8) Token {
+    return .{ .kind = .literal, .len_lit = lit };
+}
+
+// distance range 1 - 32768, stored in dist as 0 - 32767 (u15)
+// length range 3 - 258, stored in len_lit as 0 - 255 (u8)
+pub fn initMatch(dist: u16, len: u16) Token {
+    assert(len >= consts.min_length and len <= consts.max_length);
+    assert(dist >= consts.min_distance and dist <= consts.max_distance);
+    return .{
+        .kind = .match,
+        .dist = @intCast(dist - consts.min_distance),
+        .len_lit = @intCast(len - consts.base_length),
+    };
+}
+
+pub fn eql(t: Token, o: Token) bool {
+    return t.kind == o.kind and
+        t.dist == o.dist and
+        t.len_lit == o.len_lit;
+}
+
+pub fn lengthCode(t: Token) u16 {
+    return match_lengths[match_lengths_index[t.len_lit]].code;
+}
+
+pub fn lengthEncoding(t: Token) MatchLength {
+    var c = match_lengths[match_lengths_index[t.len_lit]];
+    c.extra_length = t.len_lit - c.base_scaled;
+    return c;
+}
+
+// Returns the distance code corresponding to a specific distance.
+// Distance code is in range: 0 - 29.
+pub fn distanceCode(t: Token) u8 {
+    var dist: u16 = t.dist;
+    if (dist < match_distances_index.len) {
+        return match_distances_index[dist];
+    }
+    dist >>= 7;
+    if (dist < match_distances_index.len) {
+        return match_distances_index[dist] + 14;
+    }
+    dist >>= 7;
+    return match_distances_index[dist] + 28;
+}
+
+pub fn distanceEncoding(t: Token) MatchDistance {
+    var c = match_distances[t.distanceCode()];
+    c.extra_distance = t.dist - c.base_scaled;
+    return c;
+}
+
+pub fn lengthExtraBits(code: u32) u8 {
+    return match_lengths[code - length_codes_start].extra_bits;
+}
+
+pub fn matchLength(code: u8) MatchLength {
+    return match_lengths[code];
+}
+
+pub fn matchDistance(code: u8) MatchDistance {
+    return match_distances[code];
+}
+
+pub fn distanceExtraBits(code: u32) u8 {
+    return match_distances[code].extra_bits;
+}
+
+pub fn show(t: Token) void {
+    if (t.kind == .literal) {
+        print("L('{c}'), ", .{t.literal()});
+    } else {
+        print("M({d}, {d}), ", .{ t.distance(), t.length() });
+    }
+}
+
+// Retruns index in match_lengths table for each length in range 0-255.
+const match_lengths_index = [_]u8{
+    0,  1,  2,  3,  4,  5,  6,  7,  8,  8,
+    9,  9,  10, 10, 11, 11, 12, 12, 12, 12,
+    13, 13, 13, 13, 14, 14, 14, 14, 15, 15,
+    15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
+    17, 17, 17, 17, 17, 17, 17, 17, 18, 18,
+    18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
+    19, 19, 19, 19, 20, 20, 20, 20, 20, 20,
+    20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+    21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+    21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
+    22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+    22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
+    23, 23, 23, 23, 23, 23, 23, 23, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+    24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+    25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+    25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+    25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+    25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
+    26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+    26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+    26, 26, 26, 26, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 28,
+};
+
+const MatchLength = struct {
+    code: u16,
+    base_scaled: u8, // base - 3, scaled to fit into u8 (0-255), same as lit_len field in Token.
+    base: u16, // 3-258
+    extra_length: u8 = 0,
+    extra_bits: u4,
+};
+
+// match_lengths represents table from rfc (https://datatracker.ietf.org/doc/html/rfc1951#page-12)
+//
+//      Extra               Extra               Extra
+// Code Bits Length(s) Code Bits Lengths   Code Bits Length(s)
+// ---- ---- ------     ---- ---- -------   ---- ---- -------
+//  257   0     3       267   1   15,16     277   4   67-82
+//  258   0     4       268   1   17,18     278   4   83-98
+//  259   0     5       269   2   19-22     279   4   99-114
+//  260   0     6       270   2   23-26     280   4  115-130
+//  261   0     7       271   2   27-30     281   5  131-162
+//  262   0     8       272   2   31-34     282   5  163-194
+//  263   0     9       273   3   35-42     283   5  195-226
+//  264   0    10       274   3   43-50     284   5  227-257
+//  265   1  11,12      275   3   51-58     285   0    258
+//  266   1  13,14      276   3   59-66
+//
+pub const length_codes_start = 257;
+
+const match_lengths = [_]MatchLength{
+    .{ .extra_bits = 0, .base_scaled = 0, .base = 3, .code = 257 },
+    .{ .extra_bits = 0, .base_scaled = 1, .base = 4, .code = 258 },
+    .{ .extra_bits = 0, .base_scaled = 2, .base = 5, .code = 259 },
+    .{ .extra_bits = 0, .base_scaled = 3, .base = 6, .code = 260 },
+    .{ .extra_bits = 0, .base_scaled = 4, .base = 7, .code = 261 },
+    .{ .extra_bits = 0, .base_scaled = 5, .base = 8, .code = 262 },
+    .{ .extra_bits = 0, .base_scaled = 6, .base = 9, .code = 263 },
+    .{ .extra_bits = 0, .base_scaled = 7, .base = 10, .code = 264 },
+    .{ .extra_bits = 1, .base_scaled = 8, .base = 11, .code = 265 },
+    .{ .extra_bits = 1, .base_scaled = 10, .base = 13, .code = 266 },
+    .{ .extra_bits = 1, .base_scaled = 12, .base = 15, .code = 267 },
+    .{ .extra_bits = 1, .base_scaled = 14, .base = 17, .code = 268 },
+    .{ .extra_bits = 2, .base_scaled = 16, .base = 19, .code = 269 },
+    .{ .extra_bits = 2, .base_scaled = 20, .base = 23, .code = 270 },
+    .{ .extra_bits = 2, .base_scaled = 24, .base = 27, .code = 271 },
+    .{ .extra_bits = 2, .base_scaled = 28, .base = 31, .code = 272 },
+    .{ .extra_bits = 3, .base_scaled = 32, .base = 35, .code = 273 },
+    .{ .extra_bits = 3, .base_scaled = 40, .base = 43, .code = 274 },
+    .{ .extra_bits = 3, .base_scaled = 48, .base = 51, .code = 275 },
+    .{ .extra_bits = 3, .base_scaled = 56, .base = 59, .code = 276 },
+    .{ .extra_bits = 4, .base_scaled = 64, .base = 67, .code = 277 },
+    .{ .extra_bits = 4, .base_scaled = 80, .base = 83, .code = 278 },
+    .{ .extra_bits = 4, .base_scaled = 96, .base = 99, .code = 279 },
+    .{ .extra_bits = 4, .base_scaled = 112, .base = 115, .code = 280 },
+    .{ .extra_bits = 5, .base_scaled = 128, .base = 131, .code = 281 },
+    .{ .extra_bits = 5, .base_scaled = 160, .base = 163, .code = 282 },
+    .{ .extra_bits = 5, .base_scaled = 192, .base = 195, .code = 283 },
+    .{ .extra_bits = 5, .base_scaled = 224, .base = 227, .code = 284 },
+    .{ .extra_bits = 0, .base_scaled = 255, .base = 258, .code = 285 },
+};
+
+// Used in distanceCode fn to get index in match_distance table for each distance in range 0-32767.
+const match_distances_index = [_]u8{
+    0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,
+    8,  8,  8,  8,  8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9,
+    10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+    11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+    12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+    12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+    14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+    15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+};
+
+const MatchDistance = struct {
+    base_scaled: u16, // base - 1, same as Token dist field
+    base: u16,
+    extra_distance: u16 = 0,
+    code: u8,
+    extra_bits: u4,
+};
+
+// match_distances represents table from rfc (https://datatracker.ietf.org/doc/html/rfc1951#page-12)
+//
+//      Extra           Extra               Extra
+// Code Bits Dist  Code Bits   Dist     Code Bits Distance
+// ---- ---- ----  ---- ----  ------    ---- ---- --------
+//   0   0    1     10   4     33-48    20    9   1025-1536
+//   1   0    2     11   4     49-64    21    9   1537-2048
+//   2   0    3     12   5     65-96    22   10   2049-3072
+//   3   0    4     13   5     97-128   23   10   3073-4096
+//   4   1   5,6    14   6    129-192   24   11   4097-6144
+//   5   1   7,8    15   6    193-256   25   11   6145-8192
+//   6   2   9-12   16   7    257-384   26   12  8193-12288
+//   7   2  13-16   17   7    385-512   27   12 12289-16384
+//   8   3  17-24   18   8    513-768   28   13 16385-24576
+//   9   3  25-32   19   8   769-1024   29   13 24577-32768
+//
+const match_distances = [_]MatchDistance{
+    .{ .extra_bits = 0, .base_scaled = 0x0000, .code = 0, .base = 1 },
+    .{ .extra_bits = 0, .base_scaled = 0x0001, .code = 1, .base = 2 },
+    .{ .extra_bits = 0, .base_scaled = 0x0002, .code = 2, .base = 3 },
+    .{ .extra_bits = 0, .base_scaled = 0x0003, .code = 3, .base = 4 },
+    .{ .extra_bits = 1, .base_scaled = 0x0004, .code = 4, .base = 5 },
+    .{ .extra_bits = 1, .base_scaled = 0x0006, .code = 5, .base = 7 },
+    .{ .extra_bits = 2, .base_scaled = 0x0008, .code = 6, .base = 9 },
+    .{ .extra_bits = 2, .base_scaled = 0x000c, .code = 7, .base = 13 },
+    .{ .extra_bits = 3, .base_scaled = 0x0010, .code = 8, .base = 17 },
+    .{ .extra_bits = 3, .base_scaled = 0x0018, .code = 9, .base = 25 },
+    .{ .extra_bits = 4, .base_scaled = 0x0020, .code = 10, .base = 33 },
+    .{ .extra_bits = 4, .base_scaled = 0x0030, .code = 11, .base = 49 },
+    .{ .extra_bits = 5, .base_scaled = 0x0040, .code = 12, .base = 65 },
+    .{ .extra_bits = 5, .base_scaled = 0x0060, .code = 13, .base = 97 },
+    .{ .extra_bits = 6, .base_scaled = 0x0080, .code = 14, .base = 129 },
+    .{ .extra_bits = 6, .base_scaled = 0x00c0, .code = 15, .base = 193 },
+    .{ .extra_bits = 7, .base_scaled = 0x0100, .code = 16, .base = 257 },
+    .{ .extra_bits = 7, .base_scaled = 0x0180, .code = 17, .base = 385 },
+    .{ .extra_bits = 8, .base_scaled = 0x0200, .code = 18, .base = 513 },
+    .{ .extra_bits = 8, .base_scaled = 0x0300, .code = 19, .base = 769 },
+    .{ .extra_bits = 9, .base_scaled = 0x0400, .code = 20, .base = 1025 },
+    .{ .extra_bits = 9, .base_scaled = 0x0600, .code = 21, .base = 1537 },
+    .{ .extra_bits = 10, .base_scaled = 0x0800, .code = 22, .base = 2049 },
+    .{ .extra_bits = 10, .base_scaled = 0x0c00, .code = 23, .base = 3073 },
+    .{ .extra_bits = 11, .base_scaled = 0x1000, .code = 24, .base = 4097 },
+    .{ .extra_bits = 11, .base_scaled = 0x1800, .code = 25, .base = 6145 },
+    .{ .extra_bits = 12, .base_scaled = 0x2000, .code = 26, .base = 8193 },
+    .{ .extra_bits = 12, .base_scaled = 0x3000, .code = 27, .base = 12289 },
+    .{ .extra_bits = 13, .base_scaled = 0x4000, .code = 28, .base = 16385 },
+    .{ .extra_bits = 13, .base_scaled = 0x6000, .code = 29, .base = 24577 },
+};
+
+test "flate.Token size" {
+    try expect(@sizeOf(Token) == 4);
+}
+
+// testing table https://datatracker.ietf.org/doc/html/rfc1951#page-12
+test "flate.Token MatchLength" {
+    var c = Token.initMatch(1, 4).lengthEncoding();
+    try expect(c.code == 258);
+    try expect(c.extra_bits == 0);
+    try expect(c.extra_length == 0);
+
+    c = Token.initMatch(1, 11).lengthEncoding();
+    try expect(c.code == 265);
+    try expect(c.extra_bits == 1);
+    try expect(c.extra_length == 0);
+
+    c = Token.initMatch(1, 12).lengthEncoding();
+    try expect(c.code == 265);
+    try expect(c.extra_bits == 1);
+    try expect(c.extra_length == 1);
+
+    c = Token.initMatch(1, 130).lengthEncoding();
+    try expect(c.code == 280);
+    try expect(c.extra_bits == 4);
+    try expect(c.extra_length == 130 - 115);
+}
+
+test "flate.Token MatchDistance" {
+    var c = Token.initMatch(1, 4).distanceEncoding();
+    try expect(c.code == 0);
+    try expect(c.extra_bits == 0);
+    try expect(c.extra_distance == 0);
+
+    c = Token.initMatch(192, 4).distanceEncoding();
+    try expect(c.code == 14);
+    try expect(c.extra_bits == 6);
+    try expect(c.extra_distance == 192 - 129);
+}
+
+test "flate.Token match_lengths" {
+    for (match_lengths, 0..) |ml, i| {
+        try expect(@as(u16, ml.base_scaled) + 3 == ml.base);
+        try expect(i + 257 == ml.code);
+    }
+
+    for (match_distances, 0..) |mo, i| {
+        try expect(mo.base_scaled + 1 == mo.base);
+        try expect(i == mo.code);
+    }
+}
diff --git a/lib/std/compress/flate/bit_reader.zig b/lib/std/compress/flate/bit_reader.zig
new file mode 100644
index 0000000000..e8717c8e17
--- /dev/null
+++ b/lib/std/compress/flate/bit_reader.zig
@@ -0,0 +1,333 @@
+const std = @import("std");
+const assert = std.debug.assert;
+const testing = std.testing;
+
+pub fn bitReader(reader: anytype) BitReader(@TypeOf(reader)) {
+    return BitReader(@TypeOf(reader)).init(reader);
+}
+
+/// Bit reader used during inflate (decompression). Has internal buffer of 64
+/// bits which shifts right after bits are consumed. Uses forward_reader to fill
+/// that internal buffer when needed.
+///
+/// readF is the core function. Supports few different ways of getting bits
+/// controlled by flags. In hot path we try to avoid checking whether we need to
+/// fill buffer from forward_reader by calling fill in advance and readF with
+/// buffered flag set.
+///
+pub fn BitReader(comptime ReaderType: type) type {
+    return struct {
+        // Underlying reader used for filling internal bits buffer
+        forward_reader: ReaderType = undefined,
+        // Internal buffer of 64 bits
+        bits: u64 = 0,
+        // Number of bits in the buffer
+        nbits: u32 = 0,
+
+        const Self = @This();
+
+        pub const Error = ReaderType.Error || error{EndOfStream};
+
+        pub fn init(rdr: ReaderType) Self {
+            var self = Self{ .forward_reader = rdr };
+            self.fill(1) catch {};
+            return self;
+        }
+
+        // Try to have `nice` bits are available in buffer. Reads from
+        // forward reader if there is no `nice` bits in buffer. Returns error
+        // if end of forward stream is reached and internal buffer is empty.
+        // It will not error if less than `nice` bits are in buffer, only when
+        // all bits are exhausted. During inflate we usually know what is the
+        // maximum bits for the next step but usually that step will need less
+        // bits to decode. So `nice` is not hard limit, it will just try to have
+        // that number of bits available. If end of forward stream is reached
+        // it may be some extra zero bits in buffer.
+        pub inline fn fill(self: *Self, nice: u6) !void {
+            if (self.nbits >= nice) {
+                return; // We have enought bits
+            }
+            // Read more bits from forward reader
+
+            // Number of empty bytes in bits, round nbits to whole bytes.
+            const empty_bytes =
+                @as(u8, if (self.nbits & 0x7 == 0) 8 else 7) - // 8 for 8, 16, 24..., 7 otherwise
+                (self.nbits >> 3); // 0 for 0-7, 1 for 8-16, ... same as / 8
+
+            var buf: [8]u8 = [_]u8{0} ** 8;
+            const bytes_read = self.forward_reader.read(buf[0..empty_bytes]) catch 0;
+            if (bytes_read > 0) {
+                const u: u64 = std.mem.readInt(u64, buf[0..8], .little);
+                self.bits |= u << @as(u6, @intCast(self.nbits));
+                self.nbits += 8 * @as(u8, @intCast(bytes_read));
+                return;
+            }
+
+            if (self.nbits == 0)
+                return error.EndOfStream;
+        }
+
+        // Read exactly buf.len bytes into buf.
+        pub fn readAll(self: *Self, buf: []u8) !void {
+            assert(self.alignBits() == 0); // internal bits must be at byte boundary
+
+            // First read from internal bits buffer.
+            var n: usize = 0;
+            while (self.nbits > 0 and n < buf.len) {
+                buf[n] = try self.readF(u8, flag.buffered);
+                n += 1;
+            }
+            // Then use forward reader for all other bytes.
+            try self.forward_reader.readNoEof(buf[n..]);
+        }
+
+        pub const flag = struct {
+            pub const peek: u3 = 0b001; // dont advance internal buffer, just get bits, leave them in buffer
+            pub const buffered: u3 = 0b010; // assume that there is no need to fill, fill should be called before
+            pub const reverse: u3 = 0b100; // bit reverse readed bits
+        };
+
+        // Alias for readF(U, 0).
+        pub fn read(self: *Self, comptime U: type) !U {
+            return self.readF(U, 0);
+        }
+
+        // Alias for readF with flag.peak set.
+        pub inline fn peekF(self: *Self, comptime U: type, comptime how: u3) !U {
+            return self.readF(U, how | flag.peek);
+        }
+
+        // Read with flags provided.
+        pub fn readF(self: *Self, comptime U: type, comptime how: u3) !U {
+            const n: u6 = @bitSizeOf(U);
+            switch (how) {
+                0 => { // `normal` read
+                    try self.fill(n); // ensure that there are n bits in the buffer
+                    const u: U = @truncate(self.bits); // get n bits
+                    try self.shift(n); // advance buffer for n
+                    return u;
+                },
+                (flag.peek) => { // no shift, leave bits in the buffer
+                    try self.fill(n);
+                    return @truncate(self.bits);
+                },
+                flag.buffered => { // no fill, assume that buffer has enought bits
+                    const u: U = @truncate(self.bits);
+                    try self.shift(n);
+                    return u;
+                },
+                (flag.reverse) => { // same as 0 with bit reverse
+                    try self.fill(n);
+                    const u: U = @truncate(self.bits);
+                    try self.shift(n);
+                    return @bitReverse(u);
+                },
+                (flag.peek | flag.reverse) => {
+                    try self.fill(n);
+                    return @bitReverse(@as(U, @truncate(self.bits)));
+                },
+                (flag.buffered | flag.reverse) => {
+                    const u: U = @truncate(self.bits);
+                    try self.shift(n);
+                    return @bitReverse(u);
+                },
+                (flag.peek | flag.buffered) => {
+                    return @truncate(self.bits);
+                },
+                (flag.peek | flag.buffered | flag.reverse) => {
+                    return @bitReverse(@as(U, @truncate(self.bits)));
+                },
+            }
+        }
+
+        // Read n number of bits.
+        // Only buffered flag can be used in how.
+        pub fn readN(self: *Self, n: u4, comptime how: u3) !u16 {
+            switch (how) {
+                0 => {
+                    try self.fill(n);
+                },
+                flag.buffered => {},
+                else => unreachable,
+            }
+            const mask: u16 = (@as(u16, 1) << n) - 1;
+            const u: u16 = @as(u16, @truncate(self.bits)) & mask;
+            try self.shift(n);
+            return u;
+        }
+
+        // Advance buffer for n bits.
+        pub fn shift(self: *Self, n: u6) !void {
+            if (n > self.nbits) return error.EndOfStream;
+            self.bits >>= n;
+            self.nbits -= n;
+        }
+
+        // Skip n bytes.
+        pub fn skipBytes(self: *Self, n: u16) !void {
+            for (0..n) |_| {
+                try self.fill(8);
+                try self.shift(8);
+            }
+        }
+
+        // Number of bits to align stream to the byte boundary.
+        fn alignBits(self: *Self) u3 {
+            return @intCast(self.nbits & 0x7);
+        }
+
+        // Align stream to the byte boundary.
+        pub fn alignToByte(self: *Self) void {
+            const ab = self.alignBits();
+            if (ab > 0) self.shift(ab) catch unreachable;
+        }
+
+        // Skip zero terminated string.
+        pub fn skipStringZ(self: *Self) !void {
+            while (true) {
+                if (try self.readF(u8, 0) == 0) break;
+            }
+        }
+
+        // Read deflate fixed fixed code.
+        // Reads first 7 bits, and then mybe 1 or 2 more to get full 7,8 or 9 bit code.
+        // ref: https://datatracker.ietf.org/doc/html/rfc1951#page-12
+        //         Lit Value    Bits        Codes
+        //          ---------    ----        -----
+        //            0 - 143     8          00110000 through
+        //                                   10111111
+        //          144 - 255     9          110010000 through
+        //                                   111111111
+        //          256 - 279     7          0000000 through
+        //                                   0010111
+        //          280 - 287     8          11000000 through
+        //                                   11000111
+        pub fn readFixedCode(self: *Self) !u16 {
+            try self.fill(7 + 2);
+            const code7 = try self.readF(u7, flag.buffered | flag.reverse);
+            if (code7 <= 0b0010_111) { // 7 bits, 256-279, codes 0000_000 - 0010_111
+                return @as(u16, code7) + 256;
+            } else if (code7 <= 0b1011_111) { // 8 bits, 0-143, codes 0011_0000 through 1011_1111
+                return (@as(u16, code7) << 1) + @as(u16, try self.readF(u1, flag.buffered)) - 0b0011_0000;
+            } else if (code7 <= 0b1100_011) { // 8 bit, 280-287, codes 1100_0000 - 1100_0111
+                return (@as(u16, code7 - 0b1100000) << 1) + try self.readF(u1, flag.buffered) + 280;
+            } else { // 9 bit, 144-255, codes 1_1001_0000 - 1_1111_1111
+                return (@as(u16, code7 - 0b1100_100) << 2) + @as(u16, try self.readF(u2, flag.buffered | flag.reverse)) + 144;
+            }
+        }
+    };
+}
+
+test "flate.BitReader" {
+    var fbs = std.io.fixedBufferStream(&[_]u8{ 0xf3, 0x48, 0xcd, 0xc9, 0x00, 0x00 });
+    var br = bitReader(fbs.reader());
+    const F = BitReader(@TypeOf(fbs.reader())).flag;
+
+    try testing.expectEqual(@as(u8, 48), br.nbits);
+    try testing.expectEqual(@as(u64, 0xc9cd48f3), br.bits);
+
+    try testing.expect(try br.readF(u1, 0) == 0b0000_0001);
+    try testing.expect(try br.readF(u2, 0) == 0b0000_0001);
+    try testing.expectEqual(@as(u8, 48 - 3), br.nbits);
+    try testing.expectEqual(@as(u3, 5), br.alignBits());
+
+    try testing.expect(try br.readF(u8, F.peek) == 0b0001_1110);
+    try testing.expect(try br.readF(u9, F.peek) == 0b1_0001_1110);
+    try br.shift(9);
+    try testing.expectEqual(@as(u8, 36), br.nbits);
+    try testing.expectEqual(@as(u3, 4), br.alignBits());
+
+    try testing.expect(try br.readF(u4, 0) == 0b0100);
+    try testing.expectEqual(@as(u8, 32), br.nbits);
+    try testing.expectEqual(@as(u3, 0), br.alignBits());
+
+    try br.shift(1);
+    try testing.expectEqual(@as(u3, 7), br.alignBits());
+    try br.shift(1);
+    try testing.expectEqual(@as(u3, 6), br.alignBits());
+    br.alignToByte();
+    try testing.expectEqual(@as(u3, 0), br.alignBits());
+
+    try testing.expectEqual(@as(u64, 0xc9), br.bits);
+    try testing.expectEqual(@as(u16, 0x9), try br.readN(4, 0));
+    try testing.expectEqual(@as(u16, 0xc), try br.readN(4, 0));
+}
+
+test "flate.BitReader read block type 1 data" {
+    const data = [_]u8{
+        0xf3, 0x48, 0xcd, 0xc9, 0xc9, 0x57, 0x28, 0xcf, // deflate data block type 1
+        0x2f, 0xca, 0x49, 0xe1, 0x02, 0x00,
+        0x0c, 0x01, 0x02, 0x03, //
+        0xaa, 0xbb, 0xcc, 0xdd,
+    };
+    var fbs = std.io.fixedBufferStream(&data);
+    var br = bitReader(fbs.reader());
+    const F = BitReader(@TypeOf(fbs.reader())).flag;
+
+    try testing.expectEqual(@as(u1, 1), try br.readF(u1, 0)); // bfinal
+    try testing.expectEqual(@as(u2, 1), try br.readF(u2, 0)); // block_type
+
+    for ("Hello world\n") |c| {
+        try testing.expectEqual(@as(u8, c), try br.readF(u8, F.reverse) - 0x30);
+    }
+    try testing.expectEqual(@as(u7, 0), try br.readF(u7, 0)); // end of block
+    br.alignToByte();
+    try testing.expectEqual(@as(u32, 0x0302010c), try br.readF(u32, 0));
+    try testing.expectEqual(@as(u16, 0xbbaa), try br.readF(u16, 0));
+    try testing.expectEqual(@as(u16, 0xddcc), try br.readF(u16, 0));
+}
+
+test "flate.BitReader init" {
+    const data = [_]u8{
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+    };
+    var fbs = std.io.fixedBufferStream(&data);
+    var br = bitReader(fbs.reader());
+
+    try testing.expectEqual(@as(u64, 0x08_07_06_05_04_03_02_01), br.bits);
+    try br.shift(8);
+    try testing.expectEqual(@as(u64, 0x00_08_07_06_05_04_03_02), br.bits);
+    try br.fill(60); // fill with 1 byte
+    try testing.expectEqual(@as(u64, 0x01_08_07_06_05_04_03_02), br.bits);
+    try br.shift(8 * 4 + 4);
+    try testing.expectEqual(@as(u64, 0x00_00_00_00_00_10_80_70), br.bits);
+
+    try br.fill(60); // fill with 4 bytes (shift by 4)
+    try testing.expectEqual(@as(u64, 0x00_50_40_30_20_10_80_70), br.bits);
+    try testing.expectEqual(@as(u8, 8 * 7 + 4), br.nbits);
+
+    try br.shift(@intCast(br.nbits)); // clear buffer
+    try br.fill(8); // refill with the rest of the bytes
+    try testing.expectEqual(@as(u64, 0x00_00_00_00_00_08_07_06), br.bits);
+}
+
+test "flate.BitReader readAll" {
+    const data = [_]u8{
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+    };
+    var fbs = std.io.fixedBufferStream(&data);
+    var br = bitReader(fbs.reader());
+
+    try testing.expectEqual(@as(u64, 0x08_07_06_05_04_03_02_01), br.bits);
+
+    var out: [16]u8 = undefined;
+    try br.readAll(out[0..]);
+    try testing.expect(br.nbits == 0);
+    try testing.expect(br.bits == 0);
+
+    try testing.expectEqualSlices(u8, data[0..16], &out);
+}
+
+test "flate.BitReader readFixedCode" {
+    const fixed_codes = @import("huffman_encoder.zig").fixed_codes;
+
+    var fbs = std.io.fixedBufferStream(&fixed_codes);
+    var rdr = bitReader(fbs.reader());
+
+    for (0..286) |c| {
+        try testing.expectEqual(c, try rdr.readFixedCode());
+    }
+    try testing.expect(rdr.nbits == 0);
+}
diff --git a/lib/std/compress/flate/bit_writer.zig b/lib/std/compress/flate/bit_writer.zig
new file mode 100644
index 0000000000..b5d84c7e2a
--- /dev/null
+++ b/lib/std/compress/flate/bit_writer.zig
@@ -0,0 +1,99 @@
+const std = @import("std");
+const assert = std.debug.assert;
+
+/// Bit writer for use in deflate (compression).
+///
+/// Has internal bits buffer of 64 bits and internal bytes buffer of 248 bytes.
+/// When we accumulate 48 bits 6 bytes are moved to the bytes buffer. When we
+/// accumulate 240 bytes they are flushed to the underlying inner_writer.
+///
+pub fn BitWriter(comptime WriterType: type) type {
+    // buffer_flush_size indicates the buffer size
+    // after which bytes are flushed to the writer.
+    // Should preferably be a multiple of 6, since
+    // we accumulate 6 bytes between writes to the buffer.
+    const buffer_flush_size = 240;
+
+    // buffer_size is the actual output byte buffer size.
+    // It must have additional headroom for a flush
+    // which can contain up to 8 bytes.
+    const buffer_size = buffer_flush_size + 8;
+
+    return struct {
+        inner_writer: WriterType,
+
+        // Data waiting to be written is bytes[0 .. nbytes]
+        // and then the low nbits of bits.  Data is always written
+        // sequentially into the bytes array.
+        bits: u64 = 0,
+        nbits: u32 = 0, // number of bits
+        bytes: [buffer_size]u8 = undefined,
+        nbytes: u32 = 0, // number of bytes
+
+        const Self = @This();
+
+        pub const Error = WriterType.Error || error{UnfinishedBits};
+
+        pub fn init(writer: WriterType) Self {
+            return .{ .inner_writer = writer };
+        }
+
+        pub fn setWriter(self: *Self, new_writer: WriterType) void {
+            //assert(self.bits == 0 and self.nbits == 0 and self.nbytes == 0);
+            self.inner_writer = new_writer;
+        }
+
+        pub fn flush(self: *Self) Error!void {
+            var n = self.nbytes;
+            while (self.nbits != 0) {
+                self.bytes[n] = @as(u8, @truncate(self.bits));
+                self.bits >>= 8;
+                if (self.nbits > 8) { // Avoid underflow
+                    self.nbits -= 8;
+                } else {
+                    self.nbits = 0;
+                }
+                n += 1;
+            }
+            self.bits = 0;
+            _ = try self.inner_writer.write(self.bytes[0..n]);
+            self.nbytes = 0;
+        }
+
+        pub fn writeBits(self: *Self, b: u32, nb: u32) Error!void {
+            self.bits |= @as(u64, @intCast(b)) << @as(u6, @intCast(self.nbits));
+            self.nbits += nb;
+            if (self.nbits < 48)
+                return;
+
+            var n = self.nbytes;
+            std.mem.writeInt(u64, self.bytes[n..][0..8], self.bits, .little);
+            n += 6;
+            if (n >= buffer_flush_size) {
+                _ = try self.inner_writer.write(self.bytes[0..n]);
+                n = 0;
+            }
+            self.nbytes = n;
+            self.bits >>= 48;
+            self.nbits -= 48;
+        }
+
+        pub fn writeBytes(self: *Self, bytes: []const u8) Error!void {
+            var n = self.nbytes;
+            if (self.nbits & 7 != 0) {
+                return error.UnfinishedBits;
+            }
+            while (self.nbits != 0) {
+                self.bytes[n] = @as(u8, @truncate(self.bits));
+                self.bits >>= 8;
+                self.nbits -= 8;
+                n += 1;
+            }
+            if (n != 0) {
+                _ = try self.inner_writer.write(self.bytes[0..n]);
+            }
+            self.nbytes = 0;
+            _ = try self.inner_writer.write(bytes);
+        }
+    };
+}
diff --git a/lib/std/compress/flate/block_writer.zig b/lib/std/compress/flate/block_writer.zig
new file mode 100644
index 0000000000..394f1cbec5
--- /dev/null
+++ b/lib/std/compress/flate/block_writer.zig
@@ -0,0 +1,706 @@
+const std = @import("std");
+const io = std.io;
+const assert = std.debug.assert;
+
+const hc = @import("huffman_encoder.zig");
+const consts = @import("consts.zig").huffman;
+const Token = @import("Token.zig");
+const BitWriter = @import("bit_writer.zig").BitWriter;
+
+pub fn blockWriter(writer: anytype) BlockWriter(@TypeOf(writer)) {
+    return BlockWriter(@TypeOf(writer)).init(writer);
+}
+
+/// Accepts list of tokens, decides what is best block type to write. What block
+/// type will provide best compression. Writes header and body of the block.
+///
+pub fn BlockWriter(comptime WriterType: type) type {
+    const BitWriterType = BitWriter(WriterType);
+    return struct {
+        const codegen_order = consts.codegen_order;
+        const end_code_mark = 255;
+        const Self = @This();
+
+        pub const Error = BitWriterType.Error;
+        bit_writer: BitWriterType,
+
+        codegen_freq: [consts.codegen_code_count]u16 = undefined,
+        literal_freq: [consts.max_num_lit]u16 = undefined,
+        distance_freq: [consts.distance_code_count]u16 = undefined,
+        codegen: [consts.max_num_lit + consts.distance_code_count + 1]u8 = undefined,
+        literal_encoding: hc.LiteralEncoder = .{},
+        distance_encoding: hc.DistanceEncoder = .{},
+        codegen_encoding: hc.CodegenEncoder = .{},
+        fixed_literal_encoding: hc.LiteralEncoder,
+        fixed_distance_encoding: hc.DistanceEncoder,
+        huff_distance: hc.DistanceEncoder,
+
+        pub fn init(writer: WriterType) Self {
+            return .{
+                .bit_writer = BitWriterType.init(writer),
+                .fixed_literal_encoding = hc.fixedLiteralEncoder(),
+                .fixed_distance_encoding = hc.fixedDistanceEncoder(),
+                .huff_distance = hc.huffmanDistanceEncoder(),
+            };
+        }
+
+        /// Flush intrenal bit buffer to the writer.
+        /// Should be called only when bit stream is at byte boundary.
+        ///
+        /// That is after final block; when last byte could be incomplete or
+        /// after stored block; which is aligned to the byte bounday (it has x
+        /// padding bits after first 3 bits).
+        pub fn flush(self: *Self) Error!void {
+            try self.bit_writer.flush();
+        }
+
+        pub fn setWriter(self: *Self, new_writer: WriterType) void {
+            self.bit_writer.setWriter(new_writer);
+        }
+
+        fn writeCode(self: *Self, c: hc.HuffCode) Error!void {
+            try self.bit_writer.writeBits(c.code, c.len);
+        }
+
+        // RFC 1951 3.2.7 specifies a special run-length encoding for specifying
+        // the literal and distance lengths arrays (which are concatenated into a single
+        // array).  This method generates that run-length encoding.
+        //
+        // The result is written into the codegen array, and the frequencies
+        // of each code is written into the codegen_freq array.
+        // Codes 0-15 are single byte codes. Codes 16-18 are followed by additional
+        // information. Code bad_code is an end marker
+        //
+        // num_literals: The number of literals in literal_encoding
+        // num_distances: The number of distances in distance_encoding
+        // lit_enc: The literal encoder to use
+        // dist_enc: The distance encoder to use
+        fn generateCodegen(
+            self: *Self,
+            num_literals: u32,
+            num_distances: u32,
+            lit_enc: *hc.LiteralEncoder,
+            dist_enc: *hc.DistanceEncoder,
+        ) void {
+            for (self.codegen_freq, 0..) |_, i| {
+                self.codegen_freq[i] = 0;
+            }
+
+            // Note that we are using codegen both as a temporary variable for holding
+            // a copy of the frequencies, and as the place where we put the result.
+            // This is fine because the output is always shorter than the input used
+            // so far.
+            var codegen = &self.codegen; // cache
+            // Copy the concatenated code sizes to codegen. Put a marker at the end.
+            var cgnl = codegen[0..num_literals];
+            for (cgnl, 0..) |_, i| {
+                cgnl[i] = @as(u8, @intCast(lit_enc.codes[i].len));
+            }
+
+            cgnl = codegen[num_literals .. num_literals + num_distances];
+            for (cgnl, 0..) |_, i| {
+                cgnl[i] = @as(u8, @intCast(dist_enc.codes[i].len));
+            }
+            codegen[num_literals + num_distances] = end_code_mark;
+
+            var size = codegen[0];
+            var count: i32 = 1;
+            var out_index: u32 = 0;
+            var in_index: u32 = 1;
+            while (size != end_code_mark) : (in_index += 1) {
+                // INVARIANT: We have seen "count" copies of size that have not yet
+                // had output generated for them.
+                const next_size = codegen[in_index];
+                if (next_size == size) {
+                    count += 1;
+                    continue;
+                }
+                // We need to generate codegen indicating "count" of size.
+                if (size != 0) {
+                    codegen[out_index] = size;
+                    out_index += 1;
+                    self.codegen_freq[size] += 1;
+                    count -= 1;
+                    while (count >= 3) {
+                        var n: i32 = 6;
+                        if (n > count) {
+                            n = count;
+                        }
+                        codegen[out_index] = 16;
+                        out_index += 1;
+                        codegen[out_index] = @as(u8, @intCast(n - 3));
+                        out_index += 1;
+                        self.codegen_freq[16] += 1;
+                        count -= n;
+                    }
+                } else {
+                    while (count >= 11) {
+                        var n: i32 = 138;
+                        if (n > count) {
+                            n = count;
+                        }
+                        codegen[out_index] = 18;
+                        out_index += 1;
+                        codegen[out_index] = @as(u8, @intCast(n - 11));
+                        out_index += 1;
+                        self.codegen_freq[18] += 1;
+                        count -= n;
+                    }
+                    if (count >= 3) {
+                        // 3 <= count <= 10
+                        codegen[out_index] = 17;
+                        out_index += 1;
+                        codegen[out_index] = @as(u8, @intCast(count - 3));
+                        out_index += 1;
+                        self.codegen_freq[17] += 1;
+                        count = 0;
+                    }
+                }
+                count -= 1;
+                while (count >= 0) : (count -= 1) {
+                    codegen[out_index] = size;
+                    out_index += 1;
+                    self.codegen_freq[size] += 1;
+                }
+                // Set up invariant for next time through the loop.
+                size = next_size;
+                count = 1;
+            }
+            // Marker indicating the end of the codegen.
+            codegen[out_index] = end_code_mark;
+        }
+
+        const DynamicSize = struct {
+            size: u32,
+            num_codegens: u32,
+        };
+
+        // dynamicSize returns the size of dynamically encoded data in bits.
+        fn dynamicSize(
+            self: *Self,
+            lit_enc: *hc.LiteralEncoder, // literal encoder
+            dist_enc: *hc.DistanceEncoder, // distance encoder
+            extra_bits: u32,
+        ) DynamicSize {
+            var num_codegens = self.codegen_freq.len;
+            while (num_codegens > 4 and self.codegen_freq[codegen_order[num_codegens - 1]] == 0) {
+                num_codegens -= 1;
+            }
+            const header = 3 + 5 + 5 + 4 + (3 * num_codegens) +
+                self.codegen_encoding.bitLength(self.codegen_freq[0..]) +
+                self.codegen_freq[16] * 2 +
+                self.codegen_freq[17] * 3 +
+                self.codegen_freq[18] * 7;
+            const size = header +
+                lit_enc.bitLength(&self.literal_freq) +
+                dist_enc.bitLength(&self.distance_freq) +
+                extra_bits;
+
+            return DynamicSize{
+                .size = @as(u32, @intCast(size)),
+                .num_codegens = @as(u32, @intCast(num_codegens)),
+            };
+        }
+
+        // fixedSize returns the size of dynamically encoded data in bits.
+        fn fixedSize(self: *Self, extra_bits: u32) u32 {
+            return 3 +
+                self.fixed_literal_encoding.bitLength(&self.literal_freq) +
+                self.fixed_distance_encoding.bitLength(&self.distance_freq) +
+                extra_bits;
+        }
+
+        const StoredSize = struct {
+            size: u32,
+            storable: bool,
+        };
+
+        // storedSizeFits calculates the stored size, including header.
+        // The function returns the size in bits and whether the block
+        // fits inside a single block.
+        fn storedSizeFits(in: ?[]const u8) StoredSize {
+            if (in == null) {
+                return .{ .size = 0, .storable = false };
+            }
+            if (in.?.len <= consts.max_store_block_size) {
+                return .{ .size = @as(u32, @intCast((in.?.len + 5) * 8)), .storable = true };
+            }
+            return .{ .size = 0, .storable = false };
+        }
+
+        // Write the header of a dynamic Huffman block to the output stream.
+        //
+        //  num_literals: The number of literals specified in codegen
+        //  num_distances: The number of distances specified in codegen
+        //  num_codegens: The number of codegens used in codegen
+        //  eof: Is it the end-of-file? (end of stream)
+        fn dynamicHeader(
+            self: *Self,
+            num_literals: u32,
+            num_distances: u32,
+            num_codegens: u32,
+            eof: bool,
+        ) Error!void {
+            const first_bits: u32 = if (eof) 5 else 4;
+            try self.bit_writer.writeBits(first_bits, 3);
+            try self.bit_writer.writeBits(num_literals - 257, 5);
+            try self.bit_writer.writeBits(num_distances - 1, 5);
+            try self.bit_writer.writeBits(num_codegens - 4, 4);
+
+            var i: u32 = 0;
+            while (i < num_codegens) : (i += 1) {
+                const value = self.codegen_encoding.codes[codegen_order[i]].len;
+                try self.bit_writer.writeBits(value, 3);
+            }
+
+            i = 0;
+            while (true) {
+                const code_word: u32 = @as(u32, @intCast(self.codegen[i]));
+                i += 1;
+                if (code_word == end_code_mark) {
+                    break;
+                }
+                try self.writeCode(self.codegen_encoding.codes[@as(u32, @intCast(code_word))]);
+
+                switch (code_word) {
+                    16 => {
+                        try self.bit_writer.writeBits(self.codegen[i], 2);
+                        i += 1;
+                    },
+                    17 => {
+                        try self.bit_writer.writeBits(self.codegen[i], 3);
+                        i += 1;
+                    },
+                    18 => {
+                        try self.bit_writer.writeBits(self.codegen[i], 7);
+                        i += 1;
+                    },
+                    else => {},
+                }
+            }
+        }
+
+        fn storedHeader(self: *Self, length: usize, eof: bool) Error!void {
+            assert(length <= 65535);
+            const flag: u32 = if (eof) 1 else 0;
+            try self.bit_writer.writeBits(flag, 3);
+            try self.flush();
+            const l: u16 = @intCast(length);
+            try self.bit_writer.writeBits(l, 16);
+            try self.bit_writer.writeBits(~l, 16);
+        }
+
+        fn fixedHeader(self: *Self, eof: bool) Error!void {
+            // Indicate that we are a fixed Huffman block
+            var value: u32 = 2;
+            if (eof) {
+                value = 3;
+            }
+            try self.bit_writer.writeBits(value, 3);
+        }
+
+        // Write a block of tokens with the smallest encoding. Will choose block type.
+        // The original input can be supplied, and if the huffman encoded data
+        // is larger than the original bytes, the data will be written as a
+        // stored block.
+        // If the input is null, the tokens will always be Huffman encoded.
+        pub fn write(self: *Self, tokens: []const Token, eof: bool, input: ?[]const u8) Error!void {
+            const lit_and_dist = self.indexTokens(tokens);
+            const num_literals = lit_and_dist.num_literals;
+            const num_distances = lit_and_dist.num_distances;
+
+            var extra_bits: u32 = 0;
+            const ret = storedSizeFits(input);
+            const stored_size = ret.size;
+            const storable = ret.storable;
+
+            if (storable) {
+                // We only bother calculating the costs of the extra bits required by
+                // the length of distance fields (which will be the same for both fixed
+                // and dynamic encoding), if we need to compare those two encodings
+                // against stored encoding.
+                var length_code: u16 = Token.length_codes_start + 8;
+                while (length_code < num_literals) : (length_code += 1) {
+                    // First eight length codes have extra size = 0.
+                    extra_bits += @as(u32, @intCast(self.literal_freq[length_code])) *
+                        @as(u32, @intCast(Token.lengthExtraBits(length_code)));
+                }
+                var distance_code: u16 = 4;
+                while (distance_code < num_distances) : (distance_code += 1) {
+                    // First four distance codes have extra size = 0.
+                    extra_bits += @as(u32, @intCast(self.distance_freq[distance_code])) *
+                        @as(u32, @intCast(Token.distanceExtraBits(distance_code)));
+                }
+            }
+
+            // Figure out smallest code.
+            // Fixed Huffman baseline.
+            var literal_encoding = &self.fixed_literal_encoding;
+            var distance_encoding = &self.fixed_distance_encoding;
+            var size = self.fixedSize(extra_bits);
+
+            // Dynamic Huffman?
+            var num_codegens: u32 = 0;
+
+            // Generate codegen and codegenFrequencies, which indicates how to encode
+            // the literal_encoding and the distance_encoding.
+            self.generateCodegen(
+                num_literals,
+                num_distances,
+                &self.literal_encoding,
+                &self.distance_encoding,
+            );
+            self.codegen_encoding.generate(self.codegen_freq[0..], 7);
+            const dynamic_size = self.dynamicSize(
+                &self.literal_encoding,
+                &self.distance_encoding,
+                extra_bits,
+            );
+            const dyn_size = dynamic_size.size;
+            num_codegens = dynamic_size.num_codegens;
+
+            if (dyn_size < size) {
+                size = dyn_size;
+                literal_encoding = &self.literal_encoding;
+                distance_encoding = &self.distance_encoding;
+            }
+
+            // Stored bytes?
+            if (storable and stored_size < size) {
+                try self.storedBlock(input.?, eof);
+                return;
+            }
+
+            // Huffman.
+            if (@intFromPtr(literal_encoding) == @intFromPtr(&self.fixed_literal_encoding)) {
+                try self.fixedHeader(eof);
+            } else {
+                try self.dynamicHeader(num_literals, num_distances, num_codegens, eof);
+            }
+
+            // Write the tokens.
+            try self.writeTokens(tokens, &literal_encoding.codes, &distance_encoding.codes);
+        }
+
+        pub fn storedBlock(self: *Self, input: []const u8, eof: bool) Error!void {
+            try self.storedHeader(input.len, eof);
+            try self.bit_writer.writeBytes(input);
+        }
+
+        // writeBlockDynamic encodes a block using a dynamic Huffman table.
+        // This should be used if the symbols used have a disproportionate
+        // histogram distribution.
+        // If input is supplied and the compression savings are below 1/16th of the
+        // input size the block is stored.
+        fn dynamicBlock(
+            self: *Self,
+            tokens: []const Token,
+            eof: bool,
+            input: ?[]const u8,
+        ) Error!void {
+            const total_tokens = self.indexTokens(tokens);
+            const num_literals = total_tokens.num_literals;
+            const num_distances = total_tokens.num_distances;
+
+            // Generate codegen and codegenFrequencies, which indicates how to encode
+            // the literal_encoding and the distance_encoding.
+            self.generateCodegen(
+                num_literals,
+                num_distances,
+                &self.literal_encoding,
+                &self.distance_encoding,
+            );
+            self.codegen_encoding.generate(self.codegen_freq[0..], 7);
+            const dynamic_size = self.dynamicSize(&self.literal_encoding, &self.distance_encoding, 0);
+            const size = dynamic_size.size;
+            const num_codegens = dynamic_size.num_codegens;
+
+            // Store bytes, if we don't get a reasonable improvement.
+
+            const stored_size = storedSizeFits(input);
+            const ssize = stored_size.size;
+            const storable = stored_size.storable;
+            if (storable and ssize < (size + (size >> 4))) {
+                try self.storedBlock(input.?, eof);
+                return;
+            }
+
+            // Write Huffman table.
+            try self.dynamicHeader(num_literals, num_distances, num_codegens, eof);
+
+            // Write the tokens.
+            try self.writeTokens(tokens, &self.literal_encoding.codes, &self.distance_encoding.codes);
+        }
+
+        const TotalIndexedTokens = struct {
+            num_literals: u32,
+            num_distances: u32,
+        };
+
+        // Indexes a slice of tokens followed by an end_block_marker, and updates
+        // literal_freq and distance_freq, and generates literal_encoding
+        // and distance_encoding.
+        // The number of literal and distance tokens is returned.
+        fn indexTokens(self: *Self, tokens: []const Token) TotalIndexedTokens {
+            var num_literals: u32 = 0;
+            var num_distances: u32 = 0;
+
+            for (self.literal_freq, 0..) |_, i| {
+                self.literal_freq[i] = 0;
+            }
+            for (self.distance_freq, 0..) |_, i| {
+                self.distance_freq[i] = 0;
+            }
+
+            for (tokens) |t| {
+                if (t.kind == Token.Kind.literal) {
+                    self.literal_freq[t.literal()] += 1;
+                    continue;
+                }
+                self.literal_freq[t.lengthCode()] += 1;
+                self.distance_freq[t.distanceCode()] += 1;
+            }
+            // add end_block_marker token at the end
+            self.literal_freq[consts.end_block_marker] += 1;
+
+            // get the number of literals
+            num_literals = @as(u32, @intCast(self.literal_freq.len));
+            while (self.literal_freq[num_literals - 1] == 0) {
+                num_literals -= 1;
+            }
+            // get the number of distances
+            num_distances = @as(u32, @intCast(self.distance_freq.len));
+            while (num_distances > 0 and self.distance_freq[num_distances - 1] == 0) {
+                num_distances -= 1;
+            }
+            if (num_distances == 0) {
+                // We haven't found a single match. If we want to go with the dynamic encoding,
+                // we should count at least one distance to be sure that the distance huffman tree could be encoded.
+                self.distance_freq[0] = 1;
+                num_distances = 1;
+            }
+            self.literal_encoding.generate(&self.literal_freq, 15);
+            self.distance_encoding.generate(&self.distance_freq, 15);
+            return TotalIndexedTokens{
+                .num_literals = num_literals,
+                .num_distances = num_distances,
+            };
+        }
+
+        // Writes a slice of tokens to the output followed by and end_block_marker.
+        // codes for literal and distance encoding must be supplied.
+        fn writeTokens(
+            self: *Self,
+            tokens: []const Token,
+            le_codes: []hc.HuffCode,
+            oe_codes: []hc.HuffCode,
+        ) Error!void {
+            for (tokens) |t| {
+                if (t.kind == Token.Kind.literal) {
+                    try self.writeCode(le_codes[t.literal()]);
+                    continue;
+                }
+
+                // Write the length
+                const le = t.lengthEncoding();
+                try self.writeCode(le_codes[le.code]);
+                if (le.extra_bits > 0) {
+                    try self.bit_writer.writeBits(le.extra_length, le.extra_bits);
+                }
+
+                // Write the distance
+                const oe = t.distanceEncoding();
+                try self.writeCode(oe_codes[oe.code]);
+                if (oe.extra_bits > 0) {
+                    try self.bit_writer.writeBits(oe.extra_distance, oe.extra_bits);
+                }
+            }
+            // add end_block_marker at the end
+            try self.writeCode(le_codes[consts.end_block_marker]);
+        }
+
+        // Encodes a block of bytes as either Huffman encoded literals or uncompressed bytes
+        // if the results only gains very little from compression.
+        pub fn huffmanBlock(self: *Self, input: []const u8, eof: bool) Error!void {
+            // Add everything as literals
+            histogram(input, &self.literal_freq);
+
+            self.literal_freq[consts.end_block_marker] = 1;
+
+            const num_literals = consts.end_block_marker + 1;
+            self.distance_freq[0] = 1;
+            const num_distances = 1;
+
+            self.literal_encoding.generate(&self.literal_freq, 15);
+
+            // Figure out smallest code.
+            // Always use dynamic Huffman or Store
+            var num_codegens: u32 = 0;
+
+            // Generate codegen and codegenFrequencies, which indicates how to encode
+            // the literal_encoding and the distance_encoding.
+            self.generateCodegen(
+                num_literals,
+                num_distances,
+                &self.literal_encoding,
+                &self.huff_distance,
+            );
+            self.codegen_encoding.generate(self.codegen_freq[0..], 7);
+            const dynamic_size = self.dynamicSize(&self.literal_encoding, &self.huff_distance, 0);
+            const size = dynamic_size.size;
+            num_codegens = dynamic_size.num_codegens;
+
+            // Store bytes, if we don't get a reasonable improvement.
+            const stored_size_ret = storedSizeFits(input);
+            const ssize = stored_size_ret.size;
+            const storable = stored_size_ret.storable;
+
+            if (storable and ssize < (size + (size >> 4))) {
+                try self.storedBlock(input, eof);
+                return;
+            }
+
+            // Huffman.
+            try self.dynamicHeader(num_literals, num_distances, num_codegens, eof);
+            const encoding = self.literal_encoding.codes[0..257];
+
+            for (input) |t| {
+                const c = encoding[t];
+                try self.bit_writer.writeBits(c.code, c.len);
+            }
+            try self.writeCode(encoding[consts.end_block_marker]);
+        }
+
+        // histogram accumulates a histogram of b in h.
+        fn histogram(b: []const u8, h: *[286]u16) void {
+            // Clear histogram
+            for (h, 0..) |_, i| {
+                h[i] = 0;
+            }
+
+            var lh = h.*[0..256];
+            for (b) |t| {
+                lh[t] += 1;
+            }
+        }
+    };
+}
+
+// tests
+const expect = std.testing.expect;
+const fmt = std.fmt;
+const testing = std.testing;
+const ArrayList = std.ArrayList;
+
+const TestCase = @import("testdata/block_writer.zig").TestCase;
+const testCases = @import("testdata/block_writer.zig").testCases;
+
+// tests if the writeBlock encoding has changed.
+test "flate.BlockWriter write" {
+    inline for (0..testCases.len) |i| {
+        try testBlock(testCases[i], .write_block);
+    }
+}
+
+// tests if the writeBlockDynamic encoding has changed.
+test "flate.BlockWriter dynamicBlock" {
+    inline for (0..testCases.len) |i| {
+        try testBlock(testCases[i], .write_dyn_block);
+    }
+}
+
+test "flate.BlockWriter huffmanBlock" {
+    inline for (0..testCases.len) |i| {
+        try testBlock(testCases[i], .write_huffman_block);
+    }
+    try testBlock(.{
+        .tokens = &[_]Token{},
+        .input = "huffman-rand-max.input",
+        .want = "huffman-rand-max.{s}.expect",
+    }, .write_huffman_block);
+}
+
+const TestFn = enum {
+    write_block,
+    write_dyn_block, // write dynamic block
+    write_huffman_block,
+
+    fn to_s(self: TestFn) []const u8 {
+        return switch (self) {
+            .write_block => "wb",
+            .write_dyn_block => "dyn",
+            .write_huffman_block => "huff",
+        };
+    }
+
+    fn write(
+        comptime self: TestFn,
+        bw: anytype,
+        tok: []const Token,
+        input: ?[]const u8,
+        final: bool,
+    ) !void {
+        switch (self) {
+            .write_block => try bw.write(tok, final, input),
+            .write_dyn_block => try bw.dynamicBlock(tok, final, input),
+            .write_huffman_block => try bw.huffmanBlock(input.?, final),
+        }
+        try bw.flush();
+    }
+};
+
+// testBlock tests a block against its references
+//
+// size
+//  64K [file-name].input                  - input non compressed file
+// 8.1K [file-name].golden                 -
+//   78 [file-name].dyn.expect             - output with writeBlockDynamic
+//   78 [file-name].wb.expect              - output with writeBlock
+// 8.1K [file-name].huff.expect            - output with writeBlockHuff
+//   78 [file-name].dyn.expect-noinput     - output with writeBlockDynamic when input is null
+//   78 [file-name].wb.expect-noinput      - output with writeBlock when input is null
+//
+//   wb   - writeBlock
+//   dyn  - writeBlockDynamic
+//   huff - writeBlockHuff
+//
+fn testBlock(comptime tc: TestCase, comptime tfn: TestFn) !void {
+    if (tc.input.len != 0 and tc.want.len != 0) {
+        const want_name = comptime fmt.comptimePrint(tc.want, .{tfn.to_s()});
+        const input = @embedFile("testdata/block_writer/" ++ tc.input);
+        const want = @embedFile("testdata/block_writer/" ++ want_name);
+        try testWriteBlock(tfn, input, want, tc.tokens);
+    }
+
+    if (tfn == .write_huffman_block) {
+        return;
+    }
+
+    const want_name_no_input = comptime fmt.comptimePrint(tc.want_no_input, .{tfn.to_s()});
+    const want = @embedFile("testdata/block_writer/" ++ want_name_no_input);
+    try testWriteBlock(tfn, null, want, tc.tokens);
+}
+
+// Uses writer function `tfn` to write `tokens`, tests that we got `want` as output.
+fn testWriteBlock(comptime tfn: TestFn, input: ?[]const u8, want: []const u8, tokens: []const Token) !void {
+    var buf = ArrayList(u8).init(testing.allocator);
+    var bw = blockWriter(buf.writer());
+    try tfn.write(&bw, tokens, input, false);
+    var got = buf.items;
+    try testing.expectEqualSlices(u8, want, got); // expect writeBlock to yield expected result
+    try expect(got[0] & 0b0000_0001 == 0); // bfinal is not set
+    //
+    // Test if the writer produces the same output after reset.
+    buf.deinit();
+    buf = ArrayList(u8).init(testing.allocator);
+    defer buf.deinit();
+    bw.setWriter(buf.writer());
+
+    try tfn.write(&bw, tokens, input, true);
+    try bw.flush();
+    got = buf.items;
+
+    try expect(got[0] & 1 == 1); // bfinal is set
+    buf.items[0] &= 0b1111_1110; // remove bfinal bit, so we can run test slices
+    try testing.expectEqualSlices(u8, want, got); // expect writeBlock to yield expected result
+}
diff --git a/lib/std/compress/flate/consts.zig b/lib/std/compress/flate/consts.zig
new file mode 100644
index 0000000000..c28b40f68e
--- /dev/null
+++ b/lib/std/compress/flate/consts.zig
@@ -0,0 +1,49 @@
+pub const deflate = struct {
+    // Number of tokens to accumlate in deflate before starting block encoding.
+    //
+    // In zlib this depends on memlevel: 6 + memlevel, where default memlevel is
+    // 8 and max 9 that gives 14 or 15 bits.
+    pub const tokens = 1 << 15;
+};
+
+pub const match = struct {
+    pub const base_length = 3; // smallest match length per the RFC section 3.2.5
+    pub const min_length = 4; // min length used in this algorithm
+    pub const max_length = 258;
+
+    pub const min_distance = 1;
+    pub const max_distance = 32768;
+};
+
+pub const history = struct {
+    pub const len = match.max_distance;
+};
+
+pub const lookup = struct {
+    pub const bits = 15;
+    pub const len = 1 << bits;
+    pub const shift = 32 - bits;
+};
+
+pub const huffman = struct {
+    // The odd order in which the codegen code sizes are written.
+    pub const codegen_order = [_]u32{ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };
+    // The number of codegen codes.
+    pub const codegen_code_count = 19;
+
+    // The largest distance code.
+    pub const distance_code_count = 30;
+
+    // Maximum number of literals.
+    pub const max_num_lit = 286;
+
+    // Max number of frequencies used for a Huffman Code
+    // Possible lengths are codegen_code_count (19), distance_code_count (30) and max_num_lit (286).
+    // The largest of these is max_num_lit.
+    pub const max_num_frequencies = max_num_lit;
+
+    // Biggest block size for uncompressed block.
+    pub const max_store_block_size = 65535;
+    // The special code used to mark the end of a block.
+    pub const end_block_marker = 256;
+};
diff --git a/lib/std/compress/flate/container.zig b/lib/std/compress/flate/container.zig
new file mode 100644
index 0000000000..9e6f742757
--- /dev/null
+++ b/lib/std/compress/flate/container.zig
@@ -0,0 +1,205 @@
+const std = @import("std");
+
+/// Container of the deflate bit stream body. Container adds header before
+/// deflate bit stream and footer after. It can bi gzip, zlib or raw (no header,
+/// no footer, raw bit stream).
+///
+/// Zlib format is defined in rfc 1950. Header has 2 bytes and footer 4 bytes
+/// addler 32 checksum.
+///
+/// Gzip format is defined in rfc 1952. Header has 10+ bytes and footer 4 bytes
+/// crc32 checksum and 4 bytes of uncompressed data length.
+///
+///
+/// rfc 1950: https://datatracker.ietf.org/doc/html/rfc1950#page-4
+/// rfc 1952: https://datatracker.ietf.org/doc/html/rfc1952#page-5
+///
+pub const Container = enum {
+    raw, // no header or footer
+    gzip, // gzip header and footer
+    zlib, // zlib header and footer
+
+    pub fn size(w: Container) usize {
+        return headerSize(w) + footerSize(w);
+    }
+
+    pub fn headerSize(w: Container) usize {
+        return switch (w) {
+            .gzip => 10,
+            .zlib => 2,
+            .raw => 0,
+        };
+    }
+
+    pub fn footerSize(w: Container) usize {
+        return switch (w) {
+            .gzip => 8,
+            .zlib => 4,
+            .raw => 0,
+        };
+    }
+
+    pub const list = [_]Container{ .raw, .gzip, .zlib };
+
+    pub const Error = error{
+        BadGzipHeader,
+        BadZlibHeader,
+        WrongGzipChecksum,
+        WrongGzipSize,
+        WrongZlibChecksum,
+    };
+
+    pub fn writeHeader(comptime wrap: Container, writer: anytype) !void {
+        switch (wrap) {
+            .gzip => {
+                // GZIP 10 byte header (https://datatracker.ietf.org/doc/html/rfc1952#page-5):
+                //  - ID1 (IDentification 1), always 0x1f
+                //  - ID2 (IDentification 2), always 0x8b
+                //  - CM (Compression Method), always 8 = deflate
+                //  - FLG (Flags), all set to 0
+                //  - 4 bytes, MTIME (Modification time), not used, all set to zero
+                //  - XFL (eXtra FLags), all set to zero
+                //  - OS (Operating System), 03 = Unix
+                const gzipHeader = [_]u8{ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03 };
+                try writer.writeAll(&gzipHeader);
+            },
+            .zlib => {
+                // ZLIB has a two-byte header (https://datatracker.ietf.org/doc/html/rfc1950#page-4):
+                // 1st byte:
+                //  - First four bits is the CINFO (compression info), which is 7 for the default deflate window size.
+                //  - The next four bits is the CM (compression method), which is 8 for deflate.
+                // 2nd byte:
+                //  - Two bits is the FLEVEL (compression level). Values are: 0=fastest, 1=fast, 2=default, 3=best.
+                //  - The next bit, FDICT, is set if a dictionary is given.
+                //  - The final five FCHECK bits form a mod-31 checksum.
+                //
+                // CINFO = 7, CM = 8, FLEVEL = 0b10, FDICT = 0, FCHECK = 0b11100
+                const zlibHeader = [_]u8{ 0x78, 0b10_0_11100 };
+                try writer.writeAll(&zlibHeader);
+            },
+            .raw => {},
+        }
+    }
+
+    pub fn writeFooter(comptime wrap: Container, hasher: *Hasher(wrap), writer: anytype) !void {
+        var bits: [4]u8 = undefined;
+        switch (wrap) {
+            .gzip => {
+                // GZIP 8 bytes footer
+                //  - 4 bytes, CRC32 (CRC-32)
+                //  - 4 bytes, ISIZE (Input SIZE) - size of the original (uncompressed) input data modulo 2^32
+                std.mem.writeInt(u32, &bits, hasher.chksum(), .little);
+                try writer.writeAll(&bits);
+
+                std.mem.writeInt(u32, &bits, hasher.bytesRead(), .little);
+                try writer.writeAll(&bits);
+            },
+            .zlib => {
+                // ZLIB (RFC 1950) is big-endian, unlike GZIP (RFC 1952).
+                // 4 bytes of ADLER32 (Adler-32 checksum)
+                // Checksum value of the uncompressed data (excluding any
+                // dictionary data) computed according to Adler-32
+                // algorithm.
+                std.mem.writeInt(u32, &bits, hasher.chksum(), .big);
+                try writer.writeAll(&bits);
+            },
+            .raw => {},
+        }
+    }
+
+    pub fn parseHeader(comptime wrap: Container, reader: anytype) !void {
+        switch (wrap) {
+            .gzip => try parseGzipHeader(reader),
+            .zlib => try parseZlibHeader(reader),
+            .raw => {},
+        }
+    }
+
+    fn parseGzipHeader(reader: anytype) !void {
+        const magic1 = try reader.read(u8);
+        const magic2 = try reader.read(u8);
+        const method = try reader.read(u8);
+        const flags = try reader.read(u8);
+        try reader.skipBytes(6); // mtime(4), xflags, os
+        if (magic1 != 0x1f or magic2 != 0x8b or method != 0x08)
+            return error.BadGzipHeader;
+        // Flags description: https://www.rfc-editor.org/rfc/rfc1952.html#page-5
+        if (flags != 0) {
+            if (flags & 0b0000_0100 != 0) { // FEXTRA
+                const extra_len = try reader.read(u16);
+                try reader.skipBytes(extra_len);
+            }
+            if (flags & 0b0000_1000 != 0) { // FNAME
+                try reader.skipStringZ();
+            }
+            if (flags & 0b0001_0000 != 0) { // FCOMMENT
+                try reader.skipStringZ();
+            }
+            if (flags & 0b0000_0010 != 0) { // FHCRC
+                try reader.skipBytes(2);
+            }
+        }
+    }
+
+    fn parseZlibHeader(reader: anytype) !void {
+        const cinfo_cm = try reader.read(u8);
+        _ = try reader.read(u8);
+        if (cinfo_cm != 0x78) {
+            return error.BadZlibHeader;
+        }
+    }
+
+    pub fn parseFooter(comptime wrap: Container, hasher: *Hasher(wrap), reader: anytype) !void {
+        switch (wrap) {
+            .gzip => {
+                if (try reader.read(u32) != hasher.chksum()) return error.WrongGzipChecksum;
+                if (try reader.read(u32) != hasher.bytesRead()) return error.WrongGzipSize;
+            },
+            .zlib => {
+                const chksum: u32 = @byteSwap(hasher.chksum());
+                if (try reader.read(u32) != chksum) return error.WrongZlibChecksum;
+            },
+            .raw => {},
+        }
+    }
+
+    pub fn Hasher(comptime wrap: Container) type {
+        const HasherType = switch (wrap) {
+            .gzip => std.hash.Crc32,
+            .zlib => std.hash.Adler32,
+            .raw => struct {
+                pub fn init() @This() {
+                    return .{};
+                }
+            },
+        };
+
+        return struct {
+            hasher: HasherType = HasherType.init(),
+            bytes: usize = 0,
+
+            const Self = @This();
+
+            pub fn update(self: *Self, buf: []const u8) void {
+                switch (wrap) {
+                    .raw => {},
+                    else => {
+                        self.hasher.update(buf);
+                        self.bytes += buf.len;
+                    },
+                }
+            }
+
+            pub fn chksum(self: *Self) u32 {
+                switch (wrap) {
+                    .raw => return 0,
+                    else => return self.hasher.final(),
+                }
+            }
+
+            pub fn bytesRead(self: *Self) u32 {
+                return @truncate(self.bytes);
+            }
+        };
+    }
+};
diff --git a/lib/std/compress/flate/deflate.zig b/lib/std/compress/flate/deflate.zig
new file mode 100644
index 0000000000..eac24aa301
--- /dev/null
+++ b/lib/std/compress/flate/deflate.zig
@@ -0,0 +1,783 @@
+const std = @import("std");
+const io = std.io;
+const assert = std.debug.assert;
+const testing = std.testing;
+const expect = testing.expect;
+const print = std.debug.print;
+
+const Token = @import("Token.zig");
+const consts = @import("consts.zig");
+const BlockWriter = @import("block_writer.zig").BlockWriter;
+const Container = @import("container.zig").Container;
+const SlidingWindow = @import("SlidingWindow.zig");
+const Lookup = @import("Lookup.zig");
+
+pub const Options = struct {
+    level: Level = .default,
+};
+
+/// Trades between speed and compression size.
+/// Starts with level 4: in [zlib](https://github.com/madler/zlib/blob/abd3d1a28930f89375d4b41408b39f6c1be157b2/deflate.c#L115C1-L117C43)
+/// levels 1-3 are using different algorithm to perform faster but with less
+/// compression. That is not implemented here.
+pub const Level = enum(u4) {
+    // zig fmt: off
+    fast = 0xb,         level_4 = 4,
+                        level_5 = 5,
+    default = 0xc,      level_6 = 6,
+                        level_7 = 7,
+                        level_8 = 8,
+    best = 0xd,         level_9 = 9,
+    // zig fmt: on
+};
+
+/// Algorithm knobs for each level.
+const LevelArgs = struct {
+    good: u16, // Do less lookups if we already have match of this length.
+    nice: u16, // Stop looking for better match if we found match with at least this length.
+    lazy: u16, // Don't do lazy match find if got match with at least this length.
+    chain: u16, // How many lookups for previous match to perform.
+
+    pub fn get(level: Level) LevelArgs {
+        // zig fmt: off
+        return switch (level) {
+            .fast,    .level_4 => .{ .good =  4, .lazy =   4, .nice =  16, .chain =   16 },
+                      .level_5 => .{ .good =  8, .lazy =  16, .nice =  32, .chain =   32 },
+            .default, .level_6 => .{ .good =  8, .lazy =  16, .nice = 128, .chain =  128 },
+                      .level_7 => .{ .good =  8, .lazy =  32, .nice = 128, .chain =  256 },
+                      .level_8 => .{ .good = 32, .lazy = 128, .nice = 258, .chain = 1024 },
+            .best,    .level_9 => .{ .good = 32, .lazy = 258, .nice = 258, .chain = 4096 },
+        };
+        // zig fmt: on
+    }
+};
+
+/// Compress plain data from reader into compressed stream written to writer.
+pub fn compress(comptime container: Container, reader: anytype, writer: anytype, options: Options) !void {
+    var c = try compressor(container, writer, options);
+    try c.compress(reader);
+    try c.finish();
+}
+
+/// Create compressor for writer type.
+pub fn compressor(comptime container: Container, writer: anytype, options: Options) !Compressor(
+    container,
+    @TypeOf(writer),
+) {
+    return try Compressor(container, @TypeOf(writer)).init(writer, options);
+}
+
+/// Compressor type.
+pub fn Compressor(comptime container: Container, comptime WriterType: type) type {
+    const TokenWriterType = BlockWriter(WriterType);
+    return Deflate(container, WriterType, TokenWriterType);
+}
+
+/// Default compression algorithm. Has two steps: tokenization and token
+/// encoding.
+///
+/// Tokenization takes uncompressed input stream and produces list of tokens.
+/// Each token can be literal (byte of data) or match (backrefernce to previous
+/// data with length and distance). Tokenization accumulators 32K tokens, when
+/// full or `flush` is called tokens are passed to the `block_writer`. Level
+/// defines how hard (how slow) it tries to find match.
+///
+/// Block writer will decide which type of deflate block to write (stored, fixed,
+/// dynamic) and encode tokens to the output byte stream. Client has to call
+/// `finish` to write block with the final bit set.
+///
+/// Container defines type of header and footer which can be gzip, zlib or raw.
+/// They all share same deflate body. Raw has no header or footer just deflate
+/// body.
+///
+/// Compression algorithm explained in rfc-1951 (slightly edited for this case):
+///
+///   The compressor uses a chained hash table `lookup` to find duplicated
+///   strings, using a hash function that operates on 4-byte sequences. At any
+///   given point during compression, let XYZW be the next 4 input bytes
+///   (lookahead) to be examined (not necessarily all different, of course).
+///   First, the compressor examines the hash chain for XYZW. If the chain is
+///   empty, the compressor simply writes out X as a literal byte and advances
+///   one byte in the input. If the hash chain is not empty, indicating that the
+///   sequence XYZW (or, if we are unlucky, some other 4 bytes with the same
+///   hash function value) has occurred recently, the compressor compares all
+///   strings on the XYZW hash chain with the actual input data sequence
+///   starting at the current point, and selects the longest match.
+///
+///   To improve overall compression, the compressor defers the selection of
+///   matches ("lazy matching"): after a match of length N has been found, the
+///   compressor searches for a longer match starting at the next input byte. If
+///   it finds a longer match, it truncates the previous match to a length of
+///   one (thus producing a single literal byte) and then emits the longer
+///   match. Otherwise, it emits the original match, and, as described above,
+///   advances N bytes before continuing.
+///
+///
+/// Allocates statically ~400K (192K lookup, 128K tokens, 64K window).
+///
+/// Deflate function accepts BlockWriterType so we can change that in test to test
+/// just tokenization part.
+///
+fn Deflate(comptime container: Container, comptime WriterType: type, comptime BlockWriterType: type) type {
+    return struct {
+        lookup: Lookup = .{},
+        win: SlidingWindow = .{},
+        tokens: Tokens = .{},
+        wrt: WriterType,
+        block_writer: BlockWriterType,
+        level: LevelArgs,
+        hasher: container.Hasher() = .{},
+
+        // Match and literal at the previous position.
+        // Used for lazy match finding in processWindow.
+        prev_match: ?Token = null,
+        prev_literal: ?u8 = null,
+
+        const Self = @This();
+
+        pub fn init(wrt: WriterType, options: Options) !Self {
+            const self = Self{
+                .wrt = wrt,
+                .block_writer = BlockWriterType.init(wrt),
+                .level = LevelArgs.get(options.level),
+            };
+            try container.writeHeader(self.wrt);
+            return self;
+        }
+
+        const FlushOption = enum { none, flush, final };
+
+        // Process data in window and create tokens. If token buffer is full
+        // flush tokens to the token writer. In the case of `flush` or `final`
+        // option it will process all data from the window. In the `none` case
+        // it will preserve some data for the next match.
+        fn tokenize(self: *Self, flush_opt: FlushOption) !void {
+            // flush - process all data from window
+            const should_flush = (flush_opt != .none);
+
+            // While there is data in active lookahead buffer.
+            while (self.win.activeLookahead(should_flush)) |lh| {
+                var step: u16 = 1; // 1 in the case of literal, match length otherwise
+                const pos: u16 = self.win.pos();
+                const literal = lh[0]; // literal at current position
+                const min_len: u16 = if (self.prev_match) |m| m.length() else 0;
+
+                // Try to find match at least min_len long.
+                if (self.findMatch(pos, lh, min_len)) |match| {
+                    // Found better match than previous.
+                    try self.addPrevLiteral();
+
+                    // Is found match length good enough?
+                    if (match.length() >= self.level.lazy) {
+                        // Don't try to lazy find better match, use this.
+                        step = try self.addMatch(match);
+                    } else {
+                        // Store this match.
+                        self.prev_literal = literal;
+                        self.prev_match = match;
+                    }
+                } else {
+                    // There is no better match at current pos then it was previous.
+                    // Write previous match or literal.
+                    if (self.prev_match) |m| {
+                        // Write match from previous position.
+                        step = try self.addMatch(m) - 1; // we already advanced 1 from previous position
+                    } else {
+                        // No match at previous postition.
+                        // Write previous literal if any, and remember this literal.
+                        try self.addPrevLiteral();
+                        self.prev_literal = literal;
+                    }
+                }
+                // Advance window and add hashes.
+                self.windowAdvance(step, lh, pos);
+            }
+
+            if (should_flush) {
+                // In the case of flushing, last few lookahead buffers were smaller then min match len.
+                // So only last literal can be unwritten.
+                assert(self.prev_match == null);
+                try self.addPrevLiteral();
+                self.prev_literal = null;
+
+                try self.flushTokens(flush_opt);
+            }
+        }
+
+        fn windowAdvance(self: *Self, step: u16, lh: []const u8, pos: u16) void {
+            // current position is already added in findMatch
+            self.lookup.bulkAdd(lh[1..], step - 1, pos + 1);
+            self.win.advance(step);
+        }
+
+        // Add previous literal (if any) to the tokens list.
+        fn addPrevLiteral(self: *Self) !void {
+            if (self.prev_literal) |l| try self.addToken(Token.initLiteral(l));
+        }
+
+        // Add match to the tokens list, reset prev pointers.
+        // Returns length of the added match.
+        fn addMatch(self: *Self, m: Token) !u16 {
+            try self.addToken(m);
+            self.prev_literal = null;
+            self.prev_match = null;
+            return m.length();
+        }
+
+        fn addToken(self: *Self, token: Token) !void {
+            self.tokens.add(token);
+            if (self.tokens.full()) try self.flushTokens(.none);
+        }
+
+        // Finds largest match in the history window with the data at current pos.
+        fn findMatch(self: *Self, pos: u16, lh: []const u8, min_len: u16) ?Token {
+            var len: u16 = min_len;
+            // Previous location with the same hash (same 4 bytes).
+            var prev_pos = self.lookup.add(lh, pos);
+            // Last found match.
+            var match: ?Token = null;
+
+            // How much back-references to try, performance knob.
+            var chain: usize = self.level.chain;
+            if (len >= self.level.good) {
+                // If we've got a match that's good enough, only look in 1/4 the chain.
+                chain >>= 2;
+            }
+
+            // Hot path loop!
+            while (prev_pos > 0 and chain > 0) : (chain -= 1) {
+                const distance = pos - prev_pos;
+                if (distance > consts.match.max_distance)
+                    break;
+
+                const new_len = self.win.match(prev_pos, pos, len);
+                if (new_len > len) {
+                    match = Token.initMatch(@intCast(distance), new_len);
+                    if (new_len >= self.level.nice) {
+                        // The match is good enough that we don't try to find a better one.
+                        return match;
+                    }
+                    len = new_len;
+                }
+                prev_pos = self.lookup.prev(prev_pos);
+            }
+
+            return match;
+        }
+
+        fn flushTokens(self: *Self, flush_opt: FlushOption) !void {
+            // Pass tokens to the token writer
+            try self.block_writer.write(self.tokens.tokens(), flush_opt == .final, self.win.tokensBuffer());
+            // Stored block ensures byte aligment.
+            // It has 3 bits (final, block_type) and then padding until byte boundary.
+            // After that everyting is aligned to the boundary in the stored block.
+            // Empty stored block is Ob000 + (0-7) bits of padding + 0x00 0x00 0xFF 0xFF.
+            // Last 4 bytes are byte aligned.
+            if (flush_opt == .flush) {
+                try self.block_writer.storedBlock("", false);
+            }
+            if (flush_opt != .none) {
+                // Safe to call only when byte aligned or it is OK to add
+                // padding bits (on last byte of the final block).
+                try self.block_writer.flush();
+            }
+            // Reset internal tokens store.
+            self.tokens.reset();
+            // Notify win that tokens are flushed.
+            self.win.flush();
+        }
+
+        // Slide win and if needed lookup tables.
+        fn slide(self: *Self) void {
+            const n = self.win.slide();
+            self.lookup.slide(n);
+        }
+
+        /// Compresses as much data as possible, stops when the reader becomes
+        /// empty. It will introduce some output latency (reading input without
+        /// producing all output) because some data are still in internal
+        /// buffers.
+        ///
+        /// It is up to the caller to call flush (if needed) or finish (required)
+        /// when is need to output any pending data or complete stream.
+        ///
+        pub fn compress(self: *Self, reader: anytype) !void {
+            while (true) {
+                // Fill window from reader
+                const buf = self.win.writable();
+                if (buf.len == 0) {
+                    try self.tokenize(.none);
+                    self.slide();
+                    continue;
+                }
+                const n = try reader.readAll(buf);
+                self.hasher.update(buf[0..n]);
+                self.win.written(n);
+                // Process window
+                try self.tokenize(.none);
+                // Exit when no more data in reader
+                if (n < buf.len) break;
+            }
+        }
+
+        /// Flushes internal buffers to the output writer. Outputs empty stored
+        /// block to sync bit stream to the byte boundary, so that the
+        /// decompressor can get all input data available so far.
+        ///
+        /// It is useful mainly in compressed network protocols, to ensure that
+        /// deflate bit stream can be used as byte stream. May degrade
+        /// compression so it should be used only when necessary.
+        ///
+        /// Completes the current deflate block and follows it with an empty
+        /// stored block that is three zero bits plus filler bits to the next
+        /// byte, followed by four bytes (00 00 ff ff).
+        ///
+        pub fn flush(self: *Self) !void {
+            try self.tokenize(.flush);
+        }
+
+        /// Completes deflate bit stream by writing any pending data as deflate
+        /// final deflate block. HAS to be called once all data are written to
+        /// the compressor as a signal that next block has to have final bit
+        /// set.
+        ///
+        pub fn finish(self: *Self) !void {
+            try self.tokenize(.final);
+            try container.writeFooter(&self.hasher, self.wrt);
+        }
+
+        /// Use another writer while preserving history. Most probably flush
+        /// should be called on old writer before setting new.
+        pub fn setWriter(self: *Self, new_writer: WriterType) void {
+            self.block_writer.setWriter(new_writer);
+            self.wrt = new_writer;
+        }
+
+        // Writer interface
+
+        pub const Writer = io.Writer(*Self, Error, write);
+        pub const Error = BlockWriterType.Error;
+
+        /// Write `input` of uncompressed data.
+        /// See compress.
+        pub fn write(self: *Self, input: []const u8) !usize {
+            var fbs = io.fixedBufferStream(input);
+            try self.compress(fbs.reader());
+            return input.len;
+        }
+
+        pub fn writer(self: *Self) Writer {
+            return .{ .context = self };
+        }
+    };
+}
+
+// Tokens store
+const Tokens = struct {
+    list: [consts.deflate.tokens]Token = undefined,
+    pos: usize = 0,
+
+    fn add(self: *Tokens, t: Token) void {
+        self.list[self.pos] = t;
+        self.pos += 1;
+    }
+
+    fn full(self: *Tokens) bool {
+        return self.pos == self.list.len;
+    }
+
+    fn reset(self: *Tokens) void {
+        self.pos = 0;
+    }
+
+    fn tokens(self: *Tokens) []const Token {
+        return self.list[0..self.pos];
+    }
+};
+
+/// Creates huffman only deflate blocks. Disables Lempel-Ziv match searching and
+/// only performs Huffman entropy encoding. Results in faster compression, much
+/// less memory requirements during compression but bigger compressed sizes.
+pub const huffman = struct {
+    pub fn compress(comptime container: Container, reader: anytype, writer: anytype) !void {
+        var c = try huffman.compressor(container, writer);
+        try c.compress(reader);
+        try c.finish();
+    }
+
+    pub fn Compressor(comptime container: Container, comptime WriterType: type) type {
+        return SimpleCompressor(.huffman, container, WriterType);
+    }
+
+    pub fn compressor(comptime container: Container, writer: anytype) !huffman.Compressor(container, @TypeOf(writer)) {
+        return try huffman.Compressor(container, @TypeOf(writer)).init(writer);
+    }
+};
+
+/// Creates store blocks only. Data are not compressed only packed into deflate
+/// store blocks. That adds 9 bytes of header for each block. Max stored block
+/// size is 64K. Block is emitted when flush is called on on finish.
+pub const store = struct {
+    pub fn compress(comptime container: Container, reader: anytype, writer: anytype) !void {
+        var c = try store.compressor(container, writer);
+        try c.compress(reader);
+        try c.finish();
+    }
+
+    pub fn Compressor(comptime container: Container, comptime WriterType: type) type {
+        return SimpleCompressor(.store, container, WriterType);
+    }
+
+    pub fn compressor(comptime container: Container, writer: anytype) !store.Compressor(container, @TypeOf(writer)) {
+        return try store.Compressor(container, @TypeOf(writer)).init(writer);
+    }
+};
+
+const SimpleCompressorKind = enum {
+    huffman,
+    store,
+};
+
+fn simpleCompressor(
+    comptime kind: SimpleCompressorKind,
+    comptime container: Container,
+    writer: anytype,
+) !SimpleCompressor(kind, container, @TypeOf(writer)) {
+    return try SimpleCompressor(kind, container, @TypeOf(writer)).init(writer);
+}
+
+fn SimpleCompressor(
+    comptime kind: SimpleCompressorKind,
+    comptime container: Container,
+    comptime WriterType: type,
+) type {
+    const BlockWriterType = BlockWriter(WriterType);
+    return struct {
+        buffer: [65535]u8 = undefined, // because store blocks are limited to 65535 bytes
+        wp: usize = 0,
+
+        wrt: WriterType,
+        block_writer: BlockWriterType,
+        hasher: container.Hasher() = .{},
+
+        const Self = @This();
+
+        pub fn init(wrt: WriterType) !Self {
+            const self = Self{
+                .wrt = wrt,
+                .block_writer = BlockWriterType.init(wrt),
+            };
+            try container.writeHeader(self.wrt);
+            return self;
+        }
+
+        pub fn flush(self: *Self) !void {
+            try self.flushBuffer(false);
+            try self.block_writer.storedBlock("", false);
+            try self.block_writer.flush();
+        }
+
+        pub fn finish(self: *Self) !void {
+            try self.flushBuffer(true);
+            try self.block_writer.flush();
+            try container.writeFooter(&self.hasher, self.wrt);
+        }
+
+        fn flushBuffer(self: *Self, final: bool) !void {
+            const buf = self.buffer[0..self.wp];
+            switch (kind) {
+                .huffman => try self.block_writer.huffmanBlock(buf, final),
+                .store => try self.block_writer.storedBlock(buf, final),
+            }
+            self.wp = 0;
+        }
+
+        // Writes all data from the input reader of uncompressed data.
+        // It is up to the caller to call flush or finish if there is need to
+        // output compressed blocks.
+        pub fn compress(self: *Self, reader: anytype) !void {
+            while (true) {
+                // read from rdr into buffer
+                const buf = self.buffer[self.wp..];
+                if (buf.len == 0) {
+                    try self.flushBuffer(false);
+                    continue;
+                }
+                const n = try reader.readAll(buf);
+                self.hasher.update(buf[0..n]);
+                self.wp += n;
+                if (n < buf.len) break; // no more data in reader
+            }
+        }
+
+        // Writer interface
+
+        pub const Writer = io.Writer(*Self, Error, write);
+        pub const Error = BlockWriterType.Error;
+
+        // Write `input` of uncompressed data.
+        pub fn write(self: *Self, input: []const u8) !usize {
+            var fbs = io.fixedBufferStream(input);
+            try self.compress(fbs.reader());
+            return input.len;
+        }
+
+        pub fn writer(self: *Self) Writer {
+            return .{ .context = self };
+        }
+    };
+}
+
+test "flate.Deflate tokenization" {
+    const L = Token.initLiteral;
+    const M = Token.initMatch;
+
+    const cases = [_]struct {
+        data: []const u8,
+        tokens: []const Token,
+    }{
+        .{
+            .data = "Blah blah blah blah blah!",
+            .tokens = &[_]Token{ L('B'), L('l'), L('a'), L('h'), L(' '), L('b'), M(5, 18), L('!') },
+        },
+        .{
+            .data = "ABCDEABCD ABCDEABCD",
+            .tokens = &[_]Token{
+                L('A'), L('B'),   L('C'), L('D'), L('E'), L('A'), L('B'), L('C'), L('D'), L(' '),
+                L('A'), M(10, 8),
+            },
+        },
+    };
+
+    for (cases) |c| {
+        inline for (Container.list) |container| { // for each wrapping
+            var cw = io.countingWriter(io.null_writer);
+            const cww = cw.writer();
+            var df = try Deflate(container, @TypeOf(cww), TestTokenWriter).init(cww, .{});
+
+            _ = try df.write(c.data);
+            try df.flush();
+
+            // df.token_writer.show();
+            try expect(df.block_writer.pos == c.tokens.len); // number of tokens written
+            try testing.expectEqualSlices(Token, df.block_writer.get(), c.tokens); // tokens match
+
+            try testing.expectEqual(container.headerSize(), cw.bytes_written);
+            try df.finish();
+            try testing.expectEqual(container.size(), cw.bytes_written);
+        }
+    }
+}
+
+// Tests that tokens writen are equal to expected token list.
+const TestTokenWriter = struct {
+    const Self = @This();
+    //expected: []const Token,
+    pos: usize = 0,
+    actual: [1024]Token = undefined,
+
+    pub fn init(_: anytype) Self {
+        return .{};
+    }
+    pub fn write(self: *Self, tokens: []const Token, _: bool, _: ?[]const u8) !void {
+        for (tokens) |t| {
+            self.actual[self.pos] = t;
+            self.pos += 1;
+        }
+    }
+
+    pub fn storedBlock(_: *Self, _: []const u8, _: bool) !void {}
+
+    pub fn get(self: *Self) []Token {
+        return self.actual[0..self.pos];
+    }
+
+    pub fn show(self: *Self) void {
+        print("\n", .{});
+        for (self.get()) |t| {
+            t.show();
+        }
+    }
+
+    pub fn flush(_: *Self) !void {}
+};
+
+test "flate.Deflate struct sizes" {
+    try expect(@sizeOf(Token) == 4);
+
+    // list: (1 << 15) * 4 = 128k + pos: 8
+    const tokens_size = 128 * 1024 + 8;
+    try expect(@sizeOf(Tokens) == tokens_size);
+
+    // head: (1 << 15) * 2 = 64k, chain: (32768 * 2) * 2  = 128k = 192k
+    const lookup_size = 192 * 1024;
+    try expect(@sizeOf(Lookup) == lookup_size);
+
+    // buffer: (32k * 2), wp: 8, rp: 8, fp: 8
+    const window_size = 64 * 1024 + 8 + 8 + 8;
+    try expect(@sizeOf(SlidingWindow) == window_size);
+
+    const Bw = BlockWriter(@TypeOf(io.null_writer));
+    // huffman bit writer internal: 11480
+    const hbw_size = 11472; // 11.2k
+    try expect(@sizeOf(Bw) == hbw_size);
+
+    const D = Deflate(.raw, @TypeOf(io.null_writer), Bw);
+    // 404744, 395.26K
+    // ?Token: 6, ?u8: 2, level: 8
+    try expect(@sizeOf(D) == tokens_size + lookup_size + window_size + hbw_size + 24);
+    //print("Delfate size: {d} {d}\n", .{ @sizeOf(D), tokens_size + lookup_size + hbw_size + window_size });
+
+    // current std lib deflate allocation:
+    // 797_901, 779.2k
+    // measured with:
+    // var la = std.heap.logToWriterAllocator(testing.allocator, io.getStdOut().writer());
+    // const allocator = la.allocator();
+    // var cmp = try std.compress.deflate.compressor(allocator, io.null_writer, .{});
+    // defer cmp.deinit();
+
+    const HC = huffman.Compressor(.raw, @TypeOf(io.null_writer));
+    //print("size of HOC {d}\n", .{@sizeOf(HOC)});
+    try expect(@sizeOf(HC) == 77024);
+    // 64K buffer
+    // 11480 huffman_encoded
+    // 8 buffer write pointer
+}
+
+test "flate deflate file tokenization" {
+    const levels = [_]Level{ .level_4, .level_5, .level_6, .level_7, .level_8, .level_9 };
+    const cases = [_]struct {
+        data: []const u8, // uncompressed content
+        // expected number of tokens producet in deflate tokenization
+        tokens_count: [levels.len]usize = .{0} ** levels.len,
+    }{
+        .{
+            .data = @embedFile("testdata/rfc1951.txt"),
+            .tokens_count = .{ 7675, 7672, 7599, 7594, 7598, 7599 },
+        },
+
+        .{
+            .data = @embedFile("testdata/block_writer/huffman-null-max.input"),
+            .tokens_count = .{ 257, 257, 257, 257, 257, 257 },
+        },
+        .{
+            .data = @embedFile("testdata/block_writer/huffman-pi.input"),
+            .tokens_count = .{ 2570, 2564, 2564, 2564, 2564, 2564 },
+        },
+        .{
+            .data = @embedFile("testdata/block_writer/huffman-text.input"),
+            .tokens_count = .{ 235, 234, 234, 234, 234, 234 },
+        },
+        .{
+            .data = @embedFile("testdata/fuzz/roundtrip1.input"),
+            .tokens_count = .{ 333, 331, 331, 331, 331, 331 },
+        },
+        .{
+            .data = @embedFile("testdata/fuzz/roundtrip2.input"),
+            .tokens_count = .{ 334, 334, 334, 334, 334, 334 },
+        },
+    };
+
+    for (cases) |case| { // for each case
+        const data = case.data;
+
+        for (levels, 0..) |level, i| { // for each compression level
+            var original = io.fixedBufferStream(data);
+
+            // buffer for decompressed data
+            var al = std.ArrayList(u8).init(testing.allocator);
+            defer al.deinit();
+            const writer = al.writer();
+
+            // create compressor
+            const WriterType = @TypeOf(writer);
+            const TokenWriter = TokenDecoder(@TypeOf(writer));
+            var cmp = try Deflate(.raw, WriterType, TokenWriter).init(writer, .{ .level = level });
+
+            // Stream uncompressed `orignal` data to the compressor. It will
+            // produce tokens list and pass that list to the TokenDecoder. This
+            // TokenDecoder uses CircularBuffer from inflate to convert list of
+            // tokens back to the uncompressed stream.
+            try cmp.compress(original.reader());
+            try cmp.flush();
+            const expected_count = case.tokens_count[i];
+            const actual = cmp.block_writer.tokens_count;
+            if (expected_count == 0) {
+                print("actual token count {d}\n", .{actual});
+            } else {
+                try testing.expectEqual(expected_count, actual);
+            }
+
+            try testing.expectEqual(data.len, al.items.len);
+            try testing.expectEqualSlices(u8, data, al.items);
+        }
+    }
+}
+
+fn TokenDecoder(comptime WriterType: type) type {
+    return struct {
+        const CircularBuffer = @import("CircularBuffer.zig");
+        hist: CircularBuffer = .{},
+        wrt: WriterType,
+        tokens_count: usize = 0,
+
+        const Self = @This();
+
+        pub fn init(wrt: WriterType) Self {
+            return .{ .wrt = wrt };
+        }
+
+        pub fn write(self: *Self, tokens: []const Token, _: bool, _: ?[]const u8) !void {
+            self.tokens_count += tokens.len;
+            for (tokens) |t| {
+                switch (t.kind) {
+                    .literal => self.hist.write(t.literal()),
+                    .match => try self.hist.writeMatch(t.length(), t.distance()),
+                }
+                if (self.hist.free() < 285) try self.flushWin();
+            }
+            try self.flushWin();
+        }
+
+        pub fn storedBlock(_: *Self, _: []const u8, _: bool) !void {}
+
+        fn flushWin(self: *Self) !void {
+            while (true) {
+                const buf = self.hist.read();
+                if (buf.len == 0) break;
+                try self.wrt.writeAll(buf);
+            }
+        }
+
+        pub fn flush(_: *Self) !void {}
+    };
+}
+
+test "flate.Deflate store simple compressor" {
+    const data = "Hello world!";
+    const expected = [_]u8{
+        0x1, // block type 0, final bit set
+        0xc, 0x0, // len = 12
+        0xf3, 0xff, // ~len
+        'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!', //
+        //0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x21,
+    };
+
+    var fbs = std.io.fixedBufferStream(data);
+    var al = std.ArrayList(u8).init(testing.allocator);
+    defer al.deinit();
+
+    var cmp = try store.compressor(.raw, al.writer());
+    try cmp.compress(fbs.reader());
+    try cmp.finish();
+    try testing.expectEqualSlices(u8, &expected, al.items);
+
+    fbs.reset();
+    try al.resize(0);
+
+    // huffman only compresoor will also emit store block for this small sample
+    var hc = try huffman.compressor(.raw, al.writer());
+    try hc.compress(fbs.reader());
+    try hc.finish();
+    try testing.expectEqualSlices(u8, &expected, al.items);
+}
diff --git a/lib/std/compress/flate/flate.zig b/lib/std/compress/flate/flate.zig
new file mode 100644
index 0000000000..4c0977adde
--- /dev/null
+++ b/lib/std/compress/flate/flate.zig
@@ -0,0 +1,236 @@
+/// Deflate is a lossless data compression file format that uses a combination
+/// of LZ77 and Huffman coding.
+pub const deflate = @import("deflate.zig");
+
+/// Inflate is the decoding process that takes a Deflate bitstream for
+/// decompression and correctly produces the original full-size data or file.
+pub const inflate = @import("inflate.zig");
+
+/// Decompress compressed data from reader and write plain data to the writer.
+pub fn decompress(reader: anytype, writer: anytype) !void {
+    try inflate.decompress(.raw, reader, writer);
+}
+
+/// Decompressor type
+pub fn Decompressor(comptime ReaderType: type) type {
+    return inflate.Inflate(.raw, ReaderType);
+}
+
+/// Create Decompressor which will read compressed data from reader.
+pub fn decompressor(reader: anytype) Decompressor(@TypeOf(reader)) {
+    return inflate.decompressor(.raw, reader);
+}
+
+/// Compression level, trades between speed and compression size.
+pub const Options = deflate.Options;
+
+/// Compress plain data from reader and write compressed data to the writer.
+pub fn compress(reader: anytype, writer: anytype, options: Options) !void {
+    try deflate.compress(.raw, reader, writer, options);
+}
+
+/// Compressor type
+pub fn Compressor(comptime WriterType: type) type {
+    return deflate.Compressor(.raw, WriterType);
+}
+
+/// Create Compressor which outputs compressed data to the writer.
+pub fn compressor(writer: anytype, options: Options) !Compressor(@TypeOf(writer)) {
+    return try deflate.compressor(.raw, writer, options);
+}
+
+/// Huffman only compression. Without Lempel-Ziv match searching. Faster
+/// compression, less memory requirements but bigger compressed sizes.
+pub const huffman = struct {
+    pub fn compress(reader: anytype, writer: anytype) !void {
+        try deflate.huffman.compress(.raw, reader, writer);
+    }
+
+    pub fn Compressor(comptime WriterType: type) type {
+        return deflate.huffman.Compressor(.raw, WriterType);
+    }
+
+    pub fn compressor(writer: anytype) !huffman.Compressor(@TypeOf(writer)) {
+        return deflate.huffman.compressor(.raw, writer);
+    }
+};
+
+// No compression store only. Compressed size is slightly bigger than plain.
+pub const store = struct {
+    pub fn compress(reader: anytype, writer: anytype) !void {
+        try deflate.store.compress(.raw, reader, writer);
+    }
+
+    pub fn Compressor(comptime WriterType: type) type {
+        return deflate.store.Compressor(.raw, WriterType);
+    }
+
+    pub fn compressor(writer: anytype) !store.Compressor(@TypeOf(writer)) {
+        return deflate.store.compressor(.raw, writer);
+    }
+};
+
+/// Container defines header/footer arround deflate bit stream. Gzip and zlib
+/// compression algorithms are containers arround deflate bit stream body.
+const Container = @import("container.zig").Container;
+const std = @import("std");
+const testing = std.testing;
+const fixedBufferStream = std.io.fixedBufferStream;
+const print = std.debug.print;
+
+test "flate compress/decompress" {
+    var cmp_buf: [64 * 1024]u8 = undefined; // compressed data buffer
+    var dcm_buf: [64 * 1024]u8 = undefined; // decompressed data buffer
+
+    const levels = [_]deflate.Level{ .level_4, .level_5, .level_6, .level_7, .level_8, .level_9 };
+    const cases = [_]struct {
+        data: []const u8, // uncompressed content
+        // compressed data sizes per level 4-9
+        gzip_sizes: [levels.len]usize = [_]usize{0} ** levels.len,
+        huffman_only_size: usize = 0,
+        store_size: usize = 0,
+    }{
+        .{
+            .data = @embedFile("testdata/rfc1951.txt"),
+            .gzip_sizes = [_]usize{ 11513, 11217, 11139, 11126, 11122, 11119 },
+            .huffman_only_size = 20287,
+            .store_size = 36967,
+        },
+        .{
+            .data = @embedFile("testdata/fuzz/roundtrip1.input"),
+            .gzip_sizes = [_]usize{ 373, 370, 370, 370, 370, 370 },
+            .huffman_only_size = 393,
+            .store_size = 393,
+        },
+        .{
+            .data = @embedFile("testdata/fuzz/roundtrip2.input"),
+            .gzip_sizes = [_]usize{ 373, 373, 373, 373, 373, 373 },
+            .huffman_only_size = 394,
+            .store_size = 394,
+        },
+        .{
+            .data = @embedFile("testdata/fuzz/deflate-stream.expect"),
+            .gzip_sizes = [_]usize{ 351, 347, 347, 347, 347, 347 },
+            .huffman_only_size = 498,
+            .store_size = 747,
+        },
+    };
+
+    for (cases, 0..) |case, case_no| { // for each case
+        const data = case.data;
+
+        for (levels, 0..) |level, i| { // for each compression level
+
+            inline for (Container.list) |container| { // for each wrapping
+                var compressed_size: usize = if (case.gzip_sizes[i] > 0)
+                    case.gzip_sizes[i] - Container.gzip.size() + container.size()
+                else
+                    0;
+
+                // compress original stream to compressed stream
+                {
+                    var original = fixedBufferStream(data);
+                    var compressed = fixedBufferStream(&cmp_buf);
+                    try deflate.compress(container, original.reader(), compressed.writer(), .{ .level = level });
+                    if (compressed_size == 0) {
+                        if (container == .gzip)
+                            print("case {d} gzip level {} compressed size: {d}\n", .{ case_no, level, compressed.pos });
+                        compressed_size = compressed.pos;
+                    }
+                    try testing.expectEqual(compressed_size, compressed.pos);
+                }
+                // decompress compressed stream to decompressed stream
+                {
+                    var compressed = fixedBufferStream(cmp_buf[0..compressed_size]);
+                    var decompressed = fixedBufferStream(&dcm_buf);
+                    try inflate.decompress(container, compressed.reader(), decompressed.writer());
+                    try testing.expectEqualSlices(u8, data, decompressed.getWritten());
+                }
+
+                // compressor writer interface
+                {
+                    var compressed = fixedBufferStream(&cmp_buf);
+                    var cmp = try deflate.compressor(container, compressed.writer(), .{ .level = level });
+                    var cmp_wrt = cmp.writer();
+                    try cmp_wrt.writeAll(data);
+                    try cmp.finish();
+
+                    try testing.expectEqual(compressed_size, compressed.pos);
+                }
+                // decompressor reader interface
+                {
+                    var compressed = fixedBufferStream(cmp_buf[0..compressed_size]);
+                    var dcm = inflate.decompressor(container, compressed.reader());
+                    var dcm_rdr = dcm.reader();
+                    const n = try dcm_rdr.readAll(&dcm_buf);
+                    try testing.expectEqual(data.len, n);
+                    try testing.expectEqualSlices(u8, data, dcm_buf[0..n]);
+                }
+            }
+        }
+        // huffman only compression
+        {
+            inline for (Container.list) |container| { // for each wrapping
+                var compressed_size: usize = if (case.huffman_only_size > 0)
+                    case.huffman_only_size - Container.gzip.size() + container.size()
+                else
+                    0;
+
+                // compress original stream to compressed stream
+                {
+                    var original = fixedBufferStream(data);
+                    var compressed = fixedBufferStream(&cmp_buf);
+                    var cmp = try deflate.huffman.compressor(container, compressed.writer());
+                    try cmp.compress(original.reader());
+                    try cmp.finish();
+                    if (compressed_size == 0) {
+                        if (container == .gzip)
+                            print("case {d} huffman only compressed size: {d}\n", .{ case_no, compressed.pos });
+                        compressed_size = compressed.pos;
+                    }
+                    try testing.expectEqual(compressed_size, compressed.pos);
+                }
+                // decompress compressed stream to decompressed stream
+                {
+                    var compressed = fixedBufferStream(cmp_buf[0..compressed_size]);
+                    var decompressed = fixedBufferStream(&dcm_buf);
+                    try inflate.decompress(container, compressed.reader(), decompressed.writer());
+                    try testing.expectEqualSlices(u8, data, decompressed.getWritten());
+                }
+            }
+        }
+
+        // store only
+        {
+            inline for (Container.list) |container| { // for each wrapping
+                var compressed_size: usize = if (case.store_size > 0)
+                    case.store_size - Container.gzip.size() + container.size()
+                else
+                    0;
+
+                // compress original stream to compressed stream
+                {
+                    var original = fixedBufferStream(data);
+                    var compressed = fixedBufferStream(&cmp_buf);
+                    var cmp = try deflate.store.compressor(container, compressed.writer());
+                    try cmp.compress(original.reader());
+                    try cmp.finish();
+                    if (compressed_size == 0) {
+                        if (container == .gzip)
+                            print("case {d} store only compressed size: {d}\n", .{ case_no, compressed.pos });
+                        compressed_size = compressed.pos;
+                    }
+
+                    try testing.expectEqual(compressed_size, compressed.pos);
+                }
+                // decompress compressed stream to decompressed stream
+                {
+                    var compressed = fixedBufferStream(cmp_buf[0..compressed_size]);
+                    var decompressed = fixedBufferStream(&dcm_buf);
+                    try inflate.decompress(container, compressed.reader(), decompressed.writer());
+                    try testing.expectEqualSlices(u8, data, decompressed.getWritten());
+                }
+            }
+        }
+    }
+}
diff --git a/lib/std/compress/flate/gzip.zig b/lib/std/compress/flate/gzip.zig
new file mode 100644
index 0000000000..feb9ae07b5
--- /dev/null
+++ b/lib/std/compress/flate/gzip.zig
@@ -0,0 +1,66 @@
+const deflate = @import("deflate.zig");
+const inflate = @import("inflate.zig");
+
+/// Decompress compressed data from reader and write plain data to the writer.
+pub fn decompress(reader: anytype, writer: anytype) !void {
+    try inflate.decompress(.gzip, reader, writer);
+}
+
+/// Decompressor type
+pub fn Decompressor(comptime ReaderType: type) type {
+    return inflate.Inflate(.gzip, ReaderType);
+}
+
+/// Create Decompressor which will read compressed data from reader.
+pub fn decompressor(reader: anytype) Decompressor(@TypeOf(reader)) {
+    return inflate.decompressor(.gzip, reader);
+}
+
+/// Compression level, trades between speed and compression size.
+pub const Options = deflate.Options;
+
+/// Compress plain data from reader and write compressed data to the writer.
+pub fn compress(reader: anytype, writer: anytype, options: Options) !void {
+    try deflate.compress(.gzip, reader, writer, options);
+}
+
+/// Compressor type
+pub fn Compressor(comptime WriterType: type) type {
+    return deflate.Compressor(.gzip, WriterType);
+}
+
+/// Create Compressor which outputs compressed data to the writer.
+pub fn compressor(writer: anytype, options: Options) !Compressor(@TypeOf(writer)) {
+    return try deflate.compressor(.gzip, writer, options);
+}
+
+/// Huffman only compression. Without Lempel-Ziv match searching. Faster
+/// compression, less memory requirements but bigger compressed sizes.
+pub const huffman = struct {
+    pub fn compress(reader: anytype, writer: anytype) !void {
+        try deflate.huffman.compress(.gzip, reader, writer);
+    }
+
+    pub fn Compressor(comptime WriterType: type) type {
+        return deflate.huffman.Compressor(.gzip, WriterType);
+    }
+
+    pub fn compressor(writer: anytype) !huffman.Compressor(@TypeOf(writer)) {
+        return deflate.huffman.compressor(.gzip, writer);
+    }
+};
+
+// No compression store only. Compressed size is slightly bigger than plain.
+pub const store = struct {
+    pub fn compress(reader: anytype, writer: anytype) !void {
+        try deflate.store.compress(.gzip, reader, writer);
+    }
+
+    pub fn Compressor(comptime WriterType: type) type {
+        return deflate.store.Compressor(.gzip, WriterType);
+    }
+
+    pub fn compressor(writer: anytype) !store.Compressor(@TypeOf(writer)) {
+        return deflate.store.compressor(.gzip, writer);
+    }
+};
diff --git a/lib/std/compress/flate/huffman_decoder.zig b/lib/std/compress/flate/huffman_decoder.zig
new file mode 100644
index 0000000000..5bfe9242c7
--- /dev/null
+++ b/lib/std/compress/flate/huffman_decoder.zig
@@ -0,0 +1,308 @@
+const std = @import("std");
+const testing = std.testing;
+
+pub const Symbol = packed struct {
+    pub const Kind = enum(u2) {
+        literal,
+        end_of_block,
+        match,
+    };
+
+    symbol: u8 = 0, // symbol from alphabet
+    code_bits: u4 = 0, // number of bits in code 0-15
+    kind: Kind = .literal,
+
+    code: u16 = 0, // huffman code of the symbol
+    next: u16 = 0, // pointer to the next symbol in linked list
+    // it is safe to use 0 as null pointer, when sorted 0 has shortest code and fits into lookup
+
+    // Sorting less than function.
+    pub fn asc(_: void, a: Symbol, b: Symbol) bool {
+        if (a.code_bits == b.code_bits) {
+            if (a.kind == b.kind) {
+                return a.symbol < b.symbol;
+            }
+            return @intFromEnum(a.kind) < @intFromEnum(b.kind);
+        }
+        return a.code_bits < b.code_bits;
+    }
+};
+
+pub const LiteralDecoder = HuffmanDecoder(286, 15, 9);
+pub const DistanceDecoder = HuffmanDecoder(30, 15, 9);
+pub const CodegenDecoder = HuffmanDecoder(19, 7, 7);
+
+pub const Error = error{
+    InvalidCode,
+    OversubscribedHuffmanTree,
+    IncompleteHuffmanTree,
+    MissingEndOfBlockCode,
+};
+
+/// Creates huffman tree codes from list of code lengths (in `build`).
+///
+/// `find` then finds symbol for code bits. Code can be any length between 1 and
+/// 15 bits. When calling `find` we don't know how many bits will be used to
+/// find symbol. When symbol is returned it has code_bits field which defines
+/// how much we should advance in bit stream.
+///
+/// Lookup table is used to map 15 bit int to symbol. Same symbol is written
+/// many times in this table; 32K places for 286 (at most) symbols.
+/// Small lookup table is optimization for faster search.
+/// It is variation of the algorithm explained in [zlib](https://github.com/madler/zlib/blob/643e17b7498d12ab8d15565662880579692f769d/doc/algorithm.txt#L92)
+/// with difference that we here use statically allocated arrays.
+///
+fn HuffmanDecoder(
+    comptime alphabet_size: u16,
+    comptime max_code_bits: u4,
+    comptime lookup_bits: u4,
+) type {
+    const lookup_shift = max_code_bits - lookup_bits;
+
+    return struct {
+        // all symbols in alaphabet, sorted by code_len, symbol
+        symbols: [alphabet_size]Symbol = undefined,
+        // lookup table code -> symbol
+        lookup: [1 << lookup_bits]Symbol = undefined,
+
+        const Self = @This();
+
+        /// Generates symbols and lookup tables from list of code lens for each symbol.
+        pub fn generate(self: *Self, lens: []const u4) !void {
+            try checkCompletnes(lens);
+
+            // init alphabet with code_bits
+            for (self.symbols, 0..) |_, i| {
+                const cb: u4 = if (i < lens.len) lens[i] else 0;
+                self.symbols[i] = if (i < 256)
+                    .{ .kind = .literal, .symbol = @intCast(i), .code_bits = cb }
+                else if (i == 256)
+                    .{ .kind = .end_of_block, .symbol = 0xff, .code_bits = cb }
+                else
+                    .{ .kind = .match, .symbol = @intCast(i - 257), .code_bits = cb };
+            }
+            std.sort.heap(Symbol, &self.symbols, {}, Symbol.asc);
+
+            // reset lookup table
+            for (0..self.lookup.len) |i| {
+                self.lookup[i] = .{};
+            }
+
+            // assign code to symbols
+            // reference: https://youtu.be/9_YEGLe33NA?list=PLU4IQLU9e_OrY8oASHx0u3IXAL9TOdidm&t=2639
+            var code: u16 = 0;
+            var idx: u16 = 0;
+            for (&self.symbols, 0..) |*sym, pos| {
+                //print("sym: {}\n", .{sym});
+                if (sym.code_bits == 0) continue; // skip unused
+                sym.code = code;
+
+                const next_code = code + (@as(u16, 1) << (max_code_bits - sym.code_bits));
+                const next_idx = next_code >> lookup_shift;
+
+                if (next_idx > self.lookup.len or idx >= self.lookup.len) break;
+                if (sym.code_bits <= lookup_bits) {
+                    // fill small lookup table
+                    for (idx..next_idx) |j|
+                        self.lookup[j] = sym.*;
+                } else {
+                    // insert into linked table starting at root
+                    const root = &self.lookup[idx];
+                    const root_next = root.next;
+                    root.next = @intCast(pos);
+                    sym.next = root_next;
+                }
+
+                idx = next_idx;
+                code = next_code;
+            }
+            //print("decoder generate, code: {d}, idx: {d}\n", .{ code, idx });
+        }
+
+        /// Given the list of code lengths check that it represents a canonical
+        /// Huffman code for n symbols.
+        ///
+        /// Reference: https://github.com/madler/zlib/blob/5c42a230b7b468dff011f444161c0145b5efae59/contrib/puff/puff.c#L340
+        fn checkCompletnes(lens: []const u4) !void {
+            if (alphabet_size == 286)
+                if (lens[256] == 0) return error.MissingEndOfBlockCode;
+
+            var count = [_]u16{0} ** (@as(usize, max_code_bits) + 1);
+            var max: usize = 0;
+            for (lens) |n| {
+                if (n == 0) continue;
+                if (n > max) max = n;
+                count[n] += 1;
+            }
+            if (max == 0) // emtpy tree
+                return;
+
+            // check for an over-subscribed or incomplete set of lengths
+            var left: usize = 1; // one possible code of zero length
+            for (1..count.len) |len| {
+                left <<= 1; // one more bit, double codes left
+                if (count[len] > left)
+                    return error.OversubscribedHuffmanTree;
+                left -= count[len]; // deduct count from possible codes
+            }
+            if (left > 0) { // left > 0 means incomplete
+                // incomplete code ok only for single length 1 code
+                if (max_code_bits > 7 and max == count[0] + count[1]) return;
+                return error.IncompleteHuffmanTree;
+            }
+        }
+
+        /// Finds symbol for lookup table code.
+        pub fn find(self: *Self, code: u16) !Symbol {
+            // try to find in lookup table
+            const idx = code >> lookup_shift;
+            const sym = self.lookup[idx];
+            if (sym.code_bits != 0) return sym;
+            // if not use linked list of symbols with same prefix
+            return self.findLinked(code, sym.next);
+        }
+
+        inline fn findLinked(self: *Self, code: u16, start: u16) !Symbol {
+            var pos = start;
+            while (pos > 0) {
+                const sym = self.symbols[pos];
+                const shift = max_code_bits - sym.code_bits;
+                // compare code_bits number of upper bits
+                if ((code ^ sym.code) >> shift == 0) return sym;
+                pos = sym.next;
+            }
+            return error.InvalidCode;
+        }
+    };
+}
+
+test "flate.HuffmanDecoder init/find" {
+    // example data from: https://youtu.be/SJPvNi4HrWQ?t=8423
+    const code_lens = [_]u4{ 4, 3, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 3, 2 };
+    var h: CodegenDecoder = .{};
+    try h.generate(&code_lens);
+
+    const expected = [_]struct {
+        sym: Symbol,
+        code: u16,
+    }{
+        .{
+            .code = 0b00_00000,
+            .sym = .{ .symbol = 3, .code_bits = 2 },
+        },
+        .{
+            .code = 0b01_00000,
+            .sym = .{ .symbol = 18, .code_bits = 2 },
+        },
+        .{
+            .code = 0b100_0000,
+            .sym = .{ .symbol = 1, .code_bits = 3 },
+        },
+        .{
+            .code = 0b101_0000,
+            .sym = .{ .symbol = 4, .code_bits = 3 },
+        },
+        .{
+            .code = 0b110_0000,
+            .sym = .{ .symbol = 17, .code_bits = 3 },
+        },
+        .{
+            .code = 0b1110_000,
+            .sym = .{ .symbol = 0, .code_bits = 4 },
+        },
+        .{
+            .code = 0b1111_000,
+            .sym = .{ .symbol = 16, .code_bits = 4 },
+        },
+    };
+
+    // unused symbols
+    for (0..12) |i| {
+        try testing.expectEqual(0, h.symbols[i].code_bits);
+    }
+    // used, from index 12
+    for (expected, 12..) |e, i| {
+        try testing.expectEqual(e.sym.symbol, h.symbols[i].symbol);
+        try testing.expectEqual(e.sym.code_bits, h.symbols[i].code_bits);
+        const sym_from_code = try h.find(e.code);
+        try testing.expectEqual(e.sym.symbol, sym_from_code.symbol);
+    }
+
+    // All possible codes for each symbol.
+    // Lookup table has 126 elements, to cover all possible 7 bit codes.
+    for (0b0000_000..0b0100_000) |c| // 0..32 (32)
+        try testing.expectEqual(3, (try h.find(@intCast(c))).symbol);
+
+    for (0b0100_000..0b1000_000) |c| // 32..64 (32)
+        try testing.expectEqual(18, (try h.find(@intCast(c))).symbol);
+
+    for (0b1000_000..0b1010_000) |c| // 64..80 (16)
+        try testing.expectEqual(1, (try h.find(@intCast(c))).symbol);
+
+    for (0b1010_000..0b1100_000) |c| // 80..96 (16)
+        try testing.expectEqual(4, (try h.find(@intCast(c))).symbol);
+
+    for (0b1100_000..0b1110_000) |c| // 96..112 (16)
+        try testing.expectEqual(17, (try h.find(@intCast(c))).symbol);
+
+    for (0b1110_000..0b1111_000) |c| // 112..120 (8)
+        try testing.expectEqual(0, (try h.find(@intCast(c))).symbol);
+
+    for (0b1111_000..0b1_0000_000) |c| // 120...128 (8)
+        try testing.expectEqual(16, (try h.find(@intCast(c))).symbol);
+}
+
+const print = std.debug.print;
+const assert = std.debug.assert;
+const expect = std.testing.expect;
+
+test "flate.HuffmanDecoder encode/decode literals" {
+    const LiteralEncoder = @import("huffman_encoder.zig").LiteralEncoder;
+
+    for (1..286) |j| { // for all different number of codes
+        var enc: LiteralEncoder = .{};
+        // create freqencies
+        var freq = [_]u16{0} ** 286;
+        freq[256] = 1; // ensure we have end of block code
+        for (&freq, 1..) |*f, i| {
+            if (i % j == 0)
+                f.* = @intCast(i);
+        }
+
+        // encoder from freqencies
+        enc.generate(&freq, 15);
+
+        // get code_lens from encoder
+        var code_lens = [_]u4{0} ** 286;
+        for (code_lens, 0..) |_, i| {
+            code_lens[i] = @intCast(enc.codes[i].len);
+        }
+        // generate decoder from code lens
+        var dec: LiteralDecoder = .{};
+        try dec.generate(&code_lens);
+
+        // expect decoder code to match original encoder code
+        for (dec.symbols) |s| {
+            if (s.code_bits == 0) continue;
+            const c_code: u16 = @bitReverse(@as(u15, @intCast(s.code)));
+            const symbol: u16 = switch (s.kind) {
+                .literal => s.symbol,
+                .end_of_block => 256,
+                .match => @as(u16, s.symbol) + 257,
+            };
+
+            const c = enc.codes[symbol];
+            try expect(c.code == c_code);
+        }
+
+        // find each symbol by code
+        for (enc.codes) |c| {
+            if (c.len == 0) continue;
+
+            const s_code: u15 = @bitReverse(@as(u15, @intCast(c.code)));
+            const s = try dec.find(s_code);
+            try expect(s.code == s_code);
+            try expect(s.code_bits == c.len);
+        }
+    }
+}
diff --git a/lib/std/compress/flate/huffman_encoder.zig b/lib/std/compress/flate/huffman_encoder.zig
new file mode 100644
index 0000000000..a8553ebb5e
--- /dev/null
+++ b/lib/std/compress/flate/huffman_encoder.zig
@@ -0,0 +1,536 @@
+const std = @import("std");
+const assert = std.debug.assert;
+const math = std.math;
+const mem = std.mem;
+const sort = std.sort;
+const testing = std.testing;
+
+const consts = @import("consts.zig").huffman;
+
+const LiteralNode = struct {
+    literal: u16,
+    freq: u16,
+};
+
+// Describes the state of the constructed tree for a given depth.
+const LevelInfo = struct {
+    // Our level.  for better printing
+    level: u32,
+
+    // The frequency of the last node at this level
+    last_freq: u32,
+
+    // The frequency of the next character to add to this level
+    next_char_freq: u32,
+
+    // The frequency of the next pair (from level below) to add to this level.
+    // Only valid if the "needed" value of the next lower level is 0.
+    next_pair_freq: u32,
+
+    // The number of chains remaining to generate for this level before moving
+    // up to the next level
+    needed: u32,
+};
+
+// hcode is a huffman code with a bit code and bit length.
+pub const HuffCode = struct {
+    code: u16 = 0,
+    len: u16 = 0,
+
+    // set sets the code and length of an hcode.
+    fn set(self: *HuffCode, code: u16, length: u16) void {
+        self.len = length;
+        self.code = code;
+    }
+};
+
+pub fn HuffmanEncoder(comptime size: usize) type {
+    return struct {
+        codes: [size]HuffCode = undefined,
+        // Reusable buffer with the longest possible frequency table.
+        freq_cache: [consts.max_num_frequencies + 1]LiteralNode = undefined,
+        bit_count: [17]u32 = undefined,
+        lns: []LiteralNode = undefined, // sorted by literal, stored to avoid repeated allocation in generate
+        lfs: []LiteralNode = undefined, // sorted by frequency, stored to avoid repeated allocation in generate
+
+        const Self = @This();
+
+        // Update this Huffman Code object to be the minimum code for the specified frequency count.
+        //
+        // freq  An array of frequencies, in which frequency[i] gives the frequency of literal i.
+        // max_bits  The maximum number of bits to use for any literal.
+        pub fn generate(self: *Self, freq: []u16, max_bits: u32) void {
+            var list = self.freq_cache[0 .. freq.len + 1];
+            // Number of non-zero literals
+            var count: u32 = 0;
+            // Set list to be the set of all non-zero literals and their frequencies
+            for (freq, 0..) |f, i| {
+                if (f != 0) {
+                    list[count] = LiteralNode{ .literal = @as(u16, @intCast(i)), .freq = f };
+                    count += 1;
+                } else {
+                    list[count] = LiteralNode{ .literal = 0x00, .freq = 0 };
+                    self.codes[i].len = 0;
+                }
+            }
+            list[freq.len] = LiteralNode{ .literal = 0x00, .freq = 0 };
+
+            list = list[0..count];
+            if (count <= 2) {
+                // Handle the small cases here, because they are awkward for the general case code. With
+                // two or fewer literals, everything has bit length 1.
+                for (list, 0..) |node, i| {
+                    // "list" is in order of increasing literal value.
+                    self.codes[node.literal].set(@as(u16, @intCast(i)), 1);
+                }
+                return;
+            }
+            self.lfs = list;
+            mem.sort(LiteralNode, self.lfs, {}, byFreq);
+
+            // Get the number of literals for each bit count
+            const bit_count = self.bitCounts(list, max_bits);
+            // And do the assignment
+            self.assignEncodingAndSize(bit_count, list);
+        }
+
+        pub fn bitLength(self: *Self, freq: []u16) u32 {
+            var total: u32 = 0;
+            for (freq, 0..) |f, i| {
+                if (f != 0) {
+                    total += @as(u32, @intCast(f)) * @as(u32, @intCast(self.codes[i].len));
+                }
+            }
+            return total;
+        }
+
+        // Return the number of literals assigned to each bit size in the Huffman encoding
+        //
+        // This method is only called when list.len >= 3
+        // The cases of 0, 1, and 2 literals are handled by special case code.
+        //
+        // list: An array of the literals with non-zero frequencies
+        // and their associated frequencies. The array is in order of increasing
+        // frequency, and has as its last element a special element with frequency
+        // std.math.maxInt(i32)
+        //
+        // max_bits: The maximum number of bits that should be used to encode any literal.
+        // Must be less than 16.
+        //
+        // Returns an integer array in which array[i] indicates the number of literals
+        // that should be encoded in i bits.
+        fn bitCounts(self: *Self, list: []LiteralNode, max_bits_to_use: usize) []u32 {
+            var max_bits = max_bits_to_use;
+            const n = list.len;
+            const max_bits_limit = 16;
+
+            assert(max_bits < max_bits_limit);
+
+            // The tree can't have greater depth than n - 1, no matter what. This
+            // saves a little bit of work in some small cases
+            max_bits = @min(max_bits, n - 1);
+
+            // Create information about each of the levels.
+            // A bogus "Level 0" whose sole purpose is so that
+            // level1.prev.needed == 0.  This makes level1.next_pair_freq
+            // be a legitimate value that never gets chosen.
+            var levels: [max_bits_limit]LevelInfo = mem.zeroes([max_bits_limit]LevelInfo);
+            // leaf_counts[i] counts the number of literals at the left
+            // of ancestors of the rightmost node at level i.
+            // leaf_counts[i][j] is the number of literals at the left
+            // of the level j ancestor.
+            var leaf_counts: [max_bits_limit][max_bits_limit]u32 = mem.zeroes([max_bits_limit][max_bits_limit]u32);
+
+            {
+                var level = @as(u32, 1);
+                while (level <= max_bits) : (level += 1) {
+                    // For every level, the first two items are the first two characters.
+                    // We initialize the levels as if we had already figured this out.
+                    levels[level] = LevelInfo{
+                        .level = level,
+                        .last_freq = list[1].freq,
+                        .next_char_freq = list[2].freq,
+                        .next_pair_freq = list[0].freq + list[1].freq,
+                        .needed = 0,
+                    };
+                    leaf_counts[level][level] = 2;
+                    if (level == 1) {
+                        levels[level].next_pair_freq = math.maxInt(i32);
+                    }
+                }
+            }
+
+            // We need a total of 2*n - 2 items at top level and have already generated 2.
+            levels[max_bits].needed = 2 * @as(u32, @intCast(n)) - 4;
+
+            {
+                var level = max_bits;
+                while (true) {
+                    var l = &levels[level];
+                    if (l.next_pair_freq == math.maxInt(i32) and l.next_char_freq == math.maxInt(i32)) {
+                        // We've run out of both leafs and pairs.
+                        // End all calculations for this level.
+                        // To make sure we never come back to this level or any lower level,
+                        // set next_pair_freq impossibly large.
+                        l.needed = 0;
+                        levels[level + 1].next_pair_freq = math.maxInt(i32);
+                        level += 1;
+                        continue;
+                    }
+
+                    const prev_freq = l.last_freq;
+                    if (l.next_char_freq < l.next_pair_freq) {
+                        // The next item on this row is a leaf node.
+                        const next = leaf_counts[level][level] + 1;
+                        l.last_freq = l.next_char_freq;
+                        // Lower leaf_counts are the same of the previous node.
+                        leaf_counts[level][level] = next;
+                        if (next >= list.len) {
+                            l.next_char_freq = maxNode().freq;
+                        } else {
+                            l.next_char_freq = list[next].freq;
+                        }
+                    } else {
+                        // The next item on this row is a pair from the previous row.
+                        // next_pair_freq isn't valid until we generate two
+                        // more values in the level below
+                        l.last_freq = l.next_pair_freq;
+                        // Take leaf counts from the lower level, except counts[level] remains the same.
+                        @memcpy(leaf_counts[level][0..level], leaf_counts[level - 1][0..level]);
+                        levels[l.level - 1].needed = 2;
+                    }
+
+                    l.needed -= 1;
+                    if (l.needed == 0) {
+                        // We've done everything we need to do for this level.
+                        // Continue calculating one level up. Fill in next_pair_freq
+                        // of that level with the sum of the two nodes we've just calculated on
+                        // this level.
+                        if (l.level == max_bits) {
+                            // All done!
+                            break;
+                        }
+                        levels[l.level + 1].next_pair_freq = prev_freq + l.last_freq;
+                        level += 1;
+                    } else {
+                        // If we stole from below, move down temporarily to replenish it.
+                        while (levels[level - 1].needed > 0) {
+                            level -= 1;
+                            if (level == 0) {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Somethings is wrong if at the end, the top level is null or hasn't used
+            // all of the leaves.
+            assert(leaf_counts[max_bits][max_bits] == n);
+
+            var bit_count = self.bit_count[0 .. max_bits + 1];
+            var bits: u32 = 1;
+            const counts = &leaf_counts[max_bits];
+            {
+                var level = max_bits;
+                while (level > 0) : (level -= 1) {
+                    // counts[level] gives the number of literals requiring at least "bits"
+                    // bits to encode.
+                    bit_count[bits] = counts[level] - counts[level - 1];
+                    bits += 1;
+                    if (level == 0) {
+                        break;
+                    }
+                }
+            }
+            return bit_count;
+        }
+
+        // Look at the leaves and assign them a bit count and an encoding as specified
+        // in RFC 1951 3.2.2
+        fn assignEncodingAndSize(self: *Self, bit_count: []u32, list_arg: []LiteralNode) void {
+            var code = @as(u16, 0);
+            var list = list_arg;
+
+            for (bit_count, 0..) |bits, n| {
+                code <<= 1;
+                if (n == 0 or bits == 0) {
+                    continue;
+                }
+                // The literals list[list.len-bits] .. list[list.len-bits]
+                // are encoded using "bits" bits, and get the values
+                // code, code + 1, ....  The code values are
+                // assigned in literal order (not frequency order).
+                const chunk = list[list.len - @as(u32, @intCast(bits)) ..];
+
+                self.lns = chunk;
+                mem.sort(LiteralNode, self.lns, {}, byLiteral);
+
+                for (chunk) |node| {
+                    self.codes[node.literal] = HuffCode{
+                        .code = bitReverse(u16, code, @as(u5, @intCast(n))),
+                        .len = @as(u16, @intCast(n)),
+                    };
+                    code += 1;
+                }
+                list = list[0 .. list.len - @as(u32, @intCast(bits))];
+            }
+        }
+    };
+}
+
+fn maxNode() LiteralNode {
+    return LiteralNode{
+        .literal = math.maxInt(u16),
+        .freq = math.maxInt(u16),
+    };
+}
+
+pub fn huffmanEncoder(comptime size: u32) HuffmanEncoder(size) {
+    return .{};
+}
+
+pub const LiteralEncoder = HuffmanEncoder(consts.max_num_frequencies);
+pub const DistanceEncoder = HuffmanEncoder(consts.distance_code_count);
+pub const CodegenEncoder = HuffmanEncoder(19);
+
+// Generates a HuffmanCode corresponding to the fixed literal table
+pub fn fixedLiteralEncoder() LiteralEncoder {
+    var h: LiteralEncoder = undefined;
+    var ch: u16 = 0;
+
+    while (ch < consts.max_num_frequencies) : (ch += 1) {
+        var bits: u16 = undefined;
+        var size: u16 = undefined;
+        switch (ch) {
+            0...143 => {
+                // size 8, 000110000  .. 10111111
+                bits = ch + 48;
+                size = 8;
+            },
+            144...255 => {
+                // size 9, 110010000 .. 111111111
+                bits = ch + 400 - 144;
+                size = 9;
+            },
+            256...279 => {
+                // size 7, 0000000 .. 0010111
+                bits = ch - 256;
+                size = 7;
+            },
+            else => {
+                // size 8, 11000000 .. 11000111
+                bits = ch + 192 - 280;
+                size = 8;
+            },
+        }
+        h.codes[ch] = HuffCode{ .code = bitReverse(u16, bits, @as(u5, @intCast(size))), .len = size };
+    }
+    return h;
+}
+
+pub fn fixedDistanceEncoder() DistanceEncoder {
+    var h: DistanceEncoder = undefined;
+    for (h.codes, 0..) |_, ch| {
+        h.codes[ch] = HuffCode{ .code = bitReverse(u16, @as(u16, @intCast(ch)), 5), .len = 5 };
+    }
+    return h;
+}
+
+pub fn huffmanDistanceEncoder() DistanceEncoder {
+    var distance_freq = [1]u16{0} ** consts.distance_code_count;
+    distance_freq[0] = 1;
+    // huff_distance is a static distance encoder used for huffman only encoding.
+    // It can be reused since we will not be encoding distance values.
+    var h: DistanceEncoder = .{};
+    h.generate(distance_freq[0..], 15);
+    return h;
+}
+
+fn byLiteral(context: void, a: LiteralNode, b: LiteralNode) bool {
+    _ = context;
+    return a.literal < b.literal;
+}
+
+fn byFreq(context: void, a: LiteralNode, b: LiteralNode) bool {
+    _ = context;
+    if (a.freq == b.freq) {
+        return a.literal < b.literal;
+    }
+    return a.freq < b.freq;
+}
+
+test "flate.HuffmanEncoder generate a Huffman code from an array of frequencies" {
+    var freqs: [19]u16 = [_]u16{
+        8, // 0
+        1, // 1
+        1, // 2
+        2, // 3
+        5, // 4
+        10, // 5
+        9, // 6
+        1, // 7
+        0, // 8
+        0, // 9
+        0, // 10
+        0, // 11
+        0, // 12
+        0, // 13
+        0, // 14
+        0, // 15
+        1, // 16
+        3, // 17
+        5, // 18
+    };
+
+    var enc = huffmanEncoder(19);
+    enc.generate(freqs[0..], 7);
+
+    try testing.expectEqual(@as(u32, 141), enc.bitLength(freqs[0..]));
+
+    try testing.expectEqual(@as(usize, 3), enc.codes[0].len);
+    try testing.expectEqual(@as(usize, 6), enc.codes[1].len);
+    try testing.expectEqual(@as(usize, 6), enc.codes[2].len);
+    try testing.expectEqual(@as(usize, 5), enc.codes[3].len);
+    try testing.expectEqual(@as(usize, 3), enc.codes[4].len);
+    try testing.expectEqual(@as(usize, 2), enc.codes[5].len);
+    try testing.expectEqual(@as(usize, 2), enc.codes[6].len);
+    try testing.expectEqual(@as(usize, 6), enc.codes[7].len);
+    try testing.expectEqual(@as(usize, 0), enc.codes[8].len);
+    try testing.expectEqual(@as(usize, 0), enc.codes[9].len);
+    try testing.expectEqual(@as(usize, 0), enc.codes[10].len);
+    try testing.expectEqual(@as(usize, 0), enc.codes[11].len);
+    try testing.expectEqual(@as(usize, 0), enc.codes[12].len);
+    try testing.expectEqual(@as(usize, 0), enc.codes[13].len);
+    try testing.expectEqual(@as(usize, 0), enc.codes[14].len);
+    try testing.expectEqual(@as(usize, 0), enc.codes[15].len);
+    try testing.expectEqual(@as(usize, 6), enc.codes[16].len);
+    try testing.expectEqual(@as(usize, 5), enc.codes[17].len);
+    try testing.expectEqual(@as(usize, 3), enc.codes[18].len);
+
+    try testing.expectEqual(@as(u16, 0x0), enc.codes[5].code);
+    try testing.expectEqual(@as(u16, 0x2), enc.codes[6].code);
+    try testing.expectEqual(@as(u16, 0x1), enc.codes[0].code);
+    try testing.expectEqual(@as(u16, 0x5), enc.codes[4].code);
+    try testing.expectEqual(@as(u16, 0x3), enc.codes[18].code);
+    try testing.expectEqual(@as(u16, 0x7), enc.codes[3].code);
+    try testing.expectEqual(@as(u16, 0x17), enc.codes[17].code);
+    try testing.expectEqual(@as(u16, 0x0f), enc.codes[1].code);
+    try testing.expectEqual(@as(u16, 0x2f), enc.codes[2].code);
+    try testing.expectEqual(@as(u16, 0x1f), enc.codes[7].code);
+    try testing.expectEqual(@as(u16, 0x3f), enc.codes[16].code);
+}
+
+test "flate.HuffmanEncoder generate a Huffman code for the fixed literal table specific to Deflate" {
+    const enc = fixedLiteralEncoder();
+    for (enc.codes) |c| {
+        switch (c.len) {
+            7 => {
+                const v = @bitReverse(@as(u7, @intCast(c.code)));
+                try testing.expect(v <= 0b0010111);
+            },
+            8 => {
+                const v = @bitReverse(@as(u8, @intCast(c.code)));
+                try testing.expect((v >= 0b000110000 and v <= 0b10111111) or
+                    (v >= 0b11000000 and v <= 11000111));
+            },
+            9 => {
+                const v = @bitReverse(@as(u9, @intCast(c.code)));
+                try testing.expect(v >= 0b110010000 and v <= 0b111111111);
+            },
+            else => unreachable,
+        }
+    }
+}
+
+test "flate.HuffmanEncoder generate a Huffman code for the 30 possible relative distances (LZ77 distances) of Deflate" {
+    const enc = fixedDistanceEncoder();
+    for (enc.codes) |c| {
+        const v = @bitReverse(@as(u5, @intCast(c.code)));
+        try testing.expect(v <= 29);
+        try testing.expect(c.len == 5);
+    }
+}
+
+// Reverse bit-by-bit a N-bit code.
+fn bitReverse(comptime T: type, value: T, n: usize) T {
+    const r = @bitReverse(value);
+    return r >> @as(math.Log2Int(T), @intCast(@typeInfo(T).Int.bits - n));
+}
+
+test "flate bitReverse" {
+    const ReverseBitsTest = struct {
+        in: u16,
+        bit_count: u5,
+        out: u16,
+    };
+
+    const reverse_bits_tests = [_]ReverseBitsTest{
+        .{ .in = 1, .bit_count = 1, .out = 1 },
+        .{ .in = 1, .bit_count = 2, .out = 2 },
+        .{ .in = 1, .bit_count = 3, .out = 4 },
+        .{ .in = 1, .bit_count = 4, .out = 8 },
+        .{ .in = 1, .bit_count = 5, .out = 16 },
+        .{ .in = 17, .bit_count = 5, .out = 17 },
+        .{ .in = 257, .bit_count = 9, .out = 257 },
+        .{ .in = 29, .bit_count = 5, .out = 23 },
+    };
+
+    for (reverse_bits_tests) |h| {
+        const v = bitReverse(u16, h.in, h.bit_count);
+        try std.testing.expectEqual(h.out, v);
+    }
+}
+
+test "flate.HuffmanEncoder fixedLiteralEncoder codes" {
+    var al = std.ArrayList(u8).init(testing.allocator);
+    defer al.deinit();
+    var bw = std.io.bitWriter(.little, al.writer());
+
+    const f = fixedLiteralEncoder();
+    for (f.codes) |c| {
+        try bw.writeBits(c.code, c.len);
+    }
+    try testing.expectEqualSlices(u8, &fixed_codes, al.items);
+}
+
+pub const fixed_codes = [_]u8{
+    0b00001100, 0b10001100, 0b01001100, 0b11001100, 0b00101100, 0b10101100, 0b01101100, 0b11101100,
+    0b00011100, 0b10011100, 0b01011100, 0b11011100, 0b00111100, 0b10111100, 0b01111100, 0b11111100,
+    0b00000010, 0b10000010, 0b01000010, 0b11000010, 0b00100010, 0b10100010, 0b01100010, 0b11100010,
+    0b00010010, 0b10010010, 0b01010010, 0b11010010, 0b00110010, 0b10110010, 0b01110010, 0b11110010,
+    0b00001010, 0b10001010, 0b01001010, 0b11001010, 0b00101010, 0b10101010, 0b01101010, 0b11101010,
+    0b00011010, 0b10011010, 0b01011010, 0b11011010, 0b00111010, 0b10111010, 0b01111010, 0b11111010,
+    0b00000110, 0b10000110, 0b01000110, 0b11000110, 0b00100110, 0b10100110, 0b01100110, 0b11100110,
+    0b00010110, 0b10010110, 0b01010110, 0b11010110, 0b00110110, 0b10110110, 0b01110110, 0b11110110,
+    0b00001110, 0b10001110, 0b01001110, 0b11001110, 0b00101110, 0b10101110, 0b01101110, 0b11101110,
+    0b00011110, 0b10011110, 0b01011110, 0b11011110, 0b00111110, 0b10111110, 0b01111110, 0b11111110,
+    0b00000001, 0b10000001, 0b01000001, 0b11000001, 0b00100001, 0b10100001, 0b01100001, 0b11100001,
+    0b00010001, 0b10010001, 0b01010001, 0b11010001, 0b00110001, 0b10110001, 0b01110001, 0b11110001,
+    0b00001001, 0b10001001, 0b01001001, 0b11001001, 0b00101001, 0b10101001, 0b01101001, 0b11101001,
+    0b00011001, 0b10011001, 0b01011001, 0b11011001, 0b00111001, 0b10111001, 0b01111001, 0b11111001,
+    0b00000101, 0b10000101, 0b01000101, 0b11000101, 0b00100101, 0b10100101, 0b01100101, 0b11100101,
+    0b00010101, 0b10010101, 0b01010101, 0b11010101, 0b00110101, 0b10110101, 0b01110101, 0b11110101,
+    0b00001101, 0b10001101, 0b01001101, 0b11001101, 0b00101101, 0b10101101, 0b01101101, 0b11101101,
+    0b00011101, 0b10011101, 0b01011101, 0b11011101, 0b00111101, 0b10111101, 0b01111101, 0b11111101,
+    0b00010011, 0b00100110, 0b01001110, 0b10011010, 0b00111100, 0b01100101, 0b11101010, 0b10110100,
+    0b11101001, 0b00110011, 0b01100110, 0b11001110, 0b10011010, 0b00111101, 0b01100111, 0b11101110,
+    0b10111100, 0b11111001, 0b00001011, 0b00010110, 0b00101110, 0b01011010, 0b10111100, 0b01100100,
+    0b11101001, 0b10110010, 0b11100101, 0b00101011, 0b01010110, 0b10101110, 0b01011010, 0b10111101,
+    0b01100110, 0b11101101, 0b10111010, 0b11110101, 0b00011011, 0b00110110, 0b01101110, 0b11011010,
+    0b10111100, 0b01100101, 0b11101011, 0b10110110, 0b11101101, 0b00111011, 0b01110110, 0b11101110,
+    0b11011010, 0b10111101, 0b01100111, 0b11101111, 0b10111110, 0b11111101, 0b00000111, 0b00001110,
+    0b00011110, 0b00111010, 0b01111100, 0b11100100, 0b11101000, 0b10110001, 0b11100011, 0b00100111,
+    0b01001110, 0b10011110, 0b00111010, 0b01111101, 0b11100110, 0b11101100, 0b10111001, 0b11110011,
+    0b00010111, 0b00101110, 0b01011110, 0b10111010, 0b01111100, 0b11100101, 0b11101010, 0b10110101,
+    0b11101011, 0b00110111, 0b01101110, 0b11011110, 0b10111010, 0b01111101, 0b11100111, 0b11101110,
+    0b10111101, 0b11111011, 0b00001111, 0b00011110, 0b00111110, 0b01111010, 0b11111100, 0b11100100,
+    0b11101001, 0b10110011, 0b11100111, 0b00101111, 0b01011110, 0b10111110, 0b01111010, 0b11111101,
+    0b11100110, 0b11101101, 0b10111011, 0b11110111, 0b00011111, 0b00111110, 0b01111110, 0b11111010,
+    0b11111100, 0b11100101, 0b11101011, 0b10110111, 0b11101111, 0b00111111, 0b01111110, 0b11111110,
+    0b11111010, 0b11111101, 0b11100111, 0b11101111, 0b10111111, 0b11111111, 0b00000000, 0b00100000,
+    0b00001000, 0b00001100, 0b10000001, 0b11000010, 0b11100000, 0b00001000, 0b00100100, 0b00001010,
+    0b10001101, 0b11000001, 0b11100010, 0b11110000, 0b00000100, 0b00100010, 0b10001001, 0b01001100,
+    0b10100001, 0b11010010, 0b11101000, 0b00000011, 0b10000011, 0b01000011, 0b11000011, 0b00100011,
+    0b10100011,
+};
diff --git a/lib/std/compress/flate/inflate.zig b/lib/std/compress/flate/inflate.zig
new file mode 100644
index 0000000000..d87a888d11
--- /dev/null
+++ b/lib/std/compress/flate/inflate.zig
@@ -0,0 +1,546 @@
+const std = @import("std");
+const assert = std.debug.assert;
+const testing = std.testing;
+
+const hfd = @import("huffman_decoder.zig");
+const BitReader = @import("bit_reader.zig").BitReader;
+const CircularBuffer = @import("CircularBuffer.zig");
+const Container = @import("container.zig").Container;
+const Token = @import("Token.zig");
+const codegen_order = @import("consts.zig").huffman.codegen_order;
+
+/// Decompresses deflate bit stream `reader` and writes uncompressed data to the
+/// `writer` stream.
+pub fn decompress(comptime container: Container, reader: anytype, writer: anytype) !void {
+    var d = decompressor(container, reader);
+    try d.decompress(writer);
+}
+
+/// Inflate decompressor for the reader type.
+pub fn decompressor(comptime container: Container, reader: anytype) Inflate(container, @TypeOf(reader)) {
+    return Inflate(container, @TypeOf(reader)).init(reader);
+}
+
+/// Inflate decompresses deflate bit stream. Reads compressed data from reader
+/// provided in init. Decompressed data are stored in internal hist buffer and
+/// can be accesses iterable `next` or reader interface.
+///
+/// Container defines header/footer wrapper around deflate bit stream. Can be
+/// gzip or zlib.
+///
+/// Deflate bit stream consists of multiple blocks. Block can be one of three types:
+///   * stored, non compressed, max 64k in size
+///   * fixed, huffman codes are predefined
+///   * dynamic, huffman code tables are encoded at the block start
+///
+/// `step` function runs decoder until internal `hist` buffer is full. Client
+/// than needs to read that data in order to proceed with decoding.
+///
+/// Allocates 74.5K of internal buffers, most important are:
+///   * 64K for history (CircularBuffer)
+///   * ~10K huffman decoders (Literal and DistanceDecoder)
+///
+pub fn Inflate(comptime container: Container, comptime ReaderType: type) type {
+    return struct {
+        const BitReaderType = BitReader(ReaderType);
+        const F = BitReaderType.flag;
+
+        bits: BitReaderType = .{},
+        hist: CircularBuffer = .{},
+        // Hashes, produces checkusm, of uncompressed data for gzip/zlib footer.
+        hasher: container.Hasher() = .{},
+
+        // dynamic block huffman code decoders
+        lit_dec: hfd.LiteralDecoder = .{}, // literals
+        dst_dec: hfd.DistanceDecoder = .{}, // distances
+
+        // current read state
+        bfinal: u1 = 0,
+        block_type: u2 = 0b11,
+        state: ReadState = .protocol_header,
+
+        const ReadState = enum {
+            protocol_header,
+            block_header,
+            block,
+            protocol_footer,
+            end,
+        };
+
+        const Self = @This();
+
+        pub const Error = BitReaderType.Error || Container.Error || hfd.Error || error{
+            InvalidCode,
+            InvalidMatch,
+            InvalidBlockType,
+            WrongStoredBlockNlen,
+            InvalidDynamicBlockHeader,
+        };
+
+        pub fn init(rt: ReaderType) Self {
+            return .{ .bits = BitReaderType.init(rt) };
+        }
+
+        fn blockHeader(self: *Self) !void {
+            self.bfinal = try self.bits.read(u1);
+            self.block_type = try self.bits.read(u2);
+        }
+
+        fn storedBlock(self: *Self) !bool {
+            self.bits.alignToByte(); // skip padding until byte boundary
+            // everyting after this is byte aligned in stored block
+            var len = try self.bits.read(u16);
+            const nlen = try self.bits.read(u16);
+            if (len != ~nlen) return error.WrongStoredBlockNlen;
+
+            while (len > 0) {
+                const buf = self.hist.getWritable(len);
+                try self.bits.readAll(buf);
+                len -= @intCast(buf.len);
+            }
+            return true;
+        }
+
+        fn fixedBlock(self: *Self) !bool {
+            while (!self.hist.full()) {
+                const code = try self.bits.readFixedCode();
+                switch (code) {
+                    0...255 => self.hist.write(@intCast(code)),
+                    256 => return true, // end of block
+                    257...285 => try self.fixedDistanceCode(@intCast(code - 257)),
+                    else => return error.InvalidCode,
+                }
+            }
+            return false;
+        }
+
+        // Handles fixed block non literal (length) code.
+        // Length code is followed by 5 bits of distance code.
+        fn fixedDistanceCode(self: *Self, code: u8) !void {
+            try self.bits.fill(5 + 5 + 13);
+            const length = try self.decodeLength(code);
+            const distance = try self.decodeDistance(try self.bits.readF(u5, F.buffered | F.reverse));
+            try self.hist.writeMatch(length, distance);
+        }
+
+        inline fn decodeLength(self: *Self, code: u8) !u16 {
+            if (code > 28) return error.InvalidCode;
+            const ml = Token.matchLength(code);
+            return if (ml.extra_bits == 0) // 0 - 5 extra bits
+                ml.base
+            else
+                ml.base + try self.bits.readN(ml.extra_bits, F.buffered);
+        }
+
+        fn decodeDistance(self: *Self, code: u8) !u16 {
+            if (code > 29) return error.InvalidCode;
+            const md = Token.matchDistance(code);
+            return if (md.extra_bits == 0) // 0 - 13 extra bits
+                md.base
+            else
+                md.base + try self.bits.readN(md.extra_bits, F.buffered);
+        }
+
+        fn dynamicBlockHeader(self: *Self) !void {
+            const hlit: u16 = @as(u16, try self.bits.read(u5)) + 257; // number of ll code entries present - 257
+            const hdist: u16 = @as(u16, try self.bits.read(u5)) + 1; // number of distance code entries - 1
+            const hclen: u8 = @as(u8, try self.bits.read(u4)) + 4; // hclen + 4 code lenths are encoded
+
+            if (hlit > 286 or hdist > 30)
+                return error.InvalidDynamicBlockHeader;
+
+            // lengths for code lengths
+            var cl_lens = [_]u4{0} ** 19;
+            for (0..hclen) |i| {
+                cl_lens[codegen_order[i]] = try self.bits.read(u3);
+            }
+            var cl_dec: hfd.CodegenDecoder = .{};
+            try cl_dec.generate(&cl_lens);
+
+            // literal code lengths
+            var lit_lens = [_]u4{0} ** (286);
+            var pos: usize = 0;
+            while (pos < hlit) {
+                const sym = try cl_dec.find(try self.bits.peekF(u7, F.reverse));
+                try self.bits.shift(sym.code_bits);
+                pos += try self.dynamicCodeLength(sym.symbol, &lit_lens, pos);
+            }
+            if (pos > hlit)
+                return error.InvalidDynamicBlockHeader;
+
+            // distance code lenths
+            var dst_lens = [_]u4{0} ** (30);
+            pos = 0;
+            while (pos < hdist) {
+                const sym = try cl_dec.find(try self.bits.peekF(u7, F.reverse));
+                try self.bits.shift(sym.code_bits);
+                pos += try self.dynamicCodeLength(sym.symbol, &dst_lens, pos);
+            }
+            if (pos > hdist)
+                return error.InvalidDynamicBlockHeader;
+
+            try self.lit_dec.generate(&lit_lens);
+            try self.dst_dec.generate(&dst_lens);
+        }
+
+        // Decode code length symbol to code length. Writes decoded length into
+        // lens slice starting at position pos. Returns number of positions
+        // advanced.
+        fn dynamicCodeLength(self: *Self, code: u16, lens: []u4, pos: usize) !usize {
+            if (pos >= lens.len)
+                return error.InvalidDynamicBlockHeader;
+
+            switch (code) {
+                0...15 => {
+                    // Represent code lengths of 0 - 15
+                    lens[pos] = @intCast(code);
+                    return 1;
+                },
+                16 => {
+                    // Copy the previous code length 3 - 6 times.
+                    // The next 2 bits indicate repeat length
+                    const n: u8 = @as(u8, try self.bits.read(u2)) + 3;
+                    if (pos == 0 or pos + n > lens.len)
+                        return error.InvalidDynamicBlockHeader;
+                    for (0..n) |i| {
+                        lens[pos + i] = lens[pos + i - 1];
+                    }
+                    return n;
+                },
+                // Repeat a code length of 0 for 3 - 10 times. (3 bits of length)
+                17 => return @as(u8, try self.bits.read(u3)) + 3,
+                // Repeat a code length of 0 for 11 - 138 times (7 bits of length)
+                18 => return @as(u8, try self.bits.read(u7)) + 11,
+                else => return error.InvalidDynamicBlockHeader,
+            }
+        }
+
+        // In larger archives most blocks are usually dynamic, so decompression
+        // performance depends on this function.
+        fn dynamicBlock(self: *Self) !bool {
+            // Hot path loop!
+            while (!self.hist.full()) {
+                try self.bits.fill(15); // optimization so other bit reads can be buffered (avoiding one `if` in hot path)
+                const sym = try self.decodeSymbol(&self.lit_dec);
+
+                switch (sym.kind) {
+                    .literal => self.hist.write(sym.symbol),
+                    .match => { // Decode match backreference <length, distance>
+                        try self.bits.fill(5 + 15 + 13); // so we can use buffered reads
+                        const length = try self.decodeLength(sym.symbol);
+                        const dsm = try self.decodeSymbol(&self.dst_dec);
+                        const distance = try self.decodeDistance(dsm.symbol);
+                        try self.hist.writeMatch(length, distance);
+                    },
+                    .end_of_block => return true,
+                }
+            }
+            return false;
+        }
+
+        // Peek 15 bits from bits reader (maximum code len is 15 bits). Use
+        // decoder to find symbol for that code. We then know how many bits is
+        // used. Shift bit reader for that much bits, those bits are used. And
+        // return symbol.
+        fn decodeSymbol(self: *Self, decoder: anytype) !hfd.Symbol {
+            const sym = try decoder.find(try self.bits.peekF(u15, F.buffered | F.reverse));
+            try self.bits.shift(sym.code_bits);
+            return sym;
+        }
+
+        fn step(self: *Self) !void {
+            switch (self.state) {
+                .protocol_header => {
+                    try container.parseHeader(&self.bits);
+                    self.state = .block_header;
+                },
+                .block_header => {
+                    try self.blockHeader();
+                    self.state = .block;
+                    if (self.block_type == 2) try self.dynamicBlockHeader();
+                },
+                .block => {
+                    const done = switch (self.block_type) {
+                        0 => try self.storedBlock(),
+                        1 => try self.fixedBlock(),
+                        2 => try self.dynamicBlock(),
+                        else => return error.InvalidBlockType,
+                    };
+                    if (done) {
+                        self.state = if (self.bfinal == 1) .protocol_footer else .block_header;
+                    }
+                },
+                .protocol_footer => {
+                    self.bits.alignToByte();
+                    try container.parseFooter(&self.hasher, &self.bits);
+                    self.state = .end;
+                },
+                .end => {},
+            }
+        }
+
+        /// Replaces the inner reader with new reader.
+        pub fn setReader(self: *Self, new_reader: ReaderType) void {
+            self.bits.forward_reader = new_reader;
+            if (self.state == .end or self.state == .protocol_footer) {
+                self.state = .protocol_header;
+            }
+        }
+
+        // Reads all compressed data from the internal reader and outputs plain
+        // (uncompressed) data to the provided writer.
+        pub fn decompress(self: *Self, writer: anytype) !void {
+            while (try self.next()) |buf| {
+                try writer.writeAll(buf);
+            }
+        }
+
+        // Iterator interface
+
+        /// Can be used in iterator like loop without memcpy to another buffer:
+        ///   while (try inflate.next()) |buf| { ... }
+        pub fn next(self: *Self) Error!?[]const u8 {
+            const out = try self.get(0);
+            if (out.len == 0) return null;
+            return out;
+        }
+
+        /// Returns decompressed data from internal sliding window buffer.
+        /// Returned buffer can be any length between 0 and `limit` bytes.
+        /// 0 returned bytes means end of stream reached.
+        /// With limit=0 returns as much data can. It newer will be more
+        /// than 65536 bytes, which is limit of internal buffer.
+        pub fn get(self: *Self, limit: usize) Error![]const u8 {
+            while (true) {
+                const out = self.hist.readAtMost(limit);
+                if (out.len > 0) {
+                    self.hasher.update(out);
+                    return out;
+                }
+                if (self.state == .end) return out;
+                try self.step();
+            }
+        }
+
+        // Reader interface
+
+        pub const Reader = std.io.Reader(*Self, Error, read);
+
+        /// Returns the number of bytes read. It may be less than buffer.len.
+        /// If the number of bytes read is 0, it means end of stream.
+        /// End of stream is not an error condition.
+        pub fn read(self: *Self, buffer: []u8) Error!usize {
+            const out = try self.get(buffer.len);
+            @memcpy(buffer[0..out.len], out);
+            return out.len;
+        }
+
+        pub fn reader(self: *Self) Reader {
+            return .{ .context = self };
+        }
+    };
+}
+
+test "flate.Inflate struct sizes" {
+    var fbs = std.io.fixedBufferStream("");
+    const ReaderType = @TypeOf(fbs.reader());
+    const inflate_size = @sizeOf(Inflate(.gzip, ReaderType));
+
+    try testing.expectEqual(76320, inflate_size);
+    try testing.expectEqual(
+        @sizeOf(CircularBuffer) + @sizeOf(hfd.LiteralDecoder) + @sizeOf(hfd.DistanceDecoder) + 48,
+        inflate_size,
+    );
+    try testing.expectEqual(65536 + 8 + 8, @sizeOf(CircularBuffer));
+    try testing.expectEqual(8, @sizeOf(Container.raw.Hasher()));
+    try testing.expectEqual(24, @sizeOf(BitReader(ReaderType)));
+    try testing.expectEqual(6384, @sizeOf(hfd.LiteralDecoder));
+    try testing.expectEqual(4336, @sizeOf(hfd.DistanceDecoder));
+}
+
+test "flate.Inflate decompress" {
+    const cases = [_]struct {
+        in: []const u8,
+        out: []const u8,
+    }{
+        // non compressed block (type 0)
+        .{
+            .in = &[_]u8{
+                0b0000_0001, 0b0000_1100, 0x00, 0b1111_0011, 0xff, // deflate fixed buffer header len, nlen
+                'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', 0x0a, // non compressed data
+            },
+            .out = "Hello world\n",
+        },
+        // fixed code block (type 1)
+        .{
+            .in = &[_]u8{
+                0xf3, 0x48, 0xcd, 0xc9, 0xc9, 0x57, 0x28, 0xcf, // deflate data block type 1
+                0x2f, 0xca, 0x49, 0xe1, 0x02, 0x00,
+            },
+            .out = "Hello world\n",
+        },
+        // dynamic block (type 2)
+        .{
+            .in = &[_]u8{
+                0x3d, 0xc6, 0x39, 0x11, 0x00, 0x00, 0x0c, 0x02, // deflate data block type 2
+                0x30, 0x2b, 0xb5, 0x52, 0x1e, 0xff, 0x96, 0x38,
+                0x16, 0x96, 0x5c, 0x1e, 0x94, 0xcb, 0x6d, 0x01,
+            },
+            .out = "ABCDEABCD ABCDEABCD",
+        },
+    };
+    for (cases) |c| {
+        var fb = std.io.fixedBufferStream(c.in);
+        var al = std.ArrayList(u8).init(testing.allocator);
+        defer al.deinit();
+
+        try decompress(.raw, fb.reader(), al.writer());
+        try testing.expectEqualStrings(c.out, al.items);
+    }
+}
+
+test "flate.Inflate gzip decompress" {
+    const cases = [_]struct {
+        in: []const u8,
+        out: []const u8,
+    }{
+        // non compressed block (type 0)
+        .{
+            .in = &[_]u8{
+                0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, // gzip header (10 bytes)
+                0b0000_0001, 0b0000_1100, 0x00, 0b1111_0011, 0xff, // deflate fixed buffer header len, nlen
+                'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', 0x0a, // non compressed data
+                0xd5, 0xe0, 0x39, 0xb7, // gzip footer: checksum
+                0x0c, 0x00, 0x00, 0x00, // gzip footer: size
+            },
+            .out = "Hello world\n",
+        },
+        // fixed code block (type 1)
+        .{
+            .in = &[_]u8{
+                0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x03, // gzip header (10 bytes)
+                0xf3, 0x48, 0xcd, 0xc9, 0xc9, 0x57, 0x28, 0xcf, // deflate data block type 1
+                0x2f, 0xca, 0x49, 0xe1, 0x02, 0x00,
+                0xd5, 0xe0, 0x39, 0xb7, 0x0c, 0x00, 0x00, 0x00, // gzip footer (chksum, len)
+            },
+            .out = "Hello world\n",
+        },
+        // dynamic block (type 2)
+        .{
+            .in = &[_]u8{
+                0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, // gzip header (10 bytes)
+                0x3d, 0xc6, 0x39, 0x11, 0x00, 0x00, 0x0c, 0x02, // deflate data block type 2
+                0x30, 0x2b, 0xb5, 0x52, 0x1e, 0xff, 0x96, 0x38,
+                0x16, 0x96, 0x5c, 0x1e, 0x94, 0xcb, 0x6d, 0x01,
+                0x17, 0x1c, 0x39, 0xb4, 0x13, 0x00, 0x00, 0x00, // gzip footer (chksum, len)
+            },
+            .out = "ABCDEABCD ABCDEABCD",
+        },
+        // gzip header with name
+        .{
+            .in = &[_]u8{
+                0x1f, 0x8b, 0x08, 0x08, 0xe5, 0x70, 0xb1, 0x65, 0x00, 0x03, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x2e,
+                0x74, 0x78, 0x74, 0x00, 0xf3, 0x48, 0xcd, 0xc9, 0xc9, 0x57, 0x28, 0xcf, 0x2f, 0xca, 0x49, 0xe1,
+                0x02, 0x00, 0xd5, 0xe0, 0x39, 0xb7, 0x0c, 0x00, 0x00, 0x00,
+            },
+            .out = "Hello world\n",
+        },
+    };
+    for (cases) |c| {
+        var fb = std.io.fixedBufferStream(c.in);
+        var al = std.ArrayList(u8).init(testing.allocator);
+        defer al.deinit();
+
+        try decompress(.gzip, fb.reader(), al.writer());
+        try testing.expectEqualStrings(c.out, al.items);
+    }
+}
+
+test "flate.Inflate zlib decompress" {
+    const cases = [_]struct {
+        in: []const u8,
+        out: []const u8,
+    }{
+        // non compressed block (type 0)
+        .{
+            .in = &[_]u8{
+                0x78, 0b10_0_11100, // zlib header (2 bytes)
+                0b0000_0001, 0b0000_1100, 0x00, 0b1111_0011, 0xff, // deflate fixed buffer header len, nlen
+                'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', 0x0a, // non compressed data
+                0x1c, 0xf2, 0x04, 0x47, // zlib footer: checksum
+            },
+            .out = "Hello world\n",
+        },
+    };
+    for (cases) |c| {
+        var fb = std.io.fixedBufferStream(c.in);
+        var al = std.ArrayList(u8).init(testing.allocator);
+        defer al.deinit();
+
+        try decompress(.zlib, fb.reader(), al.writer());
+        try testing.expectEqualStrings(c.out, al.items);
+    }
+}
+
+test "flate.Inflate fuzzing tests" {
+    const cases = [_]struct {
+        input: []const u8,
+        out: []const u8 = "",
+        err: ?anyerror = null,
+    }{
+        .{ .input = "deflate-stream", .out = @embedFile("testdata/fuzz/deflate-stream.expect") }, // 0
+        .{ .input = "empty-distance-alphabet01" },
+        .{ .input = "empty-distance-alphabet02" },
+        .{ .input = "end-of-stream", .err = error.EndOfStream },
+        .{ .input = "invalid-distance", .err = error.InvalidMatch },
+        .{ .input = "invalid-tree01", .err = error.IncompleteHuffmanTree }, // 5
+        .{ .input = "invalid-tree02", .err = error.IncompleteHuffmanTree },
+        .{ .input = "invalid-tree03", .err = error.IncompleteHuffmanTree },
+        .{ .input = "lengths-overflow", .err = error.InvalidDynamicBlockHeader },
+        .{ .input = "out-of-codes", .err = error.InvalidCode },
+        .{ .input = "puff01", .err = error.WrongStoredBlockNlen }, // 10
+        .{ .input = "puff02", .err = error.EndOfStream },
+        .{ .input = "puff03", .out = &[_]u8{0xa} },
+        .{ .input = "puff04", .err = error.InvalidCode },
+        .{ .input = "puff05", .err = error.EndOfStream },
+        .{ .input = "puff06", .err = error.EndOfStream },
+        .{ .input = "puff08", .err = error.InvalidCode },
+        .{ .input = "puff09", .out = "P" },
+        .{ .input = "puff10", .err = error.InvalidCode },
+        .{ .input = "puff11", .err = error.InvalidMatch },
+        .{ .input = "puff12", .err = error.InvalidDynamicBlockHeader }, // 20
+        .{ .input = "puff13", .err = error.IncompleteHuffmanTree },
+        .{ .input = "puff14", .err = error.EndOfStream },
+        .{ .input = "puff15", .err = error.IncompleteHuffmanTree },
+        .{ .input = "puff16", .err = error.InvalidDynamicBlockHeader },
+        .{ .input = "puff17", .err = error.InvalidDynamicBlockHeader }, // 25
+        .{ .input = "fuzz1", .err = error.InvalidDynamicBlockHeader },
+        .{ .input = "fuzz2", .err = error.InvalidDynamicBlockHeader },
+        .{ .input = "fuzz3", .err = error.InvalidMatch },
+        .{ .input = "fuzz4", .err = error.OversubscribedHuffmanTree },
+        .{ .input = "puff18", .err = error.OversubscribedHuffmanTree }, // 30
+        .{ .input = "puff19", .err = error.OversubscribedHuffmanTree },
+        .{ .input = "puff20", .err = error.OversubscribedHuffmanTree },
+        .{ .input = "puff21", .err = error.OversubscribedHuffmanTree },
+        .{ .input = "puff22", .err = error.OversubscribedHuffmanTree },
+        .{ .input = "puff23", .err = error.InvalidDynamicBlockHeader }, // 35
+        .{ .input = "puff24", .err = error.InvalidDynamicBlockHeader },
+        .{ .input = "puff25", .err = error.OversubscribedHuffmanTree },
+        .{ .input = "puff26", .err = error.InvalidDynamicBlockHeader },
+        .{ .input = "puff27", .err = error.InvalidDynamicBlockHeader },
+    };
+
+    inline for (cases, 0..) |c, case_no| {
+        var in = std.io.fixedBufferStream(@embedFile("testdata/fuzz/" ++ c.input ++ ".input"));
+        var out = std.ArrayList(u8).init(testing.allocator);
+        defer out.deinit();
+        errdefer std.debug.print("test case failed {}\n", .{case_no});
+
+        if (c.err) |expected_err| {
+            try testing.expectError(expected_err, decompress(.raw, in.reader(), out.writer()));
+        } else {
+            try decompress(.raw, in.reader(), out.writer());
+            try testing.expectEqualStrings(c.out, out.items);
+        }
+    }
+}
diff --git a/lib/std/compress/flate/root.zig b/lib/std/compress/flate/root.zig
new file mode 100644
index 0000000000..da385b21b0
--- /dev/null
+++ b/lib/std/compress/flate/root.zig
@@ -0,0 +1,133 @@
+pub const flate = @import("flate.zig");
+pub const gzip = @import("gzip.zig");
+pub const zlib = @import("zlib.zig");
+
+test "flate" {
+    _ = @import("deflate.zig");
+    _ = @import("inflate.zig");
+}
+
+test "flate public interface" {
+    const plain_data = [_]u8{ 'H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', 0x0a };
+
+    // deflate final stored block, header + plain (stored) data
+    const deflate_block = [_]u8{
+        0b0000_0001, 0b0000_1100, 0x00, 0b1111_0011, 0xff, // deflate fixed buffer header len, nlen
+    } ++ plain_data;
+
+    // gzip header/footer + deflate block
+    const gzip_data =
+        [_]u8{ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03 } ++ // gzip header (10 bytes)
+        deflate_block ++
+        [_]u8{ 0xd5, 0xe0, 0x39, 0xb7, 0x0c, 0x00, 0x00, 0x00 }; // gzip footer checksum (4 byte), size (4 bytes)
+
+    // zlib header/footer + deflate block
+    const zlib_data = [_]u8{ 0x78, 0b10_0_11100 } ++ // zlib header (2 bytes)}
+        deflate_block ++
+        [_]u8{ 0x1c, 0xf2, 0x04, 0x47 }; // zlib footer: checksum
+
+    try testInterface(gzip, &gzip_data, &plain_data);
+    try testInterface(zlib, &zlib_data, &plain_data);
+    try testInterface(flate, &deflate_block, &plain_data);
+}
+
+fn testInterface(comptime pkg: type, gzip_data: []const u8, plain_data: []const u8) !void {
+    const std = @import("std");
+    const testing = std.testing;
+    const fixedBufferStream = std.io.fixedBufferStream;
+
+    var buffer1: [64]u8 = undefined;
+    var buffer2: [64]u8 = undefined;
+
+    var compressed = fixedBufferStream(&buffer1);
+    var plain = fixedBufferStream(&buffer2);
+
+    // decompress
+    {
+        var in = fixedBufferStream(gzip_data);
+        try pkg.decompress(in.reader(), plain.writer());
+        try testing.expectEqualSlices(u8, plain_data, plain.getWritten());
+    }
+    plain.reset();
+    compressed.reset();
+
+    // compress/decompress
+    {
+        var in = fixedBufferStream(plain_data);
+        try pkg.compress(in.reader(), compressed.writer(), .{});
+        compressed.reset();
+        try pkg.decompress(compressed.reader(), plain.writer());
+        try testing.expectEqualSlices(u8, plain_data, plain.getWritten());
+    }
+    plain.reset();
+    compressed.reset();
+
+    // compressor/decompressor
+    {
+        var in = fixedBufferStream(plain_data);
+        var cmp = try pkg.compressor(compressed.writer(), .{});
+        try cmp.compress(in.reader());
+        try cmp.finish();
+
+        compressed.reset();
+        var dcp = pkg.decompressor(compressed.reader());
+        try dcp.decompress(plain.writer());
+        try testing.expectEqualSlices(u8, plain_data, plain.getWritten());
+    }
+    plain.reset();
+    compressed.reset();
+
+    // huffman
+    {
+        // huffman compress/decompress
+        {
+            var in = fixedBufferStream(plain_data);
+            try pkg.huffman.compress(in.reader(), compressed.writer());
+            compressed.reset();
+            try pkg.decompress(compressed.reader(), plain.writer());
+            try testing.expectEqualSlices(u8, plain_data, plain.getWritten());
+        }
+        plain.reset();
+        compressed.reset();
+
+        // huffman compressor/decompressor
+        {
+            var in = fixedBufferStream(plain_data);
+            var cmp = try pkg.huffman.compressor(compressed.writer());
+            try cmp.compress(in.reader());
+            try cmp.finish();
+
+            compressed.reset();
+            try pkg.decompress(compressed.reader(), plain.writer());
+            try testing.expectEqualSlices(u8, plain_data, plain.getWritten());
+        }
+    }
+    plain.reset();
+    compressed.reset();
+
+    // store
+    {
+        // store compress/decompress
+        {
+            var in = fixedBufferStream(plain_data);
+            try pkg.store.compress(in.reader(), compressed.writer());
+            compressed.reset();
+            try pkg.decompress(compressed.reader(), plain.writer());
+            try testing.expectEqualSlices(u8, plain_data, plain.getWritten());
+        }
+        plain.reset();
+        compressed.reset();
+
+        // store compressor/decompressor
+        {
+            var in = fixedBufferStream(plain_data);
+            var cmp = try pkg.store.compressor(compressed.writer());
+            try cmp.compress(in.reader());
+            try cmp.finish();
+
+            compressed.reset();
+            try pkg.decompress(compressed.reader(), plain.writer());
+            try testing.expectEqualSlices(u8, plain_data, plain.getWritten());
+        }
+    }
+}
diff --git a/lib/std/compress/flate/testdata/block_writer.zig b/lib/std/compress/flate/testdata/block_writer.zig
new file mode 100644
index 0000000000..cb8f3028d1
--- /dev/null
+++ b/lib/std/compress/flate/testdata/block_writer.zig
@@ -0,0 +1,606 @@
+const Token = @import("../Token.zig");
+
+pub const TestCase = struct {
+    tokens: []const Token,
+    input: []const u8 = "", // File name of input data matching the tokens.
+    want: []const u8 = "", // File name of data with the expected output with input available.
+    want_no_input: []const u8 = "", // File name of the expected output when no input is available.
+};
+
+pub const testCases = blk: {
+    @setEvalBranchQuota(4096 * 2);
+
+    const L = Token.initLiteral;
+    const M = Token.initMatch;
+    const ml = M(1, 258); // Maximum length token. Used to reduce the size of writeBlockTests
+
+    break :blk &[_]TestCase{
+        TestCase{
+            .input = "huffman-null-max.input",
+            .want = "huffman-null-max.{s}.expect",
+            .want_no_input = "huffman-null-max.{s}.expect-noinput",
+            .tokens = &[_]Token{
+                L(0x0), ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,     ml,     ml, ml, ml,
+                ml,     ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,     ml,     ml, ml, ml,
+                ml,     ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,     ml,     ml, ml, ml,
+                ml,     ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,     ml,     ml, ml, ml,
+                ml,     ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,     ml,     ml, ml, ml,
+                ml,     ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,     ml,     ml, ml, ml,
+                ml,     ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,     ml,     ml, ml, ml,
+                ml,     ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,     ml,     ml, ml, ml,
+                ml,     ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,     ml,     ml, ml, ml,
+                ml,     ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,     ml,     ml, ml, ml,
+                ml,     ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,     ml,     ml, ml, ml,
+                ml,     ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,     ml,     ml, ml, ml,
+                ml,     ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, L(0x0), L(0x0),
+            },
+        },
+        TestCase{
+            .input = "huffman-pi.input",
+            .want = "huffman-pi.{s}.expect",
+            .want_no_input = "huffman-pi.{s}.expect-noinput",
+            .tokens = &[_]Token{
+                L('3'),     L('.'),     L('1'),     L('4'),     L('1'),     L('5'),     L('9'),     L('2'),
+                L('6'),     L('5'),     L('3'),     L('5'),     L('8'),     L('9'),     L('7'),     L('9'),
+                L('3'),     L('2'),     L('3'),     L('8'),     L('4'),     L('6'),     L('2'),     L('6'),
+                L('4'),     L('3'),     L('3'),     L('8'),     L('3'),     L('2'),     L('7'),     L('9'),
+                L('5'),     L('0'),     L('2'),     L('8'),     L('8'),     L('4'),     L('1'),     L('9'),
+                L('7'),     L('1'),     L('6'),     L('9'),     L('3'),     L('9'),     L('9'),     L('3'),
+                L('7'),     L('5'),     L('1'),     L('0'),     L('5'),     L('8'),     L('2'),     L('0'),
+                L('9'),     L('7'),     L('4'),     L('9'),     L('4'),     L('4'),     L('5'),     L('9'),
+                L('2'),     L('3'),     L('0'),     L('7'),     L('8'),     L('1'),     L('6'),     L('4'),
+                L('0'),     L('6'),     L('2'),     L('8'),     L('6'),     L('2'),     L('0'),     L('8'),
+                L('9'),     L('9'),     L('8'),     L('6'),     L('2'),     L('8'),     L('0'),     L('3'),
+                L('4'),     L('8'),     L('2'),     L('5'),     L('3'),     L('4'),     L('2'),     L('1'),
+                L('1'),     L('7'),     L('0'),     L('6'),     L('7'),     L('9'),     L('8'),     L('2'),
+                L('1'),     L('4'),     L('8'),     L('0'),     L('8'),     L('6'),     L('5'),     L('1'),
+                L('3'),     L('2'),     L('8'),     L('2'),     L('3'),     L('0'),     L('6'),     L('6'),
+                L('4'),     L('7'),     L('0'),     L('9'),     L('3'),     L('8'),     L('4'),     L('4'),
+                L('6'),     L('0'),     L('9'),     L('5'),     L('5'),     L('0'),     L('5'),     L('8'),
+                L('2'),     L('2'),     L('3'),     L('1'),     L('7'),     L('2'),     L('5'),     L('3'),
+                L('5'),     L('9'),     L('4'),     L('0'),     L('8'),     L('1'),     L('2'),     L('8'),
+                L('4'),     L('8'),     L('1'),     L('1'),     L('1'),     L('7'),     L('4'),     M(127, 4),
+                L('4'),     L('1'),     L('0'),     L('2'),     L('7'),     L('0'),     L('1'),     L('9'),
+                L('3'),     L('8'),     L('5'),     L('2'),     L('1'),     L('1'),     L('0'),     L('5'),
+                L('5'),     L('5'),     L('9'),     L('6'),     L('4'),     L('4'),     L('6'),     L('2'),
+                L('2'),     L('9'),     L('4'),     L('8'),     L('9'),     L('5'),     L('4'),     L('9'),
+                L('3'),     L('0'),     L('3'),     L('8'),     L('1'),     M(19, 4),   L('2'),     L('8'),
+                L('8'),     L('1'),     L('0'),     L('9'),     L('7'),     L('5'),     L('6'),     L('6'),
+                L('5'),     L('9'),     L('3'),     L('3'),     L('4'),     L('4'),     L('6'),     M(72, 4),
+                L('7'),     L('5'),     L('6'),     L('4'),     L('8'),     L('2'),     L('3'),     L('3'),
+                L('7'),     L('8'),     L('6'),     L('7'),     L('8'),     L('3'),     L('1'),     L('6'),
+                L('5'),     L('2'),     L('7'),     L('1'),     L('2'),     L('0'),     L('1'),     L('9'),
+                L('0'),     L('9'),     L('1'),     L('4'),     M(27, 4),   L('5'),     L('6'),     L('6'),
+                L('9'),     L('2'),     L('3'),     L('4'),     L('6'),     M(179, 4),  L('6'),     L('1'),
+                L('0'),     L('4'),     L('5'),     L('4'),     L('3'),     L('2'),     L('6'),     M(51, 4),
+                L('1'),     L('3'),     L('3'),     L('9'),     L('3'),     L('6'),     L('0'),     L('7'),
+                L('2'),     L('6'),     L('0'),     L('2'),     L('4'),     L('9'),     L('1'),     L('4'),
+                L('1'),     L('2'),     L('7'),     L('3'),     L('7'),     L('2'),     L('4'),     L('5'),
+                L('8'),     L('7'),     L('0'),     L('0'),     L('6'),     L('6'),     L('0'),     L('6'),
+                L('3'),     L('1'),     L('5'),     L('5'),     L('8'),     L('8'),     L('1'),     L('7'),
+                L('4'),     L('8'),     L('8'),     L('1'),     L('5'),     L('2'),     L('0'),     L('9'),
+                L('2'),     L('0'),     L('9'),     L('6'),     L('2'),     L('8'),     L('2'),     L('9'),
+                L('2'),     L('5'),     L('4'),     L('0'),     L('9'),     L('1'),     L('7'),     L('1'),
+                L('5'),     L('3'),     L('6'),     L('4'),     L('3'),     L('6'),     L('7'),     L('8'),
+                L('9'),     L('2'),     L('5'),     L('9'),     L('0'),     L('3'),     L('6'),     L('0'),
+                L('0'),     L('1'),     L('1'),     L('3'),     L('3'),     L('0'),     L('5'),     L('3'),
+                L('0'),     L('5'),     L('4'),     L('8'),     L('8'),     L('2'),     L('0'),     L('4'),
+                L('6'),     L('6'),     L('5'),     L('2'),     L('1'),     L('3'),     L('8'),     L('4'),
+                L('1'),     L('4'),     L('6'),     L('9'),     L('5'),     L('1'),     L('9'),     L('4'),
+                L('1'),     L('5'),     L('1'),     L('1'),     L('6'),     L('0'),     L('9'),     L('4'),
+                L('3'),     L('3'),     L('0'),     L('5'),     L('7'),     L('2'),     L('7'),     L('0'),
+                L('3'),     L('6'),     L('5'),     L('7'),     L('5'),     L('9'),     L('5'),     L('9'),
+                L('1'),     L('9'),     L('5'),     L('3'),     L('0'),     L('9'),     L('2'),     L('1'),
+                L('8'),     L('6'),     L('1'),     L('1'),     L('7'),     M(234, 4),  L('3'),     L('2'),
+                M(10, 4),   L('9'),     L('3'),     L('1'),     L('0'),     L('5'),     L('1'),     L('1'),
+                L('8'),     L('5'),     L('4'),     L('8'),     L('0'),     L('7'),     M(271, 4),  L('3'),
+                L('7'),     L('9'),     L('9'),     L('6'),     L('2'),     L('7'),     L('4'),     L('9'),
+                L('5'),     L('6'),     L('7'),     L('3'),     L('5'),     L('1'),     L('8'),     L('8'),
+                L('5'),     L('7'),     L('5'),     L('2'),     L('7'),     L('2'),     L('4'),     L('8'),
+                L('9'),     L('1'),     L('2'),     L('2'),     L('7'),     L('9'),     L('3'),     L('8'),
+                L('1'),     L('8'),     L('3'),     L('0'),     L('1'),     L('1'),     L('9'),     L('4'),
+                L('9'),     L('1'),     L('2'),     L('9'),     L('8'),     L('3'),     L('3'),     L('6'),
+                L('7'),     L('3'),     L('3'),     L('6'),     L('2'),     L('4'),     L('4'),     L('0'),
+                L('6'),     L('5'),     L('6'),     L('6'),     L('4'),     L('3'),     L('0'),     L('8'),
+                L('6'),     L('0'),     L('2'),     L('1'),     L('3'),     L('9'),     L('4'),     L('9'),
+                L('4'),     L('6'),     L('3'),     L('9'),     L('5'),     L('2'),     L('2'),     L('4'),
+                L('7'),     L('3'),     L('7'),     L('1'),     L('9'),     L('0'),     L('7'),     L('0'),
+                L('2'),     L('1'),     L('7'),     L('9'),     L('8'),     M(154, 5),  L('7'),     L('0'),
+                L('2'),     L('7'),     L('7'),     L('0'),     L('5'),     L('3'),     L('9'),     L('2'),
+                L('1'),     L('7'),     L('1'),     L('7'),     L('6'),     L('2'),     L('9'),     L('3'),
+                L('1'),     L('7'),     L('6'),     L('7'),     L('5'),     M(563, 5),  L('7'),     L('4'),
+                L('8'),     L('1'),     M(7, 4),    L('6'),     L('6'),     L('9'),     L('4'),     L('0'),
+                M(488, 4),  L('0'),     L('0'),     L('0'),     L('5'),     L('6'),     L('8'),     L('1'),
+                L('2'),     L('7'),     L('1'),     L('4'),     L('5'),     L('2'),     L('6'),     L('3'),
+                L('5'),     L('6'),     L('0'),     L('8'),     L('2'),     L('7'),     L('7'),     L('8'),
+                L('5'),     L('7'),     L('7'),     L('1'),     L('3'),     L('4'),     L('2'),     L('7'),
+                L('5'),     L('7'),     L('7'),     L('8'),     L('9'),     L('6'),     M(298, 4),  L('3'),
+                L('6'),     L('3'),     L('7'),     L('1'),     L('7'),     L('8'),     L('7'),     L('2'),
+                L('1'),     L('4'),     L('6'),     L('8'),     L('4'),     L('4'),     L('0'),     L('9'),
+                L('0'),     L('1'),     L('2'),     L('2'),     L('4'),     L('9'),     L('5'),     L('3'),
+                L('4'),     L('3'),     L('0'),     L('1'),     L('4'),     L('6'),     L('5'),     L('4'),
+                L('9'),     L('5'),     L('8'),     L('5'),     L('3'),     L('7'),     L('1'),     L('0'),
+                L('5'),     L('0'),     L('7'),     L('9'),     M(203, 4),  L('6'),     M(340, 4),  L('8'),
+                L('9'),     L('2'),     L('3'),     L('5'),     L('4'),     M(458, 4),  L('9'),     L('5'),
+                L('6'),     L('1'),     L('1'),     L('2'),     L('1'),     L('2'),     L('9'),     L('0'),
+                L('2'),     L('1'),     L('9'),     L('6'),     L('0'),     L('8'),     L('6'),     L('4'),
+                L('0'),     L('3'),     L('4'),     L('4'),     L('1'),     L('8'),     L('1'),     L('5'),
+                L('9'),     L('8'),     L('1'),     L('3'),     L('6'),     L('2'),     L('9'),     L('7'),
+                L('7'),     L('4'),     M(117, 4),  L('0'),     L('9'),     L('9'),     L('6'),     L('0'),
+                L('5'),     L('1'),     L('8'),     L('7'),     L('0'),     L('7'),     L('2'),     L('1'),
+                L('1'),     L('3'),     L('4'),     L('9'),     M(1, 5),    L('8'),     L('3'),     L('7'),
+                L('2'),     L('9'),     L('7'),     L('8'),     L('0'),     L('4'),     L('9'),     L('9'),
+                M(731, 4),  L('9'),     L('7'),     L('3'),     L('1'),     L('7'),     L('3'),     L('2'),
+                L('8'),     M(395, 4),  L('6'),     L('3'),     L('1'),     L('8'),     L('5'),     M(770, 4),
+                M(745, 4),  L('4'),     L('5'),     L('5'),     L('3'),     L('4'),     L('6'),     L('9'),
+                L('0'),     L('8'),     L('3'),     L('0'),     L('2'),     L('6'),     L('4'),     L('2'),
+                L('5'),     L('2'),     L('2'),     L('3'),     L('0'),     M(740, 4),  M(616, 4),  L('8'),
+                L('5'),     L('0'),     L('3'),     L('5'),     L('2'),     L('6'),     L('1'),     L('9'),
+                L('3'),     L('1'),     L('1'),     M(531, 4),  L('1'),     L('0'),     L('1'),     L('0'),
+                L('0'),     L('0'),     L('3'),     L('1'),     L('3'),     L('7'),     L('8'),     L('3'),
+                L('8'),     L('7'),     L('5'),     L('2'),     L('8'),     L('8'),     L('6'),     L('5'),
+                L('8'),     L('7'),     L('5'),     L('3'),     L('3'),     L('2'),     L('0'),     L('8'),
+                L('3'),     L('8'),     L('1'),     L('4'),     L('2'),     L('0'),     L('6'),     M(321, 4),
+                M(300, 4),  L('1'),     L('4'),     L('7'),     L('3'),     L('0'),     L('3'),     L('5'),
+                L('9'),     M(815, 5),  L('9'),     L('0'),     L('4'),     L('2'),     L('8'),     L('7'),
+                L('5'),     L('5'),     L('4'),     L('6'),     L('8'),     L('7'),     L('3'),     L('1'),
+                L('1'),     L('5'),     L('9'),     L('5'),     M(854, 4),  L('3'),     L('8'),     L('8'),
+                L('2'),     L('3'),     L('5'),     L('3'),     L('7'),     L('8'),     L('7'),     L('5'),
+                M(896, 5),  L('9'),     M(315, 4),  L('1'),     M(329, 4),  L('8'),     L('0'),     L('5'),
+                L('3'),     M(395, 4),  L('2'),     L('2'),     L('6'),     L('8'),     L('0'),     L('6'),
+                L('6'),     L('1'),     L('3'),     L('0'),     L('0'),     L('1'),     L('9'),     L('2'),
+                L('7'),     L('8'),     L('7'),     L('6'),     L('6'),     L('1'),     L('1'),     L('1'),
+                L('9'),     L('5'),     L('9'),     M(568, 4),  L('6'),     M(293, 5),  L('8'),     L('9'),
+                L('3'),     L('8'),     L('0'),     L('9'),     L('5'),     L('2'),     L('5'),     L('7'),
+                L('2'),     L('0'),     L('1'),     L('0'),     L('6'),     L('5'),     L('4'),     L('8'),
+                L('5'),     L('8'),     L('6'),     L('3'),     L('2'),     L('7'),     M(155, 4),  L('9'),
+                L('3'),     L('6'),     L('1'),     L('5'),     L('3'),     M(545, 4),  M(349, 5),  L('2'),
+                L('3'),     L('0'),     L('3'),     L('0'),     L('1'),     L('9'),     L('5'),     L('2'),
+                L('0'),     L('3'),     L('5'),     L('3'),     L('0'),     L('1'),     L('8'),     L('5'),
+                L('2'),     M(370, 4),  M(118, 4),  L('3'),     L('6'),     L('2'),     L('2'),     L('5'),
+                L('9'),     L('9'),     L('4'),     L('1'),     L('3'),     M(597, 4),  L('4'),     L('9'),
+                L('7'),     L('2'),     L('1'),     L('7'),     M(223, 4),  L('3'),     L('4'),     L('7'),
+                L('9'),     L('1'),     L('3'),     L('1'),     L('5'),     L('1'),     L('5'),     L('5'),
+                L('7'),     L('4'),     L('8'),     L('5'),     L('7'),     L('2'),     L('4'),     L('2'),
+                L('4'),     L('5'),     L('4'),     L('1'),     L('5'),     L('0'),     L('6'),     L('9'),
+                M(320, 4),  L('8'),     L('2'),     L('9'),     L('5'),     L('3'),     L('3'),     L('1'),
+                L('1'),     L('6'),     L('8'),     L('6'),     L('1'),     L('7'),     L('2'),     L('7'),
+                L('8'),     M(824, 4),  L('9'),     L('0'),     L('7'),     L('5'),     L('0'),     L('9'),
+                M(270, 4),  L('7'),     L('5'),     L('4'),     L('6'),     L('3'),     L('7'),     L('4'),
+                L('6'),     L('4'),     L('9'),     L('3'),     L('9'),     L('3'),     L('1'),     L('9'),
+                L('2'),     L('5'),     L('5'),     L('0'),     L('6'),     L('0'),     L('4'),     L('0'),
+                L('0'),     L('9'),     M(620, 4),  L('1'),     L('6'),     L('7'),     L('1'),     L('1'),
+                L('3'),     L('9'),     L('0'),     L('0'),     L('9'),     L('8'),     M(822, 4),  L('4'),
+                L('0'),     L('1'),     L('2'),     L('8'),     L('5'),     L('8'),     L('3'),     L('6'),
+                L('1'),     L('6'),     L('0'),     L('3'),     L('5'),     L('6'),     L('3'),     L('7'),
+                L('0'),     L('7'),     L('6'),     L('6'),     L('0'),     L('1'),     L('0'),     L('4'),
+                M(371, 4),  L('8'),     L('1'),     L('9'),     L('4'),     L('2'),     L('9'),     M(1055, 5),
+                M(240, 4),  M(652, 4),  L('7'),     L('8'),     L('3'),     L('7'),     L('4'),     M(1193, 4),
+                L('8'),     L('2'),     L('5'),     L('5'),     L('3'),     L('7'),     M(522, 5),  L('2'),
+                L('6'),     L('8'),     M(47, 4),   L('4'),     L('0'),     L('4'),     L('7'),     M(466, 4),
+                L('4'),     M(1206, 4), M(910, 4),  L('8'),     L('4'),     M(937, 4),  L('6'),     M(800, 6),
+                L('3'),     L('3'),     L('1'),     L('3'),     L('6'),     L('7'),     L('7'),     L('0'),
+                L('2'),     L('8'),     L('9'),     L('8'),     L('9'),     L('1'),     L('5'),     L('2'),
+                M(99, 4),   L('5'),     L('2'),     L('1'),     L('6'),     L('2'),     L('0'),     L('5'),
+                L('6'),     L('9'),     L('6'),     M(1042, 4), L('0'),     L('5'),     L('8'),     M(1144, 4),
+                L('5'),     M(1177, 4), L('5'),     L('1'),     L('1'),     M(522, 4),  L('8'),     L('2'),
+                L('4'),     L('3'),     L('0'),     L('0'),     L('3'),     L('5'),     L('5'),     L('8'),
+                L('7'),     L('6'),     L('4'),     L('0'),     L('2'),     L('4'),     L('7'),     L('4'),
+                L('9'),     L('6'),     L('4'),     L('7'),     L('3'),     L('2'),     L('6'),     L('3'),
+                M(1087, 4), L('9'),     L('9'),     L('2'),     M(1100, 4), L('4'),     L('2'),     L('6'),
+                L('9'),     M(710, 6),  L('7'),     M(471, 4),  L('4'),     M(1342, 4), M(1054, 4), L('9'),
+                L('3'),     L('4'),     L('1'),     L('7'),     M(430, 4),  L('1'),     L('2'),     M(43, 4),
+                L('4'),     M(415, 4),  L('1'),     L('5'),     L('0'),     L('3'),     L('0'),     L('2'),
+                L('8'),     L('6'),     L('1'),     L('8'),     L('2'),     L('9'),     L('7'),     L('4'),
+                L('5'),     L('5'),     L('5'),     L('7'),     L('0'),     L('6'),     L('7'),     L('4'),
+                M(310, 4),  L('5'),     L('0'),     L('5'),     L('4'),     L('9'),     L('4'),     L('5'),
+                L('8'),     M(454, 4),  L('9'),     M(82, 4),   L('5'),     L('6'),     M(493, 4),  L('7'),
+                L('2'),     L('1'),     L('0'),     L('7'),     L('9'),     M(346, 4),  L('3'),     L('0'),
+                M(267, 4),  L('3'),     L('2'),     L('1'),     L('1'),     L('6'),     L('5'),     L('3'),
+                L('4'),     L('4'),     L('9'),     L('8'),     L('7'),     L('2'),     L('0'),     L('2'),
+                L('7'),     M(284, 4),  L('0'),     L('2'),     L('3'),     L('6'),     L('4'),     M(559, 4),
+                L('5'),     L('4'),     L('9'),     L('9'),     L('1'),     L('1'),     L('9'),     L('8'),
+                M(1049, 4), L('4'),     M(284, 4),  L('5'),     L('3'),     L('5'),     L('6'),     L('6'),
+                L('3'),     L('6'),     L('9'),     M(1105, 4), L('2'),     L('6'),     L('5'),     M(741, 4),
+                L('7'),     L('8'),     L('6'),     L('2'),     L('5'),     L('5'),     L('1'),     M(987, 4),
+                L('1'),     L('7'),     L('5'),     L('7'),     L('4'),     L('6'),     L('7'),     L('2'),
+                L('8'),     L('9'),     L('0'),     L('9'),     L('7'),     L('7'),     L('7'),     L('7'),
+                M(1108, 5), L('0'),     L('0'),     L('0'),     M(1534, 4), L('7'),     L('0'),     M(1248, 4),
+                L('6'),     M(1002, 4), L('4'),     L('9'),     L('1'),     M(1055, 4), M(664, 4),  L('2'),
+                L('1'),     L('4'),     L('7'),     L('7'),     L('2'),     L('3'),     L('5'),     L('0'),
+                L('1'),     L('4'),     L('1'),     L('4'),     M(1604, 4), L('3'),     L('5'),     L('6'),
+                M(1200, 4), L('1'),     L('6'),     L('1'),     L('3'),     L('6'),     L('1'),     L('1'),
+                L('5'),     L('7'),     L('3'),     L('5'),     L('2'),     L('5'),     M(1285, 4), L('3'),
+                L('4'),     M(92, 4),   L('1'),     L('8'),     M(1148, 4), L('8'),     L('4'),     M(1512, 4),
+                L('3'),     L('3'),     L('2'),     L('3'),     L('9'),     L('0'),     L('7'),     L('3'),
+                L('9'),     L('4'),     L('1'),     L('4'),     L('3'),     L('3'),     L('3'),     L('4'),
+                L('5'),     L('4'),     L('7'),     L('7'),     L('6'),     L('2'),     L('4'),     M(579, 4),
+                L('2'),     L('5'),     L('1'),     L('8'),     L('9'),     L('8'),     L('3'),     L('5'),
+                L('6'),     L('9'),     L('4'),     L('8'),     L('5'),     L('5'),     L('6'),     L('2'),
+                L('0'),     L('9'),     L('9'),     L('2'),     L('1'),     L('9'),     L('2'),     L('2'),
+                L('2'),     L('1'),     L('8'),     L('4'),     L('2'),     L('7'),     M(575, 4),  L('2'),
+                M(187, 4),  L('6'),     L('8'),     L('8'),     L('7'),     L('6'),     L('7'),     L('1'),
+                L('7'),     L('9'),     L('0'),     M(86, 4),   L('0'),     M(263, 5),  L('6'),     L('6'),
+                M(1000, 4), L('8'),     L('8'),     L('6'),     L('2'),     L('7'),     L('2'),     M(1757, 4),
+                L('1'),     L('7'),     L('8'),     L('6'),     L('0'),     L('8'),     L('5'),     L('7'),
+                M(116, 4),  L('3'),     M(765, 5),  L('7'),     L('9'),     L('7'),     L('6'),     L('6'),
+                L('8'),     L('1'),     M(702, 4),  L('0'),     L('0'),     L('9'),     L('5'),     L('3'),
+                L('8'),     L('8'),     M(1593, 4), L('3'),     M(1702, 4), L('0'),     L('6'),     L('8'),
+                L('0'),     L('0'),     L('6'),     L('4'),     L('2'),     L('2'),     L('5'),     L('1'),
+                L('2'),     L('5'),     L('2'),     M(1404, 4), L('7'),     L('3'),     L('9'),     L('2'),
+                M(664, 4),  M(1141, 4), L('4'),     M(1716, 5), L('8'),     L('6'),     L('2'),     L('6'),
+                L('9'),     L('4'),     L('5'),     M(486, 4),  L('4'),     L('1'),     L('9'),     L('6'),
+                L('5'),     L('2'),     L('8'),     L('5'),     L('0'),     M(154, 4),  M(925, 4),  L('1'),
+                L('8'),     L('6'),     L('3'),     M(447, 4),  L('4'),     M(341, 5),  L('2'),     L('0'),
+                L('3'),     L('9'),     M(1420, 4), L('4'),     L('5'),     M(701, 4),  L('2'),     L('3'),
+                L('7'),     M(1069, 4), L('6'),     M(1297, 4), L('5'),     L('6'),     M(1593, 4), L('7'),
+                L('1'),     L('9'),     L('1'),     L('7'),     L('2'),     L('8'),     M(370, 4),  L('7'),
+                L('6'),     L('4'),     L('6'),     L('5'),     L('7'),     L('5'),     L('7'),     L('3'),
+                L('9'),     M(258, 4),  L('3'),     L('8'),     L('9'),     M(1865, 4), L('8'),     L('3'),
+                L('2'),     L('6'),     L('4'),     L('5'),     L('9'),     L('9'),     L('5'),     L('8'),
+                M(1704, 4), L('0'),     L('4'),     L('7'),     L('8'),     M(479, 4),  M(809, 4),  L('9'),
+                M(46, 4),   L('6'),     L('4'),     L('0'),     L('7'),     L('8'),     L('9'),     L('5'),
+                L('1'),     M(143, 4),  L('6'),     L('8'),     L('3'),     M(304, 4),  L('2'),     L('5'),
+                L('9'),     L('5'),     L('7'),     L('0'),     M(1129, 4), L('8'),     L('2'),     L('2'),
+                M(713, 4),  L('2'),     M(1564, 4), L('4'),     L('0'),     L('7'),     L('7'),     L('2'),
+                L('6'),     L('7'),     L('1'),     L('9'),     L('4'),     L('7'),     L('8'),     M(794, 4),
+                L('8'),     L('2'),     L('6'),     L('0'),     L('1'),     L('4'),     L('7'),     L('6'),
+                L('9'),     L('9'),     L('0'),     L('9'),     M(1257, 4), L('0'),     L('1'),     L('3'),
+                L('6'),     L('3'),     L('9'),     L('4'),     L('4'),     L('3'),     M(640, 4),  L('3'),
+                L('0'),     M(262, 4),  L('2'),     L('0'),     L('3'),     L('4'),     L('9'),     L('6'),
+                L('2'),     L('5'),     L('2'),     L('4'),     L('5'),     L('1'),     L('7'),     M(950, 4),
+                L('9'),     L('6'),     L('5'),     L('1'),     L('4'),     L('3'),     L('1'),     L('4'),
+                L('2'),     L('9'),     L('8'),     L('0'),     L('9'),     L('1'),     L('9'),     L('0'),
+                L('6'),     L('5'),     L('9'),     L('2'),     M(643, 4),  L('7'),     L('2'),     L('2'),
+                L('1'),     L('6'),     L('9'),     L('6'),     L('4'),     L('6'),     M(1050, 4), M(123, 4),
+                L('5'),     M(1295, 4), L('4'),     M(1382, 5), L('8'),     M(1370, 4), L('9'),     L('7'),
+                M(1404, 4), L('5'),     L('4'),     M(1182, 4), M(575, 4),  L('7'),     M(1627, 4), L('8'),
+                L('4'),     L('6'),     L('8'),     L('1'),     L('3'),     M(141, 4),  L('6'),     L('8'),
+                L('3'),     L('8'),     L('6'),     L('8'),     L('9'),     L('4'),     L('2'),     L('7'),
+                L('7'),     L('4'),     L('1'),     L('5'),     L('5'),     L('9'),     L('9'),     L('1'),
+                L('8'),     L('5'),     M(91, 4),   L('2'),     L('4'),     L('5'),     L('9'),     L('5'),
+                L('3'),     L('9'),     L('5'),     L('9'),     L('4'),     L('3'),     L('1'),     M(1464, 4),
+                L('7'),     M(19, 4),   L('6'),     L('8'),     L('0'),     L('8'),     L('4'),     L('5'),
+                M(744, 4),  L('7'),     L('3'),     M(2079, 4), L('9'),     L('5'),     L('8'),     L('4'),
+                L('8'),     L('6'),     L('5'),     L('3'),     L('8'),     M(1769, 4), L('6'),     L('2'),
+                M(243, 4),  L('6'),     L('0'),     L('9'),     M(1207, 4), L('6'),     L('0'),     L('8'),
+                L('0'),     L('5'),     L('1'),     L('2'),     L('4'),     L('3'),     L('8'),     L('8'),
+                L('4'),     M(315, 4),  M(12, 4),   L('4'),     L('1'),     L('3'),     M(784, 4),  L('7'),
+                L('6'),     L('2'),     L('7'),     L('8'),     M(834, 4),  L('7'),     L('1'),     L('5'),
+                M(1436, 4), L('3'),     L('5'),     L('9'),     L('9'),     L('7'),     L('7'),     L('0'),
+                L('0'),     L('1'),     L('2'),     L('9'),     M(1139, 4), L('8'),     L('9'),     L('4'),
+                L('4'),     L('1'),     M(632, 4),  L('6'),     L('8'),     L('5'),     L('5'),     M(96, 4),
+                L('4'),     L('0'),     L('6'),     L('3'),     M(2279, 4), L('2'),     L('0'),     L('7'),
+                L('2'),     L('2'),     M(345, 4),  M(516, 5),  L('4'),     L('8'),     L('1'),     L('5'),
+                L('8'),     M(518, 4),  M(511, 4),  M(635, 4),  M(665, 4),  L('3'),     L('9'),     L('4'),
+                L('5'),     L('2'),     L('2'),     L('6'),     L('7'),     M(1175, 6), L('8'),     M(1419, 4),
+                L('2'),     L('1'),     M(747, 4),  L('2'),     M(904, 4),  L('5'),     L('4'),     L('6'),
+                L('6'),     L('6'),     M(1308, 4), L('2'),     L('3'),     L('9'),     L('8'),     L('6'),
+                L('4'),     L('5'),     L('6'),     M(1221, 4), L('1'),     L('6'),     L('3'),     L('5'),
+                M(596, 5),  M(2066, 4), L('7'),     M(2222, 4), L('9'),     L('8'),     M(1119, 4), L('9'),
+                L('3'),     L('6'),     L('3'),     L('4'),     M(1884, 4), L('7'),     L('4'),     L('3'),
+                L('2'),     L('4'),     M(1148, 4), L('1'),     L('5'),     L('0'),     L('7'),     L('6'),
+                M(1212, 4), L('7'),     L('9'),     L('4'),     L('5'),     L('1'),     L('0'),     L('9'),
+                M(63, 4),   L('0'),     L('9'),     L('4'),     L('0'),     M(1703, 4), L('8'),     L('8'),
+                L('7'),     L('9'),     L('7'),     L('1'),     L('0'),     L('8'),     L('9'),     L('3'),
+                M(2289, 4), L('6'),     L('9'),     L('1'),     L('3'),     L('6'),     L('8'),     L('6'),
+                L('7'),     L('2'),     M(604, 4),  M(511, 4),  L('5'),     M(1344, 4), M(1129, 4), M(2050, 4),
+                L('1'),     L('7'),     L('9'),     L('2'),     L('8'),     L('6'),     L('8'),     M(2253, 4),
+                L('8'),     L('7'),     L('4'),     L('7'),     M(1951, 5), L('8'),     L('2'),     L('4'),
+                M(2427, 4), L('8'),     M(604, 4),  L('7'),     L('1'),     L('4'),     L('9'),     L('0'),
+                L('9'),     L('6'),     L('7'),     L('5'),     L('9'),     L('8'),     M(1776, 4), L('3'),
+                L('6'),     L('5'),     M(309, 4),  L('8'),     L('1'),     M(93, 4),   M(1862, 4), M(2359, 4),
+                L('6'),     L('8'),     L('2'),     L('9'),     M(1407, 4), L('8'),     L('7'),     L('2'),
+                L('2'),     L('6'),     L('5'),     L('8'),     L('8'),     L('0'),     M(1554, 4), L('5'),
+                M(586, 4),  L('4'),     L('2'),     L('7'),     L('0'),     L('4'),     L('7'),     L('7'),
+                L('5'),     L('5'),     M(2079, 4), L('3'),     L('7'),     L('9'),     L('6'),     L('4'),
+                L('1'),     L('4'),     L('5'),     L('1'),     L('5'),     L('2'),     M(1534, 4), L('2'),
+                L('3'),     L('4'),     L('3'),     L('6'),     L('4'),     L('5'),     L('4'),     M(1503, 4),
+                L('4'),     L('4'),     L('4'),     L('7'),     L('9'),     L('5'),     M(61, 4),   M(1316, 4),
+                M(2279, 5), L('4'),     L('1'),     M(1323, 4), L('3'),     M(773, 4),  L('5'),     L('2'),
+                L('3'),     L('1'),     M(2114, 5), L('1'),     L('6'),     L('6'),     L('1'),     M(2227, 4),
+                L('5'),     L('9'),     L('6'),     L('9'),     L('5'),     L('3'),     L('6'),     L('2'),
+                L('3'),     L('1'),     L('4'),     M(1536, 4), L('2'),     L('4'),     L('8'),     L('4'),
+                L('9'),     L('3'),     L('7'),     L('1'),     L('8'),     L('7'),     L('1'),     L('1'),
+                L('0'),     L('1'),     L('4'),     L('5'),     L('7'),     L('6'),     L('5'),     L('4'),
+                M(1890, 4), L('0'),     L('2'),     L('7'),     L('9'),     L('9'),     L('3'),     L('4'),
+                L('4'),     L('0'),     L('3'),     L('7'),     L('4'),     L('2'),     L('0'),     L('0'),
+                L('7'),     M(2368, 4), L('7'),     L('8'),     L('5'),     L('3'),     L('9'),     L('0'),
+                L('6'),     L('2'),     L('1'),     L('9'),     M(666, 5),  M(838, 4),  L('8'),     L('4'),
+                L('7'),     M(979, 5),  L('8'),     L('3'),     L('3'),     L('2'),     L('1'),     L('4'),
+                L('4'),     L('5'),     L('7'),     L('1'),     M(645, 4),  M(1911, 4), L('4'),     L('3'),
+                L('5'),     L('0'),     M(2345, 4), M(1129, 4), L('5'),     L('3'),     L('1'),     L('9'),
+                L('1'),     L('0'),     L('4'),     L('8'),     L('4'),     L('8'),     L('1'),     L('0'),
+                L('0'),     L('5'),     L('3'),     L('7'),     L('0'),     L('6'),     M(2237, 4), M(1438, 5),
+                M(1922, 5), L('1'),     M(1370, 4), L('7'),     M(796, 4),  L('5'),     M(2029, 4), M(1037, 4),
+                L('6'),     L('3'),     M(2013, 5), L('4'),     M(2418, 4), M(847, 5),  M(1014, 5), L('8'),
+                M(1326, 5), M(2184, 5), L('9'),     M(392, 4),  L('9'),     L('1'),     M(2255, 4), L('8'),
+                L('1'),     L('4'),     L('6'),     L('7'),     L('5'),     L('1'),     M(1580, 4), L('1'),
+                L('2'),     L('3'),     L('9'),     M(426, 6),  L('9'),     L('0'),     L('7'),     L('1'),
+                L('8'),     L('6'),     L('4'),     L('9'),     L('4'),     L('2'),     L('3'),     L('1'),
+                L('9'),     L('6'),     L('1'),     L('5'),     L('6'),     M(493, 4),  M(1725, 4), L('9'),
+                L('5'),     M(2343, 4), M(1130, 4), M(284, 4),  L('6'),     L('0'),     L('3'),     L('8'),
+                M(2598, 4), M(368, 4),  M(901, 4),  L('6'),     L('2'),     M(1115, 4), L('5'),     M(2125, 4),
+                L('6'),     L('3'),     L('8'),     L('9'),     L('3'),     L('7'),     L('7'),     L('8'),
+                L('7'),     M(2246, 4), M(249, 4),  L('9'),     L('7'),     L('9'),     L('2'),     L('0'),
+                L('7'),     L('7'),     L('3'),     M(1496, 4), L('2'),     L('1'),     L('8'),     L('2'),
+                L('5'),     L('6'),     M(2016, 4), L('6'),     L('6'),     M(1751, 4), L('4'),     L('2'),
+                M(1663, 5), L('6'),     M(1767, 4), L('4'),     L('4'),     M(37, 4),   L('5'),     L('4'),
+                L('9'),     L('2'),     L('0'),     L('2'),     L('6'),     L('0'),     L('5'),     M(2740, 4),
+                M(997, 5),  L('2'),     L('0'),     L('1'),     L('4'),     L('9'),     M(1235, 4), L('8'),
+                L('5'),     L('0'),     L('7'),     L('3'),     M(1434, 4), L('6'),     L('6'),     L('6'),
+                L('0'),     M(405, 4),  L('2'),     L('4'),     L('3'),     L('4'),     L('0'),     M(136, 4),
+                L('0'),     M(1900, 4), L('8'),     L('6'),     L('3'),     M(2391, 4), M(2021, 4), M(1068, 4),
+                M(373, 4),  L('5'),     L('7'),     L('9'),     L('6'),     L('2'),     L('6'),     L('8'),
+                L('5'),     L('6'),     M(321, 4),  L('5'),     L('0'),     L('8'),     M(1316, 4), L('5'),
+                L('8'),     L('7'),     L('9'),     L('6'),     L('9'),     L('9'),     M(1810, 4), L('5'),
+                L('7'),     L('4'),     M(2585, 4), L('8'),     L('4'),     L('0'),     M(2228, 4), L('1'),
+                L('4'),     L('5'),     L('9'),     L('1'),     M(1933, 4), L('7'),     L('0'),     M(565, 4),
+                L('0'),     L('1'),     M(3048, 4), L('1'),     L('2'),     M(3189, 4), L('0'),     M(964, 4),
+                L('3'),     L('9'),     M(2859, 4), M(275, 4),  L('7'),     L('1'),     L('5'),     M(945, 4),
+                L('4'),     L('2'),     L('0'),     M(3059, 5), L('9'),     M(3011, 4), L('0'),     L('7'),
+                M(834, 4),  M(1942, 4), M(2736, 4), M(3171, 4), L('2'),     L('1'),     M(2401, 4), L('2'),
+                L('5'),     L('1'),     M(1404, 4), M(2373, 4), L('9'),     L('2'),     M(435, 4),  L('8'),
+                L('2'),     L('6'),     M(2919, 4), L('2'),     M(633, 4),  L('3'),     L('2'),     L('1'),
+                L('5'),     L('7'),     L('9'),     L('1'),     L('9'),     L('8'),     L('4'),     L('1'),
+                L('4'),     M(2172, 5), L('9'),     L('1'),     L('6'),     L('4'),     M(1769, 5), L('9'),
+                M(2905, 5), M(2268, 4), L('7'),     L('2'),     L('2'),     M(802, 4),  L('5'),     M(2213, 4),
+                M(322, 4),  L('9'),     L('1'),     L('0'),     M(189, 4),  M(3164, 4), L('5'),     L('2'),
+                L('8'),     L('0'),     L('1'),     L('7'),     M(562, 4),  L('7'),     L('1'),     L('2'),
+                M(2325, 4), L('8'),     L('3'),     L('2'),     M(884, 4),  L('1'),     M(1418, 4), L('0'),
+                L('9'),     L('3'),     L('5'),     L('3'),     L('9'),     L('6'),     L('5'),     L('7'),
+                M(1612, 4), L('1'),     L('0'),     L('8'),     L('3'),     M(106, 4),  L('5'),     L('1'),
+                M(1915, 4), M(3419, 4), L('1'),     L('4'),     L('4'),     L('4'),     L('2'),     L('1'),
+                L('0'),     L('0'),     M(515, 4),  L('0'),     L('3'),     M(413, 4),  L('1'),     L('1'),
+                L('0'),     L('3'),     M(3202, 4), M(10, 4),   M(39, 4),   M(1539, 6), L('5'),     L('1'),
+                L('6'),     M(1498, 4), M(2180, 5), M(2347, 4), L('5'),     M(3139, 5), L('8'),     L('5'),
+                L('1'),     L('7'),     L('1'),     L('4'),     L('3'),     L('7'),     M(1542, 4), M(110, 4),
+                L('1'),     L('5'),     L('5'),     L('6'),     L('5'),     L('0'),     L('8'),     L('8'),
+                M(954, 4),  L('9'),     L('8'),     L('9'),     L('8'),     L('5'),     L('9'),     L('9'),
+                L('8'),     L('2'),     L('3'),     L('8'),     M(464, 4),  M(2491, 4), L('3'),     M(365, 4),
+                M(1087, 4), M(2500, 4), L('8'),     M(3590, 5), L('3'),     L('2'),     M(264, 4),  L('5'),
+                M(774, 4),  L('3'),     M(459, 4),  L('9'),     M(1052, 4), L('9'),     L('8'),     M(2174, 4),
+                L('4'),     M(3257, 4), L('7'),     M(1612, 4), L('0'),     L('7'),     M(230, 4),  L('4'),
+                L('8'),     L('1'),     L('4'),     L('1'),     M(1338, 4), L('8'),     L('5'),     L('9'),
+                L('4'),     L('6'),     L('1'),     M(3018, 4), L('8'),     L('0'),
+            },
+        },
+        TestCase{
+            .input = "huffman-rand-1k.input",
+            .want = "huffman-rand-1k.{s}.expect",
+            .want_no_input = "huffman-rand-1k.{s}.expect-noinput",
+            .tokens = &[_]Token{
+                L(0xf8), L(0x8b), L(0x96), L(0x76), L(0x48), L(0xd),  L(0x85), L(0x94), L(0x25), L(0x80), L(0xaf), L(0xc2), L(0xfe), L(0x8d),
+                L(0xe8), L(0x20), L(0xeb), L(0x17), L(0x86), L(0xc9), L(0xb7), L(0xc5), L(0xde), L(0x6),  L(0xea), L(0x7d), L(0x18), L(0x8b),
+                L(0xe7), L(0x3e), L(0x7),  L(0xda), L(0xdf), L(0xff), L(0x6c), L(0x73), L(0xde), L(0xcc), L(0xe7), L(0x6d), L(0x8d), L(0x4),
+                L(0x19), L(0x49), L(0x7f), L(0x47), L(0x1f), L(0x48), L(0x15), L(0xb0), L(0xe8), L(0x9e), L(0xf2), L(0x31), L(0x59), L(0xde),
+                L(0x34), L(0xb4), L(0x5b), L(0xe5), L(0xe0), L(0x9),  L(0x11), L(0x30), L(0xc2), L(0x88), L(0x5b), L(0x7c), L(0x5d), L(0x14),
+                L(0x13), L(0x6f), L(0x23), L(0xa9), L(0xd),  L(0xbc), L(0x2d), L(0x23), L(0xbe), L(0xd9), L(0xed), L(0x75), L(0x4),  L(0x6c),
+                L(0x99), L(0xdf), L(0xfd), L(0x70), L(0x66), L(0xe6), L(0xee), L(0xd9), L(0xb1), L(0x9e), L(0x6e), L(0x83), L(0x59), L(0xd5),
+                L(0xd4), L(0x80), L(0x59), L(0x98), L(0x77), L(0x89), L(0x43), L(0x38), L(0xc9), L(0xaf), L(0x30), L(0x32), L(0x9a), L(0x20),
+                L(0x1b), L(0x46), L(0x3d), L(0x67), L(0x6e), L(0xd7), L(0x72), L(0x9e), L(0x4e), L(0x21), L(0x4f), L(0xc6), L(0xe0), L(0xd4),
+                L(0x7b), L(0x4),  L(0x8d), L(0xa5), L(0x3),  L(0xf6), L(0x5),  L(0x9b), L(0x6b), L(0xdc), L(0x2a), L(0x93), L(0x77), L(0x28),
+                L(0xfd), L(0xb4), L(0x62), L(0xda), L(0x20), L(0xe7), L(0x1f), L(0xab), L(0x6b), L(0x51), L(0x43), L(0x39), L(0x2f), L(0xa0),
+                L(0x92), L(0x1),  L(0x6c), L(0x75), L(0x3e), L(0xf4), L(0x35), L(0xfd), L(0x43), L(0x2e), L(0xf7), L(0xa4), L(0x75), L(0xda),
+                L(0xea), L(0x9b), L(0xa),  L(0x64), L(0xb),  L(0xe0), L(0x23), L(0x29), L(0xbd), L(0xf7), L(0xe7), L(0x83), L(0x3c), L(0xfb),
+                L(0xdf), L(0xb3), L(0xae), L(0x4f), L(0xa4), L(0x47), L(0x55), L(0x99), L(0xde), L(0x2f), L(0x96), L(0x6e), L(0x1c), L(0x43),
+                L(0x4c), L(0x87), L(0xe2), L(0x7c), L(0xd9), L(0x5f), L(0x4c), L(0x7c), L(0xe8), L(0x90), L(0x3),  L(0xdb), L(0x30), L(0x95),
+                L(0xd6), L(0x22), L(0xc),  L(0x47), L(0xb8), L(0x4d), L(0x6b), L(0xbd), L(0x24), L(0x11), L(0xab), L(0x2c), L(0xd7), L(0xbe),
+                L(0x6e), L(0x7a), L(0xd6), L(0x8),  L(0xa3), L(0x98), L(0xd8), L(0xdd), L(0x15), L(0x6a), L(0xfa), L(0x93), L(0x30), L(0x1),
+                L(0x25), L(0x1d), L(0xa2), L(0x74), L(0x86), L(0x4b), L(0x6a), L(0x95), L(0xe8), L(0xe1), L(0x4e), L(0xe),  L(0x76), L(0xb9),
+                L(0x49), L(0xa9), L(0x5f), L(0xa0), L(0xa6), L(0x63), L(0x3c), L(0x7e), L(0x7e), L(0x20), L(0x13), L(0x4f), L(0xbb), L(0x66),
+                L(0x92), L(0xb8), L(0x2e), L(0xa4), L(0xfa), L(0x48), L(0xcb), L(0xae), L(0xb9), L(0x3c), L(0xaf), L(0xd3), L(0x1f), L(0xe1),
+                L(0xd5), L(0x8d), L(0x42), L(0x6d), L(0xf0), L(0xfc), L(0x8c), L(0xc),  L(0x0),  L(0xde), L(0x40), L(0xab), L(0x8b), L(0x47),
+                L(0x97), L(0x4e), L(0xa8), L(0xcf), L(0x8e), L(0xdb), L(0xa6), L(0x8b), L(0x20), L(0x9),  L(0x84), L(0x7a), L(0x66), L(0xe5),
+                L(0x98), L(0x29), L(0x2),  L(0x95), L(0xe6), L(0x38), L(0x32), L(0x60), L(0x3),  L(0xe3), L(0x9a), L(0x1e), L(0x54), L(0xe8),
+                L(0x63), L(0x80), L(0x48), L(0x9c), L(0xe7), L(0x63), L(0x33), L(0x6e), L(0xa0), L(0x65), L(0x83), L(0xfa), L(0xc6), L(0xba),
+                L(0x7a), L(0x43), L(0x71), L(0x5),  L(0xf5), L(0x68), L(0x69), L(0x85), L(0x9c), L(0xba), L(0x45), L(0xcd), L(0x6b), L(0xb),
+                L(0x19), L(0xd1), L(0xbb), L(0x7f), L(0x70), L(0x85), L(0x92), L(0xd1), L(0xb4), L(0x64), L(0x82), L(0xb1), L(0xe4), L(0x62),
+                L(0xc5), L(0x3c), L(0x46), L(0x1f), L(0x92), L(0x31), L(0x1c), L(0x4e), L(0x41), L(0x77), L(0xf7), L(0xe7), L(0x87), L(0xa2),
+                L(0xf),  L(0x6e), L(0xe8), L(0x92), L(0x3),  L(0x6b), L(0xa),  L(0xe7), L(0xa9), L(0x3b), L(0x11), L(0xda), L(0x66), L(0x8a),
+                L(0x29), L(0xda), L(0x79), L(0xe1), L(0x64), L(0x8d), L(0xe3), L(0x54), L(0xd4), L(0xf5), L(0xef), L(0x64), L(0x87), L(0x3b),
+                L(0xf4), L(0xc2), L(0xf4), L(0x71), L(0x13), L(0xa9), L(0xe9), L(0xe0), L(0xa2), L(0x6),  L(0x14), L(0xab), L(0x5d), L(0xa7),
+                L(0x96), L(0x0),  L(0xd6), L(0xc3), L(0xcc), L(0x57), L(0xed), L(0x39), L(0x6a), L(0x25), L(0xcd), L(0x76), L(0xea), L(0xba),
+                L(0x3a), L(0xf2), L(0xa1), L(0x95), L(0x5d), L(0xe5), L(0x71), L(0xcf), L(0x9c), L(0x62), L(0x9e), L(0x6a), L(0xfa), L(0xd5),
+                L(0x31), L(0xd1), L(0xa8), L(0x66), L(0x30), L(0x33), L(0xaa), L(0x51), L(0x17), L(0x13), L(0x82), L(0x99), L(0xc8), L(0x14),
+                L(0x60), L(0x9f), L(0x4d), L(0x32), L(0x6d), L(0xda), L(0x19), L(0x26), L(0x21), L(0xdc), L(0x7e), L(0x2e), L(0x25), L(0x67),
+                L(0x72), L(0xca), L(0xf),  L(0x92), L(0xcd), L(0xf6), L(0xd6), L(0xcb), L(0x97), L(0x8a), L(0x33), L(0x58), L(0x73), L(0x70),
+                L(0x91), L(0x1d), L(0xbf), L(0x28), L(0x23), L(0xa3), L(0xc),  L(0xf1), L(0x83), L(0xc3), L(0xc8), L(0x56), L(0x77), L(0x68),
+                L(0xe3), L(0x82), L(0xba), L(0xb9), L(0x57), L(0x56), L(0x57), L(0x9c), L(0xc3), L(0xd6), L(0x14), L(0x5),  L(0x3c), L(0xb1),
+                L(0xaf), L(0x93), L(0xc8), L(0x8a), L(0x57), L(0x7f), L(0x53), L(0xfa), L(0x2f), L(0xaa), L(0x6e), L(0x66), L(0x83), L(0xfa),
+                L(0x33), L(0xd1), L(0x21), L(0xab), L(0x1b), L(0x71), L(0xb4), L(0x7c), L(0xda), L(0xfd), L(0xfb), L(0x7f), L(0x20), L(0xab),
+                L(0x5e), L(0xd5), L(0xca), L(0xfd), L(0xdd), L(0xe0), L(0xee), L(0xda), L(0xba), L(0xa8), L(0x27), L(0x99), L(0x97), L(0x69),
+                L(0xc1), L(0x3c), L(0x82), L(0x8c), L(0xa),  L(0x5c), L(0x2d), L(0x5b), L(0x88), L(0x3e), L(0x34), L(0x35), L(0x86), L(0x37),
+                L(0x46), L(0x79), L(0xe1), L(0xaa), L(0x19), L(0xfb), L(0xaa), L(0xde), L(0x15), L(0x9),  L(0xd),  L(0x1a), L(0x57), L(0xff),
+                L(0xb5), L(0xf),  L(0xf3), L(0x2b), L(0x5a), L(0x6a), L(0x4d), L(0x19), L(0x77), L(0x71), L(0x45), L(0xdf), L(0x4f), L(0xb3),
+                L(0xec), L(0xf1), L(0xeb), L(0x18), L(0x53), L(0x3e), L(0x3b), L(0x47), L(0x8),  L(0x9a), L(0x73), L(0xa0), L(0x5c), L(0x8c),
+                L(0x5f), L(0xeb), L(0xf),  L(0x3a), L(0xc2), L(0x43), L(0x67), L(0xb4), L(0x66), L(0x67), L(0x80), L(0x58), L(0xe),  L(0xc1),
+                L(0xec), L(0x40), L(0xd4), L(0x22), L(0x94), L(0xca), L(0xf9), L(0xe8), L(0x92), L(0xe4), L(0x69), L(0x38), L(0xbe), L(0x67),
+                L(0x64), L(0xca), L(0x50), L(0xc7), L(0x6),  L(0x67), L(0x42), L(0x6e), L(0xa3), L(0xf0), L(0xb7), L(0x6c), L(0xf2), L(0xe8),
+                L(0x5f), L(0xb1), L(0xaf), L(0xe7), L(0xdb), L(0xbb), L(0x77), L(0xb5), L(0xf8), L(0xcb), L(0x8),  L(0xc4), L(0x75), L(0x7e),
+                L(0xc0), L(0xf9), L(0x1c), L(0x7f), L(0x3c), L(0x89), L(0x2f), L(0xd2), L(0x58), L(0x3a), L(0xe2), L(0xf8), L(0x91), L(0xb6),
+                L(0x7b), L(0x24), L(0x27), L(0xe9), L(0xae), L(0x84), L(0x8b), L(0xde), L(0x74), L(0xac), L(0xfd), L(0xd9), L(0xb7), L(0x69),
+                L(0x2a), L(0xec), L(0x32), L(0x6f), L(0xf0), L(0x92), L(0x84), L(0xf1), L(0x40), L(0xc),  L(0x8a), L(0xbc), L(0x39), L(0x6e),
+                L(0x2e), L(0x73), L(0xd4), L(0x6e), L(0x8a), L(0x74), L(0x2a), L(0xdc), L(0x60), L(0x1f), L(0xa3), L(0x7),  L(0xde), L(0x75),
+                L(0x8b), L(0x74), L(0xc8), L(0xfe), L(0x63), L(0x75), L(0xf6), L(0x3d), L(0x63), L(0xac), L(0x33), L(0x89), L(0xc3), L(0xf0),
+                L(0xf8), L(0x2d), L(0x6b), L(0xb4), L(0x9e), L(0x74), L(0x8b), L(0x5c), L(0x33), L(0xb4), L(0xca), L(0xa8), L(0xe4), L(0x99),
+                L(0xb6), L(0x90), L(0xa1), L(0xef), L(0xf),  L(0xd3), L(0x61), L(0xb2), L(0xc6), L(0x1a), L(0x94), L(0x7c), L(0x44), L(0x55),
+                L(0xf4), L(0x45), L(0xff), L(0x9e), L(0xa5), L(0x5a), L(0xc6), L(0xa0), L(0xe8), L(0x2a), L(0xc1), L(0x8d), L(0x6f), L(0x34),
+                L(0x11), L(0xb9), L(0xbe), L(0x4e), L(0xd9), L(0x87), L(0x97), L(0x73), L(0xcf), L(0x3d), L(0x23), L(0xae), L(0xd5), L(0x1a),
+                L(0x5e), L(0xae), L(0x5d), L(0x6a), L(0x3),  L(0xf9), L(0x22), L(0xd),  L(0x10), L(0xd9), L(0x47), L(0x69), L(0x15), L(0x3f),
+                L(0xee), L(0x52), L(0xa3), L(0x8),  L(0xd2), L(0x3c), L(0x51), L(0xf4), L(0xf8), L(0x9d), L(0xe4), L(0x98), L(0x89), L(0xc8),
+                L(0x67), L(0x39), L(0xd5), L(0x5e), L(0x35), L(0x78), L(0x27), L(0xe8), L(0x3c), L(0x80), L(0xae), L(0x79), L(0x71), L(0xd2),
+                L(0x93), L(0xf4), L(0xaa), L(0x51), L(0x12), L(0x1c), L(0x4b), L(0x1b), L(0xe5), L(0x6e), L(0x15), L(0x6f), L(0xe4), L(0xbb),
+                L(0x51), L(0x9b), L(0x45), L(0x9f), L(0xf9), L(0xc4), L(0x8c), L(0x2a), L(0xfb), L(0x1a), L(0xdf), L(0x55), L(0xd3), L(0x48),
+                L(0x93), L(0x27), L(0x1),  L(0x26), L(0xc2), L(0x6b), L(0x55), L(0x6d), L(0xa2), L(0xfb), L(0x84), L(0x8b), L(0xc9), L(0x9e),
+                L(0x28), L(0xc2), L(0xef), L(0x1a), L(0x24), L(0xec), L(0x9b), L(0xae), L(0xbd), L(0x60), L(0xe9), L(0x15), L(0x35), L(0xee),
+                L(0x42), L(0xa4), L(0x33), L(0x5b), L(0xfa), L(0xf),  L(0xb6), L(0xf7), L(0x1),  L(0xa6), L(0x2),  L(0x4c), L(0xca), L(0x90),
+                L(0x58), L(0x3a), L(0x96), L(0x41), L(0xe7), L(0xcb), L(0x9),  L(0x8c), L(0xdb), L(0x85), L(0x4d), L(0xa8), L(0x89), L(0xf3),
+                L(0xb5), L(0x8e), L(0xfd), L(0x75), L(0x5b), L(0x4f), L(0xed), L(0xde), L(0x3f), L(0xeb), L(0x38), L(0xa3), L(0xbe), L(0xb0),
+                L(0x73), L(0xfc), L(0xb8), L(0x54), L(0xf7), L(0x4c), L(0x30), L(0x67), L(0x2e), L(0x38), L(0xa2), L(0x54), L(0x18), L(0xba),
+                L(0x8),  L(0xbf), L(0xf2), L(0x39), L(0xd5), L(0xfe), L(0xa5), L(0x41), L(0xc6), L(0x66), L(0x66), L(0xba), L(0x81), L(0xef),
+                L(0x67), L(0xe4), L(0xe6), L(0x3c), L(0xc),  L(0xca), L(0xa4), L(0xa),  L(0x79), L(0xb3), L(0x57), L(0x8b), L(0x8a), L(0x75),
+                L(0x98), L(0x18), L(0x42), L(0x2f), L(0x29), L(0xa3), L(0x82), L(0xef), L(0x9f), L(0x86), L(0x6),  L(0x23), L(0xe1), L(0x75),
+                L(0xfa), L(0x8),  L(0xb1), L(0xde), L(0x17), L(0x4a),
+            },
+        },
+        TestCase{
+            .input = "huffman-rand-limit.input",
+            .want = "huffman-rand-limit.{s}.expect",
+            .want_no_input = "huffman-rand-limit.{s}.expect-noinput",
+            .tokens = &[_]Token{
+                L(0x61), M(1, 74), L(0xa),  L(0xf8), L(0x8b), L(0x96), L(0x76), L(0x48), L(0xa),  L(0x85), L(0x94), L(0x25), L(0x80),
+                L(0xaf), L(0xc2),  L(0xfe), L(0x8d), L(0xe8), L(0x20), L(0xeb), L(0x17), L(0x86), L(0xc9), L(0xb7), L(0xc5), L(0xde),
+                L(0x6),  L(0xea),  L(0x7d), L(0x18), L(0x8b), L(0xe7), L(0x3e), L(0x7),  L(0xda), L(0xdf), L(0xff), L(0x6c), L(0x73),
+                L(0xde), L(0xcc),  L(0xe7), L(0x6d), L(0x8d), L(0x4),  L(0x19), L(0x49), L(0x7f), L(0x47), L(0x1f), L(0x48), L(0x15),
+                L(0xb0), L(0xe8),  L(0x9e), L(0xf2), L(0x31), L(0x59), L(0xde), L(0x34), L(0xb4), L(0x5b), L(0xe5), L(0xe0), L(0x9),
+                L(0x11), L(0x30),  L(0xc2), L(0x88), L(0x5b), L(0x7c), L(0x5d), L(0x14), L(0x13), L(0x6f), L(0x23), L(0xa9), L(0xa),
+                L(0xbc), L(0x2d),  L(0x23), L(0xbe), L(0xd9), L(0xed), L(0x75), L(0x4),  L(0x6c), L(0x99), L(0xdf), L(0xfd), L(0x70),
+                L(0x66), L(0xe6),  L(0xee), L(0xd9), L(0xb1), L(0x9e), L(0x6e), L(0x83), L(0x59), L(0xd5), L(0xd4), L(0x80), L(0x59),
+                L(0x98), L(0x77),  L(0x89), L(0x43), L(0x38), L(0xc9), L(0xaf), L(0x30), L(0x32), L(0x9a), L(0x20), L(0x1b), L(0x46),
+                L(0x3d), L(0x67),  L(0x6e), L(0xd7), L(0x72), L(0x9e), L(0x4e), L(0x21), L(0x4f), L(0xc6), L(0xe0), L(0xd4), L(0x7b),
+                L(0x4),  L(0x8d),  L(0xa5), L(0x3),  L(0xf6), L(0x5),  L(0x9b), L(0x6b), L(0xdc), L(0x2a), L(0x93), L(0x77), L(0x28),
+                L(0xfd), L(0xb4),  L(0x62), L(0xda), L(0x20), L(0xe7), L(0x1f), L(0xab), L(0x6b), L(0x51), L(0x43), L(0x39), L(0x2f),
+                L(0xa0), L(0x92),  L(0x1),  L(0x6c), L(0x75), L(0x3e), L(0xf4), L(0x35), L(0xfd), L(0x43), L(0x2e), L(0xf7), L(0xa4),
+                L(0x75), L(0xda),  L(0xea), L(0x9b), L(0xa),
+            },
+        },
+        TestCase{
+            .input = "huffman-shifts.input",
+            .want = "huffman-shifts.{s}.expect",
+            .want_no_input = "huffman-shifts.{s}.expect-noinput",
+            .tokens = &[_]Token{
+                L('1'),    L('0'),    M(2, 258), M(2, 258), M(2, 258), M(2, 258), M(2, 258), M(2, 258),
+                M(2, 258), M(2, 258), M(2, 258), M(2, 258), M(2, 258), M(2, 258), M(2, 258), M(2, 258),
+                M(2, 258), M(2, 76),  L(0xd),    L(0xa),    L('2'),    L('3'),    M(2, 258), M(2, 258),
+                M(2, 258), M(2, 258), M(2, 258), M(2, 258), M(2, 258), M(2, 258), M(2, 258), M(2, 256),
+            },
+        },
+        TestCase{
+            .input = "huffman-text-shift.input",
+            .want = "huffman-text-shift.{s}.expect",
+            .want_no_input = "huffman-text-shift.{s}.expect-noinput",
+            .tokens = &[_]Token{
+                L('/'),   L('/'), L('C'),   L('o'), L('p'),   L('y'),   L('r'),   L('i'),
+                L('g'),   L('h'), L('t'),   L('2'), L('0'),   L('0'),   L('9'),   L('T'),
+                L('h'),   L('G'), L('o'),   L('A'), L('u'),   L('t'),   L('h'),   L('o'),
+                L('r'),   L('.'), L('A'),   L('l'), L('l'),   M(23, 5), L('r'),   L('r'),
+                L('v'),   L('d'), L('.'),   L(0xd), L(0xa),   L('/'),   L('/'),   L('U'),
+                L('o'),   L('f'), L('t'),   L('h'), L('i'),   L('o'),   L('u'),   L('r'),
+                L('c'),   L('c'), L('o'),   L('d'), L('i'),   L('g'),   L('o'),   L('v'),
+                L('r'),   L('n'), L('d'),   L('b'), L('y'),   L('B'),   L('S'),   L('D'),
+                L('-'),   L('t'), L('y'),   L('l'), M(33, 4), L('l'),   L('i'),   L('c'),
+                L('n'),   L('t'), L('h'),   L('t'), L('c'),   L('n'),   L('b'),   L('f'),
+                L('o'),   L('u'), L('n'),   L('d'), L('i'),   L('n'),   L('t'),   L('h'),
+                L('L'),   L('I'), L('C'),   L('E'), L('N'),   L('S'),   L('E'),   L('f'),
+                L('i'),   L('l'), L('.'),   L(0xd), L(0xa),   L(0xd),   L(0xa),   L('p'),
+                L('c'),   L('k'), L('g'),   L('m'), L('i'),   L('n'),   M(11, 4), L('i'),
+                L('m'),   L('p'), L('o'),   L('r'), L('t'),   L('"'),   L('o'),   L('"'),
+                M(13, 4), L('f'), L('u'),   L('n'), L('c'),   L('m'),   L('i'),   L('n'),
+                L('('),   L(')'), L('{'),   L(0xd), L(0xa),   L(0x9),   L('v'),   L('r'),
+                L('b'),   L('='), L('m'),   L('k'), L('('),   L('['),   L(']'),   L('b'),
+                L('y'),   L('t'), L(','),   L('6'), L('5'),   L('5'),   L('3'),   L('5'),
+                L(')'),   L(0xd), L(0xa),   L(0x9), L('f'),   L(','),   L('_'),   L(':'),
+                L('='),   L('o'), L('.'),   L('C'), L('r'),   L('t'),   L('('),   L('"'),
+                L('h'),   L('u'), L('f'),   L('f'), L('m'),   L('n'),   L('-'),   L('n'),
+                L('u'),   L('l'), L('l'),   L('-'), L('m'),   L('x'),   L('.'),   L('i'),
+                L('n'),   L('"'), M(34, 5), L('.'), L('W'),   L('r'),   L('i'),   L('t'),
+                L('('),   L('b'), L(')'),   L(0xd), L(0xa),   L('}'),   L(0xd),   L(0xa),
+                L('A'),   L('B'), L('C'),   L('D'), L('E'),   L('F'),   L('G'),   L('H'),
+                L('I'),   L('J'), L('K'),   L('L'), L('M'),   L('N'),   L('O'),   L('P'),
+                L('Q'),   L('R'), L('S'),   L('T'), L('U'),   L('V'),   L('X'),   L('x'),
+                L('y'),   L('z'), L('!'),   L('"'), L('#'),   L(0xc2),  L(0xa4),  L('%'),
+                L('&'),   L('/'), L('?'),   L('"'),
+            },
+        },
+        TestCase{
+            .input = "huffman-text.input",
+            .want = "huffman-text.{s}.expect",
+            .want_no_input = "huffman-text.{s}.expect-noinput",
+            .tokens = &[_]Token{
+                L('/'),    L('/'),    L(' '),   L('z'),    L('i'), L('g'), L(' '), L('v'),
+                L('0'),    L('.'),    L('1'),   L('0'),    L('.'), L('0'), L(0xa), L('/'),
+                L('/'),    L(' '),    L('c'),   L('r'),    L('e'), L('a'), L('t'), L('e'),
+                L(' '),    L('a'),    L(' '),   L('f'),    L('i'), L('l'), L('e'), M(5, 4),
+                L('l'),    L('e'),    L('d'),   L(' '),    L('w'), L('i'), L('t'), L('h'),
+                L(' '),    L('0'),    L('x'),   L('0'),    L('0'), L(0xa), L('c'), L('o'),
+                L('n'),    L('s'),    L('t'),   L(' '),    L('s'), L('t'), L('d'), L(' '),
+                L('='),    L(' '),    L('@'),   L('i'),    L('m'), L('p'), L('o'), L('r'),
+                L('t'),    L('('),    L('"'),   L('s'),    L('t'), L('d'), L('"'), L(')'),
+                L(';'),    L(0xa),    L(0xa),   L('p'),    L('u'), L('b'), L(' '), L('f'),
+                L('n'),    L(' '),    L('m'),   L('a'),    L('i'), L('n'), L('('), L(')'),
+                L(' '),    L('!'),    L('v'),   L('o'),    L('i'), L('d'), L(' '), L('{'),
+                L(0xa),    L(' '),    L(' '),   L(' '),    L(' '), L('v'), L('a'), L('r'),
+                L(' '),    L('b'),    L(' '),   L('='),    L(' '), L('['), L('1'), L(']'),
+                L('u'),    L('8'),    L('{'),   L('0'),    L('}'), L(' '), L('*'), L('*'),
+                L(' '),    L('6'),    L('5'),   L('5'),    L('3'), L('5'), L(';'), M(31, 5),
+                M(86, 6),  L('f'),    L(' '),   L('='),    L(' '), L('t'), L('r'), L('y'),
+                M(94, 4),  L('.'),    L('f'),   L('s'),    L('.'), L('c'), L('w'), L('d'),
+                L('('),    L(')'),    L('.'),   M(144, 6), L('F'), L('i'), L('l'), L('e'),
+                L('('),    M(43, 5),  M(1, 4),  L('"'),    L('h'), L('u'), L('f'), L('f'),
+                L('m'),    L('a'),    L('n'),   L('-'),    L('n'), L('u'), L('l'), L('l'),
+                L('-'),    L('m'),    L('a'),   L('x'),    L('.'), L('i'), L('n'), L('"'),
+                L(','),    M(31, 9),  L('.'),   L('{'),    L(' '), L('.'), L('r'), L('e'),
+                L('a'),    L('d'),    M(79, 5), L('u'),    L('e'), L(' '), L('}'), M(27, 6),
+                L(')'),    M(108, 6), L('d'),   L('e'),    L('f'), L('e'), L('r'), L(' '),
+                L('f'),    L('.'),    L('c'),   L('l'),    L('o'), L('s'), L('e'), L('('),
+                M(183, 4), M(22, 4),  L('_'),   M(124, 7), L('f'), L('.'), L('w'), L('r'),
+                L('i'),    L('t'),    L('e'),   L('A'),    L('l'), L('l'), L('('), L('b'),
+                L('['),    L('0'),    L('.'),   L('.'),    L(']'), L(')'), L(';'), L(0xa),
+                L('}'),    L(0xa),
+            },
+        },
+        TestCase{
+            .input = "huffman-zero.input",
+            .want = "huffman-zero.{s}.expect",
+            .want_no_input = "huffman-zero.{s}.expect-noinput",
+            .tokens = &[_]Token{ L(0x30), ml, M(1, 49) },
+        },
+        TestCase{
+            .input = "",
+            .want = "",
+            .want_no_input = "null-long-match.{s}.expect-noinput",
+            .tokens = &[_]Token{
+                L(0x0), ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, ml,      ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml, ml,
+                ml,     ml, ml, M(1, 8),
+            },
+        },
+    };
+};
diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-null-max.dyn.expect b/lib/std/compress/flate/testdata/block_writer/huffman-null-max.dyn.expect
new file mode 100644
index 0000000000000000000000000000000000000000..c08165143f2c570013c4916cbac5addfe9622a55
GIT binary patch
literal 78
acmaEJppk)rfuUi+-<9GkK`aXJ0yY4fg9cgv

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-null-max.dyn.expect-noinput b/lib/std/compress/flate/testdata/block_writer/huffman-null-max.dyn.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..c08165143f2c570013c4916cbac5addfe9622a55
GIT binary patch
literal 78
acmaEJppk)rfuUi+-<9GkK`aXJ0yY4fg9cgv

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-null-max.huff.expect b/lib/std/compress/flate/testdata/block_writer/huffman-null-max.huff.expect
new file mode 100644
index 0000000000000000000000000000000000000000..db422ca3983d12e71e31979d7b3dddd080dcbca7
GIT binary patch
literal 8204
zcmZQM(8vG+0{^dqs8Ku`0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*O
uqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*AuzN<fC&ItS_3Qq

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-null-max.input b/lib/std/compress/flate/testdata/block_writer/huffman-null-max.input
new file mode 100644
index 0000000000000000000000000000000000000000..5dfddf075bed03499414ae453f0d6f30fe79da3d
GIT binary patch
literal 65535
zcmZP=1*0J_8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8Umvs
zFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*OqaiRF
z0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*
zAut*OqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3@?
z8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*O
zqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8Umvs
zFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*OqaiRF
z0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*
zAut*OqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3@?
z8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*O
zqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8Umvs
zFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*OqaiRF0;3@?8UmvsFd71*Aut*OqaiRF
U0;3@?8UmvsFd71*A;7=@000gE0RR91

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-null-max.wb.expect b/lib/std/compress/flate/testdata/block_writer/huffman-null-max.wb.expect
new file mode 100644
index 0000000000000000000000000000000000000000..c08165143f2c570013c4916cbac5addfe9622a55
GIT binary patch
literal 78
acmaEJppk)rfuUi+-<9GkK`aXJ0yY4fg9cgv

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-null-max.wb.expect-noinput b/lib/std/compress/flate/testdata/block_writer/huffman-null-max.wb.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..c08165143f2c570013c4916cbac5addfe9622a55
GIT binary patch
literal 78
acmaEJppk)rfuUi+-<9GkK`aXJ0yY4fg9cgv

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-pi.dyn.expect b/lib/std/compress/flate/testdata/block_writer/huffman-pi.dyn.expect
new file mode 100644
index 0000000000000000000000000000000000000000..e4396ac6fe5e34609ccb7ea0bc359e6adb48c7f4
GIT binary patch
literal 1696
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

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-pi.dyn.expect-noinput b/lib/std/compress/flate/testdata/block_writer/huffman-pi.dyn.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..e4396ac6fe5e34609ccb7ea0bc359e6adb48c7f4
GIT binary patch
literal 1696
zcmY$H9((C^0!LH%6+zLdfAiNIo?TpQ_4m>r1-l8q7CJuNP!Sb+?dy}0tD);8Dz9Hi
z3JKB`+{2T*diJR<Tc6`ke2;mWR|eLee8pmxR@%95hoY9gc3PEl>0M!^=IN0)QUYb$
z_t-Jq-dCes#Jnn*$ua1%?aWug(W0dv!YkV^6t%5-B{x6avNm$7d39@|p3wq<TlJ56
zHdWP}Zq6us`a^w1kZ+D(3U}|FTRHdK&KwarVV!foQS#J<Crc;E9%?d;-MoCsA~mKJ
zTwxpD8&$P+?sDtrFy-)BvASutv}sINQ^dj}yc_B+dDRCga>)En(sf^JvQzh*SmE*1
zyl<Q{S6jufE)WX}H;p#EDSLS4x*eS^E3XD8rRD32NOxY{Ykm8~-2}~zH#|klrkyvs
z&HmqfG2eMhC5!eLlj1Jn>AR1|hCDC&ZW6X?nOODg7dzhtC~Q9ZitEdUqsh8W8$T`X
zF||$IXzN+n;G!ioYsbqKc`_@UeY3XLUYwxTar*|#s;~cIbF=iLHf`P7y4I#YiOW5|
zq4!?OSB-T_%O}qi{kEgFtS5;tq(QgQ!9^r%ecsIS!_i@>F|t<4It#Ws<+}#v$BN9|
zo^n2yQDkpu>GY$wqWArsytKJ>PeP^0%woglu7;xgbcT*i`Oi8_R&g8dl<Y{9&)2%X
zeVNpToC)fAVIdA@G{PRt2)h%$_T-W)8nahz?fm*UbbWxriMNl_(l;NJh}`eJk!yx@
z&b!Kdk<$~dMtr;SZHpJHs-&>2Vm0q(2TiBvYhOCZt!EQHy0UjJr%UvwW~;9s9z5SF
z{yppVf?X=v^M#AfwU>XXT9lhrDZPI0iqCJ|MYGD3{nZU>In~sf7aIyTrN6t7pp>8<
zQ|2mCX)Sy6_N;rSG#@*AZC+CRWoL!$H8WdZ_RwTo-6j0F{p>wmdk!w$=9zb9TWIoz
zt2X|DcFM;O-*Z{BCZ~1j3YNC3Yj5|&WD7@L-o_oxRKn&QEiIOwm9pT;1-1LLRUTeF
zR#a`~zwqwe<5M~e{+gfJ{&Cs%1e+VvJMW!MT5$2)ghw;NC9W{sNxCGk=G)G~wDVgn
z<EJjY5wv*qs++qf=W?qS?s~MMe-4l4!ZSxo*S(#*@9WOnk!ud6_o^T6`Ti%b=<>t1
zy`7JL&H8#~|E-zLccm4t&23&hC&*CTaIUAy<u`YOZcT6V+ka-)$-v9Oc^NZ~f0$co
zSr{xAZy#vvl~#E9+1aSWNjxrn&B=;6^F;5zd|2ciw!n|?(&{<OjuiX3zOUR9C-U>f
z%NxQEZ_m_zJypb<XV&R06EEMquyOY0fcKTgdg>RfgH9~qzA|Ok>3^#?a7kXBm14H>
zUKH=eR=-$|u7#Jx?)da9JD&1kX{OA##cyV=iP}6p*XpL->x`ZAoPVZ0d-d$f&f5yA
zGPSRAx>Q$jKl}D;_0Ap3YWF>@Qi!|1;hdxSOZRybHkuYXrd*GWwyMvY@;y=g`yNN`
zS!Z1{&6zZnpI_nqo!9r}r}eU!Vk5K5hwS*jG^UGJ{Mk0IH!>^jTwR3KVvEGp%fC;s
zHBL*OmNzT8BeCmza30I+ZHtWKLW1As++CNmnY~ALbM{r26ZZV27R%m+bz4m3KF?ul
zKKt9W<Nlv7FDPU_pp}0v_1U)XM?a_Tu9~}dYes9@%Hn%hFD#O+DO$cF`*O^wAA8Tr
z+-ntXEDL(>_I}bj_N}wrgncgCug;#8yQlnn*T0RDKePM}uh7wF-26d`CGEi}r{0Lk
zt!Do>uMh2xR=98{(K=B%eAT-ZZ+jxXFSnhRBvf_oi&*UY=$EU#N{SPOt;%*w=y|d6
zayxzbs@SyEP*1=AoPJ~Crgi1beAR~&UbR;5F5FvM6<yyyZGHQRVu6@+K3i`K?Fmcs
zgSw9TuHL+W@%Z7giq3VOYQ0-$t|<22axd<X=i*j9;o#-B_Lg>kY|fs#G5T56qe+iz
z<`=Fh-S<QCc+7VGByDB&7w3LWvtia%ek&2J_W4Xp`=nUeef<U3?oG*_>U?j_h8Hou
z=L&Tc9-r~Jm!+bvv^|z*{o%Q+z6TTcBwl8@^Lb+3OOE#iCqr*e(s|MPwkQ1OQ!e?}
zyhU2O*Z&e#e%Lg%<>qUlrC(0y9XGYk-Q!ij8oN0DyTG#e3ok{p%V(ec(sn`hC>Phm
z+241werC!(u5)SW3$4Ay2A$4FFBQyH?a+?zEco*4D%ah)9UE8|*~loI%2)XJ<nTTY
zg<~o8vPVKY--|x#aJ_EDT4Orl@Q%;VUX@JIdu`(%zJ1e;W9`;=_HIAm_1Yodv2u!$
cbV;84Tk+|o(~kVo{C&Z|vj0`%>_1240T=^Zod5s;

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-pi.huff.expect b/lib/std/compress/flate/testdata/block_writer/huffman-pi.huff.expect
new file mode 100644
index 0000000000000000000000000000000000000000..23d8f7f98b5906e3fd0f811cb6561d7a67ec9a56
GIT binary patch
literal 1606
zcmZQM&?tJqfrs%z?=PkH4gZt=zGq&z?(3Ae`};0r@0-3o{H&S_|GVt_oQvOli3qxD
zE<WRNZ~3KTvn$WMDr}UF-<+T(b}#MzjXf{9U#>Jc_3rT6d8atdcp4U`IiI<=KtC!$
z<?531(;;tWi(h%7He+7SSKCWBKBT1G-~HoL!rMglxlKmOyMMo^>@gI%f9uSny>{o<
zrbh}?zn^yM?2X6lng<OV%XS6lZ`1ZGykI<EKelvUdc$|O{39vt+r;!)Vi&eB`2W23
z;@h*x<*QcQD-mS=-n7rOpjLuW(Ad4|{?>cRPph34UA|{@^xaq1O6Dm?&EEgK_jywC
z%^KnJkESk--+H>b{oL6{QvN^lzU6({Wie+v|MScHE*w|*a`P!ie!3gqH;1+JZEo&<
z!Pj5C%iH#-?f%10#Y#@ROqhQ4vGj!`(Y=Q=*6j{ozPe=oj^;2nvD=YXgp1`m9eC$$
zFW+-`_BG`v&%`QnZkxT|Ha$_hr;7i(*@r9qfu`Q8rpVnrIomXRcmAfT{t^@a>@SR*
ze9bc}E2dAstQO|?{_PXiJBEDaWe2N2Us)q(eP@o#bGZelr1z)HzxVV?xl^gQOS$CU
zqlwogrSsYDp1#Sj%1`_m->iK;TX)I!9M!0+?!21*Vy{AV>9@1eA=du+0=aX;%Fpl4
z>YSc*Gx|>E=Zd4v3bKo%^;|PzLMN}i$1L;so096>%O?637vE=m`?^rOx83;e?neHK
zxtTL`*rlIJ&Qsq%do%mt!wMSPCuNx|JwLrX<>Z<#>&o|(R!H#q_b)3q+HyGbc<RPl
z{`2LVGr4rzmbaEaxwTm)HEx09{D!O5k^5$<KRpvEmwhjKe^bWyYllmBSAR{NU(q-}
z{Z~iyjEF7XNBL)&ODo@AyhK`lws>!ZR^Xjd?ebmQXS~k*m8QLyb&b2(_RZ>7H=jRq
zBZ=F@QEq*C)u#EgE!Q2r8n;KNNnrWn{L3%z-i?b-Q!~i7VQ!8Ri@g(lr>Xq6iGs(M
zc`}9u^BC`5_Uis#VWp%ayD#JZ?dv<ko8H@YmB$_W$dx%S#_f~e?icTr?nGyX#aLR(
zuRDB+`Srzf8#=##dn+pLU-Izu>9|^3>jfP%U#Y%-^nB&9nTF-9SNj^O@3yT}KhoBD
zeW^{%qHAuOcS}fj-2ZW6Z$)`r;4~?@Z?gA}ehsO6W-YSa^4Ga7e&1iI##wFrbS-4{
zgS~wEo0p&4vgO<y@7B_nd!A*6-ZfeMrpkS{k7fC5=gP?TNdAhv<(r>9_&K%4{bld5
zo0V(Ay&vAV9`%5E`^-hjrKYvpxv!hB+%-9MT5xgPqE+R$g=g<;EUdbF;oxbjbKSx3
zWEHn|T)7%_b@i$C#Ol>cjTg?kU9A?|x-o9v`^xgY^TfRU-6Hn2tancIwCT2epSrGm
z0=M1Pa^o9P^QN?%wwQFN;Ln#G*4uZVYU`BLn3BHu<AI0ww70%qe13Y!>Z9FdN5i(%
zR^PlnV^h`vf1f@1CGIoN+N?a^UsO=zoxpmwGA2&bXKmG~$hT_O4=>@L5^HmO`|RXX
z6WN*1RtrDgRk+OBa^CVCI=>f{EMqTw6};GVp6a)zFNxKOV&}GL7Vi!->hXKlP<`0i
zv*PzUHI0n>7k~foDO@~ZPuAKWn<N;I2)}<Bx0S!*PIGUh&DE=)?IuL)9^U87ClQcd
zIM1s3t@3l(@@H~x;(PnV&z_z*om1au?su^zeER1&pI)AkFSbywD^cRii@Opf$Br+m
zc5IA`UoG3b;_nX2i87yMTWi}FbZ5^F=LrdMbC`dibmRKtQ!ZN`(fPixt!8PNk!VI{
z*;f8}(--6)n7i-uqu3><>R#?X?R#%eU-jLc)nDE!X|IoxmMU0S`S=WX<#&y;bX%p2
z)vIMUxaXOC59@e4^Jui4U(>lniT&->CfSWuvax&ndL%QOHcnlA`+)!P>bi#+r3<=l
zemTa%K0~f-kL12{uU9tJu-`pf@O*Fg?dLOZn+Kiaf4;nEVs%7gyX@Y#Y_8WjHg>(&
zEpc@=@Y!Zi`FN#Y_2XA%%PoE~+|M)Qy`#BB^3LTS8;)z_mlvP7>^DDdZFHhx<u0d+
zyiLIqV$S?%sqD8)kn8x$Sdph5#<KsJWAnWOO$_c9ALf?2%~Ob+yy5b)z}dAs-7`PS
r{aIr9x$A{y?QXXtSMon@d+#fCcZT(s%&R*!k2Gw!vBKmJ-%NP`qy0>Z

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-pi.input b/lib/std/compress/flate/testdata/block_writer/huffman-pi.input
new file mode 100644
index 0000000000..efaed43431
--- /dev/null
+++ b/lib/std/compress/flate/testdata/block_writer/huffman-pi.input
@@ -0,0 +1 @@
+3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920962829254091715364367892590360011330530548820466521384146951941511609433057270365759591953092186117381932611793105118548074462379962749567351885752724891227938183011949129833673362440656643086021394946395224737190702179860943702770539217176293176752384674818467669405132000568127145263560827785771342757789609173637178721468440901224953430146549585371050792279689258923542019956112129021960864034418159813629774771309960518707211349999998372978049951059731732816096318595024459455346908302642522308253344685035261931188171010003137838752886587533208381420617177669147303598253490428755468731159562863882353787593751957781857780532171226806613001927876611195909216420198938095257201065485863278865936153381827968230301952035301852968995773622599413891249721775283479131515574857242454150695950829533116861727855889075098381754637464939319255060400927701671139009848824012858361603563707660104710181942955596198946767837449448255379774726847104047534646208046684259069491293313677028989152104752162056966024058038150193511253382430035587640247496473263914199272604269922796782354781636009341721641219924586315030286182974555706749838505494588586926995690927210797509302955321165344987202755960236480665499119881834797753566369807426542527862551818417574672890977772793800081647060016145249192173217214772350141441973568548161361157352552133475741849468438523323907394143334547762416862518983569485562099219222184272550254256887671790494601653466804988627232791786085784383827967976681454100953883786360950680064225125205117392984896084128488626945604241965285022210661186306744278622039194945047123713786960956364371917287467764657573962413890865832645995813390478027590099465764078951269468398352595709825822620522489407726719478268482601476990902640136394437455305068203496252451749399651431429809190659250937221696461515709858387410597885959772975498930161753928468138268683868942774155991855925245953959431049972524680845987273644695848653836736222626099124608051243884390451244136549762780797715691435997700129616089441694868555848406353422072225828488648158456028506016842739452267467678895252138522549954666727823986456596116354886230577456498035593634568174324112515076069479451096596094025228879710893145669136867228748940560101503308617928680920874760917824938589009714909675985261365549781893129784821682998948722658804857564014270477555132379641451523746234364542858444795265867821051141354735739523113427166102135969536231442952484937187110145765403590279934403742007310578539062198387447808478489683321445713868751943506430218453191048481005370614680674919278191197939952061419663428754440643745123718192179998391015919561814675142691239748940907186494231961567945208095146550225231603881930142093762137855956638937787083039069792077346722182562599661501421503068038447734549202605414665925201497442850732518666002132434088190710486331734649651453905796268561005508106658796998163574736384052571459102897064140110971206280439039759515677157700420337869936007230558763176359421873125147120532928191826186125867321579198414848829164470609575270695722091756711672291098169091528017350671274858322287183520935396572512108357915136988209144421006751033467110314126711136990865851639831501970165151168517143765761835155650884909989859982387345528331635507647918535893226185489632132933089857064204675259070915481416549859461637180
\ No newline at end of file
diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-pi.wb.expect b/lib/std/compress/flate/testdata/block_writer/huffman-pi.wb.expect
new file mode 100644
index 0000000000000000000000000000000000000000..e4396ac6fe5e34609ccb7ea0bc359e6adb48c7f4
GIT binary patch
literal 1696
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

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-pi.wb.expect-noinput b/lib/std/compress/flate/testdata/block_writer/huffman-pi.wb.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..e4396ac6fe5e34609ccb7ea0bc359e6adb48c7f4
GIT binary patch
literal 1696
zcmY$H9((C^0!LH%6+zLdfAiNIo?TpQ_4m>r1-l8q7CJuNP!Sb+?dy}0tD);8Dz9Hi
z3JKB`+{2T*diJR<Tc6`ke2;mWR|eLee8pmxR@%95hoY9gc3PEl>0M!^=IN0)QUYb$
z_t-Jq-dCes#Jnn*$ua1%?aWug(W0dv!YkV^6t%5-B{x6avNm$7d39@|p3wq<TlJ56
zHdWP}Zq6us`a^w1kZ+D(3U}|FTRHdK&KwarVV!foQS#J<Crc;E9%?d;-MoCsA~mKJ
zTwxpD8&$P+?sDtrFy-)BvASutv}sINQ^dj}yc_B+dDRCga>)En(sf^JvQzh*SmE*1
zyl<Q{S6jufE)WX}H;p#EDSLS4x*eS^E3XD8rRD32NOxY{Ykm8~-2}~zH#|klrkyvs
z&HmqfG2eMhC5!eLlj1Jn>AR1|hCDC&ZW6X?nOODg7dzhtC~Q9ZitEdUqsh8W8$T`X
zF||$IXzN+n;G!ioYsbqKc`_@UeY3XLUYwxTar*|#s;~cIbF=iLHf`P7y4I#YiOW5|
zq4!?OSB-T_%O}qi{kEgFtS5;tq(QgQ!9^r%ecsIS!_i@>F|t<4It#Ws<+}#v$BN9|
zo^n2yQDkpu>GY$wqWArsytKJ>PeP^0%woglu7;xgbcT*i`Oi8_R&g8dl<Y{9&)2%X
zeVNpToC)fAVIdA@G{PRt2)h%$_T-W)8nahz?fm*UbbWxriMNl_(l;NJh}`eJk!yx@
z&b!Kdk<$~dMtr;SZHpJHs-&>2Vm0q(2TiBvYhOCZt!EQHy0UjJr%UvwW~;9s9z5SF
z{yppVf?X=v^M#AfwU>XXT9lhrDZPI0iqCJ|MYGD3{nZU>In~sf7aIyTrN6t7pp>8<
zQ|2mCX)Sy6_N;rSG#@*AZC+CRWoL!$H8WdZ_RwTo-6j0F{p>wmdk!w$=9zb9TWIoz
zt2X|DcFM;O-*Z{BCZ~1j3YNC3Yj5|&WD7@L-o_oxRKn&QEiIOwm9pT;1-1LLRUTeF
zR#a`~zwqwe<5M~e{+gfJ{&Cs%1e+VvJMW!MT5$2)ghw;NC9W{sNxCGk=G)G~wDVgn
z<EJjY5wv*qs++qf=W?qS?s~MMe-4l4!ZSxo*S(#*@9WOnk!ud6_o^T6`Ti%b=<>t1
zy`7JL&H8#~|E-zLccm4t&23&hC&*CTaIUAy<u`YOZcT6V+ka-)$-v9Oc^NZ~f0$co
zSr{xAZy#vvl~#E9+1aSWNjxrn&B=;6^F;5zd|2ciw!n|?(&{<OjuiX3zOUR9C-U>f
z%NxQEZ_m_zJypb<XV&R06EEMquyOY0fcKTgdg>RfgH9~qzA|Ok>3^#?a7kXBm14H>
zUKH=eR=-$|u7#Jx?)da9JD&1kX{OA##cyV=iP}6p*XpL->x`ZAoPVZ0d-d$f&f5yA
zGPSRAx>Q$jKl}D;_0Ap3YWF>@Qi!|1;hdxSOZRybHkuYXrd*GWwyMvY@;y=g`yNN`
zS!Z1{&6zZnpI_nqo!9r}r}eU!Vk5K5hwS*jG^UGJ{Mk0IH!>^jTwR3KVvEGp%fC;s
zHBL*OmNzT8BeCmza30I+ZHtWKLW1As++CNmnY~ALbM{r26ZZV27R%m+bz4m3KF?ul
zKKt9W<Nlv7FDPU_pp}0v_1U)XM?a_Tu9~}dYes9@%Hn%hFD#O+DO$cF`*O^wAA8Tr
z+-ntXEDL(>_I}bj_N}wrgncgCug;#8yQlnn*T0RDKePM}uh7wF-26d`CGEi}r{0Lk
zt!Do>uMh2xR=98{(K=B%eAT-ZZ+jxXFSnhRBvf_oi&*UY=$EU#N{SPOt;%*w=y|d6
zayxzbs@SyEP*1=AoPJ~Crgi1beAR~&UbR;5F5FvM6<yyyZGHQRVu6@+K3i`K?Fmcs
zgSw9TuHL+W@%Z7giq3VOYQ0-$t|<22axd<X=i*j9;o#-B_Lg>kY|fs#G5T56qe+iz
z<`=Fh-S<QCc+7VGByDB&7w3LWvtia%ek&2J_W4Xp`=nUeef<U3?oG*_>U?j_h8Hou
z=L&Tc9-r~Jm!+bvv^|z*{o%Q+z6TTcBwl8@^Lb+3OOE#iCqr*e(s|MPwkQ1OQ!e?}
zyhU2O*Z&e#e%Lg%<>qUlrC(0y9XGYk-Q!ij8oN0DyTG#e3ok{p%V(ec(sn`hC>Phm
z+241werC!(u5)SW3$4Ay2A$4FFBQyH?a+?zEco*4D%ah)9UE8|*~loI%2)XJ<nTTY
zg<~o8vPVKY--|x#aJ_EDT4Orl@Q%;VUX@JIdu`(%zJ1e;W9`;=_HIAm_1Yodv2u!$
cbV;84Tk+|o(~kVo{C&Z|vj0`%>_1240T=^Zod5s;

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.dyn.expect b/lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.dyn.expect
new file mode 100644
index 0000000000000000000000000000000000000000..09dc798ee37df82176b8b7c9998c88a14207c1ad
GIT binary patch
literal 1005
zcmZR0!7TpgNB6Wc58l=(stxN8{p)?9@LIg><o2WY*k092bU(LazjgnAPVv1n&vScO
zBt7fh<vm0<yqNdNF!G+smguJsI0X$3bwt<1iU{W`ujJjMtGw^#+ftUCnfLz|q&<6g
zbK|_c=E$p88X{+ucRE{~TyJ1BOF`PrHa+ip(L6sz|6>oXRI~IhW&XxGJNu5-<Z_L_
zTas=mJeOac9q4SSzhDw$PO04&)4$Go-<Oo$dNrFXh5LcB=HBnmn{9sI-@ML$iF@eG
zd-~JzWSo84AJyE9_o;a?f%&$<)N4vS?mK+5_o@i4*15hfuj(4d;u$yYie~+qY`~~0
zyQrkiJ8SBThkkrzJ3Uv%FIbjrQ&*=T?7us0(hj{PzdTN_+iA1@vi!rVy-v9w{`BxL
z+;dpn?LOUa#reM5%eoafTdLBY&d_9<`pm*8f%)+)xsVsh4IXozCmZK2NNxUgY*&?Y
zA?w$S%+@)(T+e26OJ3YvU(h<~;+B-AjZcz}+PKM2GL-RiEdTzzeGz}&i%HDcT+dfp
z3*JiW(!5pqFs1i#$d#|}Q`)V+9Qslyyz=FPMQkFgW0y~3xOVtV_*=^?)w5-<c3FK|
zI5qZZ;rTg9^Rj+jHN3bY&A@n7ptx|;%o8FB^L>qSZ%L{t-l@}5O)omdKk4kZYp17o
z8AlWsOqAWPp}d&qWAot?VdWW*n|AFC4-21j_?if-&BpbUPjrRX2mjJvm6z81%lM+=
zYU#o)HMjo$u2)zcclFfYyAR&o+O<M`=Jd>iHcdTTF}l$mb|$86=5Cb_S4sX}bx)L&
zS1SDfR{qc0QCYr{<%O>I{Wrh)_*x>^&f1-0R`G(Ep7_`NR)?I^x1^;vMDQJa<8Vc3
z%Bi0(COyft*q5GiD&RO<x>Mfb58HD-y@=nq{`u|Q<y(K8<~UMXci^W?y-lb7r3kA>
zKPGOgR#AVsuBH24$(p}6w`Xd-G0OiispX>sPuCvHJiX#8d0i!1cM{|mv)?Q2E;;cp
zx%8WD@*3mL!ykU=W^b8S(j8;G<<yENGq+7x_@4iA;-+I#Q)*m7zqtONw>0Y5f)`o`
zd-F{Mckc7M**?Aaysh%Ot5R|6VzZckD)9>3bk7vEe;2fv<C0C_mmhPV%;-FkZh1A%
zv_k!bO~bm%!b_9CtO^v8@s@s?Cz}6cci?Q-`9F{JX#JMDA9~qivO1&Mq3qDyMZa6R
zPtMag^j=Ek&Fpo16JCm%zH?e)9Q})b+jqugOg^V3L|9F8e14j<=XR^_iq6kl`~H?j
z`@g+s|Jq{lz755Hc7%NQF-X_5SQH|$i(~&M%d7vEIvz_)+tv6!{mC;Mo>NP>DmRCB
cca_eNaMIUY-1L5a8=LaO(q9}K?}>W>09POZHvj+t

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.dyn.expect-noinput b/lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.dyn.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..0c24742fde2487e3a454ec3364f15e541693c37c
GIT binary patch
literal 1054
zcmZQMz-=ML!NBlf=Gmk*#b0<gU%qx`hx3tgIm40^^Zw#w!}Eu)id>x3XF2Ejly8yu
z`nx&Xzoq)cNm}2OnR)*C#Mq4nf%p1N`*q&gFPWxRne|jeI(^G0zYL=fzn<QixNdvW
z)~)xyt_XV0z3AuVh($l<n)H?V{r9uFbVB$`(6JkvxrA;PG)))3vUTAe^@A%H?y~wg
zA#H8=vk7$%)n3Nr9NlBYxObCkPV$4zO)Qrs9iKj_X}Rm6ePx$W&C$c0&Gr8~9u}W1
z&q)0B(K4#})xV!wcjiP2{+u>RSd+=SH^RccWpAo(tm?EUI@?2)bogF*F50Tq`=Xm$
z;PO7^OtC)|`{url?&nz{5IyY?uV7rId~oZ-xRslnu102@JX7kMvfX^$`!=)JyTAYa
zF-4ML^Pm0v3TqZ|tV*ics%Q9JZ=1`u7sZ+@pZgV8<R**Q=<=?4e7k#DdGr-+8~2;G
zAFgRGc4a)PoA=zi@tNdC?(Qy~&zVy7R<}J^SEnyuF#WXe`DtrzM7pog3$1&s-+k)C
znrUtaKWyEfrrEYbljG3O^Zdz0t9HIi-qHO_c<)P2%P*XMC26x&KIz^$+>w|1;<1<A
zglAV7KN{`Q@^ilRW`(X(u#fA>?u%Pg|Gzwc`(kBZ(Y!eeF7MeDuzcBRuD`3loH_Hr
z`pPofYZW?~y{|WX-=k78(;!av<N+;~Fk#;ejWtK#Z}Lk!x*^Y{cYEm^kN?lM?lj>}
zKBH_m!ET$qag<vltB~-#*xFj|Ls#ycm6F-#U$<k*$+wPo-9!1$y_na&eXAI6aKOv&
zBGYs$N~STH750|49`F>^?7w_)jR9l)&%{LUBe_N^HM%7m(#0}bX0Y2AZrgbF?>*(p
zjjsQ9xbg&DH*%O;#$aFjo8k3Zf3+Rwe{aiwv+niX;xZQ|t<J5AtPfv1u*)$Wc1$*6
z(&x?D;S;a_O#bAHNfNv3d`$i?ufJ-LSMkg*{LMU_J!?a)ZhOD8kYU}Uxb$yv$_&2q
z+vo6<{HXY`=JQA1$)ROtp>uvXX};+)yuG3C{=)S4yE1~}Za&uSxLo12=w?id;OC|p
zF1|8$ol0-5UH3LT<$otL>#;?TOBP4Z;rvM<C1Q5>+5G-~`aZ$2@D)E}(f44t!_5n$
zX5M7bz2~-j`F-~p;chbJO&eI*65j-@d3CXL?fRAz5*OaCoj<d|bI1HYAN)Nl{}~*M
z6G;0#yOU?$K|eJgv6In%_L=RePL<^En*QZi=+5ghdo>NL&1Ue=_@rYLxbx&;)+1MC
z(}Ue5wpZL{GdEjxqgHUW!foB{RS_GQZd5L~RB^34UgAZ-D=pbj{TXLJ=AHU~<zt8^
z*SEVO_v5xFf7`E8_wt+lho&T*H?RJD-O+Hp`diavw(E)}vwj~pbKAsp{mJ!gmF<gH
dhy?ANH+!k3aq(`oaNbQGK@7K!Ot1eV4*<5=86yAy

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.huff.expect b/lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.huff.expect
new file mode 100644
index 0000000000000000000000000000000000000000..09dc798ee37df82176b8b7c9998c88a14207c1ad
GIT binary patch
literal 1005
zcmZR0!7TpgNB6Wc58l=(stxN8{p)?9@LIg><o2WY*k092bU(LazjgnAPVv1n&vScO
zBt7fh<vm0<yqNdNF!G+smguJsI0X$3bwt<1iU{W`ujJjMtGw^#+ftUCnfLz|q&<6g
zbK|_c=E$p88X{+ucRE{~TyJ1BOF`PrHa+ip(L6sz|6>oXRI~IhW&XxGJNu5-<Z_L_
zTas=mJeOac9q4SSzhDw$PO04&)4$Go-<Oo$dNrFXh5LcB=HBnmn{9sI-@ML$iF@eG
zd-~JzWSo84AJyE9_o;a?f%&$<)N4vS?mK+5_o@i4*15hfuj(4d;u$yYie~+qY`~~0
zyQrkiJ8SBThkkrzJ3Uv%FIbjrQ&*=T?7us0(hj{PzdTN_+iA1@vi!rVy-v9w{`BxL
z+;dpn?LOUa#reM5%eoafTdLBY&d_9<`pm*8f%)+)xsVsh4IXozCmZK2NNxUgY*&?Y
zA?w$S%+@)(T+e26OJ3YvU(h<~;+B-AjZcz}+PKM2GL-RiEdTzzeGz}&i%HDcT+dfp
z3*JiW(!5pqFs1i#$d#|}Q`)V+9Qslyyz=FPMQkFgW0y~3xOVtV_*=^?)w5-<c3FK|
zI5qZZ;rTg9^Rj+jHN3bY&A@n7ptx|;%o8FB^L>qSZ%L{t-l@}5O)omdKk4kZYp17o
z8AlWsOqAWPp}d&qWAot?VdWW*n|AFC4-21j_?if-&BpbUPjrRX2mjJvm6z81%lM+=
zYU#o)HMjo$u2)zcclFfYyAR&o+O<M`=Jd>iHcdTTF}l$mb|$86=5Cb_S4sX}bx)L&
zS1SDfR{qc0QCYr{<%O>I{Wrh)_*x>^&f1-0R`G(Ep7_`NR)?I^x1^;vMDQJa<8Vc3
z%Bi0(COyft*q5GiD&RO<x>Mfb58HD-y@=nq{`u|Q<y(K8<~UMXci^W?y-lb7r3kA>
zKPGOgR#AVsuBH24$(p}6w`Xd-G0OiispX>sPuCvHJiX#8d0i!1cM{|mv)?Q2E;;cp
zx%8WD@*3mL!ykU=W^b8S(j8;G<<yENGq+7x_@4iA;-+I#Q)*m7zqtONw>0Y5f)`o`
zd-F{Mckc7M**?Aaysh%Ot5R|6VzZckD)9>3bk7vEe;2fv<C0C_mmhPV%;-FkZh1A%
zv_k!bO~bm%!b_9CtO^v8@s@s?Cz}6cci?Q-`9F{JX#JMDA9~qivO1&Mq3qDyMZa6R
zPtMag^j=Ek&Fpo16JCm%zH?e)9Q})b+jqugOg^V3L|9F8e14j<=XR^_iq6kl`~H?j
z`@g+s|Jq{lz755Hc7%NQF-X_5SQH|$i(~&M%d7vEIvz_)+tv6!{mC;Mo>NP>DmRCB
cca_eNaMIUY-1L5a8=LaO(q9}K?}>W>09POZHvj+t

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.input b/lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.input
new file mode 100644
index 0000000000000000000000000000000000000000..ce038ebb5bd911cd054b86c044fd26e6003225e2
GIT binary patch
literal 1000
zcmey-J*~`xw{?nY!}>%2dS58K7H>Pb{pdZmSG5w|&+XW6-T$9ceDBQj++G$*&w6)x
z577-T=6y1Zyl1i{`so8sL4!jb(KWFm!uiT8dH3il@4NZ7lqF~8{l5ii&)(hKI4`d`
z^6Hg_$Qk9G&K4)v8yL+}kan|8&%0hU&ri|+*n=z8EWJyazp>8FzN0m{T;uPSq+1Hl
z<yU71I$P>5n8cV<YWKzTue09wC8f7s&E`tsexR(m_xtl^o8R|0uk&Bx9y;@${<J(9
zXP@>*H8<mZYF<oWzHKn|ni7xu4&Us(DuSzZuJ6mMy2i11#*Mq8S-&P5FsjNfDrxi1
zn)>3QA79x{&z12DmL=QN)hP)3?@pVvLvP71kJIaR+N{4U|L|(BQ|^a9Jv<Ee99DO`
zPxo7KzVG(3ZUxSks<fvwG?}J8voK0vemqMq<VA9W$DHTM#(4`;n|~eKRpngB`ZXi7
zb<Qr=v)SB|7kAeev`)IXC8cTOlcb|IZt{~1W&9k=zdvtZ#Gm(K5_2}!^Oe?ux6-;a
zZ&f}_>3tk><?H*DcIz*Pz7z_teEDDzo5<?e<<l6h9X=EO)-p@=Y}u<_R-YD5jeS~p
zeooT7tY23RFRn;4FkTfXF5EQpgh;}CU!&Yxl4^=~>hx68i%#)RI{WR~>FHg@5yb@)
zW%p|+FXs8!eE39IdB)?WT|2|W!si^mCc<j7asA{IUE%e?zw}q-r8WODzNolbx^PR)
zt-rtP6;{VxJ@xnQgLk)ftx%siJ@cSVQx8{+Zghv8iD{d;Tjj%5lD}8o6XoQU3je>A
z|Fd>fmak-aq3eDB&2K)wmI$`9cITK?ydb70{x!eVA?NfhY3U6Sd<Wk+Tv3{G>gS6|
zPckj`rKg+<IL?;tl(+c9_MA^I;y12;etUQM)*q)ij+E9N_$gCw)2V+c!s^kFiQB4G
z)L*V^>AqL8=I_nznObj*@;^*!`RKsYwZ}3~ulPz{SBci01o_46_e#4<PW($Q{brlI
z#<=tFhabAxTjrH?#~5!pwc^RlZ4(y0=f9k|>6p}%8kf*7uK(vPjXJjAh1S8|d=tT)
z`}}UUPcJ@itGw>2RNT7QEasm|yaG4fGezy+1uf>dWE1%1$J{3~I!~lqUX3%YP=8_5
zu&%Q3(&R6z0)=F}rJv@B=0DjTINNpp&m%orzoqVnUiO%*&Zu@MJ2ZFE@0RY9^E3{<
zmr{8%d)?lIm!hWcoR%0z|Ki{FopBkH&#4I!R?{4xpXThj-Rird^YhlezopUsZ|~W^
zwphGxL-C&-A>Vxr()BDBg-Gn;*#F7$>c6Fq$I{YvHNH=O^2~<k)Do`B&Eef$r86X)
W^febZy`SI4ru?w<7stkX;$8rWp#LfW

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.wb.expect b/lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.wb.expect
new file mode 100644
index 0000000000000000000000000000000000000000..09dc798ee37df82176b8b7c9998c88a14207c1ad
GIT binary patch
literal 1005
zcmZR0!7TpgNB6Wc58l=(stxN8{p)?9@LIg><o2WY*k092bU(LazjgnAPVv1n&vScO
zBt7fh<vm0<yqNdNF!G+smguJsI0X$3bwt<1iU{W`ujJjMtGw^#+ftUCnfLz|q&<6g
zbK|_c=E$p88X{+ucRE{~TyJ1BOF`PrHa+ip(L6sz|6>oXRI~IhW&XxGJNu5-<Z_L_
zTas=mJeOac9q4SSzhDw$PO04&)4$Go-<Oo$dNrFXh5LcB=HBnmn{9sI-@ML$iF@eG
zd-~JzWSo84AJyE9_o;a?f%&$<)N4vS?mK+5_o@i4*15hfuj(4d;u$yYie~+qY`~~0
zyQrkiJ8SBThkkrzJ3Uv%FIbjrQ&*=T?7us0(hj{PzdTN_+iA1@vi!rVy-v9w{`BxL
z+;dpn?LOUa#reM5%eoafTdLBY&d_9<`pm*8f%)+)xsVsh4IXozCmZK2NNxUgY*&?Y
zA?w$S%+@)(T+e26OJ3YvU(h<~;+B-AjZcz}+PKM2GL-RiEdTzzeGz}&i%HDcT+dfp
z3*JiW(!5pqFs1i#$d#|}Q`)V+9Qslyyz=FPMQkFgW0y~3xOVtV_*=^?)w5-<c3FK|
zI5qZZ;rTg9^Rj+jHN3bY&A@n7ptx|;%o8FB^L>qSZ%L{t-l@}5O)omdKk4kZYp17o
z8AlWsOqAWPp}d&qWAot?VdWW*n|AFC4-21j_?if-&BpbUPjrRX2mjJvm6z81%lM+=
zYU#o)HMjo$u2)zcclFfYyAR&o+O<M`=Jd>iHcdTTF}l$mb|$86=5Cb_S4sX}bx)L&
zS1SDfR{qc0QCYr{<%O>I{Wrh)_*x>^&f1-0R`G(Ep7_`NR)?I^x1^;vMDQJa<8Vc3
z%Bi0(COyft*q5GiD&RO<x>Mfb58HD-y@=nq{`u|Q<y(K8<~UMXci^W?y-lb7r3kA>
zKPGOgR#AVsuBH24$(p}6w`Xd-G0OiispX>sPuCvHJiX#8d0i!1cM{|mv)?Q2E;;cp
zx%8WD@*3mL!ykU=W^b8S(j8;G<<yENGq+7x_@4iA;-+I#Q)*m7zqtONw>0Y5f)`o`
zd-F{Mckc7M**?Aaysh%Ot5R|6VzZckD)9>3bk7vEe;2fv<C0C_mmhPV%;-FkZh1A%
zv_k!bO~bm%!b_9CtO^v8@s@s?Cz}6cci?Q-`9F{JX#JMDA9~qivO1&Mq3qDyMZa6R
zPtMag^j=Ek&Fpo16JCm%zH?e)9Q})b+jqugOg^V3L|9F8e14j<=XR^_iq6kl`~H?j
z`@g+s|Jq{lz755Hc7%NQF-X_5SQH|$i(~&M%d7vEIvz_)+tv6!{mC;Mo>NP>DmRCB
cca_eNaMIUY-1L5a8=LaO(q9}K?}>W>09POZHvj+t

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.wb.expect-noinput b/lib/std/compress/flate/testdata/block_writer/huffman-rand-1k.wb.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..0c24742fde2487e3a454ec3364f15e541693c37c
GIT binary patch
literal 1054
zcmZQMz-=ML!NBlf=Gmk*#b0<gU%qx`hx3tgIm40^^Zw#w!}Eu)id>x3XF2Ejly8yu
z`nx&Xzoq)cNm}2OnR)*C#Mq4nf%p1N`*q&gFPWxRne|jeI(^G0zYL=fzn<QixNdvW
z)~)xyt_XV0z3AuVh($l<n)H?V{r9uFbVB$`(6JkvxrA;PG)))3vUTAe^@A%H?y~wg
zA#H8=vk7$%)n3Nr9NlBYxObCkPV$4zO)Qrs9iKj_X}Rm6ePx$W&C$c0&Gr8~9u}W1
z&q)0B(K4#})xV!wcjiP2{+u>RSd+=SH^RccWpAo(tm?EUI@?2)bogF*F50Tq`=Xm$
z;PO7^OtC)|`{url?&nz{5IyY?uV7rId~oZ-xRslnu102@JX7kMvfX^$`!=)JyTAYa
zF-4ML^Pm0v3TqZ|tV*ics%Q9JZ=1`u7sZ+@pZgV8<R**Q=<=?4e7k#DdGr-+8~2;G
zAFgRGc4a)PoA=zi@tNdC?(Qy~&zVy7R<}J^SEnyuF#WXe`DtrzM7pog3$1&s-+k)C
znrUtaKWyEfrrEYbljG3O^Zdz0t9HIi-qHO_c<)P2%P*XMC26x&KIz^$+>w|1;<1<A
zglAV7KN{`Q@^ilRW`(X(u#fA>?u%Pg|Gzwc`(kBZ(Y!eeF7MeDuzcBRuD`3loH_Hr
z`pPofYZW?~y{|WX-=k78(;!av<N+;~Fk#;ejWtK#Z}Lk!x*^Y{cYEm^kN?lM?lj>}
zKBH_m!ET$qag<vltB~-#*xFj|Ls#ycm6F-#U$<k*$+wPo-9!1$y_na&eXAI6aKOv&
zBGYs$N~STH750|49`F>^?7w_)jR9l)&%{LUBe_N^HM%7m(#0}bX0Y2AZrgbF?>*(p
zjjsQ9xbg&DH*%O;#$aFjo8k3Zf3+Rwe{aiwv+niX;xZQ|t<J5AtPfv1u*)$Wc1$*6
z(&x?D;S;a_O#bAHNfNv3d`$i?ufJ-LSMkg*{LMU_J!?a)ZhOD8kYU}Uxb$yv$_&2q
z+vo6<{HXY`=JQA1$)ROtp>uvXX};+)yuG3C{=)S4yE1~}Za&uSxLo12=w?id;OC|p
zF1|8$ol0-5UH3LT<$otL>#;?TOBP4Z;rvM<C1Q5>+5G-~`aZ$2@D)E}(f44t!_5n$
zX5M7bz2~-j`F-~p;chbJO&eI*65j-@d3CXL?fRAz5*OaCoj<d|bI1HYAN)Nl{}~*M
z6G;0#yOU?$K|eJgv6In%_L=RePL<^En*QZi=+5ghdo>NL&1Ue=_@rYLxbx&;)+1MC
z(}Ue5wpZL{GdEjxqgHUW!foB{RS_GQZd5L~RB^34UgAZ-D=pbj{TXLJ=AHU~<zt8^
z*SEVO_v5xFf7`E8_wt+lho&T*H?RJD-O+Hp`diavw(E)}vwj~pbKAsp{mJ!gmF<gH
dhy?ANH+!k3aq(`oaNbQGK@7K!Ot1eV4*<5=86yAy

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.dyn.expect b/lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.dyn.expect
new file mode 100644
index 0000000000000000000000000000000000000000..2d6527934e98300d744c7558a025250f67e0f1c9
GIT binary patch
literal 229
zcmZ2;;GkD?0s}*WlJ>9sz`%=+&P^Oz-Az_cTs3x!$hulxS;#lbHBnAWXpzPdZ`Y8f
zk`>M+8ysE;S#wBpSX;FjT{*qXV%uSf+j@D`owd8?GD}_hEXkQSPtEmg#wo=hnVqKp
zC*|drSZc9W%zwP~MzFc8%&7}Ej$O6#;rri`l{&9TywvLbcm9N9vb7tHO)6UI8vje0
zBu=mBsQvor@n5H#|3Y_WYbAGH=`QfsnJu;LLtD@KwQ>bFg-eT*w4X*lpYZ2q?CZc8
mcfKq(5Pe<ECv@Qc8MBQ>-~U}W`l+H+Q!VYa{2pP=1-t<A=4)sG

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.dyn.expect-noinput b/lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.dyn.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..2d6527934e98300d744c7558a025250f67e0f1c9
GIT binary patch
literal 229
zcmZ2;;GkD?0s}*WlJ>9sz`%=+&P^Oz-Az_cTs3x!$hulxS;#lbHBnAWXpzPdZ`Y8f
zk`>M+8ysE;S#wBpSX;FjT{*qXV%uSf+j@D`owd8?GD}_hEXkQSPtEmg#wo=hnVqKp
zC*|drSZc9W%zwP~MzFc8%&7}Ej$O6#;rri`l{&9TywvLbcm9N9vb7tHO)6UI8vje0
zBu=mBsQvor@n5H#|3Y_WYbAGH=`QfsnJu;LLtD@KwQ>bFg-eT*w4X*lpYZ2q?CZc8
mcfKq(5Pe<ECv@Qc8MBQ>-~U}W`l+H+Q!VYa{2pP=1-t<A=4)sG

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.huff.expect b/lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.huff.expect
new file mode 100644
index 0000000000000000000000000000000000000000..57e59322e9884ed96ccace7d6054ca9223128a33
GIT binary patch
literal 252
zcmZSh&cN|Mk$QmZNB6Wc53bfJstxN8{p)?9@LIg><o2WY*k092bU(LazjgnAPVv1n
z&vScOBt7fh<vm0<yqNdNF!G+smguJsI0X$3bwt<1iU{W`ujJaJtGw^#+ftUCnfLz|
zq&<6gbK|_c=E$p88X{+ucRE{~TyJ1BOF`PrHa+ip(L6sz|6>oXRI~IhW&XxGJNu5-
o<Z_L_Tas=mJeOac9q4SSzhDw$PO04&)4$Go-<Oo$dNrF10Faz>$p8QV

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.input b/lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.input
new file mode 100644
index 0000000000..fb5b1be619
--- /dev/null
+++ b/lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.input
@@ -0,0 +1,4 @@
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+ø‹–vH
+…”%€¯Âþ�è ë†É·ÅÞê}‹ç>ÚßÿlsÞÌçm�IGH°èžò1YÞ4´[åà	0ˆ[|]o#©
+¼-#¾Ùíul™ßýpfæîÙ±žnƒYÕÔ€Y˜w‰C8ɯ02š F=gn×ržN!OÆàÔ{�¥ö›kÜ*“w(ý´bÚ ç«kQC9/ ’
lu>ô5ýC.÷¤uÚê›
diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.wb.expect b/lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.wb.expect
new file mode 100644
index 0000000000000000000000000000000000000000..881e59c9ab9bb356c5f1b8f2e188818bd42dbcf0
GIT binary patch
literal 186
zcmeZTBKP3eMccJ!npc;0WgY(I{J$z*V~<$A_0GR9Y`2AP6}o%=?T!4q|K|tSyg&2#
zPMnzM`Kt0t{)@c&&uWc&_M~r8{q>UB&#~EA_M+)Vr9(eYY47~@LhJqRpWCLWra$|;
zpEdLRy}NfT^w(Q{dNsA}gyhq?=fu>nOG}&$nozdc_x$cSlk@%;|KDiVzN)j=d*=R)
y=g#e0Y`Qb%@%w2@qPfmL4NqscihiX(<H(HQtnWv^tlxa^yXw;Iac7?~F#rI5<!Lei

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.wb.expect-noinput b/lib/std/compress/flate/testdata/block_writer/huffman-rand-limit.wb.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..881e59c9ab9bb356c5f1b8f2e188818bd42dbcf0
GIT binary patch
literal 186
zcmeZTBKP3eMccJ!npc;0WgY(I{J$z*V~<$A_0GR9Y`2AP6}o%=?T!4q|K|tSyg&2#
zPMnzM`Kt0t{)@c&&uWc&_M~r8{q>UB&#~EA_M+)Vr9(eYY47~@LhJqRpWCLWra$|;
zpEdLRy}NfT^w(Q{dNsA}gyhq?=fu>nOG}&$nozdc_x$cSlk@%;|KDiVzN)j=d*=R)
y=g#e0Y`Qb%@%w2@qPfmL4NqscihiX(<H(HQtnWv^tlxa^yXw;Iac7?~F#rI5<!Lei

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-rand-max.huff.expect b/lib/std/compress/flate/testdata/block_writer/huffman-rand-max.huff.expect
new file mode 100644
index 0000000000000000000000000000000000000000..47d53c89c077d0e62aeaf818154f60921960de5c
GIT binary patch
literal 65540
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
Jhu=S$2>_ICS`GjJ

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-rand-max.input b/lib/std/compress/flate/testdata/block_writer/huffman-rand-max.input
new file mode 100644
index 0000000000000000000000000000000000000000..8418633d2ac9791cc75a316d53c8490a328daa39
GIT binary patch
literal 65535
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
E0C9|15C8xG

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-shifts.dyn.expect b/lib/std/compress/flate/testdata/block_writer/huffman-shifts.dyn.expect
new file mode 100644
index 0000000000000000000000000000000000000000..7812c1c62da3cbaeb6399e9aa8ab65ae7efa9b08
GIT binary patch
literal 32
ocmaEJ(2|$IfP>+{UeCQBetd7^G}D{T$iTpm^J~2nL&Iw}0NYm#xc~qF

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-shifts.dyn.expect-noinput b/lib/std/compress/flate/testdata/block_writer/huffman-shifts.dyn.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..7812c1c62da3cbaeb6399e9aa8ab65ae7efa9b08
GIT binary patch
literal 32
ocmaEJ(2|$IfP>+{UeCQBetd7^G}D{T$iTpm^J~2nL&Iw}0NYm#xc~qF

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-shifts.huff.expect b/lib/std/compress/flate/testdata/block_writer/huffman-shifts.huff.expect
new file mode 100644
index 0000000000000000000000000000000000000000..f5133778e1c783a6da12f76fec3f04014c77694e
GIT binary patch
literal 1812
zcmZQM;K<8hAkcE4esWdg(f!+{1xLYX2#kinFbsi-|F1=5uiZLIjE2EzI>3_+tN@OD
BEKdLc

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-shifts.input b/lib/std/compress/flate/testdata/block_writer/huffman-shifts.input
new file mode 100644
index 0000000000..7c7a50d158
--- /dev/null
+++ b/lib/std/compress/flate/testdata/block_writer/huffman-shifts.input
@@ -0,0 +1,2 @@
+101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010
+232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323232323
\ No newline at end of file
diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-shifts.wb.expect b/lib/std/compress/flate/testdata/block_writer/huffman-shifts.wb.expect
new file mode 100644
index 0000000000000000000000000000000000000000..7812c1c62da3cbaeb6399e9aa8ab65ae7efa9b08
GIT binary patch
literal 32
ocmaEJ(2|$IfP>+{UeCQBetd7^G}D{T$iTpm^J~2nL&Iw}0NYm#xc~qF

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-shifts.wb.expect-noinput b/lib/std/compress/flate/testdata/block_writer/huffman-shifts.wb.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..7812c1c62da3cbaeb6399e9aa8ab65ae7efa9b08
GIT binary patch
literal 32
ocmaEJ(2|$IfP>+{UeCQBetd7^G}D{T$iTpm^J~2nL&Iw}0NYm#xc~qF

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-text-shift.dyn.expect b/lib/std/compress/flate/testdata/block_writer/huffman-text-shift.dyn.expect
new file mode 100644
index 0000000000000000000000000000000000000000..71ce3aeb75a86e8375d9ac4350b7d83b9229a3ed
GIT binary patch
literal 231
zcmb0+_15dNfyA+o=eeIK%(Kyu&3PH1rNQ%Zm(}v(eI>z;E*W04HmH<ymY-TxVJ6q<
zu6B3(>tCO{AM?yQ_d4p~$&{jff!rR<S|4mopH0}CukGh4lkd3blE5B;fR|EH?^kV_
zE&AE8Y#F;7cRN?Bwkk__W_#AwGoMN)dgofGPBBRekAC}WWiGRv<c5DI9<*H5ld20e
z%BZ#6y8Ff3y>ALirl~AHIbl+xOl^!$W4fI3vZg85dSeaJa=yn{mkInin%#3sQT6_m
qC7W~R#p|w{ZoYl>?yr9jKMvk_({BH}-RJAy{C|J`Vqwk6e+&Sr#&hNX

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-text-shift.dyn.expect-noinput b/lib/std/compress/flate/testdata/block_writer/huffman-text-shift.dyn.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..71ce3aeb75a86e8375d9ac4350b7d83b9229a3ed
GIT binary patch
literal 231
zcmb0+_15dNfyA+o=eeIK%(Kyu&3PH1rNQ%Zm(}v(eI>z;E*W04HmH<ymY-TxVJ6q<
zu6B3(>tCO{AM?yQ_d4p~$&{jff!rR<S|4mopH0}CukGh4lkd3blE5B;fR|EH?^kV_
zE&AE8Y#F;7cRN?Bwkk__W_#AwGoMN)dgofGPBBRekAC}WWiGRv<c5DI9<*H5ld20e
z%BZ#6y8Ff3y>ALirl~AHIbl+xOl^!$W4fI3vZg85dSeaJa=yn{mkInin%#3sQT6_m
qC7W~R#p|w{ZoYl>?yr9jKMvk_({BH}-RJAy{C|J`Vqwk6e+&Sr#&hNX

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-text-shift.huff.expect b/lib/std/compress/flate/testdata/block_writer/huffman-text-shift.huff.expect
new file mode 100644
index 0000000000000000000000000000000000000000..ff023114bbc8f62921df38438fbb0c415f04f220
GIT binary patch
literal 231
zcmZQM@Y~DCQH0^ce%k`MN4NWv#7o?`nwdCb&+2UMj&gL_u=&ingF8<YxZPQ_{iSEs
zrn;bMiPzn-c;<ik{XE;4d+`x97sE|vLCF@!YIOyc++jJ}=G5iYI&0R3{(b9ieayP_
z_?nVOre~$unwq7~pG+&wx+^VX*Dag1#=+sn%G}2%locl2ZaoosLO`J8)2WH)yY*Yn
z*@Zc8KYRb)>S?>vn-9KR;PB$byW>X<I*f|u&0Mnev+evfZ+A8;%opX5)s0gsj1%R!
s&#}1Ba%SAwb<fSWckh1s_weJ(S$iw%Y`4t+zv=&ed-vm?jD9l%09$-`ZvX%Q

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-text-shift.input b/lib/std/compress/flate/testdata/block_writer/huffman-text-shift.input
new file mode 100644
index 0000000000..cc5c3ad69d
--- /dev/null
+++ b/lib/std/compress/flate/testdata/block_writer/huffman-text-shift.input
@@ -0,0 +1,14 @@
+//Copyright2009ThGoAuthor.Allrightrrvd.
+//UofthiourccodigovrndbyBSD-tyl
+//licnthtcnbfoundinthLICENSEfil.
+
+pckgmin
+
+import"o"
+
+funcmin(){
+	vrb=mk([]byt,65535)
+	f,_:=o.Crt("huffmn-null-mx.in")
+	f.Writ(b)
+}
+ABCDEFGHIJKLMNOPQRSTUVXxyz!"#¤%&/?"
\ No newline at end of file
diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-text-shift.wb.expect b/lib/std/compress/flate/testdata/block_writer/huffman-text-shift.wb.expect
new file mode 100644
index 0000000000000000000000000000000000000000..71ce3aeb75a86e8375d9ac4350b7d83b9229a3ed
GIT binary patch
literal 231
zcmb0+_15dNfyA+o=eeIK%(Kyu&3PH1rNQ%Zm(}v(eI>z;E*W04HmH<ymY-TxVJ6q<
zu6B3(>tCO{AM?yQ_d4p~$&{jff!rR<S|4mopH0}CukGh4lkd3blE5B;fR|EH?^kV_
zE&AE8Y#F;7cRN?Bwkk__W_#AwGoMN)dgofGPBBRekAC}WWiGRv<c5DI9<*H5ld20e
z%BZ#6y8Ff3y>ALirl~AHIbl+xOl^!$W4fI3vZg85dSeaJa=yn{mkInin%#3sQT6_m
qC7W~R#p|w{ZoYl>?yr9jKMvk_({BH}-RJAy{C|J`Vqwk6e+&Sr#&hNX

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-text-shift.wb.expect-noinput b/lib/std/compress/flate/testdata/block_writer/huffman-text-shift.wb.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..71ce3aeb75a86e8375d9ac4350b7d83b9229a3ed
GIT binary patch
literal 231
zcmb0+_15dNfyA+o=eeIK%(Kyu&3PH1rNQ%Zm(}v(eI>z;E*W04HmH<ymY-TxVJ6q<
zu6B3(>tCO{AM?yQ_d4p~$&{jff!rR<S|4mopH0}CukGh4lkd3blE5B;fR|EH?^kV_
zE&AE8Y#F;7cRN?Bwkk__W_#AwGoMN)dgofGPBBRekAC}WWiGRv<c5DI9<*H5ld20e
z%BZ#6y8Ff3y>ALirl~AHIbl+xOl^!$W4fI3vZg85dSeaJa=yn{mkInin%#3sQT6_m
qC7W~R#p|w{ZoYl>?yr9jKMvk_({BH}-RJAy{C|J`Vqwk6e+&Sr#&hNX

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-text.dyn.expect b/lib/std/compress/flate/testdata/block_writer/huffman-text.dyn.expect
new file mode 100644
index 0000000000000000000000000000000000000000..fbffc3f36b78cc48e8c3a33f97fa86f1d0a52272
GIT binary patch
literal 217
zcmcENyO_1bK%n*gXOZXMwe<e?MV^}0#PQZQJ}J`6WOAOuF;%y_VKv_uO*?lq=8SpG
za}m~kch%io)m^<rSZAHEGBjE9d5_+Cw#nY+E82q=y>yy?LA{x4{kpy7h9}qftDW{%
zeCNz7eIZLcrLR8uIZqlR!{WXbfe(vz@#$}lDzJF)v!>2!y7axZVxmERqTZ%dXQ?R{
z-}=4B`g~D!tom-=Yul`34nO$2@hX3j;_v_MnQX4t(k}D%q`Lo{mwKb9W$CeU+tXXW
bRsH>OcAJUo^dD!dBjZIbn(7}_s$&2E8a`?5

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-text.dyn.expect-noinput b/lib/std/compress/flate/testdata/block_writer/huffman-text.dyn.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..fbffc3f36b78cc48e8c3a33f97fa86f1d0a52272
GIT binary patch
literal 217
zcmcENyO_1bK%n*gXOZXMwe<e?MV^}0#PQZQJ}J`6WOAOuF;%y_VKv_uO*?lq=8SpG
za}m~kch%io)m^<rSZAHEGBjE9d5_+Cw#nY+E82q=y>yy?LA{x4{kpy7h9}qftDW{%
zeCNz7eIZLcrLR8uIZqlR!{WXbfe(vz@#$}lDzJF)v!>2!y7axZVxmERqTZ%dXQ?R{
z-}=4B`g~D!tom-=Yul`34nO$2@hX3j;_v_MnQX4t(k}D%q`Lo{mwKb9W$CeU+tXXW
bRsH>OcAJUo^dD!dBjZIbn(7}_s$&2E8a`?5

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-text.huff.expect b/lib/std/compress/flate/testdata/block_writer/huffman-text.huff.expect
new file mode 100644
index 0000000000000000000000000000000000000000..46fa51fdad7c4186a2cbe48866d511bdf6fb75ea
GIT binary patch
literal 219
zcmZQMaJTD`fkeZ@&+oPFy$#f!<t8@0HRy)z%-I5xNt1gTO{S`RO+QjSfBE~LeDQa-
z+{#|M^!?0D##a+RC|cEYT#S6TFzy2X+SI6^l~b}Le~LeQJt_P4l&sl#0z22G*Cd%K
zZk64i=e=PM%Y!tdbhp0Wmw$a<dOyePkEKkVJR9STX(3wkCeE5aC2OjF)~?&zf`iMJ
z?dlhZ)n;HgoBFlREOYubiSo^rD<;fZ%fPTgT+2FHa%E-dp6yH*c$pIBmP@W*wnOB4
eSu@80b!AigkFVxAm;O)AIq$yq%1Y@cy7mACx@-0T

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-text.input b/lib/std/compress/flate/testdata/block_writer/huffman-text.input
new file mode 100644
index 0000000000..df97174253
--- /dev/null
+++ b/lib/std/compress/flate/testdata/block_writer/huffman-text.input
@@ -0,0 +1,14 @@
+// zig v0.10.0
+// create a file filled with 0x00
+const std = @import("std");
+
+pub fn main() !void {
+    var b = [1]u8{0} ** 65535;
+    const f = try std.fs.cwd().createFile(
+        "huffman-null-max.in",
+        .{ .read = true },
+    );
+    defer f.close();
+
+    _ = try f.writeAll(b[0..]);
+}
diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-text.wb.expect b/lib/std/compress/flate/testdata/block_writer/huffman-text.wb.expect
new file mode 100644
index 0000000000000000000000000000000000000000..fbffc3f36b78cc48e8c3a33f97fa86f1d0a52272
GIT binary patch
literal 217
zcmcENyO_1bK%n*gXOZXMwe<e?MV^}0#PQZQJ}J`6WOAOuF;%y_VKv_uO*?lq=8SpG
za}m~kch%io)m^<rSZAHEGBjE9d5_+Cw#nY+E82q=y>yy?LA{x4{kpy7h9}qftDW{%
zeCNz7eIZLcrLR8uIZqlR!{WXbfe(vz@#$}lDzJF)v!>2!y7axZVxmERqTZ%dXQ?R{
z-}=4B`g~D!tom-=Yul`34nO$2@hX3j;_v_MnQX4t(k}D%q`Lo{mwKb9W$CeU+tXXW
bRsH>OcAJUo^dD!dBjZIbn(7}_s$&2E8a`?5

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-text.wb.expect-noinput b/lib/std/compress/flate/testdata/block_writer/huffman-text.wb.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..fbffc3f36b78cc48e8c3a33f97fa86f1d0a52272
GIT binary patch
literal 217
zcmcENyO_1bK%n*gXOZXMwe<e?MV^}0#PQZQJ}J`6WOAOuF;%y_VKv_uO*?lq=8SpG
za}m~kch%io)m^<rSZAHEGBjE9d5_+Cw#nY+E82q=y>yy?LA{x4{kpy7h9}qftDW{%
zeCNz7eIZLcrLR8uIZqlR!{WXbfe(vz@#$}lDzJF)v!>2!y7axZVxmERqTZ%dXQ?R{
z-}=4B`g~D!tom-=Yul`34nO$2@hX3j;_v_MnQX4t(k}D%q`Lo{mwKb9W$CeU+tXXW
bRsH>OcAJUo^dD!dBjZIbn(7}_s$&2E8a`?5

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-zero.dyn.expect b/lib/std/compress/flate/testdata/block_writer/huffman-zero.dyn.expect
new file mode 100644
index 0000000000000000000000000000000000000000..830348a79ad9ab38d0edc449e8335c056f7d185f
GIT binary patch
literal 17
ZcmaEJU?T$q14Dzs(myYgUgYZt0{}&k2ao^&

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-zero.dyn.expect-noinput b/lib/std/compress/flate/testdata/block_writer/huffman-zero.dyn.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..830348a79ad9ab38d0edc449e8335c056f7d185f
GIT binary patch
literal 17
ZcmaEJU?T$q14Dzs(myYgUgYZt0{}&k2ao^&

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-zero.huff.expect b/lib/std/compress/flate/testdata/block_writer/huffman-zero.huff.expect
new file mode 100644
index 0000000000000000000000000000000000000000..5abdbaff9a69ad9c71178ba3641fa548818c9030
GIT binary patch
literal 51
VcmZQM(8vG+6IB0~f@s3n0RWiM1Frx8

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-zero.input b/lib/std/compress/flate/testdata/block_writer/huffman-zero.input
new file mode 100644
index 0000000000..349be0e6ec
--- /dev/null
+++ b/lib/std/compress/flate/testdata/block_writer/huffman-zero.input
@@ -0,0 +1 @@
+00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
\ No newline at end of file
diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-zero.wb.expect b/lib/std/compress/flate/testdata/block_writer/huffman-zero.wb.expect
new file mode 100644
index 0000000000000000000000000000000000000000..dbe401c54c4b6f45f3169376185a476dcf00dde9
GIT binary patch
literal 6
NcmXq#U{zse0006o0CxZY

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/huffman-zero.wb.expect-noinput b/lib/std/compress/flate/testdata/block_writer/huffman-zero.wb.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..dbe401c54c4b6f45f3169376185a476dcf00dde9
GIT binary patch
literal 6
NcmXq#U{zse0006o0CxZY

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/null-long-match.dyn.expect-noinput b/lib/std/compress/flate/testdata/block_writer/null-long-match.dyn.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..8b92d9fc20f1ee1fea5e4cc84d18aeea26a6fdaa
GIT binary patch
literal 206
bcmaEJz>txFf#HzC@8#d3xFr~dG<X64i{A#i

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/block_writer/null-long-match.wb.expect-noinput b/lib/std/compress/flate/testdata/block_writer/null-long-match.wb.expect-noinput
new file mode 100644
index 0000000000000000000000000000000000000000..8b92d9fc20f1ee1fea5e4cc84d18aeea26a6fdaa
GIT binary patch
literal 206
bcmaEJz>txFf#HzC@8#d3xFr~dG<X64i{A#i

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/deflate-stream.expect b/lib/std/compress/flate/testdata/fuzz/deflate-stream.expect
new file mode 100644
index 0000000000..ab73c04108
--- /dev/null
+++ b/lib/std/compress/flate/testdata/fuzz/deflate-stream.expect
@@ -0,0 +1,22 @@
+[
+    { id: "brieflz",
+      name: "BriefLZ",
+      libraryUrl: "https://github.com/jibsen/brieflz",
+      license: "MIT",
+      revision: "bcaa6a1ee7ccf005512b5c23aa92b40cf75f9ed1",
+      codecs: [ { name: "brieflz" } ], },
+    { id: "brotli",
+      name: "Brotli",
+      libraryUrl: "https://github.com/google/brotli",
+      license: "Apache 2.0",
+      revision: "1dd66ef114fd244778d9dcb5da09c28b49a0df33",
+      codecs: [ { name: "brotli",
+		  levels: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+		  streaming: true } ], },
+    { id: "bsc",
+      name: "bsc",
+      libraryUrl: "http://libbsc.com/",
+      license: "Apache 2.0",
+      revision: "b2b07421381b19b2fada8b291f3cdead10578abc",
+      codecs: [ { name: "bsc" } ] }
+]
diff --git a/lib/std/compress/flate/testdata/fuzz/deflate-stream.input b/lib/std/compress/flate/testdata/fuzz/deflate-stream.input
new file mode 100644
index 0000000000..a0ed06f872
--- /dev/null
+++ b/lib/std/compress/flate/testdata/fuzz/deflate-stream.input
@@ -0,0 +1,3 @@
+•�=oÂ0†çò+Ṉ�„ÄÙÚ­R»µKƒ}>W!AI@j+þ{
+¨|ˆª–¼<çóÝóÎFÎx[ÀØ´ž\õ9f;Pë%ü0৷#®¼iuûñÚV¡¸èûUWDQéûÅÚL°YFïÞtTGç¿U©î†Ÿ_Ž´¥�ï|SãQë©D¢ã<M…4)ÊXk%MÂÑe©SdűKØ0û]Cas[vª×ô•¿´;¡É•MSV™ó®ƒÛýJã‚@Nø5EaítJNˆÄY™$Y–[eѤVs…27‰Òܺ8¾­¸}wÓ†ª¡.H1ƒ„AÊ`Ê c�3PW̺¾%½ôuY@ß®éjNž‡ô]$
+,<ÙôïLŒ4<K¤ˆsa„2Òi«s#•p1ZÒVð4˵Á›™„ýØŽæ£o
\ No newline at end of file
diff --git a/lib/std/compress/flate/testdata/fuzz/empty-distance-alphabet01.input b/lib/std/compress/flate/testdata/fuzz/empty-distance-alphabet01.input
new file mode 100644
index 0000000000000000000000000000000000000000..9cd29e157f1c4346a5d6d3f9811cf8b36a5f4246
GIT binary patch
literal 12
TcmZR5z{ttKz`!67vtJJY4MPG+

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/empty-distance-alphabet02.input b/lib/std/compress/flate/testdata/fuzz/empty-distance-alphabet02.input
new file mode 100644
index 0000000000000000000000000000000000000000..32a51d3180bb3430260b85ccc15fffc005033257
GIT binary patch
literal 13
UcmWfAz{ttKz`!67vtQ2u01%7<i2wiq

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/end-of-stream.input b/lib/std/compress/flate/testdata/fuzz/end-of-stream.input
new file mode 100644
index 0000000000..05e05dc014
--- /dev/null
+++ b/lib/std/compress/flate/testdata/fuzz/end-of-stream.input
@@ -0,0 +1 @@
+•�=oÂ0†ó0
\ No newline at end of file
diff --git a/lib/std/compress/flate/testdata/fuzz/fuzz1.input b/lib/std/compress/flate/testdata/fuzz/fuzz1.input
new file mode 100644
index 0000000000000000000000000000000000000000..6854c5c0a23b511506e4fe7a7d3370e4b5e0450f
GIT binary patch
literal 60
xcmewpR@`c2-f7->>CP^TeQS5f*OrU3U1nfl;AmU5P*1{x&9IpPMG7Iz1ppI)7tH_w

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/fuzz2.input b/lib/std/compress/flate/testdata/fuzz/fuzz2.input
new file mode 100644
index 0000000000000000000000000000000000000000..e54aafb161219c58d88a5001036e8b7185d98c95
GIT binary patch
literal 56
ocmd=3%J|{`|Nr0r|7T%kVPR2W0ReUvR6bmS<-a_`ACL+L02inY?*IS*

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/fuzz3.input b/lib/std/compress/flate/testdata/fuzz/fuzz3.input
new file mode 100644
index 0000000000000000000000000000000000000000..5b7c08ddf2c0c10dcf6d409fd219e1b68fe80f9a
GIT binary patch
literal 8
Pcmd;P@Z@&z<Yxo`1V;e*

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/fuzz4.input b/lib/std/compress/flate/testdata/fuzz/fuzz4.input
new file mode 100644
index 0000000000000000000000000000000000000000..520c9543fcef253e1938ab91d84451a614f63df8
GIT binary patch
literal 20
ZcmXr<@$&QZ^=4;a_^+q;Uk?QS0{}Wk20#D+

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/invalid-distance.input b/lib/std/compress/flate/testdata/fuzz/invalid-distance.input
new file mode 100644
index 0000000000000000000000000000000000000000..fd05e4165377eed3169237659d3ed35267f79692
GIT binary patch
literal 6
NcmXReDPl`x000M=0l@$O

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/invalid-tree01.input b/lib/std/compress/flate/testdata/fuzz/invalid-tree01.input
new file mode 100644
index 0000000000..2a6b1952bf
--- /dev/null
+++ b/lib/std/compress/flate/testdata/fuzz/invalid-tree01.input
@@ -0,0 +1 @@
+000
\ No newline at end of file
diff --git a/lib/std/compress/flate/testdata/fuzz/invalid-tree02.input b/lib/std/compress/flate/testdata/fuzz/invalid-tree02.input
new file mode 100644
index 0000000000000000000000000000000000000000..a4725951a278a73da4a293fed95364aef52fa621
GIT binary patch
literal 14
VcmZR5#mLFPz`)25vtN&s0RR#Z0!;t_

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/invalid-tree03.input b/lib/std/compress/flate/testdata/fuzz/invalid-tree03.input
new file mode 100644
index 0000000000000000000000000000000000000000..a6b335a1054b4aae8fbe34193c2e1c6b51163f57
GIT binary patch
literal 12
TcmZR5!05=pz`!67vtJJY4?6;Z

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/lengths-overflow.input b/lib/std/compress/flate/testdata/fuzz/lengths-overflow.input
new file mode 100644
index 0000000000..af0620e4b3
--- /dev/null
+++ b/lib/std/compress/flate/testdata/fuzz/lengths-overflow.input
@@ -0,0 +1 @@
+í$éÿÿ9
\ No newline at end of file
diff --git a/lib/std/compress/flate/testdata/fuzz/out-of-codes.input b/lib/std/compress/flate/testdata/fuzz/out-of-codes.input
new file mode 100644
index 0000000000000000000000000000000000000000..86c8c7be0299570b0ad83db7b0f62b50b42173d0
GIT binary patch
literal 9
NcmbPgz`$St0ssk?0k!}D

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff01.input b/lib/std/compress/flate/testdata/fuzz/puff01.input
new file mode 100644
index 0000000000000000000000000000000000000000..40b450dd9d8187f90cf9f13a80c3ded26f8ecfd7
GIT binary patch
literal 5
JcmZPo0RR9600961

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff02.input b/lib/std/compress/flate/testdata/fuzz/puff02.input
new file mode 100644
index 0000000000000000000000000000000000000000..8aed0c90bd93dedd3428d60464830cfd4f21652c
GIT binary patch
literal 5
McmZQzWcc?V00RU8{{R30

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff03.input b/lib/std/compress/flate/testdata/fuzz/puff03.input
new file mode 100644
index 0000000000000000000000000000000000000000..3e5998658d5de876896345ce22533d46026f9efb
GIT binary patch
literal 6
NcmZQ%Wcc@=3jhTZ0tx^C

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff04.input b/lib/std/compress/flate/testdata/fuzz/puff04.input
new file mode 100644
index 0000000000..843dc9c1d1
--- /dev/null
+++ b/lib/std/compress/flate/testdata/fuzz/puff04.input
@@ -0,0 +1 @@
+~ÿÿ
\ No newline at end of file
diff --git a/lib/std/compress/flate/testdata/fuzz/puff05.input b/lib/std/compress/flate/testdata/fuzz/puff05.input
new file mode 100644
index 0000000000..25cb955ba2
--- /dev/null
+++ b/lib/std/compress/flate/testdata/fuzz/puff05.input
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/lib/std/compress/flate/testdata/fuzz/puff06.input b/lib/std/compress/flate/testdata/fuzz/puff06.input
new file mode 100644
index 0000000000..5750c4837b
--- /dev/null
+++ b/lib/std/compress/flate/testdata/fuzz/puff06.input
@@ -0,0 +1 @@
+€I’$I’$´ÿÿÃ
\ No newline at end of file
diff --git a/lib/std/compress/flate/testdata/fuzz/puff07.input b/lib/std/compress/flate/testdata/fuzz/puff07.input
new file mode 100644
index 0000000000000000000000000000000000000000..de6786f0d2425f81d9d3a744f2b32913b5202748
GIT binary patch
literal 14
VcmZQ+@SLRLIZ37P|NqH?3;-u}1(pB+

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff08.input b/lib/std/compress/flate/testdata/fuzz/puff08.input
new file mode 100644
index 0000000000000000000000000000000000000000..19402ac49f55b9957413e18d342401bb9faeae9e
GIT binary patch
literal 14
VcmZQM(8$5Sz`&qT|C*bD0RR_r0^<Mx

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff09.input b/lib/std/compress/flate/testdata/fuzz/puff09.input
new file mode 100644
index 0000000000000000000000000000000000000000..ef731eb5e7ebc3247c5522710fa35b58c9ffc496
GIT binary patch
literal 3
Kcmd;PU;qFBBmfKm

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff10.input b/lib/std/compress/flate/testdata/fuzz/puff10.input
new file mode 100644
index 0000000000..bb26068639
--- /dev/null
+++ b/lib/std/compress/flate/testdata/fuzz/puff10.input
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/lib/std/compress/flate/testdata/fuzz/puff11.input b/lib/std/compress/flate/testdata/fuzz/puff11.input
new file mode 100644
index 0000000000000000000000000000000000000000..138da04b6156677bc588548efb768ac0a2b3561b
GIT binary patch
literal 12
Rcmd-%(8vG+6aHtj000yH155w_

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff12.input b/lib/std/compress/flate/testdata/fuzz/puff12.input
new file mode 100644
index 0000000000000000000000000000000000000000..cb896978fb1471b9ea98014ba6accb9b302176ee
GIT binary patch
literal 3
KcmeyvzyJUO_W=C>

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff13.input b/lib/std/compress/flate/testdata/fuzz/puff13.input
new file mode 100644
index 0000000000000000000000000000000000000000..644f6437a1eb9d9184cd13579f2470f296c96906
GIT binary patch
literal 4
LcmZQ!`1c<G0}lcM

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff14.input b/lib/std/compress/flate/testdata/fuzz/puff14.input
new file mode 100644
index 0000000000000000000000000000000000000000..e532a74ff78c8d587f4c1ed63938380d041ba059
GIT binary patch
literal 4
LcmZQ!Q1Ju+0HpwO

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff15.input b/lib/std/compress/flate/testdata/fuzz/puff15.input
new file mode 100644
index 0000000000..f2d7e2529c
--- /dev/null
+++ b/lib/std/compress/flate/testdata/fuzz/puff15.input
@@ -0,0 +1 @@
+€I’$I’$´ÿÿÄ
\ No newline at end of file
diff --git a/lib/std/compress/flate/testdata/fuzz/puff16.input b/lib/std/compress/flate/testdata/fuzz/puff16.input
new file mode 100644
index 0000000000000000000000000000000000000000..12d281499e811d28e4b0d370593fa1b02b7660fb
GIT binary patch
literal 6
NcmZQ!P<i?PKL7@10}ucJ

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff17.input b/lib/std/compress/flate/testdata/fuzz/puff17.input
new file mode 100644
index 0000000000000000000000000000000000000000..3f801b25c599801873f5fb3e2820a8def0db5028
GIT binary patch
literal 6
NcmZQ!P<i=37XSs+0)7Ah

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff18.input b/lib/std/compress/flate/testdata/fuzz/puff18.input
new file mode 100644
index 0000000000000000000000000000000000000000..0621183f94ee69af6cee99b9d66ed807a27b3a21
GIT binary patch
literal 52
jcmd-%+sM$sz`!u!e>MZd=d+CrZ?ORem<k4l|NmJ41q>a7

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff19.input b/lib/std/compress/flate/testdata/fuzz/puff19.input
new file mode 100644
index 0000000000000000000000000000000000000000..131352affca8a5b9af5de48252b6d606a5de2333
GIT binary patch
literal 65
jcmd-*+sFU{6aHs2Fz~=RAO8Ob3E-5GWMKFY!v9$SzmFFM

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff20.input b/lib/std/compress/flate/testdata/fuzz/puff20.input
new file mode 100644
index 0000000000000000000000000000000000000000..9589f19c57e238d7575ca5e31f682de5831555c0
GIT binary patch
literal 12
TcmZR5z{n}Vz`!67vtJJY4g&&V

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff21.input b/lib/std/compress/flate/testdata/fuzz/puff21.input
new file mode 100644
index 0000000000000000000000000000000000000000..1d115a3bbf3dea8716571aaa9d8c4e1ca9dabd77
GIT binary patch
literal 64
zcmaFM&CSivAgl87KQ}ic<3C1521YPoU=VTuF&Y@bq97(CBVz*tHwf@?GaLj1Zf*cp
C-3ze*

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff22.input b/lib/std/compress/flate/testdata/fuzz/puff22.input
new file mode 100644
index 0000000000000000000000000000000000000000..71f0e31c3cc3f84be34b0b25674b59af4a215362
GIT binary patch
literal 142
zcmaFM&8^4Hz`(%3&B(yW%)r3N_>Yl6Kt`edH8;zFMg|6Cb^~6(Ai#(W7#J8*xVgEx
cxVb?lgJu4KNf03pvXC1J__!Gkf&n)-03eDUWB>pF

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff23.input b/lib/std/compress/flate/testdata/fuzz/puff23.input
new file mode 100644
index 0000000000000000000000000000000000000000..ff48a74c3893a1793ec50ffcff6c02f6f5eaf4b3
GIT binary patch
literal 404
zcmbO_!8ZSpfk4~yPuhNG#5T@tIdb#X+MwNAy#<?V?byQ=9X%bgwEsCc@iWwPteUpR
z=K1HlpU=4ooD;8zKESwTUd&g^G;5B4*Q%_43?3}st_%h1_GFg+{&<Ulk>THehJ_#?
ztMdQ<e^XP_Q>Lb7rZ6D-fRWSkT^s*=`S`vqOMBnf1oJ-*e7#c4MRL(&8{bwF%~KKC
zs=kLVrmhT5Il56?+WUs60XNg{SbpbR?qas+GMwPcd!HT?8}B6@#fdFOmom%B%2r+f
zGIjqJ>xK0vr}_qmiOl@GuKD&~ug6Ueem_iI6W^A2`E?wLoT(ByEjso5lCa`dBlFHn
zcXnFrTf0NPwp^U;GAI<PWw}<sLP1_$UOtG;u(`$YRKh8R<O#+BJS_a-XX>SP?Ni<R
zr8Lsv{<@c0ezNo0zevZbh%hlQFmSM<xoUN>^3(#us7qlVOiph-ID2NxUpCPjea{x>
F0|4kTw!#1a

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff24.input b/lib/std/compress/flate/testdata/fuzz/puff24.input
new file mode 100644
index 0000000000000000000000000000000000000000..c0373b24a895a817f303dae0fc9844ce69280165
GIT binary patch
literal 68
zcma#bjRFHE21bT||Ldksu+2YYAkg;wleXU(v5j+Ej@*3v|Gzu~Hv}*;{AUD#zpp?f
K2s1D+H~;{S%oXVX

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff25.input b/lib/std/compress/flate/testdata/fuzz/puff25.input
new file mode 100644
index 0000000000000000000000000000000000000000..4422bcad42dd82b33a2f0039ee8a30adef43e377
GIT binary patch
literal 64
scmaFM&8@@D&A|-<j0}um@DEHP5ey(%uqr-ohJyzWLdb&$4{~z@0M4HZ3jhEB

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff26.input b/lib/std/compress/flate/testdata/fuzz/puff26.input
new file mode 100644
index 0000000000000000000000000000000000000000..23ddec41b54c3733d61c1266103a93828caf3622
GIT binary patch
literal 346
zcmbO_!8ZSpfk4~yPuhNG#5OW8FfiU)8?<|?w_tOv9ecQ<qo+fb_P=Ubt`#*MtETO-
zdH(tC=W}iX=fo?b58T)?FXpRdnjA;KYgN`i1`n2RS6;U#v-J1JTVV^sT>@YJK6=Y%
zL!?^<!$J^{Rr&w_zp1I|DN|E3Qy36^z{qL&u8n`be0<-QrM>TKg83f@zFsNjBDv_X
zjc==o=BbEmRo_EfQdjz<9Nj1`?R`VkfSc)eEWdLicQIRZ83ZseKxkBQ)%7n^_iwRY
zSbuV=Z*Z8%%+KqZZ%;x6Z)H_fBBw>CUR)AZ+-hXrX&k`A!XJL7UTW7q)xBRzogMD4
zdzs}YJFoqVbgYU96PJ$7P1Y~(eR@o6yq9zoC$<<}%3NKnJhi|u>QdMTlha!d&Ys!w
Mmre9W-?PQ}0G{2R#sB~S

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/puff27.input b/lib/std/compress/flate/testdata/fuzz/puff27.input
new file mode 100644
index 0000000000000000000000000000000000000000..f323679da3eebc1d0d231a7265969d13d7fc9368
GIT binary patch
literal 49
ocmaEJrjY>zCj8H4VBk5+z{v3Le;t^7zzAYLK$2!)`2U&(0J`iEuK)l5

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/roundtrip1.input b/lib/std/compress/flate/testdata/fuzz/roundtrip1.input
new file mode 100644
index 0000000000000000000000000000000000000000..4e3353d0fa1310e59fc8407c907a440e7238840f
GIT binary patch
literal 370
zcmbO_!8ZSpfk4~yPuhNG#5T@tIdb#X+MwNAy#<?V?byQ=9X%bgwEtDha;>Q8ST${r
z&GXN9Kc90GI452aec;BHc`;vEA24z<FfcF(#Oz<bU3uM}%+lW<Z_WI?uK9LoxJ%&6
z-$!rxY>0Gwf3GCO{rUb-xs~tQ_~*;V_ib6)`@SZa|8d~!m0~WEiyqtfwwh?3ipW;=
zJ#;a3WpK*TjpEYYH$)A%nSRIeCns_jvqevfPQAD!thm+4yz|nXT^9S+?vSr77iYWN
zwrZiCga=#Ms_S2-?%!fv_kUsi$*I1<VIp8x{PlX=<ly(i)HU&KiI-o;k;s`UkpxUK
zY;JJ`d5M96LE%)wDTU+-#sNGm{NZQnrFQL8-TS39(&2vn%Pc?HdF@}MV^u_$xO8l8
wvVM8*(_>=ey`-Z!vBl_8=IUbQsRf2nm%=`noZfnH_RN;QY@#>%o-NJ?0E<PfM*si-

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/fuzz/roundtrip2.input b/lib/std/compress/flate/testdata/fuzz/roundtrip2.input
new file mode 100644
index 0000000000000000000000000000000000000000..26216d59c0b46c9f0dfd0de674bb2ed40bcb6888
GIT binary patch
literal 371
zcmbO_!8ZSpfk4~yPuhNG#5T@tIdb#X+MwNAy#<?V?byQ=9X%bgwEtDha;>Q8ST${r
z&GXN9Kc90GI452aec<Jmc`;ut)2ulHUaPYHF?g_iyYjj{nWeu!-U?f|<HhgLaF@WB
zzmMMX*%0aW{$5Fl`}643i%Y_aTaC;+FWuQ?v2X1T`Py=Ew##j+_J_)?eAmW5Up~HX
z%hKNWHNpIk17EKcbCF#1*v7ZjMDtWcwyN);i>WJvQ;u#Fm-fCPYQW9Jz{u~M$X(19
zUAF4_m*y77QwgUOk|!7k@UZZQpQ)d^e~b0P`jb<AgTq8-eqPsn`>)sICI`PCMy`o(
zOT7F#jzrE>iJXShMGN&LJlG83rZPZ)fYh#is(ZhbMmpSIcO%PBc3%4z=~xvJCN3SD
wo2*~n`}CODcrWQFPHZu{l)1WCd1`@S)TOWwCa1R^oISJUFPrF%zGsW`0a!b)CIA2c

literal 0
HcmV?d00001

diff --git a/lib/std/compress/flate/testdata/rfc1951.txt b/lib/std/compress/flate/testdata/rfc1951.txt
new file mode 100644
index 0000000000..403c8c722f
--- /dev/null
+++ b/lib/std/compress/flate/testdata/rfc1951.txt
@@ -0,0 +1,955 @@
+
+
+
+
+
+
+Network Working Group                                         P. Deutsch
+Request for Comments: 1951                           Aladdin Enterprises
+Category: Informational                                         May 1996
+
+
+        DEFLATE Compressed Data Format Specification version 1.3
+
+Status of This Memo
+
+   This memo provides information for the Internet community.  This memo
+   does not specify an Internet standard of any kind.  Distribution of
+   this memo is unlimited.
+
+IESG Note:
+
+   The IESG takes no position on the validity of any Intellectual
+   Property Rights statements contained in this document.
+
+Notices
+
+   Copyright (c) 1996 L. Peter Deutsch
+
+   Permission is granted to copy and distribute this document for any
+   purpose and without charge, including translations into other
+   languages and incorporation into compilations, provided that the
+   copyright notice and this notice are preserved, and that any
+   substantive changes or deletions from the original are clearly
+   marked.
+
+   A pointer to the latest version of this and related documentation in
+   HTML format can be found at the URL
+   <ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html>.
+
+Abstract
+
+   This specification defines a lossless compressed data format that
+   compresses data using a combination of the LZ77 algorithm and Huffman
+   coding, with efficiency comparable to the best currently available
+   general-purpose compression methods.  The data can be produced or
+   consumed, even for an arbitrarily long sequentially presented input
+   data stream, using only an a priori bounded amount of intermediate
+   storage.  The format can be implemented readily in a manner not
+   covered by patents.
+
+
+
+
+
+
+
+
+Deutsch                      Informational                      [Page 1]
+
+RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
+
+
+Table of Contents
+
+   1. Introduction ................................................... 2
+      1.1. Purpose ................................................... 2
+      1.2. Intended audience ......................................... 3
+      1.3. Scope ..................................................... 3
+      1.4. Compliance ................................................ 3
+      1.5.  Definitions of terms and conventions used ................ 3
+      1.6. Changes from previous versions ............................ 4
+   2. Compressed representation overview ............................. 4
+   3. Detailed specification ......................................... 5
+      3.1. Overall conventions ....................................... 5
+          3.1.1. Packing into bytes .................................. 5
+      3.2. Compressed block format ................................... 6
+          3.2.1. Synopsis of prefix and Huffman coding ............... 6
+          3.2.2. Use of Huffman coding in the "deflate" format ....... 7
+          3.2.3. Details of block format ............................. 9
+          3.2.4. Non-compressed blocks (BTYPE=00) ................... 11
+          3.2.5. Compressed blocks (length and distance codes) ...... 11
+          3.2.6. Compression with fixed Huffman codes (BTYPE=01) .... 12
+          3.2.7. Compression with dynamic Huffman codes (BTYPE=10) .. 13
+      3.3. Compliance ............................................... 14
+   4. Compression algorithm details ................................. 14
+   5. References .................................................... 16
+   6. Security Considerations ....................................... 16
+   7. Source code ................................................... 16
+   8. Acknowledgements .............................................. 16
+   9. Author's Address .............................................. 17
+
+1. Introduction
+
+   1.1. Purpose
+
+      The purpose of this specification is to define a lossless
+      compressed data format that:
+          * Is independent of CPU type, operating system, file system,
+            and character set, and hence can be used for interchange;
+          * Can be produced or consumed, even for an arbitrarily long
+            sequentially presented input data stream, using only an a
+            priori bounded amount of intermediate storage, and hence
+            can be used in data communications or similar structures
+            such as Unix filters;
+          * Compresses data with efficiency comparable to the best
+            currently available general-purpose compression methods,
+            and in particular considerably better than the "compress"
+            program;
+          * Can be implemented readily in a manner not covered by
+            patents, and hence can be practiced freely;
+
+
+
+Deutsch                      Informational                      [Page 2]
+
+RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
+
+
+          * Is compatible with the file format produced by the current
+            widely used gzip utility, in that conforming decompressors
+            will be able to read data produced by the existing gzip
+            compressor.
+
+      The data format defined by this specification does not attempt to:
+
+          * Allow random access to compressed data;
+          * Compress specialized data (e.g., raster graphics) as well
+            as the best currently available specialized algorithms.
+
+      A simple counting argument shows that no lossless compression
+      algorithm can compress every possible input data set.  For the
+      format defined here, the worst case expansion is 5 bytes per 32K-
+      byte block, i.e., a size increase of 0.015% for large data sets.
+      English text usually compresses by a factor of 2.5 to 3;
+      executable files usually compress somewhat less; graphical data
+      such as raster images may compress much more.
+
+   1.2. Intended audience
+
+      This specification is intended for use by implementors of software
+      to compress data into "deflate" format and/or decompress data from
+      "deflate" format.
+
+      The text of the specification assumes a basic background in
+      programming at the level of bits and other primitive data
+      representations.  Familiarity with the technique of Huffman coding
+      is helpful but not required.
+
+   1.3. Scope
+
+      The specification specifies a method for representing a sequence
+      of bytes as a (usually shorter) sequence of bits, and a method for
+      packing the latter bit sequence into bytes.
+
+   1.4. Compliance
+
+      Unless otherwise indicated below, a compliant decompressor must be
+      able to accept and decompress any data set that conforms to all
+      the specifications presented here; a compliant compressor must
+      produce data sets that conform to all the specifications presented
+      here.
+
+   1.5.  Definitions of terms and conventions used
+
+      Byte: 8 bits stored or transmitted as a unit (same as an octet).
+      For this specification, a byte is exactly 8 bits, even on machines
+
+
+
+Deutsch                      Informational                      [Page 3]
+
+RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
+
+
+      which store a character on a number of bits different from eight.
+      See below, for the numbering of bits within a byte.
+
+      String: a sequence of arbitrary bytes.
+
+   1.6. Changes from previous versions
+
+      There have been no technical changes to the deflate format since
+      version 1.1 of this specification.  In version 1.2, some
+      terminology was changed.  Version 1.3 is a conversion of the
+      specification to RFC style.
+
+2. Compressed representation overview
+
+   A compressed data set consists of a series of blocks, corresponding
+   to successive blocks of input data.  The block sizes are arbitrary,
+   except that non-compressible blocks are limited to 65,535 bytes.
+
+   Each block is compressed using a combination of the LZ77 algorithm
+   and Huffman coding. The Huffman trees for each block are independent
+   of those for previous or subsequent blocks; the LZ77 algorithm may
+   use a reference to a duplicated string occurring in a previous block,
+   up to 32K input bytes before.
+
+   Each block consists of two parts: a pair of Huffman code trees that
+   describe the representation of the compressed data part, and a
+   compressed data part.  (The Huffman trees themselves are compressed
+   using Huffman encoding.)  The compressed data consists of a series of
+   elements of two types: literal bytes (of strings that have not been
+   detected as duplicated within the previous 32K input bytes), and
+   pointers to duplicated strings, where a pointer is represented as a
+   pair <length, backward distance>.  The representation used in the
+   "deflate" format limits distances to 32K bytes and lengths to 258
+   bytes, but does not limit the size of a block, except for
+   uncompressible blocks, which are limited as noted above.
+
+   Each type of value (literals, distances, and lengths) in the
+   compressed data is represented using a Huffman code, using one code
+   tree for literals and lengths and a separate code tree for distances.
+   The code trees for each block appear in a compact form just before
+   the compressed data for that block.
+
+
+
+
+
+
+
+
+
+
+Deutsch                      Informational                      [Page 4]
+
+RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
+
+
+3. Detailed specification
+
+   3.1. Overall conventions In the diagrams below, a box like this:
+
+         +---+
+         |   | <-- the vertical bars might be missing
+         +---+
+
+      represents one byte; a box like this:
+
+         +==============+
+         |              |
+         +==============+
+
+      represents a variable number of bytes.
+
+      Bytes stored within a computer do not have a "bit order", since
+      they are always treated as a unit.  However, a byte considered as
+      an integer between 0 and 255 does have a most- and least-
+      significant bit, and since we write numbers with the most-
+      significant digit on the left, we also write bytes with the most-
+      significant bit on the left.  In the diagrams below, we number the
+      bits of a byte so that bit 0 is the least-significant bit, i.e.,
+      the bits are numbered:
+
+         +--------+
+         |76543210|
+         +--------+
+
+      Within a computer, a number may occupy multiple bytes.  All
+      multi-byte numbers in the format described here are stored with
+      the least-significant byte first (at the lower memory address).
+      For example, the decimal number 520 is stored as:
+
+             0        1
+         +--------+--------+
+         |00001000|00000010|
+         +--------+--------+
+          ^        ^
+          |        |
+          |        + more significant byte = 2 x 256
+          + less significant byte = 8
+
+      3.1.1. Packing into bytes
+
+         This document does not address the issue of the order in which
+         bits of a byte are transmitted on a bit-sequential medium,
+         since the final data format described here is byte- rather than
+
+
+
+Deutsch                      Informational                      [Page 5]
+
+RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
+
+
+         bit-oriented.  However, we describe the compressed block format
+         in below, as a sequence of data elements of various bit
+         lengths, not a sequence of bytes.  We must therefore specify
+         how to pack these data elements into bytes to form the final
+         compressed byte sequence:
+
+             * Data elements are packed into bytes in order of
+               increasing bit number within the byte, i.e., starting
+               with the least-significant bit of the byte.
+             * Data elements other than Huffman codes are packed
+               starting with the least-significant bit of the data
+               element.
+             * Huffman codes are packed starting with the most-
+               significant bit of the code.
+
+         In other words, if one were to print out the compressed data as
+         a sequence of bytes, starting with the first byte at the
+         *right* margin and proceeding to the *left*, with the most-
+         significant bit of each byte on the left as usual, one would be
+         able to parse the result from right to left, with fixed-width
+         elements in the correct MSB-to-LSB order and Huffman codes in
+         bit-reversed order (i.e., with the first bit of the code in the
+         relative LSB position).
+
+   3.2. Compressed block format
+
+      3.2.1. Synopsis of prefix and Huffman coding
+
+         Prefix coding represents symbols from an a priori known
+         alphabet by bit sequences (codes), one code for each symbol, in
+         a manner such that different symbols may be represented by bit
+         sequences of different lengths, but a parser can always parse
+         an encoded string unambiguously symbol-by-symbol.
+
+         We define a prefix code in terms of a binary tree in which the
+         two edges descending from each non-leaf node are labeled 0 and
+         1 and in which the leaf nodes correspond one-for-one with (are
+         labeled with) the symbols of the alphabet; then the code for a
+         symbol is the sequence of 0's and 1's on the edges leading from
+         the root to the leaf labeled with that symbol.  For example:
+
+
+
+
+
+
+
+
+
+
+
+Deutsch                      Informational                      [Page 6]
+
+RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
+
+
+                          /\              Symbol    Code
+                         0  1             ------    ----
+                        /    \                A      00
+                       /\     B               B       1
+                      0  1                    C     011
+                     /    \                   D     010
+                    A     /\
+                         0  1
+                        /    \
+                       D      C
+
+         A parser can decode the next symbol from an encoded input
+         stream by walking down the tree from the root, at each step
+         choosing the edge corresponding to the next input bit.
+
+         Given an alphabet with known symbol frequencies, the Huffman
+         algorithm allows the construction of an optimal prefix code
+         (one which represents strings with those symbol frequencies
+         using the fewest bits of any possible prefix codes for that
+         alphabet).  Such a code is called a Huffman code.  (See
+         reference [1] in Chapter 5, references for additional
+         information on Huffman codes.)
+
+         Note that in the "deflate" format, the Huffman codes for the
+         various alphabets must not exceed certain maximum code lengths.
+         This constraint complicates the algorithm for computing code
+         lengths from symbol frequencies.  Again, see Chapter 5,
+         references for details.
+
+      3.2.2. Use of Huffman coding in the "deflate" format
+
+         The Huffman codes used for each alphabet in the "deflate"
+         format have two additional rules:
+
+             * All codes of a given bit length have lexicographically
+               consecutive values, in the same order as the symbols
+               they represent;
+
+             * Shorter codes lexicographically precede longer codes.
+
+
+
+
+
+
+
+
+
+
+
+
+Deutsch                      Informational                      [Page 7]
+
+RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
+
+
+         We could recode the example above to follow this rule as
+         follows, assuming that the order of the alphabet is ABCD:
+
+            Symbol  Code
+            ------  ----
+            A       10
+            B       0
+            C       110
+            D       111
+
+         I.e., 0 precedes 10 which precedes 11x, and 110 and 111 are
+         lexicographically consecutive.
+
+         Given this rule, we can define the Huffman code for an alphabet
+         just by giving the bit lengths of the codes for each symbol of
+         the alphabet in order; this is sufficient to determine the
+         actual codes.  In our example, the code is completely defined
+         by the sequence of bit lengths (2, 1, 3, 3).  The following
+         algorithm generates the codes as integers, intended to be read
+         from most- to least-significant bit.  The code lengths are
+         initially in tree[I].Len; the codes are produced in
+         tree[I].Code.
+
+         1)  Count the number of codes for each code length.  Let
+             bl_count[N] be the number of codes of length N, N >= 1.
+
+         2)  Find the numerical value of the smallest code for each
+             code length:
+
+                code = 0;
+                bl_count[0] = 0;
+                for (bits = 1; bits <= MAX_BITS; bits++) {
+                    code = (code + bl_count[bits-1]) << 1;
+                    next_code[bits] = code;
+                }
+
+         3)  Assign numerical values to all codes, using consecutive
+             values for all codes of the same length with the base
+             values determined at step 2. Codes that are never used
+             (which have a bit length of zero) must not be assigned a
+             value.
+
+                for (n = 0;  n <= max_code; n++) {
+                    len = tree[n].Len;
+                    if (len != 0) {
+                        tree[n].Code = next_code[len];
+                        next_code[len]++;
+                    }
+
+
+
+Deutsch                      Informational                      [Page 8]
+
+RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
+
+
+                }
+
+         Example:
+
+         Consider the alphabet ABCDEFGH, with bit lengths (3, 3, 3, 3,
+         3, 2, 4, 4).  After step 1, we have:
+
+            N      bl_count[N]
+            -      -----------
+            2      1
+            3      5
+            4      2
+
+         Step 2 computes the following next_code values:
+
+            N      next_code[N]
+            -      ------------
+            1      0
+            2      0
+            3      2
+            4      14
+
+         Step 3 produces the following code values:
+
+            Symbol Length   Code
+            ------ ------   ----
+            A       3        010
+            B       3        011
+            C       3        100
+            D       3        101
+            E       3        110
+            F       2         00
+            G       4       1110
+            H       4       1111
+
+      3.2.3. Details of block format
+
+         Each block of compressed data begins with 3 header bits
+         containing the following data:
+
+            first bit       BFINAL
+            next 2 bits     BTYPE
+
+         Note that the header bits do not necessarily begin on a byte
+         boundary, since a block does not necessarily occupy an integral
+         number of bytes.
+
+
+
+
+
+Deutsch                      Informational                      [Page 9]
+
+RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
+
+
+         BFINAL is set if and only if this is the last block of the data
+         set.
+
+         BTYPE specifies how the data are compressed, as follows:
+
+            00 - no compression
+            01 - compressed with fixed Huffman codes
+            10 - compressed with dynamic Huffman codes
+            11 - reserved (error)
+
+         The only difference between the two compressed cases is how the
+         Huffman codes for the literal/length and distance alphabets are
+         defined.
+
+         In all cases, the decoding algorithm for the actual data is as
+         follows:
+
+            do
+               read block header from input stream.
+               if stored with no compression
+                  skip any remaining bits in current partially
+                     processed byte
+                  read LEN and NLEN (see next section)
+                  copy LEN bytes of data to output
+               otherwise
+                  if compressed with dynamic Huffman codes
+                     read representation of code trees (see
+                        subsection below)
+                  loop (until end of block code recognized)
+                     decode literal/length value from input stream
+                     if value < 256
+                        copy value (literal byte) to output stream
+                     otherwise
+                        if value = end of block (256)
+                           break from loop
+                        otherwise (value = 257..285)
+                           decode distance from input stream
+
+                           move backwards distance bytes in the output
+                           stream, and copy length bytes from this
+                           position to the output stream.
+                  end loop
+            while not last block
+
+         Note that a duplicated string reference may refer to a string
+         in a previous block; i.e., the backward distance may cross one
+         or more block boundaries.  However a distance cannot refer past
+         the beginning of the output stream.  (An application using a
+
+
+
+Deutsch                      Informational                     [Page 10]
+
+RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
+
+
+         preset dictionary might discard part of the output stream; a
+         distance can refer to that part of the output stream anyway)
+         Note also that the referenced string may overlap the current
+         position; for example, if the last 2 bytes decoded have values
+         X and Y, a string reference with <length = 5, distance = 2>
+         adds X,Y,X,Y,X to the output stream.
+
+         We now specify each compression method in turn.
+
+      3.2.4. Non-compressed blocks (BTYPE=00)
+
+         Any bits of input up to the next byte boundary are ignored.
+         The rest of the block consists of the following information:
+
+              0   1   2   3   4...
+            +---+---+---+---+================================+
+            |  LEN  | NLEN  |... LEN bytes of literal data...|
+            +---+---+---+---+================================+
+
+         LEN is the number of data bytes in the block.  NLEN is the
+         one's complement of LEN.
+
+      3.2.5. Compressed blocks (length and distance codes)
+
+         As noted above, encoded data blocks in the "deflate" format
+         consist of sequences of symbols drawn from three conceptually
+         distinct alphabets: either literal bytes, from the alphabet of
+         byte values (0..255), or <length, backward distance> pairs,
+         where the length is drawn from (3..258) and the distance is
+         drawn from (1..32,768).  In fact, the literal and length
+         alphabets are merged into a single alphabet (0..285), where
+         values 0..255 represent literal bytes, the value 256 indicates
+         end-of-block, and values 257..285 represent length codes
+         (possibly in conjunction with extra bits following the symbol
+         code) as follows:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Deutsch                      Informational                     [Page 11]
+
+RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
+
+
+                 Extra               Extra               Extra
+            Code Bits Length(s) Code Bits Lengths   Code Bits Length(s)
+            ---- ---- ------     ---- ---- -------   ---- ---- -------
+             257   0     3       267   1   15,16     277   4   67-82
+             258   0     4       268   1   17,18     278   4   83-98
+             259   0     5       269   2   19-22     279   4   99-114
+             260   0     6       270   2   23-26     280   4  115-130
+             261   0     7       271   2   27-30     281   5  131-162
+             262   0     8       272   2   31-34     282   5  163-194
+             263   0     9       273   3   35-42     283   5  195-226
+             264   0    10       274   3   43-50     284   5  227-257
+             265   1  11,12      275   3   51-58     285   0    258
+             266   1  13,14      276   3   59-66
+
+         The extra bits should be interpreted as a machine integer
+         stored with the most-significant bit first, e.g., bits 1110
+         represent the value 14.
+
+                  Extra           Extra               Extra
+             Code Bits Dist  Code Bits   Dist     Code Bits Distance
+             ---- ---- ----  ---- ----  ------    ---- ---- --------
+               0   0    1     10   4     33-48    20    9   1025-1536
+               1   0    2     11   4     49-64    21    9   1537-2048
+               2   0    3     12   5     65-96    22   10   2049-3072
+               3   0    4     13   5     97-128   23   10   3073-4096
+               4   1   5,6    14   6    129-192   24   11   4097-6144
+               5   1   7,8    15   6    193-256   25   11   6145-8192
+               6   2   9-12   16   7    257-384   26   12  8193-12288
+               7   2  13-16   17   7    385-512   27   12 12289-16384
+               8   3  17-24   18   8    513-768   28   13 16385-24576
+               9   3  25-32   19   8   769-1024   29   13 24577-32768
+
+      3.2.6. Compression with fixed Huffman codes (BTYPE=01)
+
+         The Huffman codes for the two alphabets are fixed, and are not
+         represented explicitly in the data.  The Huffman code lengths
+         for the literal/length alphabet are:
+
+                   Lit Value    Bits        Codes
+                   ---------    ----        -----
+                     0 - 143     8          00110000 through
+                                            10111111
+                   144 - 255     9          110010000 through
+                                            111111111
+                   256 - 279     7          0000000 through
+                                            0010111
+                   280 - 287     8          11000000 through
+                                            11000111
+
+
+
+Deutsch                      Informational                     [Page 12]
+
+RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
+
+
+         The code lengths are sufficient to generate the actual codes,
+         as described above; we show the codes in the table for added
+         clarity.  Literal/length values 286-287 will never actually
+         occur in the compressed data, but participate in the code
+         construction.
+
+         Distance codes 0-31 are represented by (fixed-length) 5-bit
+         codes, with possible additional bits as shown in the table
+         shown in Paragraph 3.2.5, above.  Note that distance codes 30-
+         31 will never actually occur in the compressed data.
+
+      3.2.7. Compression with dynamic Huffman codes (BTYPE=10)
+
+         The Huffman codes for the two alphabets appear in the block
+         immediately after the header bits and before the actual
+         compressed data, first the literal/length code and then the
+         distance code.  Each code is defined by a sequence of code
+         lengths, as discussed in Paragraph 3.2.2, above.  For even
+         greater compactness, the code length sequences themselves are
+         compressed using a Huffman code.  The alphabet for code lengths
+         is as follows:
+
+               0 - 15: Represent code lengths of 0 - 15
+                   16: Copy the previous code length 3 - 6 times.
+                       The next 2 bits indicate repeat length
+                             (0 = 3, ... , 3 = 6)
+                          Example:  Codes 8, 16 (+2 bits 11),
+                                    16 (+2 bits 10) will expand to
+                                    12 code lengths of 8 (1 + 6 + 5)
+                   17: Repeat a code length of 0 for 3 - 10 times.
+                       (3 bits of length)
+                   18: Repeat a code length of 0 for 11 - 138 times
+                       (7 bits of length)
+
+         A code length of 0 indicates that the corresponding symbol in
+         the literal/length or distance alphabet will not occur in the
+         block, and should not participate in the Huffman code
+         construction algorithm given earlier.  If only one distance
+         code is used, it is encoded using one bit, not zero bits; in
+         this case there is a single code length of one, with one unused
+         code.  One distance code of zero bits means that there are no
+         distance codes used at all (the data is all literals).
+
+         We can now define the format of the block:
+
+               5 Bits: HLIT, # of Literal/Length codes - 257 (257 - 286)
+               5 Bits: HDIST, # of Distance codes - 1        (1 - 32)
+               4 Bits: HCLEN, # of Code Length codes - 4     (4 - 19)
+
+
+
+Deutsch                      Informational                     [Page 13]
+
+RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
+
+
+               (HCLEN + 4) x 3 bits: code lengths for the code length
+                  alphabet given just above, in the order: 16, 17, 18,
+                  0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
+
+                  These code lengths are interpreted as 3-bit integers
+                  (0-7); as above, a code length of 0 means the
+                  corresponding symbol (literal/length or distance code
+                  length) is not used.
+
+               HLIT + 257 code lengths for the literal/length alphabet,
+                  encoded using the code length Huffman code
+
+               HDIST + 1 code lengths for the distance alphabet,
+                  encoded using the code length Huffman code
+
+               The actual compressed data of the block,
+                  encoded using the literal/length and distance Huffman
+                  codes
+
+               The literal/length symbol 256 (end of data),
+                  encoded using the literal/length Huffman code
+
+         The code length repeat codes can cross from HLIT + 257 to the
+         HDIST + 1 code lengths.  In other words, all code lengths form
+         a single sequence of HLIT + HDIST + 258 values.
+
+   3.3. Compliance
+
+      A compressor may limit further the ranges of values specified in
+      the previous section and still be compliant; for example, it may
+      limit the range of backward pointers to some value smaller than
+      32K.  Similarly, a compressor may limit the size of blocks so that
+      a compressible block fits in memory.
+
+      A compliant decompressor must accept the full range of possible
+      values defined in the previous section, and must accept blocks of
+      arbitrary size.
+
+4. Compression algorithm details
+
+   While it is the intent of this document to define the "deflate"
+   compressed data format without reference to any particular
+   compression algorithm, the format is related to the compressed
+   formats produced by LZ77 (Lempel-Ziv 1977, see reference [2] below);
+   since many variations of LZ77 are patented, it is strongly
+   recommended that the implementor of a compressor follow the general
+   algorithm presented here, which is known not to be patented per se.
+   The material in this section is not part of the definition of the
+
+
+
+Deutsch                      Informational                     [Page 14]
+
+RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
+
+
+   specification per se, and a compressor need not follow it in order to
+   be compliant.
+
+   The compressor terminates a block when it determines that starting a
+   new block with fresh trees would be useful, or when the block size
+   fills up the compressor's block buffer.
+
+   The compressor uses a chained hash table to find duplicated strings,
+   using a hash function that operates on 3-byte sequences.  At any
+   given point during compression, let XYZ be the next 3 input bytes to
+   be examined (not necessarily all different, of course).  First, the
+   compressor examines the hash chain for XYZ.  If the chain is empty,
+   the compressor simply writes out X as a literal byte and advances one
+   byte in the input.  If the hash chain is not empty, indicating that
+   the sequence XYZ (or, if we are unlucky, some other 3 bytes with the
+   same hash function value) has occurred recently, the compressor
+   compares all strings on the XYZ hash chain with the actual input data
+   sequence starting at the current point, and selects the longest
+   match.
+
+   The compressor searches the hash chains starting with the most recent
+   strings, to favor small distances and thus take advantage of the
+   Huffman encoding.  The hash chains are singly linked. There are no
+   deletions from the hash chains; the algorithm simply discards matches
+   that are too old.  To avoid a worst-case situation, very long hash
+   chains are arbitrarily truncated at a certain length, determined by a
+   run-time parameter.
+
+   To improve overall compression, the compressor optionally defers the
+   selection of matches ("lazy matching"): after a match of length N has
+   been found, the compressor searches for a longer match starting at
+   the next input byte.  If it finds a longer match, it truncates the
+   previous match to a length of one (thus producing a single literal
+   byte) and then emits the longer match.  Otherwise, it emits the
+   original match, and, as described above, advances N bytes before
+   continuing.
+
+   Run-time parameters also control this "lazy match" procedure.  If
+   compression ratio is most important, the compressor attempts a
+   complete second search regardless of the length of the first match.
+   In the normal case, if the current match is "long enough", the
+   compressor reduces the search for a longer match, thus speeding up
+   the process.  If speed is most important, the compressor inserts new
+   strings in the hash table only when no match was found, or when the
+   match is not "too long".  This degrades the compression ratio but
+   saves time since there are both fewer insertions and fewer searches.
+
+
+
+
+
+Deutsch                      Informational                     [Page 15]
+
+RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
+
+
+5. References
+
+   [1] Huffman, D. A., "A Method for the Construction of Minimum
+       Redundancy Codes", Proceedings of the Institute of Radio
+       Engineers, September 1952, Volume 40, Number 9, pp. 1098-1101.
+
+   [2] Ziv J., Lempel A., "A Universal Algorithm for Sequential Data
+       Compression", IEEE Transactions on Information Theory, Vol. 23,
+       No. 3, pp. 337-343.
+
+   [3] Gailly, J.-L., and Adler, M., ZLIB documentation and sources,
+       available in ftp://ftp.uu.net/pub/archiving/zip/doc/
+
+   [4] Gailly, J.-L., and Adler, M., GZIP documentation and sources,
+       available as gzip-*.tar in ftp://prep.ai.mit.edu/pub/gnu/
+
+   [5] Schwartz, E. S., and Kallick, B. "Generating a canonical prefix
+       encoding." Comm. ACM, 7,3 (Mar. 1964), pp. 166-169.
+
+   [6] Hirschberg and Lelewer, "Efficient decoding of prefix codes,"
+       Comm. ACM, 33,4, April 1990, pp. 449-459.
+
+6. Security Considerations
+
+   Any data compression method involves the reduction of redundancy in
+   the data.  Consequently, any corruption of the data is likely to have
+   severe effects and be difficult to correct.  Uncompressed text, on
+   the other hand, will probably still be readable despite the presence
+   of some corrupted bytes.
+
+   It is recommended that systems using this data format provide some
+   means of validating the integrity of the compressed data.  See
+   reference [3], for example.
+
+7. Source code
+
+   Source code for a C language implementation of a "deflate" compliant
+   compressor and decompressor is available within the zlib package at
+   ftp://ftp.uu.net/pub/archiving/zip/zlib/.
+
+8. Acknowledgements
+
+   Trademarks cited in this document are the property of their
+   respective owners.
+
+   Phil Katz designed the deflate format.  Jean-Loup Gailly and Mark
+   Adler wrote the related software described in this specification.
+   Glenn Randers-Pehrson converted this document to RFC and HTML format.
+
+
+
+Deutsch                      Informational                     [Page 16]
+
+RFC 1951      DEFLATE Compressed Data Format Specification      May 1996
+
+
+9. Author's Address
+
+   L. Peter Deutsch
+   Aladdin Enterprises
+   203 Santa Margarita Ave.
+   Menlo Park, CA 94025
+
+   Phone: (415) 322-0103 (AM only)
+   FAX:   (415) 322-1734
+   EMail: <ghost@aladdin.com>
+
+   Questions about the technical content of this specification can be
+   sent by email to:
+
+   Jean-Loup Gailly <gzip@prep.ai.mit.edu> and
+   Mark Adler <madler@alumni.caltech.edu>
+
+   Editorial comments on this specification can be sent by email to:
+
+   L. Peter Deutsch <ghost@aladdin.com> and
+   Glenn Randers-Pehrson <randeg@alumni.rpi.edu>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Deutsch                      Informational                     [Page 17]
+
diff --git a/lib/std/compress/flate/zlib.zig b/lib/std/compress/flate/zlib.zig
new file mode 100644
index 0000000000..328e625119
--- /dev/null
+++ b/lib/std/compress/flate/zlib.zig
@@ -0,0 +1,66 @@
+const deflate = @import("deflate.zig");
+const inflate = @import("inflate.zig");
+
+/// Decompress compressed data from reader and write plain data to the writer.
+pub fn decompress(reader: anytype, writer: anytype) !void {
+    try inflate.decompress(.zlib, reader, writer);
+}
+
+/// Decompressor type
+pub fn Decompressor(comptime ReaderType: type) type {
+    return inflate.Inflate(.zlib, ReaderType);
+}
+
+/// Create Decompressor which will read compressed data from reader.
+pub fn decompressor(reader: anytype) Decompressor(@TypeOf(reader)) {
+    return inflate.decompressor(.zlib, reader);
+}
+
+/// Compression level, trades between speed and compression size.
+pub const Options = deflate.Options;
+
+/// Compress plain data from reader and write compressed data to the writer.
+pub fn compress(reader: anytype, writer: anytype, options: Options) !void {
+    try deflate.compress(.zlib, reader, writer, options);
+}
+
+/// Compressor type
+pub fn Compressor(comptime WriterType: type) type {
+    return deflate.Compressor(.zlib, WriterType);
+}
+
+/// Create Compressor which outputs compressed data to the writer.
+pub fn compressor(writer: anytype, options: Options) !Compressor(@TypeOf(writer)) {
+    return try deflate.compressor(.zlib, writer, options);
+}
+
+/// Huffman only compression. Without Lempel-Ziv match searching. Faster
+/// compression, less memory requirements but bigger compressed sizes.
+pub const huffman = struct {
+    pub fn compress(reader: anytype, writer: anytype) !void {
+        try deflate.huffman.compress(.zlib, reader, writer);
+    }
+
+    pub fn Compressor(comptime WriterType: type) type {
+        return deflate.huffman.Compressor(.zlib, WriterType);
+    }
+
+    pub fn compressor(writer: anytype) !huffman.Compressor(@TypeOf(writer)) {
+        return deflate.huffman.compressor(.zlib, writer);
+    }
+};
+
+// No compression store only. Compressed size is slightly bigger than plain.
+pub const store = struct {
+    pub fn compress(reader: anytype, writer: anytype) !void {
+        try deflate.store.compress(.zlib, reader, writer);
+    }
+
+    pub fn Compressor(comptime WriterType: type) type {
+        return deflate.store.Compressor(.zlib, WriterType);
+    }
+
+    pub fn compressor(writer: anytype) !store.Compressor(@TypeOf(writer)) {
+        return deflate.store.compressor(.zlib, writer);
+    }
+};
diff --git a/lib/std/compress/gzip.zig b/lib/std/compress/gzip.zig
index 0576812a09..9d9bad7184 100644
--- a/lib/std/compress/gzip.zig
+++ b/lib/std/compress/gzip.zig
@@ -6,7 +6,7 @@ const io = std.io;
 const fs = std.fs;
 const testing = std.testing;
 const mem = std.mem;
-const deflate = std.compress.deflate;
+const deflate = @import("deflate.zig");
 
 const magic = &[2]u8{ 0x1f, 0x8b };
 
diff --git a/lib/std/compress/zlib.zig b/lib/std/compress/zlib.zig
index 6708875930..811f714286 100644
--- a/lib/std/compress/zlib.zig
+++ b/lib/std/compress/zlib.zig
@@ -6,7 +6,7 @@ const io = std.io;
 const fs = std.fs;
 const testing = std.testing;
 const mem = std.mem;
-const deflate = std.compress.deflate;
+const deflate = @import("deflate.zig");
 
 // Zlib header format as specified in RFC1950
 const ZLibHeader = packed struct {
diff --git a/lib/std/debug.zig b/lib/std/debug.zig
index 601a949ecf..3b9e46be92 100644
--- a/lib/std/debug.zig
+++ b/lib/std/debug.zig
@@ -1212,8 +1212,7 @@ pub fn readElfDebugInfo(
                 const chdr = section_reader.readStruct(elf.Chdr) catch continue;
                 if (chdr.ch_type != .ZLIB) continue;
 
-                var zlib_stream = std.compress.zlib.decompressStream(allocator, section_stream.reader()) catch continue;
-                defer zlib_stream.deinit();
+                var zlib_stream = std.compress.zlib.decompressor(section_stream.reader());
 
                 const decompressed_section = try allocator.alloc(u8, chdr.ch_size);
                 errdefer allocator.free(decompressed_section);
diff --git a/lib/std/http/Client.zig b/lib/std/http/Client.zig
index ed6aec55aa..a50e814fd4 100644
--- a/lib/std/http/Client.zig
+++ b/lib/std/http/Client.zig
@@ -404,8 +404,8 @@ pub const RequestTransfer = union(enum) {
 
 /// The decompressor for response messages.
 pub const Compression = union(enum) {
-    pub const DeflateDecompressor = std.compress.zlib.DecompressStream(Request.TransferReader);
-    pub const GzipDecompressor = std.compress.gzip.Decompress(Request.TransferReader);
+    pub const DeflateDecompressor = std.compress.zlib.Decompressor(Request.TransferReader);
+    pub const GzipDecompressor = std.compress.gzip.Decompressor(Request.TransferReader);
     pub const ZstdDecompressor = std.compress.zstd.DecompressStream(Request.TransferReader, .{});
 
     deflate: DeflateDecompressor,
@@ -601,8 +601,8 @@ pub const Request = struct {
     pub fn deinit(req: *Request) void {
         switch (req.response.compression) {
             .none => {},
-            .deflate => |*deflate| deflate.deinit(),
-            .gzip => |*gzip| gzip.deinit(),
+            .deflate => {},
+            .gzip => {},
             .zstd => |*zstd| zstd.deinit(),
         }
 
@@ -632,8 +632,8 @@ pub const Request = struct {
 
         switch (req.response.compression) {
             .none => {},
-            .deflate => |*deflate| deflate.deinit(),
-            .gzip => |*gzip| gzip.deinit(),
+            .deflate => {},
+            .gzip => {},
             .zstd => |*zstd| zstd.deinit(),
         }
 
@@ -941,10 +941,10 @@ pub const Request = struct {
                         .identity => req.response.compression = .none,
                         .compress, .@"x-compress" => return error.CompressionNotSupported,
                         .deflate => req.response.compression = .{
-                            .deflate = std.compress.zlib.decompressStream(req.client.allocator, req.transferReader()) catch return error.CompressionInitializationFailed,
+                            .deflate = std.compress.zlib.decompressor(req.transferReader()),
                         },
                         .gzip, .@"x-gzip" => req.response.compression = .{
-                            .gzip = std.compress.gzip.decompress(req.client.allocator, req.transferReader()) catch return error.CompressionInitializationFailed,
+                            .gzip = std.compress.gzip.decompressor(req.transferReader()),
                         },
                         .zstd => req.response.compression = .{
                             .zstd = std.compress.zstd.decompressStream(req.client.allocator, req.transferReader()),
diff --git a/lib/std/http/Server.zig b/lib/std/http/Server.zig
index 48c4e2cbfb..4659041779 100644
--- a/lib/std/http/Server.zig
+++ b/lib/std/http/Server.zig
@@ -195,8 +195,8 @@ pub const ResponseTransfer = union(enum) {
 
 /// The decompressor for request messages.
 pub const Compression = union(enum) {
-    pub const DeflateDecompressor = std.compress.zlib.DecompressStream(Response.TransferReader);
-    pub const GzipDecompressor = std.compress.gzip.Decompress(Response.TransferReader);
+    pub const DeflateDecompressor = std.compress.zlib.Decompressor(Response.TransferReader);
+    pub const GzipDecompressor = std.compress.gzip.Decompressor(Response.TransferReader);
     pub const ZstdDecompressor = std.compress.zstd.DecompressStream(Response.TransferReader, .{});
 
     deflate: DeflateDecompressor,
@@ -420,8 +420,8 @@ pub const Response = struct {
 
         switch (res.request.compression) {
             .none => {},
-            .deflate => |*deflate| deflate.deinit(),
-            .gzip => |*gzip| gzip.deinit(),
+            .deflate => {},
+            .gzip => {},
             .zstd => |*zstd| zstd.deinit(),
         }
 
@@ -605,10 +605,10 @@ pub const Response = struct {
                 .identity => res.request.compression = .none,
                 .compress, .@"x-compress" => return error.CompressionNotSupported,
                 .deflate => res.request.compression = .{
-                    .deflate = std.compress.zlib.decompressStream(res.allocator, res.transferReader()) catch return error.CompressionInitializationFailed,
+                    .deflate = std.compress.zlib.decompressor(res.transferReader()),
                 },
                 .gzip, .@"x-gzip" => res.request.compression = .{
-                    .gzip = std.compress.gzip.decompress(res.allocator, res.transferReader()) catch return error.CompressionInitializationFailed,
+                    .gzip = std.compress.gzip.decompressor(res.transferReader()),
                 },
                 .zstd => res.request.compression = .{
                     .zstd = std.compress.zstd.decompressStream(res.allocator, res.transferReader()),
diff --git a/src/Package/Fetch.zig b/src/Package/Fetch.zig
index fb9d7c823c..ed3c6b099f 100644
--- a/src/Package/Fetch.zig
+++ b/src/Package/Fetch.zig
@@ -1099,7 +1099,12 @@ fn unpackResource(
 
     switch (file_type) {
         .tar => try unpackTarball(f, tmp_directory.handle, resource.reader()),
-        .@"tar.gz" => try unpackTarballCompressed(f, tmp_directory.handle, resource, std.compress.gzip),
+        .@"tar.gz" => {
+            const reader = resource.reader();
+            var br = std.io.bufferedReaderSize(std.crypto.tls.max_ciphertext_record_len, reader);
+            var dcp = std.compress.gzip.decompressor(br.reader());
+            try unpackTarball(f, tmp_directory.handle, dcp.reader());
+        },
         .@"tar.xz" => try unpackTarballCompressed(f, tmp_directory.handle, resource, std.compress.xz),
         .@"tar.zst" => try unpackTarballCompressed(f, tmp_directory.handle, resource, ZstdWrapper),
         .git_pack => unpackGitPack(f, tmp_directory.handle, resource) catch |err| switch (err) {
diff --git a/src/Package/Fetch/git.zig b/src/Package/Fetch/git.zig
index df5332d41d..abbb031948 100644
--- a/src/Package/Fetch/git.zig
+++ b/src/Package/Fetch/git.zig
@@ -1115,8 +1115,7 @@ fn indexPackFirstPass(
         const entry_header = try EntryHeader.read(entry_crc32_reader.reader());
         switch (entry_header) {
             inline .commit, .tree, .blob, .tag => |object, tag| {
-                var entry_decompress_stream = try std.compress.zlib.decompressStream(allocator, entry_crc32_reader.reader());
-                defer entry_decompress_stream.deinit();
+                var entry_decompress_stream = std.compress.zlib.decompressor(entry_crc32_reader.reader());
                 var entry_counting_reader = std.io.countingReader(entry_decompress_stream.reader());
                 var entry_hashed_writer = hashedWriter(std.io.null_writer, Sha1.init(.{}));
                 const entry_writer = entry_hashed_writer.writer();
@@ -1135,8 +1134,7 @@ fn indexPackFirstPass(
                 });
             },
             inline .ofs_delta, .ref_delta => |delta| {
-                var entry_decompress_stream = try std.compress.zlib.decompressStream(allocator, entry_crc32_reader.reader());
-                defer entry_decompress_stream.deinit();
+                var entry_decompress_stream = std.compress.zlib.decompressor(entry_crc32_reader.reader());
                 var entry_counting_reader = std.io.countingReader(entry_decompress_stream.reader());
                 var fifo = std.fifo.LinearFifo(u8, .{ .Static = 4096 }).init();
                 try fifo.pump(entry_counting_reader.reader(), std.io.null_writer);
@@ -1257,8 +1255,7 @@ fn resolveDeltaChain(
 fn readObjectRaw(allocator: Allocator, reader: anytype, size: u64) ![]u8 {
     const alloc_size = std.math.cast(usize, size) orelse return error.ObjectTooLarge;
     var buffered_reader = std.io.bufferedReader(reader);
-    var decompress_stream = try std.compress.zlib.decompressStream(allocator, buffered_reader.reader());
-    defer decompress_stream.deinit();
+    var decompress_stream = std.compress.zlib.decompressor(buffered_reader.reader());
     const data = try allocator.alloc(u8, alloc_size);
     errdefer allocator.free(data);
     try decompress_stream.reader().readNoEof(data);
diff --git a/src/link/Elf/Object.zig b/src/link/Elf/Object.zig
index 395e6680a1..b29de3fc59 100644
--- a/src/link/Elf/Object.zig
+++ b/src/link/Elf/Object.zig
@@ -902,9 +902,7 @@ pub fn codeDecompressAlloc(self: Object, elf_file: *Elf, atom_index: Atom.Index)
         switch (chdr.ch_type) {
             .ZLIB => {
                 var stream = std.io.fixedBufferStream(data[@sizeOf(elf.Elf64_Chdr)..]);
-                var zlib_stream = std.compress.zlib.decompressStream(gpa, stream.reader()) catch
-                    return error.InputOutput;
-                defer zlib_stream.deinit();
+                var zlib_stream = std.compress.zlib.decompressor(stream.reader());
                 const size = std.math.cast(usize, chdr.ch_size) orelse return error.Overflow;
                 const decomp = try gpa.alloc(u8, size);
                 const nread = zlib_stream.reader().readAll(decomp) catch return error.InputOutput;
diff --git a/src/objcopy.zig b/src/objcopy.zig
index 8ea0eaac59..81638d4af0 100644
--- a/src/objcopy.zig
+++ b/src/objcopy.zig
@@ -1298,8 +1298,7 @@ const ElfFileHelper = struct {
         try compressed_stream.writer().writeAll(prefix);
 
         {
-            var compressor = try std.compress.zlib.compressStream(allocator, compressed_stream.writer(), .{});
-            defer compressor.deinit();
+            var compressor = try std.compress.zlib.compressor(compressed_stream.writer(), .{});
 
             var buf: [8000]u8 = undefined;
             while (true) {