Rust IO for PS (From Bubblers)

use io::*;  
pub fn main() {  
    let stdin = stdin().lock();  
    let stdout = stdout().lock();  
    let mut io = IO::new(stdin, stdout);  
    solve(&mut io);  
}

    pub(crate) struct IO<R: BufRead, W: Write> {
        ii: I<R>,
        oo: BufWriter<W>,
    }
    impl<R: BufRead, W: Write> IO<R, W> {
        pub(crate) fn new(r: R, w: W) -> Self {
            Self {
                ii: I::new(r),
                oo: BufWriter::new(w),
            }
        }
        pub(crate) fn get<T: Fill>(&mut self, exemplar: T) -> Option<T> {
            self.ii.get(exemplar)
        }
        pub(crate) fn put<T: Print>(&mut self, t: T) -> &mut Self {
            t.print(&mut self.oo);
            self
        }
        pub(crate) fn nl(&mut self) -> &mut Self {
            self.put("\n")
        }
    }

let n: usize = io.get(0usize)?;

    pub(crate) struct I<R: BufRead> {
        r: R,
        line: String,
        rem: &'static str,
    }
    
    impl<R: BufRead> I<R> {
        pub(crate) fn new(r: R) -> Self {
            Self {
                r,
                line: String::new(),
                rem: "",
            }
        }
        pub(crate) fn next_line(&mut self) -> Option<()> {
            self.line.clear();
            (self.r.read_line(&mut self.line).unwrap() > 0)
                .then(|| {
                    self
                        .rem = unsafe {
                        (&self.line[..] as *const str).as_ref().unwrap()
                    };
                })
        }
        pub(crate) fn get<T: Fill>(&mut self, exemplar: T) -> Option<T> {
            let mut exemplar = exemplar;
            exemplar.fill_from_input(self)?;
            Some(exemplar)
        }
    }

        pub(crate) fn next_line(&mut self) -> Option<()> {
            self.line.clear(); // 다음줄을 읽기위해 현제 버퍼 초기화
            (self.r.read_line(&mut self.line).unwrap() > 0) // 실제로 읽어들인 값이 있으면
                .then(|| {
                    self
                        .rem = unsafe { // .rem도 같이 초기화를 해주는데
                        (&self.line[..] as *const str).as_ref().unwrap() // raw 포인터로 변환을 해준다. 
                    };
                })
        }

// 여기서 rem은 포인터로서, line을 가리키며 지금 어디까지 읽었는지를 나타내줘야한다.
// 즉 로직상으로 line의 또 하나의 참조 역할이다.
struct I<R: BufRead> {
    line: String,
    rem: &'??? str,  // -> line을 가리키는 포인터, 그렇다면 러스트 입장에서는 line보다 짧은 수명을 지정해줘야함
}

struct I<'a, R: BufRead> {
    line: String,
    rem: &'a str,  // rem은 line보다 짧은 라이프타임과 하나의 문자열에 대한 두 참조가 필요한 상황을 해결해야한다.
}

self.rem = unsafe {
    (&self.line[..] as *const str).as_ref().unwrap()
};

struct I<R: BufRead> {
    r: R,
    line: String,
    pos: usize,
}

impl<R: BufRead> I<R> {
    fn remaining(&self) -> &str {
        &self.line[self.pos..]
    }
    
    fn advance(&mut self, len: usize) {
        self.pos += len;
    }
}

pub(crate) trait Fill {  
    fn fill_from_input<R: BufRead>(&mut self, i: &mut I<R>) -> Option<()>;  
}  
fn ws(c: char) -> bool {  
    c <= ' '  
}

    impl Fill for String {
        fn fill_from_input<R: BufRead>(&mut self, i: &mut I<R>) -> Option<()> {
	        // 공백 스킵
            i.rem = i.rem.trim_start_matches(ws);
            // 비어있으면 줄바꿔서 스킵
            while i.rem.is_empty() {
                i.next_line()?;
                i.rem = i.rem.trim_start_matches(ws);
            }
            // 토큰 하나 뽑고
            let tok = i.rem.split(ws).next().unwrap();
            // 포인터 밀어주고
            i.rem = &i.rem[tok.len()..];
            *self = tok.to_string();
            Some(())
        }
    }
    impl Fill for Vec<u8> {
        fn fill_from_input<R: BufRead>(&mut self, i: &mut I<R>) -> Option<()> {
            i.rem = i.rem.trim_start_matches(ws);
            while i.rem.is_empty() {
                i.next_line()?;
                i.rem = i.rem.trim_start_matches(ws);
            }
            let tok = i.rem.split(ws).next().unwrap();
            i.rem = &i.rem[tok.len()..];
            self.extend_from_slice(tok.as_bytes());
            Some(())
        }
    }

	// iter로 처리
    impl<T: Fill> Fill for Vec<T> {
        fn fill_from_input<R: BufRead>(&mut self, i: &mut I<R>) -> Option<()> {
            for ii in self.iter_mut() {
                ii.fill_from_input(i)?;
            }
            Some(())
        }
    }

pub(crate) fn get<T: Fill>(&mut self, exemplar: T) -> Option<T> {  
    let mut exemplar = exemplar;  
    exemplar.fill_from_input(self)?;  
    Some(exemplar)  
}