Struct FastInput 

pub struct FastInput {
    ptr: *const u8,
    end: *const u8,
}

Token reader for little-endian targets. Integer reads require a decimal representation that fits the requested type, with at most that type’s maximum number of digits and an optional - for signed types.

Every read, including iterator reads, must start at an available token. Reads consume exactly one trailing ASCII whitespace byte. parse and ScanSource require UTF-8. Slices returned by bytes must not outlive the input allocation. bytes and parse may also read an empty field at a delimiter.

Fields

ptr: *const u8

end: *const u8

Implementations

impl FastInput

pub unsafe fn stdin() -> Self

Reads all of stdin and retains its storage until process exit.

Safety

Call before any other stdin reads. A mapped input file must not be modified while its contents or slices returned by this reader are in use. Subsequent ScanSource reads must satisfy this type’s token requirements.

pub unsafe fn from_slice(s: &[u8]) -> Self

Safety

s must contain at least 16 initialized padding bytes after its final token delimiter. Its allocation must remain valid and unchanged while this reader or any slices returned by it are in use. Subsequent ScanSource reads must satisfy this type’s token requirements.

pub fn skip_whitespace(&mut self)

Skips ASCII whitespace without advancing beyond the input.

Examples found in repository

crates/competitive/src/tools/fast_scanner.rs (line 16)

    fn skip_whitespace(&mut self) {
        self.skip_whitespace();
    }

crates/competitive/src/tools/fastio.rs (line 740)

    fn skip_whitespace(&mut self) {
        loop {
            self.input.skip_whitespace();
            if self.input.ptr < self.input.end || !self.refill() {
                break;
            }
        }
    }

unsafe fn fetch_ud4(&mut self) -> u16

Examples found in repository

crates/competitive/src/tools/fastio.rs (line 138)

    pub unsafe fn u8(&mut self) -> u8 {
        unsafe { self.fetch_ud4() as u8 }
    }

unsafe fn fetch_ud8(&mut self) -> u32

Examples found in repository

crates/competitive/src/tools/fastio.rs (line 143)

    pub unsafe fn u16(&mut self) -> u16 {
        unsafe { self.fetch_ud8() as u16 }
    }

    /// 0..=99_999_999
    #[inline]
    pub unsafe fn u32_small(&mut self) -> u32 {
        unsafe { self.fetch_ud8() }
    }

pub unsafe fn u8(&mut self) -> u8

Examples found in repository

crates/competitive/src/tools/fastio.rs (line 474)

    pub unsafe fn i8(&mut self) -> i8 {
        unsafe {
            let b = *self.ptr == b'-';
            self.ptr = self.ptr.add(b as usize);
            let mut x = self.u8() as i8;
            if b {
                x = x.wrapping_neg();
            }
            x
        }
    }

pub unsafe fn u16(&mut self) -> u16

Examples found in repository

crates/competitive/src/tools/fastio.rs (line 487)

    pub unsafe fn i16(&mut self) -> i16 {
        unsafe {
            let b = *self.ptr == b'-';
            self.ptr = self.ptr.add(b as usize);
            let mut x = self.u16() as i16;
            if b {
                x = x.wrapping_neg();
            }
            x
        }
    }

pub unsafe fn u32_small(&mut self) -> u32

0..=99_999_999

pub unsafe fn u32(&mut self) -> u32

Examples found in repository

crates/competitive/src/tools/fastio.rs (line 500)

    pub unsafe fn i32(&mut self) -> i32 {
        unsafe {
            let b = *self.ptr == b'-';
            self.ptr = self.ptr.add(b as usize);
            let mut x = self.u32() as i32;
            if b {
                x = x.wrapping_neg();
            }
            x
        }
    }

pub unsafe fn u64(&mut self) -> u64

Examples found in repository

