Submission #37439448

---

Source Code Expand

// -*- coding:utf-8-unix -*-
// rustup doc --std --toolchain 1.42.0

#![allow(unused_imports)]
#![allow(unused_macros)]
/*
use bitset_fixed::BitSet;
use itertools::*;
use num::integer::*;
use petgraph::algo::*;
use petgraph::graph::{DiGraph, Graph, NodeIndex, UnGraph};
use petgraph::unionfind::UnionFind;
use petgraph::visit::{
    Bfs, Dfs, EdgeRef, IntoEdges, NodeCount, NodeIndexable, VisitMap, Visitable,
};
//use proconio::{input, marker::{Bytes, Chars, Isize1, Usize1}, source::{auto::AutoSource, line::LineSource, once::OnceSource}};
use rand::{
    distributions::WeightedIndex,
    prelude::{thread_rng, Distribution},
    seq::SliceRandom,
    Rng,
};
use regex::Regex;
use std::collections::*;
use std::io::{stderr, stdin, stdout, BufRead, BufReader, BufWriter, Read, Write};
use superslice::Ext;
*/

/// input macros based on tanakh's input macro / proconio-rs.
/// tanakh's input macro: <https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8>
/// proconio-rs: <https://docs.rs/proconio/0.3.8/proconio/>
/// this macro recieve `Iterator<Item = u8>` input source, except for Bytes/Chars/String read
/// ProconIBufIter receive `std::io::BufRead` trait. (`std::io::StdinLock`, `std::io::BufReader`, `&[u8]`, etc.)
#[allow(unused)]
macro_rules! finput_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, mut $var:ident : $t:tt $($r:tt)*) => {
        let mut $var = fread_value!($iter, $t);
        finput_inner!{$iter $($r)*}
    };
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = fread_value!($iter, $t);
        finput_inner!{$iter $($r)*}
    };
}
#[allow(unused)]
macro_rules! fread_value {
    ($iter:expr, ( $($t:tt),* )) => { ( $(fread_value!($iter, $t)),* ) };
    ($iter:expr, [ $t:tt ; $len:expr ]) => { (0..$len).map(|_| fread_value!($iter, $t)).collect::<Vec<_>>() };
    ($iter:expr, u128) => { $iter.parse_uint::<u128>() };
    ($iter:expr, usize) => { $iter.parse_uint::<usize>() };
    ($iter:expr, usize1) => { $iter.parse_uint::<usize>() - 1 };
    ($iter:expr, u64) => { $iter.parse_uint::<u64>() };
    ($iter:expr, u64_1) => { $iter.parse_uint::<u64>() - 1 };
    ($iter:expr, u32) => { $iter.parse_uint::<u32>() };
    ($iter:expr, u32_1) => { $iter.parse_uint::<u32>() - 1 };
    ($iter:expr, u16) => { $iter.parse_uint::<u16>() };
    ($iter:expr, u8) => { $iter.parse_uint::<u8>() };
    ($iter:expr, i128) => { $iter.parse_iint::<i128>() };
    ($iter:expr, isize) => { $iter.parse_iint::<isize>() };
    ($iter:expr, i64) => { $iter.parse_iint::<i64>() };
    ($iter:expr, i32) => { $iter.parse_iint::<i32>() };
    ($iter:expr, i16) => { $iter.parse_iint::<i16>() };
    ($iter:expr, i8) => { $iter.parse_iint::<i16>() as i8 };
    ($iter:expr, byte) => { $iter.get_ascii_byte().unwrap() };
    ($iter:expr, Bytes) => {{ let mut v = vec![];$iter.get_ascii_bytes(&mut v);v }};
    ($iter:expr, Chars) => {{ let mut v = vec![];$iter.get_ascii_chars(&mut v);v }};
    ($iter:expr, String) => {{ let mut v = vec![];$iter.get_ascii_bytes(&mut v);unsafe { std::string::String::from_utf8_unchecked(v) }}};
    ($iter:expr, LineBytes) => {{ let mut v = vec![];$iter.get_ascii_line_bytes(&mut v).and(Some(v)).unwrap() }};
    ($iter:expr, LineBytesTrim) => {{ let mut v = vec![];$iter.get_ascii_line_bytes_trim(&mut v);v }};
    ($iter:expr, LineString) => {{ let mut v = vec![];$iter.get_ascii_line_bytes(&mut v);unsafe { std::string::String::from_utf8_unchecked(v) }}};
    ($iter:expr, LineStringTrim) => {{ let mut v = vec![];$iter.get_ascii_line_bytes_trim(&mut v);unsafe { std::string::String::from_utf8_unchecked(v) }}};
    ($iter:expr, Utf8Bytes) => {{ let mut v = vec![];$iter.get_utf8_bytes(&mut v);v }};
    ($iter:expr, Utf8String) => {{ let mut v = vec![];$iter.get_utf8_bytes(&mut v);unsafe { std::string::String::from_utf8_unchecked(v) }}};
    ($iter:expr, Utf8LineBytes) => {{ let mut v = vec![];$iter.get_utf8_line_bytes(&mut v);v }};
    ($iter:expr, Utf8LineBytesTrim) => {{ let mut v = vec![];$iter.get_utf8_line_bytes_trim(&mut v);v }};
    ($iter:expr, Utf8LineString) => {{ let mut v = vec![];$iter.get_utf8_line_bytes(&mut v);unsafe { std::string::String::from_utf8_unchecked(v) }}};
    ($iter:expr, Utf8LineStringTrim) => {{ let mut v = vec![];$iter.get_utf8_line_bytes_trim(&mut v);unsafe { std::string::String::from_utf8_unchecked(v) }}};
    ($iter:expr, $t:ty) => {{ let mut v = vec![];unsafe { std::string::String::from_utf8_unchecked($iter.get_utf8_bytes(&mut v).and(Some(v)).unwrap()) }.parse::<$t>().expect("Parse error") }};
}

