herringbone 0.1.0

data/lib/herringbone/codecs/lz4.rb

@@ -0,0 +1,305 @@
+# frozen_string_literal: true
+
+module Herringbone
+  module Codecs
+    # Pure-Ruby LZ4: raw block format (Parquet LZ4_RAW), Hadoop-framed blocks
+    # (Parquet's deprecated LZ4) and a decoder for the LZ4 frame format.
+    module LZ4
+      class Error < StandardError; end
+
+      MIN_MATCH = 4
+      LAST_LITERALS = 5 # the last 5 bytes of a block are always literals
+      MFLIMIT = 12      # the last match must start at least 12 bytes before the end
+      MAX_OFFSET = 65_535
+      HASH_LOG = 14
+      HASH_SHIFT = 32 - HASH_LOG
+      SKIP_STRENGTH = 6
+      FRAME_MAGIC = 0x184D2204
+      HADOOP_PREFIX = 8
+      BINARY = Encoding::BINARY
+      # String#unpack1 accepts offset: since Ruby 3.1
+      UNPACK_OFFSET = begin
+        "\x00\x00\x00\x00".unpack1("V", offset: 0)
+        true
+      rescue ArgumentError
+        false
+      end
+
+      module_function
+
+      # Decompress a raw LZ4 block that must expand to exactly uncompressed_size bytes.
+      def decompress_block(input, uncompressed_size)
+        src = binary(input)
+        out = String.new(capacity: uncompressed_size, encoding: BINARY)
+        decode_block(src, 0, src.bytesize, out, uncompressed_size)
+        unless out.bytesize == uncompressed_size
+          raise Error, "LZ4 block decoded to #{out.bytesize} bytes, expected #{uncompressed_size}"
+        end
+        out
+      end
+
+      # Parquet LZ4 (codec 5). Tries Hadoop framing, then the LZ4 frame format,
+      # then a bare raw block (Arrow falls back hadoop -> raw; some writers emitted frames).
+      def decompress_hadoop(input, uncompressed_size)
+        src = binary(input)
+        result = try_hadoop(src, uncompressed_size)
+        return result if result
+
+        if src.bytesize >= 4 && src.unpack1("V") == FRAME_MAGIC
+          begin
+            out = decompress_frame(src, uncompressed_size)
+            return out if out.bytesize == uncompressed_size
+          rescue Error
+            # fall through to raw block
+          end
+        end
+        decompress_block(src, uncompressed_size)
+      end
+
+      # Decode LZ4 frame format data (one or more frames, skippable frames ignored).
+      # Checksums are skipped, not verified.
+      def decompress_frame(input, max_size)
+        src = binary(input)
+        n = src.bytesize
+        out = String.new(capacity: max_size, encoding: BINARY)
+        ip = 0
+        while ip < n
+          raise Error, "Truncated LZ4 frame header" if ip + 4 > n
+          magic = le32(src, ip)
+          if (magic & 0xFFFFFFF0) == 0x184D2A50 # skippable frame
+            raise Error, "Truncated skippable frame" if ip + 8 > n
+            ip += 8 + le32(src, ip + 4)
+            next
+          end
+          raise Error, "Bad LZ4 frame magic 0x#{magic.to_s(16)}" unless magic == FRAME_MAGIC
+          ip = decode_frame(src, ip + 4, n, out, max_size)
+        end
+        raise Error, "Truncated skippable frame" if ip > n
+        out
+      end
+
+      # Compress into a single raw LZ4 block.
+      def compress_block(input)
+        src = binary(input)
+        n = src.bytesize
+        out = String.new(capacity: n + (n / 255) + 16, encoding: BINARY)
+        anchor = 0
+
+        if n > MFLIMIT
+          table = Array.new(1 << HASH_LOG, -1)
+          mflimit = n - MFLIMIT
+          match_limit = n - LAST_LITERALS
+          ip = 0
+          while ip < mflimit
+            seq = UNPACK_OFFSET ? src.unpack1("V", offset: ip) : u32(src, ip)
+            h = ((seq * 40_503) & 0xFFFFFFFF) >> HASH_SHIFT
+            ref = table[h]
+            table[h] = ip
+
+            if ref < 0 || ip - ref > MAX_OFFSET ||
+                seq != (UNPACK_OFFSET ? src.unpack1("V", offset: ref) : u32(src, ref))
+              ip += 1 + ((ip - anchor) >> SKIP_STRENGTH)
+              next
+            end
+
+            # Extend the match backwards into pending literals
+            while ip > anchor && ref > 0 && src.getbyte(ip - 1) == src.getbyte(ref - 1)
+              ip -= 1
+              ref -= 1
+            end
+
+            # Extend forwards, 8 bytes at a time where possible
+            len = MIN_MATCH
+            if UNPACK_OFFSET
+              while ip + len + 8 <= match_limit &&
+                  src.unpack1("Q<", offset: ip + len) == src.unpack1("Q<", offset: ref + len)
+                len += 8
+              end
+            end
+            len += 1 while ip + len < match_limit && src.getbyte(ip + len) == src.getbyte(ref + len)
+
+            # Emit the sequence: token, literal run, offset, extended match length
+            lit_len = ip - anchor
+            ml = len - MIN_MATCH
+            out << (((lit_len < 15 ? lit_len : 15) << 4) | (ml < 15 ? ml : 15))
+            write_length(out, lit_len - 15) if lit_len >= 15
+            out << src.byteslice(anchor, lit_len) if lit_len > 0
+            offset = ip - ref
+            out << (offset & 0xFF) << (offset >> 8)
+            write_length(out, ml - 15) if ml >= 15
+
+            ip += len
+            anchor = ip
+            break if ip >= mflimit
+
+            # Seed the table with a position inside the match for better follow-up matches
+            p2 = ip - 2
+            s2 = UNPACK_OFFSET ? src.unpack1("V", offset: p2) : u32(src, p2)
+            table[((s2 * 40_503) & 0xFFFFFFFF) >> HASH_SHIFT] = p2
+          end
+        end
+
+        emit_last_literals(out, src, anchor, n - anchor)
+        out
+      end
+
+      # Single Hadoop-framed block: [BE uncompressed size][BE compressed size][raw block]
+      def compress_hadoop(input)
+        src = binary(input)
+        block = compress_block(src)
+        [src.bytesize, block.bytesize].pack("NN") << block
+      end
+
+      # -- internals --
+
+      def binary(str)
+        str.encoding == BINARY ? str : str.b
+      end
+
+      def le32(src, i)
+        src.byteslice(i, 4).unpack1("V")
+      end
+
+      def u32(src, i)
+        src.getbyte(i) | (src.getbyte(i + 1) << 8) | (src.getbyte(i + 2) << 16) | (src.getbyte(i + 3) << 24)
+      end
+
+      def write_length(out, len)
+        if len >= 255
+          out << ("\xFF".b * (len / 255))
+          len %= 255
+        end
+        out << len
+      end
+
+      def emit_last_literals(out, src, anchor, lit_len)
+        out << ((lit_len < 15 ? lit_len : 15) << 4)
+        write_length(out, lit_len - 15) if lit_len >= 15
+        out << src.byteslice(anchor, lit_len) if lit_len > 0
+      end
+
+      # Decode one raw block from src[ip...iend], appending to out (which may already
+      # hold earlier data that matches can reference). out may not grow beyond limit.
+      def decode_block(src, ip, iend, out, limit)
+        while ip < iend
+          token = src.getbyte(ip)
+          ip += 1
+
+          lit = token >> 4
+          if lit == 15
+            while true
+              raise Error, "Truncated LZ4 literal length" if ip >= iend
+              b = src.getbyte(ip)
+              ip += 1
+              lit += b
+              break if b != 255
+            end
+          end
+          if lit > 0
+            raise Error, "LZ4 literals run past end of input" if ip + lit > iend
+            raise Error, "LZ4 output exceeds expected size" if out.bytesize + lit > limit
+            out << src.byteslice(ip, lit)
+            ip += lit
+          end
+          break if ip == iend # last sequence carries literals only
+
+          raise Error, "Truncated LZ4 match offset" if ip + 2 > iend
+          offset = src.getbyte(ip) | (src.getbyte(ip + 1) << 8)
+          ip += 2
+          olen = out.bytesize
+          raise Error, "Invalid LZ4 match offset #{offset}" if offset == 0 || offset > olen
+
+          mlen = token & 15
+          if mlen == 15
+            while true
+              raise Error, "Truncated LZ4 match length" if ip >= iend
+              b = src.getbyte(ip)
+              ip += 1
+              mlen += b
+              break if b != 255
+            end
+          end
+          mlen += MIN_MATCH
+          raise Error, "LZ4 output exceeds expected size" if olen + mlen > limit
+
+          pos = olen - offset
+          if mlen <= offset
+            out << out.byteslice(pos, mlen)
+          else
+            # Overlapping match: the pattern of length `offset` repeats
+            pattern = out.byteslice(pos, offset)
+            reps, rem = mlen.divmod(offset)
+            out << (pattern * reps)
+            out << pattern.byteslice(0, rem) if rem > 0
+          end
+        end
+        ip
+      end
+
+      # Arrow-compatible Hadoop frame parsing; returns nil if the data does not fit the framing.
+      def try_hadoop(src, uncompressed_size)
+        n = src.bytesize
+        return nil if n < HADOOP_PREFIX
+
+        out = String.new(capacity: uncompressed_size, encoding: BINARY)
+        ip = 0
+        while n - ip >= HADOOP_PREFIX
+          expected, csize = src.byteslice(ip, HADOOP_PREFIX).unpack("NN")
+          ip += HADOOP_PREFIX
+          return nil if csize > n - ip
+          return nil if out.bytesize + expected > uncompressed_size
+
+          target = out.bytesize + expected
+          begin
+            decode_block(src, ip, ip + csize, out, target)
+          rescue Error
+            return nil
+          end
+          return nil unless out.bytesize == target
+          ip += csize
+        end
+        return nil unless ip == n && out.bytesize == uncompressed_size
+        out
+      end
+
+      def decode_frame(src, ip, n, out, limit)
+        raise Error, "Truncated LZ4 frame descriptor" if ip + 3 > n
+        flg = src.getbyte(ip)
+        raise Error, "Unsupported LZ4 frame version" unless (flg >> 6) == 1
+        raise Error, "LZ4 frames with dictionaries are not supported" if flg & 0x01 != 0
+        block_checksum = flg & 0x10 != 0
+        content_size = flg & 0x08 != 0
+        content_checksum = flg & 0x04 != 0
+        ip += 2 # FLG, BD
+        ip += 8 if content_size
+        ip += 1 # header checksum
+        raise Error, "Truncated LZ4 frame descriptor" if ip > n
+
+        while true
+          raise Error, "Truncated LZ4 frame block header" if ip + 4 > n
+          bsize = le32(src, ip)
+          ip += 4
+          break if bsize == 0 # EndMark
+
+          uncompressed = bsize & 0x80000000 != 0
+          bsize &= 0x7FFFFFFF
+          raise Error, "LZ4 frame block runs past end of input" if ip + bsize > n
+          if uncompressed
+            raise Error, "LZ4 output exceeds expected size" if out.bytesize + bsize > limit
+            out << src.byteslice(ip, bsize)
+          else
+            decode_block(src, ip, ip + bsize, out, limit)
+          end
+          ip += bsize
+          ip += 4 if block_checksum
+        end
+        ip += 4 if content_checksum
+        raise Error, "Truncated LZ4 frame" if ip > n
+        ip
+      end
+
+      private_class_method :binary, :le32, :u32, :write_length, :emit_last_literals,
+        :decode_block, :try_hadoop, :decode_frame
+    end
+  end
+end