crates/competitive/src/tools/fastio.rs (line 466)

    pub unsafe fn usize(&mut self) -> usize {
        unsafe { self.u64() as usize }
    }

    #[inline]
    pub unsafe fn i8(&mut self) -> i8 {
        unsafe {
            let b = *self.ptr == b'-';
            self.ptr = self.ptr.add(b as usize);
            let mut x = self.u8() as i8;
            if b {
                x = x.wrapping_neg();
            }
            x
        }
    }

    #[inline]
    pub unsafe fn i16(&mut self) -> i16 {
        unsafe {
            let b = *self.ptr == b'-';
            self.ptr = self.ptr.add(b as usize);
            let mut x = self.u16() as i16;
            if b {
                x = x.wrapping_neg();
            }
            x
        }
    }

    #[inline]
    pub unsafe fn i32(&mut self) -> i32 {
        unsafe {
            let b = *self.ptr == b'-';
            self.ptr = self.ptr.add(b as usize);
            let mut x = self.u32() as i32;
            if b {
                x = x.wrapping_neg();
            }
            x
        }
    }

    #[inline]
    pub unsafe fn i64(&mut self) -> i64 {
        unsafe {
            let b = *self.ptr == b'-';
            self.ptr = self.ptr.add(b as usize);
            #[cfg(all(target_arch = "x86_64", target_feature = "ssse3"))]
            let mut x = self.u64_simd::<19>() as i64;
            #[cfg(not(all(target_arch = "x86_64", target_feature = "ssse3")))]
            let mut x = self.u64() as i64;
            if b {
                x = x.wrapping_neg();
            }
            x
        }
    }

pub unsafe fn u128(&mut self) -> u128

Examples found in repository

crates/competitive/src/tools/fastio.rs (line 529)

    pub unsafe fn i128(&mut self) -> i128 {
        unsafe {
            let b = *self.ptr == b'-';
            self.ptr = self.ptr.add(b as usize);
            let mut x = self.u128() as i128;
            if b {
                x = x.wrapping_neg();
            }
            x
        }
    }

pub unsafe fn usize(&mut self) -> usize

pub unsafe fn i8(&mut self) -> i8

pub unsafe fn i16(&mut self) -> i16

pub unsafe fn i32(&mut self) -> i32

pub unsafe fn i64(&mut self) -> i64

Examples found in repository

crates/competitive/src/tools/fastio.rs (line 539)

    pub unsafe fn isize(&mut self) -> isize {
        unsafe { self.i64() as isize }
    }

pub unsafe fn i128(&mut self) -> i128

pub unsafe fn isize(&mut self) -> isize

pub unsafe fn byte(&mut self) -> u8

pub unsafe fn bytes<'a>(&mut self) -> &'a [u8]

Examples found in repository

crates/competitive/src/tools/fast_scanner.rs (line 21)

    fn next_token(&mut self) -> Option<&str> {
        Some(unsafe { from_utf8_unchecked(self.bytes()) })
    }

crates/competitive/src/tools/fastio.rs (line 625)

    pub unsafe fn parse<T>(&mut self) -> T
    where
        T: FromStr,
    {
        unsafe {
            let s = std::str::from_utf8_unchecked(self.bytes());
            s.parse().ok().unwrap()
        }
    }
}

/// Buffered token reader with the same token requirements as [`FastInput`].
/// Tokens may span reads and borrowed tokens remain valid until the next scan.
pub struct BufferedInput<R> {
    reader: R,
    buffer: Vec<u8>,
    input: FastInput,
    filled: usize,
    eof: bool,
}

impl<R: Read> BufferedInput<R> {
    /// # Safety
    /// Every scan must satisfy [`FastInput`]'s token requirements, including UTF-8.
    pub unsafe fn new(reader: R) -> Self {
        let buffer = vec![b' '; (1 << 16) + 16];
        let input = FastInput {
            ptr: buffer.as_ptr(),
            end: buffer.as_ptr(),
        };
        Self {
            reader,
            buffer,
            input,
            filled: 0,
            eof: false,
        }
    }