pub fn solve() {
    //let tins = std::time::Instant::now();
    let stdin = std::io::stdin();
    let mut source = ProconIBufIter::new(stdin.lock());
    macro_rules! finput { ($($r:tt)*) => { finput_inner!{source, $($r)*} }; }
    //let out = stdout();
    //let mut out = BufWriter::new(out.lock());
    //let err = stderr();
    //let mut err = BufWriter::new(err.lock());
    //let mut durs = Vec::with_capacity(16);
    //durs.push((tins.elapsed(), "init"));
    finput! { h: usize, w: usize, n: usize, }
    let w1 = 1536;
    //durs.push((tins.elapsed(), "head_input"));
    let mut cumsum_table = [0i32; 1536 * 1504];
    //durs.push((tins.elapsed(), "cumsum_alloc"));
    for _ in 0..n {
        finput! { a: usize, b: usize, c: usize, d: usize, }
        let aw1 = a * w1;
        let c1w1 = (c + 1) * w1;
        let b0 = b - 1;
        unsafe { *cumsum_table.get_unchecked_mut(aw1 + b0) += 1 };
        unsafe { *cumsum_table.get_unchecked_mut(aw1 + d) -= 1 };
        unsafe { *cumsum_table.get_unchecked_mut(c1w1 + b0) -= 1 };
        unsafe { *cumsum_table.get_unchecked_mut(c1w1 + d) += 1 };
    }
    //durs.push((tins.elapsed(), "input_abcd"));
    for i in 0..h {
        let mut prev = unsafe { cumsum_table.as_ptr().add(i * w1) };
        let mut curr = unsafe { cumsum_table.as_mut_ptr().add(i * w1 + w1) };
        let mut cumsum_x = 0;
        for _ in 0..w {
            cumsum_x += unsafe { *curr };
            unsafe { *curr = *prev + cumsum_x };
            unsafe { prev = prev.add(1) };
            unsafe { curr = curr.add(1) };
        }
    }
    //durs.push((tins.elapsed(), "cumsum"));
    {
        unsafe fn buf_sp(ptr: &mut *mut u8) {
            **ptr = b' ';
            *ptr = (*ptr).add(1);
        }
        unsafe fn buf_lf(ptr: &mut *mut u8) {
            **ptr = b'\n';
            *ptr = (*ptr).add(1);
        }
        unsafe fn buf_u32(ptr: &mut *mut u8, mut d: u32) {
            let bptr = *ptr;
            let mut cptr = *ptr;
            if d == 0 {
                *cptr = b'0';
                *ptr = cptr.add(1);
            } else {
                while d != 0 {
                    let (q, r) = (d / 10, d % 10);
                    d = q;
                    *cptr = b'0' + r as u8;
                    cptr = cptr.add(1);
                }
                *ptr = cptr;
                let mut lptr = bptr;
                let mut rptr = cptr.sub(1);
                while (lptr as usize) < (rptr as usize) {
                    let (dr, dl) = (*lptr, *rptr);
                    *lptr = dl;
                    *rptr = dr;
                    lptr = lptr.add(1);
                    rptr = rptr.sub(1);
                }
            }
        }
        let mut out_buf = Vec::<u8>::with_capacity(15794176);
        //durs.push((tins.elapsed(), "buf_alloc"));
        let buf_ptr = out_buf.as_mut_ptr();
        let mut tptr_line = cumsum_table.as_ptr();
        let mut buf_curptr = buf_ptr;
        for _ in 0..h {
            tptr_line = unsafe { tptr_line.add(w1) };
            let mut tptr = tptr_line;
            for _ in 0..(w - 1) {
                unsafe { buf_u32(&mut buf_curptr, (*tptr) as u32) };
                unsafe { buf_sp(&mut buf_curptr) };
                unsafe { tptr = tptr.add(1) };
            }
            unsafe { buf_u32(&mut buf_curptr, (*tptr) as u32) };
            unsafe { buf_lf(&mut buf_curptr) };
        }
        unsafe { out_buf.set_len((buf_curptr as usize) - (buf_ptr as usize)) };
        //durs.push((tins.elapsed(), "out_buffer"));
        std::io::Write::write_all(&mut std::io::stdout(), out_buf.as_slice()).unwrap();
        //durs.push((tins.elapsed(), "output"));
    }

    //(0..durs.len()).for_each(|i| {eprintln!("{:.6} {:.6} {}",(durs[i].0 - durs[i.max(1) - 1].0).as_secs_f64(),durs[i].0.as_secs_f64(),durs[i].1)});
    //writeln!(&mut out, "{}", count).unwrap();
    //writeln!(&mut err, "{}", count).unwrap();
    //out.flush().unwrap();
    //err.flush().unwrap();
}