data/lib/herringbone/codecs/snappy.rb

@@ -0,0 +1,375 @@
+# frozen_string_literal: true
+
+module Herringbone
+  module Codecs
+    # Pure-Ruby implementation of the raw Snappy block format (as used by Parquet),
+    # see https://github.com/google/snappy/blob/main/format_description.txt
+    #
+    # 32-bit loads are done with four getbyte calls rather than unpack1(offset:) to stay
+    # compatible with Ruby 3.0 - the speed difference on MRI is marginal.
+    module Snappy
+      class Error < StandardError; end
+
+      BLOCK_SIZE = 1 << 16
+      HASH_BITS = 14
+      HASH_SHIFT = 32 - HASH_BITS
+      HASH_MUL = 0x1e35a7bd
+      INPUT_MARGIN = 15 # bytes at the block end never searched for matches, as in the reference
+      MAX_UNCOMPRESSED = (1 << 32) - 1
+
+      module_function
+
+      # @param input [String] raw snappy block
+      # @return [String] decompressed bytes in ASCII-8BIT
+      def decompress(input)
+        src = input.encoding == Encoding::BINARY ? input : input.b
+        return decompress_io_buffer(src) if IOBufferSupport::AVAILABLE
+        decompress_string(src)
+      end
+
+      # Decompresses into a preallocated IO::Buffer: copies do not allocate intermediate Strings.
+      def decompress_io_buffer(src)
+        n = src.bytesize
+        expected, pos = read_varint(src, n)
+        return "".b if expected.zero? && pos == n
+        out = IO::Buffer.new([expected, 1].max)
+        inbuf = IO::Buffer.for(src)
+        op = 0
+        while pos < n
+          tag = src.getbyte(pos)
+          pos += 1
+          kind = tag & 3
+          if kind == 0
+            len = tag >> 2
+            if len >= 60
+              nbytes = len - 59
+              raise Error, "truncated literal length" if pos + nbytes > n
+              len = 0
+              nbytes.times { |i| len |= src.getbyte(pos + i) << (8 * i) }
+              pos += nbytes
+            end
+            len += 1
+            raise Error, "literal overruns input" if pos + len > n
+            raise Error, "output exceeds declared length" if op + len > expected
+            out.copy(inbuf, op, len, pos)
+            op += len
+            pos += len
+            next
+          elsif kind == 1
+            raise Error, "truncated copy" if pos >= n
+            len = ((tag >> 2) & 7) + 4
+            offset = ((tag >> 5) << 8) | src.getbyte(pos)
+            pos += 1
+          elsif kind == 2
+            raise Error, "truncated copy" if pos + 2 > n
+            len = (tag >> 2) + 1
+            offset = src.getbyte(pos) | (src.getbyte(pos + 1) << 8)
+            pos += 2
+          else
+            raise Error, "truncated copy" if pos + 4 > n
+            len = (tag >> 2) + 1
+            offset = src.getbyte(pos) | (src.getbyte(pos + 1) << 8) |
+              (src.getbyte(pos + 2) << 16) | (src.getbyte(pos + 3) << 24)
+            pos += 4
+          end
+          raise Error, "invalid copy offset #{offset}" if offset == 0 || offset > op
+          raise Error, "output exceeds declared length" if op + len > expected
+          if offset >= len
+            out.copy(out, op, len, op - offset)
+          else
+            # Overlapping copy of a pattern with period `offset`: each copy doubles the
+            # replicated region, and never overlaps its own source.
+            from = op - offset
+            done = 0
+            step = offset
+            while done < len
+              chunk = len - done
+              chunk = step if chunk > step
+              out.copy(out, op + done, chunk, from)
+              done += chunk
+              step <<= 1
+            end
+          end
+          op += len
+        end
+        raise Error, "decompressed #{op} bytes, expected #{expected}" if op != expected
+        out.get_string(0, expected)
+      ensure
+        inbuf&.free
+      end
+
+      def decompress_string(src)
+        n = src.bytesize
+        expected, pos = read_varint(src, n)
+        out = String.new(capacity: expected, encoding: Encoding::BINARY)
+
+        while pos < n
+          tag = src.getbyte(pos)
+          pos += 1
+
+          case tag & 3
+          when 0 # literal
+            len = tag >> 2
+            if len >= 60
+              nbytes = len - 59
+              raise Error, "truncated literal length" if pos + nbytes > n
+              len = 0
+              nbytes.times { |i| len |= src.getbyte(pos + i) << (8 * i) }
+              pos += nbytes
+            end
+            len += 1
+            raise Error, "literal overruns input" if pos + len > n
+            raise Error, "output exceeds declared length" if out.bytesize + len > expected
+            out << src.byteslice(pos, len)
+            pos += len
+            next
+          when 1 # copy, 1-byte offset
+            raise Error, "truncated copy" if pos >= n
+            len = ((tag >> 2) & 7) + 4
+            offset = ((tag >> 5) << 8) | src.getbyte(pos)
+            pos += 1
+          when 2 # copy, 2-byte offset
+            raise Error, "truncated copy" if pos + 2 > n
+            len = (tag >> 2) + 1
+            offset = src.getbyte(pos) | (src.getbyte(pos + 1) << 8)
+            pos += 2
+          else # copy, 4-byte offset
+            raise Error, "truncated copy" if pos + 4 > n
+            len = (tag >> 2) + 1
+            offset = src.getbyte(pos) | (src.getbyte(pos + 1) << 8) |
+              (src.getbyte(pos + 2) << 16) | (src.getbyte(pos + 3) << 24)
+            pos += 4
+          end
+
+          produced = out.bytesize
+          raise Error, "invalid copy offset #{offset}" if offset == 0 || offset > produced
+          raise Error, "output exceeds declared length" if produced + len > expected
+
+          if offset >= len
+            out << out.byteslice(produced - offset, len)
+          else
+            # Overlapping copy: the source is a pattern with period `offset`. Double it
+            # until it covers `len` (keeps whole periods, so it stays in phase).
+            pattern = out.byteslice(produced - offset, offset)
+            pattern << pattern while pattern.bytesize < len
+            out << pattern.byteslice(0, len)
+          end
+        end
+
+        raise Error, "decompressed #{out.bytesize} bytes, expected #{expected}" if out.bytesize != expected
+        out
+      end
+
+      # @param input [String] bytes to compress
+      # @return [String] raw snappy block in ASCII-8BIT
+      def compress(input)
+        src = input.encoding == Encoding::BINARY ? input : input.b
+        n = src.bytesize
+        raise Error, "input too large for snappy" if n > MAX_UNCOMPRESSED
+
+        out = String.new(capacity: 32 + n + n / 6, encoding: Encoding::BINARY)
+        write_varint(out, n)
+        table = Array.new(1 << HASH_BITS, 0)
+        start = 0
+        while start < n
+          len = n - start
+          len = BLOCK_SIZE if len > BLOCK_SIZE
+          table.fill(0)
+          compress_block(src, start, len, out, table)
+          start += len
+        end
+        out
+      end
+
+      def read_varint(src, n)
+        value = 0
+        shift = 0
+        pos = 0
+        while true
+          raise Error, "truncated length preamble" if pos >= n
+          byte = src.getbyte(pos)
+          pos += 1
+          value |= (byte & 0x7f) << shift
+          break if byte < 0x80
+          shift += 7
+          raise Error, "length preamble too long" if shift > 28
+        end
+        raise Error, "declared length too large" if value > MAX_UNCOMPRESSED
+        [value, pos]
+      end
+
+      def write_varint(out, value)
+        while value >= 0x80
+          out << ((value & 0x7f) | 0x80)
+          value >>= 7
+        end
+        out << value
+      end
+
+      # Mirrors CompressFragment from the reference implementation. Table entries are
+      # positions relative to `base`; matches never cross the block boundary.
+      # The 4-byte little-endian word at every position of the block is unpacked up front
+      # (in C, via String#unpack) so hashing and match checks are single Array lookups.
+      def compress_block(src, base, len, out, table)
+        ip_end = base + len
+        next_emit = base
+
+        if len >= INPUT_MARGIN
+          words = block_words(src, base, len)
+          ip_limit = ip_end - INPUT_MARGIN
+          ip = base + 1
+          next_hash = ((words[1][0] * HASH_MUL) & 0xffffffff) >> HASH_SHIFT
+          done = false
+
+          until done
+            # Scan for a 4-byte match, skipping faster the longer we find nothing.
+            skip = 32
+            next_ip = ip
+            candidate = nil
+            while true
+              ip = next_ip
+              h = next_hash
+              next_ip = ip + (skip >> 5)
+              skip += 1
+              if next_ip > ip_limit
+                done = true
+                break
+              end
+              rel_next = next_ip - base
+              next_hash = ((words[rel_next & 3][rel_next >> 2] * HASH_MUL) & 0xffffffff) >> HASH_SHIFT
+              rel = table[h]
+              candidate = base + rel
+              table[h] = ip - base
+              rel_ip = ip - base
+              break if words[rel_ip & 3][rel_ip >> 2] == words[rel & 3][rel >> 2]
+            end
+            break if done
+
+            emit_literal(out, src, next_emit, ip - next_emit)
+
+            # Emit copies for as long as the position right after a copy matches again.
+            while true
+              matched = 4 + match_length_words(words, src, base, candidate + 4, ip + 4, ip_end)
+              emit_copy(out, ip - candidate, matched)
+              ip += matched
+              next_emit = ip
+              if ip >= ip_limit
+                done = true
+                break
+              end
+              rel_ip = ip - base
+              prev = rel_ip - 1
+              table[((words[prev & 3][prev >> 2] * HASH_MUL) & 0xffffffff) >> HASH_SHIFT] = prev
+              cur = words[rel_ip & 3][rel_ip >> 2]
+              h = ((cur * HASH_MUL) & 0xffffffff) >> HASH_SHIFT
+              rel = table[h]
+              candidate = base + rel
+              table[h] = rel_ip
+              break unless cur == words[rel & 3][rel >> 2]
+            end
+            break if done
+
+            ip += 1
+            rel_ip = ip - base
+            next_hash = ((words[rel_ip & 3][rel_ip >> 2] * HASH_MUL) & 0xffffffff) >> HASH_SHIFT
+          end
+        end
+
+        emit_literal(out, src, next_emit, ip_end - next_emit) if next_emit < ip_end
+      end
+
+      # words[k][j] is the 4-byte little-endian value at base + 4 * j + k, so the word at
+      # relative position i is words[i & 3][i >> 2]
+      def block_words(src, base, len)
+        Array.new(4) { |k| src.byteslice(base + k, len - k).unpack("V*") }
+      end
+
+      # Like match_length, but compares 4 bytes at a time using the unpacked block words,
+      # which avoids allocating substrings for the (common) short matches.
+      def match_length_words(words, src, base, s1, s2, limit)
+        start = s2
+        r1 = s1 - base
+        r2 = s2 - base
+        last_word = limit - base - 4
+        while r2 <= last_word && words[r1 & 3][r1 >> 2] == words[r2 & 3][r2 >> 2]
+          r1 += 4
+          r2 += 4
+          return (base + r2 - start) + match_length(src, base + r1, base + r2, limit) if r2 - (start - base) >= 64
+        end
+        s1 = base + r1
+        s2 = base + r2
+        while s2 < limit && src.getbyte(s1) == src.getbyte(s2)
+          s1 += 1
+          s2 += 1
+        end
+        s2 - start
+      end
+
+      # Number of equal bytes at s1 and s2 (s1 < s2), not reading past limit. Gallops
+      # with byteslice comparisons (memcmp) to avoid per-byte loops on long matches.
+      def match_length(src, s1, s2, limit)
+        start = s2
+        return 0 if s2 >= limit || src.getbyte(s1) != src.getbyte(s2)
+
+        step = 8
+        growing = true
+        while step > 0
+          if s2 + step <= limit && src.byteslice(s1, step) == src.byteslice(s2, step)
+            s1 += step
+            s2 += step
+            if growing
+              step <<= 1 if step < 4096
+            else
+              step >>= 1
+            end
+          else
+            growing = false
+            step >>= 1
+          end
+        end
+        s2 - start
+      end
+
+      def emit_literal(out, src, pos, len)
+        return if len == 0
+        n = len - 1
+        if n < 60
+          out << (n << 2)
+        elsif n < 0x100
+          out << (60 << 2) << n
+        elsif n < 0x10000
+          out << (61 << 2) << (n & 0xff) << (n >> 8)
+        elsif n < 0x1000000
+          out << (62 << 2) << (n & 0xff) << ((n >> 8) & 0xff) << (n >> 16)
+        else
+          out << (63 << 2) << (n & 0xff) << ((n >> 8) & 0xff) << ((n >> 16) & 0xff) << (n >> 24)
+        end
+        out << src.byteslice(pos, len)
+      end
+
+      # Offsets are always < 64KB (matches stay within a block), so 4-byte offsets are never needed.
+      def emit_copy(out, offset, len)
+        while len >= 68
+          emit_copy_upto64(out, offset, 64)
+          len -= 64
+        end
+        if len > 64
+          emit_copy_upto64(out, offset, 60)
+          len -= 60
+        end
+        emit_copy_upto64(out, offset, len)
+      end
+
+      def emit_copy_upto64(out, offset, len)
+        if len < 12 && offset < 2048
+          out << (1 | ((len - 4) << 2) | ((offset >> 8) << 5)) << (offset & 0xff)
+        else
+          out << (2 | ((len - 1) << 2)) << (offset & 0xff) << (offset >> 8)
+        end
+      end
+
+      private_class_method :decompress_io_buffer, :decompress_string, :read_varint, :write_varint, :compress_block, :block_words, :match_length_words,
+        :match_length, :emit_literal, :emit_copy, :emit_copy_upto64
+    end
+  end
+end