From fa51fe8f096b5d9c3505ec681394be831aa07924 Mon Sep 17 00:00:00 2001 From: Joining7943 <111500881+Joining7943@users.noreply.github.com> Date: Mon, 22 Aug 2022 03:10:09 +0200 Subject: [PATCH] tail: improve performance of piped stdin Rewrite handling of stdin when it is piped and read input in chunks. Fixes https://github.com/uutils/coreutils/issues/3842 --- Cargo.lock | 1 + src/uu/tail/Cargo.toml | 9 +- src/uu/tail/src/chunks.rs | 430 ++++++++++++++++- src/uu/tail/src/tail.rs | 123 +++-- tests/by-util/test_tail.rs | 446 ++++++++++++++++++ .../random_ascii_24576_bytes_304_lines.txt | 304 ++++++++++++ ...ii_24576_bytes_304_lines_c_+16385.expected | 105 +++++ ...ii_24576_bytes_304_lines_c_+16386.expected | 105 +++++ ...cii_24576_bytes_304_lines_c_+8193.expected | 205 ++++++++ ...cii_24576_bytes_304_lines_c_+8194.expected | 205 ++++++++ ...ii_24576_bytes_304_lines_c_-16384.expected | 205 ++++++++ ...ii_24576_bytes_304_lines_c_-16385.expected | 205 ++++++++ ...cii_24576_bytes_304_lines_c_-8192.expected | 105 +++++ ...cii_24576_bytes_304_lines_c_-8193.expected | 105 +++++ .../random_ascii_8192_bytes_103_lines.txt | 103 ++++ ...m_ascii_8192_bytes_103_lines_c_+2.expected | 103 ++++ ...m_ascii_8192_bytes_103_lines_c_-1.expected | 1 + ...scii_8192_bytes_103_lines_c_-8191.expected | 103 ++++ ...m_ascii_8192_bytes_103_lines_n_+2.expected | 102 ++++ ...m_ascii_8192_bytes_103_lines_n_-1.expected | 1 + ...ascii_8192_bytes_103_lines_n_-102.expected | 102 ++++ .../random_ascii_8193_bytes_103_lines.txt | 103 ++++ ...m_ascii_8193_bytes_103_lines_c_+2.expected | 103 ++++ ...m_ascii_8193_bytes_103_lines_c_-1.expected | 1 + ...scii_8193_bytes_103_lines_c_-8192.expected | 103 ++++ ...m_ascii_8193_bytes_103_lines_n_+2.expected | 102 ++++ ...m_ascii_8193_bytes_103_lines_n_-1.expected | 1 + ...ascii_8193_bytes_103_lines_n_-102.expected | 102 ++++ 28 files changed, 3512 insertions(+), 71 deletions(-) create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines.txt create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16385.expected create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16386.expected create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8193.expected create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8194.expected create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16384.expected create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16385.expected create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8192.expected create mode 100644 tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8193.expected create mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines.txt create mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_+2.expected create mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-1.expected create mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-8191.expected create mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_+2.expected create mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-1.expected create mode 100644 tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-102.expected create mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines.txt create mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_+2.expected create mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-1.expected create mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-8192.expected create mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_+2.expected create mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-1.expected create mode 100644 tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-102.expected diff --git a/Cargo.lock b/Cargo.lock index 394b9b8cd38..87c13c407aa 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2814,6 +2814,7 @@ version = "0.0.15" dependencies = [ "clap 3.2.17", "libc", + "memchr", "nix", "notify", "uucore", diff --git a/src/uu/tail/Cargo.toml b/src/uu/tail/Cargo.toml index 98ab9314dfe..0f744b1ed67 100644 --- a/src/uu/tail/Cargo.toml +++ b/src/uu/tail/Cargo.toml @@ -18,12 +18,13 @@ path = "src/tail.rs" [dependencies] clap = { version = "3.2", features = ["wrap_help", "cargo"] } libc = "0.2.132" -notify = { version = "=5.0.0-pre.16", features=["macos_kqueue"]} -uucore = { version=">=0.0.15", package="uucore", path="../../uucore", features=["ringbuffer", "lines"] } +memchr = "2.5.0" +notify = { version = "=5.0.0-pre.16", features = ["macos_kqueue"] } +uucore = { version = ">=0.0.15", package = "uucore", path = "../../uucore", features = ["ringbuffer", "lines"] } [target.'cfg(windows)'.dependencies] -winapi = { version="0.3", features=["fileapi", "handleapi", "processthreadsapi", "synchapi", "winbase"] } -winapi-util = { version="0.1.5" } +winapi = { version = "0.3", features = ["fileapi", "handleapi", "processthreadsapi", "synchapi", "winbase"] } +winapi-util = { version = "0.1.5" } [target.'cfg(unix)'.dependencies] nix = { version = "0.25", features = ["fs"] } diff --git a/src/uu/tail/src/chunks.rs b/src/uu/tail/src/chunks.rs index 2704930935f..1da065a95b7 100644 --- a/src/uu/tail/src/chunks.rs +++ b/src/uu/tail/src/chunks.rs @@ -1,14 +1,23 @@ -//! Iterating over a file by chunks, starting at the end of the file. +//! Iterating over a file by chunks, either starting at the end of the file with [`ReverseChunks`] +//! or at the end of piped stdin with [`LinesChunk`] or [`BytesChunk`]. //! -//! Use [`ReverseChunks::new`] to create a new iterator over chunks of -//! bytes from the file. +//! Use [`ReverseChunks::new`] to create a new iterator over chunks of bytes from the file. +use std::collections::vec_deque::Iter; +use std::collections::VecDeque; use std::fs::File; -use std::io::{Read, Seek, SeekFrom}; +use std::io::{BufReader, Read, Seek, SeekFrom, Write}; +use uucore::error::UResult; /// When reading files in reverse in `bounded_tail`, this is the size of each /// block read at a time. pub const BLOCK_SIZE: u64 = 1 << 16; +/// The size of the backing buffer of a LinesChunk or BytesChunk. Some calculations concerning the +/// buffer assume that the target system's usize is greater than this BUFFER_SIZE, and therefore +/// convert from u64 to usize as long as it is known, that the value resides somewhere between 0 +/// and the BUFFER_SIZE. +pub const BUFFER_SIZE: usize = 8192; + /// An iterator over a file in non-overlapping chunks from the end of the file. /// /// Each chunk is a [`Vec`]<[`u8`]> of size [`BLOCK_SIZE`] (except @@ -81,3 +90,416 @@ impl<'a> Iterator for ReverseChunks<'a> { Some(buf[0..(block_size as usize)].to_vec()) } } + +/// The type of the backing buffer of the BytesChunk and LinesChunk structs. +type ChunkBuffer = [u8; BUFFER_SIZE]; + +#[derive(Clone, PartialEq, Eq, Debug)] +pub struct BytesChunk { + buffer: ChunkBuffer, + bytes: usize, +} + +impl BytesChunk { + pub(crate) fn new() -> Self { + Self { + buffer: [0; BUFFER_SIZE], + bytes: 0, + } + } + + fn from(chunk: &Self, offset: usize) -> Self { + assert!( + offset <= chunk.bytes, + "offset may not be larger than the chunk size" + ); + + let mut buffer: ChunkBuffer = [0; BUFFER_SIZE]; + let slice = chunk.get_buffer_with(offset); + buffer[..slice.len()].copy_from_slice(slice); + Self { + buffer, + bytes: chunk.bytes - offset, + } + } + + pub(crate) fn get_buffer(&self) -> &[u8] { + &self.buffer[..self.bytes] + } + + pub(crate) fn get_buffer_with(&self, offset: usize) -> &[u8] { + &self.buffer[offset..self.bytes] + } + + pub(crate) fn fill(&mut self, filehandle: &mut BufReader) -> UResult> { + let num_bytes = filehandle.read(&mut self.buffer)?; + self.bytes = num_bytes; + if num_bytes == 0 { + return Ok(None); + } + + Ok(Some(self.bytes)) + } +} + +pub(crate) struct BytesChunkBuffer { + num_print: u64, + bytes: u64, + chunks: VecDeque>, +} + +impl BytesChunkBuffer { + pub(crate) fn new(num_print: u64) -> Self { + Self { + bytes: 0, + num_print, + chunks: VecDeque::new(), + } + } + + /// Fills the chunks collection with chunks and consumes the reader completely. This method + /// ensures that there are exactly as many chunks as needed to match `self.num_print` bytes, so + /// there are in sum exactly `self.num_print` bytes stored in all chunks. The method returns + /// an iterator over these chunks. If there are no chunks, for example because the piped stdin + /// contained no bytes, or `num_print = 0` then `iterator.next` returns None. + /// + /// # Arguments + /// + /// * `reader`: A buffered reader with an inner element implementing the [`Read`] trait. + /// + /// returns: Result>, Box> + /// + /// # Examples + /// + /// ```rust,ignore + /// use std::io::{BufReader, Cursor}; + /// + /// let mut reader = BufReader::new(Cursor::new("")); + /// let num_print = 0; + /// let mut chunks = BytesChunkBuffer::new(num_print); + /// let mut iter = chunks.fill(&mut reader).unwrap(); + /// + /// let chunk = iter.next(); + /// assert!(chunk.is_none()); + /// + /// let mut reader = BufReader::new(Cursor::new("a")); + /// let num_print = 1; + /// let mut chunks = BytesChunkBuffer::new(num_print); + /// let mut iter = chunks.fill(&mut reader).unwrap(); + /// + /// let chunk = iter.next(); + /// assert!(chunk.is_some()); + /// assert_eq!(&[b'a'], chunk.unwrap().get_buffer()); + /// assert_eq!(None, iter.next()); + /// ``` + pub(crate) fn fill( + &mut self, + reader: &mut BufReader, + ) -> UResult>> { + let mut chunk = Box::new(BytesChunk::new()); + + // fill chunks with all bytes from reader and reuse already instantiated chunks if possible + while (chunk.fill(reader)?).is_some() { + self.bytes += chunk.bytes as u64; + self.chunks.push_back(chunk); + + let first = &self.chunks[0]; + if self.bytes - first.bytes as u64 > self.num_print { + chunk = self.chunks.pop_front().unwrap(); + self.bytes -= chunk.bytes as u64; + } else { + chunk = Box::new(BytesChunk::new()); + } + } + + // quit early if there are no chunks for example in case the pipe was empty + if self.chunks.is_empty() { + return Ok(self.chunks.iter()); + } + + let chunk = self.chunks.pop_front().unwrap(); + // calculate the offset in the first chunk and put the calculated chunk as first element in + // the self.chunks collection. + let offset = if self.num_print >= self.bytes { + // ignore a passed in value exceeding the number of actually read bytes and treat it + // like a value equal to the number of bytes. + 0 + } else { + // the calculated offset must be in the range 0 to BUFFER_SIZE and is therefore safely + // convertable to a usize without losses. + (self.bytes - self.num_print) as usize + }; + + self.chunks + .push_front(Box::new(BytesChunk::from(&chunk, offset))); + + Ok(self.chunks.iter()) + } +} + +pub(crate) struct LinesChunk { + buffer: ChunkBuffer, + bytes: usize, + lines: usize, + delimiter: u8, +} + +impl LinesChunk { + pub(crate) fn new(delimiter: u8) -> Self { + Self { + buffer: [0; BUFFER_SIZE], + bytes: 0, + lines: 0, + delimiter, + } + } + + fn count_lines(&self) -> usize { + memchr::memchr_iter(self.delimiter, self.get_buffer()).count() + } + + /// Creates a new [`LinesChunk`] from an existing one with an offset in lines. The new chunk + /// contains exactly `chunk.lines - offset` lines. The offset in bytes is calculated and applied + /// to the new chunk, so the new chunk contains only the bytes encountered after the offset in + /// number of lines and the `delimiter`. If the offset is larger or equal to `chunk.lines` then + /// a new empty `LinesChunk` is returned. + /// + /// # Arguments + /// + /// * `chunk`: The chunk to create the new chunk from + /// * `offset`: The offset in number of lines (not bytes) + /// + /// returns: LinesChunk + /// + /// # Examples + /// + /// ```rust,ignore + /// let mut chunk = LinesChunk::new(b'\n'); + /// // manually filling the buffer and setting the correct values for bytes and lines + /// chunk.buffer[0..12].copy_from_slice("hello\nworld\n".as_bytes()); + /// chunk.bytes = 12; + /// chunk.lines = 2; + /// + /// let offset = 1; // offset in number of lines + /// let new_chunk = LinesChunk::from(&chunk, offset); + /// assert_eq!("world\n".as_bytes(), new_chunk.get_buffer()); + /// assert_eq!(6, new_chunk.bytes); + /// assert_eq!(1, new_chunk.lines); + /// ``` + fn from_chunk(chunk: &Self, offset: usize) -> Self { + if offset >= chunk.lines { + Self::new(chunk.delimiter); + } + + let mut buffer: ChunkBuffer = [0; BUFFER_SIZE]; + + let bytes_offset = chunk.calculate_bytes_offset_from(offset); + let slice = chunk.get_buffer_with(bytes_offset); + buffer[..slice.len()].copy_from_slice(slice); + + Self { + buffer, + lines: chunk.lines - offset, + bytes: chunk.bytes - bytes_offset, + delimiter: chunk.delimiter, + } + } + + pub(crate) fn has_data(&self) -> bool { + self.bytes > 0 + } + + pub(crate) fn get_buffer(&self) -> &[u8] { + &self.buffer[..self.bytes] + } + + pub(crate) fn get_buffer_with(&self, offset: usize) -> &[u8] { + &self.buffer[offset..self.bytes] + } + + pub(crate) fn get_lines(&self) -> usize { + self.lines + } + + pub(crate) fn increment_lines(&mut self) -> usize { + self.lines += 1; + self.lines + } + + pub(crate) fn fill(&mut self, filehandle: &mut BufReader) -> UResult> { + let num_bytes = filehandle.read(&mut self.buffer)?; + self.bytes = num_bytes; + + if num_bytes == 0 { + self.lines = 0; + return Ok(None); + } + + self.lines = self.count_lines(); + Ok(Some(self.bytes)) + } + + fn calculate_bytes_offset_from(&self, offset: usize) -> usize { + let mut lines_offset = offset; + let mut bytes_offset = 0; + for byte in self.get_buffer().iter() { + if lines_offset == 0 { + break; + } + if byte == &self.delimiter { + lines_offset -= 1; + } + bytes_offset += 1; + } + bytes_offset + } + + pub(crate) fn print_lines(&self, writer: &mut impl Write, offset: usize) -> UResult<()> { + self.print_bytes(writer, self.calculate_bytes_offset_from(offset)) + } + + pub(crate) fn print_bytes(&self, writer: &mut impl Write, offset: usize) -> UResult<()> { + writer.write_all(&self.buffer[offset..self.bytes])?; + Ok(()) + } +} + +pub struct LinesChunkBuffer { + delimiter: u8, + lines: u64, + num_print: u64, + chunks: VecDeque>, +} + +impl LinesChunkBuffer { + pub(crate) fn new(delimiter: u8, num_print: u64) -> Self { + Self { + delimiter, + num_print, + lines: 0, + chunks: VecDeque::new(), + } + } + + pub(crate) fn fill( + &mut self, + reader: &mut BufReader, + ) -> UResult>> { + let mut chunk = Box::new(LinesChunk::new(self.delimiter)); + + while (chunk.fill(reader)?).is_some() { + self.lines += chunk.lines as u64; + self.chunks.push_back(chunk); + + let first = &self.chunks[0]; + if self.lines - first.lines as u64 > self.num_print { + chunk = self.chunks.pop_front().unwrap(); + + self.lines -= chunk.lines as u64; + } else { + chunk = Box::new(LinesChunk::new(self.delimiter)); + } + } + + if !&self.chunks.is_empty() { + let length = &self.chunks.len(); + let last = &mut self.chunks[length - 1]; + if !last.buffer[..last.bytes].ends_with(&[self.delimiter]) { + last.lines += 1; + self.lines += 1; + } + } else { + // chunks is empty when a file is empty so quitting early here + return Ok(self.chunks.iter()); + } + + // skip unnecessary chunks and save the first chunk which may hold some lines we have to + // print + let chunk = loop { + // it's safe to call unwrap here because there is at least one chunk and sorting out + // more chunks than exist shouldn't be possible. + let chunk = self.chunks.pop_front().unwrap(); + + // skip is true as long there are enough lines left in the other stored chunks. + let skip = self.lines - chunk.lines as u64 > self.num_print; + if skip { + self.lines -= chunk.lines as u64; + } else { + break chunk; + } + }; + + // calculate the number of lines to skip in the chunk + let skip_lines = if self.num_print >= self.lines { + 0 + } else { + (self.lines - self.num_print) as usize + }; + + let chunk = LinesChunk::from_chunk(&chunk, skip_lines); + self.chunks.push_front(Box::new(chunk)); + + Ok(self.chunks.iter()) + } +} + +#[cfg(test)] +mod tests { + use crate::chunks::{BytesChunk, BUFFER_SIZE}; + + #[test] + fn test_bytes_chunk_from_when_offset_is_zero() { + let mut chunk = BytesChunk::new(); + chunk.bytes = BUFFER_SIZE; + chunk.buffer[1] = 1; + let other = BytesChunk::from(&chunk, 0); + assert_eq!(other, chunk); + + chunk.bytes = 2; + let other = BytesChunk::from(&chunk, 0); + assert_eq!(other, chunk); + + chunk.bytes = 1; + let other = BytesChunk::from(&chunk, 0); + assert_eq!(other.buffer, [0; BUFFER_SIZE]); + assert_eq!(other.bytes, chunk.bytes); + + chunk.bytes = BUFFER_SIZE; + let other = BytesChunk::from(&chunk, 2); + assert_eq!(other.buffer, [0; BUFFER_SIZE]); + assert_eq!(other.bytes, BUFFER_SIZE - 2); + } + + #[test] + fn test_bytes_chunk_from_when_offset_is_not_zero() { + let mut chunk = BytesChunk::new(); + chunk.bytes = BUFFER_SIZE; + chunk.buffer[1] = 1; + + let other = BytesChunk::from(&chunk, 1); + let mut expected_buffer = [0; BUFFER_SIZE]; + expected_buffer[0] = 1; + assert_eq!(other.buffer, expected_buffer); + assert_eq!(other.bytes, BUFFER_SIZE - 1); + + let other = BytesChunk::from(&chunk, 2); + assert_eq!(other.buffer, [0; BUFFER_SIZE]); + assert_eq!(other.bytes, BUFFER_SIZE - 2); + } + + #[test] + fn test_bytes_chunk_from_when_offset_is_larger_than_chunk_size_then_panics() { + let mut chunk = BytesChunk::new(); + chunk.bytes = BUFFER_SIZE; + let result = std::panic::catch_unwind(|| BytesChunk::from(&chunk, BUFFER_SIZE + 1)); + assert!(result.is_err()); + + chunk.bytes = 0; + let result = std::panic::catch_unwind(|| BytesChunk::from(&chunk, 1)); + assert!(result.is_err()); + + chunk.bytes = 1; + let result = std::panic::catch_unwind(|| BytesChunk::from(&chunk, 2)); + assert!(result.is_err()); + } +} diff --git a/src/uu/tail/src/tail.rs b/src/uu/tail/src/tail.rs index 32ebb21b06f..40505c16dae 100644 --- a/src/uu/tail/src/tail.rs +++ b/src/uu/tail/src/tail.rs @@ -21,6 +21,7 @@ extern crate clap; #[macro_use] extern crate uucore; +extern crate core; mod chunks; mod parse; @@ -30,11 +31,12 @@ use chunks::ReverseChunks; use clap::{Arg, Command}; use notify::{RecommendedWatcher, RecursiveMode, Watcher, WatcherKind}; +use std::cmp::Ordering; use std::collections::{HashMap, VecDeque}; use std::ffi::OsString; -use std::fmt; use std::fs::{File, Metadata}; -use std::io::{stdin, stdout, BufRead, BufReader, Read, Seek, SeekFrom, Write}; +use std::io; +use std::io::{stdin, stdout, BufRead, BufReader, BufWriter, Read, Seek, SeekFrom, Write}; use std::path::{Path, PathBuf}; use std::sync::mpsc::{self, channel, Receiver}; use std::time::Duration; @@ -43,9 +45,7 @@ use uucore::error::{ get_exit_code, set_exit_code, FromIo, UError, UResult, USimpleError, UUsageError, }; use uucore::format_usage; -use uucore::lines::lines; use uucore::parse_size::{parse_size, ParseSizeError}; -use uucore::ringbuffer::RingBuffer; #[cfg(unix)] use std::os::unix::fs::MetadataExt; @@ -1427,70 +1427,67 @@ fn bounded_tail(file: &mut File, settings: &Settings) { std::io::copy(file, &mut stdout).unwrap(); } -/// An alternative to [`Iterator::skip`] with u64 instead of usize. This is -/// necessary because the usize limit doesn't make sense when iterating over -/// something that's not in memory. For example, a very large file. This allows -/// us to skip data larger than 4 GiB even on 32-bit platforms. -fn skip_u64(iter: &mut impl Iterator, num: u64) { - for _ in 0..num { - if iter.next().is_none() { - break; - } - } -} - -/// Collect the last elements of an iterator into a `VecDeque`. -/// -/// This function returns a [`VecDeque`] containing either the last -/// `count` elements of `iter`, an [`Iterator`] over [`Result`] -/// instances, or all but the first `count` elements of `iter`. If -/// `beginning` is `true`, then all but the first `count` elements are -/// returned. -/// -/// # Panics -/// -/// If any element of `iter` is an [`Err`], then this function panics. -fn unbounded_tail_collect( - mut iter: impl Iterator>, - count: u64, - beginning: bool, -) -> UResult> -where - E: fmt::Debug, -{ - if beginning { - // GNU `tail` seems to index bytes and lines starting at 1, not - // at 0. It seems to treat `+0` and `+1` as the same thing. - let i = count.max(1) - 1; - skip_u64(&mut iter, i); - Ok(iter.map(|r| r.unwrap()).collect()) - } else { - let count: usize = count - .try_into() - .map_err(|_| USimpleError::new(1, "Insufficient addressable memory"))?; - Ok(RingBuffer::from_iter(iter.map(|r| r.unwrap()), count).data) - } -} - fn unbounded_tail(reader: &mut BufReader, settings: &Settings) -> UResult<()> { - // Read through each line/char and store them in a ringbuffer that always - // contains count lines/chars. When reaching the end of file, output the - // data in the ringbuf. - match settings.mode { - FilterMode::Lines(count, sep) => { - let mut stdout = stdout(); - for line in unbounded_tail_collect(lines(reader, sep), count, settings.beginning)? { - stdout - .write_all(&line) - .map_err_context(|| String::from("IO error"))?; + match (&settings.mode, settings.beginning) { + (FilterMode::Lines(count, sep), false) => { + let mut chunks = chunks::LinesChunkBuffer::new(*sep, *count); + let mut writer = BufWriter::new(stdout().lock()); + for chunk in chunks.fill(reader)? { + writer.write_all(chunk.get_buffer())?; + } + } + (FilterMode::Lines(count, sep), true) => { + let mut num_skip = (*count).max(1) - 1; + let mut writer = BufWriter::new(stdout().lock()); + let mut chunk = chunks::LinesChunk::new(*sep); + while chunk.fill(reader)?.is_some() { + let lines = chunk.get_lines() as u64; + match lines.cmp(&num_skip) { + Ordering::Less => { + num_skip -= lines; + } + Ordering::Equal | Ordering::Greater => { + break; + } + } + } + if chunk.has_data() { + if !chunk.get_buffer().ends_with(&[*sep]) { + chunk.increment_lines(); + } + chunk.print_lines(&mut writer, num_skip as usize)?; + io::copy(reader, &mut writer)?; } } - FilterMode::Bytes(count) => { - for byte in unbounded_tail_collect(reader.bytes(), count, settings.beginning)? { - if let Err(err) = stdout().write(&[byte]) { - return Err(USimpleError::new(1, err.to_string())); + (FilterMode::Bytes(count), false) => { + let mut chunks = chunks::BytesChunkBuffer::new(*count); + let mut writer = BufWriter::new(stdout().lock()); + for chunk in chunks.fill(reader)? { + writer.write_all(chunk.get_buffer())?; + } + } + (FilterMode::Bytes(count), true) => { + let mut num_skip = (*count).max(1) - 1; + let mut writer = BufWriter::new(stdout().lock()); + let mut chunk = chunks::BytesChunk::new(); + loop { + if let Some(bytes) = chunk.fill(reader)? { + let bytes: u64 = bytes as u64; + match bytes.cmp(&num_skip) { + Ordering::Less => num_skip -= bytes, + Ordering::Equal => { + break; + } + Ordering::Greater => { + writer.write_all(chunk.get_buffer_with(num_skip as usize))?; + break; + } + } + } else { + return Ok(()); } } + io::copy(reader, &mut writer)?; } } Ok(()) diff --git a/tests/by-util/test_tail.rs b/tests/by-util/test_tail.rs index d4755a48832..d78795d62fa 100644 --- a/tests/by-util/test_tail.rs +++ b/tests/by-util/test_tail.rs @@ -30,6 +30,10 @@ static FOLLOW_NAME_SHORT_EXP: &str = "follow_name_short.expected"; #[cfg(target_os = "linux")] static FOLLOW_NAME_EXP: &str = "follow_name.expected"; +static RANDOM_TEXT_BUFFER_SIZE: &str = "random_ascii_8192_bytes_103_lines.txt"; +static RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE: &str = "random_ascii_8193_bytes_103_lines.txt"; +static RANDOM_TEXT_BUFFER_SIZE_MULT_THREE: &str = "random_ascii_24576_bytes_304_lines.txt"; + #[test] #[cfg(all(unix, not(target_os = "android")))] // FIXME: fix this test for Android fn test_stdin_default() { @@ -2435,3 +2439,445 @@ fn test_illegal_seek() { ); assert_eq!(p.wait().unwrap().code().unwrap(), 1); } + +#[test] +fn test_pipe_when_lines_option_value_is_higher_than_contained_lines() { + let test_string = "a\nb\n"; + new_ucmd!() + .args(&["-n", "3"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-n", "4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-n", "999"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-n", "+3"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-n", "+4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-n", "+999"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); +} + +#[test] +fn test_pipe_when_negative_lines_option_given_no_newline_at_eof() { + let test_string = "a\nb"; + new_ucmd!() + .args(&["-n", "0"]) + .pipe_in(test_string) + .succeeds() + .no_stdout() + .no_stderr(); + new_ucmd!() + .args(&["-n", "1"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("b"); + new_ucmd!() + .args(&["-n", "2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a\nb"); +} + +#[test] +fn test_pipe_when_positive_lines_option_given_no_newline_at_eof() { + let test_string = "a\nb"; + new_ucmd!() + .args(&["-n", "+0"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a\nb"); + new_ucmd!() + .args(&["-n", "+1"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a\nb"); + new_ucmd!() + .args(&["-n", "+2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("b"); +} + +#[test] +fn test_pipe_when_lines_option_given_multibyte_utf8_characters() { + // the test string consists of from left to right a 4-byte,3-byte,2-byte,1-byte utf-8 character + let test_string = "𝅘𝅥𝅮\n⏻\nƒ\na"; + new_ucmd!() + .args(&["-n", "+0"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-n", "+2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("⏻\nƒ\na"); + new_ucmd!() + .args(&["-n", "+3"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("ƒ\na"); + new_ucmd!() + .args(&["-n", "+4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a"); + new_ucmd!() + .args(&["-n", "+5"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-n", "-4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-n", "-3"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("⏻\nƒ\na"); + new_ucmd!() + .args(&["-n", "-2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("ƒ\na"); + new_ucmd!() + .args(&["-n", "-1"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a"); + new_ucmd!() + .args(&["-n", "-0"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); +} + +#[test] +fn test_pipe_when_lines_option_given_input_size_is_equal_to_buffer_size() { + new_ucmd!() + .args(&["-n", "+0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE); + new_ucmd!() + .args(&["-n", "+2"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture("random_ascii_8192_bytes_103_lines_n_+2.expected"); + new_ucmd!() + .args(&["-n", "-0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-n", "-1"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture("random_ascii_8192_bytes_103_lines_n_-1.expected"); + new_ucmd!() + .args(&["-n", "-102"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture("random_ascii_8192_bytes_103_lines_n_-102.expected"); + new_ucmd!() + .args(&["-n", "-103"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE); +} + +#[test] +fn test_pipe_when_lines_option_given_input_size_is_one_byte_greater_than_buffer_size() { + new_ucmd!() + .args(&["-n", "+0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE); + + new_ucmd!() + .args(&["-n", "-1"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture("random_ascii_8193_bytes_103_lines_n_-1.expected"); + + new_ucmd!() + .args(&["-n", "+2"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture("random_ascii_8193_bytes_103_lines_n_+2.expected"); + + new_ucmd!() + .args(&["-n", "-102"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture("random_ascii_8193_bytes_103_lines_n_-102.expected"); +} + +#[test] +fn test_pipe_when_bytes_option_value_is_higher_than_contained_bytes() { + let test_string = "a\nb"; + new_ucmd!() + .args(&["-c", "4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-c", "5"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-c", "999"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-c", "+4"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-c", "+5"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-c", "+999"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); +} + +#[test] +fn test_pipe_when_bytes_option_given_multibyte_utf8_characters() { + // the test string consists of from left to right a 4-byte,3-byte,2-byte,1-byte utf-8 character + let test_string = "𝅘𝅥𝅮⏻ƒa"; + new_ucmd!() + .args(&["-c", "+0"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); + new_ucmd!() + .args(&["-c", "+2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only_bytes(&test_string.as_bytes()[1..]); + new_ucmd!() + .args(&["-c", "+5"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("⏻ƒa"); + new_ucmd!() + .args(&["-c", "+8"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("ƒa"); + new_ucmd!() + .args(&["-c", "+10"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a"); + new_ucmd!() + .args(&["-c", "+11"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(""); + new_ucmd!() + .args(&["-c", "-1"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("a"); + new_ucmd!() + .args(&["-c", "-2"]) + .pipe_in(test_string) + .succeeds() + .stdout_only_bytes(&"ƒa".as_bytes()[1..]); + new_ucmd!() + .args(&["-c", "-3"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("ƒa"); + new_ucmd!() + .args(&["-c", "-6"]) + .pipe_in(test_string) + .succeeds() + .stdout_only("⏻ƒa"); + new_ucmd!() + .args(&["-c", "-10"]) + .pipe_in(test_string) + .succeeds() + .stdout_only(test_string); +} + +#[test] +fn test_pipe_when_bytes_option_given_input_size_is_equal_to_buffer_size() { + new_ucmd!() + .args(&["-c", "+0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE); + + new_ucmd!() + .args(&["-c", "+2"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture("random_ascii_8192_bytes_103_lines_c_+2.expected"); + + new_ucmd!() + .args(&["-c", "-0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_only(""); + + new_ucmd!() + .args(&["-c", "-8191"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture("random_ascii_8192_bytes_103_lines_c_-8191.expected"); + + new_ucmd!() + .args(&["-c", "-8192"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE); + + new_ucmd!() + .args(&["-c", "-8193"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE); + + new_ucmd!() + .args(&["-c", "-1"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE) + .succeeds() + .stdout_is_fixture("random_ascii_8192_bytes_103_lines_c_-1.expected"); +} + +#[test] +fn test_pipe_when_bytes_option_given_input_size_is_one_byte_greater_than_buffer_size() { + new_ucmd!() + .args(&["-c", "+0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE); + + new_ucmd!() + .args(&["-c", "+2"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture("random_ascii_8193_bytes_103_lines_c_+2.expected"); + + new_ucmd!() + .args(&["-c", "-0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_only(""); + + new_ucmd!() + .args(&["-c", "-1"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture("random_ascii_8193_bytes_103_lines_c_-1.expected"); + + new_ucmd!() + .args(&["-c", "-8192"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture("random_ascii_8193_bytes_103_lines_c_-8192.expected"); + + new_ucmd!() + .args(&["-c", "-8193"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE_PLUS_ONE); +} + +#[test] +fn test_pipe_when_bytes_option_given_input_size_has_multiple_size_of_buffer_size() { + new_ucmd!() + .args(&["-c", "+0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE); + + new_ucmd!() + .args(&["-c", "-0"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_only(""); + + new_ucmd!() + .args(&["-c", "+8193"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_+8193.expected"); + + new_ucmd!() + .args(&["-c", "+8194"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_+8194.expected"); + + new_ucmd!() + .args(&["-c", "+16385"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_+16385.expected"); + + new_ucmd!() + .args(&["-c", "+16386"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_+16386.expected"); + + new_ucmd!() + .args(&["-c", "-8192"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_-8192.expected"); + + new_ucmd!() + .args(&["-c", "-8193"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_-8193.expected"); + + new_ucmd!() + .args(&["-c", "-16384"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_-16384.expected"); + + new_ucmd!() + .args(&["-c", "-16385"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture("random_ascii_24576_bytes_304_lines_c_-16385.expected"); + + new_ucmd!() + .args(&["-c", "-24576"]) + .pipe_in_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE) + .succeeds() + .stdout_is_fixture(RANDOM_TEXT_BUFFER_SIZE_MULT_THREE); +} diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines.txt b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines.txt new file mode 100644 index 00000000000..d8f4feecb07 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines.txt @@ -0,0 +1,304 @@ +J4oQ6fxiqTHDbuEkMmoaSGaIUsZEOOdQOyvYnZ1YLQpWlV7r31y2xe68plK5I1xR12wTDdoE7rxe2eUKMPCBTVxVNH8bY228GJHp +lR6GhgHuxsMvcYvSabj9kCB4PqGcvfazUkm3MW2271kJu7LhYRjMpsSlzN7WrQJQqiEgtTItHnsxiSqp1P1gd4MDveEtePk7Draw +IdV9Cf7MCJK09ndDt1aJH2GFHDnzopgemQVEdD +bDAGoTWu0fMT9siH61yKIz2II1oVyBx9g2prC8U9AlGuf15WcVK95NMxLmZrmyDtA +LwOtKZ4nVn3g7xmPVTN2Kg5n6O9Yl76O3T22Q9mVqZt4YpFrK1xGzpqjxBNUdJDsvawSCNSNEA7AMTzYSrYpPpPt2P9iyx2MvpNR +X8tlk4pRgQjuoXKEp5TuFF3OuIFY5XXYJQymjWLIDGcxSjjI6xEqdU8CMN +YMJJs74SPsjiOwNAK2VpinYb1QtwXPqVdGfbGg8VQ5o9QnOcVCGvQyVbRpWBo or0F9E e9xo7i8l5UM4Azm Tq8uMIWI9 +9XfvyGGMs DP7COeWrqdFQNTo8Pbv7XadRB2LcvQ6SlR6gwd8VUN7dyMdOkZLV4Jb7VT f4NIFMiRwVecGp +WQXKXeThT2qAGMsXSXefIvXqpoVjbjeexj79h9Mj9xoBfRASf3nYHB0icQAg9RfpzAAh34ozWgmUjqLF4MF00he5EGIOHsRTeoEu +nSeUSahCLkcHJ3ESVXjLIUCG1p5QSNM1RECulAEcMfMuUuSRwO5iVVDXLSkHPzHPg07HhsLhfVjuinFhZNvmb8xI5D2 +6MW8GNggwEDB2bX9epFvZNPx47GvVINAs +UJhLmBGjBGb6PsbrvKKY0GXeVVaMCUMIK8qlCpWRnmTUkjJ0SwQ4KxZb4fdOKCEH0QZDZOikYWMvc8Y9IJq3t +ljByUTerOapn3UbSsaqaLl12SwePUY1Cle2EZUfXmvjcO8bVvUg7LB4v06ai7QFZxpVvUrbxlnzVXInk0T62JJ23qxWrCwiWgRa3 +5DEXGaWwwuWOlPyzNBslkiaqPxWRL4zHeyqjO3A +JcHL0yolKdeNza8LtNCqzstf6t2YD24p24nHQNT4fU3WnjYZkWQIjCZQuZEXJG65p4Rxa9iMHTiiLxO +r6TD0TobCVWvsOvbuewX6457GdS4RO2JnlDckEeqxkCofrXZxbUN29IixwTTS5sQOQnbkoIbd9m8dO63WaxBNl97zQxhcvYqy7kk +u9qI168NZSKAsNDiY93nqPoOdzlsFaadHvBRBcW1XCmM6b6xhd7BXA33arsomRHBrybN2tqHtmSUMdU0f64N4AQDRg7yxgf2Qkgn +9RLYDwmrW6SwTqMSUBV8Xh09mnwOYInEIfnIQxBZhBQlIW7QmFBqWdDlNt3tQC3ji +4bZjdOzgqIIDLrbjEnrTFXOkyKvgC84WPul0mzVhZiZoV5xANWeXgsA4dwbiM 6WIVegaAxtVWnfdOmukoEhWGH +4DdaktQoh7HHi4g7Q7X8bEm9I6eOLhrXRqn7NWkX +mKUEW0CUTDGrCR4dEmW8PbGveLR70d0gD45mwoR8ivpQrGHBiBKFKjhTZosG4RCN7GJInO4JnMSlO935SX8qoXIEVcCtjdTvTWZb +oaj8njqe1WTCkfnZX0J7FfxH3g1V2vdw7uqAkP7YmUzx7Gie5432XuxwKzzGu50BwJre5AJ9GHl8r2BMuv77IdBNlp7hnafTlIva +Nh8pWJwSEXwrg +yVATXJX68rwMo41rPisbRexAvKfsyizVJwVt5g32b4q03NHEVEpHmQCUgJUMUze26EIU5aCy1ZurtFXWLOSNNxs2SOOEoFdN6KKc +08q2nhdrQ oovQsOCZk1wd7k +5p6hXKZ3ACq6Cu4Ad8MnKSlMOilFbNOhCqUST2YKY6ET0GvX2UuXaXlMEkimrLAomnPMvlJctZPAygx1X7pDe +sMOQOGnRNucYeICZKh2Zv1ecg6IA93VKY36QLoEhWkoE3gIoQFonh6PNs701K1eH8mL5qnlENaWexVJTd9bHVvSM8iEfUY2Bg7gc +amGTM2iiiefj8A2JjjDgHcMzW0kGnmLG3q5gPJF6D9RJV8kw35CBkKv1L4AZMUMtVKzNjKE4Q61l3HBfNUPqLDlF1aa97yB464MX +lzvXIpc1mWceFWPLzziai5Pqw1 tbtY8jyxC29pMCW2pzY1o2hK3zfHm3pQP7kG +TdlJ468GKpqfR7ALEyL3UgIiM88LI9A0RjXouOEZ6ZIPl2iFYU8CuT9O 9han5ROjXOOO7qiu6WgAIXi +BYwTfRSnCi1R4k8RIgfEx4DRcSXiygBf0xHPzm7iGG 4h NSXoSaV1R4nF3fT8hScc3dYl +iJoFdbYJXf6yL6cg8hVynqs1m7lGNUMrw8a2pgnCHAy +ojqFHZzc6scJsLtAcPkpa3OUR6JdHABOk40OdBm704VuLg05TbMC8daDKY0Xb6MdHdNoHjby4jLCEsU4ZOpqluwiGlEoCEhS +lvXn0B1wr0EMN2V3gLr f9m6b45r952K450PA0G1D +SrwHLTw9r3fmJWBhuJptCBXFTh5ogT4l3WiaIAEvmTyc742DgsB8qvx9SFSKGwS8EQtrEzIOEuDycNmQkY2HSjvhod5kdAnAharQ +DgHDpB XwbHpgkF6GnevICk9CzeicW7ejE34MyG7Zls99d2MhUlaIsEsUH9DOMVdTdrQpd3AmZAktNF66e1 +Tuk0IVg2Ydv97QrO958rC4KzRsqS29n0SHiD85UouIaQKdE1L7mVBUghMr70XlqMLw9tINkjS75mLYA +dMjrvrXlvJAwTPMe49SlitQLRol06OWC ojS b00IJOoIJJKgbN ufw7IKkMsphU0MdPfuU wGbH0Nfymwhy6udv h2deKFxbV +DYUQ84zpLDThoBClPqMnaKTcRHT1zWL1hv0ir4PjF8FUGHKAAe9Ol35y5XiaDY6vyowmusm29fkS1IgESiDJivRE89KthOeSPDGS +4dmxKagasI05Ny6qzslXkPqoTlsHnN56val EvvPdEZe79MpnPj6iAyvobUDcn0W4NyhwQNTD5hoPBhL7215mpK +8FBvhjbWvFEhPpLMv70txCIZ38uu0qg UZILFGPlXatAu29fiILbA32ojP8dyop7EkMLVMK9IgcLsPBTw6tm8Ic87y71 +fIED6GWYNYozuCAHlL6z0LMj0eidbRsIX3Jy4Mz1m4MtPWOXmjgZXbkhL +Ev0ERzawuimBTeFKlXvSlTjMP3sOUj9caZowuFLX4noZKXPMVVgMXvnMBl1xwbCg7E2yvbWaH3ruqJH7RMXff9FYeIji8yF4sTDB +ujeDyqJqySTpbNkJ8ByDbyabqc5uutUhwpTbaljn8ss9QzGJYD2JrQTDZW4xcCIduGBufY862WbgE7HiL4cGBDYnKfhzox59VCtG +LyengubNpNecXP6u5hjQpY1idKdqCYC3jRU0HcAqk590hsxMwW4YKzgUvdTjPUkHHbi04Hns9272wYsDzYhXtTCLs40F3XKTka0e +K47uiWwlm4SDXUpoVupwCnBBDCUx1s7mraSePlHrEtreDBJD6DlbVfOYoWHzVWUW7XwczOd9UwU7wNyZxApKvoR89oYXaBtGEJ4C +5GI9j3GHcR 2BLyoumh3nGLQy2oUeasWAOCyFGzm0RscKRWYvTav8jQOjSgxWTjTxXG +4XoElg0rkiQ3HCW7GgCSDvcGDKS8Npu5sOIihppBRnIyx4OZDpwLhmzJfxbMJbnIPRNuk6GfBvgS hZ8MBxHhVW OhMLWGV +FtlDbZKyiaN1dwljcS5NKLTwL1xCBi3WkZ11 yatKBBwUTJits0PzR8V7UlDUXKzPqpefTQuw7B99JwUrQPDz2Bn03e05NXx31 +eB0qzoAVO470hDHa6G17fBenDm9YAvVMJaeqXqZUZNAOtbsddPo4EJRE9GPbgeRGaUzpmjL2DS0SgLrT1Bb0k Y +76nNUndzbxAz0WpPVRebZb61UKAaVRQm +K5gb71TkqSE7TNYyP1erCTv9dHhzgI2i6omHU5Oad4IwWMQZbwHRQOo1NSwqHG9qhjSiDUNb +7a0JNBLotxxAuny1qnnNE6eJUnWuqApL73j6qzXuaGlSzhm5R7qPjqHHSOeOsLX3uET9JLBQQfHoYC6t81WFaYj4UhrsA3WNiW2D +1ehCPHReFTNDtCPNH9gTBtd40vC3S6b3w7nXec3fE1ZDYT8ry5YeZYqPDz9DIJniEyqRr76gxeduHvhwC +TZwOS1bZr32TItefc4dG9bVG2VpfgD7zVM20SPxWlIdkTXxEDFAvg agcz8LIfBqz4jHr6p +wtG0JEtXMWWIfLvVML7DT8NluPzBey9QyhtTgYyxYGx93truoReslHMjtLpKyFxDWz30m8MEL1D4Ch86ltjybsARupZif3IyV6MA +teM1Um2wASkZZpRBcYWFxmsTah57OJMq9zWyyC2iFx1jshAhXeBqg8bkUV5EO5PAxGZ8evXWsREZ +51fl3ymZu0fra6sbTrJCjXFfTYFM0g8Foamoe N3 l2IXbNFOxpSm2QVFxuaV WJT0JlW +qkLc3j5HCGdOibkCJVz2orsQ7AEr1IHFb9oK4CFWjxPDtOxIuQQHmiyHaIlfiwDIx6AJcKrNRWcB1qGupUhQeE0dY9QZD3O +L66YuALn2YJ8Sdwhsaqm9hh8yN9cTh0AYU9Fm9qLOEczlxCzPMUAHVXSAZpnbkEjZAJKiIHA5hi4unZ90mwreQDX1SilFYOVTY0M +kPEWphf1U6UugF8RYwS0cU0ESLuQnxpQbKsbNI90qWJsMOToRXa49J0YKWuRppuZDsXAucO9tD8xHgXnq824FYQvKdBTdUCTc59H +In33xgNgQtWsUFrIt4436zfjiZSlgHMcOm7311i9b1kZLYG0hdr8 aydTC gPtNj4kKxojwdxZk81OVFHjNYtkrs8K5KW +bKUyv0a7x2hY52ebafP3qIDqkDneehvtVzdKDNiZeePw BHyh6ZCzVY 1WqvYSTIwBXFQ D5dJuScKJuByAkHtrAc2RNMD +LEDQVgwv9xBdRqiWa8Z6UmG4sdDj EmidDdlPFdmNKE0FaVOrZV 2MmhEcTmUgFIKCxw2DYbKpQcn1whTxEC z4FRFnxk8toL +4Btu8k9QJbxyzpKquJkfIL4agcyu1SiyTtM +ecOHStkGkwMjOfnmhUGEL85COIEZFEl6DkiHs5iTNvYNXNYz0LEEEq9QdkSlfo4Q5eEVeboxqbsaSs5JnA9XhZm6GdeYptnHfLwZ +7C vSMNUDAMDGHBjYh0GwBsA RBnQqKDSC3gOlvyLMYCevdUjK3yA84EmLvZ68wg9HHjWiOE8u05zr +dJkz5eTDH1iBUxOFKBlL0HBFvKVota5opnuDTCg +s1EGHPHtVjZqnBupfDU2gCZa5X6ETHTd1IDxh1OKgVPNpxHOU1u06snilMkxJRO9C6vWJcTzqCf7kMY2jaQqI9L2J8yVVpSqjW0s +eadd5TQmhmX SqcyX8qdUQCn5FgsOXRGY9DoQUEnKS9jh8CdcwPN M5Jg4QFG +6Zu0I3PUuVKNxkpK9GTYmF6tDmk0PDjituCuuFv9T5CPtACYNxR4Lla +TAlDA4b4e10AIwKjNJOB3UpjDhcZmVZQjUg5wc2s348W0kNIVFKNQ9ZeJWLbG9nPg0Oi2GShGk7Inzm0RccECTtXTfcvFCsux6N4 +0RIo7ZMEENN3rKNcQRNQewI9M0eU4FKC vdEV3dXcKHGIvWESC2hA2OIOSO3hfGKR7Qatkws1EAXXD +pOPlJgz853NtQMFI1vJ87A8GHpYIm xtoBxOqXvqgasg1k0lvawezzO5cvfJcbuJmNCdERJxP5WC8zngTEX1 +6DwSQuV8mhwQtPT0iERyQYeE cdbqJOTGEuwnUlBwKUa78EwKZf3kw gR1Ss4BHQhHXd 2kPkD +4MDk8puPDmibPcZtPcu541Y9BEbyiaNI7E6g98mK btVAKSrqvocNEBTh6XYHJbgee8 +pdntzVjwk4BSXSNZpzBKnKFa9bSWGTDbzKYIXl0iBsn625EgQaIlhxrCamcaHfkMPEjb0izMw2fExA7PRHjZ4tiijDMpCMbocWWY +o274WWap1jLtgpEVaMRPOeJ1bHGrquBWN2YPfQCk6NeXShgC4D5fZ12hofJ6ScIh0NRNjl7wgQX4rSdc3NeWgXABb4Tv1PBPIjy4 +AugAqkt0p2iF3WzehKNCU53csmeH8Bzn5db92GyrYEdJPeDGLuBvp2J0tGQfPqCWKQdbvFwQMpK iJRB56byKSd9M +QNRzCxGNkgdswpe1jexXQD0anS9euxN 78Qw9ENQuSUNsp15xW xkdfQNnrtdYUYYQ +Msc15WA42U1flB8uVVMENsnAUkIoAV5kW7DsQ0pXae rJNYuG6XIAKCtY2G697KaDoV03nPSTIwdMgLZJPRGEipkIWyKVmellIe +QWxOUw6m0vHkZKGnp5qyinKZz1xBtbM7HUQdPb0BSc6jRXDpTutxuhHM0WHQTejBhdQeOtzZ bc zxnKthkXH +x33H1hITTDUD44IBoKyEK8W4HGS4ClbABxhDg38qZnS4CynfLcQumOIuytArK5PUq2zJg1Z90AqkYCNVe52uCdbVomFjIiTdI3ww +5 L gMqFFwZlcln0htEcUE2exoUxT2bGbwhWHXH2gFjDnXiTv6yIBapBNoC cE1i4ZOWMM4P +XEzMFgRy0Sk91KNkUbqOcKZ8ilL7kkpp9xJvNU4NMOpJvicNXaD9vGewLQrHlmi7GAklQwgxxtGg1F7HOs3iDAiuxA4NvYNfit +Xu9hw9kzDId7fhbdQwnByNzoGQMb4JXpj3HKJV6zCji2ZSjd4z2r9CGyoSvIL9ModwzkTEsU3JoSPNR +an0Bjr3kKxmF6TFLV3hQFUEzjuZ +EbgntoQdcxa5ejRRj5RaL5xQh4DS58Y5WD5mdO51mO9r6OeEDlvh8XD9WJrczTKaFmL9kyFSFJiBywZhWbtqICPIX5A86jt3RanX +ioEBdOhAAyCJdZPWQc9A01IHnnXxduRyIXUj6mPUMEozF4D3pmwNL6 hNPhGkKKm5KeDEPv7 +vQmixtzVX75oXcrDzh5f0x2rz5lvRB63xIOyF0WW761yT82gtrb +KcQ79Ai1FMUPNtrlNaEtU1CS9XXVXz4KKnScAUOJ0dpeqq4b2peKB39gAxANIXETCbZUrgHUPdyPOJcBsU1BxnyvnZ14nieQbur1 +5PtE1YSPHbUoH7jPYxMrnh7RkyeR4gtlUcxCrXsDIS3VBb9smAyAK9MKVryybIjZ8EotfSLo1jMbxAGeqEo34VA5ds aiGo7s +E37V0nnm1itRo2uBCKAJBxOhRSEZL0QZIRD3zPsgbXdE9N7gZjOGbMZQ00k2FiBKxTh5FsJ1GEZSnKuCyoTbGUUghHXzb9ZlqZ0n +75T3rJaFjNt66s6kJiC060rAshKtI5VvQPfiI5uL4n6EprWwGKBWpI1jM1HziuDR2rYNVJaQq +brR80YVAbPzrU3hIggLw0gIqM5WNfknHMZRjtjHzYQ0LGw5qAkUYSn0LQOYpbTbzvLB81tpqb43l8C5 +7HPL1RjflbxJRpltWxTjRQayzTVcp3No3qXSe4PhKJVQ9Iull0OZzVSdgRwpjN5CS48iuSePdWl5Dz9zheDm2pQ +1Bd8zOlDyrKNbQrjaKTA9wjuQ0qSrbp4YuFwiZ8boLk40vVbdLRab6ufV7lTd7rVuemEJJE +RLmjOiiXfaXN8wjfOusp0CtXw3TUGvH3Ps68 BbL0RuC6Bg9ZmXxhyUySy8kSt EJeiVLDIcGqCx6wYbqZhSkq6gRW +qCrA7LNdy1RqE6FyTIR3fN9A2Y1K95k5CKzdeas +g4LylIj3P1DEn07KlkKA2MLEcRhipcJsk4hwSIwvDOIkOjlRwwmK7HjBjYzeS7aOGq9mEhb5PbevpDVgBBKNIYEb4HhrrfixUC8j +J2 PNukXTyPowk2P490ZRC hjIqTv3QZxI7 wrsa0rJ8ixaNmZ3Za evP5y6eRvwSwJng787yQzpVi3wCDBw XrEPBJ0 +t2BMpq3evy3ELNduHoifzv6jkN0gJy9o +99sUZ34ro19oJd3UTlLLvi8h8vwToC3ijOEXhY8abO4dCMZUhwj8QlYdDC0JmtAXLO9CEZ0dWZXAMvXgDaorn7CDVBks2Qa7aMkN +1JClm9DlcPR65EKgtPeh +wdteBwA8oEHKRttRIEGI8IstPh2s75Sc9mg0LFG4tn256bBycdcJu4yj6bjBYN13U2dsKkrsJuonekqCOaTTtKudcIwAqRFnZYSa +eXQuRchTkAoQQdZMOejbLczo975o4h0rnt0UvAgU53n +8BYujbW5W2X50yUfshDCtEra20Nx9rJnMAtCkw8QgfECDM988y4A5FGw1sOSyaNch4 +Y47fv7VGVhfl9NG9ByImguZRrYZ3En0DYy2P0G1ufy7xplzshenzxNEjwTe3UR9G83VUs6obeSVCYBAo7pBmaQxH 9f5f9Mv +4oC5X0WDLvadtlM0NNmyDKYfzgw3JTGXDzPGVl7WkL5hsec6MbwS6l0Q7ruX0WtU1WVD8vyCBmVcr2q9DtmgHqclSbMoHXokGFkY +knfOZFLg9DrRkWp3VZfVLYKgsi6pCv 9J7JUWTWxRXLpSszJpKvQbbLa1BYpw0hI3LwgEbX +6ttL77Ak2kox3W9QqdzwQLmTh45n1rwe2daWBRpzwOq33LEBG1nwOlPY5tve0iH5z4T2Vs7cBj6BrOFc8OgS1RXygUURmkmZvYC9 +7XuL HJk8TMOkeCLMZzoJZ9EZVAJXQO9lHftsvw05CwmcscDV7QuRmuwQBD6f4qAnr35io +xNyNC60pDHAKQOV4sIbyoUra8u78PMofY52BjsfFySGZenDGkc4joegzKdogbeQeEjRRD3pPX1CjGu +NtxYCePWXkwgYoxasuDn0ULgaJ9rTD BjglBpG3kpRBB84GwJzfjh8dEmRmKMxsPA8K KpGfjhm +EEVeLcH2t16Se4FZkLSFzADooDijqm60lvxSOpe2LGGhXa94dQmMTESl6FPVqchzKKQuMg77ulrF7GSUosvw4Ry5oLJEQGPqHuxs +jCcE238RM7JOGHwDomNGHoyY0LIYO2dqIcxNOMqvVcFLqCwxnWnX6N zWqHH4ACm1EbtXCACZAOtGsPsM4DdXw +DyqJiYYqBZZAZ0jyvwF2Rzm7DDpWtphJFvKaCvi1n4lf3lBQe FRzakzcOm1sP3q5BMwWDQjcKIhKCsTR4KsqAQWM2cef1 +CTOu64tjU65CzlCmns0QSG8PpqeXLZGo32GbMz1dsSU3byFdXvUfLInNPWTQIGj9tmeGnDzeBihPKIwOQzeB +4oyVwRjiyn0pyMWZ0ChczKOLO57DxwNd4v38dZ 1nIVIVSxlVl0GH4v4tt9judjPKvsMxrAxJq7cDbK bVlc9EcVvTR +ikVAsOiY5ZQT7Y88wh4clEB7lV 8kTSte3RXOTA +1bVCT7yBXD3Es6yezJWm7hdz6vZPaIIOX2l0fTUXB8RfxTq3Kaj6lmQJnuItDJncz6AaYbjXe95W3Vmp0PS3ATEzdG9mEZwSymjd +egkKfFTdY4kx6EnInnegVUFBDalZa5z9ubx3eu6nHD7zfYkjFWUMaLSgwVKjJpsYcw3DtHlfhLWo1nwC9hTX89vCEShI4bcsnlJ7 +3jyOhJSBOym5T55E8F154bYhF4dnwt6q2DRPnenggO1d04bJbVhRbfTgbhGPen3mO5VaU2Z63Rs7q9kp8CsJwPtO5Bp0LC0sTh4Q + +0fJLwkEdB9cY9rVMHpMpRq30e3X1YdchhB8mOkKBXCCaS9WhoBXZYV4zS0R1LOCC5OqHu8TxDJ6p3rOoGxM2s1KzJMZlweexZzSa +ovcwhSG UZ2TTYIan8vFvreBtkSyxmlnQsUyfZnajIPFZeNE +IGu8JRG1yuZuCq0xNPJ19G1ysunyc3X57fORpykArVk2TVQhsBlvsqsloPMMd9FKOSTc0jZsnJf2nLujBuHP5vwqrytGCZMh3mI1 +rZz f5h5RW4JYTtZbd8yeqAF6Hxmze5KaG0jLI7XWIA2ZbVzKLJRydDZu7tiRyNSNjXdw5MuFDgSudZcav3WHJyO OXQ +S4KSuD4dKkPL2hDwuHVwVf6L7hNvyLC5EuqZN1JIgbYiozbhmhU6CKqDLoOdsxFZsr5Uy5F4j3GruUTukaxxIXV9THGDm3E35XGy +OYLvjv2YQWsT5eiWnm5AFuGUBI8pdDSVdnvLPW1Gm9Blb3lQU6xwJsUIWw11NWLmCSf2Aj9olkGXtxWXhji1ypQhQd2GKZUodWyH +gLRGD6QucBcQI5VI8fjoQGWPAgtoWhgsKDGbG6ZH2x9YoFWgWJc OsB1rt7pUWu3vyBueDujMduUejf7RdLO +KqnRyHahI19I5jLVHLKGyNWrbvb9sxEhKPyZEKop +uRCHEXbWRYGZhPks3Q3Wcjvaea8oeuguFZqZVkd0fVpgX8WDleCk8ZqWU1eQbVWjgzaxTNJB23qqMYl6YJFczQb4TkE3GGgDYS3J +cSP1D3qqirQASr42pWt2PBOF7OaRzjD6HUn8MtGF1wyPPWrORXAx3pWPtl4KqVXdsDDFD 6RgMB +ekLwEfmUgQsMsCwBvzkO6H2sJyVJnJ1lpwcsXvJj5skReQdBulviH1NLUIx6KnpIquID2WoY7BoAajF5I evPqde68gP9jb7B +FEawPc OpvimjyZAes9sdECf3B2JF fIChuOk8iDpcneQ1bwseUKjXr7pON6pOc9UaU87Iu +NHD2joerAZTwSMPBAPMRRXNzNLaSIbIrwbzMBNHJrevadSa nY2CfcuuQw5 C0cTEl1ahv6B94v61xTdPXlwMGVYY +7I8Mg2wvMqGLUAbpJtwN2HSFlutq4L2hIF1K08MyKpvI20e0IegHjIHyTuZ1uzZFtQ86Euh1uyI +r6rBVKxfnFihxTPfBBMLo9UXER 4tHUGvLZLPATCdaV4rfT6RmUowQ09KGFxiRdUC +EOEroqWa4gLkFgDHDYEUdYAA2OYGrMPqzilN7OLJqaWmFudOHTRFB6MSSpOCeGLNbGAkT7adB4J9ucX035wU3YTSPAehBbzIe5Aq +vmHRBFC6l FLY2MdW2qGIGjAgQwZMND42REPfVmFmn7HrDo Eoxwjaxzutvua xfqbd1w70 +G43CnoGLCkxmHCiJ1CBHtFA3ytIX5aXiaZkFL47OcLC3u46Lv0TnQdjnGtew5I9YCSq7Y4342RtnQae6dsSfrwaqa2WtYASIDDuW +3PCri8Hd07miGhuRrwrwZCi7NN1q6cGvsCjgQCDzbwlnXd3lrB1ilFX2pAw24 20rp6tW78 7Csmtkjhu2oPIwSO2A +r7m47cYIDK +hpJ7OVfU98IYdwXAy230328Hwyn5bLldYAdvWDnkthFsWxi7wXROx08xhSDRn4i232OY0Jpl2PkSbX5mK3aEjbamS8tpp8gKnF +JjR2XpPFzk7BmeHedc5KSFQl1AFH 3DzxlnyQd5ebjS3Bqd8qHc2LbSTcnqDkVrRvRBLmkhtWCTbpHm05COf 52nO1gcPe +8THe9oE8LrkF0uZKgXLsSkCIq82PFhsv7WaR1CcwXIKToOe8OeFWjUORkmYw4EfKEwVoK6786bf9H3Zv5EMCpWthC8c2mREEdIdj +AQ2ZE7YmIhqJvtby7q vkf2t7hWc6K8Bz9TG8U0XZxRfq0m Ci9joyI3Wfen +dZinbVG6q5PHjKv8ImrXM5D6u3fXCacFyYG8KJoe01bfyD1vw9foYMPCEL1aGo6Uph6bQRNvVsImOd2r5Zvg8staHtt7IsAwiKou +KNuIH7UyLjCH +ABkyySlH5b2e8lZxpQKkHqIChY5xe3uzK1cVwwjrk38LLmKpXlv5GqcHZLEmM31ZaJ9nJ1dAOoqVGw2xjNuqgDi62NgLdyN8bnqD +CSH5kvYfOkxVgN9H196mcpJF2E1IVzjqJeTeJfuBKrE +iUaFSINIPMmYTqMWEtJBestMGF9RQKEtQCPCbIiqwl3kA8EXMkgU9dQSZvJR0DymlBBQ6MUfVqFbblexcUaZIRclnogDPfawyphL +2HXcmB7py2qyWWqbiUBFQCkg3Ic41tpFy7I58BZ46XVhw07jio W7v8PoqvgG1wOV7f8fuiuXvPlQoC2lY07wm0 nQgRok +w3JrHmwWyKmRLhJrrk9jjHhoiTGuLE3j4tsciZlwfhQprtYIkKVez2pr4YlNNYcRvLq0kWQDFo3BohylWpPaO5 +i7lLo7pmeACCHzh4jXoNuBBSOCTRKRi1KEdeWqPH1BUHlhzHKzrXJFL1gmcspqNO2h6dmEwHSlKIowLeaZUyCXMZC4iz8BckLNE0 +feeyDvyILnsWK8ysQZ7WrV1BlJpVxkeULrT5TaKUC8BcNnPWQZeIGC9eOROCmoBmRhnyoXBSWEkOIBgl0MqJ5uub6kdxMGSh76D1 +3NQkbCAHJeCDltw5P8ivcicJZIKiqZ PzAZQItATtQWTyX5zJkFjYG1iQb0N4ssd +O7oMoWi3eKwNRJFMt0ipSs3eaI5W06ncBWdiFWIb4sg6onYSSrwlGkhe8W6fSBHWf PowV2RJb1hlYV88oaCdvFv21SPC8nJQ +U1iITVNuOAw6zhEZOc8z MpFsl4q9kulMJ8cjvW7EI1FfikBXDThfFxPHWu +G1DV05xMQIxLgG5NFmJnSXBmKi2pkZNii303wKIqmL4Qz0xi9MznIBbKob56ZSH01lB9zgll7C9W8gwlDxpfduiQ4pkANDmDSgns +pn4yak7rgCezcCP46lIRVFcZr6HM9JwP3ejcLoLLdAm0GM0ovbrwFIBnZRbzXNjWqfdTYiTCqyYxr4TzXFGgxv3 +VzPVnagOAzhzpbJSAf8arLn7ZCL9Nt7EXYX8OL3S2ocutTJ3snzyVbaxoAX9cefUMaM6JWcR2s8pB6pVFTjGl7p6aN11DiBXmXb4 +V VcleLQyNYWYQv3z8grpAWYsSlMFGu3KRa7dWaiiH2t +q3jSX6ZY7929tTGA0YP8lDhro5X83MKFjL4201yatzDb4HaTjuQLRpXVAZy5lqHQyMJmdQqn1 Si2 D NYRhpHl5VKr +6JMzwA00ZRVy1Z2hI1WxV7wSyIXR +MNm2hwXasuvK2pjoihAkXzoUtuYDhqBFFqWsYRW3njSteQPb9srNSBNE4UM9tR8Fp3lmLB6jJpFu3OQnVCiLEUHkUBBWeUNna0S8 +S5ETB5w8Z8pxy55mrppkTE4x85VRzhErGFeRAUBfuJtManvRtMpTBpsjuro27yLjyGWwUTnhUh7Ga2MIu4aTIHpgU7mk Rc qAv +22xdHaKlod6f4Gbpk8SRo1WlkqYDWw0kLXCXeNCZ3Azu8M0nRtOQLx9zGyHizMClckRWFFZqFYKOPrGdMuTCUdHELsSMWEgl6Daj +sDWuyiHvPzaQrq1NM0Ryy4VUwwgKOi c2Elp6skrC4kLgg7qyIO5HOke 1LRoZc6eIL5DPSc +Jiukkxl5yUueJOUvd3Y3e0bxnQqwPjnYvBta8p7HUGF2Fs8cHMfGBuCsvjqf2pqs4BVcgdZb4xnvVJUvTIlnCckgHs8yXlWtMtgv +nNJ34AkMxBSzWanNsWWHtE7Pnn5Ea3D80CIVB9Ld85aSNWrfWLp0Pe5mOw7VQ5YBak4TPHjmQDX1KyEbdYvCkVBdymSxDP8NUBa8 +WnCCYghXUFDHEccoqmPlFwRREV7KwuXqI0UnaLQYDE7U9H5qcRIi1hX2vjs02KYYDykGBYYfXrtSXg2JBCtXkeogKaOQPTpVUv2c +zs CbrnVrA7i5oiDDAsglO0Ta sa5f6mXYUgIN64m3zpmqsLQbCRKLkKYfQ8sbH7Sdcd3oDnp70dbSg0JtuAD64hucNRE h +JRrn4fzfDz35Ho8yuRDN4Fn0JZKbJBamM7Ugn9nSldmMwIqsWIIQG5JAomGveR7XZFal2XIotpPujUmQ1G8D4aFtwUn3j6n6olgW +hiaOzdzuBXFPGPZOhjshexl5jGUxTRIZl1jCWCMW1fyKtEDReYhhfjEdeV8Os9OwgZP73TmuyG8Pw1XbMWkxt25I9JWF0DLYaUwx +8hOKeNzko QDzJL97X O5wI5k0OSrUDjxA97lYNGCTyGww0neGp RW1DUaJTfaWsMXsR1SzkQ4NqNgraLRgZJYm +NSEeFJ8CpEsK5MHx2rHGSGQamJl5bhOEpTa5gghVl0Vi3q +l77M6H27VVICru1xXUgoQ8iahSjrJTWdofNKswdORFLTn5QGGrHX0XnN2ubp9E38B6wsswuzLOlPswu93RGDw pTFk65uWoc +4XANAZojJHgREiWaG5T4GvW4y0vhUrrmjjFEQGPfwBMeDXNFji5v +KLATcQroa5yJ4XTZtqTAfy316iCSJ1Ea8KestkkNfpBpuwbD1b0JN7gQkqRz0FAcWg5XqeRGXfPA6psmiSs8uuVlF6 +a4xF24lzDQTr7DWloSLJWhCuwNkK9acMYh06NUXVwnA0MVqkqyjNnShsWl8H4oQv5Nsf3Kbcg7R7AYwqbIyyvoi1L0OMG2icFaTU +veRNQRxoXZ0TwV0BDeNUWpOTgf9BBSXrpU9gHePT88AzPlGDTAawY6kCoekbUMntEaXY0vAVVHp R362Ou LOObMUiodtscmyL5 +cdTV6u6EWPl01fTH0FUZ2H0V4W8z44F4Gh2ydhSgI5uRlGZWCpidd2ZQPPSU44nGR59YGAbBGs3g8yFVmh3S2ZDiAoHPRdGUUVbD +O6yXceTzh0ax9buiGdvRVS6KsykYClnlACuhL3B3cZXletNklhYjd4iM10VIfUqmsd1O1eFmRa0awYKiLYWyXq6jKYA61uQlyj1D +i4k0S00cPzV8xAzE1ytC4 E4oQkbgweEF1R lPKNmluEfUFGioa6Rah2KecZ7d1Lh6uQdNNgD0s eUS5ySCPMxouDK8 +0HgjteGUDEcipVohCCBKBOiZUciFI6DvSAiuPJ7sfXEN8wOnmf1REzGhvvctZOgXVTBLlwrNFxR5iCGxGJ6vj8aCaGdAiHusVcHV +62LhpLay021xMEDPxkFKIcucN3tMmAeY75U3aPMPWhE42jEGZb9xsl2WuqH1MHpybhKP207Xva8KpgDmh36bFjN2AKSvtRYEBT9l +LWkQ1I2k3mRg5AUHmufZuRLFl8mK9PlfswEE9kK5KpOWQdULt0PbAuxG35WTQpGuIwMiMiGQhRqJdoYpyqsp5IChwrTHpdoR8vuZ +GruCxRwK5X8s2E0mwJ6NpC5DOEcNKbU2NU3a4fAsfMfCr2ENRbe6SwrihPx2n3GojnoQjoSA5t9nVk6ZT +tyCDw51m6ycbu37bPuiuoz76Zh +pgRi400F8WY82Qj8ze2OyWRrtAmgdSPhaTTfrsMne6Ug5S0CI72XWpcrTLq3IMe1RaaPujHLRbt6TeUSjcvDLizBMAHLXl5K5GS5 +B2NzwHeRY32toI78mq +aQQgMWn70ZyPCXIoMBRB72AwaVkatE5BhYxNuhX9hZBu8oCQuVoLF4IOeTkGHK2gckjFZBkOiRDsKg3B7YYN3NtT2Xfr +0Ty0o3QOim0BeJsaaR8rhFISxPf1iX8IfroC2dj8Yc QT06CFy5oeLhFTdjQoYrHUWpgupG9G4pXHLpG5tk03TFDBa6ExHnvRx +uggfzWdjjrC4hple6IJmJfAZmtXXHXzLJE9VDxquA +Xv1ABk8D8GBAXFc78pUQbC9TVoyQAHI0R3GUSkoJyoql8lRc2fI9BmAYl61BGAxG7r5jre14oQNxqN5JHj6guic9EqsYVoUNbQZX +ogqLoERowSmByIgpTZSQOaIrNwy3PtWpcSOR7QgNZCAFcv7h4bm4vcRJOknBhMouP6jAHyrRnxAK7jSnUOG9cMZecHhQgbzGSMJw +Oj +iJu1iZRbPgiO4LldaJwpEHGKk3DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16385.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16385.expected new file mode 100644 index 00000000000..a30c8ea3471 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16385.expected @@ -0,0 +1,105 @@ +ESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16386.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16386.expected new file mode 100644 index 00000000000..e4d11d8b6bf --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+16386.expected @@ -0,0 +1,105 @@ +SvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8193.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8193.expected new file mode 100644 index 00000000000..88d4bdf6c0e --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8193.expected @@ -0,0 +1,205 @@ +IYEb4HhrrfixUC8j +J2 PNukXTyPowk2P490ZRC hjIqTv3QZxI7 wrsa0rJ8ixaNmZ3Za evP5y6eRvwSwJng787yQzpVi3wCDBw XrEPBJ0 +t2BMpq3evy3ELNduHoifzv6jkN0gJy9o +99sUZ34ro19oJd3UTlLLvi8h8vwToC3ijOEXhY8abO4dCMZUhwj8QlYdDC0JmtAXLO9CEZ0dWZXAMvXgDaorn7CDVBks2Qa7aMkN +1JClm9DlcPR65EKgtPeh +wdteBwA8oEHKRttRIEGI8IstPh2s75Sc9mg0LFG4tn256bBycdcJu4yj6bjBYN13U2dsKkrsJuonekqCOaTTtKudcIwAqRFnZYSa +eXQuRchTkAoQQdZMOejbLczo975o4h0rnt0UvAgU53n +8BYujbW5W2X50yUfshDCtEra20Nx9rJnMAtCkw8QgfECDM988y4A5FGw1sOSyaNch4 +Y47fv7VGVhfl9NG9ByImguZRrYZ3En0DYy2P0G1ufy7xplzshenzxNEjwTe3UR9G83VUs6obeSVCYBAo7pBmaQxH 9f5f9Mv +4oC5X0WDLvadtlM0NNmyDKYfzgw3JTGXDzPGVl7WkL5hsec6MbwS6l0Q7ruX0WtU1WVD8vyCBmVcr2q9DtmgHqclSbMoHXokGFkY +knfOZFLg9DrRkWp3VZfVLYKgsi6pCv 9J7JUWTWxRXLpSszJpKvQbbLa1BYpw0hI3LwgEbX +6ttL77Ak2kox3W9QqdzwQLmTh45n1rwe2daWBRpzwOq33LEBG1nwOlPY5tve0iH5z4T2Vs7cBj6BrOFc8OgS1RXygUURmkmZvYC9 +7XuL HJk8TMOkeCLMZzoJZ9EZVAJXQO9lHftsvw05CwmcscDV7QuRmuwQBD6f4qAnr35io +xNyNC60pDHAKQOV4sIbyoUra8u78PMofY52BjsfFySGZenDGkc4joegzKdogbeQeEjRRD3pPX1CjGu +NtxYCePWXkwgYoxasuDn0ULgaJ9rTD BjglBpG3kpRBB84GwJzfjh8dEmRmKMxsPA8K KpGfjhm +EEVeLcH2t16Se4FZkLSFzADooDijqm60lvxSOpe2LGGhXa94dQmMTESl6FPVqchzKKQuMg77ulrF7GSUosvw4Ry5oLJEQGPqHuxs +jCcE238RM7JOGHwDomNGHoyY0LIYO2dqIcxNOMqvVcFLqCwxnWnX6N zWqHH4ACm1EbtXCACZAOtGsPsM4DdXw +DyqJiYYqBZZAZ0jyvwF2Rzm7DDpWtphJFvKaCvi1n4lf3lBQe FRzakzcOm1sP3q5BMwWDQjcKIhKCsTR4KsqAQWM2cef1 +CTOu64tjU65CzlCmns0QSG8PpqeXLZGo32GbMz1dsSU3byFdXvUfLInNPWTQIGj9tmeGnDzeBihPKIwOQzeB +4oyVwRjiyn0pyMWZ0ChczKOLO57DxwNd4v38dZ 1nIVIVSxlVl0GH4v4tt9judjPKvsMxrAxJq7cDbK bVlc9EcVvTR +ikVAsOiY5ZQT7Y88wh4clEB7lV 8kTSte3RXOTA +1bVCT7yBXD3Es6yezJWm7hdz6vZPaIIOX2l0fTUXB8RfxTq3Kaj6lmQJnuItDJncz6AaYbjXe95W3Vmp0PS3ATEzdG9mEZwSymjd +egkKfFTdY4kx6EnInnegVUFBDalZa5z9ubx3eu6nHD7zfYkjFWUMaLSgwVKjJpsYcw3DtHlfhLWo1nwC9hTX89vCEShI4bcsnlJ7 +3jyOhJSBOym5T55E8F154bYhF4dnwt6q2DRPnenggO1d04bJbVhRbfTgbhGPen3mO5VaU2Z63Rs7q9kp8CsJwPtO5Bp0LC0sTh4Q + +0fJLwkEdB9cY9rVMHpMpRq30e3X1YdchhB8mOkKBXCCaS9WhoBXZYV4zS0R1LOCC5OqHu8TxDJ6p3rOoGxM2s1KzJMZlweexZzSa +ovcwhSG UZ2TTYIan8vFvreBtkSyxmlnQsUyfZnajIPFZeNE +IGu8JRG1yuZuCq0xNPJ19G1ysunyc3X57fORpykArVk2TVQhsBlvsqsloPMMd9FKOSTc0jZsnJf2nLujBuHP5vwqrytGCZMh3mI1 +rZz f5h5RW4JYTtZbd8yeqAF6Hxmze5KaG0jLI7XWIA2ZbVzKLJRydDZu7tiRyNSNjXdw5MuFDgSudZcav3WHJyO OXQ +S4KSuD4dKkPL2hDwuHVwVf6L7hNvyLC5EuqZN1JIgbYiozbhmhU6CKqDLoOdsxFZsr5Uy5F4j3GruUTukaxxIXV9THGDm3E35XGy +OYLvjv2YQWsT5eiWnm5AFuGUBI8pdDSVdnvLPW1Gm9Blb3lQU6xwJsUIWw11NWLmCSf2Aj9olkGXtxWXhji1ypQhQd2GKZUodWyH +gLRGD6QucBcQI5VI8fjoQGWPAgtoWhgsKDGbG6ZH2x9YoFWgWJc OsB1rt7pUWu3vyBueDujMduUejf7RdLO +KqnRyHahI19I5jLVHLKGyNWrbvb9sxEhKPyZEKop +uRCHEXbWRYGZhPks3Q3Wcjvaea8oeuguFZqZVkd0fVpgX8WDleCk8ZqWU1eQbVWjgzaxTNJB23qqMYl6YJFczQb4TkE3GGgDYS3J +cSP1D3qqirQASr42pWt2PBOF7OaRzjD6HUn8MtGF1wyPPWrORXAx3pWPtl4KqVXdsDDFD 6RgMB +ekLwEfmUgQsMsCwBvzkO6H2sJyVJnJ1lpwcsXvJj5skReQdBulviH1NLUIx6KnpIquID2WoY7BoAajF5I evPqde68gP9jb7B +FEawPc OpvimjyZAes9sdECf3B2JF fIChuOk8iDpcneQ1bwseUKjXr7pON6pOc9UaU87Iu +NHD2joerAZTwSMPBAPMRRXNzNLaSIbIrwbzMBNHJrevadSa nY2CfcuuQw5 C0cTEl1ahv6B94v61xTdPXlwMGVYY +7I8Mg2wvMqGLUAbpJtwN2HSFlutq4L2hIF1K08MyKpvI20e0IegHjIHyTuZ1uzZFtQ86Euh1uyI +r6rBVKxfnFihxTPfBBMLo9UXER 4tHUGvLZLPATCdaV4rfT6RmUowQ09KGFxiRdUC +EOEroqWa4gLkFgDHDYEUdYAA2OYGrMPqzilN7OLJqaWmFudOHTRFB6MSSpOCeGLNbGAkT7adB4J9ucX035wU3YTSPAehBbzIe5Aq +vmHRBFC6l FLY2MdW2qGIGjAgQwZMND42REPfVmFmn7HrDo Eoxwjaxzutvua xfqbd1w70 +G43CnoGLCkxmHCiJ1CBHtFA3ytIX5aXiaZkFL47OcLC3u46Lv0TnQdjnGtew5I9YCSq7Y4342RtnQae6dsSfrwaqa2WtYASIDDuW +3PCri8Hd07miGhuRrwrwZCi7NN1q6cGvsCjgQCDzbwlnXd3lrB1ilFX2pAw24 20rp6tW78 7Csmtkjhu2oPIwSO2A +r7m47cYIDK +hpJ7OVfU98IYdwXAy230328Hwyn5bLldYAdvWDnkthFsWxi7wXROx08xhSDRn4i232OY0Jpl2PkSbX5mK3aEjbamS8tpp8gKnF +JjR2XpPFzk7BmeHedc5KSFQl1AFH 3DzxlnyQd5ebjS3Bqd8qHc2LbSTcnqDkVrRvRBLmkhtWCTbpHm05COf 52nO1gcPe +8THe9oE8LrkF0uZKgXLsSkCIq82PFhsv7WaR1CcwXIKToOe8OeFWjUORkmYw4EfKEwVoK6786bf9H3Zv5EMCpWthC8c2mREEdIdj +AQ2ZE7YmIhqJvtby7q vkf2t7hWc6K8Bz9TG8U0XZxRfq0m Ci9joyI3Wfen +dZinbVG6q5PHjKv8ImrXM5D6u3fXCacFyYG8KJoe01bfyD1vw9foYMPCEL1aGo6Uph6bQRNvVsImOd2r5Zvg8staHtt7IsAwiKou +KNuIH7UyLjCH +ABkyySlH5b2e8lZxpQKkHqIChY5xe3uzK1cVwwjrk38LLmKpXlv5GqcHZLEmM31ZaJ9nJ1dAOoqVGw2xjNuqgDi62NgLdyN8bnqD +CSH5kvYfOkxVgN9H196mcpJF2E1IVzjqJeTeJfuBKrE +iUaFSINIPMmYTqMWEtJBestMGF9RQKEtQCPCbIiqwl3kA8EXMkgU9dQSZvJR0DymlBBQ6MUfVqFbblexcUaZIRclnogDPfawyphL +2HXcmB7py2qyWWqbiUBFQCkg3Ic41tpFy7I58BZ46XVhw07jio W7v8PoqvgG1wOV7f8fuiuXvPlQoC2lY07wm0 nQgRok +w3JrHmwWyKmRLhJrrk9jjHhoiTGuLE3j4tsciZlwfhQprtYIkKVez2pr4YlNNYcRvLq0kWQDFo3BohylWpPaO5 +i7lLo7pmeACCHzh4jXoNuBBSOCTRKRi1KEdeWqPH1BUHlhzHKzrXJFL1gmcspqNO2h6dmEwHSlKIowLeaZUyCXMZC4iz8BckLNE0 +feeyDvyILnsWK8ysQZ7WrV1BlJpVxkeULrT5TaKUC8BcNnPWQZeIGC9eOROCmoBmRhnyoXBSWEkOIBgl0MqJ5uub6kdxMGSh76D1 +3NQkbCAHJeCDltw5P8ivcicJZIKiqZ PzAZQItATtQWTyX5zJkFjYG1iQb0N4ssd +O7oMoWi3eKwNRJFMt0ipSs3eaI5W06ncBWdiFWIb4sg6onYSSrwlGkhe8W6fSBHWf PowV2RJb1hlYV88oaCdvFv21SPC8nJQ +U1iITVNuOAw6zhEZOc8z MpFsl4q9kulMJ8cjvW7EI1FfikBXDThfFxPHWu +G1DV05xMQIxLgG5NFmJnSXBmKi2pkZNii303wKIqmL4Qz0xi9MznIBbKob56ZSH01lB9zgll7C9W8gwlDxpfduiQ4pkANDmDSgns +pn4yak7rgCezcCP46lIRVFcZr6HM9JwP3ejcLoLLdAm0GM0ovbrwFIBnZRbzXNjWqfdTYiTCqyYxr4TzXFGgxv3 +VzPVnagOAzhzpbJSAf8arLn7ZCL9Nt7EXYX8OL3S2ocutTJ3snzyVbaxoAX9cefUMaM6JWcR2s8pB6pVFTjGl7p6aN11DiBXmXb4 +V VcleLQyNYWYQv3z8grpAWYsSlMFGu3KRa7dWaiiH2t +q3jSX6ZY7929tTGA0YP8lDhro5X83MKFjL4201yatzDb4HaTjuQLRpXVAZy5lqHQyMJmdQqn1 Si2 D NYRhpHl5VKr +6JMzwA00ZRVy1Z2hI1WxV7wSyIXR +MNm2hwXasuvK2pjoihAkXzoUtuYDhqBFFqWsYRW3njSteQPb9srNSBNE4UM9tR8Fp3lmLB6jJpFu3OQnVCiLEUHkUBBWeUNna0S8 +S5ETB5w8Z8pxy55mrppkTE4x85VRzhErGFeRAUBfuJtManvRtMpTBpsjuro27yLjyGWwUTnhUh7Ga2MIu4aTIHpgU7mk Rc qAv +22xdHaKlod6f4Gbpk8SRo1WlkqYDWw0kLXCXeNCZ3Azu8M0nRtOQLx9zGyHizMClckRWFFZqFYKOPrGdMuTCUdHELsSMWEgl6Daj +sDWuyiHvPzaQrq1NM0Ryy4VUwwgKOi c2Elp6skrC4kLgg7qyIO5HOke 1LRoZc6eIL5DPSc +Jiukkxl5yUueJOUvd3Y3e0bxnQqwPjnYvBta8p7HUGF2Fs8cHMfGBuCsvjqf2pqs4BVcgdZb4xnvVJUvTIlnCckgHs8yXlWtMtgv +nNJ34AkMxBSzWanNsWWHtE7Pnn5Ea3D80CIVB9Ld85aSNWrfWLp0Pe5mOw7VQ5YBak4TPHjmQDX1KyEbdYvCkVBdymSxDP8NUBa8 +WnCCYghXUFDHEccoqmPlFwRREV7KwuXqI0UnaLQYDE7U9H5qcRIi1hX2vjs02KYYDykGBYYfXrtSXg2JBCtXkeogKaOQPTpVUv2c +zs CbrnVrA7i5oiDDAsglO0Ta sa5f6mXYUgIN64m3zpmqsLQbCRKLkKYfQ8sbH7Sdcd3oDnp70dbSg0JtuAD64hucNRE h +JRrn4fzfDz35Ho8yuRDN4Fn0JZKbJBamM7Ugn9nSldmMwIqsWIIQG5JAomGveR7XZFal2XIotpPujUmQ1G8D4aFtwUn3j6n6olgW +hiaOzdzuBXFPGPZOhjshexl5jGUxTRIZl1jCWCMW1fyKtEDReYhhfjEdeV8Os9OwgZP73TmuyG8Pw1XbMWkxt25I9JWF0DLYaUwx +8hOKeNzko QDzJL97X O5wI5k0OSrUDjxA97lYNGCTyGww0neGp RW1DUaJTfaWsMXsR1SzkQ4NqNgraLRgZJYm +NSEeFJ8CpEsK5MHx2rHGSGQamJl5bhOEpTa5gghVl0Vi3q +l77M6H27VVICru1xXUgoQ8iahSjrJTWdofNKswdORFLTn5QGGrHX0XnN2ubp9E38B6wsswuzLOlPswu93RGDw pTFk65uWoc +4XANAZojJHgREiWaG5T4GvW4y0vhUrrmjjFEQGPfwBMeDXNFji5v +KLATcQroa5yJ4XTZtqTAfy316iCSJ1Ea8KestkkNfpBpuwbD1b0JN7gQkqRz0FAcWg5XqeRGXfPA6psmiSs8uuVlF6 +a4xF24lzDQTr7DWloSLJWhCuwNkK9acMYh06NUXVwnA0MVqkqyjNnShsWl8H4oQv5Nsf3Kbcg7R7AYwqbIyyvoi1L0OMG2icFaTU +veRNQRxoXZ0TwV0BDeNUWpOTgf9BBSXrpU9gHePT88AzPlGDTAawY6kCoekbUMntEaXY0vAVVHp R362Ou LOObMUiodtscmyL5 +cdTV6u6EWPl01fTH0FUZ2H0V4W8z44F4Gh2ydhSgI5uRlGZWCpidd2ZQPPSU44nGR59YGAbBGs3g8yFVmh3S2ZDiAoHPRdGUUVbD +O6yXceTzh0ax9buiGdvRVS6KsykYClnlACuhL3B3cZXletNklhYjd4iM10VIfUqmsd1O1eFmRa0awYKiLYWyXq6jKYA61uQlyj1D +i4k0S00cPzV8xAzE1ytC4 E4oQkbgweEF1R lPKNmluEfUFGioa6Rah2KecZ7d1Lh6uQdNNgD0s eUS5ySCPMxouDK8 +0HgjteGUDEcipVohCCBKBOiZUciFI6DvSAiuPJ7sfXEN8wOnmf1REzGhvvctZOgXVTBLlwrNFxR5iCGxGJ6vj8aCaGdAiHusVcHV +62LhpLay021xMEDPxkFKIcucN3tMmAeY75U3aPMPWhE42jEGZb9xsl2WuqH1MHpybhKP207Xva8KpgDmh36bFjN2AKSvtRYEBT9l +LWkQ1I2k3mRg5AUHmufZuRLFl8mK9PlfswEE9kK5KpOWQdULt0PbAuxG35WTQpGuIwMiMiGQhRqJdoYpyqsp5IChwrTHpdoR8vuZ +GruCxRwK5X8s2E0mwJ6NpC5DOEcNKbU2NU3a4fAsfMfCr2ENRbe6SwrihPx2n3GojnoQjoSA5t9nVk6ZT +tyCDw51m6ycbu37bPuiuoz76Zh +pgRi400F8WY82Qj8ze2OyWRrtAmgdSPhaTTfrsMne6Ug5S0CI72XWpcrTLq3IMe1RaaPujHLRbt6TeUSjcvDLizBMAHLXl5K5GS5 +B2NzwHeRY32toI78mq +aQQgMWn70ZyPCXIoMBRB72AwaVkatE5BhYxNuhX9hZBu8oCQuVoLF4IOeTkGHK2gckjFZBkOiRDsKg3B7YYN3NtT2Xfr +0Ty0o3QOim0BeJsaaR8rhFISxPf1iX8IfroC2dj8Yc QT06CFy5oeLhFTdjQoYrHUWpgupG9G4pXHLpG5tk03TFDBa6ExHnvRx +uggfzWdjjrC4hple6IJmJfAZmtXXHXzLJE9VDxquA +Xv1ABk8D8GBAXFc78pUQbC9TVoyQAHI0R3GUSkoJyoql8lRc2fI9BmAYl61BGAxG7r5jre14oQNxqN5JHj6guic9EqsYVoUNbQZX +ogqLoERowSmByIgpTZSQOaIrNwy3PtWpcSOR7QgNZCAFcv7h4bm4vcRJOknBhMouP6jAHyrRnxAK7jSnUOG9cMZecHhQgbzGSMJw +Oj +iJu1iZRbPgiO4LldaJwpEHGKk3DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8194.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8194.expected new file mode 100644 index 00000000000..c6fe21e9470 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_+8194.expected @@ -0,0 +1,205 @@ +YEb4HhrrfixUC8j +J2 PNukXTyPowk2P490ZRC hjIqTv3QZxI7 wrsa0rJ8ixaNmZ3Za evP5y6eRvwSwJng787yQzpVi3wCDBw XrEPBJ0 +t2BMpq3evy3ELNduHoifzv6jkN0gJy9o +99sUZ34ro19oJd3UTlLLvi8h8vwToC3ijOEXhY8abO4dCMZUhwj8QlYdDC0JmtAXLO9CEZ0dWZXAMvXgDaorn7CDVBks2Qa7aMkN +1JClm9DlcPR65EKgtPeh +wdteBwA8oEHKRttRIEGI8IstPh2s75Sc9mg0LFG4tn256bBycdcJu4yj6bjBYN13U2dsKkrsJuonekqCOaTTtKudcIwAqRFnZYSa +eXQuRchTkAoQQdZMOejbLczo975o4h0rnt0UvAgU53n +8BYujbW5W2X50yUfshDCtEra20Nx9rJnMAtCkw8QgfECDM988y4A5FGw1sOSyaNch4 +Y47fv7VGVhfl9NG9ByImguZRrYZ3En0DYy2P0G1ufy7xplzshenzxNEjwTe3UR9G83VUs6obeSVCYBAo7pBmaQxH 9f5f9Mv +4oC5X0WDLvadtlM0NNmyDKYfzgw3JTGXDzPGVl7WkL5hsec6MbwS6l0Q7ruX0WtU1WVD8vyCBmVcr2q9DtmgHqclSbMoHXokGFkY +knfOZFLg9DrRkWp3VZfVLYKgsi6pCv 9J7JUWTWxRXLpSszJpKvQbbLa1BYpw0hI3LwgEbX +6ttL77Ak2kox3W9QqdzwQLmTh45n1rwe2daWBRpzwOq33LEBG1nwOlPY5tve0iH5z4T2Vs7cBj6BrOFc8OgS1RXygUURmkmZvYC9 +7XuL HJk8TMOkeCLMZzoJZ9EZVAJXQO9lHftsvw05CwmcscDV7QuRmuwQBD6f4qAnr35io +xNyNC60pDHAKQOV4sIbyoUra8u78PMofY52BjsfFySGZenDGkc4joegzKdogbeQeEjRRD3pPX1CjGu +NtxYCePWXkwgYoxasuDn0ULgaJ9rTD BjglBpG3kpRBB84GwJzfjh8dEmRmKMxsPA8K KpGfjhm +EEVeLcH2t16Se4FZkLSFzADooDijqm60lvxSOpe2LGGhXa94dQmMTESl6FPVqchzKKQuMg77ulrF7GSUosvw4Ry5oLJEQGPqHuxs +jCcE238RM7JOGHwDomNGHoyY0LIYO2dqIcxNOMqvVcFLqCwxnWnX6N zWqHH4ACm1EbtXCACZAOtGsPsM4DdXw +DyqJiYYqBZZAZ0jyvwF2Rzm7DDpWtphJFvKaCvi1n4lf3lBQe FRzakzcOm1sP3q5BMwWDQjcKIhKCsTR4KsqAQWM2cef1 +CTOu64tjU65CzlCmns0QSG8PpqeXLZGo32GbMz1dsSU3byFdXvUfLInNPWTQIGj9tmeGnDzeBihPKIwOQzeB +4oyVwRjiyn0pyMWZ0ChczKOLO57DxwNd4v38dZ 1nIVIVSxlVl0GH4v4tt9judjPKvsMxrAxJq7cDbK bVlc9EcVvTR +ikVAsOiY5ZQT7Y88wh4clEB7lV 8kTSte3RXOTA +1bVCT7yBXD3Es6yezJWm7hdz6vZPaIIOX2l0fTUXB8RfxTq3Kaj6lmQJnuItDJncz6AaYbjXe95W3Vmp0PS3ATEzdG9mEZwSymjd +egkKfFTdY4kx6EnInnegVUFBDalZa5z9ubx3eu6nHD7zfYkjFWUMaLSgwVKjJpsYcw3DtHlfhLWo1nwC9hTX89vCEShI4bcsnlJ7 +3jyOhJSBOym5T55E8F154bYhF4dnwt6q2DRPnenggO1d04bJbVhRbfTgbhGPen3mO5VaU2Z63Rs7q9kp8CsJwPtO5Bp0LC0sTh4Q + +0fJLwkEdB9cY9rVMHpMpRq30e3X1YdchhB8mOkKBXCCaS9WhoBXZYV4zS0R1LOCC5OqHu8TxDJ6p3rOoGxM2s1KzJMZlweexZzSa +ovcwhSG UZ2TTYIan8vFvreBtkSyxmlnQsUyfZnajIPFZeNE +IGu8JRG1yuZuCq0xNPJ19G1ysunyc3X57fORpykArVk2TVQhsBlvsqsloPMMd9FKOSTc0jZsnJf2nLujBuHP5vwqrytGCZMh3mI1 +rZz f5h5RW4JYTtZbd8yeqAF6Hxmze5KaG0jLI7XWIA2ZbVzKLJRydDZu7tiRyNSNjXdw5MuFDgSudZcav3WHJyO OXQ +S4KSuD4dKkPL2hDwuHVwVf6L7hNvyLC5EuqZN1JIgbYiozbhmhU6CKqDLoOdsxFZsr5Uy5F4j3GruUTukaxxIXV9THGDm3E35XGy +OYLvjv2YQWsT5eiWnm5AFuGUBI8pdDSVdnvLPW1Gm9Blb3lQU6xwJsUIWw11NWLmCSf2Aj9olkGXtxWXhji1ypQhQd2GKZUodWyH +gLRGD6QucBcQI5VI8fjoQGWPAgtoWhgsKDGbG6ZH2x9YoFWgWJc OsB1rt7pUWu3vyBueDujMduUejf7RdLO +KqnRyHahI19I5jLVHLKGyNWrbvb9sxEhKPyZEKop +uRCHEXbWRYGZhPks3Q3Wcjvaea8oeuguFZqZVkd0fVpgX8WDleCk8ZqWU1eQbVWjgzaxTNJB23qqMYl6YJFczQb4TkE3GGgDYS3J +cSP1D3qqirQASr42pWt2PBOF7OaRzjD6HUn8MtGF1wyPPWrORXAx3pWPtl4KqVXdsDDFD 6RgMB +ekLwEfmUgQsMsCwBvzkO6H2sJyVJnJ1lpwcsXvJj5skReQdBulviH1NLUIx6KnpIquID2WoY7BoAajF5I evPqde68gP9jb7B +FEawPc OpvimjyZAes9sdECf3B2JF fIChuOk8iDpcneQ1bwseUKjXr7pON6pOc9UaU87Iu +NHD2joerAZTwSMPBAPMRRXNzNLaSIbIrwbzMBNHJrevadSa nY2CfcuuQw5 C0cTEl1ahv6B94v61xTdPXlwMGVYY +7I8Mg2wvMqGLUAbpJtwN2HSFlutq4L2hIF1K08MyKpvI20e0IegHjIHyTuZ1uzZFtQ86Euh1uyI +r6rBVKxfnFihxTPfBBMLo9UXER 4tHUGvLZLPATCdaV4rfT6RmUowQ09KGFxiRdUC +EOEroqWa4gLkFgDHDYEUdYAA2OYGrMPqzilN7OLJqaWmFudOHTRFB6MSSpOCeGLNbGAkT7adB4J9ucX035wU3YTSPAehBbzIe5Aq +vmHRBFC6l FLY2MdW2qGIGjAgQwZMND42REPfVmFmn7HrDo Eoxwjaxzutvua xfqbd1w70 +G43CnoGLCkxmHCiJ1CBHtFA3ytIX5aXiaZkFL47OcLC3u46Lv0TnQdjnGtew5I9YCSq7Y4342RtnQae6dsSfrwaqa2WtYASIDDuW +3PCri8Hd07miGhuRrwrwZCi7NN1q6cGvsCjgQCDzbwlnXd3lrB1ilFX2pAw24 20rp6tW78 7Csmtkjhu2oPIwSO2A +r7m47cYIDK +hpJ7OVfU98IYdwXAy230328Hwyn5bLldYAdvWDnkthFsWxi7wXROx08xhSDRn4i232OY0Jpl2PkSbX5mK3aEjbamS8tpp8gKnF +JjR2XpPFzk7BmeHedc5KSFQl1AFH 3DzxlnyQd5ebjS3Bqd8qHc2LbSTcnqDkVrRvRBLmkhtWCTbpHm05COf 52nO1gcPe +8THe9oE8LrkF0uZKgXLsSkCIq82PFhsv7WaR1CcwXIKToOe8OeFWjUORkmYw4EfKEwVoK6786bf9H3Zv5EMCpWthC8c2mREEdIdj +AQ2ZE7YmIhqJvtby7q vkf2t7hWc6K8Bz9TG8U0XZxRfq0m Ci9joyI3Wfen +dZinbVG6q5PHjKv8ImrXM5D6u3fXCacFyYG8KJoe01bfyD1vw9foYMPCEL1aGo6Uph6bQRNvVsImOd2r5Zvg8staHtt7IsAwiKou +KNuIH7UyLjCH +ABkyySlH5b2e8lZxpQKkHqIChY5xe3uzK1cVwwjrk38LLmKpXlv5GqcHZLEmM31ZaJ9nJ1dAOoqVGw2xjNuqgDi62NgLdyN8bnqD +CSH5kvYfOkxVgN9H196mcpJF2E1IVzjqJeTeJfuBKrE +iUaFSINIPMmYTqMWEtJBestMGF9RQKEtQCPCbIiqwl3kA8EXMkgU9dQSZvJR0DymlBBQ6MUfVqFbblexcUaZIRclnogDPfawyphL +2HXcmB7py2qyWWqbiUBFQCkg3Ic41tpFy7I58BZ46XVhw07jio W7v8PoqvgG1wOV7f8fuiuXvPlQoC2lY07wm0 nQgRok +w3JrHmwWyKmRLhJrrk9jjHhoiTGuLE3j4tsciZlwfhQprtYIkKVez2pr4YlNNYcRvLq0kWQDFo3BohylWpPaO5 +i7lLo7pmeACCHzh4jXoNuBBSOCTRKRi1KEdeWqPH1BUHlhzHKzrXJFL1gmcspqNO2h6dmEwHSlKIowLeaZUyCXMZC4iz8BckLNE0 +feeyDvyILnsWK8ysQZ7WrV1BlJpVxkeULrT5TaKUC8BcNnPWQZeIGC9eOROCmoBmRhnyoXBSWEkOIBgl0MqJ5uub6kdxMGSh76D1 +3NQkbCAHJeCDltw5P8ivcicJZIKiqZ PzAZQItATtQWTyX5zJkFjYG1iQb0N4ssd +O7oMoWi3eKwNRJFMt0ipSs3eaI5W06ncBWdiFWIb4sg6onYSSrwlGkhe8W6fSBHWf PowV2RJb1hlYV88oaCdvFv21SPC8nJQ +U1iITVNuOAw6zhEZOc8z MpFsl4q9kulMJ8cjvW7EI1FfikBXDThfFxPHWu +G1DV05xMQIxLgG5NFmJnSXBmKi2pkZNii303wKIqmL4Qz0xi9MznIBbKob56ZSH01lB9zgll7C9W8gwlDxpfduiQ4pkANDmDSgns +pn4yak7rgCezcCP46lIRVFcZr6HM9JwP3ejcLoLLdAm0GM0ovbrwFIBnZRbzXNjWqfdTYiTCqyYxr4TzXFGgxv3 +VzPVnagOAzhzpbJSAf8arLn7ZCL9Nt7EXYX8OL3S2ocutTJ3snzyVbaxoAX9cefUMaM6JWcR2s8pB6pVFTjGl7p6aN11DiBXmXb4 +V VcleLQyNYWYQv3z8grpAWYsSlMFGu3KRa7dWaiiH2t +q3jSX6ZY7929tTGA0YP8lDhro5X83MKFjL4201yatzDb4HaTjuQLRpXVAZy5lqHQyMJmdQqn1 Si2 D NYRhpHl5VKr +6JMzwA00ZRVy1Z2hI1WxV7wSyIXR +MNm2hwXasuvK2pjoihAkXzoUtuYDhqBFFqWsYRW3njSteQPb9srNSBNE4UM9tR8Fp3lmLB6jJpFu3OQnVCiLEUHkUBBWeUNna0S8 +S5ETB5w8Z8pxy55mrppkTE4x85VRzhErGFeRAUBfuJtManvRtMpTBpsjuro27yLjyGWwUTnhUh7Ga2MIu4aTIHpgU7mk Rc qAv +22xdHaKlod6f4Gbpk8SRo1WlkqYDWw0kLXCXeNCZ3Azu8M0nRtOQLx9zGyHizMClckRWFFZqFYKOPrGdMuTCUdHELsSMWEgl6Daj +sDWuyiHvPzaQrq1NM0Ryy4VUwwgKOi c2Elp6skrC4kLgg7qyIO5HOke 1LRoZc6eIL5DPSc +Jiukkxl5yUueJOUvd3Y3e0bxnQqwPjnYvBta8p7HUGF2Fs8cHMfGBuCsvjqf2pqs4BVcgdZb4xnvVJUvTIlnCckgHs8yXlWtMtgv +nNJ34AkMxBSzWanNsWWHtE7Pnn5Ea3D80CIVB9Ld85aSNWrfWLp0Pe5mOw7VQ5YBak4TPHjmQDX1KyEbdYvCkVBdymSxDP8NUBa8 +WnCCYghXUFDHEccoqmPlFwRREV7KwuXqI0UnaLQYDE7U9H5qcRIi1hX2vjs02KYYDykGBYYfXrtSXg2JBCtXkeogKaOQPTpVUv2c +zs CbrnVrA7i5oiDDAsglO0Ta sa5f6mXYUgIN64m3zpmqsLQbCRKLkKYfQ8sbH7Sdcd3oDnp70dbSg0JtuAD64hucNRE h +JRrn4fzfDz35Ho8yuRDN4Fn0JZKbJBamM7Ugn9nSldmMwIqsWIIQG5JAomGveR7XZFal2XIotpPujUmQ1G8D4aFtwUn3j6n6olgW +hiaOzdzuBXFPGPZOhjshexl5jGUxTRIZl1jCWCMW1fyKtEDReYhhfjEdeV8Os9OwgZP73TmuyG8Pw1XbMWkxt25I9JWF0DLYaUwx +8hOKeNzko QDzJL97X O5wI5k0OSrUDjxA97lYNGCTyGww0neGp RW1DUaJTfaWsMXsR1SzkQ4NqNgraLRgZJYm +NSEeFJ8CpEsK5MHx2rHGSGQamJl5bhOEpTa5gghVl0Vi3q +l77M6H27VVICru1xXUgoQ8iahSjrJTWdofNKswdORFLTn5QGGrHX0XnN2ubp9E38B6wsswuzLOlPswu93RGDw pTFk65uWoc +4XANAZojJHgREiWaG5T4GvW4y0vhUrrmjjFEQGPfwBMeDXNFji5v +KLATcQroa5yJ4XTZtqTAfy316iCSJ1Ea8KestkkNfpBpuwbD1b0JN7gQkqRz0FAcWg5XqeRGXfPA6psmiSs8uuVlF6 +a4xF24lzDQTr7DWloSLJWhCuwNkK9acMYh06NUXVwnA0MVqkqyjNnShsWl8H4oQv5Nsf3Kbcg7R7AYwqbIyyvoi1L0OMG2icFaTU +veRNQRxoXZ0TwV0BDeNUWpOTgf9BBSXrpU9gHePT88AzPlGDTAawY6kCoekbUMntEaXY0vAVVHp R362Ou LOObMUiodtscmyL5 +cdTV6u6EWPl01fTH0FUZ2H0V4W8z44F4Gh2ydhSgI5uRlGZWCpidd2ZQPPSU44nGR59YGAbBGs3g8yFVmh3S2ZDiAoHPRdGUUVbD +O6yXceTzh0ax9buiGdvRVS6KsykYClnlACuhL3B3cZXletNklhYjd4iM10VIfUqmsd1O1eFmRa0awYKiLYWyXq6jKYA61uQlyj1D +i4k0S00cPzV8xAzE1ytC4 E4oQkbgweEF1R lPKNmluEfUFGioa6Rah2KecZ7d1Lh6uQdNNgD0s eUS5ySCPMxouDK8 +0HgjteGUDEcipVohCCBKBOiZUciFI6DvSAiuPJ7sfXEN8wOnmf1REzGhvvctZOgXVTBLlwrNFxR5iCGxGJ6vj8aCaGdAiHusVcHV +62LhpLay021xMEDPxkFKIcucN3tMmAeY75U3aPMPWhE42jEGZb9xsl2WuqH1MHpybhKP207Xva8KpgDmh36bFjN2AKSvtRYEBT9l +LWkQ1I2k3mRg5AUHmufZuRLFl8mK9PlfswEE9kK5KpOWQdULt0PbAuxG35WTQpGuIwMiMiGQhRqJdoYpyqsp5IChwrTHpdoR8vuZ +GruCxRwK5X8s2E0mwJ6NpC5DOEcNKbU2NU3a4fAsfMfCr2ENRbe6SwrihPx2n3GojnoQjoSA5t9nVk6ZT +tyCDw51m6ycbu37bPuiuoz76Zh +pgRi400F8WY82Qj8ze2OyWRrtAmgdSPhaTTfrsMne6Ug5S0CI72XWpcrTLq3IMe1RaaPujHLRbt6TeUSjcvDLizBMAHLXl5K5GS5 +B2NzwHeRY32toI78mq +aQQgMWn70ZyPCXIoMBRB72AwaVkatE5BhYxNuhX9hZBu8oCQuVoLF4IOeTkGHK2gckjFZBkOiRDsKg3B7YYN3NtT2Xfr +0Ty0o3QOim0BeJsaaR8rhFISxPf1iX8IfroC2dj8Yc QT06CFy5oeLhFTdjQoYrHUWpgupG9G4pXHLpG5tk03TFDBa6ExHnvRx +uggfzWdjjrC4hple6IJmJfAZmtXXHXzLJE9VDxquA +Xv1ABk8D8GBAXFc78pUQbC9TVoyQAHI0R3GUSkoJyoql8lRc2fI9BmAYl61BGAxG7r5jre14oQNxqN5JHj6guic9EqsYVoUNbQZX +ogqLoERowSmByIgpTZSQOaIrNwy3PtWpcSOR7QgNZCAFcv7h4bm4vcRJOknBhMouP6jAHyrRnxAK7jSnUOG9cMZecHhQgbzGSMJw +Oj +iJu1iZRbPgiO4LldaJwpEHGKk3DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16384.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16384.expected new file mode 100644 index 00000000000..88d4bdf6c0e --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16384.expected @@ -0,0 +1,205 @@ +IYEb4HhrrfixUC8j +J2 PNukXTyPowk2P490ZRC hjIqTv3QZxI7 wrsa0rJ8ixaNmZ3Za evP5y6eRvwSwJng787yQzpVi3wCDBw XrEPBJ0 +t2BMpq3evy3ELNduHoifzv6jkN0gJy9o +99sUZ34ro19oJd3UTlLLvi8h8vwToC3ijOEXhY8abO4dCMZUhwj8QlYdDC0JmtAXLO9CEZ0dWZXAMvXgDaorn7CDVBks2Qa7aMkN +1JClm9DlcPR65EKgtPeh +wdteBwA8oEHKRttRIEGI8IstPh2s75Sc9mg0LFG4tn256bBycdcJu4yj6bjBYN13U2dsKkrsJuonekqCOaTTtKudcIwAqRFnZYSa +eXQuRchTkAoQQdZMOejbLczo975o4h0rnt0UvAgU53n +8BYujbW5W2X50yUfshDCtEra20Nx9rJnMAtCkw8QgfECDM988y4A5FGw1sOSyaNch4 +Y47fv7VGVhfl9NG9ByImguZRrYZ3En0DYy2P0G1ufy7xplzshenzxNEjwTe3UR9G83VUs6obeSVCYBAo7pBmaQxH 9f5f9Mv +4oC5X0WDLvadtlM0NNmyDKYfzgw3JTGXDzPGVl7WkL5hsec6MbwS6l0Q7ruX0WtU1WVD8vyCBmVcr2q9DtmgHqclSbMoHXokGFkY +knfOZFLg9DrRkWp3VZfVLYKgsi6pCv 9J7JUWTWxRXLpSszJpKvQbbLa1BYpw0hI3LwgEbX +6ttL77Ak2kox3W9QqdzwQLmTh45n1rwe2daWBRpzwOq33LEBG1nwOlPY5tve0iH5z4T2Vs7cBj6BrOFc8OgS1RXygUURmkmZvYC9 +7XuL HJk8TMOkeCLMZzoJZ9EZVAJXQO9lHftsvw05CwmcscDV7QuRmuwQBD6f4qAnr35io +xNyNC60pDHAKQOV4sIbyoUra8u78PMofY52BjsfFySGZenDGkc4joegzKdogbeQeEjRRD3pPX1CjGu +NtxYCePWXkwgYoxasuDn0ULgaJ9rTD BjglBpG3kpRBB84GwJzfjh8dEmRmKMxsPA8K KpGfjhm +EEVeLcH2t16Se4FZkLSFzADooDijqm60lvxSOpe2LGGhXa94dQmMTESl6FPVqchzKKQuMg77ulrF7GSUosvw4Ry5oLJEQGPqHuxs +jCcE238RM7JOGHwDomNGHoyY0LIYO2dqIcxNOMqvVcFLqCwxnWnX6N zWqHH4ACm1EbtXCACZAOtGsPsM4DdXw +DyqJiYYqBZZAZ0jyvwF2Rzm7DDpWtphJFvKaCvi1n4lf3lBQe FRzakzcOm1sP3q5BMwWDQjcKIhKCsTR4KsqAQWM2cef1 +CTOu64tjU65CzlCmns0QSG8PpqeXLZGo32GbMz1dsSU3byFdXvUfLInNPWTQIGj9tmeGnDzeBihPKIwOQzeB +4oyVwRjiyn0pyMWZ0ChczKOLO57DxwNd4v38dZ 1nIVIVSxlVl0GH4v4tt9judjPKvsMxrAxJq7cDbK bVlc9EcVvTR +ikVAsOiY5ZQT7Y88wh4clEB7lV 8kTSte3RXOTA +1bVCT7yBXD3Es6yezJWm7hdz6vZPaIIOX2l0fTUXB8RfxTq3Kaj6lmQJnuItDJncz6AaYbjXe95W3Vmp0PS3ATEzdG9mEZwSymjd +egkKfFTdY4kx6EnInnegVUFBDalZa5z9ubx3eu6nHD7zfYkjFWUMaLSgwVKjJpsYcw3DtHlfhLWo1nwC9hTX89vCEShI4bcsnlJ7 +3jyOhJSBOym5T55E8F154bYhF4dnwt6q2DRPnenggO1d04bJbVhRbfTgbhGPen3mO5VaU2Z63Rs7q9kp8CsJwPtO5Bp0LC0sTh4Q + +0fJLwkEdB9cY9rVMHpMpRq30e3X1YdchhB8mOkKBXCCaS9WhoBXZYV4zS0R1LOCC5OqHu8TxDJ6p3rOoGxM2s1KzJMZlweexZzSa +ovcwhSG UZ2TTYIan8vFvreBtkSyxmlnQsUyfZnajIPFZeNE +IGu8JRG1yuZuCq0xNPJ19G1ysunyc3X57fORpykArVk2TVQhsBlvsqsloPMMd9FKOSTc0jZsnJf2nLujBuHP5vwqrytGCZMh3mI1 +rZz f5h5RW4JYTtZbd8yeqAF6Hxmze5KaG0jLI7XWIA2ZbVzKLJRydDZu7tiRyNSNjXdw5MuFDgSudZcav3WHJyO OXQ +S4KSuD4dKkPL2hDwuHVwVf6L7hNvyLC5EuqZN1JIgbYiozbhmhU6CKqDLoOdsxFZsr5Uy5F4j3GruUTukaxxIXV9THGDm3E35XGy +OYLvjv2YQWsT5eiWnm5AFuGUBI8pdDSVdnvLPW1Gm9Blb3lQU6xwJsUIWw11NWLmCSf2Aj9olkGXtxWXhji1ypQhQd2GKZUodWyH +gLRGD6QucBcQI5VI8fjoQGWPAgtoWhgsKDGbG6ZH2x9YoFWgWJc OsB1rt7pUWu3vyBueDujMduUejf7RdLO +KqnRyHahI19I5jLVHLKGyNWrbvb9sxEhKPyZEKop +uRCHEXbWRYGZhPks3Q3Wcjvaea8oeuguFZqZVkd0fVpgX8WDleCk8ZqWU1eQbVWjgzaxTNJB23qqMYl6YJFczQb4TkE3GGgDYS3J +cSP1D3qqirQASr42pWt2PBOF7OaRzjD6HUn8MtGF1wyPPWrORXAx3pWPtl4KqVXdsDDFD 6RgMB +ekLwEfmUgQsMsCwBvzkO6H2sJyVJnJ1lpwcsXvJj5skReQdBulviH1NLUIx6KnpIquID2WoY7BoAajF5I evPqde68gP9jb7B +FEawPc OpvimjyZAes9sdECf3B2JF fIChuOk8iDpcneQ1bwseUKjXr7pON6pOc9UaU87Iu +NHD2joerAZTwSMPBAPMRRXNzNLaSIbIrwbzMBNHJrevadSa nY2CfcuuQw5 C0cTEl1ahv6B94v61xTdPXlwMGVYY +7I8Mg2wvMqGLUAbpJtwN2HSFlutq4L2hIF1K08MyKpvI20e0IegHjIHyTuZ1uzZFtQ86Euh1uyI +r6rBVKxfnFihxTPfBBMLo9UXER 4tHUGvLZLPATCdaV4rfT6RmUowQ09KGFxiRdUC +EOEroqWa4gLkFgDHDYEUdYAA2OYGrMPqzilN7OLJqaWmFudOHTRFB6MSSpOCeGLNbGAkT7adB4J9ucX035wU3YTSPAehBbzIe5Aq +vmHRBFC6l FLY2MdW2qGIGjAgQwZMND42REPfVmFmn7HrDo Eoxwjaxzutvua xfqbd1w70 +G43CnoGLCkxmHCiJ1CBHtFA3ytIX5aXiaZkFL47OcLC3u46Lv0TnQdjnGtew5I9YCSq7Y4342RtnQae6dsSfrwaqa2WtYASIDDuW +3PCri8Hd07miGhuRrwrwZCi7NN1q6cGvsCjgQCDzbwlnXd3lrB1ilFX2pAw24 20rp6tW78 7Csmtkjhu2oPIwSO2A +r7m47cYIDK +hpJ7OVfU98IYdwXAy230328Hwyn5bLldYAdvWDnkthFsWxi7wXROx08xhSDRn4i232OY0Jpl2PkSbX5mK3aEjbamS8tpp8gKnF +JjR2XpPFzk7BmeHedc5KSFQl1AFH 3DzxlnyQd5ebjS3Bqd8qHc2LbSTcnqDkVrRvRBLmkhtWCTbpHm05COf 52nO1gcPe +8THe9oE8LrkF0uZKgXLsSkCIq82PFhsv7WaR1CcwXIKToOe8OeFWjUORkmYw4EfKEwVoK6786bf9H3Zv5EMCpWthC8c2mREEdIdj +AQ2ZE7YmIhqJvtby7q vkf2t7hWc6K8Bz9TG8U0XZxRfq0m Ci9joyI3Wfen +dZinbVG6q5PHjKv8ImrXM5D6u3fXCacFyYG8KJoe01bfyD1vw9foYMPCEL1aGo6Uph6bQRNvVsImOd2r5Zvg8staHtt7IsAwiKou +KNuIH7UyLjCH +ABkyySlH5b2e8lZxpQKkHqIChY5xe3uzK1cVwwjrk38LLmKpXlv5GqcHZLEmM31ZaJ9nJ1dAOoqVGw2xjNuqgDi62NgLdyN8bnqD +CSH5kvYfOkxVgN9H196mcpJF2E1IVzjqJeTeJfuBKrE +iUaFSINIPMmYTqMWEtJBestMGF9RQKEtQCPCbIiqwl3kA8EXMkgU9dQSZvJR0DymlBBQ6MUfVqFbblexcUaZIRclnogDPfawyphL +2HXcmB7py2qyWWqbiUBFQCkg3Ic41tpFy7I58BZ46XVhw07jio W7v8PoqvgG1wOV7f8fuiuXvPlQoC2lY07wm0 nQgRok +w3JrHmwWyKmRLhJrrk9jjHhoiTGuLE3j4tsciZlwfhQprtYIkKVez2pr4YlNNYcRvLq0kWQDFo3BohylWpPaO5 +i7lLo7pmeACCHzh4jXoNuBBSOCTRKRi1KEdeWqPH1BUHlhzHKzrXJFL1gmcspqNO2h6dmEwHSlKIowLeaZUyCXMZC4iz8BckLNE0 +feeyDvyILnsWK8ysQZ7WrV1BlJpVxkeULrT5TaKUC8BcNnPWQZeIGC9eOROCmoBmRhnyoXBSWEkOIBgl0MqJ5uub6kdxMGSh76D1 +3NQkbCAHJeCDltw5P8ivcicJZIKiqZ PzAZQItATtQWTyX5zJkFjYG1iQb0N4ssd +O7oMoWi3eKwNRJFMt0ipSs3eaI5W06ncBWdiFWIb4sg6onYSSrwlGkhe8W6fSBHWf PowV2RJb1hlYV88oaCdvFv21SPC8nJQ +U1iITVNuOAw6zhEZOc8z MpFsl4q9kulMJ8cjvW7EI1FfikBXDThfFxPHWu +G1DV05xMQIxLgG5NFmJnSXBmKi2pkZNii303wKIqmL4Qz0xi9MznIBbKob56ZSH01lB9zgll7C9W8gwlDxpfduiQ4pkANDmDSgns +pn4yak7rgCezcCP46lIRVFcZr6HM9JwP3ejcLoLLdAm0GM0ovbrwFIBnZRbzXNjWqfdTYiTCqyYxr4TzXFGgxv3 +VzPVnagOAzhzpbJSAf8arLn7ZCL9Nt7EXYX8OL3S2ocutTJ3snzyVbaxoAX9cefUMaM6JWcR2s8pB6pVFTjGl7p6aN11DiBXmXb4 +V VcleLQyNYWYQv3z8grpAWYsSlMFGu3KRa7dWaiiH2t +q3jSX6ZY7929tTGA0YP8lDhro5X83MKFjL4201yatzDb4HaTjuQLRpXVAZy5lqHQyMJmdQqn1 Si2 D NYRhpHl5VKr +6JMzwA00ZRVy1Z2hI1WxV7wSyIXR +MNm2hwXasuvK2pjoihAkXzoUtuYDhqBFFqWsYRW3njSteQPb9srNSBNE4UM9tR8Fp3lmLB6jJpFu3OQnVCiLEUHkUBBWeUNna0S8 +S5ETB5w8Z8pxy55mrppkTE4x85VRzhErGFeRAUBfuJtManvRtMpTBpsjuro27yLjyGWwUTnhUh7Ga2MIu4aTIHpgU7mk Rc qAv +22xdHaKlod6f4Gbpk8SRo1WlkqYDWw0kLXCXeNCZ3Azu8M0nRtOQLx9zGyHizMClckRWFFZqFYKOPrGdMuTCUdHELsSMWEgl6Daj +sDWuyiHvPzaQrq1NM0Ryy4VUwwgKOi c2Elp6skrC4kLgg7qyIO5HOke 1LRoZc6eIL5DPSc +Jiukkxl5yUueJOUvd3Y3e0bxnQqwPjnYvBta8p7HUGF2Fs8cHMfGBuCsvjqf2pqs4BVcgdZb4xnvVJUvTIlnCckgHs8yXlWtMtgv +nNJ34AkMxBSzWanNsWWHtE7Pnn5Ea3D80CIVB9Ld85aSNWrfWLp0Pe5mOw7VQ5YBak4TPHjmQDX1KyEbdYvCkVBdymSxDP8NUBa8 +WnCCYghXUFDHEccoqmPlFwRREV7KwuXqI0UnaLQYDE7U9H5qcRIi1hX2vjs02KYYDykGBYYfXrtSXg2JBCtXkeogKaOQPTpVUv2c +zs CbrnVrA7i5oiDDAsglO0Ta sa5f6mXYUgIN64m3zpmqsLQbCRKLkKYfQ8sbH7Sdcd3oDnp70dbSg0JtuAD64hucNRE h +JRrn4fzfDz35Ho8yuRDN4Fn0JZKbJBamM7Ugn9nSldmMwIqsWIIQG5JAomGveR7XZFal2XIotpPujUmQ1G8D4aFtwUn3j6n6olgW +hiaOzdzuBXFPGPZOhjshexl5jGUxTRIZl1jCWCMW1fyKtEDReYhhfjEdeV8Os9OwgZP73TmuyG8Pw1XbMWkxt25I9JWF0DLYaUwx +8hOKeNzko QDzJL97X O5wI5k0OSrUDjxA97lYNGCTyGww0neGp RW1DUaJTfaWsMXsR1SzkQ4NqNgraLRgZJYm +NSEeFJ8CpEsK5MHx2rHGSGQamJl5bhOEpTa5gghVl0Vi3q +l77M6H27VVICru1xXUgoQ8iahSjrJTWdofNKswdORFLTn5QGGrHX0XnN2ubp9E38B6wsswuzLOlPswu93RGDw pTFk65uWoc +4XANAZojJHgREiWaG5T4GvW4y0vhUrrmjjFEQGPfwBMeDXNFji5v +KLATcQroa5yJ4XTZtqTAfy316iCSJ1Ea8KestkkNfpBpuwbD1b0JN7gQkqRz0FAcWg5XqeRGXfPA6psmiSs8uuVlF6 +a4xF24lzDQTr7DWloSLJWhCuwNkK9acMYh06NUXVwnA0MVqkqyjNnShsWl8H4oQv5Nsf3Kbcg7R7AYwqbIyyvoi1L0OMG2icFaTU +veRNQRxoXZ0TwV0BDeNUWpOTgf9BBSXrpU9gHePT88AzPlGDTAawY6kCoekbUMntEaXY0vAVVHp R362Ou LOObMUiodtscmyL5 +cdTV6u6EWPl01fTH0FUZ2H0V4W8z44F4Gh2ydhSgI5uRlGZWCpidd2ZQPPSU44nGR59YGAbBGs3g8yFVmh3S2ZDiAoHPRdGUUVbD +O6yXceTzh0ax9buiGdvRVS6KsykYClnlACuhL3B3cZXletNklhYjd4iM10VIfUqmsd1O1eFmRa0awYKiLYWyXq6jKYA61uQlyj1D +i4k0S00cPzV8xAzE1ytC4 E4oQkbgweEF1R lPKNmluEfUFGioa6Rah2KecZ7d1Lh6uQdNNgD0s eUS5ySCPMxouDK8 +0HgjteGUDEcipVohCCBKBOiZUciFI6DvSAiuPJ7sfXEN8wOnmf1REzGhvvctZOgXVTBLlwrNFxR5iCGxGJ6vj8aCaGdAiHusVcHV +62LhpLay021xMEDPxkFKIcucN3tMmAeY75U3aPMPWhE42jEGZb9xsl2WuqH1MHpybhKP207Xva8KpgDmh36bFjN2AKSvtRYEBT9l +LWkQ1I2k3mRg5AUHmufZuRLFl8mK9PlfswEE9kK5KpOWQdULt0PbAuxG35WTQpGuIwMiMiGQhRqJdoYpyqsp5IChwrTHpdoR8vuZ +GruCxRwK5X8s2E0mwJ6NpC5DOEcNKbU2NU3a4fAsfMfCr2ENRbe6SwrihPx2n3GojnoQjoSA5t9nVk6ZT +tyCDw51m6ycbu37bPuiuoz76Zh +pgRi400F8WY82Qj8ze2OyWRrtAmgdSPhaTTfrsMne6Ug5S0CI72XWpcrTLq3IMe1RaaPujHLRbt6TeUSjcvDLizBMAHLXl5K5GS5 +B2NzwHeRY32toI78mq +aQQgMWn70ZyPCXIoMBRB72AwaVkatE5BhYxNuhX9hZBu8oCQuVoLF4IOeTkGHK2gckjFZBkOiRDsKg3B7YYN3NtT2Xfr +0Ty0o3QOim0BeJsaaR8rhFISxPf1iX8IfroC2dj8Yc QT06CFy5oeLhFTdjQoYrHUWpgupG9G4pXHLpG5tk03TFDBa6ExHnvRx +uggfzWdjjrC4hple6IJmJfAZmtXXHXzLJE9VDxquA +Xv1ABk8D8GBAXFc78pUQbC9TVoyQAHI0R3GUSkoJyoql8lRc2fI9BmAYl61BGAxG7r5jre14oQNxqN5JHj6guic9EqsYVoUNbQZX +ogqLoERowSmByIgpTZSQOaIrNwy3PtWpcSOR7QgNZCAFcv7h4bm4vcRJOknBhMouP6jAHyrRnxAK7jSnUOG9cMZecHhQgbzGSMJw +Oj +iJu1iZRbPgiO4LldaJwpEHGKk3DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16385.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16385.expected new file mode 100644 index 00000000000..32b6b3dc600 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-16385.expected @@ -0,0 +1,205 @@ +NIYEb4HhrrfixUC8j +J2 PNukXTyPowk2P490ZRC hjIqTv3QZxI7 wrsa0rJ8ixaNmZ3Za evP5y6eRvwSwJng787yQzpVi3wCDBw XrEPBJ0 +t2BMpq3evy3ELNduHoifzv6jkN0gJy9o +99sUZ34ro19oJd3UTlLLvi8h8vwToC3ijOEXhY8abO4dCMZUhwj8QlYdDC0JmtAXLO9CEZ0dWZXAMvXgDaorn7CDVBks2Qa7aMkN +1JClm9DlcPR65EKgtPeh +wdteBwA8oEHKRttRIEGI8IstPh2s75Sc9mg0LFG4tn256bBycdcJu4yj6bjBYN13U2dsKkrsJuonekqCOaTTtKudcIwAqRFnZYSa +eXQuRchTkAoQQdZMOejbLczo975o4h0rnt0UvAgU53n +8BYujbW5W2X50yUfshDCtEra20Nx9rJnMAtCkw8QgfECDM988y4A5FGw1sOSyaNch4 +Y47fv7VGVhfl9NG9ByImguZRrYZ3En0DYy2P0G1ufy7xplzshenzxNEjwTe3UR9G83VUs6obeSVCYBAo7pBmaQxH 9f5f9Mv +4oC5X0WDLvadtlM0NNmyDKYfzgw3JTGXDzPGVl7WkL5hsec6MbwS6l0Q7ruX0WtU1WVD8vyCBmVcr2q9DtmgHqclSbMoHXokGFkY +knfOZFLg9DrRkWp3VZfVLYKgsi6pCv 9J7JUWTWxRXLpSszJpKvQbbLa1BYpw0hI3LwgEbX +6ttL77Ak2kox3W9QqdzwQLmTh45n1rwe2daWBRpzwOq33LEBG1nwOlPY5tve0iH5z4T2Vs7cBj6BrOFc8OgS1RXygUURmkmZvYC9 +7XuL HJk8TMOkeCLMZzoJZ9EZVAJXQO9lHftsvw05CwmcscDV7QuRmuwQBD6f4qAnr35io +xNyNC60pDHAKQOV4sIbyoUra8u78PMofY52BjsfFySGZenDGkc4joegzKdogbeQeEjRRD3pPX1CjGu +NtxYCePWXkwgYoxasuDn0ULgaJ9rTD BjglBpG3kpRBB84GwJzfjh8dEmRmKMxsPA8K KpGfjhm +EEVeLcH2t16Se4FZkLSFzADooDijqm60lvxSOpe2LGGhXa94dQmMTESl6FPVqchzKKQuMg77ulrF7GSUosvw4Ry5oLJEQGPqHuxs +jCcE238RM7JOGHwDomNGHoyY0LIYO2dqIcxNOMqvVcFLqCwxnWnX6N zWqHH4ACm1EbtXCACZAOtGsPsM4DdXw +DyqJiYYqBZZAZ0jyvwF2Rzm7DDpWtphJFvKaCvi1n4lf3lBQe FRzakzcOm1sP3q5BMwWDQjcKIhKCsTR4KsqAQWM2cef1 +CTOu64tjU65CzlCmns0QSG8PpqeXLZGo32GbMz1dsSU3byFdXvUfLInNPWTQIGj9tmeGnDzeBihPKIwOQzeB +4oyVwRjiyn0pyMWZ0ChczKOLO57DxwNd4v38dZ 1nIVIVSxlVl0GH4v4tt9judjPKvsMxrAxJq7cDbK bVlc9EcVvTR +ikVAsOiY5ZQT7Y88wh4clEB7lV 8kTSte3RXOTA +1bVCT7yBXD3Es6yezJWm7hdz6vZPaIIOX2l0fTUXB8RfxTq3Kaj6lmQJnuItDJncz6AaYbjXe95W3Vmp0PS3ATEzdG9mEZwSymjd +egkKfFTdY4kx6EnInnegVUFBDalZa5z9ubx3eu6nHD7zfYkjFWUMaLSgwVKjJpsYcw3DtHlfhLWo1nwC9hTX89vCEShI4bcsnlJ7 +3jyOhJSBOym5T55E8F154bYhF4dnwt6q2DRPnenggO1d04bJbVhRbfTgbhGPen3mO5VaU2Z63Rs7q9kp8CsJwPtO5Bp0LC0sTh4Q + +0fJLwkEdB9cY9rVMHpMpRq30e3X1YdchhB8mOkKBXCCaS9WhoBXZYV4zS0R1LOCC5OqHu8TxDJ6p3rOoGxM2s1KzJMZlweexZzSa +ovcwhSG UZ2TTYIan8vFvreBtkSyxmlnQsUyfZnajIPFZeNE +IGu8JRG1yuZuCq0xNPJ19G1ysunyc3X57fORpykArVk2TVQhsBlvsqsloPMMd9FKOSTc0jZsnJf2nLujBuHP5vwqrytGCZMh3mI1 +rZz f5h5RW4JYTtZbd8yeqAF6Hxmze5KaG0jLI7XWIA2ZbVzKLJRydDZu7tiRyNSNjXdw5MuFDgSudZcav3WHJyO OXQ +S4KSuD4dKkPL2hDwuHVwVf6L7hNvyLC5EuqZN1JIgbYiozbhmhU6CKqDLoOdsxFZsr5Uy5F4j3GruUTukaxxIXV9THGDm3E35XGy +OYLvjv2YQWsT5eiWnm5AFuGUBI8pdDSVdnvLPW1Gm9Blb3lQU6xwJsUIWw11NWLmCSf2Aj9olkGXtxWXhji1ypQhQd2GKZUodWyH +gLRGD6QucBcQI5VI8fjoQGWPAgtoWhgsKDGbG6ZH2x9YoFWgWJc OsB1rt7pUWu3vyBueDujMduUejf7RdLO +KqnRyHahI19I5jLVHLKGyNWrbvb9sxEhKPyZEKop +uRCHEXbWRYGZhPks3Q3Wcjvaea8oeuguFZqZVkd0fVpgX8WDleCk8ZqWU1eQbVWjgzaxTNJB23qqMYl6YJFczQb4TkE3GGgDYS3J +cSP1D3qqirQASr42pWt2PBOF7OaRzjD6HUn8MtGF1wyPPWrORXAx3pWPtl4KqVXdsDDFD 6RgMB +ekLwEfmUgQsMsCwBvzkO6H2sJyVJnJ1lpwcsXvJj5skReQdBulviH1NLUIx6KnpIquID2WoY7BoAajF5I evPqde68gP9jb7B +FEawPc OpvimjyZAes9sdECf3B2JF fIChuOk8iDpcneQ1bwseUKjXr7pON6pOc9UaU87Iu +NHD2joerAZTwSMPBAPMRRXNzNLaSIbIrwbzMBNHJrevadSa nY2CfcuuQw5 C0cTEl1ahv6B94v61xTdPXlwMGVYY +7I8Mg2wvMqGLUAbpJtwN2HSFlutq4L2hIF1K08MyKpvI20e0IegHjIHyTuZ1uzZFtQ86Euh1uyI +r6rBVKxfnFihxTPfBBMLo9UXER 4tHUGvLZLPATCdaV4rfT6RmUowQ09KGFxiRdUC +EOEroqWa4gLkFgDHDYEUdYAA2OYGrMPqzilN7OLJqaWmFudOHTRFB6MSSpOCeGLNbGAkT7adB4J9ucX035wU3YTSPAehBbzIe5Aq +vmHRBFC6l FLY2MdW2qGIGjAgQwZMND42REPfVmFmn7HrDo Eoxwjaxzutvua xfqbd1w70 +G43CnoGLCkxmHCiJ1CBHtFA3ytIX5aXiaZkFL47OcLC3u46Lv0TnQdjnGtew5I9YCSq7Y4342RtnQae6dsSfrwaqa2WtYASIDDuW +3PCri8Hd07miGhuRrwrwZCi7NN1q6cGvsCjgQCDzbwlnXd3lrB1ilFX2pAw24 20rp6tW78 7Csmtkjhu2oPIwSO2A +r7m47cYIDK +hpJ7OVfU98IYdwXAy230328Hwyn5bLldYAdvWDnkthFsWxi7wXROx08xhSDRn4i232OY0Jpl2PkSbX5mK3aEjbamS8tpp8gKnF +JjR2XpPFzk7BmeHedc5KSFQl1AFH 3DzxlnyQd5ebjS3Bqd8qHc2LbSTcnqDkVrRvRBLmkhtWCTbpHm05COf 52nO1gcPe +8THe9oE8LrkF0uZKgXLsSkCIq82PFhsv7WaR1CcwXIKToOe8OeFWjUORkmYw4EfKEwVoK6786bf9H3Zv5EMCpWthC8c2mREEdIdj +AQ2ZE7YmIhqJvtby7q vkf2t7hWc6K8Bz9TG8U0XZxRfq0m Ci9joyI3Wfen +dZinbVG6q5PHjKv8ImrXM5D6u3fXCacFyYG8KJoe01bfyD1vw9foYMPCEL1aGo6Uph6bQRNvVsImOd2r5Zvg8staHtt7IsAwiKou +KNuIH7UyLjCH +ABkyySlH5b2e8lZxpQKkHqIChY5xe3uzK1cVwwjrk38LLmKpXlv5GqcHZLEmM31ZaJ9nJ1dAOoqVGw2xjNuqgDi62NgLdyN8bnqD +CSH5kvYfOkxVgN9H196mcpJF2E1IVzjqJeTeJfuBKrE +iUaFSINIPMmYTqMWEtJBestMGF9RQKEtQCPCbIiqwl3kA8EXMkgU9dQSZvJR0DymlBBQ6MUfVqFbblexcUaZIRclnogDPfawyphL +2HXcmB7py2qyWWqbiUBFQCkg3Ic41tpFy7I58BZ46XVhw07jio W7v8PoqvgG1wOV7f8fuiuXvPlQoC2lY07wm0 nQgRok +w3JrHmwWyKmRLhJrrk9jjHhoiTGuLE3j4tsciZlwfhQprtYIkKVez2pr4YlNNYcRvLq0kWQDFo3BohylWpPaO5 +i7lLo7pmeACCHzh4jXoNuBBSOCTRKRi1KEdeWqPH1BUHlhzHKzrXJFL1gmcspqNO2h6dmEwHSlKIowLeaZUyCXMZC4iz8BckLNE0 +feeyDvyILnsWK8ysQZ7WrV1BlJpVxkeULrT5TaKUC8BcNnPWQZeIGC9eOROCmoBmRhnyoXBSWEkOIBgl0MqJ5uub6kdxMGSh76D1 +3NQkbCAHJeCDltw5P8ivcicJZIKiqZ PzAZQItATtQWTyX5zJkFjYG1iQb0N4ssd +O7oMoWi3eKwNRJFMt0ipSs3eaI5W06ncBWdiFWIb4sg6onYSSrwlGkhe8W6fSBHWf PowV2RJb1hlYV88oaCdvFv21SPC8nJQ +U1iITVNuOAw6zhEZOc8z MpFsl4q9kulMJ8cjvW7EI1FfikBXDThfFxPHWu +G1DV05xMQIxLgG5NFmJnSXBmKi2pkZNii303wKIqmL4Qz0xi9MznIBbKob56ZSH01lB9zgll7C9W8gwlDxpfduiQ4pkANDmDSgns +pn4yak7rgCezcCP46lIRVFcZr6HM9JwP3ejcLoLLdAm0GM0ovbrwFIBnZRbzXNjWqfdTYiTCqyYxr4TzXFGgxv3 +VzPVnagOAzhzpbJSAf8arLn7ZCL9Nt7EXYX8OL3S2ocutTJ3snzyVbaxoAX9cefUMaM6JWcR2s8pB6pVFTjGl7p6aN11DiBXmXb4 +V VcleLQyNYWYQv3z8grpAWYsSlMFGu3KRa7dWaiiH2t +q3jSX6ZY7929tTGA0YP8lDhro5X83MKFjL4201yatzDb4HaTjuQLRpXVAZy5lqHQyMJmdQqn1 Si2 D NYRhpHl5VKr +6JMzwA00ZRVy1Z2hI1WxV7wSyIXR +MNm2hwXasuvK2pjoihAkXzoUtuYDhqBFFqWsYRW3njSteQPb9srNSBNE4UM9tR8Fp3lmLB6jJpFu3OQnVCiLEUHkUBBWeUNna0S8 +S5ETB5w8Z8pxy55mrppkTE4x85VRzhErGFeRAUBfuJtManvRtMpTBpsjuro27yLjyGWwUTnhUh7Ga2MIu4aTIHpgU7mk Rc qAv +22xdHaKlod6f4Gbpk8SRo1WlkqYDWw0kLXCXeNCZ3Azu8M0nRtOQLx9zGyHizMClckRWFFZqFYKOPrGdMuTCUdHELsSMWEgl6Daj +sDWuyiHvPzaQrq1NM0Ryy4VUwwgKOi c2Elp6skrC4kLgg7qyIO5HOke 1LRoZc6eIL5DPSc +Jiukkxl5yUueJOUvd3Y3e0bxnQqwPjnYvBta8p7HUGF2Fs8cHMfGBuCsvjqf2pqs4BVcgdZb4xnvVJUvTIlnCckgHs8yXlWtMtgv +nNJ34AkMxBSzWanNsWWHtE7Pnn5Ea3D80CIVB9Ld85aSNWrfWLp0Pe5mOw7VQ5YBak4TPHjmQDX1KyEbdYvCkVBdymSxDP8NUBa8 +WnCCYghXUFDHEccoqmPlFwRREV7KwuXqI0UnaLQYDE7U9H5qcRIi1hX2vjs02KYYDykGBYYfXrtSXg2JBCtXkeogKaOQPTpVUv2c +zs CbrnVrA7i5oiDDAsglO0Ta sa5f6mXYUgIN64m3zpmqsLQbCRKLkKYfQ8sbH7Sdcd3oDnp70dbSg0JtuAD64hucNRE h +JRrn4fzfDz35Ho8yuRDN4Fn0JZKbJBamM7Ugn9nSldmMwIqsWIIQG5JAomGveR7XZFal2XIotpPujUmQ1G8D4aFtwUn3j6n6olgW +hiaOzdzuBXFPGPZOhjshexl5jGUxTRIZl1jCWCMW1fyKtEDReYhhfjEdeV8Os9OwgZP73TmuyG8Pw1XbMWkxt25I9JWF0DLYaUwx +8hOKeNzko QDzJL97X O5wI5k0OSrUDjxA97lYNGCTyGww0neGp RW1DUaJTfaWsMXsR1SzkQ4NqNgraLRgZJYm +NSEeFJ8CpEsK5MHx2rHGSGQamJl5bhOEpTa5gghVl0Vi3q +l77M6H27VVICru1xXUgoQ8iahSjrJTWdofNKswdORFLTn5QGGrHX0XnN2ubp9E38B6wsswuzLOlPswu93RGDw pTFk65uWoc +4XANAZojJHgREiWaG5T4GvW4y0vhUrrmjjFEQGPfwBMeDXNFji5v +KLATcQroa5yJ4XTZtqTAfy316iCSJ1Ea8KestkkNfpBpuwbD1b0JN7gQkqRz0FAcWg5XqeRGXfPA6psmiSs8uuVlF6 +a4xF24lzDQTr7DWloSLJWhCuwNkK9acMYh06NUXVwnA0MVqkqyjNnShsWl8H4oQv5Nsf3Kbcg7R7AYwqbIyyvoi1L0OMG2icFaTU +veRNQRxoXZ0TwV0BDeNUWpOTgf9BBSXrpU9gHePT88AzPlGDTAawY6kCoekbUMntEaXY0vAVVHp R362Ou LOObMUiodtscmyL5 +cdTV6u6EWPl01fTH0FUZ2H0V4W8z44F4Gh2ydhSgI5uRlGZWCpidd2ZQPPSU44nGR59YGAbBGs3g8yFVmh3S2ZDiAoHPRdGUUVbD +O6yXceTzh0ax9buiGdvRVS6KsykYClnlACuhL3B3cZXletNklhYjd4iM10VIfUqmsd1O1eFmRa0awYKiLYWyXq6jKYA61uQlyj1D +i4k0S00cPzV8xAzE1ytC4 E4oQkbgweEF1R lPKNmluEfUFGioa6Rah2KecZ7d1Lh6uQdNNgD0s eUS5ySCPMxouDK8 +0HgjteGUDEcipVohCCBKBOiZUciFI6DvSAiuPJ7sfXEN8wOnmf1REzGhvvctZOgXVTBLlwrNFxR5iCGxGJ6vj8aCaGdAiHusVcHV +62LhpLay021xMEDPxkFKIcucN3tMmAeY75U3aPMPWhE42jEGZb9xsl2WuqH1MHpybhKP207Xva8KpgDmh36bFjN2AKSvtRYEBT9l +LWkQ1I2k3mRg5AUHmufZuRLFl8mK9PlfswEE9kK5KpOWQdULt0PbAuxG35WTQpGuIwMiMiGQhRqJdoYpyqsp5IChwrTHpdoR8vuZ +GruCxRwK5X8s2E0mwJ6NpC5DOEcNKbU2NU3a4fAsfMfCr2ENRbe6SwrihPx2n3GojnoQjoSA5t9nVk6ZT +tyCDw51m6ycbu37bPuiuoz76Zh +pgRi400F8WY82Qj8ze2OyWRrtAmgdSPhaTTfrsMne6Ug5S0CI72XWpcrTLq3IMe1RaaPujHLRbt6TeUSjcvDLizBMAHLXl5K5GS5 +B2NzwHeRY32toI78mq +aQQgMWn70ZyPCXIoMBRB72AwaVkatE5BhYxNuhX9hZBu8oCQuVoLF4IOeTkGHK2gckjFZBkOiRDsKg3B7YYN3NtT2Xfr +0Ty0o3QOim0BeJsaaR8rhFISxPf1iX8IfroC2dj8Yc QT06CFy5oeLhFTdjQoYrHUWpgupG9G4pXHLpG5tk03TFDBa6ExHnvRx +uggfzWdjjrC4hple6IJmJfAZmtXXHXzLJE9VDxquA +Xv1ABk8D8GBAXFc78pUQbC9TVoyQAHI0R3GUSkoJyoql8lRc2fI9BmAYl61BGAxG7r5jre14oQNxqN5JHj6guic9EqsYVoUNbQZX +ogqLoERowSmByIgpTZSQOaIrNwy3PtWpcSOR7QgNZCAFcv7h4bm4vcRJOknBhMouP6jAHyrRnxAK7jSnUOG9cMZecHhQgbzGSMJw +Oj +iJu1iZRbPgiO4LldaJwpEHGKk3DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8192.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8192.expected new file mode 100644 index 00000000000..a30c8ea3471 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8192.expected @@ -0,0 +1,105 @@ +ESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8193.expected b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8193.expected new file mode 100644 index 00000000000..b1e55dd70d7 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_24576_bytes_304_lines_c_-8193.expected @@ -0,0 +1,105 @@ +DESvmNPr1UGOMNJ9aw1ywapjn7YQScZTPpdAJIDX6eHBhdwnMllqNXx7swClNvjPSSyuAzyCYr +mV17sLUZjaT1cZcXGLUZl4wrzsq20GimhHuK75t1Dp0h86fw +J1ENeNpXfhVfTvIWj8CVukFBme66osxiRjGdSGGhiAAxHUSOsmKZBuePntuLnU5LZJYIWZeitP7I673IUE5VcENvLL46ENJqyF +NIcfNtyDhIsL0IZOXKbR1aGAw5V6TL002zgcJ9WLLU5kVuN5yEAEPduAzcfNoLjtZKLfta02uhidUaQwiK6wVwM2LtB5ERDNqF4u + F3tqz3OWd2HsqaqdU1mjisMajSPJlonJZsPfx5z5RDGA8YO5kQVKOjw6OP +tM5khFZBfxY27zqh3ZbaGV5q2Uq5crI9plcfvlQfEEqaLdkvIa0x9rqlHu4VVt2MiTCFUzItRGegcD25HijguQ05ZzsWWhjMkIL1 +VEY0FG1TWN2F4Z9An6dCOQI556VKEBDrUn50blILaMCp5FtVeM8uNaE1oafy1KVmdkaiHGZ8SRhNXryeo7pO +5BFbLdSpl4o8A2YeTrM0icxjvgisLGtlqmG1R9XF21jjFujQb1SxSmSxN5QyXb6qy9Fo2P3T9dXlIpoujTy9Ou6WLJHDc0eTYYSJ +JOJkdabqkOJhQveNnbr9T9r8FrMhgxRYWdf1wLnjArimj5I3ICesyCradGROWCQZx6XlW00DUzxV9jeNEgjDBkTWt0K7 v503 +g0NPccBf39qSyzlnZNCfS70oeK3fLALL9ENEHxubb5fb7pMf0CpEyVpXBkeJTulcph2EotUQxl7NiM65vgAExJASAUnyTmskiR7R +m7nQ8PiwNNNCaNGyYsRqWhj7LmR1sxnDzrfTgZ3l4RC2l9lv2G8H +xf1K3OdRadeYyjHDcJkRT4lI1qCzutAFrcigB197CTqRbp6qmPCQkmlDFkwXODbUOlCsPRhUwFH +IbnkywqW0bB5iT9UK52PL5SvzBSUzpEuarTsgh79laWHv4FFiS3dBay0tR1RD2PVBhVNdl3AZXmDR59091h87lOI +iAEL8O85aVxhuiSMbF9F9hU1WeYFtZMz1NdCUIaQ7O6pHLQQF6SIeuLH +BpdeB41Wh50els9VGccGM0dfm9AhrFInJjCFbueQIInCnh6uxGSwGV6T43itFKe81URZBzQGj2mSLSXyXnmLZnUpW4ShNMpVjmhz +yapBCwU1q9whJZdsbx2sSDvWeSrfhAkVTkgLvvT5PlPXpaRR2NfacB62qxrBg44Z4N0eTryJaT 2LGg b l +3rvw4FtPxN0ff0sdYj1DvyK7IzEwSMzJrER0Q6Q3YZE174JxaAWQpNh7Xg +ImGRG6f2ZriNOHeIcKHiM0O9thJY0S9RR2bnBIB4Kdxvgv0d30fzC1P5owsG5q4H1rCJjNcF9ttSFoifQf9wizaiJ6vDKlC7yJK8 +7rnh5O VeHOLnppP2LaJD0e4Fqqj4vFydT4SqpGN4phgq2p3o6YlinnSpvYhbkqJjYH +Iz0YwI6rCRg94F1ECmhq3dDXngZTwo8y0MEowSQpNPX s odsHtpUu6AZImnU7ZEaIJSMeysShqLIFWY +aUeYUk4V7VqgXvH0m692p9adXkZDfYRmhOomYqsVv9tx0nuPYLUWMPD2Ph3N3eIbTh8SBmOWHRKeptkIPj8YbbG9ENrIISC +WBgLKpTdrymxPAqgrcXpBQWLaHCffVWhnU0lo9zthk 58yy +LS9DR8rHfIAnpR7GvmJ7jVsaowj3OJvN0jsx28BcHhwvjXfFITGF1mpaGYC01DUY4 YX6mHmB3vP +tpdq61R7zhO76cvdfnBf9taM0AqpOubGbaVl57e45dy3KRb3yrl48ZlkuPuLdLGnatwyLviZWYhvUBwT2ZeY8koNeo5701FsmabL +tkX4Zs09PbzO1mkaArPquKlDzVALUL33besKw4KxvjZhxeanKHlodIsruqtY5PPco32 +lZ2CpK8J7hHCtKLaqSBVSD0EJ0Qi7KwxApnRzcy4k7okWE46LdOdGgXnIGdzLgj217zJM6mBUxOmmy9L3R08nMBravXx1BZmNRhf +D5ehGbcis4mcywKwYctDaEk2zZReQN8T08weAnQg5FX4oL06Do9oRhOQ14bXwn7lpgcJL2UqYurFfUaVWBirZ5suOV8FqGdb6o4q +Ykqzq2jqajCWtZJTPo1ZplUIO5l7k25aiIPkohnJIeKWhfovoa xu8bMc8jceV25yGG8QSLMXXHLDQRQVkA +W8iuqpxZ7aHhepsKBi1Dg4J3VJpwkimRa3aJfGnnpIPXGAcByKEaHfd7Dokhp +bMyg6N4uIIuxBv1thaMUz9WQwVwuUxIM2Euhn8uWOjSIOkRUawlgFTs4dan3IBRSeGyhkqryoJRgDYEgZE0TQcLkxThAzdGfMJ +pQlAgRRsFoI63VwG4q142VKpgESQwO21PAHqfG gE tTuPMrhIze7t755PXq11ldTHPjyG0uAAU5UdM1BWo87 +gNb0AiiW93NW9T5yAJeCLd3qO5Ammek6Db9b8aNGWL1wOJPTtQax9O93batsHZCm5At vpv4zWZW4gnFRuGkm6d0OLwPr +LwwzWpdMPKCePffZwVd99PYE5yoa78PFDCyIGhPv0ITnalz4TIjcCUVf2r +WU2s6ZCMd9IYsk9zAc2BJN3vrjfHNukJUBloVO92Ss9CTgv6wQIAVXa3cgoPYoCx1Y7y58pn2PzmAI43eOQfSwOsfUg7p90BD8R6 +oaDX26UBg28UnRCOsnR3HyX8S8pbpkF0LYnv9CIAU2M4FnROpzDfEz7MHqO5oNGx1Kx3bqnB2iIIEwB9pergdrLk9tXrlW4hrBgh +FNP0Y6IqX49F35bfD7kjoSWsjkyk +Kb0AXTMz2kgh7qW0Yuwt95lWmmr91ylzpDUwsDn6zdVdV3tOfVHPJgGbG4eeI6LqvgsDXF3bryIDe4XPBjpBpXCo3ni +OeinspAF +MCM69HuKfn8uj1hWdFfMbK3GmRU0Ak4dheLlDNlzHvNGptIUKcsmJqKPFDXFL6LOTGp316Vt0rGD2DomPmZpoHyD2DeWBzDjfekC +ONwZExY64x17zX6bYpevYFprSMqe2nc6 +YECfrIBjQBsbW5JAE2b9UPDkTw7N2A7vMGBXVTWL66yPOwpSxnSkbl7kqelM6JdZSiZGiMdNniPUUPYvPa1GbflBTPVX6e0k6i1f +kXh9kOhIzVqwpFYL6792xRen97bIkDrrNJyPwOVX9xFVJh 3WIdjCyEh5ouXqXLaMhEUGWOR1xb2WZZasPaUnp +4k2LckiYDygHeC6aN7FNDPveqNnXtDWK5Q4nR9BdJhZ6LRAck9eaI0cF9UB2q8A +wmZlWdEnUZGdomfPCnCBrNSkcF0aFlEDljvPiEymMkGuiYhRUBvlDlkL Enw +9qZtQeXKU6YontHYt3wjeQHR70BLt7CYkabEo8DJoy2yOOz6d0UpbClJeTRGVTSuQnIv231L2KTh4 +Yc4dftwjyoHZ8bRV0RDhw6OzOnWjmuBbnMcHKxCDksUbMwi0HtU3TRLg3It2w4rYKQXPZdsBl8ppKWFmkr55QKKZ0qWCpla 5 +NjIKROUsLZPYooxoQo9shhOugB LVmVl8S40EYOco8UhLfpLE8Q3lX6 aKklDoQ52w60Lzf1kcBIlS6hgbne +MLhSrXoELk4FCbdPms4t8l27WWDmNrEhmz0MXnYisTGCyhY720vYz9sjITiC7CREv P7h26os3AxmcXz9 +tVcudn0um9UC0U2PAmI6pUVh8 pd LzEQ3MFhikPKPzMylBe67YtioVlRakXUDpXFB2jH9X sd4HXac +LfIyXJwzInu5yeiuioy8GwEtA OjRjoaAFtJrQrBxDRcxzdmJel9H2k +1NytOr5IByoBIYqdmPxZ8qJoN2ou8dJlbz7vMDrjNVZWVTmvY0o6G +faWjeQHA8lcIdJWnSvkbmyacAQln6lO6OBUYklXdzPndtiIrgsdCi NWiVsLVvaYMOH5JkTvPVq2ufzNSJW +Wm5pqzVVGTH7AiWHRgehjRVwPpJGT0LUglRNNGNS82A8QdYtQUQuOpNeWgbzmS18otdsUdCrRkqUx2n mRXCdTrMLC +uh0l7Jhk2ig54ZezmeIFjEElPxp4WOdtr2Roqh2dQ4a12tgM3ZySLAC3ETTFDeBQ6QtwyOpDaXhYHJuhQ0RTs1EXY7wgUrVhw48m +TZjpfr77TucXhWFydJDRUwmM4PpFkplX3yE8ILyD32Y5G8pGkd +NDh0xNGHHgS2sCQnWIFrqinN8i6nO9ne3UPD5SLsYhJfVZyclqJHbol3zpC1MeqFA5cF0JLw50hbGia94XsVPx2hTG EyWh +sRW9TlfQfskJ6y3mnQd3l45kXQ Ypakb1Dv0lEypSVflWK6hegxl6GP HrAO4lXDSnT320YsXJdAiJItDdr8lwev +G64BlYVwN9v1dcjdczjMYnfVcAsVfnBqVXMqthL1P1AtLJQTy1fU Na P0 +a4fUNhmcV6aK9PZMVFyAqe4kyLh4m9KHh1yW8jqrTJvzGcXaYYnqiaECEb7JAq304qOCr8 8JMyO3OJxfSWsHV jBuPPb0Rasrx +50bNoMxJdSt83qWhWuZI387xqXeIIo7Kfi8VAeS7kCucrsVhYKY0MOzc6BxzFkmX6SgJox6DR8qF5vD3NsuVKpfxid +YpFTwon9cw1ISmIQ8zJrE23ZvWL5IdXLKJulN2yVPlmtxn2U2V9R0vwLkNBHXksgEYs33vkdbW6OclteTGqjKYEuIvxUBZhofOVU +5BtEDiiNWlblRgJBx9DddzSA6yaKmn BL9F1m11i8eO6JWhp2tXuOouKMwLU6rhRJ6w9y30WVA T1MeQTRo0vvC1qyGIia FpM +0RlsNFegAijnXAGnyIJzrA0nQbatU9 +ZSwXhY66f2YEuG0fd23FY6M9jqzLl4D3d42nO1wtwpzf7mHweex8FNmeB9aJtwnJ5EHNvR3MItl0gjZ86JOQHVFKOhdIhcNXjGA3 +s0YehjVFmDt2rClB +9MZg55b9GtXXE7C0YMCKiCvu6XYjxNxGkJ3KNMZrtS3LdmAB0SOetJPl9I91h54cwScmJ4XFZKEQkVaUR0C92ygH5s3V1dhKST +bGUUKajKDP3ajzCwmL1wLc6j5w2xxstHyJ6LU5uiN5U8RavpDVVfHQyL5gvH7Ssxt4sEjU2eBqiSng1wL0GKR +D2JZSst9b7AqtYfQRoWMZmd3qcP1QrIc9GZJuOF3QkHvQuH65yWAWpKlA4PZLas0x0imX7IVv +r5RNEb679GeQp4SrfOs13XHFr8hYMI5dmGrsVbYMuPpqkFcvT4yj +U9zceOAruBN2B085lOsrHbaWsJjunY1PhdjAE9wNMWU4oa4c9BjScFZwkkyE64lon +HMCrnmyb0ssy3PfSNESmFZNXs398NIP2SdOYQC97TTZDnWDIfsEFutm7swk2LzMoI46gRcwh CoTcmYXnmCFF +MeHwaxPEVn3lcABK1fjFzI5xTGoi6GfXlhyYUCUd1IX IdJccZr5e2NAM LghP W5V5zqgITbkWbeqp +6cDCWWtE2sZQQYULTZU452XSf23r6xJD5JGAnxul2UqaTp7ztpI0MOgDbax1dgOp0T25CtT1NNH6SnpinYPfC8U9e8nooJKbpNxy +32nwH JS77ThqGlrGLnYnuh8OofQ10c1pUudxEOuEkivf91NVrxztslaxxqI4hLKEt6L6moQiWg +nwa78J4Eg4LFXwXHDJZm71Pz3XG4TtG0ufpJF3oVGTYYB6sooVhSOt7ScWvyZnezZjqi9LOUhQlNSO6fpaLF2XgGqwZ15s52lJpd +uFew 1GHvUFHoXuvkyzQGAay8WLEaqZ9UoXc0asKRkaO3UeysYIBI71OIfjPwxLELRm9EzRN +fTPmacTPNIHKYk9vsQSutDmD0bu6oLN4deneorwP2VfbBRVCEZ7mUwj1ndMRKao5zgBL0ECMpWdyEUFQxHuehwk7GT8XhrRsIq57 +J8 +xA6Om95egcDGIoc2O5DFeCqRDuR10RCZbG30UaH2vuqETML3Rv6TFHTMycdMd4h5d1En9f3RIQ2LiKLknEe7rHhTFlND747JcryJ +Zhkf8AIwsqxCCxg82cRQfCGRzXjlQfOSyTSkSfVNV +uu4EKbiFMkXayJftggnzoryYzi5e8KayOul7Cb2YLRaoTl1vk3eFM8dmWMKnoloc61 DYueCdRw2 +lnDEnv7inuRSkcX1vdVTV8raM2mlDafOjzPWa7aRaPQZ +pwN3SpBXuQedyK53eWaCasJPqY2GsS3DYXy5wDpNp4I0CjKMtVxTx41vOVUYjoHl0nVjPrYBFY1AtzQ7zWtNvXkxpidjPjgsnzC3 +24A1SVGXRsuhmao8oRy4xcqqsQ6PtrK8sr0yrrrhgxFpq +GqrgfwlB3Ou5xdVeBYniuscNUvWecJuOOP8lANJxrLojKQdFOmwS8APkjnftiUTiedHz9etC ZR9DclaVZ +fYnxEp6BxPvQlil4He2nBm5iFor3ewto6ey3vAA9X5srRY9PxCTglPTxwmOd6g9FkJoh4t2mFQBneHB34SelqtFI +HEXGGXrZohhBhfiCLrZcMsjg3DVNnpqwdFe56MOZ87UFxZrDeMTj56AiWpBXwZ3hqjOuXKH2AxfVP3QXhXd8ubsWlmLXmSZleAc +lqp0mhme4b2O1Z6nk0QmfL3cb4fcU9fnKJbfrVxyLZrevKgi5UBNtpSKLuhK5J61dw40viQcIPwwmq48iAqmKbPrQntbTw6GxG6M +yIBG0pO7V5kmxY3I0Bz8Gw31yMIVIkzqPUr60Fk149T9rvZPRmZbTBWwyPgPnSYGOBaO5m +gcE6c9dmu9NsJg7m2LHaMCls1b8SWsfUQUvOgNqXmBTOQRgxH9WUFNAKyXFxFd803HAD4XnBa01MhH +L5TiMCvyJYVmFNjZr9MtsvqdJ3u +a4qHRmbtpyxvzSMoBYKj0fi1CqQEcSJ2JiDPUF1D9a7lDFXda3jCfB4a7u4074vudLJoPpiKpBrNJ8JVmeIuS +Ibuoy1Vry2l6aHYgte8RTakAeoMfSW34grqqhIPX14jg2AmXUnBKrYQXiBeZVwLIENKa5jAmRCZmGh +MjS7FPa8UiLMn8OwCxcdUXmdHmiqOwnyrZb2FJ7A8RPD3fr3b59svbdVVWz8UCdnB3BFTiAuPN47MiOjICZFrP0BnZKbzoTMuEw1 +mZYZodI3kEpWpUoTU4YrzEiXdF jCs R9WgEK7fv +TEWMMtxHL8IpazljQfx1PaPqQN89GklaodplZxsJm38LsX3ylgt4qzJF7qZtC5zNQLKd gn +6WFRyPxxjf4MXVf1DjmUj2ZRBKnseuVlvehjSUH9OJprWzAnyYv +YzMk7j3Iy9hHpoEUJcupUwuauOWqv7jZ0EEiMUd38dyn4ACb1YTuekwcNIlPlQQxaSajrbFJDFAFMOIaJmvzfn9TCjhKYQq9BB0o +Y7uzqNDYeujAKvcPbbe9L3UvW9X3WgZsygaWc65Pk2zwj1DiPD0MZCQnq8DFtkOFeWdf1f9YKvVfAgd +oFlgSt8XZKyQuu65e2QaKltz8bWaxGqprSRwmTtRJA3mgMRyfSxA6voLXinvVkStqNCKm3Wbed +tkDZE9F6vRoLXUuQAK0EZCDLKH +qudEfbGYvy37TKhKbIJZSRZaLk6jrOIUTmw2gJnkKLyd4vLzAIsWEiegsJ96aLDUoFkozllWvYUW9pe9KSZSwN4nzfC0vrQlDfaC +2yeHdLWfVNqrHcLxoaicoGxGvZG0xgUsEXfEu9FOp9rNSZYvSbCuxif9sjhgNxoIE +uNfq4kDI46Wm8U1KqCVJto3Oj2kGAA8YwVZERxVOg0Pl7oMTBVmEqAXXMNyeeyCoDSqTKGWtQfma4R4PTeXDXIkJ9Ha7CTjneFRp +o5tTe6bADsTw5ZsbUW6AHg9552sqaKDWX diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines.txt b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines.txt new file mode 100644 index 00000000000..4ec2c6700c2 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines.txt @@ -0,0 +1,103 @@ +xxSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_+2.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_+2.expected new file mode 100644 index 00000000000..e6c5768c7fd --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_+2.expected @@ -0,0 +1,103 @@ +xSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-1.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-1.expected new file mode 100644 index 00000000000..8b137891791 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-1.expected @@ -0,0 +1 @@ + diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-8191.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-8191.expected new file mode 100644 index 00000000000..e6c5768c7fd --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_c_-8191.expected @@ -0,0 +1,103 @@ +xSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_+2.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_+2.expected new file mode 100644 index 00000000000..b78a76687d4 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_+2.expected @@ -0,0 +1,102 @@ +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-1.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-1.expected new file mode 100644 index 00000000000..30b643a88e9 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-1.expected @@ -0,0 +1 @@ +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-102.expected b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-102.expected new file mode 100644 index 00000000000..b78a76687d4 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8192_bytes_103_lines_n_-102.expected @@ -0,0 +1,102 @@ +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMG diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines.txt b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines.txt new file mode 100644 index 00000000000..d6fb16fa7f0 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines.txt @@ -0,0 +1,103 @@ +xxSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_+2.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_+2.expected new file mode 100644 index 00000000000..b7cf0e1ac78 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_+2.expected @@ -0,0 +1,103 @@ +xSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-1.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-1.expected new file mode 100644 index 00000000000..8b137891791 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-1.expected @@ -0,0 +1 @@ + diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-8192.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-8192.expected new file mode 100644 index 00000000000..b7cf0e1ac78 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_c_-8192.expected @@ -0,0 +1,103 @@ +xSubEB6AHTti03FfzLvGmcNbpsqxAxgH39yMwzUODn4JfLbdWGftRpt BqZtDhJMc0vfPFMtttQZykgxDJ2pPZPdOBDm +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_+2.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_+2.expected new file mode 100644 index 00000000000..3797bf0301e --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_+2.expected @@ -0,0 +1,102 @@ +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-1.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-1.expected new file mode 100644 index 00000000000..e9e28bd1608 --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-1.expected @@ -0,0 +1 @@ +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX diff --git a/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-102.expected b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-102.expected new file mode 100644 index 00000000000..3797bf0301e --- /dev/null +++ b/tests/fixtures/tail/random_ascii_8193_bytes_103_lines_n_-102.expected @@ -0,0 +1,102 @@ +vVHIxa8L0W58e4gqvBfGJxfAEmVdj0zkcZnrTub30E +zwiWtiCrfAQcq49k8MoOQ0b1tQdWwUmfbdTGjGEd79LMCrNJO79j0sqzHAGOZKEJ +wjG0ZEkWd3yTaX2Nj2WTT8gi5x8x795fsVQ27bPf8g5CcuU0QSaq2w58MkRswHzbCWLPUzi0NnvPsPVMSbQoUNiDqdFYyuJkGnb3 +KDkc74G3C rG4J6KnPapczUos6NRGLUEX5vg0WpHRXlFxbmC +8B686wehCZSuVA6in6dtoTUAkFWnCwOHixoXWyt31EZ9LknGDbxsNEh 8jHCFUFveJDshQkb7UinR48pAj +mi2UF7vj6AjSsqrk319qAxAeI96Ecn6oEyx3BcLn1dzEPcA9KqwHLgN1wIgHbloKy4tx10TYqoSlRjA +BtAIYVlKTONJVaw195L1NQnappnAMrDSKa7pXOGivletllT7eJNWgWxiQXwNsYZwRhc6SD +q1xHnaf4IQqNzDKAGiEQqOchPMj7Pw3PoieeNqe0IcgWq9bngmADHeLqncp7Qz8y1kWQ4dV7fjE6Qr517he9Xh06ONUx00hGkrj4 +OtCiOcnH3bzRY7P6XXWGAxnqIhP3HbE +vxKmvqNwwwb5Cxb59R6zzLHnLEIO6gn0hOlRgYJdX3D0V5nUyWl7grFnDTLlbP8B3KRjr3ost4zsHATvG8lRu5UeFIzEQ8qyC3xf +7MQP4m0TJima0cbDsucS2AfPF0d4O1F8yc8SbaGDDgH qUzRiJt6e6ecv9MWxV4tGGQZPIFdhlWvwuzzgbIaYLolBkBDF0 7yD +lQT6cwEl5p6RT8LFxLzzQLfkIPiKKwhlpmmTtKiQYDLI5QowkHzs4hSOm4VC1X2OZ89pntZkNiPjSbJoJ1 44j +vtLseAi60PXcvWMX0WB20ITSHko7rpkZp2XcgCpxLT17uZ3Kipa82hE1i7ZPC8TMYdRrZmn7EfhubDXMVBrM2DKcg8kHLvEcIjOQ +ENPH48HIfFk0BJMJJe1Fe PCjDKtH0o655ree5YFPRy840LDr2SssXJoT1eBwj0kHY06TXKqFiIZ +r0Tp1HTXmifEGX6DZiCWSEr7SATjcwnVJ2EqF19zQUAzmChvrKZzAW21GI 7ZnlnlI 9ALn72LgFFBIYlba +lUgFXvsUn9cboyBGdQm2CFDEzJcDKKkew0pPUJYwLeax3uld8u61O7mPIIJGiZZgKl1mDxjSX25GJa3Qyzx7kCee7tWiRP6yLO2q +PU5zMN9ghlkBA +nfiz93PVlEBxCzcrnHi6VgI2CLN6lqNkCNKAFPoP7ThAiIOfoQSx5Xntw7ixJkIeJgnvOFETCx85SvRzEI9lQoiOx5CSHOUCUJiZ +gctUwuT6ikkzRDgKBAI0FLZEEbMSiC05mbVidzscSeIrAXPDhWIprWLe0ksulHrKBQjHsNuJGBEnQW7JPfXiVix1Jl19kQblOcSA +fF8hlyaDdYC69aeucxYmDfj4tg WbCZZIDmoNW0 9G3mF7saYEX 4LyaNQHUlandV +Jag51swad16DenkVaTYoTiWsTl5LhZLo0vqb3iqwapYszK IL8B0hMmpX1Fns6bOPYS1lf8RsZiX +uNEdGqPMArM9mi0oiXeYna6mB9np2lCHo EFV1US RtHqaT0sIZLaCz4Gai2R6zlah5J +KVGiQggPnr6SjA2XiZs846dCoZg8PwECxvroPBjG0737JJiziqB0TMChQMCIt0quC7GFode9oYbxv8Jr3kFsPMr +qy5YUBNVOrweJj8bdGIQ Y6M5c +kCBPCTjbRmcFDTyQFSjSiVjNL0f1UX0oR6XziJbXZZzSTkP54K9a2He5hzOE5I7eBS1YuhY9TcUsAFnShRgi8jTsp2i0z4ly1NGE +dKeOcMbVxMfedYRLOlcpemm9iQ9NcpigSPhcWZDWdzn0Rh9eTrnbf7lGDDyJriiUWrJCDXovIRWGZyY89cxY0BKm1nZOxrlMXS +GmNVeULWaGS350XzVOsXG2N8J5UcRezieanWmXwV04fvxUstiBTPbJjXye89SSPUX0l85Rk6eD7u LLLQdIEgzbu +oCbgLZuioXwjsO7Hqp2Gcg +BfDY1lW7j2cjNGk02KdsKrU1EfMi1pzjXssEJtenqetZbyxr6ecuVkvbcPkUByiTS4rClvlxFInsOJ +xOBn3n1n5lNO6JooGrilOhgV5JDRHcRg0t6mKQrBT7FwLZIpS4DnvDYN4DCSGdq84P4cPaSZQFWauPYUildl2al +rCPidDyn7DwTo2pad50YkX2l7hPwx3PrFkGviKFNeqp6ijXNdJa59detAOy5Ta bNWunIcQEeTWlDBhvkjYyg +BKqYDlgfNnk6DD9Te80sV4HWMZbfkTHZc8htZl57J3XhZC0IwCkMV7f8iLsmwQjqtWzq1DM3lZJLZ06L6a9CdJaN5bJzwtjzBjGx +9y05Oz2BQ55NnFpll8zt6keAmuCFLoAP8sO6krMMal3uEEfI8FSlThbCBjvDpuusH6bBjxmGbP82WGH9el1SPD5LVxzvwJhaNMiI +1M3NvaHNmgYu89HWhuCbaGC54Eu2 +x8zH2Rlok2RL0sSodWjDw7dUz2SDZFhSDCguex1VOArsIUKNldlqHj9FnhUjZIBxPEjYJXfEhcvrjIDZwmXsjDAdHXB3LoYdoGz6 +1pJ1vEbnOia3XdfLJc91d1sW8J91wr32qnEW0O9Fp6F2zCft0Ll8V5Jqeo5CfbHgAaoBa2WqlTKqgLKrrTh286EI4APu3NacaQ9Q +Q2CjpU1dpF5f7qohK +6Nt5rjzoH839e9E8YCwdscmnx3IQTjQDYXY7fRv8yseYxWvetZpz5rFw8RJszFdZBMNTCCYGNzbSf14QSku1VnsqRE8pSskNSm1x +rtTs8lFr0ZTesCNoOQYHyr04iRdOCG2E28HIOcLFJdY4Vfa6275DFF4EGtYEZtqaFNPfiRFw6fPQsrJ6amhW8VBSx9R9Jf +buZha3wYriOydbTiTRsPvfSXTbrsJ5 +ztrPZ4OomBXGtnTF6T4LkaCyHVtxcm0mLQMOlGjy96Dqex86jKi9NBZfaf2aLzb1Qc2HTmN9GVlzt9Kno3yhI0BqWaQk1ruHUzTC +2NihomG8BsbbLezZ1O8ke0fUmdMKUam9m1X9xCeJ96sTDPi1Xq1kYrJhPfL1noRBF1vFzEaaiHoOTr2LvFx2Me4NW7iQO4NrTt3S +EX7NJ7TsIq0GUEaR0duC3g91cjnJvBbgIAgUqAuRMLexz5vuYHjVKZhNz2X4VBIhcuOSqohnepap5OfhdvqqejgFjEYu7Af9Vc08 +nfmcwsEQPRagk62N4BTXzyOocsgrjb33ZwpyAb6HXsrN2FspTumKYK2PBEuH7CQf0fNmZTHq45yDb6eeMBexPUncwr5MAkDm8tbK +dZkcpdeyNwqDE0pQ57tw96ZIMW3NOw5tbu5zn9lgT8QSlgByxkFv9AZJjLZ1eVouJD49zb010ygG1qI +k4i8qXwgJIvd2uKxBHOQqi98oCXVZzbMSQFAutSGk39heC9mHTIpBYZHa3If4PVNcpBjnaZ3Gw3fJQIDiyKYSleq9 +gaqJgYRpledK0KabQ16JzbynqTwfFPlDc0RJ8zA62c0FDUJsRVqdJa3MYogq +yuYylHTCtTC3aEf7KmtBXjaGo6FQheLeTH5Fo3k3e1ow48kcfR26GRdu9LFEpYkhlBOI kEBHptsa8EBsiy DXoGe6 +TpXekonK3zx0cbmhFmqfSuVhVrVmC43sqVSGFVtyIxbQlojQa7dT3A0k2cxtMlBiEdPz0ydHoUG23Q361vhpnJf8nGTYtf8QDYV8 +ImrJA0UaVt4PEuVHSU703DdAzrt9NFWV BJ7mouM7qomqKl94GKOEt5RYDgPHV4hSWlq747BnH46mltoHCrzsEaIHuVKhpAKEiB +b3u14jebKyvQLyDMt1mpGmXF19NcXwqgURzhBHZ +KRG8F50XeB9twPjFu31LXGYiolIrzH0i1I9eEv5lJYitIqMSqzFCmH53hvOEZDIV109UhfBbpC3PnB7XMpIP2hiUuFSj1tUP +PJkPLJKje10I9C2rw2BqX Gm5NysfVIRpgFToNh25g7UoYHhewGcYJYWlAsir6xvl9bxajp7n4rb 9HMGOeGc +8QIp1tQlq9tJjZ4MROovlRgqhmSMXkvV6Tdt 59 +52hCWfvXj2aq2z7fmopL0dNgA2nTwLFvKmnLkUOPA2Ne84G49CRjldLzJr1pZmafLYNF8nY2QRvcYl3PamR9VeNsdo6GSBjrpjox +LcmQv2lJ9YhHxK3t7Rl0QrBpxKqO1lyNzBy8MYaHjxSrk7tcmAOBPQGU1cglU8VmcPm440XXsCUQ962Bxc1 +HO4gDRrI3VtRox1yhjUGun3tQrxd67BSr5X2wvSyzO5iII1XGHyx3jpdHTFY4w6TdlGQcIlw6cZVWI1L5l5Nd0EQ2dBwwStsF1MU +rN2N0r1dbg2UcgMM4RI2fXJEo4cifIPFJ2E3hGviQeOqhtjOW4VRVGj0TIZvG5UydGYr11MVcO7ag75tSVc3PG0phF +9qtu7jEbFlSIXL5IhMABSMggQKGxN2IhqsG oc1uQO +AZxCAQ8KwP2Kd2LytCaMJu1KnPRaCjgQpH1itxepremf4IJhUFk5yUovdiXQ00vOrTkyxG1Dqh5PInK1J7lMvcqMAvUzZcRh9wa9 +icvS2tLIJ3tVOV4YLmujzZj37KqYuz F iWfOCMRgC Yp3SNyyOo2ZYeEeIKLjWS2OXHEPvZt29mgFURsr0tKq17 +jvuBDGXtgGyYaIEAWtpT5sY8Ibf9P +cMO7IFQZYxbKP6L6BJYy5Y0H21Mrhf7nW6ix864Nyccu4ZnlaEJzRqQVP5aoFXjmtcmLN87FTIZo8amAaRLYvi1T3fq5cM3U0ge8 +QWNaq IEizCvh9StdNKsjcPhWGyvZ pIHTQKW9qSWHmEufDoHOM6MipL kgESL8okMQnr KG +eJKDwZAIDkYOA2HSdZimLgO8xCs3EkQC41CBKkfS67mBDX7dHACDAxN6gRnRB5BC7QtpS9rNOIVh3c02sjKUYOKXFupZYou32g6V +gJn9AwXlZXVdIdvnpv0sRLtPUmun0YJHyiK32HgbLZK9KHoJoAXfERMB +4ejaVweRjjBBKth80uc7R0REzyU1go2Wovw8YCs8xunM7N nwP7Hz2k0QyxwZBK7jjucPwpmhUCB dagGj41o9cywuV +Fcyonc4FdKLQj5wLHsxWZAjUIdTD01ooEMLm6D8LX tTAnMS3AWFgVXf2q1yb5flmoI8AGOwU6Cu53RAmoctff95mF2AIZ4O +szVjlv5357a0klYupALvkCpxdhstEEW1KyNw0YtlGCI6eTTFSIXoX2 XZhO00WV3c5L5TczHhCxrGneDuei w B1L9fy Rt24o +PdYo0ppjmwJpDBPVWTSfka2HEkLQMyz25sP3yHV0Qw12a86raNO JKgElsDPoCrf +YHcrjOIff2fiayGteix2s8jp812omJrC096AHJAcuUH1mn69Vu vQcWA +HBuny2h7JdPfv1rNr2aBIhmKCaOkeqxLHxU8zTcrrhQjHUDlE4Og28wHWAMXhXptz6Y7CBJdIqRcePkexZdctQlRNEbQs5Y1z1Mt +kkfP5lIfB3ZDTytkmjzkEM9KCM6p88PfJOpxOdlmYz1wsedNhUZ3zlqPDHw9lVdvU0vWV33eTaZNd6U9zh6IMjV6fuVoM +y4pioICDOQfJslm66Raq4MTJk0sFPW7GUPlZ +HVHRvM0Fg3AgX1ULFgjuAmHzmY4VvUMvkltZg9WSqtV71I5fPBVSHJGBsjSx2wpSmpl5euSb9MG10XnUUgIFgujustBvJVnPAjtj +eTVZ41eII4CcHceS770KnZULvtUSby78IzzgrSahCWmUwErreHQb RqOYHaLLcFBYLkAsdhXm5e3SRajRRTbAR7bt0Qm3pZ6S +vVLJ1ZqljWDTnULCi2zK71yeIs3dmZRMOwyXhmY4QH0Yw4Qn87opPOJbK9Qk8RRWy7yUyNM1g18BYYLcSFKipcQF4ZGJ17Hd +kRiz9FlTHLX5gQxwzVUFWkpzZqX7HzhxWLRLtNHTt2aUAyxKpZZFPPLEyHwIee9IkG0D056zWDJZmni91SbB7AApcicw0l +cJ4yErVGqp2Cut8EV4uPUazQurEwOxSZKb7jcPXDuphjMYQHRskWzyBge76qEckguFBtnkbMfLIGEtxJt1y yLXTFPpEE +drqXGjXRtcVMhSRbaBZSV +4ewp4YKxrnfMaIaqNnAqYPdqDpqPH2329xmWoHT5pK5sKuYZ8Afws307xlGJowinC7yDMx7NdrK59XE7k2oiAsZAVdDJnNMTark4 +0Aj8La5CKUp6xN09ZZSwnim7RT7J0cI0yqC1G2m7MFR0knEFTMELGaP8psyKWIqx7jtGiX1RPW9gJwUWX834ZQei5ww9liQacCoV +Aef5 +XdRmDL7mhtifPrJunHfY9GzpROTDbaDtECkjEqc54QeHGqVYmKyJfObe6AMOM36AwBecJ4AnoqDO1ijPFk7pyGyek8epXA4TteHA +3jxmCIQRKQEh36RYy2bqCV5VrT6i72I7mCKG1J3xppLS979weQgJrPN72H2OEDFAABclOtURwnzlRJ6pX3 +RoBzQN0bYJwlioLqwT56oqNY hNBx +qGjF3TB4hvivDqU2zdbmrYl9evLwfIZhYNTCwRwrbTwZw0ZhG9LjyN5eneRM7zfw8ujL9sUgnQzJV76fRZWKLQbx3ucVuWjrJpwK +HFyXIalOEG4fNdB nYB9hzrtJ6VO0XBk2JIt iT3mtWcWgGvRu8cc3iv95hIoK LVqRgSDm1WuqPAe4Qj26KQw5vmC4TPOw +smU5lHaYqGRHjlVwsdK6 cHDMQ6hzHd7PuzhZw5zpiaw9sdlns60Dkcl98SR5u5 +raaKP4LyU0z9If2E9OWXKk2QvkHkiIBeDsTJX +TFHZLLeAOcAQ7rPermbCTcSabrnTyTwA2kGEfJXsi6FSAIT26PTx8DMh1yDNmMZLUjUR1zcrbgVBkCQNwREE1k +Qdod57OJBv5utuc0YQ5v4BQEAxbqV37v3t1k6gPoGJ0Q5lHmBC64UT4MX7QZsspHrH8ezjGyKBkMxQeRj5BUwJFN7256A97kBE1L +BX36v9VYVVArITKEp23NRKySuGwu1RuNhdNxH9pMd4DDGIav +w7yxCH3ovQvP67aBRzXxOrw51rvJcmsYkKQXAXO8yIuSuwjPr9F7i D0wEUcHdBL0cvkrdxgWrVtYeGxhfd1loIzMEwI +zuLYYuL3mElLex2 0s4fVdLR6oqZy15n1tcH9d3GRDKAbyQTigxTPdvxjHP5nPAF4Tq7uIj +9k9WE04WTedDJgOQfTazQS6yo3wXH9sWDx1W5bj8OHNIccbFWN7g8mncI +AQm6n7d9E4ly6fzdvCNOrae9WMXXvaq5fFGLffxODXv3rvA9mXgP3Dlm7xNjg0wGjpk2uTM1ge5n6Vo3TdazmAChxhiehXMbZ3WY +Fguj5j9sR8eTcfM3WEUr2rRowBtkbL0D6eKpXPs98dn39 +B2Nruy3EGE3CyOTZPd4gK9pdsEX8f1nYVz6EudzcU46OLB0ZAxZdwOXMyovt QsFSQQIAX6YVASTaMd5Ox5k3x5JHhrEWS09hHY +eVPEAqPyKzXnuw5tcZUkjl6zkHxGePOjJt6Q 8RgtLDe +4RauYtcdRH8R1IEoe8adYwbj0fCfiNP33hLDtazjAfzLTJNc7ldHYohFo3xAPZA0uY12GzaMijlr2UczCyEtG9iNM4O5rT +3a5NHN8feyRbImU0v5RhjtUyAJYBu1h0F90iyoPb6YGMMt3uK1SeBj0x9UWhOR4u8NLpUac130qC8tpVleMMGX