simplify dynamic decode loop

Current timing:

$ zig build bench -Doptimize=ReleaseSafe && hyperfine --warmup 1 -r 10 'zig-out/bin/inflate_bench'
Benchmark 1: zig-out/bin/inflate_bench
  Time (mean ± σ):     355.0 ms ±   0.8 ms    [User: 353.4 ms, System: 1.6 ms]
  Range (min … max):   354.0 ms … 356.3 ms    10 runs

src/Token.zig

@@ -35,7 +35,7 @@ const match_lengths_index = [_]u8{
 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-358
+    base: u16, // 3-258
     extra_length: u8 = 0,
     extra_bits: u4,
 };

src/inflate.zig

@@ -180,32 +180,37 @@ pub fn Inflate(comptime wrap: Wrapper, comptime ReaderType: type) type {
 
         fn dynamicBlock(self: *Self) !bool {
             while (!self.windowFull()) {
-                try self.bits.fill(15);
-                const sym = self.lit_h.find(try self.bits.peekF(u15, F.buffered | F.reverse));
-                self.bits.shift(sym.code_bits);
+                try self.bits.fill(15); // optimization so other bit reads can be buffered (avoiding one in hot path)
+                const sym = try self.decodeSymbol(&self.lit_h);
 
                 if (sym.kind == .literal) {
                     self.win.write(sym.symbol);
                     continue;
                 }
                 if (sym.kind == .end_of_block) {
-                    // end of block
                     return true;
                 }
 
-                // decode backward pointer <length, distance>
-                try self.bits.fill(5 + 15 + 13);
+                // 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 = self.dst_h.find(try self.bits.peekF(u15, F.buffered | F.reverse)); // distance symbol
-                self.bits.shift(dsm.code_bits);
-
+                const dsm = try self.decodeSymbol(&self.dst_h);
                 const distance = try self.decodeDistance(dsm.symbol);
                 self.win.writeCopy(length, distance);
             }
             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.
+        inline fn decodeSymbol(self: *Self, decoder: anytype) !hfd.Symbol {
+            const sym = decoder.find(try self.bits.peekF(u15, F.buffered | F.reverse));
+            self.bits.shift(sym.code_bits);
+            return sym;
+        }
+
         fn step(self: *Self) Error!void {
             switch (self.state) {
                 .protocol_header => {