fn main() {
    // In order to avoid potential stack overflow, spawn a new thread.
    let stack_size = 104_857_600; // 100 MB
    let thd = std::thread::Builder::new().stack_size(stack_size);
    thd.spawn(|| solve()).unwrap().join().unwrap();
}

/// chmax, chmin sugar syntax
trait Change {
    fn chmax(&mut self, x: Self);
    fn chmin(&mut self, x: Self);
}
impl<T: PartialOrd> Change for T {
    fn chmax(&mut self, x: T) {
        if *self < x {
            *self = x;
        }
    }
    fn chmin(&mut self, x: T) {
        if *self > x {
            *self = x;
        }
    }
}
/// Interaction with `std::io::BufRead` Trait, Implementation of `Iterator<Item = u8>`
pub struct ProconIBufIter<R: std::io::BufRead> {
    inner: R,
    raw: *const u8,
    len: usize,
    ptr: *const u8,
    end: *const u8,
}
unsafe fn ptr_offset_u8(dist: *const u8, origin: *const u8) -> usize {
    // Rust 1.47.0 or later, `dist.offset_from(origin) as usize`
    // <https://doc.rust-lang.org/std/primitive.pointer.html#method.offset_from>
    dist as usize - origin as usize
}
impl<R: std::io::BufRead> ProconIBufIter<R> {
    /// consume raw buffer
    #[allow(unused)]
    fn consume(&mut self, amt: usize) {
        let remain = unsafe { ptr_offset_u8(self.end, self.ptr) };
        assert!(remain >= amt);
        unsafe {
            self.ptr = self.ptr.add(amt);
        }
    }
    /// read when buffer is empty
    unsafe fn inner_read(&mut self) -> bool {
        assert!(self.is_empty());
        self.inner.consume(self.len);
        let buffer = self.inner.fill_buf().unwrap();
        let raw = buffer.as_ptr();
        let len = buffer.len();
        self.raw = raw;
        self.len = len;
        self.ptr = raw;
        self.end = raw.add(len);
        self.len > 0
    }
    /// check end of buffer
    fn is_empty(&self) -> bool {
        self.ptr == self.end
    }
    /// Interaction with `std::io::BufRead` Trait, Implementation of `Iterator<Item = u8>`
    #[allow(unused)]
    fn new(inner: R) -> Self {
        let mut bufiter = Self {
            inner,
            raw: std::ptr::null(),
            len: 0,
            ptr: std::ptr::null(),
            end: std::ptr::null(),
        };
        unsafe { bufiter.inner_read() };
        bufiter
    }
    /// next(), but return empty value
    #[allow(unused)]
    fn next_unread(&mut self) -> Option<()> {
        if self.is_empty() && unsafe { !self.inner_read() } {
            return None;
        }
        unsafe {
            self.ptr = self.ptr.add(1);
        }
        return Some(());
    }
    /// get now pointer & increment pointer
    unsafe fn next_unchecked(&mut self) -> u8 {
        let p = self.ptr;
        self.ptr = p.add(1);
        *p
    }
    /// peek
    #[allow(unused)]
    fn peek(&mut self) -> Option<&u8> {
        if !self.is_empty() || unsafe { self.inner_read() } {
            unsafe { Some(&*self.ptr) }
        } else {
            None
        }
    }
    /// raw buffer
    #[allow(unused)]
    fn raw_buf(&mut self) -> &[u8] {
        if self.is_empty() {
            unsafe {
                self.inner_read();
            }
        }
        unsafe { std::slice::from_raw_parts(self.ptr, ptr_offset_u8(self.end, self.ptr)) }
    }
    /// skip unmatch bytes
    fn skipuntil_bytes_fn<F: FnMut(u8) -> bool>(&mut self, f: &mut F) -> bool {
        loop {
            let mut ptr = self.ptr;
            while ptr != self.end {
                if f(unsafe { *ptr }) {
                    self.ptr = ptr;
                    return true;
                }
                unsafe {
                    ptr = ptr.add(1);
                }
            }
            self.ptr = ptr;
            if unsafe { !self.inner_read() } {
                return false;
            }
        }
    }
}
impl<R: std::io::BufRead> Iterator for ProconIBufIter<R> {
    type Item = u8;
    /// fetch next byte
    fn next(&mut self) -> Option<Self::Item> {
        if !self.is_empty() || unsafe { self.inner_read() } {
            unsafe { Some(self.next_unchecked()) }
        } else {
            None
        }
    }
    /// remain size hint
    fn size_hint(&self) -> (usize, Option<usize>) {
        (unsafe { ptr_offset_u8(self.end, self.ptr) }, None)
    }
}
impl<R: std::io::BufRead> Drop for ProconIBufIter<R> {
    /// Saving the pointer on interruption
    fn drop(&mut self) {
        self.inner
            .consume(unsafe { ptr_offset_u8(self.ptr, self.raw) });
    }
}
/// speed frenzy input parser for program compete (fail parse may cause panic)
trait ProconParse {
    /// parse unsigned integer
    fn parse_uint<
        U: Copy
            + std::cmp::Ord
            + std::ops::BitAnd<Output = U>
            + std::ops::Add<Output = U>
            + std::ops::Sub<Output = U>
            + std::ops::Mul<Output = U>
            + std::convert::From<u8>,
    >(
        &mut self,
    ) -> U;
    /// parse signed integer
    fn parse_iint<
        I: Copy
            + std::cmp::Ord
            + std::ops::BitAnd<Output = I>
            + std::ops::Add<Output = I>
            + std::ops::Sub<Output = I>
            + std::ops::Mul<Output = I>
            + std::convert::From<u8>
            + std::ops::Neg<Output = I>,
    >(
        &mut self,
    ) -> I;
    /// get char (printable ascii char)
    fn parse_byte(&mut self) -> Option<u8>;
    /// get chars (printable ascii word)
    fn parse_bytes(&mut self) -> Vec<u8>;
    /// get line chars (sp+printable ascii)
    fn parse_line_bytes(&mut self) -> Vec<u8>;
    /// get line chars (trimed sp+printable ascii)
    fn parse_line_bytes_trim(&mut self) -> Vec<u8>;
}
/// speed frenzy input byte reader for program compete
trait ProconBytes {
    /// get bytes
    fn get_bytes_fn<F: Fn(u8) -> bool>(&mut self, vec: &mut Vec<u8>, f: &mut F);
    /// get chars
    fn get_ascii_chars_fn<F: Fn(u8) -> bool>(&mut self, vec: &mut Vec<char>, f: &mut F);
    /// get byte (printable ascii char)
    fn get_ascii_byte(&mut self) -> Option<u8>;
    /// get bytes (printable ascii word)
    fn get_ascii_bytes(&mut self, vec: &mut Vec<u8>);
    /// get chars (printable ascii word)
    fn get_ascii_chars(&mut self, vec: &mut Vec<char>);
    /// get line bytes (sp+printable ascii)
    fn get_ascii_line_bytes(&mut self, vec: &mut Vec<u8>);
    /// get line bytes (trimed sp+printable ascii)
    fn get_ascii_line_bytes_trim(&mut self, vec: &mut Vec<u8>);
    /// get bytes (printable utf8 word)
    fn get_utf8_bytes(&mut self, vec: &mut Vec<u8>);
    /// get line bytes (sp+printable utf8)
    fn get_utf8_line_bytes(&mut self, vec: &mut Vec<u8>);
    /// get line bytes (trimed sp+printable utf8)
    fn get_utf8_line_bytes_trim(&mut self, vec: &mut Vec<u8>);
}
impl<T: Iterator<Item = u8>> ProconParse for T {
    fn parse_uint<
        U: Copy
            + std::cmp::Ord
            + std::ops::BitAnd<Output = U>
            + std::ops::Add<Output = U>
            + std::ops::Sub<Output = U>
            + std::ops::Mul<Output = U>
            + std::convert::From<u8>,
    >(
        &mut self,
    ) -> U {
        loop {
            match self.next() {
                Some(c @ b'0'..=b'9') => {
                    let mut x = U::from(c.wrapping_sub(b'0'));
                    while let Some(c @ b'0'..=b'9') = self.next() {
                        x = x.mul(U::from(10)).add(U::from(c.wrapping_sub(b'0')));
                    }
                    break x;
                }
                Some(_) => continue,
                None => break U::from(0),
            }
        }
    }
    fn parse_iint<
        I: Copy
            + std::cmp::Ord
            + std::ops::BitAnd<Output = I>
            + std::ops::Add<Output = I>
            + std::ops::Sub<Output = I>
            + std::ops::Mul<Output = I>
            + std::ops::Neg<Output = I>
            + std::convert::From<u8>,
    >(
        &mut self,
    ) -> I {
        loop {
            match self.next() {
                Some(c @ b'0'..=b'9') => {
                    let mut x = I::from(c.wrapping_sub(b'0'));
                    while let Some(c @ b'0'..=b'9') = self.next() {
                        x = x.mul(I::from(10)).add(I::from(c.wrapping_sub(b'0')));
                    }
                    break x;
                }
                Some(b'-') => {
                    let mut x = if let Some(c @ b'0'..=b'9') = self.next() {
                        I::from(c.wrapping_sub(b'0')).neg()
                    } else {
                        break I::from(0);
                    };
                    while let Some(c @ b'0'..=b'9') = self.next() {
                        x = x.mul(I::from(10)).sub(I::from(c.wrapping_sub(b'0')));
                    }
                    break x;
                }
                Some(_) => continue,
                None => break I::from(0),
            }
        }
    }
    fn parse_byte(&mut self) -> Option<u8> {
        loop {
            match self.next() {
                Some(c @ b'!'..=b'~') => break Some(c),
                Some(_) => continue,
                None => break None,
            }
        }
    }
    fn parse_bytes(&mut self) -> Vec<u8> {
        let mut v = vec![];
        loop {
            match self.next() {
                Some(c @ b'!'..=b'~') => {
                    v.push(c);
                    while let Some(c @ b'!'..=b'~') = self.next() {
                        v.push(c);
                    }
                    break v;
                }
                Some(_) => continue,
                None => break v,
            }
        }
    }
    fn parse_line_bytes(&mut self) -> Vec<u8> {
        let mut v = vec![];
        loop {
            match self.next() {
                Some(c @ b' '..=b'~') => {
                    v.push(c);
                    while let Some(c @ b' '..=b'~') = self.next() {
                        v.push(c);
                    }
                    break v;
                }
                Some(_) => continue,
                None => break v,
            }
        }
    }
    fn parse_line_bytes_trim(&mut self) -> Vec<u8> {
        let mut v = vec![];
        loop {
            match self.next() {
                Some(c @ b'!'..=b'~') => {
                    v.push(c);
                    while let Some(c @ b' '..=b'~') = self.next() {
                        v.push(c);
                    }
                    while v.last() == Some(&b' ') {
                        v.pop();
                    }
                    break v;
                }
                Some(_) => continue,
                None => break v,
            }
        }
    }
}
impl<R: std::io::BufRead> ProconBytes for ProconIBufIter<R> {
    /// get bytes vector
    fn get_bytes_fn<F: Fn(u8) -> bool>(&mut self, vec: &mut Vec<u8>, f: &mut F) {
        if !self.skipuntil_bytes_fn(f) {
            return;
        }
        let begin_ptr = self.ptr;
        let mut ptr = self.ptr;
        loop {
            unsafe {
                ptr = ptr.add(1);
            }
            if ptr == self.end {
                self.ptr = ptr;
                vec.extend_from_slice(unsafe {
                    std::slice::from_raw_parts(begin_ptr, ptr_offset_u8(ptr, begin_ptr))
                });
                break;
            }
            if !f(unsafe { *ptr }) {
                self.ptr = ptr;
                vec.extend_from_slice(unsafe {
                    std::slice::from_raw_parts(begin_ptr, ptr_offset_u8(ptr, begin_ptr))
                });
                return;
            }
        }
        if unsafe { !self.inner_read() } {
            return;
        }
        ptr = self.ptr;
        loop {
            if !f(unsafe { *ptr }) {
                self.ptr = ptr;
                vec.extend_from_slice(unsafe {
                    std::slice::from_raw_parts(self.raw, ptr_offset_u8(ptr, self.raw))
                });
                return;
            }
            unsafe {
                ptr = ptr.add(1);
            }
            if ptr == self.end {
                self.ptr = ptr;
                vec.extend_from_slice(unsafe { std::slice::from_raw_parts(self.raw, self.len) });
                if unsafe { !self.inner_read() } {
                    return;
                }
                ptr = self.ptr;
            }
        }
    }
    fn get_ascii_chars_fn<F: Fn(u8) -> bool>(&mut self, vec: &mut Vec<char>, f: &mut F) {
        if !self.skipuntil_bytes_fn(f) {
            return;
        }
        let begin_ptr = self.ptr;
        let mut ptr = self.ptr;
        loop {
            unsafe {
                ptr = ptr.add(1);
            }
            if ptr == self.end {
                self.ptr = ptr;
                let len = unsafe { ptr_offset_u8(ptr, begin_ptr) };
                vec.reserve(len);
                let mut p = begin_ptr;
                while p != ptr {
                    vec.push(unsafe { *p } as char);
                    p = unsafe { p.add(1) };
                }
                break;
            }
            if !f(unsafe { *ptr }) {
                self.ptr = ptr;
                let len = unsafe { ptr_offset_u8(ptr, begin_ptr) };
                vec.reserve(len);
                let mut p = begin_ptr;
                while p != ptr {
                    vec.push(unsafe { *p } as char);
                    p = unsafe { p.add(1) };
                }
                return;
            }
        }
        if unsafe { !self.inner_read() } {
            return;
        }
        ptr = self.ptr;
        loop {
            if !f(unsafe { *ptr }) {
                self.ptr = ptr;
                let len = unsafe { ptr_offset_u8(ptr, self.raw) };
                vec.reserve(len);
                let mut p = self.raw;
                while p != ptr {
                    vec.push(unsafe { *p } as char);
                    p = unsafe { p.add(1) };
                }
                return;
            }
            unsafe {
                ptr = ptr.add(1);
            }
            if ptr == self.end {
                self.ptr = ptr;
                let len = unsafe { ptr_offset_u8(ptr, self.raw) };
                vec.reserve(len);
                let mut p = self.raw;
                while p != ptr {
                    vec.push(unsafe { *p } as char);
                    p = unsafe { p.add(1) };
                }
                if unsafe { !self.inner_read() } {
                    return;
                }
                ptr = self.ptr;
            }
        }
    }
    fn get_ascii_byte(&mut self) -> Option<u8> {
        loop {
            match self.next() {
                Some(c @ b'!'..=b'~') => break Some(c),
                Some(_) => continue,
                None => break None,
            }
        }
    }
    fn get_ascii_bytes(&mut self, vec: &mut Vec<u8>) {
        self.get_bytes_fn(vec, &mut |c| (b'!'..=b'~').contains(&c))
    }
    fn get_ascii_chars(&mut self, vec: &mut Vec<char>) {
        self.get_ascii_chars_fn(vec, &mut |c| (b'!'..=b'~').contains(&c))
    }
    fn get_ascii_line_bytes(&mut self, vec: &mut Vec<u8>) {
        self.get_bytes_fn(vec, &mut |c| (b' '..=b'~').contains(&c))
    }
    fn get_ascii_line_bytes_trim(&mut self, vec: &mut Vec<u8>) {
        self.skipuntil_bytes_fn(&mut |c| (b'!'..=b'~').contains(&c));
        self.get_bytes_fn(vec, &mut |c| (b' '..=b'~').contains(&c));
        while vec.last() == Some(&b' ') {
            vec.pop();
        }
    }
    fn get_utf8_bytes(&mut self, vec: &mut Vec<u8>) {
        self.get_bytes_fn(vec, &mut |c| (b'!'..=0xf4).contains(&c))
    }
    fn get_utf8_line_bytes(&mut self, vec: &mut Vec<u8>) {
        self.get_bytes_fn(vec, &mut |c| (b' '..=0xf4).contains(&c))
    }
    fn get_utf8_line_bytes_trim(&mut self, vec: &mut Vec<u8>) {
        self.skipuntil_bytes_fn(&mut |c| (b'!'..=0xf4).contains(&c));
        self.get_bytes_fn(vec, &mut |c| (b' '..=0xf4).contains(&c));
        while vec.last() == Some(&b' ') {
            vec.pop();
        }
    }
}

Submission Info

Judge Result