Rustの出力コード改善 about atcoder-tools HOT 4 OPEN

use io::*;
use std::*;

const MOD: i64 = 123;
const YES: &'static str = "yes";
const NO: &'static str = "NO";
fn solve(N: i64, M: i64, H: Vec<Vec<String>>, A: Vec<i64>, B: Vec<f64>, Q: i64, X: Vec<i64>) {}

fn main() {
    let con = read_string();
    let mut scanner = Scanner::new(&con);
    let N: i64 = scanner.next();
    let M: i64 = scanner.next();
    let H: Vec<Vec<String>> = (0..(N - 2 + 1) as usize)
        .map(|_| {
            (0..(M - 1 - 2 + 1) as usize)
                .map(|_| scanner.next())
                .collect::<Vec<_>>()
        })
        .collect::<Vec<_>>();
    let mut A: Vec<i64> = vec![0i64; (N - 2 + 1) as usize];
    let mut B: Vec<f64> = vec![0f64; (N - 2 + 1) as usize];
    for i in 0..(N - 2 + 1) as usize {
        A[i] = scanner.next();
        B[i] = scanner.next();
    }
    let Q: i64 = scanner.next();
    let X: Vec<i64> = (0..(M + Q) as usize)
        .map(|_| scanner.next())
        .collect::<Vec<_>>();
    // 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(move || solve(N, M, H, A, B, Q, X))
        .unwrap()
        .join()
        .unwrap();
}

pub mod io {
    use std;
    use std::str::FromStr;

    pub struct Scanner<'a> {
        iter: std::str::SplitWhitespace<'a>,
    }

    impl<'a> Scanner<'a> {
        pub fn new(s: &'a str) -> Scanner<'a> {
            Scanner {
                iter: s.split_whitespace(),
            }
        }

        pub fn next<T: FromStr>(&mut self) -> T {
            let s = self.iter.next().unwrap();
            if let Ok(v) = s.parse::<T>() {
                v
            } else {
                panic!("Parse error")
            }
        }

        pub fn next_vec_len<T: FromStr>(&mut self) -> Vec<T> {
            let n: usize = self.next();
            self.next_vec(n)
        }

        pub fn next_vec<T: FromStr>(&mut self, n: usize) -> Vec<T> {
            (0..n).map(|_| self.next()).collect()
        }
    }

    pub fn read_string() -> String {
        use std::io::Read;

        let mut s = String::new();
        std::io::stdin().read_to_string(&mut s).unwrap();
        s
    }

    pub fn read_line() -> String {
        let mut s = String::new();
        std::io::stdin().read_line(&mut s).unwrap();
        s.trim_right().to_owned()
    }
}