From 6519529e3016bb9add323741bba6841439bc6fac Mon Sep 17 00:00:00 2001 From: James Ross Date: Sun, 15 Nov 2026 17:56:21 -0800 Subject: [PATCH 1/2] Changelog: the lumen-image crate and its inflate decoder Opens the work on the zlib decoder of ADR 0012; the entry is refined as the code lands. Issue: flyingrobots/lumen#195 Agent-Session: 7659171b-5ea2-4675-adcf-cb84ac79c847 Agent-Tool: Claude Code --- CHANGELOG.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 91ceaee..e1205bf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -100,6 +100,11 @@ part was built. - **The image hash and the PNG**: `sha256:` and the lowercase hex SHA-256 of the raw RGBA8 bytes (ADR 0009), with Lumen's own SHA-256; a PNG encoder with stored deflate blocks, whose bytes are a fixed function of the pixels (`write_png`, `png_len`). (flyingrobots/lumen#2.) +- **Image decoding, `lumen-image`** (ADR 0012): a workspace crate with no dependency and no + float, inside the deterministic core, that `lumen` depends on. It decompresses a zlib stream + (RFC 1950 and 1951: stored, fixed- and dynamic-Huffman blocks, the Adler-32 check) into a + caller-limited output, refusing every malformed stream with a typed error and its byte + offset. (flyingrobots/lumen#195.) - **Tests**: hand-derived radiance, shadows against exact geometry, every ray and every sample against brute force and an independent composition, order independence, counts against oracles other than the counting code, golden image hashes and content digests (one value for From 24511dfa0b1f7879bf58db3967774646f5cedd2e Mon Sep 17 00:00:00 2001 From: James Ross Date: Sun, 15 Nov 2026 18:04:42 -0800 Subject: [PATCH 2/2] wip: lumen-image inflate decoder, corpus and hand-assembled tests (unbuilt) Checkpoint at the maintainer's pause. The crate is not yet a workspace member nor a dependency of lumen, so nothing compiles it; no test or gate has run on it. Issue: flyingrobots/lumen#195 Agent-Session: 7659171b-5ea2-4675-adcf-cb84ac79c847 Agent-Tool: Claude Code --- crates/lumen-image/Cargo.toml | 15 + crates/lumen-image/src/inflate.rs | 144 +++ crates/lumen-image/src/inflate/adler32.rs | 24 + crates/lumen-image/src/inflate/bits.rs | 99 ++ crates/lumen-image/src/inflate/blocks.rs | 161 +++ crates/lumen-image/src/inflate/error.rs | 202 ++++ crates/lumen-image/src/inflate/huffman.rs | 101 ++ crates/lumen-image/src/inflate/output.rs | 81 ++ crates/lumen-image/src/lib.rs | 37 + crates/lumen-image/tests/corpus/corpus.table | 36 + crates/lumen-image/tests/corpus/empty.raw | 0 crates/lumen-image/tests/corpus/empty.zlib | Bin 0 -> 8 bytes .../lumen-image/tests/corpus/final_stored.raw | 50 + .../tests/corpus/final_stored.zlib | Bin 0 -> 1545 bytes .../tests/corpus/fixed_strategy.raw | 272 ++++++ .../tests/corpus/fixed_strategy.zlib | Bin 0 -> 5342 bytes .../lumen-image/tests/corpus/hand_streams.py | 27 + .../lumen-image/tests/corpus/huffman_only.raw | 297 ++++++ .../tests/corpus/huffman_only.zlib | 11 + crates/lumen-image/tests/corpus/level_1.raw | 528 ++++++++++ crates/lumen-image/tests/corpus/level_1.zlib | Bin 0 -> 10675 bytes crates/lumen-image/tests/corpus/level_2.zlib | Bin 0 -> 10443 bytes crates/lumen-image/tests/corpus/level_3.zlib | Bin 0 -> 9645 bytes crates/lumen-image/tests/corpus/level_4.zlib | Bin 0 -> 9420 bytes crates/lumen-image/tests/corpus/level_5.zlib | Bin 0 -> 8845 bytes crates/lumen-image/tests/corpus/level_6.zlib | Bin 0 -> 8305 bytes crates/lumen-image/tests/corpus/level_7.zlib | Bin 0 -> 8268 bytes crates/lumen-image/tests/corpus/level_8.zlib | Bin 0 -> 8266 bytes crates/lumen-image/tests/corpus/level_9.zlib | Bin 0 -> 8266 bytes .../lumen-image/tests/corpus/make_corpus.py | 236 +++++ .../lumen-image/tests/corpus/max_distance.raw | Bin 0 -> 33026 bytes .../tests/corpus/max_distance.zlib | Bin 0 -> 34564 bytes crates/lumen-image/tests/corpus/noise.raw | Bin 0 -> 20000 bytes crates/lumen-image/tests/corpus/noise.zlib | Bin 0 -> 20016 bytes crates/lumen-image/tests/corpus/one_byte.raw | 1 + crates/lumen-image/tests/corpus/one_byte.zlib | Bin 0 -> 9 bytes crates/lumen-image/tests/corpus/rle.raw | 265 +++++ crates/lumen-image/tests/corpus/rle.zlib | Bin 0 -> 10487 bytes crates/lumen-image/tests/corpus/run_258.raw | 1 + crates/lumen-image/tests/corpus/run_258.zlib | Bin 0 -> 43 bytes .../lumen-image/tests/corpus/short_text.raw | 2 + .../lumen-image/tests/corpus/short_text.zlib | 3 + .../lumen-image/tests/corpus/small_window.raw | 260 +++++ .../tests/corpus/small_window.zlib | Bin 0 -> 6525 bytes .../lumen-image/tests/corpus/stored_multi.raw | 920 ++++++++++++++++++ .../tests/corpus/stored_multi.zlib | Bin 0 -> 70016 bytes .../lumen-image/tests/corpus/stored_small.raw | 14 + .../tests/corpus/stored_small.zlib | 14 + crates/lumen-image/tests/hand.rs | 401 ++++++++ crates/lumen-image/tests/writer/mod.rs | 106 ++ 50 files changed, 4308 insertions(+) create mode 100644 crates/lumen-image/Cargo.toml create mode 100644 crates/lumen-image/src/inflate.rs create mode 100644 crates/lumen-image/src/inflate/adler32.rs create mode 100644 crates/lumen-image/src/inflate/bits.rs create mode 100644 crates/lumen-image/src/inflate/blocks.rs create mode 100644 crates/lumen-image/src/inflate/error.rs create mode 100644 crates/lumen-image/src/inflate/huffman.rs create mode 100644 crates/lumen-image/src/inflate/output.rs create mode 100644 crates/lumen-image/src/lib.rs create mode 100644 crates/lumen-image/tests/corpus/corpus.table create mode 100644 crates/lumen-image/tests/corpus/empty.raw create mode 100644 crates/lumen-image/tests/corpus/empty.zlib create mode 100644 crates/lumen-image/tests/corpus/final_stored.raw create mode 100644 crates/lumen-image/tests/corpus/final_stored.zlib create mode 100644 crates/lumen-image/tests/corpus/fixed_strategy.raw create mode 100644 crates/lumen-image/tests/corpus/fixed_strategy.zlib create mode 100644 crates/lumen-image/tests/corpus/hand_streams.py create mode 100644 crates/lumen-image/tests/corpus/huffman_only.raw create mode 100644 crates/lumen-image/tests/corpus/huffman_only.zlib create mode 100644 crates/lumen-image/tests/corpus/level_1.raw create mode 100644 crates/lumen-image/tests/corpus/level_1.zlib create mode 100644 crates/lumen-image/tests/corpus/level_2.zlib create mode 100644 crates/lumen-image/tests/corpus/level_3.zlib create mode 100644 crates/lumen-image/tests/corpus/level_4.zlib create mode 100644 crates/lumen-image/tests/corpus/level_5.zlib create mode 100644 crates/lumen-image/tests/corpus/level_6.zlib create mode 100644 crates/lumen-image/tests/corpus/level_7.zlib create mode 100644 crates/lumen-image/tests/corpus/level_8.zlib create mode 100644 crates/lumen-image/tests/corpus/level_9.zlib create mode 100644 crates/lumen-image/tests/corpus/make_corpus.py create mode 100644 crates/lumen-image/tests/corpus/max_distance.raw create mode 100644 crates/lumen-image/tests/corpus/max_distance.zlib create mode 100644 crates/lumen-image/tests/corpus/noise.raw create mode 100644 crates/lumen-image/tests/corpus/noise.zlib create mode 100644 crates/lumen-image/tests/corpus/one_byte.raw create mode 100644 crates/lumen-image/tests/corpus/one_byte.zlib create mode 100644 crates/lumen-image/tests/corpus/rle.raw create mode 100644 crates/lumen-image/tests/corpus/rle.zlib create mode 100644 crates/lumen-image/tests/corpus/run_258.raw create mode 100644 crates/lumen-image/tests/corpus/run_258.zlib create mode 100644 crates/lumen-image/tests/corpus/short_text.raw create mode 100644 crates/lumen-image/tests/corpus/short_text.zlib create mode 100644 crates/lumen-image/tests/corpus/small_window.raw create mode 100644 crates/lumen-image/tests/corpus/small_window.zlib create mode 100644 crates/lumen-image/tests/corpus/stored_multi.raw create mode 100644 crates/lumen-image/tests/corpus/stored_multi.zlib create mode 100644 crates/lumen-image/tests/corpus/stored_small.raw create mode 100644 crates/lumen-image/tests/corpus/stored_small.zlib create mode 100644 crates/lumen-image/tests/hand.rs create mode 100644 crates/lumen-image/tests/writer/mod.rs diff --git a/crates/lumen-image/Cargo.toml b/crates/lumen-image/Cargo.toml new file mode 100644 index 0000000..0afb782 --- /dev/null +++ b/crates/lumen-image/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "lumen-image" +description = "Lumen's image decoders: integer-only, with no dependency (ADR 0012)." +authors.workspace = true +edition.workspace = true +license.workspace = true +repository.workspace = true +rust-version.workspace = true +version.workspace = true +keywords = ["zlib", "inflate", "deterministic"] +categories = ["compression"] +publish = false + +[lints] +workspace = true diff --git a/crates/lumen-image/src/inflate.rs b/crates/lumen-image/src/inflate.rs new file mode 100644 index 0000000..8f375f5 --- /dev/null +++ b/crates/lumen-image/src/inflate.rs @@ -0,0 +1,144 @@ +//! This module owns zlib decompression: the RFC 1950 frame (a two-byte header, deflate blocks, +//! an Adler-32 trailer) and the entry points. +//! +//! The rules the decoder holds to, beyond the RFCs' own: +//! +//! - **A preset dictionary is refused** (`FDICT` set), by name: no caller supplies one. +//! - **Distances are checked twice**: against the bytes decoded so far, and against the window +//! the header declares (`CINFO`, 256 to 32 768 bytes), as zlib's own decoder does. +//! - **Incomplete codes**: a literal/length or distance code whose lengths do not fill the code +//! space is refused, except a code of exactly one symbol of length 1 (RFC 1951 section 3.2.7 +//! allows one distance code of one bit; zlib accepts the same shape in either alphabet) and a +//! distance code with no symbols at all (a block of literals only). Reading the unused bit +//! pattern of such a code is refused. The code-length code must be complete. +//! - **Trailing bytes are an error**: the stream must end at its Adler-32 trailer. +//! +//! Byte offsets in errors count from the start of the stream (for [`inflate_zlib_chunks`], of +//! the chunks' concatenation). A fault is reported at the byte holding the last bit read when +//! it was found; a truncation at the stream's length, the first byte that is missing. + +mod adler32; +mod bits; +mod blocks; +mod error; +mod huffman; +mod output; +#[cfg(test)] +mod tests; + +pub use error::{Alphabet, InflateError, InflateErrorKind}; + +use bits::BitReader; +use output::Output; + +/// The identity of the decoder's contract: which zlib streams it accepts (the rules above and +/// in [`InflateErrorKind`]) and what it returns for them. An accepted stream's output is fixed +/// by RFC 1951; a change to what is refused makes a new identity. +pub const INFLATE_ID: &str = "lumen-zlib-inflate/1"; + +/// The most bytes a decode may produce, from the caller. +/// +/// A stream whose output would pass it is refused with [`InflateErrorKind::OutputLimit`] as soon +/// as a block declares or decodes the first byte beyond it, and the output's buffer never +/// requests capacity beyond it. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct OutputLimit { + bytes: usize, +} + +impl OutputLimit { + /// A limit of `bytes` decoded bytes; zero admits only an empty stream. + #[must_use] + pub const fn new(bytes: usize) -> Self { + Self { bytes } + } + + /// The limit in bytes. + #[must_use] + pub const fn bytes(self) -> usize { + self.bytes + } +} + +/// Decompresses the zlib stream `stream` into at most `limit` bytes. +/// +/// Allocates the returned vector, at most `limit` bytes of capacity; reads nothing outside +/// `stream`. +/// +/// # Errors +/// +/// An [`InflateError`] for a malformed or truncated stream, a bad Adler-32 check, bytes after +/// the trailer, or an output beyond `limit`; its [`kind`](InflateError::kind) names the fault. +/// +/// # Panics +/// +/// Does not panic. +pub fn inflate_zlib(stream: &[u8], limit: OutputLimit) -> Result, InflateError> { + inflate_zlib_chunks(&[stream], limit) +} + +/// Decompresses one zlib stream stored as the concatenation of `chunks`, in order, into at most +/// `limit` bytes: a PNG file's `IDAT` chunk data, passed without copying them together. Empty +/// chunks are allowed, and a chunk boundary may fall anywhere, even inside a code. Error offsets +/// count from the start of the first chunk. +/// +/// # Errors +/// +/// As [`inflate_zlib`]. +/// +/// # Panics +/// +/// Does not panic. +pub fn inflate_zlib_chunks( + chunks: &[&[u8]], + limit: OutputLimit, +) -> Result, InflateError> { + let mut input = BitReader::new(chunks); + let window = header(&mut input)?; + let mut output = Output::new(limit.bytes, window); + blocks::inflate(&mut input, &mut output)?; + trailer(&mut input, output.bytes())?; + Ok(output.into_bytes()) +} + +/// Reads the two header bytes (RFC 1950 section 2.2) and returns the window size they declare. +fn header(input: &mut BitReader<'_>) -> Result { + let cmf = input.byte()?; + let flg = input.byte()?; + let at = |kind| InflateError::new(kind, input.last_offset()); + if (u16::from(cmf) << 8 | u16::from(flg)) % 31 != 0 { + return Err(at(InflateErrorKind::HeaderCheck { cmf, flg })); + } + if cmf & 0x0f != 8 { + return Err(at(InflateErrorKind::CompressionMethod { method: cmf & 0x0f })); + } + let cinfo = cmf >> 4; + if cinfo > 7 { + return Err(at(InflateErrorKind::WindowSize { cinfo })); + } + if flg & 0x20 != 0 { + return Err(at(InflateErrorKind::PresetDictionary)); + } + Ok(1 << (cinfo + 8)) +} + +/// Reads the Adler-32 trailer after the last block (RFC 1950 section 2.2), checks it against +/// `decoded` and refuses anything after it. +fn trailer(input: &mut BitReader<'_>, decoded: &[u8]) -> Result<(), InflateError> { + input.align(); + let mut stored = 0_u32; + for _ in 0..4 { + stored = stored << 8 | u32::from(input.byte()?); + } + let computed = adler32::adler32(decoded); + if stored != computed { + let kind = InflateErrorKind::Adler32Mismatch { stored, computed }; + return Err(InflateError::new(kind, input.last_offset())); + } + let trailing = input.remaining(); + if trailing != 0 { + let kind = InflateErrorKind::TrailingBytes { count: trailing }; + return Err(InflateError::new(kind, input.next_offset())); + } + Ok(()) +} diff --git a/crates/lumen-image/src/inflate/adler32.rs b/crates/lumen-image/src/inflate/adler32.rs new file mode 100644 index 0000000..bc78768 --- /dev/null +++ b/crates/lumen-image/src/inflate/adler32.rs @@ -0,0 +1,24 @@ +//! This module owns the Adler-32 checksum of RFC 1950 section 8. + +/// The largest prime below 2^16. +const MODULUS: u32 = 65_521; + +/// The most bytes summed before reducing: the largest `n` with +/// `255 n (n + 1) / 2 + (n + 1) (MODULUS - 1) < 2^32`, so neither sum can overflow (zlib's +/// `NMAX`). +const RUN: usize = 5_552; + +/// The Adler-32 of `bytes`: the high half is the sum of the running sums, the low half one +/// plus the sum of the bytes, both modulo 65 521. +pub(super) fn adler32(bytes: &[u8]) -> u32 { + let (mut low, mut high) = (1_u32, 0_u32); + for run in bytes.chunks(RUN) { + for &byte in run { + low += u32::from(byte); + high += low; + } + low %= MODULUS; + high %= MODULUS; + } + high << 16 | low +} diff --git a/crates/lumen-image/src/inflate/bits.rs b/crates/lumen-image/src/inflate/bits.rs new file mode 100644 index 0000000..344bb74 --- /dev/null +++ b/crates/lumen-image/src/inflate/bits.rs @@ -0,0 +1,99 @@ +//! This module owns reading the input: bytes from a sequence of slices, and bits from those +//! bytes least significant first (RFC 1951 section 3.1.1). + +use super::error::{InflateError, InflateErrorKind}; + +/// A reader of bits and bytes over the concatenation of its chunks. +/// +/// Invariant: `held < 8` between calls, so the last byte taken holds every buffered bit, and +/// the bit most recently read is in byte `taken - 1`. +pub(super) struct BitReader<'a> { + chunks: &'a [&'a [u8]], + /// The chunk being read, and the position in it. + chunk: usize, + at: usize, + /// Bytes taken from the input so far. + taken: usize, + /// Bits taken but not yet read, the next one lowest, and how many. + buffer: u32, + held: u32, +} + +impl<'a> BitReader<'a> { + pub(super) fn new(chunks: &'a [&'a [u8]]) -> Self { + Self { chunks, chunk: 0, at: 0, taken: 0, buffer: 0, held: 0 } + } + + /// The offset of the byte that holds the last bit read (zero before any). + pub(super) fn last_offset(&self) -> usize { + self.taken.saturating_sub(1) + } + + /// The offset of the next byte to be taken. + pub(super) fn next_offset(&self) -> usize { + self.taken + } + + /// The next whole byte, after the bits already read are discarded by [`Self::align`]. + pub(super) fn byte(&mut self) -> Result { + while let Some(chunk) = self.chunks.get(self.chunk) { + if let Some(&byte) = chunk.get(self.at) { + self.at += 1; + self.taken = self.taken.saturating_add(1); + return Ok(byte); + } + self.chunk += 1; + self.at = 0; + } + Err(InflateError::new(InflateErrorKind::Truncated, self.taken)) + } + + /// The next `count` bits (at most 16) as an integer, the first read lowest. + pub(super) fn bits(&mut self, count: u32) -> Result { + debug_assert!(count <= 16, "at most 16 bits at a time"); + while self.held < count { + // `held < count <= 16`, so the byte lands below bit 24. + self.buffer |= u32::from(self.byte()?) << self.held; + self.held += 8; + } + let value = self.buffer & ((1 << count) - 1); + self.buffer >>= count; + self.held -= count; + Ok(value) + } + + /// Discards the bits left in the current byte, so the next read starts on a byte boundary. + pub(super) fn align(&mut self) { + self.buffer = 0; + self.held = 0; + } + + /// Copies the next `count` whole bytes into `out`, as a stored block's data. Call after + /// [`Self::align`]. + pub(super) fn copy(&mut self, count: usize, out: &mut Vec) -> Result<(), InflateError> { + let mut left = count; + while left > 0 { + let Some(chunk) = self.chunks.get(self.chunk) else { + return Err(InflateError::new(InflateErrorKind::Truncated, self.taken)); + }; + let rest = chunk.get(self.at..).unwrap_or_default(); + let take = rest.len().min(left); + out.extend_from_slice(rest.get(..take).unwrap_or_default()); + self.at += take; + self.taken = self.taken.saturating_add(take); + left -= take; + if left > 0 { + self.chunk += 1; + self.at = 0; + } + } + Ok(()) + } + + /// The bytes not yet taken, in every chunk. + pub(super) fn remaining(&self) -> usize { + let current = self.chunks.get(self.chunk).map_or(0, |c| c.len().saturating_sub(self.at)); + let later = self.chunks.get(self.chunk + 1..).unwrap_or_default(); + later.iter().fold(current, |sum, c| sum.saturating_add(c.len())) + } +} diff --git a/crates/lumen-image/src/inflate/blocks.rs b/crates/lumen-image/src/inflate/blocks.rs new file mode 100644 index 0000000..66851c9 --- /dev/null +++ b/crates/lumen-image/src/inflate/blocks.rs @@ -0,0 +1,161 @@ +//! This module owns the deflate blocks of RFC 1951 section 3.2: their headers, the stored, +//! fixed-Huffman and dynamic-Huffman forms, and the literal, length and distance symbols. + +use super::bits::BitReader; +use super::error::{Alphabet, InflateError, InflateErrorKind}; +use super::huffman::{CodeFault, Huffman}; +use super::output::Output; + +/// The base length of length symbols 257 to 285, and their extra bits (section 3.2.5). +const LENGTH_BASE: [u16; 29] = [ + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, + 163, 195, 227, 258, +]; +const LENGTH_EXTRA: [u8; 29] = + [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0]; + +/// The base distance of distance symbols 0 to 29, and their extra bits (section 3.2.5). +const DISTANCE_BASE: [u16; 30] = [ + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, + 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, +]; +const DISTANCE_EXTRA: [u8; 30] = + [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]; + +/// The order in which a dynamic block lists the code-length code's lengths (section 3.2.7). +const CODE_LENGTH_ORDER: [usize; 19] = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]; + +/// The end-of-block symbol. +const END_OF_BLOCK: u16 = 256; + +/// Decodes blocks into `output` until the one marked final. +pub(super) fn inflate(input: &mut BitReader<'_>, output: &mut Output) -> Result<(), InflateError> { + loop { + let last = input.bits(1)? == 1; + match input.bits(2)? { + 0 => stored(input, output)?, + 1 => { + let (literals, distances) = fixed(); + codes(input, output, &literals, &distances)?; + } + 2 => { + let (literals, distances) = dynamic(input)?; + codes(input, output, &literals, &distances)?; + } + _ => return Err(InflateError::new(InflateErrorKind::ReservedBlockType, input.last_offset())), + } + if last { + return Ok(()); + } + } +} + +/// A stored block (section 3.2.4): to the byte boundary, `LEN`, `NLEN`, then `LEN` bytes. +fn stored(input: &mut BitReader<'_>, output: &mut Output) -> Result<(), InflateError> { + input.align(); + let mut field = || -> Result { + let low = input.byte()?; + Ok(u16::from_le_bytes([low, input.byte()?])) + }; + let (len, nlen) = (field()?, field()?); + if len != !nlen { + let kind = InflateErrorKind::StoredLengthMismatch { len, nlen }; + return Err(InflateError::new(kind, input.last_offset())); + } + output.stored(input, usize::from(len)) +} + +/// The fixed codes (section 3.2.6): literal/length 0-143 of 8 bits, 144-255 of 9, 256-279 of 7, +/// 280-287 of 8; all 32 distance codes of 5 bits. Both are complete. +fn fixed() -> (Huffman, Huffman) { + let mut lengths = [8_u8; 288]; + lengths[144..256].fill(9); + lengths[256..280].fill(7); + (Huffman::canonical(Alphabet::LiteralLength, &lengths), Huffman::canonical(Alphabet::Distance, &[5; 32])) +} + +/// A dynamic block's header (section 3.2.7): the counts, the code-length code, then the +/// literal/length and distance code lengths it encodes. +fn dynamic(input: &mut BitReader<'_>) -> Result<(Huffman, Huffman), InflateError> { + let literal_count = 257 + input.bits(5)?; + let distance_count = 1 + input.bits(5)?; + let length_count = 4 + input.bits(4)?; + let too_many = |alphabet, count: u32| { + let count = u16::try_from(count).unwrap_or(u16::MAX); + InflateError::new(InflateErrorKind::TooManyCodes { alphabet, count }, input.last_offset()) + }; + if literal_count > 286 { + return Err(too_many(Alphabet::LiteralLength, literal_count)); + } + if distance_count > 30 { + return Err(too_many(Alphabet::Distance, distance_count)); + } + let mut code_lengths = [0_u8; 19]; + for &symbol in CODE_LENGTH_ORDER.iter().take(usize::try_from(length_count).unwrap_or(19)) { + code_lengths[symbol] = u8::try_from(input.bits(3)?).unwrap_or(0); + } + let code_lengths = build(input, Alphabet::CodeLength, &code_lengths)?; + let (literal_count, total) = (literal_count as usize, (literal_count + distance_count) as usize); + let mut lengths = [0_u8; 286 + 30]; + let mut filled = 0; + while filled < total { + let symbol = code_lengths.decode(input)?; + let (value, repeat) = match symbol { + 0..=15 => (u8::try_from(symbol).unwrap_or(0), 1), + 16 => { + let previous = filled.checked_sub(1).and_then(|i| lengths.get(i)).copied(); + let previous = previous.ok_or(InflateError::new(InflateErrorKind::RepeatWithoutLength, input.last_offset()))?; + (previous, 3 + input.bits(2)?) + } + 17 => (0, 3 + input.bits(3)?), + _ => (0, 11 + input.bits(7)?), + }; + let end = filled + repeat as usize; + let run = lengths.get_mut(filled..end).filter(|_| end <= total); + run.ok_or(InflateError::new(InflateErrorKind::CodeLengthsOverrun, input.last_offset()))?.fill(value); + filled = end; + } + if lengths[usize::from(END_OF_BLOCK)] == 0 { + return Err(InflateError::new(InflateErrorKind::MissingEndOfBlock, input.last_offset())); + } + let literals = build(input, Alphabet::LiteralLength, &lengths[..literal_count])?; + let distances = build(input, Alphabet::Distance, &lengths[literal_count..total])?; + Ok((literals, distances)) +} + +/// The code of `lengths` in `alphabet`, or the error for its fault at the current offset. +fn build(input: &BitReader<'_>, alphabet: Alphabet, lengths: &[u8]) -> Result { + Huffman::new(alphabet, lengths).map_err(|fault| { + let kind = match fault { + CodeFault::OverSubscribed => InflateErrorKind::OverSubscribedCode { alphabet }, + CodeFault::Incomplete => InflateErrorKind::IncompleteCode { alphabet }, + }; + InflateError::new(kind, input.last_offset()) + }) +} + +/// A Huffman-coded block's symbols (section 3.2.5), to its end-of-block symbol. +fn codes(input: &mut BitReader<'_>, output: &mut Output, literals: &Huffman, distances: &Huffman) -> Result<(), InflateError> { + loop { + let symbol = literals.decode(input)?; + let invalid = |alphabet, symbol| InflateError::new(InflateErrorKind::InvalidSymbol { alphabet, symbol }, input.last_offset()); + match symbol { + 0..=255 => output.literal(u8::try_from(symbol).unwrap_or(0), input.last_offset())?, + END_OF_BLOCK => return Ok(()), + _ => { + let index = usize::from(symbol - 257); + let (Some(&base), Some(&extra)) = (LENGTH_BASE.get(index), LENGTH_EXTRA.get(index)) else { + return Err(invalid(Alphabet::LiteralLength, symbol)); + }; + let length = usize::from(base) + input.bits(u32::from(extra))? as usize; + let symbol = distances.decode(input)?; + let index = usize::from(symbol); + let (Some(&base), Some(&extra)) = (DISTANCE_BASE.get(index), DISTANCE_EXTRA.get(index)) else { + return Err(invalid(Alphabet::Distance, symbol)); + }; + let distance = usize::from(base) + input.bits(u32::from(extra))? as usize; + output.copy_match(distance, length, input.last_offset())?; + } + } + } +} diff --git a/crates/lumen-image/src/inflate/error.rs b/crates/lumen-image/src/inflate/error.rs new file mode 100644 index 0000000..fcea15c --- /dev/null +++ b/crates/lumen-image/src/inflate/error.rs @@ -0,0 +1,202 @@ +//! This module owns the decoder's errors: what was refused, and where. + +use core::fmt; + +/// A refused zlib stream: the fault, and the byte offset where it was found (see the +/// [crate documentation](crate) for how offsets are counted). +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct InflateError { + kind: InflateErrorKind, + offset: usize, +} + +impl InflateError { + pub(super) const fn new(kind: InflateErrorKind, offset: usize) -> Self { + Self { kind, offset } + } + + /// What was refused. + #[must_use] + pub const fn kind(&self) -> &InflateErrorKind { + &self.kind + } + + /// The offset, from the start of the stream, of the byte where the fault was found: the + /// byte holding the last bit read, or for [`InflateErrorKind::Truncated`] the stream's + /// length, and for [`InflateErrorKind::TrailingBytes`] the first byte after the trailer. + #[must_use] + pub const fn offset(&self) -> usize { + self.offset + } +} + +/// One of the three Huffman alphabets of a deflate block (RFC 1951 section 3.2.7). +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub enum Alphabet { + /// The code lengths' own code, of 19 symbols, that a dynamic block's header uses. + CodeLength, + /// Literal bytes, the end of the block and match lengths: 286 symbols, 288 codes. + LiteralLength, + /// Match distances: 30 symbols, 32 codes. + Distance, +} + +/// Why a zlib stream was refused. +#[derive(Clone, Debug, PartialEq, Eq)] +#[non_exhaustive] +pub enum InflateErrorKind { + /// The two header bytes, read as a big-endian number, are not a multiple of 31. + HeaderCheck { + /// The first header byte (`CMF`). + cmf: u8, + /// The second header byte (`FLG`). + flg: u8, + }, + /// The compression method is not 8 (deflate). + CompressionMethod { + /// The method the header names. + method: u8, + }, + /// The window size field is above 7 (a window over 32 768 bytes). + WindowSize { + /// The field (`CINFO`). + cinfo: u8, + }, + /// The header asks for a preset dictionary (`FDICT`), which no caller supplies. + PresetDictionary, + /// A block has the reserved type 3. + ReservedBlockType, + /// A stored block's length is not the complement of its check field. + StoredLengthMismatch { + /// The length field (`LEN`). + len: u16, + /// The check field (`NLEN`). + nlen: u16, + }, + /// A dynamic block declares more literal/length or distance codes than the alphabet has + /// symbols (over 286 or 30). + TooManyCodes { + /// The alphabet. + alphabet: Alphabet, + /// How many codes the block declares. + count: u16, + }, + /// A code's lengths give more codes than the code space holds. + OverSubscribedCode { + /// The alphabet. + alphabet: Alphabet, + }, + /// A code's lengths leave part of the code space unused, outside the shapes the decoder + /// admits (one symbol of length 1; no distance symbol at all). + IncompleteCode { + /// The alphabet. + alphabet: Alphabet, + }, + /// A repeat of the previous code length (symbol 16) comes first. + RepeatWithoutLength, + /// The code lengths run past the number of codes the block declares. + CodeLengthsOverrun, + /// The end-of-block symbol (256) has no code. + MissingEndOfBlock, + /// The bits read are the unused pattern of an incomplete code. + UnusedCode { + /// The alphabet. + alphabet: Alphabet, + }, + /// A fixed block's code for a symbol outside the alphabet: literal/length 286 or 287, or + /// distance 30 or 31. + InvalidSymbol { + /// The alphabet. + alphabet: Alphabet, + /// The symbol. + symbol: u16, + }, + /// A match reaches back past the first decoded byte. + DistanceTooFar { + /// The match's distance. + distance: usize, + /// The bytes decoded before the match. + available: usize, + }, + /// A match reaches back past the window the header declares. + DistanceBeyondWindow { + /// The match's distance. + distance: usize, + /// The window size in bytes. + window: usize, + }, + /// The stream ends before its last block or its trailer does. + Truncated, + /// The Adler-32 trailer does not match the decoded bytes. + Adler32Mismatch { + /// The trailer's value. + stored: u32, + /// The Adler-32 of the decoded bytes. + computed: u32, + }, + /// Bytes follow the Adler-32 trailer. + TrailingBytes { + /// How many. + count: usize, + }, + /// The output would pass the caller's limit. + OutputLimit { + /// The limit in bytes. + limit: usize, + }, +} + +impl fmt::Display for Alphabet { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(match self { + Self::CodeLength => "code-length", + Self::LiteralLength => "literal/length", + Self::Distance => "distance", + }) + } +} + +impl fmt::Display for InflateErrorKind { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + Self::HeaderCheck { cmf, flg } => { + write!(f, "header check failed: {cmf:#04x} {flg:#04x} is not a multiple of 31") + } + Self::CompressionMethod { method } => write!(f, "compression method {method} is not deflate"), + Self::WindowSize { cinfo } => write!(f, "window size field {cinfo} is over 7"), + Self::PresetDictionary => f.write_str("a preset dictionary is not supported"), + Self::ReservedBlockType => f.write_str("reserved block type 3"), + Self::StoredLengthMismatch { len, nlen } => { + write!(f, "stored block length {len} does not match its complement {nlen}") + } + Self::TooManyCodes { alphabet, count } => write!(f, "{count} {alphabet} codes declared"), + Self::OverSubscribedCode { alphabet } => write!(f, "over-subscribed {alphabet} code"), + Self::IncompleteCode { alphabet } => write!(f, "incomplete {alphabet} code"), + Self::RepeatWithoutLength => f.write_str("code length repeat with no previous length"), + Self::CodeLengthsOverrun => f.write_str("code lengths run past the declared codes"), + Self::MissingEndOfBlock => f.write_str("the end-of-block symbol has no code"), + Self::UnusedCode { alphabet } => write!(f, "unused {alphabet} code"), + Self::InvalidSymbol { alphabet, symbol } => write!(f, "invalid {alphabet} symbol {symbol}"), + Self::DistanceTooFar { distance, available } => { + write!(f, "distance {distance} reaches before the output's {available} bytes") + } + Self::DistanceBeyondWindow { distance, window } => { + write!(f, "distance {distance} is beyond the {window}-byte window") + } + Self::Truncated => f.write_str("the stream is truncated"), + Self::Adler32Mismatch { stored, computed } => { + write!(f, "adler-32 {stored:#010x} does not match the output's {computed:#010x}") + } + Self::TrailingBytes { count } => write!(f, "{count} bytes after the trailer"), + Self::OutputLimit { limit } => write!(f, "the output passes its limit of {limit} bytes"), + } + } +} + +impl fmt::Display for InflateError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "zlib stream refused at byte {}: {}", self.offset, self.kind) + } +} + +impl core::error::Error for InflateError {} diff --git a/crates/lumen-image/src/inflate/huffman.rs b/crates/lumen-image/src/inflate/huffman.rs new file mode 100644 index 0000000..f25d609 --- /dev/null +++ b/crates/lumen-image/src/inflate/huffman.rs @@ -0,0 +1,101 @@ +//! This module owns the canonical Huffman codes of RFC 1951 section 3.2.2: building a code from +//! its lengths, with the completeness rules of the [module above](super), and decoding a symbol +//! bit by bit. + +use super::bits::BitReader; +use super::error::{Alphabet, InflateError, InflateErrorKind}; + +/// The longest code any alphabet uses. +const MAX_BITS: usize = 15; + +/// The most codes in any alphabet (the fixed literal/length code's 288). +const MAX_SYMBOLS: usize = 288; + +/// A canonical Huffman code: how many codes there are of each length, and the symbols in code +/// order (by length, then by symbol). +pub(super) struct Huffman { + alphabet: Alphabet, + counts: [u16; MAX_BITS + 1], + symbols: [u16; MAX_SYMBOLS], + longest: usize, +} + +/// Why a set of lengths makes no code the decoder admits. +#[derive(Debug, PartialEq, Eq)] +pub(super) enum CodeFault { + OverSubscribed, + Incomplete, +} + +impl Huffman { + /// The code whose symbol `s` has length `lengths[s]` (0: no code), refused if it is + /// over-subscribed or incomplete beyond the shapes [the module above](super) admits. + /// `lengths` holds at most 288 entries, each at most 15: the callers' alphabets guarantee + /// both. + pub(super) fn new(alphabet: Alphabet, lengths: &[u8]) -> Result { + let code = Self::canonical(alphabet, lengths); + // The code space left after each length; negative means more codes than room. + let mut left: i32 = 1; + for &count in code.counts.iter().skip(1) { + left = 2 * left - i32::from(count); + if left < 0 { + return Err(CodeFault::OverSubscribed); + } + } + let used: u16 = code.counts.iter().sum(); + let single = used == 1 && code.counts[1] == 1 && alphabet != Alphabet::CodeLength; + let none = used == 0 && alphabet == Alphabet::Distance; + if left > 0 && !single && !none { + return Err(CodeFault::Incomplete); + } + Ok(code) + } + + /// The canonical code of `lengths`, unchecked: for the fixed codes, which are complete. + pub(super) fn canonical(alphabet: Alphabet, lengths: &[u8]) -> Self { + let mut code = Self { alphabet, counts: [0; MAX_BITS + 1], symbols: [0; MAX_SYMBOLS], longest: 0 }; + for &length in lengths.iter().filter(|&&l| l != 0) { + if let Some(count) = code.counts.get_mut(usize::from(length)) { + *count += 1; + code.longest = code.longest.max(usize::from(length)); + } + } + // The first slot of each length in `symbols`, then each symbol in its slot. + let mut next = [0_u16; MAX_BITS + 1]; + for length in 1..MAX_BITS { + next[length + 1] = next[length] + code.counts[length]; + } + for (symbol, &length) in (0_u16..).zip(lengths) { + // Each slot is below the number of lengths, so below 288. + if let Some(slot) = next.get_mut(usize::from(length)).filter(|_| length != 0) { + if let Some(entry) = code.symbols.get_mut(usize::from(*slot)) { + *entry = symbol; + } + *slot += 1; + } + } + code + } + + /// The next symbol from `input`, reading the code most significant bit first. + pub(super) fn decode(&self, input: &mut BitReader<'_>) -> Result { + // `code` is the bits read so far; `first` the first code of the current length and + // `index` its slot in `symbols`. + let (mut code, mut first, mut index) = (0_u32, 0_u32, 0_u32); + for &count in self.counts.iter().take(self.longest + 1).skip(1) { + code |= input.bits(1)?; + let count = u32::from(count); + if code < first + count { + let slot = usize::try_from(index + code - first).unwrap_or(MAX_SYMBOLS); + if let Some(&symbol) = self.symbols.get(slot) { + return Ok(symbol); + } + } + index += count; + first = (first + count) << 1; + code <<= 1; + } + let kind = InflateErrorKind::UnusedCode { alphabet: self.alphabet }; + Err(InflateError::new(kind, input.last_offset())) + } +} diff --git a/crates/lumen-image/src/inflate/output.rs b/crates/lumen-image/src/inflate/output.rs new file mode 100644 index 0000000..c153e35 --- /dev/null +++ b/crates/lumen-image/src/inflate/output.rs @@ -0,0 +1,81 @@ +//! This module owns the decoded bytes: appending literals, stored data and matches while +//! holding the caller's limit and the header's window. + +use super::bits::BitReader; +use super::error::{InflateError, InflateErrorKind}; + +/// The first capacity requested, before the output doubles towards its limit. +const FIRST_CAPACITY: usize = 4_096; + +/// The bytes decoded so far, never more than `limit`, in a buffer that never requests capacity +/// beyond `limit`. +pub(super) struct Output { + bytes: Vec, + limit: usize, + window: usize, +} + +impl Output { + pub(super) fn new(limit: usize, window: usize) -> Self { + Self { bytes: Vec::new(), limit, window } + } + + pub(super) fn bytes(&self) -> &[u8] { + &self.bytes + } + + pub(super) fn into_bytes(self) -> Vec { + self.bytes + } + + /// Makes room for `count` more bytes, refusing (at `offset`) if they pass the limit. + /// Capacity grows by doubling, capped at the limit. + fn reserve(&mut self, count: usize, offset: usize) -> Result<(), InflateError> { + let len = self.bytes.len(); + let needed = len + .checked_add(count) + .filter(|&n| n <= self.limit) + .ok_or(InflateError::new(InflateErrorKind::OutputLimit { limit: self.limit }, offset))?; + if needed > self.bytes.capacity() { + let target = self.bytes.capacity().saturating_mul(2).max(FIRST_CAPACITY).max(needed); + self.bytes.reserve_exact(target.min(self.limit) - len); + } + Ok(()) + } + + /// Appends one literal byte. + pub(super) fn literal(&mut self, byte: u8, offset: usize) -> Result<(), InflateError> { + self.reserve(1, offset)?; + self.bytes.push(byte); + Ok(()) + } + + /// Appends a stored block's `count` bytes from `input`, after checking the limit. + pub(super) fn stored(&mut self, input: &mut BitReader<'_>, count: usize) -> Result<(), InflateError> { + self.reserve(count, input.last_offset())?; + input.copy(count, &mut self.bytes) + } + + /// Appends the `length` bytes that start `distance` bytes back, which may overlap the bytes + /// being written (a distance below the length repeats them). + pub(super) fn copy_match(&mut self, distance: usize, length: usize, offset: usize) -> Result<(), InflateError> { + let available = self.bytes.len(); + if distance > available { + return Err(InflateError::new(InflateErrorKind::DistanceTooFar { distance, available }, offset)); + } + if distance > self.window { + let window = self.window; + return Err(InflateError::new(InflateErrorKind::DistanceBeyondWindow { distance, window }, offset)); + } + self.reserve(length, offset)?; + let mut left = length; + while left > 0 { + // Each piece is at most `distance` long, so it lies wholly in the bytes written. + let start = self.bytes.len() - distance; + let piece = left.min(distance); + self.bytes.extend_from_within(start..start + piece); + left -= piece; + } + Ok(()) + } +} diff --git a/crates/lumen-image/src/lib.rs b/crates/lumen-image/src/lib.rs new file mode 100644 index 0000000..1bce3d3 --- /dev/null +++ b/crates/lumen-image/src/lib.rs @@ -0,0 +1,37 @@ +//! Lumen's image decoders, written without a dependency and without floating point +//! ([ADR 0012](https://github.com/flyingrobots/lumen/blob/main/docs/adr/0012-image-decoding.md)). +//! +//! The crate is part of Lumen's deterministic core: the nondeterminism gates of ADR 0006 read it +//! as they read `lumen`. It holds, so far, one decoder: [`inflate_zlib`], which decompresses a +//! zlib stream (RFC 1950 framing over RFC 1951 deflate blocks) into at most a caller-given +//! number of bytes. [`inflate_zlib_chunks`] does the same for a stream split across several +//! slices, as a PNG file splits its image data across `IDAT` chunks. +//! +//! Every input is either decoded or refused with an [`InflateError`] that names the fault and +//! the byte offset where it was found; no input makes the decoder panic, read past its input or +//! allocate past the caller's limit. +//! +//! # Example +//! +//! ``` +//! use lumen_image::{inflate_zlib, InflateErrorKind, OutputLimit}; +//! +//! // The zlib stream of "abc" from a standard encoder, with its Adler-32 trailer. +//! let stream = [0x78, 0x9c, 0x4b, 0x4c, 0x4a, 0x06, 0x00, 0x02, 0x4d, 0x01, 0x27]; +//! assert_eq!(inflate_zlib(&stream, OutputLimit::new(3))?, b"abc"); +//! +//! let refused = inflate_zlib(&stream, OutputLimit::new(2)).unwrap_err(); +//! assert_eq!(refused.kind(), &InflateErrorKind::OutputLimit { limit: 2 }); +//! # Ok::<(), lumen_image::InflateError>(()) +//! ``` + +// No float in the crate: `clippy.toml` bans the float types; this catches arithmetic on a float +// whose type is only inferred (docs/adr/0006-nondeterminism-gate.md). +#![deny(clippy::float_arithmetic)] + +mod inflate; + +pub use inflate::{ + inflate_zlib, inflate_zlib_chunks, Alphabet, InflateError, InflateErrorKind, OutputLimit, + INFLATE_ID, +}; diff --git a/crates/lumen-image/tests/corpus/corpus.table b/crates/lumen-image/tests/corpus/corpus.table new file mode 100644 index 0000000..12ecae9 --- /dev/null +++ b/crates/lumen-image/tests/corpus/corpus.table @@ -0,0 +1,36 @@ +| `empty` | `empty.raw` | 0 | 8 | fixed | `aca503def43dc086a5aaa5c3d6f86bcbbc2aa6a80007ddea4a81bce2b376fceb` | +| `final_stored` | `final_stored.raw` | 3700 | 1545 | dynamic, stored x2 | `3f754f95da9af9c317f0bee0b281ad9d6142881e0f8b47607384c8a7217deeda` | +| `fixed_strategy` | `fixed_strategy.raw` | 20000 | 5342 | fixed | `fac2fb0410617d404c9b7eab84af1a525cf88ad43a74df88b97220e36743a7e3` | +| `huffman_only` | `huffman_only.raw` | 20000 | 10519 | dynamic x2 | `d123a9c8e521ae7aed9b48c6f2ba3e5854b9955f742d8d4576a2d4f7af630072` | +| `level_1` | `level_1.raw` | 40000 | 10675 | dynamic | `5a8117e6f2f251ac26f4a8cd27771093762c2a685999a3d1b90b8af0d29a196b` | +| `level_2` | `level_1.raw` | 40000 | 10443 | dynamic | `64d11c3ecaaf7fe4ac958f58d28f084d36b4e29c1d9a97308a9832ab5abe5895` | +| `level_3` | `level_1.raw` | 40000 | 9645 | dynamic | `e5894073b0cbd81d5644d68f5d9a174a5c058d1c0dac56ce2e62b9886f9693a2` | +| `level_4` | `level_1.raw` | 40000 | 9420 | dynamic | `90036a448da5fa72920258ab2005f4e7d55869e5bf5e976e1dd245b882d63ead` | +| `level_5` | `level_1.raw` | 40000 | 8845 | dynamic | `8dffe3ea1c5830c413ead6ed1c8c96147caef06cc992bf1495a32fe7b7812123` | +| `level_6` | `level_1.raw` | 40000 | 8305 | dynamic | `be5b0f39d4f9a425a4890fa5f00c971374b1899d06674aaf104b8b79886df464` | +| `level_7` | `level_1.raw` | 40000 | 8268 | dynamic | `ca630fe618e2e8be80bc15757efa1c7fc00d614f6d9cc858d14eddc7f0199a6b` | +| `level_8` | `level_1.raw` | 40000 | 8266 | dynamic | `1bc2fcd2291718dd17d372dbccc7b454c0952d6e15aaa8cb570c5b31e4b087d8` | +| `level_9` | `level_1.raw` | 40000 | 8266 | dynamic | `1bc2fcd2291718dd17d372dbccc7b454c0952d6e15aaa8cb570c5b31e4b087d8` | +| `max_distance` | `max_distance.raw` | 33026 | 34564 | fixed | `883db1f9acaa21e57e31c775409ed0708ea5bf324c50aff0b6fe4e162dc6e269` | +| `noise` | `noise.raw` | 20000 | 20016 | stored x2 | `88f701ce3c1883be61cca7fe562ada7b99953348b2fce3db8f199e9fec3ae6c3` | +| `one_byte` | `one_byte.raw` | 1 | 9 | fixed | `0c5d0951f7867ca2f99c7fd5bf7ae00e477e65c20847532870ae33a81236aeab` | +| `rle` | `rle.raw` | 20000 | 10487 | dynamic x2 | `c4a7c2dd2617eb5818c722be15cc52d4b1d3328b8bc523271511ae7ca6c62d36` | +| `run_258` | `run_258.raw` | 20000 | 43 | dynamic | `2fc2d8b54a08717a2f1a405b77309df0e29a4143cd88b58ad87e6bf0e43ca624` | +| `short_text` | `short_text.raw` | 120 | 93 | dynamic | `3c3fce012ec5f5a6b0f814c95224ccb0fad1bed3843f43bf0e34d67d0afbfb5c` | +| `small_window` | `small_window.raw` | 20000 | 6525 | dynamic | `2cdb285f2ccb2143e017386e00542f5e1c3580d65b3a5437b9130eee6483a7ef` | +| `stored_multi` | `stored_multi.raw` | 70000 | 70016 | stored x2 | `2083f5a7615a535748bfbac2361dfdbff4587619338bad2f0082d1b6d6ce3dde` | +| `stored_small` | `stored_small.raw` | 1000 | 1011 | stored | `599d3a4d201f8e3dc0f4d1492fd401ba6e697df0bf2bf8797dcd1f112113c7be` | +| `empty.raw` | 0 | `e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855` | +| `final_stored.raw` | 3700 | `bc205f959cf452b364d4afad548a59832998f573a70e61d6c6950183c47264e0` | +| `fixed_strategy.raw` | 20000 | `1f8de4ce447c2b7b0c3fe8dcc3764349a24d0207e83f161388dedc54ef187957` | +| `huffman_only.raw` | 20000 | `c05f67ad3b3b141f642b6d195282dab9dab765cda3a37db38b00d31a726eeba0` | +| `level_1.raw` | 40000 | `6047bce9add3acccc284fb321cc7b60adef48f30439d6bfa581c5839d6549a6a` | +| `max_distance.raw` | 33026 | `c28970b54518a6908e371100b0bbdb6fc2c301255396a76777e7f1eda07a3f73` | +| `noise.raw` | 20000 | `a23a346a52bea99a81333db1a0288acfd6fc88f6beff3c65c1a5a6c0214d2839` | +| `one_byte.raw` | 1 | `72dfcfb0c470ac255cde83fb8fe38de8a128188e03ea5ba5b2a93adbea1062fa` | +| `rle.raw` | 20000 | `3012c9aeab22d26227fc20f366b7a71324bcd19c1f09c5d968b67cb18dc81eb4` | +| `run_258.raw` | 20000 | `cc17faaad36649c4603dda4d8ff97cb149722af0bcac0746305a2134ad2d0b97` | +| `short_text.raw` | 120 | `237411b1c8c28eca0d8b49d562b85f52e823f76e7f00f0a24f083808536ddc01` | +| `small_window.raw` | 20000 | `b47be152c1e4509497bf3d262bbd9612385e829764117bfc51306df9aa3bd097` | +| `stored_multi.raw` | 70000 | `f8b58ae9a520ad84487fabaea5e87c6b9a63d34141e838981feb600078ab328f` | +| `stored_small.raw` | 1000 | `ee351d9f8ddd78318dafb7818b3d4c713a25bdd3b38080a31cfb1011b46629d8` | diff --git a/crates/lumen-image/tests/corpus/empty.raw b/crates/lumen-image/tests/corpus/empty.raw new file mode 100644 index 0000000..e69de29 diff --git a/crates/lumen-image/tests/corpus/empty.zlib b/crates/lumen-image/tests/corpus/empty.zlib new file mode 100644 index 0000000000000000000000000000000000000000..f89cd1a721f48cf76e9f6af6b3b5359a544b45ac GIT binary patch literal 8 Ncmb=J!^{8#i~tB90T}=Q literal 0 HcmV?d00001 diff --git a/crates/lumen-image/tests/corpus/final_stored.raw b/crates/lumen-image/tests/corpus/final_stored.raw new file mode 100644 index 0000000..a9deae1 --- /dev/null +++ b/crates/lumen-image/tests/corpus/final_stored.raw @@ -0,0 +1,50 @@ +bunny returns same texture point bytes texture +every returns +texture floating light lumen returns light on on point a falls floating +bunny while a light maps renders thread without point each falls same ray floating on every bytes same the bunny same +falls lumen each on on bunny maps every floating on floating renders bunny thread thread returns bunny each +every ray floating bunny the renders light light thread returns ray +while a lumen light point floating the without texture every returns without triangles each renders ray point integer and point integer renders without a on and a +on a point same platform bunny made on platform decoded light the decoded +renders decoded integer platform light a without maps on each platform +platform point triangles bytes made +maps made while returns falls and renders bytes the count bytes without of +thread of each lumen texture ray of point light same platform renders and thread platform thread same ray ray point floating +while without a bunny +triangles ray the point returns while each integer the integer point thread of integer bunny the the integer thread integer point every floating every +bytes ray count the a triangles every every each maps maps +made without of maps floating texture +each +returns lumen thread light bytes platform thread while a triangles the falls bunny thread every light each thread ray on every returns made bytes while made lumen on and count same decoded the thread +thread without platform triangles point count the bunny platform +ray bunny on returns bytes renders renders every of bunny thread every the point the lumen on on without triangles of platform renders made integer maps same light the texture each triangles lumen bunny ray +renders each maps made decoded texture thread +every a the each platform falls renders and texture on made while falls of a floating thread and made renders made +without and the a integer returns +renders and lumen count bytes on and +point every the the each texture decoded the renders each every bunny +integer while point +bunny the decoded on on and renders count on +renders platform of each floating thread ray while thread texture each without texture bunny +and +point same bytes triangles thread integer texture on falls maps renders triangles on thread of +lumen returns on same without made +and while renders returns bunny +made point thread decoded the every ray count maps every while without a renders thread falls of triangles ray texture ray +each integer platform of decoded +made made count made and ray triangles bytes a renders the same +and bunny triangles decoded returns point on the maps without and without decoded bytes floating made maps texture the light every bytes +texture +while on a platform platform on lumen integer lumen texture triangles lumen +triangles triangles renders point point the count bunny platform light floating without same floating on platform lumen triangles lumen and decoded point falls every decoded the integer triangles of floating bunny apoint of +the on without without +integer while bunny thread returns light the triangles bunny each lumen point light platform bunny triangles decoded and integer thread returns +on returns bytes without thread bunny every the platform bytes thread returns the returns light point of on made on bunny every the +on renders made on +returns a the +on bytes triangles lumen same and point maps integer the every while and returns bunny +point thread made same bunny +renders same ray lumen bytes light maps light renders ray +count the without integer floating bunny point light +bunny light count +renders made the of returns while maps count and decoded without and decoded integer integer every bytes same on r \ No newline at end of file diff --git a/crates/lumen-image/tests/corpus/final_stored.zlib b/crates/lumen-image/tests/corpus/final_stored.zlib new file mode 100644 index 0000000000000000000000000000000000000000..22c1c2903f74eb94b24a42868388b6f8fa48d602 GIT binary patch literal 1545 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 for i in range(n)] + def huff(s,c,n): s.bits += [(c>>i)&1 for i in range(n-1,-1,-1)] + def done(s): + b=s.bits+[0]*(-len(s.bits)%8) + print(''.join(map(str,s.bits)), len(s.bits)) + return bytes(sum(b[i+j]<I',zlib.adler32(raw)) +# fixed +b=B(); b.put(1,1); b.put(1,2); b.huff(0x30+97,8); b.huff(1,7); b.huff(0,5); b.huff(0,7) +f=wrap(b.done(),b'aaaa'); print(f.hex(), zlib.decompress(f)) +# dynamic +b=B(); b.put(1,1); b.put(2,2); b.put(0,5); b.put(0,5); b.put(14,4) +order=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15] +cl={18:1,1:1} +for s in order[:18]: b.put(cl.get(s,0),3) +# code-length code: symbol 1 -> '0', symbol 18 -> '1' +b.huff(1,1); b.put(86,7) # 97 zeros +b.huff(0,1) # 'a' length 1 +b.huff(1,1); b.put(127,7) # 138 zeros +b.huff(1,1); b.put(9,7) # 20 zeros +b.huff(0,1) # 256 length 1 +b.huff(0,1) # distance 0 length 1 +b.huff(0,1); b.huff(0,1); b.huff(1,1) # a a EOB +d=wrap(b.done(),b'aa'); print(d.hex(), zlib.decompress(d)) diff --git a/crates/lumen-image/tests/corpus/huffman_only.raw b/crates/lumen-image/tests/corpus/huffman_only.raw new file mode 100644 index 0000000..1027ab2 --- /dev/null +++ b/crates/lumen-image/tests/corpus/huffman_only.raw @@ -0,0 +1,297 @@ +platform every point and the renders and +bunny same ray each lumen integer decoded bunny falls platform a +decoded +renders bunny triangles made thread bunny count point triangles +returns a while platform platform while +every same bunny count integer the every the returns each the +bunny point renders maps every without renders each texture triangles +point made platform a floating falls while texture +a triangles bunny falls on light platform integer returns floating texture maps lumen a texture bunny a +returns the platform bytes same while triangles without ray on and decoded falls bytes decoded falls renders each renders on integer integer count point and decoded +on while the bytes texture integer lumen returns maps decoded every bytes bunny every same falls lumen platform each floating platform decoded lumen made the bunny thread count +same bunny +a point made returns ray falls of every +ray decoded on on light triangles on point point a maps on a ray point a every thread +on floating a without ray of same ray decoded platform lumen same the triangles triangles the platform of texture ray +on of texture +same a triangles platform bytes platform without renders triangles while lumen the thread each the the on on returns returns count and decoded ray thread made the falls the returns and floating bunny on while returns texture +lumen maps falls the returns ray light on and on a count a bunny bunny +made +on lumen +light on without the while same point floating +count each bytes point platform falls integer triangles a decoded lumen a and each falls bytes of the while bytes +lumen decoded point texture on floating maps count every triangles platform texture a every texture point bytes +each bunny on +bunny light floating renders returns without floating the made bunny +decoded without on integer renders of +without +floating while count +the point texture triangles of bunny +count +of platform count triangles every lumen the of made and lumen the the returns light maps every count +without falls light and +ray light returns and +light made bytes made falls texture on bunny decoded platform +on returns ray a floating count maps on triangles renders maps a falls count returns thread light of +made without on +renders renders the and a the count point +light integer texture a triangles integer while falls lumen the a returns point the returns made the platform lumen integer bunny a point returns while of returns light floating same platform +a returns made light of without the integer triangles every texture every maps maps light ray a same on on triangles made renders thread on texture count +bytes platform ray +thread +triangles bytes count the maps floating thread +a every the bytes triangles +falls platform renders returns floating +floating falls +falls point every maps platform made falls of texture ray thread bunny bytes floating while on without count of made texture platform +point and bunny falls and without returns returns platform triangles falls point returns +on on bunny while and while light a point +made and without count texture on +thread falls every on the maps bunny floating each point every falls while the lumen of on the platform a same while falls point triangles +texture every made ray without count falls triangles point bytes of of lumen +integer on bunny ray of every falls +renders texture +integer point bytes +made texture same point point same light renders returns point and each +the lumen decoded returns ray +maps without triangles returns falls made made same the on renders falls light without and +maps while a falls point the returns a every made bytes without falls on every floating each decoded each the lumen of count +the returns count texture texture light without the the and without bytes each point ray bunny thread +the +made ray bytes on returns every +the made light +falls without point maps texture on maps +integer and count without floating bunny each +lumen on +light platform decoded the on bytes platform on on lumen falls +count and on falls thread on triangles triangles without bytes same a point point the every and platform ray a bunny the every a each on made thread on maps platform integer decoded integer count point count while decoded decoded bunny +on and renders returns without falls while decoded falls bunny +on without returns returns +returns +each and bytes every the bunny on on thread returns triangles maps made floating thread floating without bytes +triangles +point triangles floating and triangles and same count a the lumen the a and the the bunny same each and light on renders +each and decoded floating platform without bytes returns renders and point the bunny decoded triangles maps the lumen while platform the same on renders every +on +on bunny decoded thread and returns of floating +thread falls bytes each lumen on renders texture light bytes a the +renders bunny the same bytes +renders renders the platform floating platform and bytes falls made every bunny the +light lumen ray point ray made without returns integer renders count thread falls floating maps thread on count lumen while count renders +maps maps and platform maps triangles on returns lumen +on maps while without +a light every same each floating on ray the the triangles bytes +on falls platform falls returns every renders +and on without and thread light without the returns the thread without falls falls triangles bunny point while every the maps while +point decoded platform triangles the bytes bytes decoded without thread lumen returns falls without +texture platform on the triangles +on count falls triangles triangles of +the count count each maps the bunny while falls without floating point on decoded integer lumen on integer returns +thread integer a platform on light made of without bytes +on triangles while bunny the +same +same light while of the +on on triangles without +on without floating every integer renders falls of same renders decoded light lumen point ray on light the on floating every platform maps the while every and maps triangles thread +each floating +triangles of thread made lumen renders on platform lumen of and integer +bunny texture on and same maps +the platform texture integer decoded and made on lumen floating floating triangles made bunny maps falls triangles platform platform integer ray integer +ray a without same light point platform +bytes integer thread returns platform bunny count decoded of texture light of same lumen texture point and of count a renders the texture +thread same thread point light falls the point the renders thread renders count bunny same without light each same made floating triangles thread thread +same same returns every while a triangles point renders triangles on on and a decoded the a decoded while light and the maps count falls the on floating and point triangles returns bytes +same point on renders +returns each bytes bytes thread bytes made the +platform the the of without made same falls platform each count thread floating +bunny +returns decoded made thread +bytes of without and texture the decoded on triangles +the floating platform lumen bytes and triangles light every bunny ray every returns point bunny floating while on floating renders without lumen made ray light while every while texture while without without +the falls every falls platform count thread made the integer platform the count on bunny count while renders +the on returns without count thread bunny and count platform bunny maps platform the integer light thread platform and texture +on on and decoded a returns +platform renders integer point texture on point on without every and lumen light a falls thread falls the bytes each thread lumen bytes triangles a platform and same +a returns a ray returns every the same of every point returns lumen +on count made lumen floating while and falls ray +falls falls bytes made floating renders ray every made thread thread light without ray platform a a +the light thread integer same +on +decoded each light each +the maps maps decoded decoded +without the count every renders made integer floating each made bunny on ray the integer same of +lumen without ray integer on while made maps thread bunny lumen of light thread on integer on falls a renders light point of decoded without bunny integer thread without thread the +while every without +the each count decoded while the ray on +lumen thread maps returns point floating +while every integer point a lumen +falls platform +floating and integer lumen and ray floating of and a each maps of bunny returns ray integer falls bunny maps +thread platform platform on on the same the maps +while of the triangles on and platform on without of bunny a bunny same count bunny bytes +a texture made +triangles made point platform renders a integer a count floating bunny +count made count made floating the +a integer floating falls thread decoded of decoded lumen maps ray triangles same +texture the maps floating point the ray falls decoded maps of returns bunny while of made thread +point on maps on lumen integer platform made ray thread maps without while a while of ray of point a and on count triangles thread thread maps while texture count the renders maps every decoded +triangles without decoded +each the +platform the integer every floating +point without made texture lumen +made maps integer lumen on ray point the bunny point without of lumen bunny and maps texture point of decoded texture lumen platform triangles of on bytes without platform same light platform triangles without +the lumen made integer bunny of while ray every and and platform returns texture floating each the returns renders +point count count a returns returns point bunny and the integer triangles each on point every lumen a every floating falls +made bunny renders the count +without triangles returns while +on the count lumen returns platform on texture every returns platform bytes while platform integer bytes triangles made texture made made light without bytes and count ray count thread on every decoded same every +a and texture on point on a and while the made every count on bytes on texture ray while each the floating lumen count count maps and on same floating maps and maps texture the every floating made +same ray while thread each bunny ray on returns the each point decoded +thread bytes light ray same triangles bytes thread thread each renders a on while each the falls maps the on integer decoded while integer same a triangles on count floating same every integer integer renders +ray bunny the count +decoded renders while +and +decoded +every texture returns +made each on point bunny +while light +falls the a a bunny the made +renders renders lumen a platform decoded +bunny count and triangles renders lumen count same integer on the while lumen bytes +without made bytes +triangles platform on light made +point lumen +returns while on +thread decoded maps light triangles count floating count decoded made the platform same integer on count of on texture floating +the each same every count platform renders +each texture returns light returns texture returns maps a renders texture on same maps +on returns the a while +every each point the made integer +on on of floating while without count falls made thread +floating count same each each renders ray maps while the decoded the light light lumen without texture falls and renders +falls floating the decoded on count each made lumen texture every on texture falls decoded integer platform and each renders maps renders point each renders same texture returns platform count +on falls returns the a ray and without +light +integer on count each thread ray on decoded renders maps and ray made +bunny same the on integer made texture the renders light floating made floating and returns of point triangles platform light returns ray light without lumen bytes on made +texture ray and +floating count the +platform same renders decoded the the the +point every platform every lumen +ray texture count texture integer +integer texture bunny platform the returns maps +without bunny while decoded on triangles integer +maps +every a falls made while bunny count point every light falls renders maps platform on decoded without on point +made falls the of lumen count of bytes each +same of +point ray of on texture point renders on each and light without light integer count bytes renders thread ray integer count returns texture integer +maps lumen platform count integer and maps made triangles triangles on +the +point renders falls integer integer point same on decoded each and point the a maps bunny without on of without integer while every lumen light +platform made while made platform returns +every point maps decoded platform while bytes floating without of maps each a and bytes count same maps platform maps count bytes every of bytes lumen and count decoded thread each every +the while platform and lumen +on made texture floating the every thread +renders texture bytes thread platform on and floating bytes the ray +floating every texture thread returns on lumen same thread bytes made made maps on each +on triangles +light returns on +light integer +the thread triangles returns renders a count each a without platform on while every without +on maps point on falls integer while texture made +the while integer +maps thread floating maps +a floating on platform maps bytes bunny while and each decoded +a on thread falls texture the renders the point ray bunny made falls triangles bytes floating decoded thread of while without point same triangles the of on count same falls platform a lumen each point falls bunny +and bunny triangles thread on renders on +every the same on integer on renders on bunny on on decoded while maps texture +count +bytes made on count while of ray +each lumen the light texture the count texture of thread the each made without count ray thread texture thread on bytes and triangles count of without thread platform on maps thread on each the without point floating triangles same decoded the the +and texture triangles texture same a the triangles light made platform on of returns floating bytes point returns point light decoded bunny of the falls and light texture bytes decoded integer on returns thread without the bunny renders point integer same falls every count integer lumen falls lumen while +floating maps point same falls on platform on falls light light maps bunny while bytes decoded integer bytes made count the platform floating integer the bunny bytes thread falls point the made thread integer and count +lumen platform +triangles every every made ray same +texture renders on on bytes the of +bunny bunny point count of on triangles bunny decoded the floating a while platform decoded while made renders +each same on and each falls while a without bunny every maps while falls while +maps without a without point lumen of while lumen maps on renders platform bytes the on count bytes made decoded each the renders the floating platform made falls decoded the without while while bunny each maps decoded on returns platform ray without triangles the triangles the every without point while bunny count point without bunny without +made on +point without +returns same on maps lumen each made on the integer bytes returns of +bunny lumen texture triangles +on of bunny integer same falls count maps and and decoded on triangles the maps +count thread triangles falls falls without renders platform texture platform triangles renders returns thread without integer triangles on texture a a light of without floating texture made count lumen of without thread a texture every texture lumen triangles thread thread lumen point on returns platform +floating +falls +platform lumen +while platform every count without and maps made maps bunny decoded falls texture ray +integer triangles ray count without while ray +without bytes without returns +count lumen triangles the ray on renders texture of maps texture +same bytes bytes +every the the returns on integer lumen +bytes a ray ray bunny bytes on platform bytes count falls +same triangles the point triangles lumen count count on the +light texture floating +bunny bunny a floating maps falls on every decoded ray triangles +light bytes each platform without without count on on light same texture while floating renders same texture every made texture floating falls ray +on +count the made floating decoded each bunny the +falls bunny every platform triangles made point each on each of thread +without ray floating +on maps every lumen ray of on lumen maps floating light the +on +on maps +floating each texture made bytes of the thread floating the ray light bunny made light the a same floating triangles +renders while on floating bunny integer renders decoded returns triangles integer falls triangles on and on made the renders made renders floating of without point a on the made floating on made each integer returns the point +and the without the without and lumen platform +of thread a and integer integer every without floating +on every the made +count without the while the renders every and point and triangles light +integer maps and the on renders bunny returns point falls integer ray bytes without light +maps ray renders each lumen lumen platform point every triangles texture same bunny each the light +ray floating without point renders count platform lumen on integer falls bytes integer light returns without without bunny made +of decoded bunny texture lumen decoded falls every the +light renders on without while maps on platform renders triangles triangles same while every ray same and same without texture bytes without returns every renders +light bytes of and falls of each triangles +same while each platform +of +platform on thread of integer +count on and same +each the point falls made on decoded renders count renders +while each made texture renders +on of triangles triangles and platform without without while floating thread triangles falls +every lumen the thread renders every on triangles on light made light every floating +floating and light thread thread +triangles triangles a light bunny platform thread on of of lumen of without of bunny each on the every thread renders returns integer thread count triangles decoded ray on and a of +on triangles light ray the +and a the the count made made bunny platform every returns on ray every of lumen +every +lumen and point floating renders thread of while and every +returns thread decoded each the light falls +integer on every a same triangles lumen of floating bunny light ray on made platform without bytes lumen thread made light ray without ray falls falls the triangles floating every and +same lumen on the integer bunny made lumen the every without decoded the of light on light point maps of on +made same without bytes texture renders on thread +texture while bytes decoded of a each +the of on integer bunny maps same same platform on maps without floating on on of platform point light each count +on +platform same integer every maps the bunny the decoded bytes point every without ray falls +every and a on of every while a a bunny thread the falls the thread platform floating decoded same decoded +on ray floating floating +lumen lumen decoded the floating maps each on falls floating renders +each made renders +maps the same a on renders every renders +lumen every integer without thread bunny decoded of maps thread every without decoded renders +floating on every while the without maps on thread while a +returns texture same maps and platform texture integer the on each a each each falls same a same a and floating thread on made and without same +lumen while +integer falls each +the integer without bunny the of on ray ray on floating the decoded decoded on each +triangles and same decoded lumen lumen floating point on platform the decoded maps the platform platform triangles while of lumen decoded on a maps light platform bunny returns decoded on every light each and bytes without without while same returns platform thread +renders +bunny +made same point lumen made texture +platform returns decoded on +thread on thread each triangles on the thread texture renders r \ No newline at end of file diff --git a/crates/lumen-image/tests/corpus/huffman_only.zlib b/crates/lumen-image/tests/corpus/huffman_only.zlib new file mode 100644 index 0000000..1500114 --- /dev/null +++ b/crates/lumen-image/tests/corpus/huffman_only.zlib @@ -0,0 +1,11 @@ +xÁÑ‘¥0 À¢˜Ôôð€]%K”<>–ì¯ûqÓ•5Á¬OŽ,Ô‰b4Ö‚E;~;âòI”} �¾'#Ä›…Æ3~;âÃeî �›®¬ ;ÏllG1ká·#>¨†Åí\˜Öõ¢5üvć3wOŽTÃâv®£¨]±`xûpâqÓ•5ñ¸éÊšxûpüÇú°l¿ñáÌÂñfA�à?Öu¢¨]±@;;Ôyüvć'GÅh¬…iÏÿ±>¼C=·PŒÆZ �âŸvªaq;×ñäaZ#7]Y†ËÓ4âÆeî oNˆÚÅà·sá·#>\æ¾�w7]Y#Ä›…¢vÅÂåiqCüÓ.bÚ³à{2`ÿ´‹øíˆvµ+Ô‰ÇMWÖÄï–Mâíà հ¸� ïPÏ-”}È€ECã™� —¹/ü>q¡ñÌÆ†ËÜŠÑX ´³£�µ��âÍÂñfáÌ“#‹†Æ3Û‘�·'Ô‰ß'.ˆÚEŒo|OŠÚ Óž…Æ3ø�õá÷‰ ¿ñ�ÿX–Mâ2÷ß“�ÇMWÖí츨­áÌ:–Mâ·#¾ÃðäaZ#ŠÚ e.s_È üÇú޲�g66d >î.¨†Åí\ÈÀ“#„'G†iÏB ež!ø�õA½híÈÀåiqÃðõÜBÙ‡¼°leÏllxÜteMøž ,›„:¡·sA5,nç‚:ñ¸éÊšÈ âŸveß‘�¼ þi�e“0¨†Åí\xÜteMü>qáqÓ•5ñõÜB1kA5,nçÂÛ‡¾'ê„zÑhg‡:¡Nd E튅¢vÅ™;‹†Æ3Ê>¨­aZ#Ô‰ËÜÔ‰¢vÅ‚EÃåiqã·#>dàíÉ¢vÅ‚ø§]<|O¦= —¹/¨E튅²>î.dÀ¢!†3w†ßŽøðÛß1­ñÈ€ïÉ8|Ü]ÈÀ;Ôs êÄÛ‡Ë&ñäáò4�¸�3w´³ã÷‰ OŽ7]Y—¹/ŒoTÃâv.Ïllð=0X4ÐÎŽËÜ~Ÿ¸�Ô‰·'~Ÿ¸ß“�Æ3ž!ˆÚEdàò4�¸1íY8s‡À¬ªaq;7]YâŸvþc}ÿ´‹xr„ðûÄuÐΎߎø�qüvÄw.OÓˆÅh¬…¢vÅÂ;Ôs —§iÄ ubZ#~;â;Ïllx‡zn!#Ä›…b4ÖB^Ç;Ôs븜¹CÇ;Ôs —¹/ø¸»`ÑŽ²>î.µ+,Úáãî´Fü>qaZ#.s_ÿ´‹ÈÀoG|h<³±áqÓ•5� µ+Ê>.OÓˆgî¦= P ‹Û¹PŒÆZ˜ö,.s_8s‡PÔ®XP/Zƒ�» yÓñõÜBÆQŒÆZ(Fc-¨ uâÌ“#tø¸»0B¼Yÿ´‹0¨†Åí\!Þ,¼}8q™û‚ïÉ€:a(jW,<9BP'ŠÚ Ó¡NL{¦= >î.”}0,›D2 ·saZ#ŠÑX êEkÈ€ø§]Ä™;tü>qáqÓ•5QöêEk‡jXÜÎ…ß'.œ¹CP'¦= —§iÄ õ¢µÃÀ¬êÄïTÃâv®ã2÷…ÇMWÖD1k¡¨]±pyšFÜÇåiqã2÷u\æ¾ðä�ÿX¦= �›®¬‰i�¸Ì}!/ˆÚE”}P/ZÃoG|ø}âÂåiqãíÉ ¼C=·pæ!/Lk„ø§]Äã¦+kOŽ,~;âÃeî  ïPÏ-µ+ŠÚ �›®¬ Õ°¸� —¹/<9B(jW¬#øíˆoNX4¼}8áãî‚áÉ:¦5¢áê¹…3wâŸv‡zÑ.s_à?Ö‡ ¨Óž…ߎøpyšFÜ �OŽø�õá2÷…·'Ô ß“�¼�uâqÓ•5aX6‰·'.s_xr„ ·sâŸvüÇú0­eÞ¡ž[8s‡p™û‚jXÜÎ…'G¿O\È yÁ÷d#Ä›… üvć²y�ÿX.s_G1kAüÓ.#Ä›…'G¿O\Ç´FˆÚE,›Ä“#„'GË&áãîB1k¡¨]±ðäÁ¢�vöC�ð=h<³±¡¨]±PöÓž…w¨çTÃâv.µ+.s_˜Öˆi�X6 u"Åh¬…ËÜ|Ü]x‡znÁ¢Óž…·' —¹/<9BP'ŠÚ þc}˜Öˆß'.¼C=·p™ûBø�õáò4�¸A;;Ïll �ê„ïÉ@^8s‡u¢¨]±pæAüÓ.BüÓ.ÂÇÝ…w¨çÔ u¢áê¹…ß'.ÐÎŽ'Ge~;âƒzÑÚ¡ÎcZ#Ê>ü>q!EíŠþc}‡:1­>î®ã2÷…w¨çž!L{Ä?í"20íYÇñfÁ¢áÌÂ;Ôs —§iÄ�ߎø@;ûá{2�qø¸»ð¸éÊšh<³±A�ÈÀï7]YÈ€ïÉÀeîë8s‡`Ñ��ËÜÔ‹Ö�Õ°¸� ªaq;Þ¡ž[ø}â²Iž!<9BP'ø�õÁ¢áqÓ•5QöÁðÛÔ þc}0ÐÎŽ Lk„zÑ20íYxÜteMŒoÏll!Þ,œ¹Cxr„pæáíÉÆ3ÏlløíˆïÈ€EC1k¡¨]±ðõÜÂeî oN4žÙØp™ûÂoG|GÞ¡ž[(jW,µ+ÖQÔ®Xíì°hø}âÿ±>¨¿ñ!P/ZCQ»bA5,nç´gaZ#.OÓˆêEk¸Ô‹Öp™ûÂïhg‡ïÉ@ŠÑX âŸv>î.ü>qÁ Î£�µðÛÔ‰e“ø}â:ŠÑX Åh¬uâqÓ•5qyšFÜxÜteMX4ü>qá2÷…i�à?ևߎø ÎÃÇÝß“�²OŽÊ>LkÄ;Ôs E튅âÍB1káÌ‚zÑ.s_¸œx‡znwø�õaÙ$hgÇåiq#eÔ uB5,nçÂïב�ËÜ7]Y—¹/µ+ø�õ¡�µ‹† ¼C=·`Ñ ^´wÞ¡ž[P'ŠÚ ê„zÑÞ¡ž[¸Ì}á2÷Õ°¸� ¿ñáÉÂÛ‡üÇú NL{Þ>œÇ“#„Æ37]Yªaq;Ô‰ß'.ü>q¡ñÌÆ†w¨çÔ‹Öà{2PÔ®X¸Ì}áê¹uˆÚEî.¼}8‘Ôyd ªaq;Þ¡ž[GÞ¡ž[¸î.øž <9B(û�wÔ‰ \ž¦7ø�õáqÓ•51íYP'Þ>œà?Ö‹†iÏ‚jXÜÎõ¢µƒvv\ž¦÷¡·s!/¨­aZ#|OŠÑX xÜteMøž 䋆âÍ:~;âƒø§]D,–MbÚ³uâqÓ•5!þi1B¼Yh<³±Á¢aZ#2à{2pyšFܸq!/¼C=·`Ñ þi¡N4žÙØ�Õ°¸�ëP'.OÓˆ�›®¬ ß“�ß'.X4¨†Åí\ðqw�ÿX~;âCÙþc}(jW,<9Bøíˆ—§iÄ�·'2pyšFÜ(Fc-¼C=·à{20­e|Ü]xûp‚ÿXÞ>œÿ´‹xûpâê¹…w¨çÖ¡N\æ¾À¬—¹/¨Ë&‘ø�õáÉBQ»bÁ÷d8s‡0­¾'—§iÄ�·',.s_(ûŽËÜ.s_ø}â´F\ž¦7ŠÑX eø�õaZ#Ô‹Ö ^´wÞ¡ž[(ûð¸éÊš0Ø¡Nø¸» ^´†âͲÉ#ãh<³±�vvø¸»@;û¡NL{¦= �g664žÙØŽw¨çÔ‰3wüÇúPŒÆZ˜ÖˆâÍÂåiqƒvvLkÄoG|È@Ùub„x³°ly¾'ïPÏ-”}!Þ,dàíÉi�˜ö,¨­á·#>øž äwÔ‹Ö��âÍB.s_0£±|Ü]xr„�Ïllx‡zná·#>ŒoÔ‹ÖðõÜ‚zÑÔy¼}8Á¬ïPÏ­C� �gîÏllxûpB�(û�qøž ¨­aÚ³PÔ®Xxr„pyšFÜÇÛ‡üÇú0B¼Yxr„`ð=Çeî �›®¬y\ž¦7,Fˆ7 ¾' e.OÓˆyÁ¢Á@;;¦= yá·#>µ+Ê>Œo.s_øíˆÓžu¨­áqÓ•5ñ¸éÊšÈ@Ô‰e“P'¦=ëxûp"/¨ªaq;2`Ñð¸éÊšÈÀ;Ôs yá·#>~;âòIœ¹Cøíˆ¿O\‡AüÓ.bZã¡·saZ#ž!¨†Åí\X6yˆÚE¨Óž…ËÓ4âÆ“#u¢ìÃeî �g66L{òBQ»bá·#>¼}8‘¦5B½híxr„��iÏB|OFˆ7 �›®¬‰i�(û ^´†iÏÂ;Ôs oNÞ>œÈ eò“#ƒECÎÜ!¨†Åí\P/ZƒzѦ= oNˆÚEœ¹CP'ŠÑX Óžþc}h<³±ªaq;Þ¡ž[h<³±´³C�Çã¦+kB�!Þ,ðëÃåiqOŽÞ¡ž[˜ÖñO»ß“qLkÄ´ga„x³à{2��²OŽԉߎøðäáê¹…¼à{2ðÛ,¦= âŸvOŽòBã™� âŸv¾'�›®¬ Õ°¸� y!¿O\x‡znáqÓ•5±l>î.µ+7]Y¿O\xûpâqÓ•51B¼Yø}â‚jXÜÎ…i�ÿ´‹˜Öˆi�ðqwáê¹…ß'.X4œ¹C(ûpæA½h à?Ö‡Æ3–M‚ÿXßa°hÿ´‹ÈÀ“#„ ,Þ>œP'¦5‚ÿXÎÜ!dà÷‰ ÿ´‹(ûðöáíìP'.OÓˆ¾'gîÎÜ!L{,2°l—§iÄ�iÏ‚EôgAüÓ.B�à?Ö‡ËÓ4âÆ´ÆcÙ$Ê>¼}8¡^´ÚÙñÛÊ>d ¨]± NÐÎŽ'G�g6¶C½h ¿O\ðqw¡ìòI¨†Åí\ø}â‚zÑÔ‹Ö@;;ŠÑX † ¼}8A;;Ô‰Ëܦ= êDFˆ7 �g66¼}81B¼YX6 ƒjXÜÎ… œ¹C¸ŒoFˆ7 Åh¬u”}øíˆêÄ™;t4žÙØPŒÆZxûpíh<³±üÇú þiQÔ®XÇ´FÐÎŽ <9BøíˆïxûpÂÇÝu\æ¾ N ¿ñA�˜Öx£±ŠÑX ¾'†ÇMWÖDã™�íøíˆgî,TÃâv.£±|OÎÜ!,›Äñf!êÄÛ‡¾'¿O\Ç;Ôs ÓñûÄu¨†Åí\xÜteMdÀÇÝ…i�Ç“#ß“qµ+Þ>œÈ8Ô‹ÖÐxfcôgÁÇÝÕ°¸� gî.OÓˆgîÏll˜ÖuâqÓ•5±l#Ä›… œ¹CÈ ÿ´‹¸î.øž ¼C=· þiq™û‚EC1k—¹/\ž¦7Ô‰Æ32pæ�vvLk„ïÉ€ø§]ÿ±>d@üÓ.â2÷…Æ3Fˆ7 �›®¬ ‹ÚÙQŒÆZ˜ö,£±ž!ÐÎŽb4Ö²IˆÚEµ+7]YgîБ�ËÜŠÚ ê„¡ìƒEÃ;Ôsëðqw#Ä›… œ¹C �êEk(û��Æ3ŠÑX Óž‹†²Ó�ߎø°lêDFˆ7 Ó!þi¡N£±|Ü]¸î.ŒoÎÜ!ü>q¡�µ ^´†²#Ä›…3wEíŠñO»ˆâÍ:¦= ¾'�›®¬‰3w#Ä›‹†iÏ´F¨†Åí\P ‹Û¹�q¨óxr„PŒÆZ¸Ì}a„x³0B¼Yxr„°lh<³±�vvX4<9BP' Óž…ߎøðõÜBòÂ;Ôs #Ä›…·'ø�õÁ÷dÀÇÝuœø}âÂåiqãê¹…¼0íY �‹†ß'.œ¹CX6‰iÏÂã¦+kbÚ³pæá÷‰ üÇú�~Ÿ¸à{2`Ñpæ¡ñÌÆõ¢5ÐÎþc}‡:ñöáÄã¦+k¢Á÷d˜ÖñO»ˆËÓ4â†:Á¬êEkG1kAüÓ.â÷‰ êEkxÜteMdÀ¢áò4�¸ñûÄu¢ì;.OÓˆüÇú þi¡^´†¢vÅB|O–MB½h ¿O\˜Öˆi�˜ö,d€vö#ªaq;×áãîBQ»b!ãðqwa„x³uB½h ªaq;ŠÚ Åh¬Ù;ÚÙax‡znáqÓ•5‘�·'ø�õáê¹ud`Ú³ðä!—¹/ŒoÞ>œÿ´‹˜Öx¨oNŒoÖ1íYP/ZÃåiqcÚ³Ãåiq#�›®¬‰iÏÂï~;âÃÛ‡ ´³£ñÌÆv2 ^´†ËÜÄ?í"Ô‰b4Ö‚:ñä¡ìÃoG|˜ÖˆËÜTÃâv.ü>qáò4�¸ÑxfcƒzÑòÂÛ‡ïPÏ-<9BX6 Õ°¸� êD^ÈÀ™;„e“¸Ì}áqÓ•5að= �OŽ.s_øíˆï°høíˆªaq;Ô‹Ö��b4ÖBÆÁ¬êIJId`„x³��b4ÖB~;âC2ÐxfcÃÛ‡ÓžñO»xœ¹CÇï¦5"gîÞ>œÈ eßA;;|OÔ wÄ?í"Ô‰3wâŸvyA½h êíì˜Öˆw¨çÎÜ!”}P/Zƒø§]„zÑ2ðûċհ¸� gîòÂ;Ôs êEkxÜteMd`Ú³ ^´† ÐÎuâê¹…'G—§iÄ Õ°¸� Ë&Ñxfcƒ:¡ÎâAüÓ.B5,nç‚ø§]IJIÔ Õ°¸� >î.LkÄã¦+k"y¡¨]±pyšFÜø}â“#„¢vÅ“#wÏlløíˆyA�¸Ì}Á¢ÁÇÝñO»ˆß'.4žÙØ0B¼YÈ@Q»bA½h ïPÏ-¨¿ñ¡�µðäa„x³°l—¹/ðëÙ;„âÍ‚ïÉÀeî ¾'oÎãò4�¸1íYxr„°l—¹/dàqÓ•5‘�ËÜ|Ü]ðqwaÚ³ðÛÞ>œø}âBã™� #Ä›…ß'.LkÄ™;uâqÓ•5qyšFÜ!Þ,¨¿ñá÷‰ êEk¸Ì}áÉ‚:1­êEk!Þ,X4œ¹C‡ïÉÀã¦+kªaq;ø�õ�ÿX¦5¢ìòÉCüÓ.¢�µ�� ü>qA�Èëøíˆ¿ñáÉ™;„¼�Õ°¸� ¿ñ¡ñÌÆuâò4�¸axûpâqÓ•5ÑxfcÃÛ‡ÓQŒÆZíìX6‰ X4ÐÎŽËÜÞ>œ0¼C=·ðÛø�õaÚ³ðöáÄeî oÎcÚ³ðõÜ‚áê¹…'G¾'yáíà ߓ�iÏBŠÑX �›®¬‰ß'.¨8s‡ðûÄ…i�h<³±�vv¨Åh¬uâò4�¸ñ¸éÊš˜ÖˆËÜÏllP'Þ¡ž[xûpâíÉߎø@;;¦= �g66d ¨]±ð¸éÊš(ûðõÜ‚jXÜÎuB5,nç‚:Á¬ïPÏ-<9Bxûpâ·#>œ¹Cxr„ðõÜÂoG|x‡znÓ‘q<9Bx‡znE튅e“ÈÀ´gÁ÷d€vvLkDÔ‰âÍÂïŠÚ y¿ñÁ÷d@üÓ.B5,nç:2�~;âÃñfaÙ$.s_8s‡0íY°h°hh<³±!ªaq;Ô‰iÏ:ÎÜ!¨­A5,nçÂeî —¹/¼C=·PŒÆZxÜteMˆÚEœ¹Cx‡znÁ¢aÚ³0­Óž…ߎøÐxfcÃeî âŸveß1B¼YP ‹Û¹PöáÌÂ;Ôs oN”}Ç;Ôs ¿O\x‡zn¡¨]±Ž3w¾'ªaq;Ô‰²(Fc-ˆÚEä…iÏ‚ø§]<–Mâ÷‰ ¿O\ÿ±>¨êDQ»b!#ěߓqü>qÁPö¡ìÃoG|ø}âB7]Y¿O\8s‡p™û:–MB5,nç‚:ñäA5,nç‚ïÉÀ™;„3wPçáãî‚ø§]Äåiq¿ñá·#>.OÓˆÓž…ËÜ2À¬�g66”}P ‹Û¹w~Ÿ¸@;;7]YïPÏ-¼C=·pæ!ðqwaÙ$Ä?í"Þ>œ¸\ž¦÷‘�iÏÿoÇ–Ã ÿŤÆ1£GB×ëì·û�ùÁ΢#åC4„Ã΢cɳÑ,¤¦wØì£PƒWøŽ%Ͼš…ÔôÊ=PüW'‰%Jü¾âF4Ô j$EÑ,¤¦wÔ R>Øì£ð;î–(a³�B B°eÍBjzGåïÆ}%]™ï˜F„£YHMïø÷Ó‹�‰¤+sCy‡R‘¬“¾Q9Å»qcz±3ÑÄl£rŠwãF8ÄáX¢D "éÊÜX¢DÒ•¹Ñ,¤¦wDÃ;kÄ)<1½ G b‰ÍBjzG8–(A¹¦;É:é5ˆ'¦×%®¨A¼³FœB â�5âÄv�IµÈuEC�¤(âŠéÅÎÄôbg‚ÌﬧÐ,¤¦÷+üc~¨A,Q^w/¼³FœB âÓˆDÒ•¹Á?æqÅÓ âŠÊ)Þ�6û¨kz±3±äÙWÔ Â‘tenüŽû‡d�ô�'¦š˜mL/v&R>ü¾âÆ;kÄ)Øì£®%ÏFʇ¤+sƒrØYtØYt<&Õ"ž˜^àóCåïÆ�â¿:IlYÄ︠Ü5›}Ô•ò¡YHMïxg�8…'¦’®Ì�;Ž“j‘ vá˜^ìL41Ûø}Å�éÅ΄Í> +É:éﬧðÎq +¿ãþa‰òŠåJÅï¸(þ«“„�E‡ò¥¢‰Ùÿ˜jð²ÙG!éÊÜÇ;kÄ)¼c±äÙÇcR-r!éÊܨœâݸQ9Å»qcË"Þ1�àóCʇ-‹WlYÄ;kÄ)ÿÕIâ÷7ÞY#N!Y'}ƒÌIWæ¾löQø}Å�hW41ÛˆÊ=P9Å»q_[ñŽiåxLªE®+Úõ˜T‹\G�¤(¢az±3¯;ŽÂ!®Ø²xQî�ÄÓ MÌ6–(åJEÒ•¹qÇñBÒ•¹¯wL#(÷À%Šÿê$‘teî+ÑP9Å»q£rŠwㆸâ1©¹ðÎq +ﬧðŽiD³�šÞQ#)ŠÊ)Þ�MÌöÅ?æ;‹ŽD�¤(’®Ì þ1?„£rŠwãF8löQX¢„Í> +üc~hRÓûÕ,¤¦wˆ+löQ¨‘E�¤èU9Å»q£rŠwã†Àf…ßqÿð˜T‹\¨‘E8¢!ì,:¢á�5â¢áwÜ?Pî�pÔ øÇüP#)Ф+s#Y'}cz±3Q#)Š;Ž*§x7n(ïP*R>„C\!ˆv…£rŠwã†Í> +)jðWj5ˆ;Ž–(±D‰ßqÿð˜T‹\àóC²NúF8R>ð�ù!ì,úÅ?æwÙYtˆ+ž˜^hRÓ;’®Ì�IQDÃ;¦â +þ1¿+Y'}£FRÊ;” +Ê=Pƒ°ÙG¡‰Ù¾¦;áàóƒ`Ë"*§x7nØYtDC³�šÞñ;îlöQHùŽ%J<&Õ"ÞY#Ná÷7ì,:j$E±D ›}R>¼³FœBʇ&fMÌ6j•S¼7š…Ôôþ1?ˆëµevá¨AL/v&~ÇýÃ%ì,:jüc~xg�8åJE "löQ‡Í> +OL/,y6¢!üZ¢Ä–E¼³FœÂï+nÿÕI"éÊÜG�¤èUüW'‰wL#~_qCy‡R Ê=®D4„cz±3ñ;î–<[±e�IµÈ…p,y6ÞY#N¡YHMïG8¢á1©¹ðÄô‚Í> +”{àŽãu…_�IµÈ…-‹˜^ìLð�ùaɳQƒø÷5åJÅï+n<1½À?æ‡wÖˆSHùÐÄl_üc~W üc~xÇ4B ø÷5’¢¨A41Û¨AÔHŠâ1©¹Ð,¤¦w(ïP*¶,By‡R¯p¤|hRÓ;š…Ôô~ÙYtØYt(ïP*jÍBjzÇ’gƒr„£‰ÙF³�šÞ‘teî‹r,Q"éÊÜ×’g£±e‚p$]™üc~Hº2÷egÑÁ?æ‡éÅÎÄ;kÄ)ÔHŠâwÜ?(ïP*¢aɳQ#) +þ1?¼³Fœ‚ò¥"éÊÜW³�šÞþ1?¼cQƒxg�8…%ÏF8j$EñŽi„\É:éÅu’زˆ%φ¸â1©¹PüW'‰éÅÎD "”{@@¹(÷@³�-‹lY„@\Ñ,¤¦wÔHŠ"K”W¼³FœÂ–ÅË΢ãÓxM/v&š˜mPîqÕ ¦;ﬧð;îjÑŽ”)ÂÑ,¤¦wÔ ”w(Ê;”ŠpPîqUNñnÜWlY„ò¥Â΢Ã΢£YHMïxbz!�IµÈ…„ò¥bɳQƒxLªE.<&Õ"*§x7n¼c vÊ;”Šp–<6û(<&Õ"~ÇýC²Nú†ò¥"üc~°ÙG�rˆ+~_qã�5âÞY#NáÓˆ-‹HÖIßxLªE.ÔHŠ^IWæ¾~Çý»–(±eOL/ØYt,Q¢ø¯NòzLªE.$ë¤o(ïP*¯IQ„£FR”{ rŠwãF8j5’¢(þ«“DÒ•¹‘ÿS1ø­ \ No newline at end of file diff --git a/crates/lumen-image/tests/corpus/level_1.raw b/crates/lumen-image/tests/corpus/level_1.raw new file mode 100644 index 0000000..4a55119 --- /dev/null +++ b/crates/lumen-image/tests/corpus/level_1.raw @@ -0,0 +1,528 @@ +a point count every texture on the thread point of renders point made every point ray on texture bunny and the a each bunny floating the floating a renders platform platform bytes count bytes on every ray maps triangles integer maps count without same integer thread while renders count light without triangles made lumen every the same bytes platform ray on count thread floating count light decoded made bunny a falls falls lumen on the the platform integer maps returns +platform ray maps made light integer +texture floating +maps of and +triangles lumen decoded each thread light bunny falls +platform decoded a count +lumen +while bunny lumen made platform on falls and returns each and decoded platform ray returns decoded falls +the each on triangles on maps a on bunny every ray lumen maps while floating same triangles renders every floating +bytes falls and lumen bytes same +without bytes the bytes renders bunny +each the the every on on without the made bunny renders a count falls made a the without +floating same decoded maps every +same +ray returns integer point without ray the of bunny +returns every texture every thread ray the light platform texture +light integer the lumen on while a while ray of lumen made of platform integer of point count +integer count count bytes platform every of light +integer on count maps and floating integer and decoded same floating falls same without bytes platform ray ray returns each of lumen falls point triangles the platform made same bytes a made triangles the without and texture point point renders maps bunny triangles ray each thread on renders bytes the ray the of integer lumen platform platform every every integer +of ray +on +every count same the count renders triangles +ray texture made integer +count texture decoded the without +point without each without and lumen triangles floating while floating on triangles bytes of a the every lumen platform count triangles same on integer while +ray on maps returns the ray while every returns bunny a falls made on on count triangles +on and renders on without +renders a +lumen falls the thread on bytes on every lumen on platform the bunny count light and on while lumen falls +decoded same maps of on each +integer ray bunny bunny thread triangles a light texture maps floating platform point on count each renders +every without platform texture while while on texture on floating on +while count integer renders renders lumen on texture thread each +on triangles count maps +of lumen on point same bunny the returns renders thread integer made on decoded thread the made +ray same maps integer each falls +while same the integer thread and on +floating point on platform the point maps texture on on while platform +bunny triangles of light while bunny triangles each same every falls of floating same floating on +and bunny light floating count bytes platform triangles same ray on made maps every made while floating without and while on ray bunny falls every lumen same a on on integer count +bunny bytes bytes maps falls the count without without point triangles lumen each count of ray a on texture on light floating bytes without platform on on bytes falls of the and on +texture +thread of +made on lumen and each triangles made +made triangles without light falls made returns light on platform light point +the maps count same +bunny made a bytes the renders while of of thread falls without while every bunny made light +on integer without without lumen integer light and and the ray bytes integer count +renders the count every +triangles ray bytes floating +the triangles each renders a each each +a triangles returns lumen light integer on each decoded triangles platform integer count falls decoded light light of thread made thread light +point bytes triangles on lumen texture lumen count maps light renders floating same every falls every same floating bunny without the +integer light each +without renders every on decoded bytes point platform platform lumen of ray light while thread point renders every floating +and texture decoded while lumen the each thread and texture count thread texture triangles every light +texture the ray on a platform light count returns the bunny texture bytes decoded triangles while while the made returns integer made returns light decoded bunny platform on platform light returns point made count on +maps light of light triangles while bunny bunny integer every point +count and while ray platform returns floating +point bunny on floating count lumen made thread floating on integer light lumen and every decoded the of on decoded the and bytes the light falls triangles on the same texture thread of +triangles lumen renders without +thread a integer returns returns decoded +same falls platform lumen platform +count without on of decoded every ray texture ray returns same every triangles while +made point lumen ray thread on ray made decoded on +bunny triangles every on lumen the texture renders on +ray falls and lumen maps same each of returns ray ray decoded +maps count without point on on same without point the while +falls every each of texture platform lumen integer returns maps while thread thread +while ray floating bunny ray decoded the renders every ray each bytes each +on thread bunny of +integer returns +count thread without every and integer while bunny integer each triangles ray lumen falls same platform renders point made made falls of the +maps light and a triangles returns while on a decoded and while falls bunny triangles maps count and on platform maps the integer the +on on on same point returns ray platform bunny the ray decoded maps point light +lumen and returns point bytes decoded of a without integer on maps on a +decoded without same texture same bytes lumen made thread renders made light bytes triangles the and floating the ray the texture bunny lumen on every the and maps and light of ray the triangles +without while maps +texture returns while platform the platform floating each integer on and lumen returns the the a renders of point count and on and platform point texture integer bytes ray count maps every floating count the light platform +a decoded the same thread every renders integer texture +integer a decoded without every same and light and light returns floating integer texture platform while bytes of returns while same platform the each texture each and +texture point without each integer texture +ray integer every while count the each floating count and decoded thread while and light made a platform ray returns a same texture renders every lumen the floating thread same renders returns bunny and made the while made while floating the lumen point of light point each on thread decoded texture integer bytes a of maps point bytes on without each a lumen the texture renders of decoded triangles renders while texture and on each the floating renders texture platform point while and thread triangles on the point count same on renders and the returns integer +renders +the point platform lumen +light each thread count decoded integer made lumen light the floating maps bytes every integer and the same without same floating every on bytes ray +integer point point point platform each renders light the maps floating integer lumen point light decoded point of point bunny the of ray and count made +platform and falls +of count returns while the on lumen same renders made same bunny renders on without count each count made each floating on lumen falls of triangles bytes on thread point on integer lumen the lumen of the on triangles floating made renders and while every on while decoded ray +falls the each falls same while and bytes platform thread +floating maps while on while on every bytes integer returns without of lumen bytes returns every bunny +returns +falls bunny thread maps bytes renders while renders on every ray without light while decoded +on bunny falls without decoded lumen decoded thread bytes floating ray floating point light +of integer +count floating made +the bunny renders each maps every +bytes platform on renders ray renders +a light a light integer platform integer and every point +count +while a ray bunny while renders decoded integer the and returns every count same falls point platform +same without maps platform thread +bytes lumen count bytes the floating platform triangles point lumen while thread same same decoded bunny texture ray falls returns point a every of and the texture every thread on +platform the the count on decoded of a floating +triangles triangles count count thread count count decoded point ray texture made count and bytes point floating ray the on renders the +the ray on triangles light on floating triangles same on the texture while made and while falls falls same integer a count bytes the a bunny thread floating maps bytes integer platform returns light bunny count +on +bunny texture the decoded renders renders light maps a without the +returns without while integer every light decoded and on bunny falls lumen renders without maps integer on falls lumen the texture renders lumen thread +thread of of the maps a decoded lumen integer floating +each each triangles the without count thread of and renders floating +platform same triangles light of on falls every light floating and of count and +the same each every triangles without +on maps +on on made returns made lumen light light each bunny lumen and thread of every falls returns made while count floating a made texture lumen +lumen decoded while the triangles on falls floating the the the triangles of falls bunny thread each a a point integer each while platform the returns each made every integer ray made made platform texture platform integer ray made the same +on on on on renders bunny made the each maps +renders on integer a decoded falls floating and platform decoded bunny same light same count without on a on while ray +integer ray ray triangles thread each +a on without on texture same maps bunny every every the light triangles integer floating platform falls ray count renders each thread a the floating bytes floating and point while bunny maps triangles +decoded and lumen same while a floating the +floating +while decoded +and count a bunny the falls count bytes of +each and bytes point every ray while bunny texture a platform same integer floating maps bunny without on renders maps while renders triangles +every bytes same the renders texture on renders light same on light count point bunny a bunny without the without integer count without renders on maps maps and decoded lumen same the thread triangles light the of floating same renders while the lumen while and each +floating a on returns floating renders renders light while same on +and same thread same +integer count returns the decoded texture without without and every decoded bytes on of on the triangles count count the lumen bunny floating triangles on returns light light platform floating on +falls texture maps maps +returns point the bytes without falls decoded the without while returns platform and floating point renders without +bunny +thread ray made floating each made of ray the the decoded triangles falls bytes texture on +ray of triangles made +floating falls floating thread without returns bunny +point same floating light on thread and floating while thread made each bytes each same of falls every +floating light made every returns and and made without integer renders on light floating a integer +thread on floating triangles on light lumen +a thread the bytes on renders each a each maps on without each same platform on lumen made on each +every without integer of falls maps on maps on integer a lumen lumen thread every without texture made of triangles floating platform thread each without on floating returns integer floating maps every on bunny made bunny decoded the same each +thread floating bunny count +maps of integer triangles of the thread integer platform each floating while texture +of texture point of returns maps platform on a returns on thread the count renders ray +thread same falls on the the light bytes bunny bunny without decoded every same renders +lumen texture and texture bunny triangles the lumen +floating platform on the bunny floating bunny without count +the each bytes texture count maps +triangles +the bunny renders same ray returns returns while bunny renders count integer platform on +a decoded decoded of maps floating texture point decoded bunny on +made decoded thread and count returns triangles returns on light bytes texture made ray +integer count platform count and bunny every lumen +ray platform on of count lumen on +lumen made count light floating point a light integer decoded same bytes point without floating on texture ray falls +same +decoded the of returns same of texture bunny on the made of made point integer of on light without +floating count on the a while falls the thread +on thread the a maps floating each bunny bunny renders while triangles falls count +renders bunny platform renders light of thread decoded bytes triangles the while each the ray renders same maps each floating ray triangles texture point count floating texture on platform floating point a floating renders and every each lumen bunny each renders bunny maps returns light decoded made point made the lumen decoded lumen on +decoded while +integer thread renders floating ray light same of every falls +same thread thread falls point platform +light same renders integer without platform same bunny returns and +decoded light renders thread returns same integer maps ray while point while texture the point platform on maps +point every each bunny made texture of +while maps a each returns a bytes falls a bytes integer while every triangles falls a without ray +and returns each renders texture integer platform on decoded bunny on on made the platform each +while on the floating without count made the floating falls same made +light +triangles +bytes point and maps while on falls same point without same on floating decoded thread ray and made triangles platform maps the ray +lumen point on triangles and lumen each every on every of point renders +renders light on and integer light without count the each on bytes light the floating on +maps decoded made triangles a +while each integer the without falls falls floating falls the texture lumen triangles on count ray while ray a floating point count maps thread decoded of floating on made made floating integer on and light +lumen decoded a decoded bunny while lumen each on decoded on lumen triangles made on +every +texture lumen +bytes lumen made without same triangles falls bytes on light without +platform +texture the a decoded bunny thread and the triangles renders point +floating decoded falls ray while without renders the the ray light triangles decoded without without on each bunny renders without and lumen a bunny bytes decoded light same +bytes +thread count the maps integer each platform integer lumen texture while bytes floating made returns returns without +count renders falls bunny maps light every falls light each +bytes without renders bytes +triangles same without falls of +every of light on texture floating on while bytes and maps and on a bunny the returns texture +texture integer +falls of +every same on +without the and ray on ray texture lumen same floating texture texture +thread count bytes and the bunny on a integer bytes falls integer light the thread ray renders lumen the a triangles a +each lumen ray of each count on light platform while +renders the renders and returns bunny bytes bunny bunny while bunny decoded count +the lumen every bytes lumen on a thread point the platform bytes floating point bytes lumen without renders every returns platform integer maps on +bunny maps bytes texture returns falls and ray maps and texture falls +and of bunny while returns integer of and made light floating texture the +the thread same bunny decoded texture lumen lumen every floating and bunny made made on bytes made same decoded count bytes texture and triangles texture the each count maps falls texture each renders renders maps lumen returns thread lumen bytes thread on lumen falls on and +platform thread thread without point falls triangles while falls on point same returns on bunny the without triangles the triangles point the same on texture lumen +of the thread count returns light integer ray light floating the bunny renders while ray returns on of +on the made falls integer thread the triangles on thread without maps floating without ray falls lumen the made point ray ray on decoded same renders bytes the +floating count platform bytes lumen the bytes decoded floating falls point platform falls same triangles floating each bunny integer made light bytes bunny thread while on point of +floating while the texture returns the texture decoded bytes floating count falls triangles triangles ray a made a maps floating returns and +and bunny point the count of while ray +lumen texture each count each made ray integer while lumen decoded every bytes on texture bytes bunny of and triangles integer thread thread bytes count bunny texture platform platform decoded thread lumen without renders thread triangles each thread ray thread renders every ray ray decoded maps without the same texture +every decoded bytes light each of on returns a without the +bytes on while +point thread texture triangles decoded bunny while decoded lumen each on while and point point same thread the texture lumen a bytes without on maps +while triangles triangles without each falls point made count bytes +and +returns point falls made integer count returns renders platform made renders on count bytes decoded on a bunny made thread on each thread without triangles maps decoded light each bytes point renders integer and light decoded same the on and bytes count texture while +each each bytes texture +floating on lumen on a same falls made texture maps lumen point without integer texture of on bytes +of +light on while falls and and the of count same bunny the +thread light on each integer falls made count bunny renders point +on while light on ray on point the +without point and on and triangles lumen same on triangles bunny +texture texture point bytes same while on without texture point on and bunny and returns while every while point +a floating the without texture without +integer while +integer of light made of the +the while +the of integer decoded lumen +floating +every renders on returns returns decoded ray triangles bytes on platform platform triangles returns light floating the integer floating light returns made the renders same maps made texture a platform count without thread without bytes lumen +each a maps triangles light triangles light on +on +lumen triangles returns on lumen and +lumen lumen a +returns maps +the of ray ray +texture count bytes and ray the +light each decoded lumen +every point integer +the +a floating maps floating +point count the the falls of triangles the and +platform each bytes light light on maps a the on the the every count texture and +each on floating ray on decoded count made a while triangles falls and +without thread falls the same and maps and +bunny on on +platform bytes and bytes light light while bunny +triangles a without without on of platform +thread without renders triangles thread floating of same +lumen returns every same every +thread bytes of of each same floating each a triangles texture renders thread floating the returns returns light the while each platform the decoded bunny ray point of while platform without count each without maps triangles integer and falls while platform a bytes floating decoded platform ray while platform returns bunny each on the lumen made +decoded the falls decoded floating integer falls decoded each the maps lumen of bunny every decoded ray returns integer +and while same thread the a thread while returns bunny light platform the platform made floating bytes renders returns of on bunny on made integer bunny thread count light of falls and maps renders +returns a +renders every +the made decoded without light falls thread a ray texture falls point bunny maps and decoded each count point each on integer the integer a bytes bunny each each decoded returns maps a falls without point on ray the on every platform ray and decoded texture renders +decoded renders count renders decoded lumen bytes on without falls light the falls lumen the renders bunny bytes +floating renders every renders floating renders the +integer ray bunny while same lumen falls decoded triangles each platform of +falls on integer of while +of lumen texture each decoded integer each and renders a bunny on on returns each bunny bytes on same without every +the +same point decoded returns returns bytes point decoded count same of the +texture texture without same the returns a ray count integer +ray texture renders bunny decoded a count floating decoded light every a light ray +ray platform light bytes +ray on the the count floating of decoded maps ray renders of decoded bytes texture decoded the ray while same while +on and returns triangles decoded ray on bunny made thread light of texture platform integer of bunny count on same point returns +returns returns decoded lumen thread thread light count a same decoded without +the light point count integer bunny +of while of the +ray triangles the while a floating made bunny ray ray of renders renders floating count without maps light +triangles lumen triangles bunny platform integer on +falls the light point renders each returns and falls made +returns a texture platform renders renders on the lumen renders +lumen floating count same triangles without falls light thread point returns floating bunny same on floating without triangles without falls triangles the texture ray renders on bunny platform falls ray while +the a while without ray ray integer bunny ray count lumen a and +each returns thread falls without bytes while a renders returns on point returns maps on returns renders floating texture +on integer made returns on +maps made light lumen returns a without made +made maps while triangles while floating maps decoded of lumen lumen falls point count made decoded same +returns integer +of count while falls returns renders bunny bunny on +every triangles each platform lumen returns texture point bunny ray on the platform without falls integer lumen and integer platform returns falls made on ray a decoded the decoded platform lumen a platform and returns on made texture count of point maps texture count ray platform platform falls +every and on each light platform made point made lumen ray every falls without bytes maps +lumen ray and the of lumen without light triangles a floating a each +platform on +renders without platform each renders of each while each count same a a bytes without triangles lumen bytes count the of count the light returns same ray thread lumen made and +on renders the light lumen lumen light bunny +count a falls while on ray bytes maps floating integer maps lumen without on +renders triangles on while +while each ray light on integer lumen thread integer thread and +point while triangles texture on count platform and the renders +without bunny light the ray and a every bytes falls without the +and the triangles thread made of of light texture on light made ray on each renders of texture while each same renders integer +point triangles each renders platform on floating floating made on platform decoded the +lumen the point each renders falls of bunny without bunny bunny count and platform and made falls +a falls renders maps integer on integer falls every on same point a ray ray while light +each a and made renders and light same triangles while +a each +maps on count bunny decoded each count lumen decoded without returns integer decoded a floating of on platform each maps the on lumen decoded platform triangles every lumen made thread returns maps floating +thread texture falls point count point the the made platform and lumen while bunny +falls of each decoded platform returns a bunny the every and falls made bunny renders bytes platform same +of point falls bunny renders count +platform +ray texture decoded renders +on and same maps while bytes a texture light the +decoded point renders +every texture count on +integer renders on triangles on and each on bunny and falls and +made renders ray decoded and platform integer of decoded count without ray every triangles falls maps every light integer each bytes integer ray texture same thread same without the light every each +falls texture platform made renders each +falls falls count without maps floating same made thread a on thread +bunny renders decoded light returns count falls a +made decoded thread bytes a light falls thread without of bytes decoded bytes and on a integer triangles +made returns maps thread decoded bunny ray +floating triangles +integer point +ray without +ray made the without integer light point falls +the while made made the maps point returns light point each decoded triangles the +integer falls every while made falls and on on returns on made bytes ray on bytes texture on +of maps maps a texture returns a on made the integer of and floating on +decoded texture +integer falls maps on of +the renders light the +on returns maps each +light falls floating point ray +falls platform every made same platform while the same bytes every renders returns platform same on without maps the while every integer made +every on without without renders a made platform lumen triangles +of on count light light light on floating count while floating decoded texture same ray point falls bytes the of triangles +maps renders point +platform same bunny maps every maps +without thread and triangles platform thread triangles every point thread +point a light thread platform point made texture without on on same +triangles of a count texture while a without the each falls lumen the point on falls triangles +on lumen made made +without integer a the point ray while falls the thread floating bunny +triangles count floating a lumen +renders a made while while triangles falls bunny on while count light +without platform same a of falls bytes on every the a falls platform ray on of same each lumen thread ray every of point made bytes decoded +platform light floating a point a renders on without same a lumen renders a on returns without without while while and a count of each each on the +point integer +the returns while a platform +bunny while a ray made light of the while and same integer returns of +and the bunny thread light floating bytes thread point platform same lumen thread maps made thread +falls count each every lumen lumen of a a +same lumen light while returns on bytes while on +light renders the on falls of light the triangles ray returns floating ray +texture point same count +floating thread lumen ray platform platform on renders triangles on bunny texture of the renders renders point made made +count without point +a on and and made ray ray floating and ray point renders a integer +without a lumen bunny without integer of made point the count of on floating texture triangles made point the decoded bunny lumen renders +and +integer platform +texture the triangles each every every triangles on each every floating integer every platform thread point decoded made without renders decoded maps on decoded platform and of bunny +thread decoded ray triangles and triangles and every +the floating on the point platform floating point the and texture decoded the count count ray light light decoded count the +point point integer of +floating +the thread returns without returns on on while and a ray each integer of +on count integer the without texture each lumen point +floating bunny +bunny +count falls bunny +ray every +lumen falls without maps without texture count light and light on +each bunny lumen floating maps while the maps renders decoded lumen texture same renders renders falls bunny lumen same +thread ray the maps thread a the light returns without thread +made of floating renders bunny maps falls +renders on each count of returns made of +count of the returns on made triangles and count floating thread maps on point renders maps texture and returns and maps on the bytes +thread light floating triangles maps on same and point ray floating floating maps each on returns while of made returns the falls falls returns light floating light lumen +on of decoded integer ray and while platform +every platform the bytes and bunny same of bunny renders point and while integer every on bytes falls +renders while floating light same bytes on the count the made of decoded without without every made a bunny light falls bunny texture decoded on count +made triangles +and point of point light every on of every maps count bytes and floating bunny thread same on renders platform +texture the lumen ray while made bytes made while a falls made on while ray same texture +returns a the falls on +while the while maps of platform floating made each floating platform maps on each +made a integer on thread point made lumen count without +of ray made without maps renders count bytes +maps falls lumen and falls integer point bytes bunny the light bytes light without maps ray a +and platform floating while light +bunny made same on triangles without renders triangles point each and triangles decoded on count each point integer decoded triangles texture renders thread thread returns while count floating on decoded +ray without same bytes +lumen bunny a bytes floating made a on integer while and light made +while triangles on +triangles platform count each and same maps integer thread on +ray thread bunny texture floating +every +integer the point ray maps ray falls while count bunny returns thread maps count same light platform ray integer texture returns on every on triangles integer the triangles on ray count a falls bunny point each on a maps the +on count platform while bunny triangles renders on +floating +lumen while every floating point while count +while floating triangles while decoded bytes bunny triangles on the on thread platform +on while light a bunny platform falls the every bunny returns triangles bytes falls point the the every without returns renders integer on each without and on +bunny of platform triangles returns integer every and thread the without integer texture and +of lumen +texture on while and a light renders the light ray without the platform renders ray +bunny count count returns triangles each while while every each +bunny floating floating while renders on integer same without of floating +maps maps the lumen count falls triangles floating of +without without maps falls each triangles ray count a count platform +integer each point without lumen made +returns while without light +maps integer +point returns each texture lumen the lumen floating triangles triangles on floating decoded bytes bunny point integer ray of decoded floating +lumen made thread floating floating light count while of the integer made lumen of same returns made point the ray +without lumen bunny renders each on on decoded on each +made bytes falls and point and every count decoded +count ray every of integer renders bytes thread +returns same maps made and +triangles on on bunny same bytes same the same on and the every each point the while decoded a integer on bytes light and floating renders bunny thread lumen integer +each and the and falls decoded decoded lumen every made lumen floating floating falls falls decoded point +point thread a floating while the the triangles made and the the count of on same +light triangles bytes maps point the and and on point on on each of of thread on on renders without lumen renders +bunny each triangles floating light and without count texture +while lumen same on bunny a of each each bunny on falls bunny texture platform of maps count falls ray on on decoded returns triangles on each the on a without count falls same +every bunny decoded texture count falls triangles the falls while of +a while point maps returns +falls made every on +the and +and +of lumen each +on the bunny maps a maps maps while lumen falls a bunny +point floating the +and ray bunny platform without same maps on integer bunny a of integer falls lumen lumen the point every +of floating integer and on light triangles lumen integer falls count decoded decoded bytes every on while count and platform integer lumen +bytes count decoded of of the falls texture +ray texture on +count decoded lumen on every a a while on returns each floating while +without same every texture each every decoded same on same +on floating bunny lumen renders integer while light light bunny returns falls on texture platform and maps made bunny the returns the ray without +without decoded on without the floating light integer count texture bytes bytes +every floating of falls light lumen made +ray on on a same count same the without and ray point without returns ray decoded every without and triangles integer integer returns decoded on same same thread light +a the without the +bunny +renders ray point returns the triangles renders +lumen while +bytes renders +bunny count maps +bytes without renders +without the made same +maps ray platform the bunny renders ray on without texture the floating and texture +ray +light made made each lumen ray each the texture of a the count and triangles floating without maps the floating on thread bytes without on lumen a light of ray maps falls maps every while renders every texture the floating maps triangles made point the triangles while each and made each and on ray on without while floating while and the decoded a returns point count platform texture point light while triangles +renders texture and without and same on platform thread bunny lumen platform falls and falls platform +renders decoded bytes floating returns each integer integer +integer +ray on thread integer integer the same ray the +bytes point maps lumen while count and bunny bunny returns and decoded light a bytes bytes triangles bytes the +lumen falls without while ray +every of platform the light made on triangles +maps falls while bytes of each bytes triangles floating a light while while platform point renders each each light while platform every same of on maps a on same light the lumen decoded on renders floating ray point bunny same integer the thread falls triangles triangles while ray lumen a the thread the renders point the on without thread platform the returns +texture same bunny decoded triangles on floating +of +renders bytes light +point ray made each decoded returns count bunny texture texture without the each returns and +integer texture renders renders +light every point each the made decoded every on point maps of bunny +light the lumen point falls without each on on renders bunny point light falls lumen decoded and falls every on same maps each on and thread every floating on count ray each light floating without made bunny the bytes on light ray on point decoded of returns point light same of and ray +a the each point same light each bunny lumen falls on each floating +returns bunny +decoded and maps falls texture on point point made without renders bytes while falls and ray every a ray light bunny lumen bytes every on made while falls a of without every while floating +lumen texture point on the bytes the every +bytes lumen +point triangles platform while +the while +every a light each decoded point of same point the same while maps floating on texture count of on decoded integer same +maps the platform renders +bunny each count platform every decoded decoded thread texture light texture and platform made integer of on every the point renders and +lumen bytes while ray +and platform bunny and integer decoded triangles thread texture texture and on the lumen the +integer same bunny light texture bytes bytes falls ray decoded +ray of platform the on the falls floating same returns bytes lumen and falls the light every falls and the count count triangles thread +and of falls on maps maps floating of ray without the integer platform integer maps +bunny point and bunny and on lumen bunny floating count lumen platform on bytes made without the maps triangles without of texture on same of +lumen and count lumen falls lumen light maps texture each ray on count count of made without the triangles without platform lumen texture same while the of count ray without integer and on triangles a same +texture the decoded point and lumen decoded same +same thread the triangles decoded point every returns made while +on platform maps returns maps +count lumen thread while renders thread the and each decoded texture on falls platform thread falls on same the platform light on texture lumen while without the thread triangles falls texture and platform the falls maps texture lumen texture light floating thread bunny returns decoded a on while and texture thread on count decoded lumen decoded while floating renders the same thread floating a and bytes light the each without returns of without bunny falls point decoded decoded point triangles without maps texture +same made on ray the while renders point renders triangles of thread and light the maps made +same on on without platform light platform and maps on triangles made a triangles ray lumen ray same without bytes falls every on triangles every the maps integer of made same triangles decoded point maps while maps point +same floating lumen bunny each maps returns every ray same thread light integer maps on maps maps each while count thread and bunny point light on platform point bytes +falls renders the and maps +maps same and integer +ray made texture triangles integer integer lumen returns lumen thread integer +bytes bytes point made every floating a falls maps +platform light each platform every bunny without point renders triangles the the maps without light bunny every +triangles light decoded each and on integer a a thread the decoded of +thread renders +each returns +returns the each lumen made point decoded each count while +made returns point returns the the platform count renders count decoded a platform a on lumen point and count renders bytes returns the a without every made platform platform thread every every and made returns a triangles a on every and each and of light of ray falls renders on texture renders +count bytes decoded +each on triangles triangles renders falls maps count integer bytes platform ray returns a every integer bytes light of made on every of made triangles integer while triangles point texture while triangles count texture bunny same made made the the on without on lumen returns light +falls returns floating the and ray texture on triangles platform bytes without without thread decoded decoded while platform ray made the same maps ray every while thread +decoded and +while +floating the while every returns on of a every platform of bytes renders +bytes on without light thread +maps same same falls returns a of ray the maps the every renders floating the light of +the ray of on bunny the falls +thread thread and +the a bytes without lumen lumen thread ray same on +of bytes made count lumen point triangles of +falls on count bunny made +returns same bytes of the of bytes +the the texture decoded same on on thread on of the without texture integer light decoded +on falls decoded returns falls the integer falls light triangles renders of texture a the point +falls maps same without every light ray +same bytes a while a on +floating the and made on lumen a of +on returns falls floating bunny on while triangles made on without bytes and a lumen lumen integer point +without on ray +and lumen triangles without renders decoded renders the platform platform the and bytes while on bunny triangles +texture lumen each returns +of while count decoded each without without maps the integer made light floating point light without +on bytes returns same ray same +every +falls returns same bytes on on triangles ray on falls the ray light every falls the light triangles thread +made same decoded bunny +returns ray every integer +decoded returns texture count triangles made +lumen and count without the on bunny point ray the triangles each +bunny lumen thread triangles on maps same falls bytes while on and every on r \ No newline at end of file diff --git a/crates/lumen-image/tests/corpus/level_1.zlib b/crates/lumen-image/tests/corpus/level_1.zlib new file mode 100644 index 0000000000000000000000000000000000000000..54aff0b9f375fa915b4368ebf4adf6ae61f71922 GIT binary patch literal 10675 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%0DH00s$ z{)|c2M3vn=6*%m?U;l|%1OOnsTv&2QBU6hiv$?;u+8TFA^&5_2>k3jwtJSh5>t~&e zPn*Ryd+jFN=e3wMl^05eo-i71S4zG(6&I_*+)QH@rw~`Y24`z9&{P!VJF8o|lU8g2 zgyZevC>H#f<-MzyazWt6rp8c70Ed#e>VAYyXmNg3R2==OsFKuuEkfHwE64ykU@dxU z?WHgRBDXj#%0SpHgnV)e>qv*L&wzPSiNGAAh9e2dMNsSvV(~ZQV90cdux+}!d|nIa zExUwZ#5L*6lM)Brm~%Dt_|$7^v}>G;p{zQ6LqB-DBV2v^QSHf^7lSF+Vl(#P54VKh z$E?gtUhOO>AsFphg)^yAb1l9c@2pDcB?}#JZ(+(Xc))a+*bqW?Vo>tLjRzqmI-XiU6m|%zEu^9YPI$)NWHTvb;wJf>ZHjpY;TatlZ=4r-C8Dd z(ow7FvlMp8!!$y+}vrH37ihk5)j z0)Gbv@7y`Cf%7w`bxR4R{00w=(0BP4gD?^2-s*9#NpWVOBzgC8rsjI*t+W}j#Gg;8 zd-*(@S3uN6nKHlIoZ@RAFEY5l*>zsIjxI&zd3|$8l6GhjCUIO8a-$NT_VGxLJ#o_P jG$=w1!FpHacIVI@$10N~H@COuzd|*I*FXLrLwDNl1>*Z( literal 0 HcmV?d00001 diff --git a/crates/lumen-image/tests/corpus/level_4.zlib b/crates/lumen-image/tests/corpus/level_4.zlib new file mode 100644 index 0000000000000000000000000000000000000000..6dd770403861bd67b8e291287679038bb97a097b GIT binary patch literal 9420 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 P|D#lcWPkl1LwDNlg6Umz literal 0 HcmV?d00001 diff --git a/crates/lumen-image/tests/corpus/level_6.zlib b/crates/lumen-image/tests/corpus/level_6.zlib new file mode 100644 index 0000000000000000000000000000000000000000..c276ec645f78b4ab5b329a501e243ed092585e38 GIT binary patch literal 8305 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 literal 0 HcmV?d00001 diff --git a/crates/lumen-image/tests/corpus/level_7.zlib b/crates/lumen-image/tests/corpus/level_7.zlib new file mode 100644 index 0000000000000000000000000000000000000000..daac928961a5e4f62f0adab8f995bcd1e9411b33 GIT binary patch literal 8268 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 K759HbciQgI&na{O literal 0 HcmV?d00001 diff --git a/crates/lumen-image/tests/corpus/level_8.zlib b/crates/lumen-image/tests/corpus/level_8.zlib new file mode 100644 index 0000000000000000000000000000000000000000..3f7084a2ff677c0fa1990cb1d5c311274b291422 GIT binary patch literal 8266 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 I14DP(?w&{|h5!Hn literal 0 HcmV?d00001 diff --git a/crates/lumen-image/tests/corpus/level_9.zlib b/crates/lumen-image/tests/corpus/level_9.zlib new file mode 100644 index 0000000000000000000000000000000000000000..3f7084a2ff677c0fa1990cb1d5c311274b291422 GIT binary patch literal 8266 zcmV-QAhq9k+I^kdl3O{hMBn)p^=o^^Qri)3$zi)^j{p8h1Oco}vgV=Pc9pa*ya0(r z0=zzcJik4DfBgIT&+E_Ie{MhjeEh!s-|v5Z-aej>kKbQ!um67Dt}p9z&-=&E+vCga z=dbmHzppR1^}YDP&+E_p=DNtg{&_t9d|Zz&^IF%(?fUoE^~3x3=k@#Bx}oJH^f4xBdJ2@$2LF&u`b`ukWwly`JXw*X?KgIKK4X zZ@<4j|M~s#>-zgvzh5u-->=`k-|FV^`S0KU`r6;>OV79d{?FgHy#4zX=0)SN>WSBA z#MRb~>Q#Ah#^CmQpEuQ`6r*XXy6Tjvwb8C_a3o&ljkGG;(Grro}!meKF{m-@t8GHb7uQ0 zxklovHFz=g{rGXc`04u!BiB*<=>3H8x4hnbps~g`COK~LoD*Nm@bz;nll=A?==A{e z1K0fQ`rgpj=>_*=y~&sl$sx^^6+1ic|Ng}Ly03K-Ph9gP<|8-8TqyaSSTHqz>$5|a zWqdG~drZZZ+w;Aj?p!*re{DPA{j)Y}BYzy@L-SGJT;qI?2dr<@){Ry3z~;@5a9z%U ztxv>6%%ADZ>+;2T$AZn*i|@ya^x~7PKSuy|=Zc@`r}O612(QVBt1gSZ7SMdhSW{T* zugBw#e~m~j*ILF{5jiaJ3cCr9fsQ}Z485Jo^=CXEBYqx39-HoU)%a)LwH|G*)O?@$ z+IhWYZP%}Ia<~taT@c%{9MXO5x_A{EhV^9io%xQhtK_K7>yPC$ zXwPey;|Z40TEA0w5xe36w^Jkb`cc@`7|OOOqm0Pl+JpOlKHTHh4(;9iHEj|-+xw2S zk8$-OyCyx)`|_{ps2%uz=eXutnejM1gx9)FuY@0%uwH-xUvf<5l&_awt1cIS8>jW; z@h6bY+g0^KSe`AeUJt)UHUHl}d|hL`&3t27Ol@^W*@O2`&$oyTzlP&h%b<2hT(n_9 ztcTtQF@npB%+=OYkl&gE6!R2sR@>2FQ%r9=ml|kU76}&L0IkQbmPLMcxcNzo{6XN* zzn)JypKST!xolrwQeVe;dOz>NAM?V7#>_(7R;``+btd2Lcfx3!YZbu7U89<%sD7~Z%kro{#(?znA_cu<0#*X1V2j}?)= zJq^fx9;!`TF8lZe7u*6F@3$YZ%qswx5GRInAtZRQwSU%Z z-Q#@%vd`Pr_`(L`S^*ts&22v7y~{(EbwDISh%R87pDZCZXaMP z=hG0)23+D#rgJNUMw2OIiNEkk1k3|ThyP%xCdadW& zAH_0MSf0kosMYgy~O(QAEds3P}vZ?AfYg3c2+d9XiMT0Gne z)c5sMB0+pdNOk*1SRykM7vhW(gIXY=TnA6$3Tl`u=7SGiBfF>lOAYZks_> z?`KZ1hAjDydbqjtFi5@c=@5hGE<+(yR4#@0|131kC(7$DYVi6)n4`d;oV)XC*5UooWXrq%JX3Zg7m~aANar(uV|(h8fk-KzH&t0^VfV%vu|q& z)GBv=D$tv*s6s3Cm&H{Gw@?G0`1>vyD^2Q1qGt%=$xyzQvTkt9Q$t22bz~$)W#*K0 zDJDUZkqI<~`%oB5P}B*E1wm!DM#r;dvELJc6qyY_Oi7skFdNB9Uq+&AR7uBmh%!f} zyqYc4p>!jYSV*S~7LS>v!U$qp!pz&MBCsPnDmLsul`{I0SYzH&vX9ChbV#L`_3Hdw zTE=6R@fDQ`cxb{5aq@(`O_MbiHS%3z6#ht!;Fg7I06|Jf*5)!A;PnPb7lhzRZMJ{k zQb!yN-~ta%U`!h1`J`UDr%!%rTguAUApJ8svIenK_Rdoy3scSHJh?bGQ}I%Y=+rqa zC_y7~nBNCS#@i@JFVG^+=K}g1J%oL zd|G1jn3t}FItpsU(>brQsGk)Uu1HnLx(((4A2ECbPJ2B7iCMW45juoHfqzK>5A_C( zAp`}k9YBm+|1r~aaBBFp0EGtFqF&i$1WmK8QcteH~*PfKwSSnqGSn5mdws;}6 z$MuL?wAjJWmOi$KwcvlF^0}a4sh*FW5jlH2@E$8UO}1ukd3|A0O&-5{!f{UXr29;v#Qdt!^J}f$ z2@r-|8=k8et(B(^|7=?ko6n&}YfUQ!b6!eFcfFI+EmEl^E9Uz`Xy%lZvWOM&r~F`U zR@MAKIG759AHT?hxBFZu2T<@suO-2NEQ3SL1e5{G3!9-CQnlDk0W|=Kzi#aBd}oLC z1na54s+f|%2nKV*|4Oe2sW+IHYWX-aQJkc!e$`8Rm;b%-1*6GDtAk8$TXlSf3+pmYSZiMM_>UMx!{3nC|kw_Qhi9GEW8|3?#~Pu5U88M zO2R>j8<8p!c$J@`B-GiA5LR2}UQ*fEC?y&wnZ%rrN@~MY)c|e^?;<@SswWZ9dwJ+S zyKL4Gyy;q6d)&OBN|j8np_r!yKnhDNA`ZGV69VAZ5F)7cv0y`%twoc7raNHCMX+JF z22}IL1W3ZHBThK$Sumj$w`nX}D^`NrVd~3G@znaFTv&**2eG9{+l(8;6+BhA=>Ub3 zFR(CF`DNNvS^QeRQZWqUE;2}#(MVQ;fe@Cia0ajNsdK;yAv$L#1sukAk-Yb%f3Y-T zY?Uh>4IQlTW>kw|kxXzk{?OD%emzxmMHXgT%uOUM9ix#Bi9Or+_N84&0hkXn z<rsg@h*iKp2ReOxyD?PIoVT4sz~xePpe_RloSn1 za_9znQ(#i8Maac<&i4_e(DNZITLIM6tE-tFcH5+CNKH+XAITf0gFrcLxWm-(B>8fA zmM^$Wm=RB;1`Qz^ky0l!F0oaBFN>{US-``ooK=^E5=ttrUx9Z#9-*$sMTU_C>N1 zgA8~rz?Y@Qp%e}qSSVSLtRwki8Cl5*G8Eo$b$Ly=9_9H2{s^7yvbiV$fc&88B9UuM z2Q{2OF$!&ETut}PAV^E85RkT6*o(f^W%QD)Osse{rA;&z*5IGB-9h^|o07{!F7-dt+aQDqX%(MyS)kK&tm|FS#n;>ZF@GbL`9Jvnhonep5=U zRZvpXky>su2HR?b9%q>n$wlp@F%~hLjrW$WVGa)p|6QHFiKOYcsnQ&$ObPPXLAZ3Z zNRdKIBd4RxiTb4I=7gj*>`z49878XvG>Z4o;j$D;2FOm^>?L+koo!__fz00PQByW3 z$UEn$wr(Dxi+ifF2oc1kY3=j|ocB{-jvtPZL9l8%h#D*9MwuP^aFASYmC$t-Fc1W z56Valb;nS?dyP>!&{kqbicYbzU_7MQ*&0K$4G(}H0#%YZAe)9J>$j_B+@sa{z;no+ zt=f_<+Ohr!vfo=4pz?g!8}D+WRAXN7A|yjE zTIFOLyTf?!h$1di*f3LFnN&3?+CdO6aDRtyCCv9rU5;vxJ(%oEN(gk($qg)@q-g1ZC0$UAnwr2XtXlcan$9l!1xy4xoB&{V;V9q<5{jdH-sQ22}hWgEImT) zs^+*C4jlq{M+IumJ4!KdYTw9K5%_@wp@s@kh1L_1?{29C1BXURtpJ7);4-y;IdI6O zm%Zh>lQJ#cbioOGFLxTiSe(u4GC(7 z0M_(^+_Q?gSVS)KWQMD_94a(=O1>!Q} zgZ!2)^OC;0Z|tP8H{v!eXSyZ1O!UxMHB@%-#YE6XpZn3ff~aN@~5AlFM9mnw}N>K$wpE%!F4Xdzoka;s;V>YuAYuo2Jddlr3?MOf~~ zA2ui{5p=@C*?e{elC)YTmcddgEWNM{vq2IYIXJ~F(Fd}?jEU&&f%{2;3`b7ICXjCM z*Jk3UI{JO)wJZ&waehr=7Vg*j;th$J2yxSiHEu=K7huaqwyfa@*$)G2z&(*~lD~l((S6SZsfAsjEam1EHJbL?=7#TcCy7-vlN~sT@$0B?A(UdYaXH?7U>vu?15-; z#2A)N03B+LMRnT(h9UB(E%Gd0RaP#LYd51sbdwMx+MqBUpo?p=9Gi%OqVtHAwKHR- zl`9#MD;-Nl)d(GI8*4kfx1C%^+6h-GNq_*kGMIqT5FZhaN*p?`D?><}B*j#fU|2cOFLTM7^7bRnMrX z`>I%~pxG?7@)o_1@K9u5E!pDKfCgJmLl!0#Q(mnWnDH58cGnI#$?K)#@Q+`fh|$#Q zrjasFN{zzMs+WxYwbPQsI?TfaHW^YecAe7YDw?3&z)@F8&ZT!bod2A1HwG83(CBDu zWv(p7@cLIoKC7rm7m&0vb#Zd?rR-o3@a$YSaiQ;kwpS0H!}i#+A}f2vA{0nrOcf6! zl;!3|UE+-kVD8 zqBh%W(vkm$wkR;BS131+uyYs;u?YfI{Iw>>iA(FwISy@6qg#X&A!iIELf1C9y+U(Q zm9}2$whkr0U|K|MC$-C)s>{Bms7FcJH~e*yN(vV&u9X%T9A5l(V@PbHfU2PIX-dI8tVR%8IaWL31gp=_=}IP)XO5KD2SV#+DxE z^5}vvY}E%BS1dGfss@rw9Hd{vyc0<&_?S_KUJmRKxa7C;Lpe%Qv$g3twUa9hea@gN z?D3=uoMTJAhMf(>nBh9Gdd2VI)?LpY6L3?&Hm~NFt z8Mw_Lu{wttrTa;7h%2gv(?ckR3g+#p5rC{AXTemgr_Tzu5Z_#Sf(YA2nR!YZV5eG) zp0>hiWENsv8|rW3G|R-1t$-^&`j&R%2x3tUQi)SZmUR7rXr_^#Y%yCNhQm-ix=ZZV z{m`OQi$k+v#~OGLrQ*?$5)t^Y4wq6-Cw7ebX4J5BI!V(^6rncL$KnF5Fs(%YHH6r* z8iNQDkfPs3v7f8kKw+rI^<}uyZ{qt7q{msl=1%d{q^;osIUMY}LF{!M%MGvXL@evN zyh+*Lr_JnvFWy*bP|K#Qjy=+|emfa4d@VhBTiu#s=8RN2E$L=EkH!;y%w#(s)J4ya zV-bec`g98X5;LXht*hvjvFDA>2QT3qgc>4J=7vd`tYVMTgLl(%2-#=e*%>w<4V}r- zud|wbL-DAcQ zGzl-W3rwzsLltRngNAf3S3%VKYC9aWeuqYd!n_0KjiyW6o1IIokbD~M&0*;eCrad= z(Y-LVoLVY1AZ%3wDJk|r`!ke{mQMHHY5K5Hw8f>O?!EM0R62Nv&dU*K!HYE%@Y7ZsBvSsK&ZvXKV#hpxMY3mzvY?3_Jr{SK zfY!*>+90M2PpS#cN$f}$WK3Z}2qy&eX{00cOs=g419`-T$Vjc+tf8$fH*Z=e7gVtZm2w z!K|gsIZuEiTxTB$bqEP4vAJqR<+Pm;k+Qpaa_oWZRdujQy@xoq1LBY5p@)-NYCUP@zrUB_t-DmfI` z99!)$S{PC>BT#eZIghtp~A zG3!m*vQc7cu0h*0Ho2?*3oW$rB&JwII3K+I58lq{Iv_rxW0 zY?XzF!U<@l?Za%?bVs>t8n;f9s`?OcQA%a0OP91V#RZ?X`)CF=H!%BD5S(4Y-6%BT9P9gq`yH=ZS{-=kFY5! z8R;`h?TvJ~I31us149HzUE)cUD=8N6HSYS^$PbJ5;0y$*Si?JMvjDuOHdI@HF3hle zHv&*>gFOkDm`X6;(Ej8cn?nPrdQgz`$DVIn2a68XFXVLje1?{J8r}*M-bG@Pyis># zEpxi>WDR-+?d(ywNzbiITDN@AxGEP`YeIGi@bCx}R`Nt=)lT`}$~;jU*}x%K>#Q z%Zgh~Yv_IQj3qxF&7wX5q>SXQJm%oeKRWkOtKC zE-2-nH_6f6%8i(tae_iGFy9VmeX^de{XRqZgqzf^)<_CxTuGE&UVji%u#{1AguzFn` z8*hp%5xEv^v;4`)-dcM?`O;)NUyf8se2x;?OYFW zdQw%}vv%``Fh>bVBPiSzd1oj;(6Gfb4ABdAn?1*RJ)V8A{es5fa zE6@T8TZnJr+0v02;BFJ87%{?(v zKb=ELS^9p)^3g7f>4+}oBvkWyjR@+ I14DP(?w&{|h5!Hn literal 0 HcmV?d00001 diff --git a/crates/lumen-image/tests/corpus/make_corpus.py b/crates/lumen-image/tests/corpus/make_corpus.py new file mode 100644 index 0000000..8e76490 --- /dev/null +++ b/crates/lumen-image/tests/corpus/make_corpus.py @@ -0,0 +1,236 @@ +"""Builds the zlib corpus of lumen-image's inflate tests, outside the repository's build. + +Run as `python3 -I make_corpus.py OUT_DIR` with CPython's standard library only. Each case +writes OUT_DIR/.raw (the encoder's input, which is the expected output of decoding) +and OUT_DIR/.zlib (the stream). Streams come from CPython's `zlib` module, except where +zlib cannot produce the shape under test: there a small bit writer below assembles the deflate +blocks, and the stream is checked to decompress to the raw bytes with `zlib.decompress` before +it is written. The script prints, for each stream, its raw file, sizes, block types (read back by `block_types`) +and SHA-256, then each raw file's SHA-256: the tables in the corpus README. +""" + +import hashlib +import random +import struct +import sys +import zlib + +OUT = sys.argv[1] + + +def text(seed, size): + """Deterministic pseudo-English: words from a fixed list, chosen by a seeded generator.""" + words = ("the light falls on a bunny made of integer triangles while every ray " + "returns the same bytes on each platform and thread count lumen renders " + "texture maps decoded without floating point").split() + rng = random.Random(seed) + out = bytearray() + while len(out) < size: + out += rng.choice(words).encode() + (b"\n" if rng.random() < 0.08 else b" ") + return bytes(out[:size]) + + +def noise(seed, size): + rng = random.Random(seed) + return bytes(rng.getrandbits(8) for _ in range(size)) + + +def deflate(raw, level=6, wbits=15, strategy=zlib.Z_DEFAULT_STRATEGY, mem=8): + c = zlib.compressobj(level, zlib.DEFLATED, wbits, mem, strategy) + return c.compress(raw) + c.flush() + + +class Bits: + """An LSB-first bit writer (RFC 1951 section 3.1.1).""" + + def __init__(self): + self.out, self.acc, self.n = bytearray(), 0, 0 + + def put(self, value, count): + self.acc |= value << self.n + self.n += count + while self.n >= 8: + self.out.append(self.acc & 0xFF) + self.acc >>= 8 + self.n -= 8 + + def huff(self, code, length): + """A Huffman code, most significant bit first (RFC 1951 section 3.1.1).""" + for i in range(length - 1, -1, -1): + self.put((code >> i) & 1, 1) + + def align(self): + if self.n: + self.put(0, 8 - self.n) + return bytes(self.out) + + +def fixed_literal(bits, byte): + if byte < 144: + bits.huff(0x30 + byte, 8) + else: + bits.huff(0x190 + byte - 144, 9) + + +def zlib_wrap(raw_deflate, raw): + return b"\x78\x01" + raw_deflate + struct.pack(">I", zlib.adler32(raw)) + + +def max_distance(): + """32 768 literals, then one length-258 match at distance 32 768, in one fixed block. + + zlib's encoder never emits a distance beyond 32 506 (MAX_DIST), so this is assembled. + Length 258 is symbol 285 (8-bit code 11000101, no extra bits); distance 32 768 is code + 29 (5-bit code 11101) with 13 extra bits of 8 191 (base 24 577). + """ + head = noise(11, 32768) + bits = Bits() + bits.put(1, 1) + bits.put(1, 2) + for b in head: + fixed_literal(bits, b) + bits.huff(0b11000101, 8) + bits.huff(29, 5) + bits.put(8191, 13) + bits.huff(0, 7) + raw = head + head[:258] + return raw, zlib_wrap(bits.align(), raw) + + +def final_stored(): + """A dynamic or fixed block from zlib, a sync flush (an empty stored block), then a final + stored block assembled by hand (BFINAL 1, BTYPE 00, LEN, NLEN, the bytes).""" + a, b = text(21, 3000), text(22, 700) + c = zlib.compressobj(6, zlib.DEFLATED, -15) + body = c.compress(a) + c.flush(zlib.Z_SYNC_FLUSH) + body += b"\x01" + struct.pack("> 3] >> (pos[0] & 7)) & 1 + pos[0] += 1 + return b + + def bits(n): + return sum(bit() << i for i in range(n)) + + def table(lengths): + codes, code = {}, 0 + for length in range(1, 16): + for sym, l in enumerate(lengths): + if l == length: + codes[(length, code)] = sym + code += 1 + code <<= 1 + return codes + + def decode(codes): + code, length = 0, 0 + while True: + code, length = (code << 1) | bit(), length + 1 + if (length, code) in codes: + return codes[(length, code)] + + lbase = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, + 99, 115, 131, 163, 195, 227, 258] + lext = [0] * 8 + [i // 4 for i in range(4, 24)] + [0] + dext = [0, 0] + [i // 2 - 1 for i in range(2, 30)] + kinds = [] + while True: + final, kind = bit(), bits(2) + kinds.append(["stored", "fixed", "dynamic"][kind]) + if kind == 0: + pos[0] = (pos[0] + 7) & ~7 + n = bits(16) + bits(16) + pos[0] += 8 * n + else: + if kind == 1: + lit = table([8] * 144 + [9] * 112 + [7] * 24 + [8] * 8) + dist = table([5] * 30) + else: + hlit, hdist, hclen = bits(5) + 257, bits(5) + 1, bits(4) + 4 + order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15] + cl = [0] * 19 + for i in range(hclen): + cl[order[i]] = bits(3) + clt, lengths = table(cl), [] + while len(lengths) < hlit + hdist: + s = decode(clt) + if s < 16: + lengths.append(s) + elif s == 16: + lengths += [lengths[-1]] * (3 + bits(2)) + elif s == 17: + lengths += [0] * (3 + bits(3)) + else: + lengths += [0] * (11 + bits(7)) + lit, dist = table(lengths[:hlit]), table(lengths[hlit:]) + while True: + s = decode(lit) + if s == 256: + break + if s > 256: + bits(lext[s - 257]) + bits(dext[decode(dist)]) + if final: + return kinds + + +def summary(kinds): + """Runs of equal block types: `stored x2, fixed`.""" + out = [] + for k in kinds: + if out and out[-1][0] == k: + out[-1][1] += 1 + else: + out.append([k, 1]) + return ", ".join(k if n == 1 else f"{k} x{n}" for k, n in out) + + +def main(): + made = {name: (raw, make(raw)) for name, (raw, make) in CASES.items()} + made["max_distance"] = max_distance() + made["final_stored"] = final_stored() + raws = {} + for name, (raw, stream) in sorted(made.items()): + assert zlib.decompress(stream) == raw, name + # Equal inputs share one raw file, named for the first case that uses it. + raw_name = raws.setdefault(raw, name) + files = [(f"{name}.zlib", stream)] + if raw_name == name: + files.append((f"{name}.raw", raw)) + for file, data in files: + with open(f"{OUT}/{file}", "wb") as f: + f.write(data) + print(f"| `{name}` | `{raw_name}.raw` | {len(raw)} | {len(stream)} | " + f"{summary(block_types(stream))} | `{hashlib.sha256(stream).hexdigest()}` |") + for raw, name in sorted(raws.items(), key=lambda kv: kv[1]): + print(f"| `{name}.raw` | {len(raw)} | `{hashlib.sha256(raw).hexdigest()}` |") + + +main() diff --git a/crates/lumen-image/tests/corpus/max_distance.raw b/crates/lumen-image/tests/corpus/max_distance.raw new file mode 100644 index 0000000000000000000000000000000000000000..42d1d10b3327a6633b9d3761730b4b65a421bd3c GIT binary patch literal 33026 zcmV(rK<>YD-H+Ss$9Hpr+Lkac&4YQNoy#v6a!n)`iO=J)q6(P%W%hHYy`82gp99o~ z5Dy73;XRoL$97Y2m)A0cJEKc~0jU*rr$=c2jsEV}6}3T7!a9RV2N96O8)h5WN@5Z9 z1lX?tHZ|?(4R~PswPkA(kfAcitVLE9PgMi< zYouZwWo!L507c#S`OTM2|KbHTFJ%7OnxvB%3jHNEaY6#coK)0HViFSq5=gZ4o^y|iROYtrYK zeM^Nb?YR08AUb-Fr`nyJ5=S=b>NLLu5kzTnKMxBnNM47M`5_lvBjj`YRH(bKg_ZIn zmk8_xdFflTPxc4}nW7VW5xY-OBL5N-bBkWQ3+C^Sz9Dm21sOx+| zrpi#B7a%d<=G0h5cB#* z(kmQuct-3t)M;U$g?_A1x7OGDpL0?Z)Cfo4n+mP9N0M4krpk~6q#|c@Fb2fbL_EhN z%MAOW9da9?iKnB^UiA~NGBeV7K`pid!FY(a2`xEA$5@K8@`Zq%|G_9^*~+u$ITmT| zjyW_-Vklf2rP(IugU5ocqadZ=DCE|t*~(N;eM3zuol8NaE6ac z)VhzODusjB=#N29t6}um-sYS&P1z*(i-tv#e=})`9e@FvUN0K-EQps&mX7&DQsTj|pGTphH5qQX~z|F6|B%@TVX z1_{HBorC9*dnGV09W*T0DE&z7tQeFJBJ-|x6T=u&WOr?YT5dI&Ujw4E3fMC)Xmnh? zUT5nunkpEB$^%m570uVQ;N0k;@Mn>kFoBi(SI)yiN9i5DzQ-ug?`IZn&lLZ}}8@)V1 zab|%G!ZM{`0vSR;M(0c2he>;z4dqb3Wek-4x$#jF%;!06xOzbO z!9ELx8Sl@z=yxRg_0c|>v>gneYIGhn+znfYCm&sLBdTh2nM0$Mu4`S#zK78NBlAkT zAU%5>faFiefuGo0Mn#;jxsbA#Frr7mJuve>fcmHEGT^QXpbr8?LTm<~2^u(xM-ssn z>8&Y@JfZtvdwN8Y9&u}yxt!?9CH;UqX)sJT;J=pItFaFLkn z=kTxTM{tMD{!VpKIA-_ny5)pF6y^vnaV~Qu%myj(j7Q%Gl+DOj@ zID`(1D3MF|1*X@{Y!H--PRWZERTM_N8s<O5LotCDgB~guPRbB zV{C^?M)=|ncuu<=O{FKs>n-UIz;y(bd+5vwP#ZEYTQ`A~+$ zpp5a+jC$HaeB)>8^jE2j#q<|@+&E?oH}WFQ%wqY6%Y?>8$^8zf>^$TG-+1R=bIU)r zYn$IFYAD50B|_-l&x9ePz5bp=goq6$lEp0mG}7wWCek1kT1B0=hZy5}v3C{pzm|*J zflUO;FlsUCt{2GDa5V{wX@-6%^3?WEP)}zQj!yq~s<#nb6R#s1s${KpzxT-0AE$8x z-C(x0c|1#y9d*S5+x^(gxHRUSCQ6`S?~1=n^j5)Sj;a9qf~O! zVHX-CpBN#np|ve8F=h$Yc9*ml89E3k{2y;<#S&NR(rxX6Bc(LNCDO2BdsORbp98vP zoU>8;$;v*d{F{daLR2tUPNr}hj$kx`Rmn@!8l1K$K*WjXOpH5PoPdKQlD0DZ?u7rh zwAJr2k?{tgs4~VCB0hSPYO+;S7wz9%M0VmIbNRX=J?D{&i;obG>O(8&zWwFVRhcCp z@6!NDujO4m!jfFnDleFf&l7YAXD-P6?(qMpBTm7q*u3arotLA{!vrWZX?F-DhhiR) zXDn8QAwxcq?o|z>$O*Ws$t7p?f0-J1SZU>->9CN(XuwE(d9fOX=sk;0sAcdx;SvAo zyZ7I!Ufqjpkj^SNroU^EALkMog~}lx;fa&;bO1{}x=aRBED&(zbI^xnBwMkSI}1(+ zbmmY_Q-37y#`?y1;50K!+w8IB4>C~J+gj#$1T3QAvi^@Vh@m_&^WpgnrW;PV(NOm0 zM&4_-;UZPC^zg@VY7{Fu+)f^~urfq0xIBQWOUgxG&8dds9hZbU`c38SE~+_3A)~4n zcKZ`>>W31C=nDavmPm;}Y|W7tDoFjoFg`6uyNm}f%H<~fcEv^0PW;|4=xan z#--?7QmA{#2!u+3)7YY~`-Q&qh%A`L#VQ<|Z#=7TjKx98x5~IYLVb%k+LW4qLJ2dN z__hs_a^K-DQzn}Pn}5!4fN{A)+sp?N9q28Qql=WvxICXF4Nq(evQW{Vy@tm_!06l2qh9nncj!bxL z?-Te4uK%~g`MaDtOF$lt+C6J_7VbJ-Pge5#?3_0WDQA_Y{tmoXk+JFB;+O2=Eq2^w z@7FeAV8{$NYgj)o%Z$w_dNgJ>n0LZXcyfLIpsg<4d^Cz;YZ45wMqKhno&~FBFeZbTAP6;2 zX>59nu_A=Dj6zVkbE;q^;WX7ph_-WQB4UKyTR9p^URazrBMR9DzoC1O0?)$vzD%jB z5$oDFj<8y)AN0oFUp&a6LKnILUy9$n}V>1Ra^V1C$@OnA6c;y@Ax30P9(Uyw{g(5vGwq_?Th+k z06mO;*`~vc6ra+M;?%JC%T+^I8sY>{&bKwPWv?jqG1Dn1RiChZ&X7x9YDrzctB8L* zr9WI#v@Pm`yddBZ{Sna`;i)%t$PY7pWSKRdkt7XWr4lRv1CBEqCj4^u2U{m z+rl*0kklcO`)j1MAfLU|M9nE6Ghm;qN;{@6`2%>BvGB_H?IJ|5MQcEzs%2vCt^Fem zD7OC|-U=~ETf2$=%^qh|=LXe^+j}ct5l?W;-qxl_Ib^t=Xu~A?lVhy0H;YKj-6e4> z)f_Fz`y`|0L(e|S?7V(vPR)qZs>IFw#2N4NduG?PXh7!Zp9TVxBsx-Kxn6;&M$i6TprdnI zPe&2wr&5?0Lsd4tE;bClA&X6}G%Z*gCnR54E^Y+^W`GT67*g|z*Ymr1G5y6%l zl>Aa|dG_!)e`v?F<1Nrd5v^nL>r&w^$6JQ|0wublsbJ}(4mO>gSmSWpwxDc*_>t@# zAJ)CFzI1P@cWc&SfI48AijoS0>j;OSb8<+R3z!Y=QznUbRQ^G{pHMKoc>RrL4c_-4 z!2RWY96K-9?54`_B-9yB?|ACMn5s^G0 zsTP8RPD@(HK0lXfcMbhFmUAnP8g(Pt<{Ho0fF~sQkcKR1o}BjGw)P%r(gHds%+VaY zytZH{ONX8ZXB>V^>GzAI!`a3QV`@wkHbRLUsOxJ~<$W}#{^F1FBa!=n?dKR|piD%) znL;>T6>Z9TVq2zeRdXE-Pt}JHDTiT*G)B>!)|HFL@WuFy|BkfnCw*{T=uD~{wiviNSdTUj!p!@0S(i1Gm6>zV>BVfUD zt#8d9aZ%;Gx)RkL^wnFc)Qq+qvmRwnu=J;o9qisV7-~|9Bi8aCC*MYRXb9zQ?qD;l zv+aI3Go{<2z;D2;tpeI|1A z_`_SyO&LGPCpY{v+=#rKSRN_EFqJFj{_I|`Q(YVL$+yl*o7>d7`$HT*TLmnM<3OrQ zNkESwLwplO2T03D@q#AbV<^(xi`pTa7K_ZgDTu(Rv+I_|qe4y%ZSTiirpbysdvmW| zSh_dyqk%<`x>@2o6Z4E5lkn}Rz7kF502=O)_8u|)UQb%zBoFecsu3gyX_6%S=CAqM z`N->qiW6^!tuGdav09ve>@wlB8fqhaF%+?U2afRg=8qO4=1f6VII~6YCi#l<-|Q#b zZSTtkn|;fd|F4pq<(yFND;C6rDD~+G8yrmDP4)Z+Y6vFOFR+@0*p$Ss2p2t*4wqn1z!; zlHdg|PdgAzf>gb^G^_~9KZ+L=ufu>oaW@NUj{PHEt6LH268+U<{~~M3tH?W6{>n6A z=t+;4@x2jw`O)bE4Sxt>^bl<7C?pXyDByneIqp$cBkm$3&9+hU3Nbt)v#mVg*}3BL zt8`vpx*qIBCGg%7`!BgztqdPdQZAJrMuvro(2;S&&4xqr7Zj&C1QY8|`NHq)t$;5n z_f(^i8cTc18Pr3_O+8X3PpfG3TOz8f{vR4)PLx+j}NTP}iz}fLHA@r8ltEa?MQos_G!G zKg_zeM$b&m;VmA}c}=!H3+vAX^n<8Zc*>-ltm$U%@TA=k`Kl-!Li8%H;V{d^D!7~Hgp40*x6hCfL&?v!0UZ&PIv zRt@!9ONQL?+oOnTH)!iT%6aPb6d!GFd9P~2p^nd_?C^l+@<5h~YySg>7BDWv{0^Na zFOB#`$+(re?@>g=%%uvn4s;K0`5W_jG4w#==MIb#07Q1Nop9bD{%n7e$i6;j(55}E z-JNI)7PXKdJ`R$3X9QvrzGS+0o*OmvKH9x}{FdKP?fau1RZRsr)!n#)lWDzX-s3Sr z2+9|=L~=D<+pT!n*ym_GEjC81At>uCF%*pO%;;R$AI!ijan)8{b z|EqLwHm6KEnZ*@~mioF^khWw5*J@bAZ9*5FVL07oO#bvTzv*uef0Yf=H`bG%W@m z=@p~P2E8yt1$_>(l?STPO59X7pR`=FQdZC4=Qr4Svrq?d>d(oMNSlHDTRDt5nx0W6 zrS|Jr$#COtEYmLPm#xDqd0LvZSvSSuQQz7*dR-4Xez&U(*|NS6#MiEi@RbG_QVW+_ z!u)-ih}>cj%NlA0=(3$HjYSKpC$g`F{R0|Z@9YL_fTEF3A= z7rgl>Mjb-_!F^7PbKEqE{E%oG& zg&FyyFGDcU%egtiDh^l(xy-jC$}^$|y(!{(rS<$$&O+wXy)RLs9i0L1uM6FfO=98F zs6b=4r7voJr}qgxmq$hFGprR5KrgX8VM_1VsPrABR8; z9S2MP73^;2Qki7?*eS&$(Gt=N{UJFsv#+2%(dZP?6e!`rwT(zOiDh$|Hv7$yX>Sd zpk&?JSHnOYj`|+GYTd6~mzu5hljY%)RH+1`uwy>pRVREx2~u zdGD-iL{X1rJy5y5$aaaZo+j$Zr}ymFaLrn+C^ZH=RqJ=_hgiuqGX zamGoaYRM#rb|y=V&myHx&i>=D|;j%DIy)?;J>>Nk*p^+RdOzx z`wd9%3{|uwY{wHDjS2atRd{CR>&nA4)C=jFEqH!SPU>nk#-#NUYwRfUb)GI#54mdR z?#uZK(Sbc9*o%Yni`_^+D~*Iv-z%8DL&82*tZUw~@47j55FUaUJ1aiZYk%0Jd|fhL z6D>LUo0~r%7qfwxgq-@t)SJuT$oOt(Jf-?y>1oJaAEiKAcUq6wM9i?QC)Y`0uA~b< zVo;G8_{=Qp=}nhlq8+m&`lE;Bp%sWh$HIL%7~m0Fvw86|%u4QT&PPtVdIvS5kx|-)YW+zP9DCn~~DV!_#pW(IvhN+$r|;$4?z_BX=v1 zl1HG&oKzavRn2PvevDuj=i)XISwyA8s+Yp5E@@PSr!;ML3PBI7cN>f&m@<)wij;i- z_WU;0reUBcdDE%-a4oaJ-_d^Wl{KXvT`Fxm>E;*c0eROT=vo&&NTt}giN;xP^>hYz z#$L;Gfv@wn;8XaKvLz=AhGURh?Fft%aHOG)WU&TD4z6PVl4Y7%KaXSkZYw)18T#kLcqJnRy{#0rHe8<&Z@r<-o#y9K51V z(c*3aR5|3kVBoRF#zyrNXtj2`?hlslvxgH1ae6;iD;kvIVefVy&T=3{jjVtiE>&V_ zgL#H;BA8F`1n#`(+ti0TwLUU+>7;v`v{|VAOHZc+As6m7{k!wm@d~Is89pA#6y@JT zj2dzGNBHQslz1S&S;Xjq!$tIlnyIr>y`v%}LHP4FEIGdQ9rFq7v)5?Zr_xoCt`p(A z@72E64+~@ugS)_d4CIyluX5U~GpbRsZ(a|h{1L+DV7a%=XLj*4CUbGF(u}toC;ps;wBRKbJ(Xp55BCXB^tKPJmEW1vfELs&-qY_!E{SDc!jOh)kcbk0967}oQ(*1UI z#sit1nxiY+)|_2k4*{jrQlEYNe3vrX2*sKGHFoCZqGh!LjZ^Ab5B`y5P(~22;24um zzGc227ny==Tg?krpZc#dlZQR(;xroJ6vSTM%ejLIE{+J@& zPrYCcSRp^Z7}wPOh{l~L(~%pWaGG`^V)syj_Cyc+aAMLCysHI57&j|TbenBa*sA&G zkNq{{zU#L@=F(dhnUv2Hdl`fBupl|NxQ3Mg)5{?b*y6>}yMNnqeg|^1L<**c0ql3J z{~c7gEwgG=xW(6$AZde!)kfV(u;WWv6~$#;G%)J`8TJ>z{rkq2d=Gdj=nS-+Ri9(@ z|4T(X6*vSX*#{_olxt~TjPv18PSY@mZW?w6TbrKWgA6{iAUjg8+11XvGd@cvfcJmu z8|*iVehtxH+2}VBD@(2l0O9Id-WAJ)PR9IT%}rOb#G%8P2^!aMB+>lVsA$ zLja47V2M4pa`Ggxd^!3uAA8wIIgR}mg0Wa?+zf{v4ez1ZcHy{V`}{mB5V>>lk2U@Q zJ|K7%Sk2g*)Ol(h^rQnLNFoN9L8Rx+|I?Twl}&RbW_^VRq24I2Af)uB08zURj6Pyy=agDAh(njjmot5#WlA((X z1v6M~7}&q@B9{?DC<`}_SZLVpgEV+FHUw!07tYh)W+$ZsS(8^kFP$^#`oD)qx|@$m zL&7pbzTVHRHsp+0EA)<)20_cE2~WEn#R`?2KRpo{FvhGT<-vDFFkRyA0Mww>x%w=c zlajgWi@4>!mz=SV?{;aXU3|J8W5* z<3)F#qj{ps?#(Scp8BqfwN+d}Z?^nzf3N;Qo7|s6Vc!36WM*uWB!%jXZ;w0kCcZHj zTl^mbh7I4*=tlSl$t~@E8rOCO_9{~YuMK2Sd41CNou#_kJ(nBl2&|bsd0$+5xEyNi zZF@O0D1E@rd__B!4i}w04lh)JWw07L0dz}9Zbhd%_z&>Gty6@fV~pN~LD0r6gL>(IOL zt#d-e0)G2uLmy|T#p_eBXi*V{)?3(QIK^54%6m+M)FpMhl|bQV1V2%jg>JU5ifo0* zUX8XIeSMlh!Ax!Pn0gewS|^gB=N@G^*dV_KBIu6xOHJ z&pUU51k90|FNTFLIT6J$NruUoesyZ1qL7rOdTDmo)QDZ-GyE0P-Nodv=Z%Lyl^PML zNk5{TCX8>JT5aY%EKTOJ0pcT3cTjNKiG@L~1*Z z&4q1UM*`1Br+JC<$s-fz|M?Tju1CuRr{O0N@l06oq^yO~p4Ia$=7HxJ!C*OlRnfgl zsjBWIb3w!p`;?lNsJ51CdhcPl5s{ML@h*i*zl{)?-t=CrehdEbS9dxz-ou2TBHEda zL_w5zJ$DOQjg)I9zd$e^V+Ny!biA`?(&i(ZU#L?_uIBw&zSy-sGV^Y(W-S)G94Ad; zUSK{|OnN-k?7Dmuh$F3iC`@n2gMqMxPhUs}u+j))G1K-Nr*4Oe z-zT;cbnn>kL;r7!BD+MHC3+ew@T7Ec|E-7$0ZWk_%fn-OQb|3?P=&xsR%CYoT@SMf zV)n@3O^g5V42sRJ;2M)}%bcKS7^mk~bEm8|(tUkxJBHQ{v_8GJpDOuz`2NJ4RJ()4 zg7?2;VP(O=a|WOH$bCtI3~A*pP%`Pue}wc2*qyc1 zW2W#fdGi}C-GVH2H7a#PelOoDQ3~g!52`jmy7Q`R?Q|sV9;S+S_P?{e&QA3aNV^rk zubB=VF1}1G2+XdZE~3B_{9U@ckQ|{2VQC-Quc5O#LKMW--PdBX%`{`cdji!g?@{{n z*9pBTV7ocPa6~8*b=nm8LFgZl&=r%tzowAX*urvvclrT#X>u*2`pH$6aPT8VaOHmB z-dM#4Oqq6`?e(dS@wtY=I4k|CwQ%$|+D7byyf6;kpJ?a8XZ?$#s8*AS&g^mYbJ zdeYo9p#xiUZwxjErJJ3aii-UbeUEU37EK^Ijwh0PLtT26{jB>&F`I8fU%vY^@R)(T zV9cS1oaw{-Ov+JP0YqA$BOv%K>lm!2^JBv6htAlDeOF&n{S7`GVc$|rlLBt~PGOG5 zHgnkb<`hhM4y8y2^XmOp7_FWZp%lCpcgZX9q3XqlTNg^kAAu6cH==rw-7A=l@m~X(deOcU6>Okd4(^toa57?bBm=vH zTMFY});@X!0dkysQ9HZrcj7aD|IKt->cCgW9a<#4AX&~V&}(fSO1B3hfF*$4}gk|An2|HlXm+Z$mn0)2qDY!V6;N+<6 zpcfJM4oV@N2EcqvfKE>5C(11Og&5bMPQ6C-gt@~@?NyU2l@bD_5%kfbn(O}{gPpQnFxbGE+MU{*U!J1G3m# zr2%W>lOP>LI)!--9L2M@{T}|FXCM=YhZhb==5vONa;MtuW>vyjfHgh5$zBRJ2QgV| zd)B0IozOUVHo7q(yOmI**z&{xNAhuDw#99&h_V<*c z!8(TwXNw$sN8By{q0xpt3j70{7YXDwsP+2Guf0sEss;Ysh)|y9~)@q5!$~ZPCnnArJXO!^Pf9fMC;(R=&(=aQ)svu)v2D z%j!dm{w!P2mf|uYd*Q3~=v#lva=7o2lVh+@UeI00Ir7vI{E;KHPd6t87UWFFL$<|L zl5q6U%NHKGZ?$1|!Shj}7vg_0BWMjuq<^x(mHm?GHrn?2QoCln_ZPWn4}HKI>EaSRl&Rh-OzErCC2L+F$awL5gn%TUf#6>hdmfx_MxM~)4) z=~u0~K3ce+h8jCjDvx2DzjmbwV~YCS=ta~ujh_5F`x+S&=%29Rcg0JVo!`6JvP7L> z75QZGn50;t+gIZk^;8f$nW6BfT%khgrvMZ*hZ!nfDCx&{rp&G`>slqu-%C8YU77c% z1P8NR2>gX$@<)#UwwKYeAA5T<*GlR-+Obp?ejVe1fBpQ(nX59rXEelu3IxoB z&Ir^UbRG&=yLl5gi4zAO0rNThr0K#UjWYn@J_EicbEahW$LxjJ{ZSOVkMC6G2>7_e zn8~NJ2yDQT`|fa(2?jZGrrx}@OM7|mYr*0;{kE+6>b;V83PUIO7jdL%%scGZ8&RI=oe0$94g^ZMt@963W|yaF<`9n7 zdVbH%R|$405jqFZDFs*scwil3p4cASI6bqylUr!SZm6UY7teHimsK$?P!6mK$idvG=7Od z)|DW3yuyk0q`j%0S%D%Pm%4Q_v|(wL0Yd=Xh>L;wlLbh2eo~B+A*Jh=cJRS)1YV85 zppBzMsq6eXR}*WAw&@1ioX}*P?}DsK=_(U(Q`Jz7F#G(>>x)pAl4@A!#MQtp#pc|t ze_W2fKx=8S`GJU`X6sJlL3(jx5x2&w7#N6xxkqZH87hrT%s?eabdbZ`U!)18h{7yn zWo^i&7Bm9Do$CtWybz`8g*mbzt(|aKN-Y$d%85gX^nxv&dB^a$V6>CdfOt)#MI3w- z5_1i%6+F-No=S{;`*(o&G$&a=&Z3Q6C|7qO((0^nMU)FZr|(T0wz85C4v0QeJM-0W zqSnI)*gSmvV_rB3T0$*cyNB3eG)@C~;CKu!S%e;w?2;tCA9EWvrSb3{VNKI&>1ixA zsoa%K_>2#m{~-}>G$Hqjm%4k}?C{hb@pT8PL|>NibAC+TVG)C4+_E#)2!6xcM#3g( zAhofCxg1>Pa@Ygp<~%*diU~x2@J;f8>SAn+8gIYCHK@HuR5Ervxl`wCM1dZ|i2J`n zQcGimzya-|kO_I1be1Awc>N7@LFCv<>0^rmTBLuse=;1evNP)R%K#|1heVDnvzIWK- zR>b0hgH0Js#`>nCtP&`N_H6-~Z%7{JS9{vjHbQRW;EUdiR&S2+43Myh%3XYQ1V!L+ zHlB z5-Gy8{2XF4FM4sQAUfw;RGz zChX4}XW;P5^d*orxx2upZU^IsHZacHQ;B>7^kw`4zUPtS54RWqn(&E3GNvBGA&>GM zw?3}B&>zfT+wN9q;wP4-pIL#*GF?&B`qO$Xa*GLapC2me9aoN=mk&VmBKpd&#vxFt zDtLi;b~iI7BG}@ZVZW2Tz-En%!cEMlgl^x+&`NA!L>1x*nl@D0gvb}+_HGl}kQhQS#0)=S6mMZ9W8r8f5QrwhT z)m)RZl#-}PwI}6k#^d<@2e<389j_+oaVae&C)e@?&xP)1>+7SR`Z<6Q9(bgUv3EX{ zL=OgBa@5yJU@!|UUGQPvI%msN*IoqS$>`zp*4w$RJRQ>UV=CUg!CRjR&ZwqA9^*nT zf2zQ54GiW;yiWzj&&5XX4=O%3`d^+>y)@y#g#k8+l_K0wvP#Ex9q_BXDQ%hk-9TJ0 zD59jrNV$T6v$^?IhVrSs!OhN!vFjapkn>}4*7KNA&xH7of{a?%-Pz_Yz_c)iiD%;- z+~~#q(YgGR6ctrcOjKnS31CEBm}ylJCLs#*t&LwhZ*!qsR(uUD&AvMBKA?>Cz|bm* z429UR0bY+2$#dz^1*|CwCDXDDY=mMhVN4-A|D9g7HsV2nI1l*=5fvmL8ZAvrwI(px zc3eSv638bmo`9ALynNv8+L2;Sf}%ly!++nRGPa)MW%{D_rq7J7^vp6bDl%Bt7H^6L z;J!~HI7OlBp)eBD&qR{TRbf_-Td#Y!hBY&*T`DF%vd4KRv1#ueWtGb;?OZbYsB(OO zoCupkY#Vo;xF-fJ2_#ItA{%ck2Y5Dx z-YpZUhL8mIvh>)X*A~Ww{zcqJ*c11#G^i~`wL1>}_l>Z!_dZ1NLAMQpARJ(CZU&b% z?Z`A7MKl*z@%M}>{c1mm>I;F8?h$QKJ5sy<7;yJYLR2J7YbkJ0aItw>Z92sXJIRPl zhDAi#6ZpQ2KM|$YlEVQ6FG+^gQhD|*Jp7zCtS)4+MErBLvjs{8Z#JZ=1oh_~(W|Je zNe9m7rBIt+jmoNvub`$5{GYTYQqum$bEYAsxcLIqE4RU1v;%kl91yw-+?Z7UHgP>Q z`~>_d5L`i76hzSA{r~&=?lQcxB`F+s27ne&3&>J9cg?QE-Jx_73AdPfS2xkA`Ph8!so zz3CQkBy$}hZu_(YW5`bnM@eRUS9BhHz^3c``MMyIMtEy_^R<&(Cyd7#c}v;-C^(X+3Q(Je(o8@;H#b@|ymV@P6p%Ovtawf8>I~SGVLGC_#EPZ zyMM>Z!RRA0d;;p;FZp*?&6!7HEMmT+R)0 zL=<6^tFhNvEsA$#V<+!HnegnRc#8PWqt>dyie`?A*-||as_ecLo?oomdryMt+674_ z{BjSXcFTI@fYI_VZ2gf7Fn8QpiUtZakp7JLc3A)aPrdpGV45T}SV!BpB{e@TaBLlo2RK0+{Fxe#X0#xNce)n4}LPwF0b#FS?e(dS^n7C(yD5h%cW(Mi;i z+(06WqCt8DIUN(pYH}HaIH<)zeK0v_RKT3OMRg3D`9bdTQ=>4=4PJ|sy0!j@*TPCg zoXC(-!hPp{#x^th3li6@FT$uIEatGVVj!-<9uo@`v3~)7m^B-~F^!ZE&xfR!^9lIu178NE+tfMBBH?pTN5> z1Cfvq|Gw7A1~rm#eiy{5w6eVq-kjUu@GYC@=SAZLITc{R1u?kXYj5uriqVTxt|5c~ zS535b{eGjBq7IM>vx?z8j&fSCr>`c*I&R zF<{%FCFSe=9pWcLJ!@%(NOiCje_bl>J79a^CggpCs_Fyz9Rk#s!t}*YMqE`U&Ed+B ztCt>_yXE_YB8(|=2UUsqMWtqb02TzJi3^8#KQ=dH$T+Y$if@S?ND;MGZgMWj3fh-Px0?w<~!)rMdNyXR9U?qYK%(Q2w}-V0MvjeTae4d zTY}t6<(UOm+^dSqXU#LlK_3D|9;@i0J>=tXi4TVoA`GaBjZ#+$d*}iXp;_j}D6b$l zV)mwTywdG#J*B+#Di2PPg_n-^a+zR5JR?DkQ7Rx=V)Ya*pfshcae%z&*i**B%W7Tz zH|y~+z+c08qj*Y}39#lSM5g}Ib7^iw5kM%Ly&mm0qD@t>O}<@=#Uyk$VBwKOsK{AH7ok;gDlL$lYrQpPAzHCBw3 zHgflPose9@SR`gP)*v&4P&7U6(=_37F~oyNloYr-`m_sKPVvJhR!t~=+EsH)DjHOQ zU%w?@j{5?iC0zeqkVjk?+jwJ$!OK__`3IZmOkA(Iso;S};w|~d@=gAL(EuHl1#oyZ zCNXpE_2%wRq){bS6Id8x|Md|BL|nCut(^N+xwzA9hbG18c{L5R(Crc{CBbONOIYpd zbR)HdT>2)4QQ+ogw551_k+m+oRkxGEv^F27_{$-`G%bOQAp`#SVx>+#kDAj^k&cte zjoTypBdC6fV}!&eMhJo9koou2d@#JA;xfcioyv*s2Lsc`)U|T5O(oY^$-Y%Iuq)zv z+$)_!EGRTK-5S7YELK<}ek~4XG!no|q6=)jz#o5jAtKPOZuy0@brr=i?kWW0suhaE zuEpThG;Hf?uv*He?t8wp*l_XJubK5lzH8Pyg6eM!S7zmHjho^c7OT=CtVgU+!V)_F zun+L(zOVD`VwabUL2_%1I#fk1bd@g4y!r{~(wZqW#*fu0_uPxYN?=@4;Nu)`D-#W? zvuk}G_uF4JvM@)7@IQG~>2t~MkCzv2r_>_tk?PO}4bJMugtkb!p{R2;5ALeV|2_1G ziZB*Do}d~d4+6QK%AGmrhX(ggz#bmzc+SKpB6w-A0G^b4o{B~_L=U|vaf1FN#Nq); z@&jxE#Q!lI`{tT_fHFDJ_5U zP2nUYegQNasNEP+B#~uYlWUWrFYx;iVr!nZzsYQ%yGJ+%Ogi6>Y32KtiI|CEoxsER zpLqtPfrrjOxabcP6l>4ySCX=0*)=I&8^24g{GN03PF^EO!=LQ#2(+o&3DnsIC!>-+ zHm-fivd%Ry$6t{sDb$>_%a7}f6}-Z9lP>u5sK&c~w~tvgSv#B!2&rMv6+@vhG;XU% zKEbO$NJ86Zz1vK-MI8hql?`00OQ)VHX-JmZ)C~H&|J2T>gi#{Bd+flDbf3GK>Fw?L z7pi)E=N|!l2W*_JhI~amg)>>d!je|S)-gYFART)wIa%pOPxQt?4A-KFmDq@K=8!wQfS{S*=4Grof@jaCIA|m)~4$ zQOR?Wj>!(#G$mv(C6;kmV@%ZmFmaOqFKEp-$zN-ko(A_TXoenLW3hiBJ`kbl?!X(Q zdYUycewstt2)dtGL}1h4x3Z1>=sV(M6#yflx3Yee4YuFdiqC8nmNo5egOzLlmMqHT;^ zfLkAEp@SD3H0db5}bntRg#(8yBpq`n?>&UR_Rx)U5)-g`1E6m>#blOz0=WN%L( z!iYpUE|C{et+&&eDgf(NW5U8#oW&m8TkKiDIBn*7J{FBj$V1!AxyYNLCBsN=>Z6fc z{sW|iOWw^38VwlJ74P1;dW;Gqrj2)gz``O?SgtXIShB+|uBHSr9jUiEv9};=;&{KR+Jr2Qr z4v#G${z*?9yOZ5?-=0 zHnU+cVf2^<5$(iiOmT#Op*%I}QG~0DB;Ql1>ehoExlA@TQ-gIvhvhXjH)D)vKvCee z+J3joJ6dGcxz(j-gzpaRmpLqr65lI2W#08o{?e3S_3_={&tcgEgr2>T_DeVFDr=})w!@g(#xx-S{G?**ZJ+}26d3K6GM<2vxx>1-am%ri z)kQS+VqB9Av8j6Aw|hIF6Y|b#An@Xl4zt~ z2WLmf9-$CGh^P-aeqSiFFx}07{Oq9|o$f8+YzE`>5}sfuJ_k8WCV#t*R>=GeQhv4n zUC_lM4{!TTKlQ!5QrZM(iLD@p$dfiV40DNGmCd9~w(txN=a9}SzbpaLO8qoP;R8h{ zWg0a(yT%@AchkUPT%b9$gXS>mx?j-fJmd_aU#$Y3*_8A(m$-!?mZn_biu#@5*;-2( zCFya445Lr!f|T0DmSy~|$YT6X;kHziEkv?}y`E^g(gvlX(Ut%c)?ne4JIvQ@LvGpH z)g09O7{D2xVgDsjgVkpKdN^_eb16=dS}(*zlOlk)LY{@Cas)^_ih zW_7jb+Fj9Am|xb5!7l7P=sn-)FT__be!2j6NNC@}`P_YMgc=+JiRA96P9vxQ(NJ_I zZc?@ZEk{<6JBtv{KDyNFzgB1Z9bJRsNjRa;+u2;%Q?1kf+jFseRV?ih5QY5=xJ(aE zE7Hq?Rd8zp+KZ8Agkw7?9JOR|1hK4$k^R(^E% z^DBjYJ1Tj^{q59DPk$1K?BGnj6s>Dy!^U4-%}DSJtjOV2mc11>t$;!F&d%l7ciXhV z3>uT%sOjs@5!Nz*!akgfbNcvS5>eig9O*r#sKpHk!{Sa(%fgw=LC4A@>(j~s7usJLcB%4SHb5H3FxC9!YWVz4k04BBlxAQ>6 z1IU)unulv~k8*Fzq21LONRe zh`S9IXlhnmnr`H~6ljW)cE)16F%ol89u%zHOHbbdK7BU4FebWY*9YFYgkYmYTUv=; z9O2&vY{q+;8byOhGWq-W6UAC;6eu(DfV2?-qWhV(#J^WBqOMjcu&DgoEsm~q%z;1u z448v2g6*86!h2Qu&a$@4K4v@fbFJG#;KGROhiHB;zY_&zwJC%^knY;K8&-qz^WHv+ zou)<<#L=ToBU2-bSnYB8%<1vqjdK^^bqw)56KZj6M9`%lHVF$3FG7ZkYarJiHua{% z?W+bueZw`BV!J}V!X`nz`w%qNOZ=n0ADS#mRcEO{(vz0dNtBQy`=?&t9TW+GbMEqC z@G!A&I}BieHl=XZ#dilqh3PiXo*Bw|!*W=BZuS|6mg5DLND;hr%~SzMdeu}J(?b-ytIr1Yn~`}k?a=%@(q6LfU|^T7YZ*UZ>@(~x+7&WRr>V{=!i9g+Dli64H(PG zh8gYxZ;J|_Wc#wAJNBr{I&`Zu0&KM#G%aIJ_jnoz6T|pt&sUKyhF^7zqoalfYhBi^Y-_UkO>3>{=KYpV) zwDWxRI7b!rp*tcu*nxFGxj#h_=#2QFaU{|Rb4{1q? zGL9{QK+Xm~j?in}y^{4dnE$BQ<>K};aaY|QZAf)cK`Oq3K((SQIJBJ1Vk z#?}R0IA&?F1e-g=SWx>=4GXehHUpp|0_MQ`>=qAn`PbYPPyBnF0i`Z#4%%2(K;;oM z5ZEs<4m~1M)^BXW7ChZLEJ8Vf3nbQYa$%Iog38(i<_^vKh&HmcH`d(QgvAB|RMhft zO5h#~{QqqllD1q`LRnJ7?&E!xwuPM!KE&r9>Nq234CT43CQsczd_aWLMtF`cPcH;9 zh$Y|oss(og*)$ACHm_b_1(O#|%yoF%r_L{d=ql`lRyi_WSUE`5Vp6a2#C_(+o#fJv zrgaogEW|tt8w^7BtC7AFb6blTr1-A@ZH8PCg-n!RB2sn9fF8oGNniE;xulKd1@Qlt0vb#dXFvQrS0G7qd_|y5;3u%46FKHs=mr`r(Jksu*ZuBvPLHA( z$7|K)npWbAsi9#K@|I~$8X)NlUna|};{C{vu$5Dkfna2~&f-vJa5l!09S6yBjghTs zt`k1C<9D8>TP_=6Gz17&l-gjUuOvHzrXxsAZRS9> z7Zm@|LTLc0oi`4d8t^(`GjU(+RVq*7$MRuu=7Y0C;`nanR(O<)|9=!1uAkExjpZLJ z{|QrD>j-%s9)gI2OBPS@ zB29oaghX10H{3)-`DcDPYazW8yIRcL$dgXmJ_vy5y@o`q=oTN|JKAEuEma{^Pk{n_ znPZGEB$&N{X@!g~;<`LxK$8{X!0cLDP$i12t9hEK169^IsnFiTtHr3aMbB8u?>JDz=`unM zbffkvqYQ=V0)k}FAd`XoY~?d|NvEIH!swsk6SBn+Lj-UUr+#cre^AcC}RO1mre zbu0*N-_;3C{AT=b<1&~|{7?%PUIBT?DW9+H(bjS+4lq=y+ZX(JVlD%7-ukpH3Y369 zT)h1(lJ4#9YBN~*hx`^MXOvKkEy>n^l2^FJnrS&eM~^Q;pfpamA#BpuAxim;RN1VY z{24yv;BZtvi6C?wingzR#MEIavDe_Pg6?=~c62Twn@mGSUzYBsNiJ2ssM(s%*(o6U zLhURcBu->=#1+(vGKIC0Fzj=QAVxel(9pN6e$wOq9HL7xtPCNNa%63JEo4TZLdT0X zRsxaLRKU2R-~pX%)m?T46@%r*GDZ{ezxEjVg2HX^4Tf}-9VfF+*FkGRkH=(GnI-u0 zJl>d%0~+cc4)|@9T}F!lK+rC#hUU;$_yKAAJ_k}|9t_|2&9x&>>AZgimv*7`zu`7- zT5*irp*^^uIifQBtb1$|`QG&T^-ucS;%>`H4SLLL*B~oQ97pGkEOHEYTf$lBP4zF~ zbQRYK2$6c|@YBzx2V;?fF*ql0-Pr0y|40MS1Wi^2Ux^#G>6>?8{N)Q6cLo}!_(bKD z9dcUZ_}`d^X0)6sc>LJ;7i^Pv>Bk2QPep1DnNHQpiV79E^cF7*&Z-=18Z@f2W|r9E z51<<)6%leEDhw&dbVSEZ$_8eSSgk@Hu@PTSw5J`PIWdeE0V?I+*Who(8RuXzSfN_; zZ^9(%59AYpB)T$FYP%)fCGM0akiSQ7v^R*tHTm4!k(MM3fBXz*PB!CRWVn9>2oi7- z-xKM|bsYTj`coY8(oR2bnnQZEI2JN${1o2sX|mBevZY|G(7@MlSJ~>UTdz0a+Hi8`l0?=O|qw=?rruo6P7o1$+UlPydOfyZ|$^5|#ja0XZ~d@nCBPL*p)c zaK=6gHhFZ8YsdKpY$OX853IK5hn$xN^&CsFEj?+;^eyBFki)*7PJVUFHkFx#$V!iQ z+iX4W%0{)s-Smu_PBLQDxcN!|`NOjY|9xxMgTTdf_*5Cq;breMJ_!jGK5+~#l7Q0a^PVqcRVkI`ZdTB-4hCci44L%x(C^9yO_EXT$c`pAs z3sVX#Et1Vt&?#5Bg0iIqo9d6H zrzC!{YWVYAVc(yB^BYU|AtnNC8C%U_e8+(s(-x_Pi1b5B(%Q^H)TTJ@;Mi27j3hY75sJ z*zbe(n|Ja&T)FUBiFOnAEFHt7{?G-bB>cws*B>SzVl|k>lrm_hlzQ+W<={#q`;|yK zQzURK*d7eZ>Tk>)d_Zvaz{$(Wn!ODBb5l>Oc8lZ*F4yz}WDmDht?b47z~(-?rfOY- z_Sqi{7Uv-{2q+tjX(O49bCVCZAl3&PoMTBoi(psy-I{k6IG)OBd~2K~>@X7XSWa0x zOQ#B3Tr$3x`=#57-aIjO4mX#d_-_drbUa?z$!^Q{!(7TI1Xi^g+Rah#3EI>o-gl6UvqmTZLa489Jp;}C?CVs$DaDtlvLdPAor zBO^B)VDS-|m2B5t=4_#uIWXzzmNd{GEujxCAyx;UiJya8--)9ffCB@q=QnlE2^*T` z=Q9t{tih2i0FFWW9{PB?c{EK{vTW7?1lMCEJmiKuUi7z>W!Ne4#BD~SWthj5Uxy_` zYhfMyj1vPGETqtcm6mf*k zBltOuTAxX`Ihit~nm$~Tp^+{|SAjD6)AU7=O++9okh(<`uCHVRnO24y>~=pe+Cebx zjdHHN1!PX+XkRC!z@{9rYn?FMwSTei$_a*+oB8M2YK!s&N=a$H;%pa&abdV5mVO2+ zV3^afaF$a_KQF&$3x2|SNF947)V$3Z#3C%2BSYWOkCaIvXPsib*OkKnZaU4~>2pQMsgERt=I9KQX0HO1SugFAfTVCvo$Zc!$wWZxB| zP9#C(^dxm$!JGxFQAW!co|N|1Wmw-QD&dO;gMV|2=~?mFm}KxvOITMf`dU!a{GbuW zO0uE7-^T@DGnxh(E^356JfaV)8(MBf6e7wG`XT8(a;w!LP& z6}4x`t;d@B2ES`gxH&9>TBOMp*JDVd6VW>##B;w5BrH{BYjAz@SV;@RV?&D>>azfv z&ERQ-G(F7p0nIf`bhJ=_z?uiwgnJoB1_U;M8owVWU;h8y`{O_!JsM<`F|@wCdO@Dw zZX`F6BU~vsV_JL22-9ouJAttO@PBS}5TTM1mxXFnkjvFvJXT!HzugfFuU#xqNL$Wg z#dm5wy}~S>n=Fq$?hM?ag_k|2EMoH{8U{sikR%MQ?=-Oi+YWOds^tPG({bDXepRTN zH$_U}W}?Gu_LVL+@ztx1B*e;*N^c0+XH6T^<#90qJ=haId(VO(JMXry?Ug8jLLf5A zYwm8fT7Heg=$MjJA5efWiAsN1L8xKyQ*xH?{rGV~T22wtBQ-xMjwPbLWBk%M{0>`% z*j0q~JE|j*e1EO+VR5QPxXlZtUOuDX&J7?Jr_xg?^UaHK`JBu+hWG&@qbaNDI=WY2H!9R#oIiBkA4kt+K?KqaWAu3ATeq zwJ}O!>3kk9ZDuKjrmf7!d1V4z} z^J^)mgJ*9*7Ns7(p;TbOmeE12S0*jWy+7%D=rvB&9trqk_x)zdyhElK^SrKZ520@) z1Qganz?>Zgb-KzwSzU>d3IB*426FF};+k|;`_nZ){=%mCaJ=#W-%h_$ME?|?+$4q+ zl?z=UqrXD&#ax|9&%$cjqaIF+2z*A=Xsa_DcfM~d4fzB8bwQe#8GbWDQa*VS7m4W5 zIj_W>u9DR@noM+9h}AI--!c}bjQny5(spuyjHR*2L=FB#(AqFptGPM_GNA2P+QK-% zJdXI4m`QaZoUk)Dkn;9$Pr*tbp_{O7wU3;$e{tEr+QuXDB<(RJ^T0XlS9n=?cL=`$49bgudYKqwbShRT%>gi$b+;}51)pXDWw$UC}I;J{Jk91YLZt7JL8s8mh( zEq&&&m(i|(E4>HA%#fE`?wd`#@oq1~X^O%Au$L~Ji&Lh6AmhWX=5ud2Krj*BJL6yNj!*58jcj7||!TXYAjam0J#!e#ot3o?-1w z`-Shn7j*eH*N*UZ0q?%GOP1$gAG?DiixheO`Ux+teB#>{xAY7q)v7Dt+q~zJX3$xW zDOuBy+%vUU@2*`=7<0r9j9^)u#aM*^ipIC?ER43V5YQezOgf?#am1{$CF;qOqsNau zQbbYJ{LB~+{=8O5MAyZ=WSboOXIN6KTqau?hQ1pO8sO!1t6H$K$YNip`{*6YDr>Qg!;;?UZ`*G|hT%wx=ncv$sSVOGO4#=$QWE4AjTsk=#$ z!E}D6u>^J0<{;Kg8>h#Vi%bq;R%X)rac(R4fA|_S8`eU&0XcNv&RN13x8K!?{}5BY zlEA0EHLI-mXsR*BQ)v0QXj`P;xC}_{DN66c0?uNn>6e4AvbTk2nExZ;$z(&Qx6Ap1 z6*bID3{fEspQg`!rG_#%)|NXtbZqtNWhXqiN?keC4iQDNrR(8htB$a) zn#5)V#--FF_0-*Cn~s?qU&*c~vA+0;X?$RogTaEz7Fx2vX=S1Xyk8Wt@EPP)=VwPb ztcSfC5}F=K>}J&h?_r%JdC{08@t;@tCQ;(U1zEGQQ)AS+*L5Eza4C;G3)B%-m+-EmY4^`*T`5% zv-1;?Kv!!sj98G*hCW}(4qIC`5 z9x4BBR$ce210F!JC*8hYH1r)`=x4#~a{aL8_6)bB-xMrcx~~C0<=**EuBfL;IpX7x zrZxZ6_}ebxZMp%~zg!OXc!Cvmnh!VRAopExB5186IU&>~5XUAMY>Dx#^o<&>hjqDk zh3RHn^34kup)v;7?)vR?*cfk8N@aiyf}3Y8TSd@YE~`kMLvn3AZ$F>7YH##Mn-4%) z{*su!;tfE=P?>NHoKa0*>p3&vg-fst?{3aTYQ@MKqryL%0?*{>Y_*J)Ml1Tg<5M4l ziFzGeU+rj6;THOeKvN~JKnrPT1kPpfRyu+1p0HU!V%!VJl5;ENID&eVrIUKqJo%k&=N8rpYSLR8+ zS54AtUEK;%nqRGOEe-YDdlp! z@>*Qfpm-ZVb9IoY!zTQAPhGT|7+7_Ya{XEggyBpwC{~>sXky!f?Y!P>K0RI2LYGub zJE%M=5Yhg}w=+ME&*gK6kZGwn&$1b<$MmcxW`!iu|gLKx%{Kx1r{(O7Pi{Y zl=`!O7#AnI=1~MvEj65Qfy#-@~u44DbKB6C_I!jQBWr-GMM5q zCny-NX7e~RhF-kn?mes^PT)i5Z3eqkqAExye4Xn>sY|LmxdPlO@@smtL{=W^g6z?(p%5xN5qx7PrNr&s^)8Bgn?pc=IDd=VW z(}kVKEP6Gzu9Sy!JCrt9A0^#|$!*U@xdRad6Zy89p|aHO#l~$vpLX-_3;CXkhkSq5 zr`Bj1BVxQ9@xOam-QL&jj^N$`SD;^AeQtKSC1n|ko7FZdhA3AzX^UI%>-h;>9-RYU zCZ3!NXxQu(FWy^`@a=vvUUrff^x)LsY+2Tr`CV5}S5W3MXx9_kP<*(xHN}ve8ZB=w zsjU+?lXX1Ka5=8q1Nd>#ix2x9hgRX};ZWW(wy3nO#S1e?BWws& zfI~~PzNx`WQ*%PufP36MJ8ZU86>Am?G4VJlg@K8STaPq?g;VxR>`C7c0`XZv^5PKb|-yLomw zl?Lgy02@M88eokc)8LvQ#204n@L;b&*b*i7HvY65H@UZVj41i8cxQ$lSLEV5F>x7N z^B(pyQb{UmWgj~rb)}`eaA1(EULdpQXB0;fY{`K$s3iX|Tsw`OETP7I#`JyoJ+UA~ zXJ;2YAiBK5Ox({2N|I?!RtOj$q5aJ&FZMijF05#Vwa8s{-{GqrJWVTiF zOz>Yb6%`l|QfpUr&CMr{+V?k)0~C|7MbRpBWXb$xU)u%llhL0c_k zu%=jF*!qzn57l1eD^AMr5KFSpK)vJbAPfvZsxl~#Awkl1+g;A7(*?egV94XTI`-Zk z;&$s+Uf1#Xi*;PkE}55n)f%RnAP50b@x-w|AK}UMz?lawC9&uXsc7c-L~Sbjx0kmH zVfkhhUmL6I?`{g5pZEKiKB*Y3Ewsh0&s72DGncM{M~12k&DHP zW>^Q!n+DC?TMn$T4YhYk+4htoS^`Fqs?XefX3_RNU8VuZH)gP(nR>hKN1*6SpH3_Xuuiouv>ceb?N`Lg zXQ_;7^MZ|%`fVCOY4ZsS3_(7rz_b?AAS=(1dEi?r_%>F6Kb6nC%A0~6s!v}mV;l=R z-4hfvmYlgg|2Q=ou;B&K{Q1F+;Ri1e+DeTTCN(_;o+TB8HG1tD{kW-L<~rE3IcJcG zQkg6q^sH~T&&&0ZNtO>3rbvYiYKI4+Ir{*)g}nY!8hAEKBlMF#{T$+(1}^`;z`BJT zL9B+n3p>^{V9#-#r8UOu@iWU2>>t8p$_sscC=$w2#upC|rL4`=?`WdqWPOw+R|XLT zaj}9)e5S>_L*g;qeEDwt3uylpn@#Q<^O}cQOX3jGLCHOhXhVsG=2Xx;oK$}@DEdj-^=E?SjD)YR{ z-L;>40x}EU_*Vnbg%^tVF$7UV1loYL)lWK}M=t=7WNO5~QSIFu09&ah3BMmK#0=aC zyYzs1{W>vJYCCno{t<_HZq~hS5mc9A^PTbsZl-!NbS`u>Kx0Vb15qg`pDSnP4xc<_ zr#1mXR=s&!RMTrj1S7izQPdR^q$vS$bf)$4Bo>9aNSVTM{zKI8XEEyR7~A7ia{u zg7En~4lFouun8-#S42Yd0Ox9Ghm5pV@`J3&^3Q z+s6(x6pA1(eyt*cqa93f#HMTt?c+%?-YJ|eQQ6}O2kosV4&J&L83`xk7gyBNdJKW} zh&aYIOQ=DE@EKg)K2w5|#2+HOMVqY3EG7qKKK~z8K`4f{37Dwi<0|5?t!&Gqf^5(WYi=E%=V@nmR5q@PQf) z7~-=F3+s8PLGz!6A2dF9?b*0dhi{zEghySX}@d zLh%baF^1>fVs8B_IW{>AT}~AUgtHTG2uS3)T#vKQw{&vkX`-~#K9DpZovz>VOCT*} zO{|#Cx}IrpBU(?f7ak$Aa(u2Ow;{6KzIy?oV(eHVr;3K-3dEWgAfL2yHrS(~gz($C z=nm}%ilWurqd-p-uJ$ef=${K+@~$@iW-A&Ti2-&y;07`|^Nw2tNxTZ;2Ll7*f05D@ z=3@PrpP5Cn(4}PQq;MYAfWEBI1lo=kuObHFv$wozK=?LfpZE9#J1E2`3Vx+PRD|V= zz%ob&T!X)BLHt>wZlisLT1t(RY1`Kkjbd6eTeH^6c@6-DmGMrat{4K4T*(ng7N&*@ z6!ZipVM&DAk=LCn*q`t5cVG|jG2dsOJkI^po^D~jNYyr!EF`z>d)dDI z38jIP1_;pzwFMS;b{GNPR_ z+P+%tRP_rvw;aBx#mODM;yoN*(1dw*hURzU-c?&Xr@4b@b#C|Zv)Ib_4~iC14PWJ5 z4~%bt1-Q?u4X#DUuhp*)6n&p|?Yz|3bkFz%h4u1mnVy%DkZk2gfPAok;+5+(k%GWXDtBe;PuZF6W!gu>Mn%mI9Ien(vX;PDqYX33pDJcJT+cDj z9V@)4+GqF7HEZ@x8`PhH{FYs0tN0|?kfxB$=nRY4yWaf`?E-F zY@rOC)t!BzyW!>XsX0S?>hGW<`9pC&ApeB+yf1g{25$KrKK zFWzayg+{Fe!&wOnnO0;jR$}01n~=OLc^V@mFwrtvdgIsVYe zKsD&pN3t31eodT8y5J=wj#jMHE$dM`-lqDY6n*7bK){}&$OFD`)YG4S&;c$C}v(gF5GUJ=gU_o>7!FVZ^C&&q{fDXHaw zB5w#5U?fk7<(pJ=oFnU14pl4XxrXVWT^{e;pFE-6Bz(g>aHJ+JBC$FKdvzPIF&xI- z$r#kep3a`DEWFB4&{~%yiDD3G3a47S>!??#=u_}TL|Jzo*;A#elYT+WAYqTHhQPOU zIL>wDF8r+~s2NE6Dqs&-09EvUx@d7r(~cm7_+T@>q9c$1f=@HJib?z^yu6=->-#%1 z4MjKuOpluu*v7N`xf`Qnh$1rmkQ^&CFLH^mD%^Q|mKi@8>Xdw636&oFE&i7|$*d=4 zP@vt;*;%?`ski&&!Dlnnd}j74Kc(6h!j`HE9M1s#qvy>DgP$|C<U)qFk;$ zWYkM>UtX$Zpfp|tE(KamjENifE#%%>SJ-K57Kw%*C~XU0h7o#4m#bx!J0;)S*>oN` zWjS8Kz(DMFlD}K07bFMpT#pQ@4Kb`JsNmU8$BhuX?aD1OHXl3 z;9~2;{tJB1neN(FFjNs9Uk{hNP!1sef(wV2UPMCxU!L{Op=u82Qx9A=K!n&{2*LrGCzr^OOsL|vYxiP70XY5ZaY z98%+E=1~r|_`Z$iUBqIiB({(jh(oZfU&9nm#u$FZn^VQVTnF!(!n4@2dD&mID%H{1 z-Ak8+)bM+o_}CSp?~B2u7ooU)q9x9|Df=b@abcHSW90A{Z2VvNRR2`C)9}gw4ud1u zTk~x8D;9q?ch}jQdM^uH41?Rz?KGzru|-FemR$#~>_(jH@zSa^_h#ZNX)G>l%#7`Rps!W`20D*;ai;Kyvi=jrOuxbxbi5F74vl?@GVck`Z_t-mt?RYK+ZgY zRuk_&!%i?L+B+CI$CR>v7{p05{`&R4Gk(H`R$YF6+@mjh-;N{oP8b0mgK6#Gtoy5D}Y z;nL(KBog|qVcB(b;z!orPGQxsB4W25k+cw+9Bi|<`Sdec5+-_EGCVyacgZ;-*vtyZo#q!C4+m( zy>3H^UK#lfe*DuK!(_^dNvR>9*nm?+k2E`r{Kp1OjcosomH9>$(Lr)kfD625m{JEZKgO$EuXQ zA&Cu{2JPs#k<*fYLD}XZ@)%UvSe%e4GQ}FGd0ild9d+!0)q*bRx!b05(pZZm;M*8> zDyou6C3ialz?ZzYHv@&}0sC*<=Ahnb3TuyiDL^Dl?N8y_4FZ^|p2+|NgV?Ey^HlS247Ye(WUzFoCRz7~xSZ!;!Q+xJ;To>Qf{1B%CwBm-nX zi&5@Kax!pCbWnb%?@X*TLBMBnlNwq0@*!ac+zYLl8_Y2$j&Q92V8cVJc~2#RShnUt z5b0~$Y*Q0Ue*v+ejj8doJ`u|+ACaH)0^HUi@kCI42plaSf}ZZu>L}awFXg)tR9X7;p{Xm=+wyUqLMFnnUIwEfHO z2M?ZtBKQ%B$_qPoSHvkRl@K}h_{l6~zqu(U?e~?no)F>j*klEaDq9Z)EuP5Qun!<* zTgak#TI+_JDYpNnNRJ1Kb zNB|aZl8PKtqfF=QA4BRbQAkNackuA@x8`?aC4`k)W~>#Dog@MKFlB9n2*JvfQR{yK=k9`msbx?hL&Fla** zqZ_~8DUMae6kr0QnRG7Z-ofx1VF8T00I@bWU@sc^^wbH$k#*|@7`Mi8l-*5luJQ!WJ2Xm%yT{;BfBnY(Yl6b2SPy!4;!2QiPyqW zcDkOKQR@=?;6Uo6FEFd`yUz;N$|h-qE9Z|=+p>9V@z623%gre&?NsTKLr1(PHBSq~ z2>P-#2#$;Mc)TQyj?_qu*b6hlgCpZC&96D`vvV&i?zbiu5sP_Ad|z;sWf%o?zD%Oe zN^95ePfsB-A6p30uEGZO8l1yuw5u0TTVeSk;D~oisC()rc58-Jyi!uB^TEtDWre@;S98ykO@8wWXU(%b1R`H3S>6?^MdP>L4UJh(X7whc@+?`p?!48 zZjrf8Q2cF~>Aks<&ha~EY%p=u=e}~iJqP6wIWs0nHs4z(X$VB2!tb&YD+kj1=Rgcn z(3OXrTI=Vh_aGVo-8uv0bcrUP5ILXL7)K(rbQNrpxJ?Zqr&-|p+9-+zJF)7J%f)wU zW=ktm&H2&H48I0>RvA*@%Pc7y!8y&LUecjCCq2+|->11s7D2$#qaN%-!o%Pa2nAfK zPuqeVSXw&mjGpK%m_p%xT3;IUkan}Y%K2$Cfs^9wJh&uiF>Zg+#z@-+F2b2OHsbyIc?yd=FN*R-K~;Y1M!p=N;N) zV6x3}K^f#I!b@xt?MSDmAr+_91xUm~w|S~nZQ^Zh+}O{^m#P3_w9@j&#a2VNCSqk4GaBnGf7HlKL{$Ce-y9 zT3I@Xl>6uUFujB@w6o<&O;1&XruaJl2Vfb=WU$eW*MVSG9s9^174-hK#+g1$C(k31 z-d9Idn)1gKGbd7SMxAby*p4ZS)rTk_j2ctyKH)DSx(@W_D>*enh%^>rqhHfY3;tp^ z<#gN8W_dA5Y2c=S|V*NT+^4T%?d&xrld-|(QRwU-?&xX?Ctbc;zo$O z)Ak+J%O{H5F{hRZ@{O%Z?NMx3!&YK3&&_K zcBo@4YbwlzjXqLjRmk4rK$Roqa=;IDr}}MFQPG~ne()LR3FzGI__1F}D!hD%Nt1`P z)X4M|5TWb4C;j-r3fx`d=*gh)gp#^s+ zz%{Hsoeo95dslb(`R`UcPYBo1^xd8(#QGjtnR5{;yfx7_doi&zY4JUxV-Uzu&AB=X zO)xczcxD&f1EFF}*G+7&|8ErXIbr#^?%Nh%R4|;GkKmV>+M~wYjEicTAtRiU)WJeB z7s$Ih5zy2~W6?WmQZ?jRyyDJ@WBBlmQzI^r zUd^0w`O#}8yGpLJDr7w*w%8|boa7;@1WEiZVqd#ayy(5M@Bj7GWv3QK`R=3A_4T?t zr!hGKlh#AJ_J7I^7Frl_wigbh_%Ic-ibd=0Yw+xmqA4TN;{ddrq12f44$UWSOW8T$ z<&xX1$zMB%RnQA2sQ2!0@!D<}-;0B|01r~q@N0rxqMWmpLKY@oYzJ_e(IS<%a)%cG z8c{$ymfaW#BxiN`KPHf!+$mA424hrWCG(5F9KMr=1INiDpWw24oT~f5o_a5QLkw|K zG2p2v)6PA^BcpA(gT8^s-ODnz3oFjo_w`sgyv@+2S7%4Ij>jO^jicnIzODhll0rIE zBC&&SE61AwWq6RO_ca?pGBQ1cQD)`fK1Hd4ep^r_x(K44)i&FD`tLpH*ZEsoK)xNp zcwj(R%N|OpH}ftQyCj zH0D8aKdf`Pev55Yi4uEzj8?a|P}J9%JSpdVLnIK5DT{%Ql6*<^@K%*dz-ObpjD(!a zg~A_m-9gZ`x?d@4R3iW&n5ln`W7_+gQx(ECmxGtDYKym=WHAL6fJ^pu(@Q1s>!up% z6rH5xknWQe%@JNIF&r?baf%|3SIIUEfnfWnx%wzX+|J;?$$fT5h>WM3h6BsO3!(Ee z$bq$^izn+LcC?1lkSm>q?K|_~7s^^Y>q7dml43ZI_PZN#3SpmTbdYNb2IRW}MMi4W zYC=L^2z{7fJK1s&34g5%mPvuK+eR?dc78VEVOXYZ8#5GRLe%Ru)fH1NLab>>eUN zv>5^qcg%b(u8%Nsf-wBM#35^>VjX2`{Wbta-T3*zwE)JtL#6Bjj=qCNweUSFSdAoZ4e)srIKVlJR3Pv|<)oIklRD7~TZjWVzEW8r(6 a6l)9`8wrEgBt5(%Md()aVV+Rpw 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 literal 0 HcmV?d00001 diff --git a/crates/lumen-image/tests/corpus/rle.raw b/crates/lumen-image/tests/corpus/rle.raw new file mode 100644 index 0000000..fce5310 --- /dev/null +++ b/crates/lumen-image/tests/corpus/rle.raw @@ -0,0 +1,265 @@ +texture falls integer +a same lumen renders +same lumen floating thread each texture thread thread returns falls returns the renders and on each maps every maps bytes count bytes the of triangles on without made thread lumen same platform decoded bytes +renders and without platform ray triangles same +returns ray the falls thread the maps falls same maps falls thread same point the integer every bytes floating returns returns integer thread a same texture every floating ray integer ray lumen floating on +the bunny +renders thread every same light a platform +texture maps falls on point and while and count and lumen and +on maps bunny floating maps the the a made the the integer each +texture every point +bytes integer same floating count maps of light while light lumen point returns falls thread on lumen falls every the count triangles bytes ray point each a bunny of the each renders ray the bytes thread of texture integer a and falls +light light count thread light +of of count triangles falls decoded +without on count light the thread returns triangles of decoded on made the texture count while falls and +every of the count returns light the +falls the falls platform a on thread platform bytes same integer without +renders texture on texture +bunny each same bytes on same and a the decoded +returns a each every renders falls platform floating made a floating bytes light renders floating while each integer texture integer on platform a bytes count point maps on while lumen of bunny a lumen platform platform texture every while floating +renders +without same the the lumen floating on decoded maps every same texture +on a the without a same same count on decoded while on triangles without on count bytes thread the maps on decoded +the each a integer count every lumen the without each bunny and ray platform and returns +without platform of light and bytes integer every returns on on and integer +bytes thread light +on +returns bunny every +integer every each maps lumen texture lumen triangles the renders decoded of and lumen on point on +integer falls renders a decoded +made without count each while the bunny of a each each integer platform each lumen +of each floating without texture integer returns every each without +and triangles thread on each each point while +returns the on same light maps maps every bunny same ray on +maps platform integer platform without integer ray point +every bunny texture the made +light same on while same every on floating integer every a renders lumen made without bytes ray bytes light and floating decoded lumen thread texture renders each while bunny renders point +while each platform +triangles bytes thread returns on platform falls decoded on point platform count returns ray the triangles returns light while every every maps a and and the and a +on platform +made light maps same every decoded the integer decoded and lumen platform on floating +triangles made returns the texture made each ray lumen light on platform point bunny platform triangles of a on on on +every integer of each while the on texture decoded decoded returns ray bytes each thread count +without same lumen on +and light +the the count platform same the and every a returns of count renders floating ray thread +triangles and on each and renders every integer and the made returns integer every decoded maps count +lumen bunny maps the a on decoded made on count count and falls lumen thread floating floating without returns each floating platform and texture count platform the triangles the on the lumen on on every maps lumen integer the on floating the integer bunny +thread +the the light integer of while integer light point of bytes same ray bytes a light decoded the and bunny texture maps bunny made bunny each and the lumen decoded light thread point on on the falls ray +point a +light +maps bunny made same falls platform renders platform texture every on the and count on lumen same floating without of decoded decoded returns +on decoded on on platform ray triangles and without of +floating floating and on returns every integer integer every count while maps every ray without point texture returns +while triangles +decoded made platform of the returns of every made floating on platform the a and decoded platform same decoded without +ray point bunny maps texture without same integer floating of bytes without decoded +maps and on bytes platform the bytes on +platform returns made made bunny triangles point bunny platform lumen +the floating a triangles on maps +falls ray count falls renders and light and +returns light the texture triangles renders while +integer point +and of each the made a bunny and the a +each each returns on +texture a on decoded light point platform bytes bytes point floating without without on same renders floating triangles renders +same returns returns the count the light a bytes the the without platform +the while point bytes without returns integer count point texture thread and platform made +a made the integer without the renders triangles every falls made falls made maps made light the +decoded triangles the falls on light platform bytes ray made texture on while thread and on made lumen on the on made returns +the a every decoded a while triangles triangles falls on every of renders made returns ray each the light light lumen count and light and renders without triangles the made each thread lumen while lumen +integer and the the falls the platform the triangles every lumen without and +texture maps thread bytes count renders made renders +integer renders triangles same falls on each +maps bunny and the point returns floating on bytes texture point the while triangles platform same falls triangles a while point light maps every count the returns floating light ray decoded texture a floating the of while on ray +made on decoded maps on each light returns +floating texture renders ray maps texture while made integer every and texture each made texture falls bunny made triangles while returns floating thread same same maps thread maps point the +decoded platform texture light on floating platform the point falls every of bunny ray renders every a +bunny texture maps made falls triangles the lumen made decoded while +bytes +made made each platform on same a decoded bunny same ray of a triangles while without and triangles each triangles of bunny lumen bunny a returns a count +and texture lumen same without +point made integer bunny same the maps thread renders renders of ray renders texture falls of a on while integer and the renders triangles point lumen on on the the renders decoded a and made bytes platform a ray +falls +of integer renders while +light lumen on maps platform renders returns floating the bytes thread the ray on lumen maps same +bunny light count thread light each +a while thread the count the lumen texture integer bunny each lumen platform without on point every integer on maps every falls triangles the a point returns integer the maps point ray made made lumen integer thread light renders on decoded of triangles the maps thread every decoded light +falls triangles of integer maps lumen texture ray thread count renders count of triangles made floating platform each of bunny point made renders same decoded texture falls count while of +each ray ray while renders while each thread thread texture on the while the ray +falls platform maps integer ray while bytes without on the decoded on a bytes the on and returns platform point made floating ray light +floating and each count every light each floating and maps texture made integer triangles each the on of floating thread floating point the falls the made without of without thread of the of decoded lumen and on the renders without falls while count each made bunny of each count a of a bytes triangles same +returns on the thread each integer on floating returns without made made made on platform thread the every thread renders +texture lumen each returns of light falls every lumen thread decoded without integer point decoded integer maps decoded the floating count count the bunny without count bunny +and triangles returns each light decoded and while on returns every every a lumen a the falls floating the each renders without bytes each the integer renders every returns of count of point lumen returns returns integer while every bytes platform on and bytes +ray returns decoded texture point decoded of and on a and and thread bunny light decoded without while on +point and of triangles platform texture made ray texture decoded falls falls light decoded +a decoded renders maps every +every same on integer on each the thread on and point while falls lumen the on triangles falls texture falls falls and returns a integer a light every light bytes every texture of returns and a without count maps same each on decoded each the same bunny +decoded while on the on light on count floating the count integer same point maps +the bunny +light +bunny and each decoded the texture +maps a returns made a point platform floating on maps thread floating lumen a +light +of floating triangles ray the the on on thread +bytes ray texture bytes triangles same on triangles decoded texture every while thread light while bytes triangles thread +each +light texture on renders returns thread +count falls while maps same ray texture texture platform and texture a on falls count while made same same decoded the maps lumen on falls the on while of without each and +ray floating decoded falls +floating integer decoded on decoded falls triangles the the thread platform platform on renders on falls every count on made platform triangles light triangles a returns while on falls +without a point triangles bunny same the floating returns the every platform platform light thread made falls every every point bytes decoded on ray decoded a triangles while maps light of renders of same texture +platform on falls floating triangles on lumen renders light on bytes light the maps light ray decoded floating bytes lumen floating lumen bytes lumen thread of ray every thread +renders each a +returns floating bunny the integer and returns texture point on light falls platform maps returns light +thread floating bytes light without ray without bunny on every the triangles every floating lumen decoded without same bytes ray floating +returns without falls the point renders bunny and each +light the thread decoded thread point lumen while on maps while +made thread count ray renders every on on light on the +integer +without floating ray while point maps and the returns texture +platform and every maps point while while each bunny renders +lumen each texture every triangles texture same count texture floating bytes +floating light +made floating made without while same and a +decoded +made made +decoded each made point thread made made made decoded floating on each count returns floating +the floating count thread returns point renders each the light count light every the floating thread without renders on without on without of returns +and same the of +the bytes lumen floating lumen thread returns on decoded integer every the made while +while a platform triangles made integer a floating thread texture renders lumen integer the on +without +on floating thread +each thread on on while the count +bunny lumen of integer +made bunny point floating light +thread floating point without maps thread each the a each without decoded thread falls floating +a same triangles decoded thread on platform thread the on light thread platform a a ray +point a same falls returns integer +lumen texture same same thread lumen +of on floating without decoded +on without falls maps platform point count floating texture on renders falls texture ray of renders on +decoded the light bytes thread maps on made each texture bunny platform decoded without maps while returns +renders bytes the on ray while every on and each while platform of and same a maps light of lumen falls +and bunny point bytes maps every same +decoded and each light bunny +on same on platform +on ray of count +the renders maps same of floating of and light same texture light each each bunny +bunny same a the without +maps same triangles the integer point point texture and lumen +on lumen light thread bunny +bytes renders of texture bunny the without +on decoded ray while falls thread decoded point on on integer falls ray made floating ray point point on each made of bytes maps of +bunny floating bunny each +of without on the count decoded count floating lumen integer of texture on +platform a lumen made point light falls bytes lumen decoded point on without the each while light and +made the and of maps maps bunny decoded decoded a point returns decoded on platform floating each of count the renders a ray the thread count the without bunny floating a integer and every while +platform thread bunny bytes point +made point the each +made bytes same without made of +bunny lumen on returns bytes floating lumen falls of +and maps renders maps integer each on floating bytes while bunny a platform the made +lumen same lumen point maps +made decoded of point triangles +light returns +while floating while renders of same of made texture on +without every decoded the each the renders same each texture and +each while while while integer returns every and same every same and ray +maps texture maps made on made and decoded bytes of each integer bunny without floating lumen while point of every without each integer bunny of floating each decoded the and returns renders falls +ray on decoded while the on a +same point thread and of renders maps the triangles light each floating each bunny decoded count made renders the light a each point +light lumen +of a thread ray count made returns integer of the decoded +and +a falls bytes ray platform point each the on +light on decoded thread floating floating light renders +bytes decoded point same renders on point on renders +returns every renders decoded platform +thread thread ray light lumen decoded platform triangles each of each point +texture the same returns renders maps floating bytes made while platform ray ray on decoded made +of same every a the ray point on every of made returns on while +without triangles and +ray the returns without lumen light floating and triangles returns point floating ray +thread count renders renders on renders +and thread thread a platform the and renders while made renders texture lumen falls on point falls texture light bunny returns falls the thread lumen falls without triangles the renders bunny each maps triangles without on bunny on light a +without light same without +texture floating every platform each lumen the each integer while ray triangles made bunny returns made a maps integer same on ray falls bytes bunny made texture each on maps +each ray bytes maps +lumen made returns falls on returns +bunny the a bunny texture decoded and texture triangles +decoded decoded and the falls the on a of thread +bunny integer +triangles falls platform +made +count without ray +and light of the bunny lumen renders +every light ray floating bytes and texture without the on falls and renders bytes the count point every while made renders bytes thread +on returns ray the bytes triangles triangles +integer decoded decoded same every +platform triangles renders +platform and of the +returns each while and lumen decoded light and every the +platform +a point decoded every light falls light a count every count integer decoded each made while light on same floating renders each +ray +maps triangles decoded each ray floating count count texture light +bytes same texture count bunny lumen bytes made every same point light thread renders maps returns decoded while on point floating maps +the triangles maps +renders same every while on and same every floating on lumen thread light on lumen triangles a triangles on while platform of bunny without point decoded platform count triangles thread returns bunny on each thread same without renders +every count the the on same point decoded a texture +on a ray light of floating every triangles while a thread on bytes a renders integer bunny of the renders made every +platform bytes lumen the each decoded renders the of made same renders bytes falls +made decoded without the each light floating and maps lumen every platform same decoded bytes every each count made while decoded without without same maps made returns +count and returns platform while thread ray triangles +of bytes thread while falls without platform the bunny +count without bunny +falls every and point +maps lumen a same a +of each platform triangles renders +decoded every each on while a and decoded the light and and returns +texture thread the light point the the integer returns while floating made on bunny bunny +renders every bunny the without the every lumen ray decoded the a on a every thread a integer same +falls of of floating maps texture made bunny integer decoded +falls and ray count +same renders triangles count the each point on bunny on the of decoded platform while on a thread the the light platform made +platform thread platform and on maps a of ray a +on thread +made count each decoded lumen triangles platform ray decoded bytes count maps +thread texture the renders same floating decoded integer maps light decoded point renders lumen +on maps +count lumen lumen on on point count on point point maps returns light returns each thread every the every platform bunny same every +falls bunny made integer texture thread maps +bunny each bytes floating count on thread bytes platform a of falls point on texture every maps integer integer maps +renders ray every texture floating thread returns lumen same returns renders bunny the +decoded every same bytes on a maps light platform floating integer and a point triangles while falls bytes while returns lumen ray thread renders +while bytes platform of +bytes falls thread on the ray lumen point a texture decoded maps integer every made bunny the on on ray +renders ray bytes ray +platform decoded light falls count platform renders and point same lumen and every ray on of +each every integer each triangles returns maps of on bytes point of each +on of renders of point bunny the a of integer thread ray every +a on bunny while while +light ray each returns made texture floating triangles renders ray renders platform light ray without maps lumen integer the maps triangles integer the count triangles on renders triangles bunny on same the the lumen thread light of same maps every bunny every lumen bunny integer texture +and bytes on triangles floating thread same bytes a ray returns made thread bunny lumen decoded a and triangles count decoded triangles made renders bytes bytes ray thread light triangles the each same triangles on maps the light without the lumen lumen bunny texture thread every while on decoded renders while the thread while of floating the on +of the lumen bytes +the +of without triangles returns +point the returns and on on bunny +the light each decoded bunny triangles +the floating every light +and +count while bytes bytes on bytes point returns bunny floating on the count same renders point +count made floating lumen ray every maps light +without the lumen each ray ray the returns ray falls on integer the decoded ray light ray bunny a decoded a maps integer each the while renders ray decoded on of on every on texture point platform point and light same the made a integer point a falls without on without floating returns made light integer each count point +texture floating light point on count bytes the texture returns +maps platform while returns while a and platform light +made bytes platform bytes renders a the platform ray point while point same bunny without made count every while light integer each floating each on the floating texture light renders +triangles lumen renders every count renders returns thread bunny triangles each thread ray falls without light decoded light of +thread renders on texture +same and ray renders bunny bunny on of and platform the bunny light every on count while bunny +every integer on light count the while decoded +every texture byt \ No newline at end of file diff --git a/crates/lumen-image/tests/corpus/rle.zlib b/crates/lumen-image/tests/corpus/rle.zlib new file mode 100644 index 0000000000000000000000000000000000000000..659a9ffdbac03346f10fcb45096852e92819498e GIT binary patch literal 10487 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 A82|tP literal 0 HcmV?d00001 diff --git a/crates/lumen-image/tests/corpus/run_258.raw b/crates/lumen-image/tests/corpus/run_258.raw new file mode 100644 index 0000000..5770a2a --- /dev/null +++ b/crates/lumen-image/tests/corpus/run_258.raw @@ -0,0 +1 @@ +aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \ No newline at end of file diff --git a/crates/lumen-image/tests/corpus/run_258.zlib b/crates/lumen-image/tests/corpus/run_258.zlib new file mode 100644 index 0000000000000000000000000000000000000000..6d2cd032f58e525edaeb56e7761da54ef3c8d756 GIT binary patch literal 43 kcmb=p_4c44BLf4&p#^JR#~+fCa{zJBz=wpSpR=z303YoO-~a#s literal 0 HcmV?d00001 diff --git a/crates/lumen-image/tests/corpus/short_text.raw b/crates/lumen-image/tests/corpus/short_text.raw new file mode 100644 index 0000000..bbb1305 --- /dev/null +++ b/crates/lumen-image/tests/corpus/short_text.raw @@ -0,0 +1,2 @@ +of a platform each +the same of count maps ray a a bytes the falls point triangles maps same floating count returns textu \ No newline at end of file diff --git a/crates/lumen-image/tests/corpus/short_text.zlib b/crates/lumen-image/tests/corpus/short_text.zlib new file mode 100644 index 0000000..5ef42dc --- /dev/null +++ b/crates/lumen-image/tests/corpus/short_text.zlib @@ -0,0 +1,3 @@ +xœ-ÌA„0 CÑ=§ðÕ<(�JiS¥©4Üž‚Xû}»‚èÆT� +á~ny +«À»Ï–¨ìÁkQâw¥ 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 literal 0 HcmV?d00001 diff --git a/crates/lumen-image/tests/corpus/stored_multi.raw b/crates/lumen-image/tests/corpus/stored_multi.raw new file mode 100644 index 0000000..683d3fb --- /dev/null +++ b/crates/lumen-image/tests/corpus/stored_multi.raw @@ -0,0 +1,920 @@ +point decoded +falls bunny thread integer platform +thread returns texture bytes on bytes light every while returns bytes bunny the bunny bytes bytes bunny the lumen floating texture every point point count and same same maps thread without every floating the of maps bunny platform floating triangles count on and returns made every platform texture lumen +maps lumen each integer thread on a of point returns renders +every of falls falls +lumen every maps lumen count +each +of light +point lumen triangles the on lumen +integer decoded a of thread on +texture a renders bytes decoded integer returns count a integer +bunny the bytes count of the +falls platform platform integer integer the ray on falls on +renders made +thread triangles ray floating made returns the light floating bunny thread every +point platform count every decoded on made thread texture returns the each the every lumen +renders on ray a ray integer falls while point on +thread light same point texture same same lumen floating thread of platform returns count each each every on returns texture without texture a ray thread while bytes a point returns bytes bytes without point ray every each the the ray bunny light ray lumen count every while floating renders lumen platform maps without the bytes without bunny the made platform made on on made floating made platform platform same each count point every +same thread renders floating while without the platform bunny point ray and decoded light ray thread the the every +decoded the thread and count floating integer triangles point and bytes falls made bytes a and light the bytes point thread ray made falls every the the floating and integer on same thread bunny texture integer and texture while lumen bytes lumen lumen count floating count platform falls ray integer every falls bunny ray the bunny floating lumen returns +while maps on and every floating a while returns falls of lumen while and light bunny returns integer bytes on renders point light same decoded maps falls on same maps bunny bytes without each floating bytes falls the the thread bunny +returns falls maps light same same the bytes light floating +maps thread of same +on on texture +made while decoded floating bytes thread on a made made returns a texture on same bytes integer count on the renders made light and +integer same lumen maps a light on count bunny falls without and made while integer bytes returns thread the decoded count point made integer ray lumen made a texture decoded every platform made the same while bunny and of and without floating made maps the the while +on lumen maps returns count +each made platform lumen +each integer same texture a decoded floating platform decoded platform bytes and light of platform maps the same triangles of +bytes falls on light returns bytes every bytes same count count the +light a of platform triangles on on thread count triangles integer point renders floating every texture texture and same bytes a +while and +thread on decoded count platform returns texture platform +each lumen thread the light each without falls on floating +of on +ray +decoded and bytes bytes returns a a every +point bytes point point decoded bunny a a +count a each the made integer every point +ray the floating floating each integer count bytes the of on triangles renders on without and ray platform bytes point maps platform count every on a without returns count texture integer each triangles texture integer thread +each +the the every while bunny floating falls same floating without the triangles count the same platform without floating of while triangles ray lumen renders bytes every decoded texture of and of the decoded made bunny +renders every thread count bunny platform +lumen made made +falls and bunny platform the on each ray point a without floating falls decoded falls without texture floating +without falls a triangles made count texture +of every texture on a of +on every bytes decoded point a point lumen on renders +and falls renders +lumen returns same triangles +and lumen maps a decoded point each floating falls of renders texture falls thread returns light while same every bytes thread a ray renders of platform without bytes lumen made platform falls while of the the of +on each texture on returns a a maps ray on renders the the maps +returns +texture maps a decoded integer point maps each same ray ray texture texture bytes count falls integer without lumen maps on and point maps of returns bytes bytes maps falls the bytes every of on +on +ray triangles bunny texture decoded each of integer platform the point floating light made point point light bunny made lumen thread integer +while +and ray same count falls bunny light maps +on the +made and on point renders each maps +made +bytes renders bytes +the on +each +every on without thread the without platform on each of light thread maps without bunny each of count and a point on count made the maps triangles triangles point thread +triangles same a every floating platform and point and floating a +falls same +ray every a made while a integer while lumen light +made texture bytes made falls +on returns each bytes renders the floating made falls integer on on texture platform lumen bunny the thread and the and the of while of integer decoded point returns integer on platform while each made the ray while light returns point count of returns renders light texture ray the lumen returns renders maps bunny of renders +on ray each thread count light light floating on bunny every count on bunny triangles and integer +of made without same renders light decoded and made on bytes bunny triangles a decoded bunny +lumen platform integer ray platform and each each while light decoded platform +every +renders ray count +and while bytes integer integer lumen integer texture on +decoded +platform floating point platform each renders the the platform made maps without triangles while +while triangles thread integer bytes renders triangles bytes floating returns falls floating on same thread lumen the integer maps on on returns made falls +maps count +maps light renders count thread bytes ray the decoded made +bunny integer renders while each light returns ray integer ray thread maps falls point on the count platform returns and same made decoded maps integer floating made point light maps point triangles of renders falls integer while a of bytes same count while a the texture bunny of bytes the integer returns thread bunny count maps decoded made returns made thread thread platform and the count floating the made falls while bunny renders returns each the each floating the lumen bunny on while triangles +integer point made made count same made +decoded every made count texture bunny and on falls +on on maps renders returns thread the thread a while each a count platform count same renders falls the light thread of ray thread platform thread count each returns a bytes made made on +returns +on bunny a the platform renders renders on made on texture light without on light triangles on lumen count light ray same light each every +texture renders of platform on texture +platform on the texture platform the a triangles floating triangles on +maps lumen light the floating and every texture integer maps +each of +without each light maps same texture without light of integer renders each the triangles triangles decoded falls same thread every renders the each count bunny floating thread maps ray lumen bytes every point while triangles falls +renders maps same maps floating decoded bytes ray and texture +a a same of on lumen renders of bytes falls triangles maps on the without point a of platform +light bytes the count the thread of light the bytes on the +without point bunny renders count while count on light while count without triangles falls thread each on renders integer the thread each point integer decoded on lumen without returns and light each made point on decoded point while +bytes same lumen and the maps lumen on on each each decoded while ray triangles +on maps triangles lumen +while +maps count point count returns renders light same decoded texture returns on floating without +triangles integer and returns on made +count returns thread thread +floating every same ray lumen the floating a ray returns lumen texture returns +maps point every a bytes count texture every light maps thread the renders on while +each integer made floating floating lumen texture on each floating decoded every triangles point thread count made each bunny and decoded ray every without the lumen light the platform the +lumen floating +on falls count maps lumen of light every returns returns bunny ray integer ray ray texture on same light of and floating light floating +point of triangles without +same point same and bunny made maps while maps falls triangles integer bytes without renders point a ray floating count renders of bunny maps ray bytes while triangles and renders +triangles integer thread integer without light platform decoded made point texture integer bytes while a lumen falls a floating returns each on +texture while falls the returns on returns decoded same renders floating texture renders point maps without while triangles every +triangles returns maps bunny bytes renders count the on on texture light while while returns same count made returns made each decoded renders decoded the renders platform renders while decoded the thread renders texture maps without +made +texture every without same the while without bunny of count a platform a the the and every every without +thread integer texture maps maps while texture thread lumen bunny of integer of made lumen +floating floating ray bunny the without returns bunny triangles count falls of integer decoded each returns without bunny point the +triangles same a triangles made floating of maps integer returns count thread a +point integer +ray every of the platform on while lumen without ray floating floating same bytes the point while on bunny renders maps triangles ray each texture on maps decoded lumen while integer and triangles +thread bunny platform and the thread decoded bytes falls decoded while decoded same returns ray +thread triangles renders triangles on decoded a every on count thread every returns point triangles texture falls thread triangles ray same every every bytes every a platform same +triangles triangles floating and bunny falls the and triangles +integer texture made on decoded maps a each same of light every thread the +on bunny texture without of falls same and without same of of of platform renders made +bytes platform triangles on lumen on the the platform +of and made without point +lumen falls decoded count bunny on platform a lumen +each each count made while texture falls floating lumen floating on ray point falls decoded same every on and platform and texture maps decoded falls the lumen bytes a on each +while without falls made the lumen count maps texture each maps platform while same the on and on floating a falls the a maps light bytes on texture bytes floating the thread falls light returns +on each +every thread point and +light texture the and integer +and bunny on +the while the bytes a the point returns +same falls returns integer on on lumen lumen made falls point ray the bytes each texture the on decoded each bunny same renders and same count texture the floating decoded decoded light the triangles lumen on renders texture falls a on on decoded light point the lumen count the on ray while floating integer integer bunny decoded decoded without and falls point every integer +renders maps and integer point texture a of point +each texture platform while bytes triangles same the texture every falls on bunny and bytes light texture maps texture +renders triangles the on point maps same thread bunny each the returns triangles +count same maps maps each count integer while bytes renders the each the +platform of same every lumen while a bytes light on count count the ray lumen count bytes +thread the renders and returns platform the bytes every every renders maps maps the count falls each texture the +platform same +same platform thread bunny decoded texture and count integer maps point the lumen point light on same maps renders +while falls made on lumen light made maps the thread maps and each returns ray the on and lumen count lumen platform platform lumen ray point +the made floating and returns point falls +each every on made and same +bunny maps without integer made platform of returns thread platform the lumen integer ray +the +maps same while without bytes without light +same on and every triangles light the +and the and every count triangles +every on +bytes on same renders count each thread bunny lumen and bunny the without triangles falls on falls +lumen each a without bytes falls decoded triangles point point count and and and renders decoded bunny floating the texture a ray renders maps while +bunny triangles lumen made triangles count +a without floating returns a +every each made thread platform same and count ray point each count on while count triangles the falls +falls every +floating maps +same renders decoded count falls the bunny bunny while falls ray triangles every on every on light light each thread on maps +thread lumen thread floating thread decoded triangles thread floating decoded ray decoded the without thread count maps maps lumen texture point triangles on returns the falls same maps made triangles while the point while ray triangles thread the triangles falls floating texture count maps while lumen integer made of renders on count maps the renders count triangles count ray decoded every returns lumen ray +ray a platform renders each without same without ray point texture same +and bunny while texture floating point integer texture ray triangles texture thread of platform ray maps lumen on lumen count every bytes bytes bytes on integer falls without ray thread the falls of made texture returns renders floating thread without and texture decoded count a same point of maps on the point the +integer while every on ray made floating on point on maps a renders count count +integer bytes same renders on every thread floating every floating and every triangles integer on made lumen lumen made platform thread on the while decoded a a made texture on made count returns triangles while returns +and maps integer triangles +triangles +same and integer and ray lumen platform decoded renders same point integer of while floating renders same while on count renders of thread made same ray texture on integer returns ray +and integer made decoded light thread and of returns thread a point of lumen light count same +triangles without a a on every point platform on +same light and of light platform ray made the returns texture maps of renders triangles a light and on thread returns lumen +triangles bunny every triangles thread while every floating ray bytes triangles decoded triangles and integer on on lumen integer light count every a decoded without without bytes point without +light the made ray floating and texture integer every returns the made a the lumen integer the a while each on on lumen thread +on platform platform on on a the returns texture while of bunny of of triangles the light +made floating of thread platform returns each bunny every falls floating triangles texture returns of without on bytes thread bunny thread triangles made floating same triangles count each of floating of integer without decoded count every point the every ray triangles the texture lumen and lumen lumen platform point integer count floating same +the the and +while a and made while integer texture +every bytes falls of bytes texture same every decoded falls a renders the each without platform the same maps +texture maps integer every falls a integer of count on bunny light +and lumen the texture every +without same light light +returns platform a lumen every +platform and triangles floating ray platform triangles count on texture point +renders same maps same floating +count triangles same and the the on on made thread +without bytes returns the lumen on on +lumen light on lumen thread texture floating without platform triangles falls texture thread thread ray a triangles integer returns renders every bunny count made renders on the light ray every same lumen platform texture on triangles the point the triangles every each maps and on a decoded integer +same the decoded same same returns renders on renders every of renders on texture platform bytes maps renders on decoded +and of each while ray platform +light point on renders bytes ray returns light the floating +point triangles every the of triangles +every +point +lumen a bytes +bytes +without bytes bunny same same +on on decoded floating on light thread triangles +platform without a +floating texture without made count platform bunny point floating point ray each decoded the light count integer a on decoded a same same ray without the bunny and thread floating renders triangles lumen the texture light renders the triangles +while +falls made floating thread without a +of triangles same +a returns and texture ray point falls texture while +decoded texture on same texture light falls renders integer the the point on every floating integer without light a renders on on maps of the each platform without ray every on decoded point ray each a ray floating a each texture renders light made same while +decoded triangles of +a texture falls without every every +falls ray point ray +and on on thread maps on without +and and texture lumen decoded bytes bunny falls the ray every texture +each light lumen and bytes thread lumen light +thread while every triangles on on on +on of texture bunny on and every the a every lumen count ray light every point renders bytes platform made thread bytes point on falls returns each decoded light the floating triangles made lumen +ray +point every ray renders every while +each each light every light maps while +point platform ray of bytes triangles +made on bytes every while count the a +and the count the every and +the returns same +of lumen +on each integer same maps bunny platform floating returns +point platform texture texture decoded +and +light the ray floating on the renders made triangles while bytes made while count same on floating +bytes on light same point +the triangles the decoded the point light renders and light bunny integer falls lumen point point each on falls renders ray ray each floating platform and and integer integer of made integer every bytes same triangles while decoded lumen made ray lumen and bunny floating lumen on floating every returns +every decoded bytes the thread bunny on point lumen on same count made triangles made bunny returns without texture returns every texture and +the of maps texture triangles +each bytes the every triangles while and the +texture same platform made bytes triangles without ray on on on ray point each maps falls and bunny floating integer the on while made lumen floating count triangles +on floating falls without +point count same without the without ray +the light returns bytes point count returns while the bytes and made ray bunny the +each +bunny floating without texture decoded a of renders of each triangles ray returns the maps returns texture +falls falls without maps integer renders bytes on same triangles point bytes bunny a decoded texture point of texture lumen the same on of count thread the bunny the integer ray count maps +each point decoded the lumen ray +bunny thread +bytes same light triangles and light decoded and without bytes falls a platform +floating +on texture light light decoded maps thread decoded point the returns maps renders lumen +made same every +falls and +made +on the floating bunny returns bytes maps same thread same lumen triangles renders made triangles maps every renders on the without of point returns made each and thread floating on integer the lumen maps integer made made bytes +integer the made floating made thread floating while bunny integer triangles of +decoded floating on light integer every +without maps of bunny the and count light every maps thread on point the thread point while floating while each same every +a light a thread point +count texture falls bunny maps triangles light floating decoded falls texture while decoded integer each same falls each floating +made on on made while platform decoded thread same without lumen on point floating same a +each the thread texture maps made integer falls same +on +decoded thread while texture every +lumen every of light decoded platform thread falls of +integer on bunny texture falls floating floating bytes every on integer a falls bunny and the thread lumen on lumen made the decoded a on platform bunny of floating the lumen decoded on bytes thread falls count renders thread returns texture while decoded on light the renders and bytes the without thread platform ray floating triangles falls renders floating every the a +point texture bunny +renders bunny falls texture triangles returns while each texture of on on same maps on the without count thread ray ray returns each +returns texture the point +bytes the bytes point integer of point count triangles on bunny point floating triangles a bunny a point every without texture while of the returns on light ray bunny and thread bytes floating platform each +bunny decoded point same same decoded +the and texture while bytes +same bytes on returns count on every lumen on triangles count without decoded floating each floating and same bytes light ray decoded without falls on and floating the on point same same the count +texture point made returns on the while thread bunny of triangles while maps the platform platform floating the falls same on decoded made triangles count on light of a of returns decoded and floating platform the same maps returns maps triangles maps the +of falls without renders +and integer of decoded lumen of renders bytes on each thread made on bytes a texture each while on +while and triangles lumen thread and point on decoded +each every maps ray decoded triangles bytes a platform count floating bunny a falls lumen ray without thread +bunny without light bunny floating the floating +each made on maps floating bunny falls falls floating ray floating light a bunny +texture decoded every falls while floating falls while every floating and texture falls each a ray +a a without every on each +floating platform bytes on +integer a point made +the on made every on texture point returns point and same the light renders while renders point falls the +ray light on renders bytes +platform thread floating the texture maps on thread falls each floating the the the +point while on same falls bunny every +while integer the every integer each platform the platform bytes of made bytes of and thread texture floating of lumen maps same a count each bytes texture bytes lumen maps +while and returns integer returns falls the on the renders bunny every triangles +made returns triangles point bytes renders decoded same +every texture each decoded +returns +the lumen +bunny falls platform without floating texture integer without texture the lumen lumen falls count every ray maps falls without every on a point on +on renders same point made returns on renders platform platform light each on +light and each bytes same decoded made bytes returns falls falls +on on bunny same while platform light the count made each on ray thread of triangles of triangles the point maps on the texture count decoded and and lumen decoded thread floating returns same and each integer decoded +ray +each point thread texture light texture light a of thread platform each floating +made platform triangles ray same light on made triangles triangles platform floating a bunny light same on platform integer +bytes a of and every returns returns on made renders integer made light floating and +floating lumen same bunny lumen made +every each floating platform made the on decoded ray light while same ray and +platform of made bytes triangles +triangles platform triangles the renders +platform light while platform light +every the returns without the maps thread every a same maps platform floating maps light floating returns falls the floating texture made a made a maps lumen +point of thread a bytes maps made returns without without returns returns on a lumen a lumen on the and while point same while on floating the made while renders maps maps the without maps point +renders of same point the and thread +a light lumen integer a while maps the every bunny every lumen the made maps bunny made returns texture without made triangles texture +maps of a point platform triangles and count floating and ray bytes each of triangles +light light and the lumen thread falls without made lumen made on a maps while ray lumen count point made +a point count +triangles +lumen platform bunny each +triangles +platform point +decoded the count every bunny +and the floating every every falls each bunny each triangles light maps returns floating ray lumen platform falls of a renders the +while thread on made every made +of bytes every floating +bytes maps each on +made light lumen made lumen bunny light on maps on without +of +decoded made while floating decoded a thread count lumen +every a returns ray floating floating triangles point lumen bytes and on texture triangles texture integer the while every bunny +floating +renders decoded maps maps returns maps triangles +integer ray on bunny texture +light while maps on falls falls on on thread without while each floating while texture +platform triangles while ray on count on maps while a same same the thread count on while triangles every while the on without on on returns of bytes platform the thread of a point a returns platform without returns falls on point a triangles returns a the integer ray texture +each of lumen +platform texture every and returns count +platform lumen +triangles +made ray every platform of on the each +every while texture point on +returns returns decoded returns every every on bytes bunny count and without texture of made lumen integer +bytes same while the thread +integer on renders floating same on while maps returns floating maps the +on the while and renders +the +ray count floating made integer same without +each +same without on falls and each on bytes +while bytes made falls lumen same texture without light while bunny platform light of thread a texture +renders decoded +and while renders of ray integer point while on point the bytes made made the of texture maps integer texture made maps returns lumen without +triangles on and while ray ray +triangles made without the the +a maps bunny platform without without the bunny and the without ray triangles returns thread without returns on renders floating falls made ray without falls falls thread +point +platform bytes on same returns bytes decoded +the integer the of decoded every triangles platform each bunny the integer bunny on bunny ray falls decoded of on on bunny each the lumen texture renders while bytes lumen +made integer light without returns made on triangles light integer falls triangles without while decoded ray integer bunny texture maps on each platform and renders falls a without thread point integer a renders decoded lumen on on while falls made on count each +made on same light +thread light bunny on the texture a maps made bunny platform count each triangles while bunny every without +every integer bunny triangles thread +ray point +every light on same the the platform every triangles point thread returns bytes same maps on while platform every lumen +maps of same of a renders bytes floating bunny point integer point point on count texture +triangles maps returns the +falls falls made ray platform +and ray returns decoded made same renders same bunny platform maps a +ray ray the and returns bunny falls returns ray renders every ray every the renders and integer texture +thread +count every the lumen returns thread platform and bunny floating every integer falls made decoded same platform bytes decoded on floating bytes bunny decoded the platform on without of and returns +triangles the bytes triangles count floating +each the integer renders every and integer ray point the renders integer made ray texture on falls +thread bytes +point triangles texture on platform each thread on platform floating made integer a falls maps +and every maps without the platform bytes while a falls made point maps same and bunny bunny point triangles count same returns +triangles point made made +a and triangles bunny bunny on integer +a triangles while falls on floating ray light triangles renders the +texture the triangles integer maps each returns texture of renders while each of without lumen integer +same same +a made every returns ray renders decoded of point decoded texture count floating light of +lumen platform thread thread lumen floating on without bunny a thread lumen floating same light and lumen light and without light platform floating every without decoded bytes falls the decoded integer integer +on +a without made point while renders integer bytes falls +integer maps texture each and thread same of bytes on without made integer while ray +light triangles returns maps maps platform every light renders +maps ray integer light integer floating bytes and light on renders integer while the +same on floating count renders bunny maps same integer integer while integer made the on bunny same ray +bunny ray integer lumen of bytes +count while ray renders texture on same a ray without while thread lumen the platform +thread same the renders the on the a lumen every falls same renders same every on integer same the light the falls floating platform made +and +integer falls thread falls count of the +the a without platform decoded renders on of triangles ray every +returns integer decoded made decoded the falls without texture texture same integer texture maps each on ray the bytes falls light on the texture without the light every +while decoded on bytes integer decoded of the same ray the floating light point the texture bytes +lumen +triangles integer light falls same the point lumen floating +without +triangles and each bunny lumen and renders on the point platform bytes platform texture falls on and on thread of every decoded same made returns +thread made floating floating of bunny a +returns ray returns texture and triangles integer renders count returns light +without count made floating returns integer texture the texture returns thread falls ray while made point +renders and floating texture point while made bunny light floating lumen every made platform each of +the the count made of renders the count while each floating light on of on of bunny lumen on made and made same thread +texture +every light count each every +integer maps of texture lumen on +lumen decoded of a lumen floating +each triangles maps lumen platform texture of renders while +without +count the ray +without texture on count floating and the falls falls renders the and lumen +same bytes platform texture on same bytes maps maps without light the lumen same +floating +count platform falls triangles triangles light light +while same texture the without count light on while ray a ray ray bytes floating while returns on lumen on count bytes renders floating light without triangles the light each while of +platform bunny floating +same while each without decoded the a on of thread while texture +platform the returns renders count platform +falls triangles the platform made each maps bunny on texture thread on light renders light platform on platform every and and every of floating +without lumen +decoded +count same the while falls the and returns lumen while while triangles bunny renders texture bytes same while maps light decoded texture floating light texture platform thread same renders a lumen a renders a light bytes of returns integer point +maps each thread returns while texture +texture renders floating and bytes bunny bunny ray bytes made each lumen bunny count the the +renders and bunny decoded texture each returns and each maps while and the decoded on made thread bunny renders count thread +count a point thread a count without a platform lumen +maps the light the decoded on thread decoded on the falls of ray point the maps texture every each on falls the same of returns each triangles ray platform triangles bunny lumen count maps renders +of floating a ray count a of of without while ray the made and bunny thread returns on falls made returns on same the every texture maps each each decoded renders the integer falls +the floating renders maps thread maps the ray while +made on integer triangles +decoded count integer integer integer bunny +renders platform while texture bytes renders ray point and of floating count count triangles and maps every on each of lumen decoded ray platform falls decoded light falls light on maps lumen +of of while on texture on platform while point light +while every floating each +platform same without same each without texture floating of same of bytes texture made returns each a count falls without a bytes bunny every bunny same falls made returns lumen light falls +and bunny without maps count of returns texture count the falls decoded while count of point bytes same bunny +and a texture returns and each platform of floating while on renders +floating +platform thread light lumen without made decoded +point +bytes maps and count falls triangles on renders and on and falls decoded of every bytes on renders integer and falls same bunny +of made falls integer decoded decoded the of without ray renders returns platform ray bytes floating maps lumen each thread bytes the the returns +falls the triangles thread bytes of decoded texture bytes maps texture platform each the returns and integer a light bytes triangles the without +and on of bunny and point point falls ray +and without bunny each thread while each a platform the lumen renders floating triangles count point falls platform of the integer ray +and thread point thread count on ray bunny of texture the +platform while while the bytes thread decoded every returns +bytes thread lumen the bytes maps point same same bytes returns returns bytes decoded on decoded returns platform the a falls point platform lumen same maps thread maps every bunny bytes the ray without ray every +while of decoded bytes floating same texture falls ray +returns integer each renders texture ray same +returns renders +decoded each ray floating the on thread point renders while platform thread +maps +decoded each point triangles the bunny on made renders triangles on platform a renders thread platform +ray thread floating count floating returns without maps lumen the and each integer of each +renders bunny on floating each +without count decoded of of returns count the every made integer light returns bunny every platform the on +on point without made while every +the +renders count light on count while ray triangles integer +on same each decoded a count maps each a of same the of returns a and falls ray floating maps the every floating a decoded platform lumen platform on thread floating +of thread +on +bunny +each +falls count each bytes +integer integer texture integer the while bytes while +integer and triangles platform +the +on a thread integer platform +floating triangles point on on maps light triangles falls on bytes without returns +of of light of and and renders light returns of ray falls and thread the ray the triangles platform +every point the triangles on while bytes of floating without light maps returns decoded light same and renders on same bytes thread falls maps floating +bunny falls on +returns +texture light a of point thread count each without the triangles lumen of renders +on without texture a on texture while the falls floating made same while on +the and on +ray falls without maps falls renders returns the decoded texture of falls falls ray a decoded maps on +the ray +renders bytes falls made lumen returns bytes lumen and maps and renders on integer +lumen floating and count each on bunny made on lumen count platform bytes light triangles returns texture texture while +floating of maps triangles without returns thread a renders without on point triangles +texture made made every same on maps triangles maps a +lumen +on count point same while integer +point of the a a platform lumen count falls on ray ray thread integer of +same maps +returns lumen without +texture count renders the every renders while bunny platform +integer bytes on floating bytes and count +lumen triangles decoded triangles the every without +integer point every ray thread and without same the on count same same same and bytes falls point integer decoded bunny the +the returns every each integer platform bunny while lumen bytes without a every platform on light every renders texture lumen every floating falls the on a on lumen +light renders bunny integer lumen of point while every and thread count integer +every and made and texture point ray bunny and +floating the falls renders maps platform maps +made light count light texture light maps falls the lumen integer +thread bunny texture triangles each +floating each made integer ray the thread bytes on falls the +the +light +integer while made texture each count the bytes triangles triangles platform +of returns of each texture the renders made same decoded same bunny on a point platform floating point every thread each renders returns same bytes triangles and triangles count every same point the ray renders point texture the a +of returns maps falls falls ray +point same without bytes and light made the each count while maps floating decoded lumen on texture every while floating the on decoded maps every light texture floating +light platform made returns falls bunny on integer +integer and of a and +decoded bytes returns of +texture a bunny made platform platform on without count +while triangles +thread without light +ray bunny bunny returns +the returns count texture light floating same a triangles +bytes every +on point maps every on integer same triangles every the renders returns ray falls while same +each triangles count +count falls each platform every falls ray bytes decoded on every texture thread falls +on of same light light floating without decoded +the platform bytes decoded thread +bunny decoded falls lumen while light returns light of +without thread platform platform and of texture +decoded same the made platform the of the thread bunny bunny while ray +made maps the decoded integer maps of light of on bunny while and maps +same every the the falls thread renders while and on a point each triangles falls falls bunny ray texture falls bytes while light every light thread +decoded the maps renders the same every bytes platform +and integer of triangles decoded made the triangles every +a lumen triangles +on floating a falls renders on triangles +and count +light on +falls bytes falls and bunny lumen made maps of of a the +a floating texture texture bytes integer renders renders count maps each falls a every +light decoded point lumen triangles without on +made +bunny +floating platform of thread triangles and the floating point same +falls each texture without triangles maps lumen triangles maps made +without ray count lumen maps integer the of same decoded ray bunny the point floating maps floating +texture ray light floating point +lumen +without ray platform every of integer integer on thread bytes +point triangles the maps ray same point platform bytes while the of thread bytes returns thread light falls the lumen texture every on light thread while made +every +each texture each floating bytes lumen lumen bytes ray count a same maps +integer texture count triangles ray texture platform floating platform integer integer and a +point on count same maps each falls point +while triangles lumen bytes light made point light the texture on without falls on decoded light and +renders on ray +bunny every returns renders made on the light point +maps triangles the of returns +returns platform +and falls light renders point returns light returns +returns ray while +returns maps light +floating while platform renders falls platform falls ray platform integer point maps the returns +while on falls floating integer on while point made and same falls light platform without made every +every bytes light decoded light count light triangles returns +each bunny +made and ray each the without point on returns the integer of texture on without platform triangles on same count each the every light light light the ray triangles lumen returns made same without floating thread bytes +of the lumen while texture bunny integer texture renders thread falls a same bytes the +ray bunny lumen made bunny the point every returns decoded +texture decoded point maps +thread returns +and integer returns and lumen bytes on ray point lumen without returns triangles integer +on bytes the the triangles and while point ray falls count integer while thread triangles on thread bunny decoded renders count every integer each decoded every a texture the maps triangles +light thread falls +each point triangles returns made a lumen bytes +count same same same texture without same integer while without bunny made each same same bytes count light each same on integer light each decoded +same same ray a every platform point made each integer and and while made on renders the made point a light point thread count ray falls on falls returns returns the without lumen renders texture decoded +bunny count on thread thread decoded a without falls falls and renders thread decoded same texture thread platform made light same falls decoded bytes platform +light bunny each same light made a every made a platform triangles texture and thread light maps same the lumen light of thread of a a platform +falls +count count floating without bytes same +of falls bunny triangles light ray without texture returns without bunny light ray texture on integer the on and and +returns point and bunny lumen light +renders count triangles integer +a +falls made floating light every a platform each the count made without the the returns count +integer light texture light integer the every texture +returns returns on triangles ray +bytes triangles and while decoded count renders integer +integer of light and returns without falls made +a bunny falls point triangles on of the without maps every +every texture platform returns lumen +floating triangles ray platform lumen count on texture count on the +lumen lumen floating platform made thread thread each of maps renders on and the the triangles floating without and triangles lumen made +ray light count ray bytes triangles triangles same on the returns integer bytes +count point each renders each same bunny triangles integer +thread light ray integer every bytes maps the bytes light a lumen thread light texture lumen while without thread lumen bytes lumen floating +texture light decoded of decoded while on without while count texture bunny ray bunny while made count integer bunny thread of and platform count of bunny every made a bytes bytes texture every the the on texture returns the and floating on triangles +bunny the a triangles +renders same ray maps returns bytes a the decoded texture ray without and on the bytes +maps the platform a +same triangles lumen and texture falls triangles made without of each while floating while +lumen light on made each on +maps the returns light ray and the +the triangles triangles thread and integer count lumen without each decoded made ray integer same a count count on on floating on triangles while the a the texture maps a a on texture falls made triangles of falls each bunny of platform bytes floating floating on and on on +of returns the +the made integer without point falls on same falls maps +texture on platform the returns point maps made decoded same the decoded same +bunny bunny +the on +renders maps lumen of every +thread made of point while lumen integer on on falls on every +lumen ray +lumen triangles +texture floating bunny triangles platform each texture triangles while returns light +integer and returns made without maps every integer texture returns each renders maps bunny bunny point floating count bunny on thread thread integer +maps and thread bunny returns decoded and the a every light count count without on +texture point decoded count light lumen +while the and of ray integer floating each bunny without while +integer floating without every bytes +each lumen falls on maps of while lumen thread lumen of every integer same renders +bunny on without every while each triangles count decoded +bytes and bytes while triangles every while every without falls same returns decoded platform platform thread a each floating on platform the decoded floating bunny +returns +thread maps every of +decoded made returns decoded bytes same maps lumen maps each floating of on bunny a returns count texture of bytes renders floating without a maps and point decoded thread on of without a platform integer integer while each without and point bytes ray decoded floating renders thread thread while same thread decoded every light maps +on thread on point on on and light on floating ray on without triangles decoded light every without while every and floating bunny bytes floating same the made bunny falls thread and lumen the thread while count thread decoded floating light every platform floating +bunny maps returns +each triangles platform maps bytes texture point platform made lumen +returns every every +ray each bytes count thread without without lumen +maps ray returns +and +same while falls decoded decoded point falls platform integer bytes the each bytes a thread bytes without lumen renders the point lumen thread falls maps floating renders while the bunny +falls count falls of floating platform falls triangles maps every every count on triangles lumen light count count on made on a count bunny every the bunny the every floating count every the +made and +on thread ray a bunny a platform returns each point platform bytes same falls decoded platform renders light thread light decoded count point made renders made platform bunny while of each lumen bytes thread integer same bytes ray bunny +on thread bunny each bytes returns floating and triangles triangles a of falls while triangles light platform thread +of without decoded and decoded point +light +thread floating thread the on each platform light +thread +integer a without falls platform point made each the texture light the renders every of renders maps renders the bunny count triangles bunny while maps without point +count each integer falls of decoded a +decoded floating on made decoded floating +of thread and every triangles point texture platform the on every every texture and without maps count ray of count the the light while ray thread +maps while texture same without bytes ray floating on integer every ray bunny each while light +returns made each made lumen on a made and +returns light point returns each light platform decoded count a of renders platform the bytes every integer renders maps ray floating each +each same floating light on made on without same floating texture +triangles bytes bytes without every bytes bytes falls every every a renders lumen decoded the returns each count decoded renders on floating light the returns every renders lumen platform integer texture of the and the renders platform same lumen a texture count light the falls lumen falls without triangles bytes on returns a thread the while light integer renders +maps floating bytes on bunny every bytes triangles same bytes count each +texture integer bunny +count count made and lumen made thread a every bytes every the renders returns +decoded renders count a same +on light same renders point every returns returns point falls of and renders same made made renders of returns floating without returns while the every maps falls without falls same platform platform falls returns while platform the maps while triangles of a maps maps light light bunny light integer same decoded platform without same light the returns renders the of floating every +point integer platform integer and count falls texture on without a falls bytes lumen bunny texture the same returns texture and count platform on maps integer made integer +integer bytes bytes decoded triangles every ray every ray on while each platform +the the a floating platform bunny lumen +on maps returns returns count renders same falls without on +decoded without on falls decoded without count decoded on each platform +integer each each bytes +integer maps platform renders lumen floating triangles of ray the triangles count without the texture bytes integer bytes texture triangles and made without thread lumen count floating platform without +decoded maps falls falls and every bytes falls on maps maps platform +decoded +thread point bunny platform bunny +ray while on lumen ray falls renders +the a bunny maps the decoded on decoded made decoded integer renders without texture point ray lumen the while count decoded triangles maps count bunny of lumen +renders +same bytes floating light while same +and same of on count decoded without the on count falls triangles falls each without maps +on maps a falls floating point +every point renders the renders lumen every falls ray falls decoded on on a light platform renders the floating without bytes made light bytes made the on +same count +triangles returns platform falls triangles maps without lumen triangles and each maps count every bytes same returns bunny same returns ray +floating without same lumen every light decoded platform maps returns ray platform without integer renders of triangles without a triangles floating triangles light a lumen every bunny decoded triangles returns and and decoded every lumen while each integer bytes texture lumen +falls decoded each every on triangles the bytes and the same point ray bunny +the +each without maps and on thread lumen on +on bytes triangles platform bunny integer every a the bunny thread on made maps bytes the on the bytes falls integer the returns floating falls on point integer falls the light while +made on +and triangles lumen triangles floating count lumen and while count lumen +texture count ray texture point +texture on on without decoded bytes count without and light the falls of same point of the triangles point point returns light each +made lumen every point lumen light a on bunny on of falls point triangles same lumen returns +while +while every returns falls each each +and floating without +floating floating integer platform +floating the +the +on point triangles same the +on +lumen on bunny bytes and lumen a the bytes count bytes the platform light bytes decoded made made +falls on floating decoded bunny bunny and while of a triangles integer ray while returns floating of same texture without texture bytes of the every +renders on integer maps falls while triangles integer without ray bytes returns light of bytes renders the the without falls count every and thread point triangles returns triangles lumen falls maps point of on point every a while maps and +point on +platform each light returns platform the +platform +the the renders every the each every bytes the bytes while lumen light floating +each decoded every triangles a light every the without point +floating decoded on triangles decoded the on on +on light +every ray count count platform triangles falls platform decoded +each texture renders and of ray the point falls renders same the a integer thread +light +renders falls bytes texture count ray texture same without ray integer renders returns each texture without +every every thread without on the on on of +falls every triangles without maps of +platform a decoded count returns point same floating lumen integer without the triangles light lumen and triangles texture renders platform while returns bunny every falls bunny without the floating lumen point count each of light of maps thread point +same platform the of every thread floating triangles each light light renders bunny same light thread light point triangles +point platform a count without +on renders on the +bytes decoded count decoded a the floating bytes +texture point returns +the lumen falls triangles the platform the bunny lumen texture on returns triangles renders triangles of the returns count made +point +the on of a thread floating +the point a the on triangles the lumen the point platform bunny thread every and on each renders falls of on renders the every falls triangles +decoded the a bytes made on +the ray triangles texture maps the maps of integer point bunny point +without thread light on floating thread decoded falls floating point platform of bytes bunny made decoded bytes returns count floating thread the same floating on without decoded light a returns +falls bunny triangles on made bytes and texture and +the of +light while made decoded falls count light renders platform platform integer triangles ray light bytes +falls +without ray light bytes on +bytes without triangles on a renders on maps decoded same point on decoded the on made made integer ray on ray thread floating +thread every +decoded platform maps every +thread point point every bytes the integer without without +without lumen lumen texture decoded integer of renders and +made on falls light and each point of lumen decoded and each point on integer the while bytes made while on renders returns while falls maps same on every platform every without each light each +on without maps texture without the count the renders a integer on floating floating and every ray texture ray integer on +without same thread point texture same point renders +returns maps light each lumen without maps the while texture on returns thread and platform maps +the point renders triangles the maps returns bytes floating +made decoded of +a bunny thread +on +the renders renders on integer the and and renders +a each same ray renders lumen same lumen same returns maps lumen maps lumen every each on thread maps on same the falls count +maps light ray on decoded bunny made every a decoded floating a +without renders count +platform +the +light the +each decoded bunny on point maps +same every lumen bunny of count renders bunny ray thread falls a without each lumen platform thread +ray count bunny thread platform triangles made +lumen ray made lumen returns lumen returns the a floating bytes platform a on falls on triangles without +decoded texture on falls ray returns every without thread the of point the without without floating a while thread each on maps platform while each same of of a each while every the integer on a bunny integer made on each the on returns +triangles without texture without count returns integer and floating maps maps +platform on ray thread light of returns same without on the while made platform and and texture integer +renders same and falls bytes integer made on renders a texture without the platform a floating without the bunny +ray falls +thread +a count without platform falls a each on lumen platform triangles +the integer on lumen returns renders count light lumen renders texture floating maps without +decoded and on +bunny ray integer thread +while point on maps decoded renders lumen renders count every count while +the texture falls while platform each the renders lumen every every maps count thread +platform lumen decoded integer without each without maps on texture on light the platform of while returns falls bunny made lumen a every +without light bunny texture floating of integer triangles on light thread a every decoded the the on of same +on and floating thread count bytes light thread bytes floating floating count +platform decoded decoded returns of without on while the the of the +decoded ray maps and renders same count lumen +on on +returns texture light on and without texture without renders lumen ray lumen thread on lumen the platform +thread every +on without while returns count +of made maps same ray bytes thread without bunny platform a the returns texture +returns returns ray renders each +on platform returns on thread falls +the lumen floating each bytes every on renders lumen light bytes texture texture count the made decoded renders on falls light point maps +floating without every on each of every made bunny without a maps maps renders of integer maps falls same same thread thread decoded returns bunny ray a decoded +returns every on without maps on every platform +same +maps while falls floating integer and texture maps platform a light every returns returns and count of made on falls +ray ray light same returns light bunny on the point point on each texture made while floating every bunny of integer of +and without lumen of +renders thread count the renders renders platform triangles each returns while texture maps and +of +on same +bytes falls light maps floating count the light platform made +bunny triangles ray returns of each integer on a the texture while on +returns without the the of platform while while point maps lumen decoded renders triangles of triangles bunny same bunny a on on ray without bytes bunny lumen and a +light light same on decoded every ray point maps maps integer thread +the platform +count bunny maps integer of thread while while falls a a returns same every a returns a +decoded +while a a decoded without bytes on each same +count same texture +the on lumen bunny a each and point each same every the +maps bytes the ray bytes of a triangles thread returns floating renders texture returns bytes the light +while lumen same returns renders returns decoded +made +texture on and bytes on same texture the of +on thread thread platform a decoded +of floating floating same integer every a same each each +a maps maps platform returns maps decoded lumen count bytes on bunny made light ray lumen floating and renders a on light thread made the returns renders renders a bytes bunny maps made thread made integer of each +each same while bunny the the light integer returns of texture each triangles floating thread decoded renders +and same while same bunny made on decoded texture every the while the made floating bytes the without count the thread texture falls renders bytes platform on bunny returns integer while of point and while on of same renders light +the count on point ray each made the triangles made maps texture renders platform while platform count a +light point on texture without bunny +triangles texture on every on renders ray count +integer integer floating thread of point bytes point the decoded triangles the and texture while decoded every bunny point floating renders on +lumen light count a bunny same point every and renders while maps renders decoded returns each bunny of triangles same +texture decoded the texture +texture on floating triangles light a platform decoded platform texture +of without +the falls without bunny on decoded count on point ray on each the platform +renders +the the without the falls same bytes triangles of made on +every thread +on floating every ray every returns ray on triangles bunny without made without while thread light platform every platform bytes renders on on lumen count floating ray count floating on renders and each every the platform point each light while integer +thread point bytes and same without on bunny without thread the bytes point triangles on lumen lumen while and light maps floating point on maps lumen and bytes same made maps the point on the decoded triangles integer while while each while maps while texture count same a and every triangles a same and floating falls a decoded decoded on while triangles the a integer a of bunny and renders triangles falls integer of light same count and texture and bunny count +while made same every every bunny texture bytes on every platform of point lumen every decoded a each triangles renders without thread point on point returns on decoded while made maps decoded maps while and on falls the while floating +bunny thread made every on maps texture platform decoded point returns and thread +of ray maps on decoded made returns returns floating texture floating every a integer light of ray +texture bytes triangles platform and and of same ray returns point thread returns same falls bunny triangles thread while triangles floating platform a integer bunny +falls every texture the decoded ray without count on ray made +platform renders the triangles while returns the the point bytes the made a while of floating bytes maps a the the triangles count integer made each bunny +and ray floating integer every on floating texture decoded made while while and without a thread without count the and +the on each decoded +a on light +each lumen bytes integer maps and thread count platform same light platform while +the count maps ray of +made renders on without the while triangles integer +point bytes without every point +thread renders while each made without bunny renders count platform a floating ray on without integer bunny +renders bytes while triangles count each floating triangles +returns ray integer same every bunny every made integer while without ray each thread texture same while +and of bunny count decoded thread lumen a texture triangles returns light a the point +each thread thread a a the integer bytes lumen +ray returns point returns point texture ray thread bytes ray of on light on triangles made platform triangles decoded each on the lumen ray maps renders +decoded platform and returns ray floating same returns platform lumen falls count the floating on bunny of the bunny the light point lumen the without integer lumen on count integer on +of renders platform triangles triangles of +each a a bunny +returns lumen bytes and on each thread texture and while lumen count ray triangles texture without platform on each thread +without returns floating +floating +triangles platform floating made of returns on +of bunny bytes the while maps bytes platform falls point +maps and each without falls bytes texture bunny light decoded the count returns renders bunny renders renders on the and thread light light made platform of without and integer returns and point +integer triangles point without integer decoded returns integer triangles and made floating a thread point +returns while bunny made light made maps a on bytes integer and while each triangles without renders point point triangles ray the lumen a and triangles on floating on texture ray +point and texture decoded integer triangles triangles decoded of made decoded made on thread renders the of triangles renders a of ray texture same every bunny triangles floating integer count floating decoded bunny bytes on on triangles made light thread the same +lumen decoded bunny floating bunny bunny count renders while platform integer platform made +while bunny ray lumen ray without light of and texture each same renders decoded renders renders decoded light without thread lumen integer on texture each each light every ray texture bunny decoded bunny floating texture every ray +while ray texture and texture light the without a on renders floating +of point texture +count while decoded on triangles made thread count lumen texture returns maps on count falls +lumen every triangles integer returns made integer triangles decoded while ray bunny on and ray platform on +same made each integer a on renders bunny ray the thread thread renders every a maps bytes integer bunny triangles floating bunny the integer on triangles a same and integer of of a renders integer thread point +point and on triangles made on texture on light falls every light the decoded integer platform bytes falls floating triangles +of each bytes every returns point made texture renders decoded +the made returns returns count on maps bytes the count falls triangles platform maps on +a same on same +count same bunny decoded integer platform and the made ray on on ray lumen renders renders +the a bunny decoded lumen +maps +without the maps platform made lumen +a decoded texture of the floating light bytes and light floating +without a lumen light +floating a platform while without lumen floating floating ray same and thread on renders light triangles bytes of integer same on texture renders made platform and a bytes made on made on +decoded maps on a on on light renders on +the +without returns integer platform and and +every lumen triangles made and light platform while renders of same on +same light triangles light same each count without +every of without count point count of +and light integer texture point +lumen ray every on count maps integer thread returns same point of of +on the count maps every +every every +ray returns texture of light integer thread on triangles the thread bytes on bunny point made lumen returns maps the while made lumen bytes the without same every count on texture renders bunny the floating each of decoded platform triangles the and +each thread and a same bytes integer a decoded platform maps maps texture on lumen a texture bunny on the made maps light falls every the maps platform on maps texture while on the same count maps ray a every bytes decoded a ray while on ray on falls maps of each platform on without lumen lumen platform maps each made bunny texture returns bunny returns the the thread texture texture platform bytes without returns texture same maps thread maps renders on the lumen maps a count renders thread each the every on integer returns and +without texture of decoded same each +texture bytes without every decoded every ray a every +thread texture and bunny without point the of returns renders count ray floating returns on every triangles returns on texture returns same texture decoded the falls texture thread lumen the lumen a of the integer integer same lumen bunny triangles the triangles ray returns on integer a returns decoded and while count renders and on same and thread made +on each on +every of falls falls bytes decoded ray while texture bytes light the without count lumen thread and while platform the light while on same bunny ray thread +the thread +bunny integer a and renders each same bunny every the the falls without of count while triangles texture point on renders a and integer platform point +same +integer on falls maps made every on count same ray ray +platform triangles maps each texture light +count returns lumen texture +integer ray on each floating platform made maps the triangles same same floating triangles same while and same triangles made integer lumen and thread returns +texture on made floating while every bytes returns and maps falls ray on ray of decoded floating every bunny renders renders decoded thread the light returns each each returns each made of of texture light made while renders on thread light falls made and +falls bunny while without renders point falls lumen decoded lumen and on every integer +the bytes +and returns each while of of integer the decoded count +falls point while bunny of thread integer made on without count renders bunny while made on made platform floating +made returns a every and light without on without point texture ray returns +bunny without the thread returns without platform floating returns floating of point platform point while platform count same every every bytes every without each count lumen +on maps +thread the platform platform renders every +ray +renders each while maps decoded thread returns on thread the ray bytes maps point the point the triangles +light bunny and floating count point same every floating +light point bunny renders bytes bunny platform triangles ray floating bunny count ray the decoded texture ray a on of on ray +bunny +returns every thread and bunny maps falls and count light falls triangles the renders the on on texture without bunny thread every decoded count lumen bytes +on integer ray falls returns each of triangles without of each a every thread maps lumen integer on on bunny integer on bunny triangles platform count made lumen bunny ray without point point platform thread on without platform +on renders +and a platform ray the thread bunny falls the without +on without texture triangles count made +returns each bytes each decoded +triangles lumen falls same +while on the while the returns each and integer the made integer on light and without a same count integer +on the and on a texture on texture the returns maps each on bytes +renders maps every light count lumen returns count of +the each integer each every the same bytes a and falls bunny each while +the +integer on thread each the +made a floating thread maps renders maps every lumen decoded on the falls while lumen lumen made every the the texture of lumen ray on without renders bytes without renders each triangles integer while bunny texture platform each count floating a made bunny integer of every platform and decoded returns +on texture the falls while the every thread on falls floating falls maps bytes triangles the +decoded integer and the ray each returns lumen decoded without on +bunny triangles made the point while on integer triangles texture bytes every made triangles bytes point texture platform bunny ray falls the maps renders bunny platform light thread bytes decoded returns decoded bytes triangles the returns ray every ray returns floating decoded on the of falls of made every integer +without returns thread falls and the and falls maps without every without on +every decoded of ray the same same each falls +each renders while thread +on +on while light and thread +triangles point point made texture light and and point while made lumen maps without returns of of decoded +bytes point renders +point floating while light light returns made ray of each returns decoded bytes on on same falls platform +without triangles and same lumen the texture lumen texture triangles floating on floating bunny made +renders lumen integer a every maps renders floating platform bunny texture texture +on the bunny platform every bytes bunny texture falls light maps while floating same decoded while every the and while light each floating decoded on of and texture same the the platform +maps decoded a on and bytes while while floating a lumen returns made same count the while floating decoded point maps on returns bunny on the +maps made +the same +on renders of ray triangles of each decoded lumen point same returns every returns light same bytes while bunny bytes made and triangles \ No newline at end of file diff --git a/crates/lumen-image/tests/corpus/stored_multi.zlib b/crates/lumen-image/tests/corpus/stored_multi.zlib new file mode 100644 index 0000000000000000000000000000000000000000..5549d10ee7d2d9b5feb399c1788c78098d93a4f7 GIT binary patch literal 70016 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 literal 0 HcmV?d00001 diff --git a/crates/lumen-image/tests/corpus/stored_small.raw b/crates/lumen-image/tests/corpus/stored_small.raw new file mode 100644 index 0000000..26e6492 --- /dev/null +++ b/crates/lumen-image/tests/corpus/stored_small.raw @@ -0,0 +1,14 @@ +a texture integer renders and made the ray renders count lumen each without the +on +without made lumen +of point of thread the floating +maps floating bunny lumen on without count point maps made each same bytes decoded +of ray bunny without thread falls bytes bunny ray lumen +light decoded each and bytes the on on bytes decoded the thread point ray maps point texture renders returns same each point same returns on texture the texture bunny bunny texture decoded integer +point falls the +renders integer platform triangles +bunny point integer triangles while on +ray texture on lumen made returns the ray lumen the thread maps and bytes bytes ray texture and lumen point light decoded +floating lumen each the decoded +maps without bunny decoded count light every each returns same thread bytes while ray the decoded each while integer maps on without on on lumen +a floating integer platform integer while of platform count a renders light ray texture a platform floating each each integer triangles float \ No newline at end of file diff --git a/crates/lumen-image/tests/corpus/stored_small.zlib b/crates/lumen-image/tests/corpus/stored_small.zlib new file mode 100644 index 0000000..2181a42 --- /dev/null +++ b/crates/lumen-image/tests/corpus/stored_small.zlib @@ -0,0 +1,14 @@ +xèüa texture integer renders and made the ray renders count lumen each without the +on +without made lumen +of point of thread the floating +maps floating bunny lumen on without count point maps made each same bytes decoded +of ray bunny without thread falls bytes bunny ray lumen +light decoded each and bytes the on on bytes decoded the thread point ray maps point texture renders returns same each point same returns on texture the texture bunny bunny texture decoded integer +point falls the +renders integer platform triangles +bunny point integer triangles while on +ray texture on lumen made returns the ray lumen the thread maps and bytes bytes ray texture and lumen point light decoded +floating lumen each the decoded +maps without bunny decoded count light every each returns same thread bytes while ray the decoded each while integer maps on without on on lumen +a floating integer platform integer while of platform count a renders light ray texture a platform floating each each integer triangles floatró \ No newline at end of file diff --git a/crates/lumen-image/tests/hand.rs b/crates/lumen-image/tests/hand.rs new file mode 100644 index 0000000..148777d --- /dev/null +++ b/crates/lumen-image/tests/hand.rs @@ -0,0 +1,401 @@ +//! Size class: small. Streams assembled bit by bit from RFC 1951 and RFC 1950, never from an +//! encoder: two written out in full in the comments (a fixed-Huffman and a dynamic-Huffman +//! block), then one stream per refusal, each with the offset the RFC's bit order puts it at. +//! +//! Oracle: the RFCs. The expected bytes are those the streams were built to hold, and each +//! expected offset is the byte that [`writer::Writer`] placed the faulting bit in. + +#![allow(clippy::unwrap_used, reason = "test code fails loudly")] + +mod writer; + +use lumen_image::{inflate_zlib, Alphabet, InflateErrorKind, OutputLimit}; +use writer::{adler32, flg_for, Writer}; + +const ROOM: OutputLimit = OutputLimit::new(1 << 20); + +/// Asserts that `stream` is refused with `kind` at `offset`. +fn refused(stream: &[u8], kind: InflateErrorKind, offset: usize) { + let error = inflate_zlib(stream, ROOM).unwrap_err(); + assert_eq!((error.kind(), error.offset()), (&kind, offset), "{error}"); +} + +/// The code-length code the dynamic streams below use, chosen to be complete: symbols 0 to 12 +/// have 4 bits and 13 to 18 have 5 (13/16 + 6/32 = 1). By section 3.2.2, the 4-bit codes are +/// `0000` to `1100` in symbol order; the 5-bit codes start at `(1100 + 1) << 1 = 11010`. +fn length_symbol(w: &mut Writer, symbol: u32) -> &mut Writer { + if symbol <= 12 { + w.code(symbol, 4) + } else { + w.code(0b11010 + symbol - 13, 5) + } +} + +/// A dynamic block's header for literal/length lengths `literals` and distance lengths +/// `distances`, each length written as its own code-length symbol. +fn dynamic(w: &mut Writer, last: bool, literals: &[u8], distances: &[u8]) { + w.block(last, 2); + let (hlit, hdist) = (literals.len() - 257, distances.len() - 1); + w.value(u32::try_from(hlit).unwrap(), 5).value(u32::try_from(hdist).unwrap(), 5).value(15, 4); + // The code-length lengths, in the order of section 3.2.7. + for symbol in [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15] { + w.value(if symbol <= 12 { 4 } else { 5 }, 3); + } + for &length in literals.iter().chain(distances) { + length_symbol(w, u32::from(length)); + } +} + +/// Literal/length lengths with `lengths` set and the rest zero. +fn lengths(set: &[(usize, u8)]) -> [u8; N] { + let mut all = [0; N]; + for &(symbol, length) in set { + all[symbol] = length; + } + all +} + +/// One fixed block, final, holding "aaaa" as a literal and a match, built by hand: +/// +/// ```text +/// field value code (sent first to last) bits on the wire, in order +/// BFINAL 1 1 +/// BTYPE 01 (value, LSB first) 1 0 +/// 'a' = 97 lit 00110000 + 97 = 10010001 1 0 0 1 0 0 0 1 +/// length 3 257 0000000 + 1 = 0000001 0 0 0 0 0 0 1 +/// distance 1 0 00000 0 0 0 0 0 +/// end 256 0000000 0 0 0 0 0 0 0 +/// ``` +/// +/// The 30 bits, packed least significant first: `1101_0010 0010_0000 0100_0000 0000_00`, read +/// right to left per byte: 0x4b, 0x04, 0x02, 0x00. The header is `78 01` (0x7801 = 31 * 991), +/// the trailer Adler-32("aaaa") = 0x03ce0185 (A = 1 + 4 * 97 = 389, B = 98 + 195 + 292 + 389 = +/// 974 = 0x3ce). +#[test] +fn a_hand_assembled_fixed_block_decodes() { + let stream = [0x78, 0x01, 0x4b, 0x04, 0x02, 0x00, 0x03, 0xce, 0x01, 0x85]; + assert_eq!(inflate_zlib(&stream, ROOM).unwrap(), b"aaaa"); +} + +/// One dynamic block, final, holding "aa" with two one-bit literal/length codes and the single +/// one-bit distance code of section 3.2.7, built by hand: +/// +/// ```text +/// BFINAL 1, BTYPE 10 1 | 0 1 +/// HLIT 0 (257), HDIST 0 (1), HCLEN 14 00000 | 00000 | 0111 +/// code-length lengths, order 16 17 18 0 8 7 9 6 10 5 11 4 12 3 13 2 14 1: +/// 18 and 1 have length 1, the rest 0 000 000 100 000 ... 000 100 (18 fields, 3 bits each) +/// code-length code (section 3.2.2): symbol 1 -> 0, symbol 18 -> 1 +/// lengths: 97 zeros 18 + 86 (7 bits) 1 | 0110101 +/// 'a' = 1 1 0 +/// 138 zeros 18 + 127 1 | 1111111 +/// 20 zeros 18 + 9 1 | 1001000 +/// 256 = 1 1 0 +/// dist 0 = 1 1 0 +/// literal/length code: 97 -> 0, 256 -> 1; data 'a' 'a' end 0 0 1 +/// ``` +/// +/// 101 bits; packed, `05 c0 81 00 00 00 00 00 90 56 ff 13 10`. Adler-32("aa") = 0x012500c3 (A +/// = 195, B = 98 + 195 = 293 = 0x125). The stream was checked to decompress to "aa" with +/// CPython's zlib. +#[test] +fn a_hand_assembled_dynamic_block_with_one_distance_code_decodes() { + let stream = [ + 0x78, 0x01, 0x05, 0xc0, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x56, 0xff, 0x13, 0x10, + 0x01, 0x25, 0x00, 0xc3, + ]; + assert_eq!(inflate_zlib(&stream, ROOM).unwrap(), b"aa"); +} + +/// RFC 1950's smallest stream: a final fixed block holding only its end code, `03 00`. +#[test] +fn the_empty_stream_decodes_to_nothing_even_with_a_zero_limit() { + let stream = [0x78, 0x9c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x01]; + assert_eq!(inflate_zlib(&stream, OutputLimit::new(0)).unwrap(), b""); +} + +#[test] +fn a_header_that_is_not_a_multiple_of_31_is_refused() { + refused(&[0x78, 0x02, 0x03, 0x00], InflateErrorKind::HeaderCheck { cmf: 0x78, flg: 0x02 }, 1); +} + +#[test] +fn a_method_other_than_deflate_is_refused() { + let cmf = 0x77; + refused(&[cmf, flg_for(cmf, 0)], InflateErrorKind::CompressionMethod { method: 7 }, 1); +} + +#[test] +fn a_window_field_of_7_is_accepted_and_8_is_refused() { + let mut w = Writer::zlib(0x78, flg_for(0x78, 0)); + w.block(true, 1).code(0, 7); + assert_eq!(inflate_zlib(&w.trailer(b""), ROOM).unwrap(), b""); + refused(&[0x88, flg_for(0x88, 0)], InflateErrorKind::WindowSize { cinfo: 8 }, 1); +} + +#[test] +fn a_preset_dictionary_is_refused_by_name() { + refused(&[0x78, flg_for(0x78, 0x20)], InflateErrorKind::PresetDictionary, 1); +} + +#[test] +fn the_reserved_block_type_is_refused() { + let mut w = Writer::deflate(); + w.block(true, 3); + refused(&w.finish(), InflateErrorKind::ReservedBlockType, w.last_byte()); +} + +#[test] +fn a_stored_length_that_does_not_match_its_complement_is_refused() { + let mut w = Writer::deflate(); + w.block(true, 0).align().bytes(&[5, 0, 0xfa, 0xfe]); + let kind = InflateErrorKind::StoredLengthMismatch { len: 5, nlen: 0xfefa }; + refused(&w.finish(), kind, w.last_byte()); +} + +#[test] +fn a_stored_block_of_the_largest_length_decodes() { + let data: Vec = (0..65_535_u32).map(|i| u8::try_from(i % 251).unwrap()).collect(); + let mut w = Writer::deflate(); + w.block(true, 0).align().bytes(&[0xff, 0xff, 0, 0]).bytes(&data); + assert_eq!(inflate_zlib(&w.trailer(&data), ROOM).unwrap(), data); +} + +#[test] +fn literal_length_codes_are_accepted_up_to_286_and_refused_at_287() { + let mut literals = lengths::<286>(&[(97, 1), (256, 1)]); + let mut w = Writer::deflate(); + dynamic(&mut w, true, &literals, &[0]); + w.code(0, 1).code(1, 1); + assert_eq!(inflate_zlib(&w.trailer(b"a"), ROOM).unwrap(), b"a"); + + let mut w = Writer::deflate(); + w.block(true, 2).value(30, 5).value(0, 5).value(15, 4); + let kind = InflateErrorKind::TooManyCodes { alphabet: Alphabet::LiteralLength, count: 287 }; + refused(&w.finish(), kind, w.last_byte()); + literals[0] = 0; +} + +#[test] +fn distance_codes_are_accepted_up_to_30_and_refused_at_31() { + let literals = lengths::<257>(&[(97, 1), (256, 1)]); + let mut w = Writer::deflate(); + dynamic(&mut w, true, &literals, &[0; 30]); + w.code(0, 1).code(1, 1); + assert_eq!(inflate_zlib(&w.trailer(b"a"), ROOM).unwrap(), b"a"); + + let mut w = Writer::deflate(); + w.block(true, 2).value(0, 5).value(30, 5).value(15, 4); + let kind = InflateErrorKind::TooManyCodes { alphabet: Alphabet::Distance, count: 31 }; + refused(&w.finish(), kind, w.last_byte()); +} + +/// Code-length lengths written in section 3.2.7's order, `HCLEN` + 4 of them. +fn code_length_header(lengths: &[u32]) -> Writer { + let mut w = Writer::deflate(); + w.block(true, 2).value(0, 5).value(0, 5).value(u32::try_from(lengths.len() - 4).unwrap(), 4); + for &length in lengths { + w.value(length, 3); + } + w +} + +#[test] +fn an_over_subscribed_code_length_code_is_refused() { + // Symbols 16, 17 and 18 each with one bit: three codes where two fit. + let w = code_length_header(&[1, 1, 1, 0]); + let kind = InflateErrorKind::OverSubscribedCode { alphabet: Alphabet::CodeLength }; + refused(&w.finish(), kind, w.last_byte()); +} + +#[test] +fn a_code_length_code_of_one_symbol_is_refused_as_incomplete() { + // Only symbol 18, with one bit: the one-code shape is admitted for no code-length code. + let w = code_length_header(&[0, 0, 1, 0]); + let kind = InflateErrorKind::IncompleteCode { alphabet: Alphabet::CodeLength }; + refused(&w.finish(), kind, w.last_byte()); +} + +#[test] +fn an_incomplete_literal_length_code_is_refused() { + // 'a' and 256 with two bits each: half the code space unused. + let mut w = Writer::deflate(); + dynamic(&mut w, true, &lengths::<257>(&[(97, 2), (256, 2)]), &[0]); + let kind = InflateErrorKind::IncompleteCode { alphabet: Alphabet::LiteralLength }; + refused(&w.finish(), kind, w.last_byte()); +} + +#[test] +fn an_over_subscribed_distance_code_is_refused() { + let mut w = Writer::deflate(); + dynamic(&mut w, true, &lengths::<257>(&[(97, 1), (256, 1)]), &[1, 1, 1]); + let kind = InflateErrorKind::OverSubscribedCode { alphabet: Alphabet::Distance }; + refused(&w.finish(), kind, w.last_byte()); +} + +#[test] +fn an_incomplete_distance_code_of_two_symbols_is_refused() { + let mut w = Writer::deflate(); + dynamic(&mut w, true, &lengths::<257>(&[(97, 1), (256, 1)]), &[2, 2]); + let kind = InflateErrorKind::IncompleteCode { alphabet: Alphabet::Distance }; + refused(&w.finish(), kind, w.last_byte()); +} + +#[test] +fn a_literal_length_code_of_only_the_end_symbol_decodes_an_empty_block() { + let mut w = Writer::deflate(); + dynamic(&mut w, true, &lengths::<257>(&[(256, 1)]), &[0]); + w.code(0, 1); + assert_eq!(inflate_zlib(&w.trailer(b""), ROOM).unwrap(), b""); +} + +#[test] +fn the_unused_half_of_a_one_symbol_distance_code_is_refused() { + // 257 -> 0, 'a' -> 10, 256 -> 11 (section 3.2.2); one distance code, 0 -> 0. + let mut w = Writer::deflate(); + dynamic(&mut w, true, &lengths::<258>(&[(97, 2), (256, 2), (257, 1)]), &[1]); + w.code(0b10, 2).code(0, 1).code(1, 1); + refused(&w.finish(), InflateErrorKind::UnusedCode { alphabet: Alphabet::Distance }, w.last_byte()); +} + +#[test] +fn a_match_in_a_block_with_no_distance_code_is_refused() { + let mut w = Writer::deflate(); + dynamic(&mut w, true, &lengths::<258>(&[(97, 2), (256, 2), (257, 1)]), &[0]); + w.code(0b10, 2).code(0, 1); + refused(&w.finish(), InflateErrorKind::UnusedCode { alphabet: Alphabet::Distance }, w.last_byte()); +} + +#[test] +fn a_repeat_with_no_previous_length_is_refused() { + let mut w = Writer::deflate(); + w.block(true, 2).value(0, 5).value(0, 5).value(15, 4); + for symbol in [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15] { + w.value(if symbol <= 12 { 4 } else { 5 }, 3); + } + length_symbol(&mut w, 16); + refused(&w.finish(), InflateErrorKind::RepeatWithoutLength, w.last_byte()); +} + +#[test] +fn lengths_that_run_past_the_declared_codes_are_refused() { + // 258 lengths declared; 138 + 138 zeros run past them. + let mut w = Writer::deflate(); + w.block(true, 2).value(0, 5).value(0, 5).value(15, 4); + for symbol in [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15] { + w.value(if symbol <= 12 { 4 } else { 5 }, 3); + } + length_symbol(&mut w, 18).value(127, 7); + length_symbol(&mut w, 18).value(127, 7); + refused(&w.finish(), InflateErrorKind::CodeLengthsOverrun, w.last_byte()); +} + +#[test] +fn a_block_whose_end_symbol_has_no_code_is_refused() { + let mut w = Writer::deflate(); + dynamic(&mut w, true, &lengths::<257>(&[(97, 1), (98, 1)]), &[0]); + refused(&w.finish(), InflateErrorKind::MissingEndOfBlock, w.last_byte()); +} + +#[test] +fn fixed_literal_length_symbols_286_and_287_are_refused() { + for (symbol, code) in [(286, 0b1100_0110), (287, 0b1100_0111)] { + let mut w = Writer::deflate(); + w.block(true, 1).code(code, 8); + let kind = InflateErrorKind::InvalidSymbol { alphabet: Alphabet::LiteralLength, symbol }; + refused(&w.finish(), kind, w.last_byte()); + } +} + +#[test] +fn fixed_distance_symbols_30_and_31_are_refused() { + for symbol in [30, 31] { + let mut w = Writer::deflate(); + w.block(true, 1).fixed_literal(b'a').code(1, 7).code(u32::from(symbol), 5); + let kind = InflateErrorKind::InvalidSymbol { alphabet: Alphabet::Distance, symbol }; + refused(&w.finish(), kind, w.last_byte()); + } +} + +#[test] +fn a_distance_to_the_first_byte_decodes_and_one_further_is_refused() { + // 'a' 'b', then length 3 at distance 2 (symbol 1, no extra bits): "ababa". + let mut w = Writer::deflate(); + w.block(true, 1).fixed_literal(b'a').fixed_literal(b'b').code(1, 7).code(1, 5).code(0, 7); + assert_eq!(inflate_zlib(&w.trailer(b"ababa"), ROOM).unwrap(), b"ababa"); + + // Distance 3 (symbol 2) with two bytes decoded. + let mut w = Writer::deflate(); + w.block(true, 1).fixed_literal(b'a').fixed_literal(b'b').code(1, 7).code(2, 5); + let kind = InflateErrorKind::DistanceTooFar { distance: 3, available: 2 }; + refused(&w.finish(), kind, w.last_byte()); +} + +/// A header with `CINFO` 0 (a 256-byte window), 300 literals, then a 3-byte match at +/// `distance` (256 is symbol 15, base 193, 6 extra bits of 63; 257 is symbol 16, base 257, 7 +/// extra bits of 0). +fn small_window(distance: u32) -> (Writer, Vec) { + let mut w = Writer::zlib(0x08, flg_for(0x08, 0)); + let literals: Vec = (0..300_u32).map(|i| u8::try_from(i % 256).unwrap()).collect(); + w.block(true, 1); + for &b in &literals { + w.fixed_literal(b); + } + w.code(1, 7); + if distance == 256 { + w.code(15, 5).value(63, 6); + } else { + w.code(16, 5).value(distance - 257, 7); + } + (w, literals) +} + +#[test] +fn a_distance_equal_to_the_declared_window_decodes_and_one_past_is_refused() { + let (mut w, mut decoded) = small_window(256); + w.code(0, 7); + let start = decoded.len() - 256; + decoded.extend_from_within(start..start + 3); + assert_eq!(inflate_zlib(&w.trailer(&decoded), ROOM).unwrap(), decoded); + + let (w, _) = small_window(257); + let kind = InflateErrorKind::DistanceBeyondWindow { distance: 257, window: 256 }; + refused(&w.finish(), kind, w.last_byte()); +} + +#[test] +fn a_stream_cut_inside_its_header_is_truncated_at_its_length() { + refused(&[0x78], InflateErrorKind::Truncated, 1); + refused(&[], InflateErrorKind::Truncated, 0); +} + +#[test] +fn a_wrong_adler32_is_refused() { + let stream = [0x78, 0x9c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x02]; + let kind = InflateErrorKind::Adler32Mismatch { stored: 2, computed: adler32(b"") }; + refused(&stream, kind, 7); +} + +#[test] +fn a_byte_after_the_trailer_is_refused() { + let stream = [0x78, 0x9c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00]; + refused(&stream, InflateErrorKind::TrailingBytes { count: 1 }, 8); +} + +#[test] +fn a_stored_block_beyond_the_limit_is_refused_before_its_data_is_read() { + // The block declares 10 bytes and holds none: the limit, not the truncation, is reported. + let mut w = Writer::deflate(); + w.block(true, 0).align().bytes(&[10, 0, 0xf5, 0xff]); + let error = inflate_zlib(&w.finish(), OutputLimit::new(9)).unwrap_err(); + assert_eq!((error.kind(), error.offset()), (&InflateErrorKind::OutputLimit { limit: 9 }, 6)); +} + +#[test] +fn a_match_beyond_the_limit_is_refused_at_the_match() { + // "aaaa" is 'a' and a 3-byte match: a limit of 3 admits the literal and refuses the match. + let stream = [0x78, 0x01, 0x4b, 0x04, 0x02, 0x00, 0x03, 0xce, 0x01, 0x85]; + let error = inflate_zlib(&stream, OutputLimit::new(3)).unwrap_err(); + assert_eq!(error.kind(), &InflateErrorKind::OutputLimit { limit: 3 }); + assert_eq!(inflate_zlib(&stream, OutputLimit::new(4)).unwrap(), b"aaaa"); +} diff --git a/crates/lumen-image/tests/writer/mod.rs b/crates/lumen-image/tests/writer/mod.rs new file mode 100644 index 0000000..a92fcdd --- /dev/null +++ b/crates/lumen-image/tests/writer/mod.rs @@ -0,0 +1,106 @@ +//! A deflate bit writer for the tests: it assembles streams bit by bit from RFC 1951 and RFC +//! 1950 as written, sharing no code with the decoder, so a test's stream and its expected +//! offsets come from the RFCs and not from what the decoder reads. + +/// Bits packed least significant first into bytes (RFC 1951 section 3.1.1). +#[derive(Default)] +pub struct Writer { + bits: Vec, +} + +impl Writer { + /// A stream that starts with the zlib header `cmf`, `flg`. + pub fn zlib(cmf: u8, flg: u8) -> Self { + let mut w = Self::default(); + w.value(u32::from(cmf), 8); + w.value(u32::from(flg), 8); + w + } + + /// The default header: deflate, a 32 KiB window, no dictionary (`78 01`). + pub fn deflate() -> Self { + Self::zlib(0x78, 0x01) + } + + /// `count` bits of `value`, least significant first: header fields and extra bits. + pub fn value(&mut self, value: u32, count: u32) -> &mut Self { + self.bits.extend((0..count).map(|i| u8::try_from((value >> i) & 1).unwrap())); + self + } + + /// A Huffman code of `length` bits, most significant first (section 3.1.1). + pub fn code(&mut self, code: u32, length: u32) -> &mut Self { + self.bits.extend((0..length).rev().map(|i| u8::try_from((code >> i) & 1).unwrap())); + self + } + + /// A block header: `BFINAL`, then `BTYPE` in two bits. + pub fn block(&mut self, last: bool, kind: u32) -> &mut Self { + self.value(u32::from(last), 1).value(kind, 2) + } + + /// Zero bits to the next byte boundary. + pub fn align(&mut self) -> &mut Self { + while self.bits.len() % 8 != 0 { + self.bits.push(0); + } + self + } + + /// Whole bytes, after [`Self::align`]. + pub fn bytes(&mut self, bytes: &[u8]) -> &mut Self { + for &b in bytes { + self.value(u32::from(b), 8); + } + self + } + + /// The offset of the byte that holds the last bit written so far: where a decoder that + /// faults on that bit must report the fault. + pub fn last_byte(&self) -> usize { + (self.bits.len() - 1) / 8 + } + + /// The bits so far, zero-padded to a whole byte. + pub fn finish(&self) -> Vec { + self.bits + .chunks(8) + .map(|byte| byte.iter().enumerate().map(|(i, &b)| b << i).sum()) + .collect() + } + + /// The bits so far, aligned, then the Adler-32 trailer of `decoded`: a complete stream. + pub fn trailer(&mut self, decoded: &[u8]) -> Vec { + self.align(); + self.bytes(&adler32(decoded).to_be_bytes()); + self.finish() + } + + /// A fixed-Huffman literal (section 3.2.6): 0-143 as `00110000` plus the byte in 8 bits, + /// 144-255 as `110010000` plus the byte less 144 in 9 bits. + pub fn fixed_literal(&mut self, byte: u8) -> &mut Self { + if byte < 144 { + self.code(0x30 + u32::from(byte), 8) + } else { + self.code(0x190 + u32::from(byte) - 144, 9) + } + } +} + +/// The second header byte that makes `cmf` and `flags` (the top three bits, `FDICT` and +/// `FLEVEL`) a multiple of 31 (RFC 1950 section 2.2, `FCHECK`). +pub fn flg_for(cmf: u8, flags: u8) -> u8 { + let base = u32::from(cmf) * 256 + u32::from(flags & 0xe0); + flags & 0xe0 | u8::try_from((31 - base % 31) % 31).unwrap() +} + +/// Adler-32 straight from its definition (RFC 1950 section 8): A is one plus the sum of the +/// bytes and B the sum of each step's A, both modulo 65 521, reduced at every byte. +pub fn adler32(bytes: &[u8]) -> u32 { + let (mut a, mut b) = (1_u32, 0_u32); + for &byte in bytes { + a = (a + u32::from(byte)) % 65_521; + b = (b + a) % 65_521; + } + b * 65_536 + a +}