    #[cold]
    fn refill(&mut self) -> bool {
        if self.eof {
            return false;
        }
        let position = unsafe { self.input.ptr.offset_from(self.buffer.as_ptr()) as usize };
        self.buffer.copy_within(position..self.filled, 0);
        self.filled -= position;
        self.input = FastInput {
            ptr: self.buffer.as_ptr(),
            end: self.buffer.as_ptr(),
        };
        loop {
            if self.filled == self.buffer.len() - 16 {
                self.buffer.resize(2 * self.filled + 16, b' ');
                self.input = FastInput {
                    ptr: self.buffer.as_ptr(),
                    end: self.buffer.as_ptr(),
                };
            }
            let end = self.buffer.len() - 16;
            let start = self.filled;
            match self.reader.read(&mut self.buffer[self.filled..end]) {
                Ok(0) => {
                    self.eof = true;
                    if self.filled != 0 {
                        self.buffer[self.filled] = b' ';
                        self.filled += 1;
                    }
                }
                Ok(n) => self.filled += n,
                Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
                Err(e) => panic!("io error: {e}"),
            }
            let (prefix, chunks) = self.buffer[start..self.filled].as_rchunks();
            let end = prefix.len()
                + 8 * chunks
                    .iter()
                    .rposition(|&chunk| {
                        let x = u64::from_le_bytes(chunk);
                        x.wrapping_sub(0x2121_2121_2121_2121) & !x & 0x8080_8080_8080_8080 != 0
                    })
                    .map_or(0, |i| i + 1);
            if let Some(end) = self.buffer[start..start + end]
                .iter()
                .rposition(u8::is_ascii_whitespace)
            {
                self.buffer[self.filled..self.filled + 16].fill(b' ');
                self.input = FastInput {
                    ptr: self.buffer.as_ptr(),
                    end: unsafe { self.buffer.as_ptr().add(start + end + 1) },
                };
                return true;
            }
            if self.eof {
                self.input = FastInput {
                    ptr: self.buffer.as_ptr(),
                    end: self.buffer.as_ptr(),
                };
                return false;
            }
        }
    }
}

macro_rules! impl_buffered_scan_integer {
    ($($ty:ty, $read:ident, $method:ident);* $(;)?) => {$(
        #[inline]
        fn $read(&mut self) -> Option<$ty> {
            if self.input.ptr >= self.input.end && !self.refill() {
                return None;
            }
            Some(unsafe { self.input.$method() })
        }
    )*};
}

impl<R: Read> ScanSource for BufferedInput<R> {
    #[inline]
    fn skip_whitespace(&mut self) {
        loop {
            self.input.skip_whitespace();
            if self.input.ptr < self.input.end || !self.refill() {
                break;
            }
        }
    }

    #[inline]
    fn next_token(&mut self) -> Option<&str> {
        if self.input.ptr >= self.input.end && !self.refill() {
            return None;
        }
        Some(unsafe { std::str::from_utf8_unchecked(self.input.bytes()) })
    }

pub unsafe fn parse<T>(&mut self) -> T

where T: FromStr,

Trait Implementations

impl ScanSource for FastInput

fn skip_whitespace(&mut self)

Skips separators without consuming the next token.

fn next_token(&mut self) -> Option<&str>

Reads a token under the source’s input requirements. Checked sources return None at EOF; unchecked sources require available input.

fn read_u8(&mut self) -> Option<u8>

fn read_u16(&mut self) -> Option<u16>

fn read_u32(&mut self) -> Option<u32>

fn read_u64(&mut self) -> Option<u64>

fn read_u128(&mut self) -> Option<u128>

fn read_usize(&mut self) -> Option<usize>

fn read_i8(&mut self) -> Option<i8>

fn read_i16(&mut self) -> Option<i16>

fn read_i32(&mut self) -> Option<i32>

fn read_i64(&mut self) -> Option<i64>

fn read_i128(&mut self) -> Option<i128>

fn read_isize(&mut self) -> Option<isize>

fn scan<T: Scan>(&mut self) -> T::Output

Panics if reading fails.

fn mscan<T: MarkedScan>(&mut self, marker: T) -> T::Output

Panics if reading fails.

fn scan_vec<T: Scan>(&mut self, size: usize) -> Vec<T::Output>

fn iter<T: Scan>(&mut self) -> ScannerIter<'_, Self, T>