Problem:
Score : 100 points

Problem Statement

You are given a grid of N rows and M columns. The square at the i-th row and j-th column will be denoted as (i,j).
Some of the squares contain an object. All the remaining squares are empty.
The state of the grid is represented by strings S_1,S_2,\cdots,S_N. The square (i,j) contains an object if S_{i,j}= # and is empty if S_{i,j}= ..

Consider placing 1 \times 2 tiles on the grid. Tiles can be placed vertically or horizontally to cover two adjacent empty squares.
Tiles must not stick out of the grid, and no two different tiles may intersect. Tiles cannot occupy the square with an object.

Calculate the maximum number of tiles that can be placed and any configulation that acheives the maximum.

Constraints

1 \leq N \leq 100

1 \leq M \leq 100

S_i is a string with length M consists of # and ..

Input

Input is given from Standard Input in the following format:

N M
S_1
S_2
\vdots
S_N

Output

On the first line, print the maximum number of tiles that can be placed.

On the next N lines, print a configulation that achieves the maximum.
Precisely, output the strings t_1,t_2,\cdots,t_N constructed by the following way.

t_i is initialized to S_i.

For each (i,j), if there is a tile that occupies (i,j) and (i+1,j), change t_{i,j}:=v, t_{i+1,j}:=^.

For each (i,j), if there is a tile that occupies (i,j) and (i,j+1), change t_{i,j}:=>, t_{i,j+1}:=<.

See samples for further information.

You may print any configulation that maximizes the number of tiles.

Sample Input 1

3 3
#..
..#
...

Sample Output 1

3
#><
vv#
^^.

The following output is also treated as a correct answer.

3
#><
v.#
^><

Solution in Rust (1.42.0) (judge verdict: Accepted)

use competitive_programming_rs::graph::maximum_flow::dinitz::Dinitz;
fn main() {
    let (r, w) = (std::io::stdin(), std::io::stdout());
    let mut sc = IO::new(r.lock(), w.lock());
    let n: usize = sc.read();
    let m: usize = sc.read();
    let mut map: Vec<Vec<char>> = (0..n).map(|_| sc.chars()).collect();
    let mut dinitz = Dinitz::new(m * n + 2);
    let source = m * n;
    let sink = source + 1;
    for i in 0..n {
        for j in 0..m {
            if map[i][j] == '#' {
                continue;
            }
            let v = i * m + j;
            if (i + j) % 2 == 0 {
                dinitz.add_edge(source, v, 1);
                for &(di, dj) in [(0, !0), (0, 1), (1, 0), (!0, 0)].iter() {
                    let ni = i.wrapping_add(di);
                    let nj = j.wrapping_add(dj);
                    if ni >= n || nj >= m {
                        continue;
                    }
                    dinitz.add_edge(v, ni * m + nj, 1);
                }
            } else {
                dinitz.add_edge(v, sink, 1);
            }
        }
    }
    let flow = dinitz.max_flow(source, sink);
    for from in 0..(m * n) {
        for e in dinitz.g[from].iter() {
            if e.is_reversed || e.cap > 0 || e.to == sink {
                continue;
            }
            let (from_i, from_j) = (from / m, from % m);
            let (to_i, to_j) = (e.to / m, e.to % m);
            assert_eq!(map[from_i][from_j], '.');
            assert_eq!(map[to_i][to_j], '.');
            if from_i < to_i {
                map[from_i][from_j] = 'v';
                map[to_i][to_j] = '^';
            } else if from_i > to_i {
                map[from_i][from_j] = '^';
                map[to_i][to_j] = 'v';
            } else if from_j < to_j {
                map[from_i][from_j] = '>';
                map[to_i][to_j] = '<';
            } else {
                map[from_i][from_j] = '<';
                map[to_i][to_j] = '>';
            }
        }
    }
    sc.write(flow);
    sc.write('\n');
    for i in 0..n {
        for j in 0..m {
            sc.write(map[i][j]);
        }
        sc.write('\n');
    }
}
pub struct IO<R, W: std::io::Write>(R, std::io::BufWriter<W>);
impl<R: std::io::Read, W: std::io::Write> IO<R, W> {
    pub fn new(r: R, w: W) -> Self {
        Self(r, std::io::BufWriter::new(w))
    }
    pub fn write<S: ToString>(&mut self, s: S) {
        use std::io::Write;
        self.1.write_all(s.to_string().as_bytes()).unwrap();
    }
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self
            .0
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }
    pub fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}
mod competitive_programming_rs {
    #![doc = " # The Competitive Programming Library in Rust"]
    #![doc = " The Competitive Programming Library in Rust is a set of snippets,"]
    #![doc = " which can be used in programming contests."]
    #![allow(clippy::module_inception)]
    #![allow(clippy::suspicious_arithmetic_impl)]
    #[doc = " Algorithms related to graph theory."]
    pub mod graph {
        pub mod bridge_detection {
            pub struct BridgeDetector {
                articulations: Vec<usize>,
                bridges: Vec<(usize, usize)>,
                visit: Vec<bool>,
                order: Vec<usize>,
                low_link: Vec<usize>,
                k: usize,
            }
            impl BridgeDetector {
                pub fn new(graph: &[Vec<usize>]) -> Self {
                    let n = graph.len();
                    let mut d = BridgeDetector {
                        articulations: vec![],
                        bridges: vec![],
                        visit: vec![false; n],
                        order: vec![0; n],
                        low_link: vec![0; n],
                        k: 0,
                    };
                    d.run(graph);
                    d
                }
                fn run(&mut self, graph: &[Vec<usize>]) {
                    let n = graph.len();
                    for i in 0..n {
                        if !self.visit[i] {
                            self.dfs(i, 0, graph, i);
                        }
                    }
                }
                fn dfs(&mut self, v: usize, previous: usize, graph: &[Vec<usize>], root: usize) {
                    self.visit[v] = true;
                    self.order[v] = self.k;
                    self.k += 1;
                    self.low_link[v] = self.order[v];
                    let mut is_articulation = false;
                    let mut dimension = 0;
                    for &next in graph[v].iter() {
                        if !self.visit[next] {
                            dimension += 1;
                            self.dfs(next, v, graph, root);
                            self.low_link[v] = std::cmp::min(self.low_link[v], self.low_link[next]);
                            if v != root && self.order[v] <= self.low_link[next] {
                                is_articulation = true;
                            }
                            if self.order[v] < self.low_link[next] {
                                let min = std::cmp::min(v, next);
                                let max = std::cmp::max(v, next);
                                self.bridges.push((min, max));
                            }
                        } else if v == root || next != previous {
                            self.low_link[v] = std::cmp::min(self.low_link[v], self.order[next]);
                        }
                    }
                    if v == root && dimension > 1 {
                        is_articulation = true;
                    }
                    if is_articulation {
                        self.articulations.push(v);
                    }
                }
            }
            #[cfg(test)]
            mod tests {
                use super::*;
                use crate::utils::test_helper::Tester;
                #[test]
                fn solve_grl_3_a() {
                    let tester = Tester::new("./assets/GRL_3_A/in/", "./assets/GRL_3_A/out/");
                    tester.test_solution(|sc| {
                        let n: usize = sc.read();
                        let m: usize = sc.read();
                        let mut graph = vec![vec![]; n];
                        for _ in 0..m {
                            let u: usize = sc.read();
                            let v: usize = sc.read();
                            graph[u].push(v);
                            graph[v].push(u);
                        }
                        let mut low_link_link = BridgeDetector::new(&graph);
                        low_link_link.articulations.sort();
                        for v in low_link_link.articulations.into_iter() {
                            sc.write(format!("{}\n", v));
                        }
                    });
                }
                #[test]
                fn solve_grl_3_b() {
                    let tester = Tester::new("./assets/GRL_3_B/in/", "./assets/GRL_3_B/out/");
                    tester.test_solution(|sc| {
                        let n: usize = sc.read();
                        let m: usize = sc.read();
                        let mut graph = vec![vec![]; n];
                        for _ in 0..m {
                            let u: usize = sc.read();
                            let v: usize = sc.read();
                            graph[u].push(v);
                            graph[v].push(u);
                        }
                        let mut low_link_link = BridgeDetector::new(&graph);
                        low_link_link.bridges.sort();
                        for (a, b) in low_link_link.bridges.into_iter() {
                            sc.write(format!("{} {}\n", a, b));
                        }
                    });
                }
            }
        }
        pub mod cost_scaling_push_relabel {
            pub mod cost_scaling_push_relabel {
                use std::collections::VecDeque;
                type Flow = i64;
                type Cost = i64;
                const INF_POTENTIAL: f64 = 1e10;
                const SCALING_FACTOR: f64 = 2.0;
                #[derive(Clone)]
                struct Edge {
                    to: usize,
                    rev: usize,
                    flow: Flow,
                    capacity: Flow,
                    cost: Cost,
                    is_rev: bool,
                }
                impl Edge {
                    fn residual(&self) -> Flow {
                        self.capacity - self.flow
                    }
                }
                #[derive(Clone)]
                struct Node {
                    excess_flow: Flow,
                    potential: f64,
                }
                pub struct Solver {
                    nodes: Vec<Node>,
                    graph: Vec<Vec<Edge>>,
                    active_nodes: VecDeque<usize>,
                    cost_scaling_factor: f64,
                    eps: f64,
                }
                impl Solver {
                    pub fn new(num_nodes: usize) -> Self {
                        Self {
                            nodes: vec![
                                Node {
                                    excess_flow: 0,
                                    potential: 0.0
                                };
                                num_nodes
                            ],
                            graph: vec![vec![]; num_nodes],
                            active_nodes: VecDeque::new(),
                            eps: 1.0,
                            cost_scaling_factor: num_nodes as f64 * 2.0,
                        }
                    }
                    pub fn add_edge(&mut self, from: usize, to: usize, capacity: Flow, cost: Cost) {
                        let rev = self.graph[to].len();
                        self.graph[from].push(Edge {
                            to,
                            rev,
                            flow: 0,
                            capacity,
                            cost,
                            is_rev: false,
                        });
                        let rev = self.graph[from].len() - 1;
                        self.graph[to].push(Edge {
                            to: from,
                            rev,
                            flow: capacity,
                            capacity,
                            cost: -cost,
                            is_rev: true,
                        });
                        self.eps = max(self.eps, cost.abs() as f64 * self.cost_scaling_factor);
                    }
                    pub fn solve(&mut self, source: usize, sink: usize, flow: Flow) -> Flow {
                        self.nodes[source].excess_flow = flow;
                        self.nodes[sink].excess_flow = -flow;
                        while self.eps > 1.0 {
                            for node in 0..self.nodes.len() {
                                for edge in 0..self.graph[node].len() {
                                    if self.graph[node][edge].is_rev {
                                        continue;
                                    }
                                    let reduced_cost = self.calc_reduced_cost(node, edge);
                                    if reduced_cost < 0.0 && self.graph[node][edge].residual() > 0 {
                                        let f = self.graph[node][edge].residual();
                                        self.push_flow(node, edge, f);
                                    }
                                    if reduced_cost > 0.0 && self.graph[node][edge].flow > 0 {
                                        let f = -self.graph[node][edge].flow;
                                        self.push_flow(node, edge, f);
                                    }
                                }
                            }
                            self.get_active_nodes();
                            while let Some(node) = self.active_nodes.pop_front() {
                                while self.nodes[node].excess_flow > 0 {
                                    if !self.push(node) {
                                        self.relabel(node);
                                        self.active_nodes.push_back(node);
                                        break;
                                    }
                                }
                            }
                            self.eps = max(1.0, self.eps / SCALING_FACTOR);
                        }
                        let mut total_cost = 0;
                        for e in self.graph.iter().flat_map(|g| g.iter()) {
                            if e.is_rev {
                                continue;
                            }
                            total_cost += e.flow * e.cost;
                        }
                        total_cost
                    }
                    fn push_flow(&mut self, node: usize, edge: usize, flow: Flow) {
                        self.graph[node][edge].flow += flow;
                        let to = self.graph[node][edge].to;
                        let rev = self.graph[node][edge].rev;
                        let from = node;
                        self.graph[to][rev].flow -= flow;
                        self.nodes[from].excess_flow -= flow;
                        self.nodes[to].excess_flow += flow;
                    }
                    fn calc_reduced_cost(&self, node: usize, edge: usize) -> f64 {
                        let cost = self.graph[node][edge].cost;
                        let from = node;
                        let to = self.graph[node][edge].to;
                        cost as f64 * self.cost_scaling_factor - self.nodes[from].potential
                            + self.nodes[to].potential
                    }
                    fn get_active_nodes(&mut self) {
                        for u in 0..self.nodes.len() {
                            if self.nodes[u].excess_flow > 0 {
                                self.active_nodes.push_back(u);
                            }
                        }
                    }
                    fn push(&mut self, from: usize) -> bool {
                        if self.nodes[from].excess_flow == 0 {
                            return false;
                        }
                        assert!(self.nodes[from].excess_flow > 0);
                        for i in (0..self.graph[from].len()).rev() {
                            if self.graph[from][i].residual() == 0 {
                                continue;
                            }
                            let reduced_cost = self.calc_reduced_cost(from, i);
                            if reduced_cost < 0.0 {
                                let flow = min(
                                    self.graph[from][i].residual(),
                                    self.nodes[from].excess_flow,
                                );
                                self.push_flow(from, i, flow);
                                let to = self.graph[from][i].to;
                                if self.nodes[to].excess_flow > 0
                                    && self.nodes[to].excess_flow <= flow
                                {
                                    self.active_nodes.push_back(to);
                                }
                                return true;
                            }
                        }
                        false
                    }
                    fn relabel(&mut self, from: usize) {
                        let mut min_potential = INF_POTENTIAL;
                        for e in self.graph[from].iter() {
                            if e.residual() > 0 {
                                min_potential = min(
                                    min_potential,
                                    e.cost as f64 * self.cost_scaling_factor
                                        + self.nodes[e.to].potential
                                        + self.eps,
                                );
                            }
                        }
                        assert!(min_potential < INF_POTENTIAL);
                        self.nodes[from].potential = min_potential;
                    }
                }
                fn min<T: PartialOrd>(a: T, b: T) -> T {
                    if a > b {
                        b
                    } else {
                        a
                    }
                }
                fn max<T: PartialOrd>(a: T, b: T) -> T {
                    if a < b {
                        b
                    } else {
                        a
                    }
                }
            }
            #[cfg(test)]
            mod tests {
                use crate::graph::cost_scaling_push_relabel::cost_scaling_push_relabel;
                use crate::graph::min_cost_flow::primal_dual;
                use crate::utils::test_helper::Tester;
                #[test]
                fn solve_grl_6_b() {
                    let tester = Tester::new("./assets/GRL_6_B/in/", "./assets/GRL_6_B/out/");
                    tester.test_solution(|sc| {
                        let v: usize = sc.read();
                        let e: usize = sc.read();
                        let f: i64 = sc.read();
                        let mut solver = cost_scaling_push_relabel::Solver::new(v);
                        let mut verify = primal_dual::MinimumCostFlowSolver::new(v);
                        for _ in 0..e {
                            let u: usize = sc.read();
                            let v: usize = sc.read();
                            let c: i64 = sc.read();
                            let d: i64 = sc.read();
                            solver.add_edge(u, v, c, d);
                            verify.add_edge(u, v, c, d);
                        }
                        match verify.solve(0, v - 1, f) {
                            Some(ans) => {
                                sc.write(format!("{}\n", ans));
                                assert_eq!(ans, solver.solve(0, v - 1, f));
                            }
                            _ => {
                                sc.write("-1\n");
                            }
                        }
                    });
                }
            }
        }
        pub mod lca {
            pub mod lca {
                const MAX_PARENT: usize = 1 << 50;
                pub struct LowestCommonAncestor {
                    parent: Vec<Vec<usize>>,
                    depth: Vec<usize>,
                    log_v: usize,
                }
                impl LowestCommonAncestor {
                    pub fn new(graph: &[Vec<usize>]) -> Self {
                        let num_v = graph.len();
                        let root = 0;
                        let mut depth = vec![0; num_v];
                        let mut log_v = 1;
                        let mut i = 1;
                        while i <= num_v {
                            i *= 2;
                            log_v += 1;
                        }
                        let mut parent: Vec<Vec<usize>> = vec![vec![0; num_v]; log_v];
                        let mut depth_vis = vec![false; num_v];
                        let mut stack = ::std::collections::VecDeque::new();
                        stack.push_front(root);
                        parent[0][root] = MAX_PARENT;
                        depth[root] = 0;
                        depth_vis[root] = true;
                        while !stack.is_empty() {
                            let v = stack.pop_front().unwrap();
                            stack.push_front(v);
                            for &u in &graph[v] {
                                if depth_vis[u] {
                                    continue;
                                }
                                parent[0][u] = v;
                                depth[u] = depth[v] + 1;
                                depth_vis[u] = true;
                                stack.push_front(u);
                            }
                            let head = stack.pop_front().unwrap();
                            if head != v {
                                stack.push_front(head);
                            }
                        }
                        for k in 0..(log_v - 1) {
                            for u in 0..num_v {
                                parent[k + 1][u] = if parent[k][u] == MAX_PARENT {
                                    MAX_PARENT
                                } else {
                                    parent[k][parent[k][u]]
                                };
                            }
                        }
                        LowestCommonAncestor {
                            parent,
                            depth,
                            log_v,
                        }
                    }
                    pub fn get_lca(&self, u: usize, v: usize) -> usize {
                        let (mut u, mut v) = if self.depth[u] <= self.depth[v] {
                            (u, v)
                        } else {
                            (v, u)
                        };
                        for k in 0..self.log_v {
                            if ((self.depth[v] - self.depth[u]) & (1 << k)) != 0 {
                                v = self.parent[k][v];
                            }
                        }
                        if u == v {
                            return u;
                        }
                        for k in (0..self.log_v).rev() {
                            if self.parent[k][u] != self.parent[k][v] {
                                u = self.parent[k][u];
                                v = self.parent[k][v];
                            }
                        }
                        self.parent[0][u]
                    }
                    pub fn get_dist(&self, u: usize, v: usize) -> usize {
                        let lca = self.get_lca(u, v);
                        self.depth[u] + self.depth[v] - self.depth[lca] * 2
                    }
                }
            }
            #[cfg(test)]
            mod tests {
                use super::lca::*;
                use crate::utils::test_helper::Tester;
                #[test]
                fn solve_grl_5_c() {
                    let tester = Tester::new("./assets/GRL_5_C/in/", "./assets/GRL_5_C/out/");
                    tester.test_solution(|sc| {
                        let n: usize = sc.read();
                        let mut graph = (0..n).map(|_| Vec::new()).collect::<Vec<_>>();
                        for i in 0..n {
                            let k = sc.read();
                            for _ in 0..k {
                                let c: usize = sc.read();
                                graph[i].push(c);
                                graph[c].push(i);
                            }
                        }
                        let lca = LowestCommonAncestor::new(&graph);
                        let q: usize = sc.read();
                        for _ in 0..q {
                            let u: usize = sc.read();
                            let v: usize = sc.read();
                            let ans = lca.get_lca(u, v);
                            sc.write(format!("{}\n", ans));
                        }
                    });
                }
            }
        }
        pub mod maximum_flow {
            pub mod dinitz {
                pub struct Edge {
                    pub to: usize,
                    pub rev: usize,
                    pub is_reversed: bool,
                    pub cap: i64,
                }
                pub struct Dinitz {
                    pub g: Vec<Vec<Edge>>,
                }
                impl Dinitz {
                    pub fn new(v: usize) -> Dinitz {
                        let mut g: Vec<Vec<Edge>> = Vec::new();
                        for _ in 0..v {
                            g.push(Vec::new());
                        }
                        Dinitz { g }
                    }
                    pub fn add_edge(&mut self, from: usize, to: usize, cap: i64) {
                        let to_len = self.g[to].len();
                        let from_len = self.g[from].len();
                        self.g[from].push(Edge {
                            to,
                            rev: to_len,
                            is_reversed: false,
                            cap,
                        });
                        self.g[to].push(Edge {
                            to: from,
                            rev: from_len,
                            is_reversed: true,
                            cap: 0,
                        });
                    }
                    fn dfs(
                        &mut self,
                        v: usize,
                        sink: usize,
                        flow: i64,
                        level: &[i32],
                        iter: &mut [usize],
                    ) -> i64 {
                        if v == sink {
                            return flow;
                        }
                        while iter[v] < self.g[v].len() {
                            let flow = std::cmp::min(flow, self.g[v][iter[v]].cap);
                            let to = self.g[v][iter[v]].to;
                            if flow > 0 && level[v] < level[to] {
                                let flowed = self.dfs(to, sink, flow, level, iter);
                                if flowed > 0 {
                                    let rev = self.g[v][iter[v]].rev;
                                    self.g[v][iter[v]].cap -= flowed;
                                    self.g[to][rev].cap += flowed;
                                    return flowed;
                                }
                            }
                            iter[v] += 1;
                        }
                        0
                    }
                    fn bfs(&self, s: usize) -> Vec<i32> {
                        let v = self.g.len();
                        let mut level = vec![-1; v];
                        level[s] = 0;
                        let mut deque = std::collections::VecDeque::new();
                        deque.push_back(s);
                        while let Some(v) = deque.pop_front() {
                            for e in self.g[v].iter() {
                                if e.cap > 0 && level[e.to] < 0 {
                                    level[e.to] = level[v] + 1;
                                    deque.push_back(e.to);
                                }
                            }
                        }
                        level
                    }
                    pub fn max_flow(&mut self, s: usize, t: usize) -> i64 {
                        let v = self.g.len();
                        let mut flow: i64 = 0;
                        loop {
                            let level = self.bfs(s);
                            if level[t] < 0 {
                                return flow;
                            }
                            let mut iter = vec![0; v];
                            loop {
                                let f = self.dfs(s, t, std::i64::MAX, &level, &mut iter);
                                if f == 0 {
                                    break;
                                }
                                flow += f;
                            }
                        }
                    }
                }
            }
            #[cfg(test)]
            mod tests {
                use super::*;
                use crate::utils::test_helper::Tester;
                #[doc = " Solve http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_6_A"]
                #[test]
                fn solve_grl_6_a() {
                    let tester = Tester::new("./assets/GRL_6_A/in/", "./assets/GRL_6_A/out/");
                    tester.test_solution(|sc| {
                        let v = sc.read();
                        let e = sc.read();
                        let mut dinitz = dinitz::Dinitz::new(v);
                        for _ in 0..e {
                            let from = sc.read();
                            let to = sc.read();
                            let c = sc.read();
                            dinitz.add_edge(from, to, c);
                        }
                        let flow = dinitz.max_flow(0, v - 1);
                        sc.write(format!("{}\n", flow));
                    });
                }
            }
        }
        pub mod min_cost_flow {
            pub mod primal_dual {
                use std::cmp;
                use std::collections::BinaryHeap;
                use std::i64;
                type Flow = i64;
                type Cost = i64;
                const INF: Cost = i64::MAX >> 3;
                struct Edge {
                    to: usize,
                    capacity: Flow,
                    flow: Flow,
                    cost: Cost,
                    reverse_to: usize,
                    is_reversed: bool,
                }
                impl Edge {
                    fn residue(&self) -> Flow {
                        self.capacity - self.flow
                    }
                }
                pub struct MinimumCostFlowSolver {
                    graph: Vec<Vec<Edge>>,
                    previous_edge: Vec<(usize, usize)>,
                }
                impl MinimumCostFlowSolver {
                    pub fn new(n: usize) -> Self {
                        MinimumCostFlowSolver {
                            graph: (0..n).map(|_| Vec::new()).collect(),
                            previous_edge: vec![(0, 0); n],
                        }
                    }
                    pub fn add_edge(&mut self, from: usize, to: usize, capacity: Flow, cost: Cost) {
                        let reverse_from = self.graph[to].len();
                        let reverse_to = self.graph[from].len();
                        self.graph[from].push(Edge {
                            to,
                            capacity,
                            flow: 0,
                            cost,
                            reverse_to: reverse_from,
                            is_reversed: false,
                        });
                        self.graph[to].push(Edge {
                            to: from,
                            capacity,
                            flow: capacity,
                            cost: -cost,
                            reverse_to,
                            is_reversed: true,
                        });
                    }
                    pub fn solve(
                        &mut self,
                        source: usize,
                        sink: usize,
                        mut flow: Flow,
                    ) -> Option<Flow> {
                        let n = self.graph.len();
                        let mut result = 0;
                        let mut h = vec![0; n];
                        let mut q: BinaryHeap<(Cost, usize)> = BinaryHeap::new();
                        while flow > 0 {
                            let mut dist = vec![INF; n];
                            dist[source] = 0;
                            q.push((0, source));
                            while let Some((current_dist, v)) = q.pop() {
                                if dist[v] < current_dist {
                                    continue;
                                }
                                for (i, e) in self.graph[v].iter().enumerate() {
                                    if e.residue() == 0 {
                                        continue;
                                    }
                                    if dist[e.to] + h[e.to] > current_dist + h[v] + e.cost {
                                        dist[e.to] = current_dist + h[v] + e.cost - h[e.to];
                                        self.previous_edge[e.to] = (v, i);
                                        q.push((dist[e.to], e.to));
                                    }
                                }
                            }
                            if dist[sink] == INF {
                                return None;
                            }
                            for i in 0..n {
                                h[i] += dist[i];
                            }
                            let mut df = flow;
                            let mut v = sink;
                            while v != source {
                                let (prev_v, prev_e) = self.previous_edge[v];
                                df = cmp::min(df, self.graph[prev_v][prev_e].residue());
                                v = prev_v;
                            }
                            flow -= df;
                            result += df * h[sink];
                            let mut v = sink;
                            while v != source {
                                let (prev_v, prev_e) = self.previous_edge[v];
                                self.graph[prev_v][prev_e].flow += df;
                                let reversed_edge_id = self.graph[prev_v][prev_e].reverse_to;
                                self.graph[v][reversed_edge_id].flow -= df;
                                v = prev_v;
                            }
                        }
                        Some(result)
                    }
                    pub fn neg_solve(
                        &mut self,
                        source: usize,
                        sink: usize,
                        mut flow: Flow,
                    ) -> Option<Flow> {
                        let n = self.graph.len();
                        let mut result = 0;
                        while flow > 0 {
                            let mut dist = vec![INF; n];
                            dist[source] = 0;
                            loop {
                                let mut updated = false;
                                for v in 0..n {
                                    if dist[v] == INF {
                                        continue;
                                    }
                                    for (i, e) in self.graph[v].iter().enumerate() {
                                        if e.residue() == 0 {
                                            continue;
                                        }
                                        if dist[e.to] > dist[v] + e.cost {
                                            dist[e.to] = dist[v] + e.cost;
                                            self.previous_edge[e.to] = (v, i);
                                            updated = true;
                                        }
                                    }
                                }
                                if !updated {
                                    break;
                                }
                            }
                            if dist[sink] == INF {
                                return None;
                            }
                            let mut df = flow;
                            let mut v = sink;
                            while v != source {
                                let (prev_v, prev_e) = self.previous_edge[v];
                                df = cmp::min(df, self.graph[prev_v][prev_e].residue());
                                v = prev_v;
                            }
                            flow -= df;
                            result += df * dist[sink];
                            let mut v = sink;
                            while v != source {
                                let (prev_v, prev_e) = self.previous_edge[v];
                                self.graph[prev_v][prev_e].flow += df;
                                let reversed_edge_id = self.graph[prev_v][prev_e].reverse_to;
                                self.graph[v][reversed_edge_id].flow -= df;
                                v = prev_v;
                            }
                        }
                        Some(result)
                    }
                }
            }
            #[cfg(test)]
            mod tests {
                use super::*;
                use crate::utils::test_helper::Tester;
                #[test]
                fn solve_grl_6_b() {
                    let tester = Tester::new("./assets/GRL_6_B/in/", "./assets/GRL_6_B/out/");
                    tester.test_solution(|sc| {
                        let v: usize = sc.read();
                        let e: usize = sc.read();
                        let f: i64 = sc.read();
                        let mut solver = primal_dual::MinimumCostFlowSolver::new(v);
                        for _ in 0..e {
                            let u: usize = sc.read();
                            let v: usize = sc.read();
                            let c: i64 = sc.read();
                            let d: i64 = sc.read();
                            solver.add_edge(u, v, c, d);
                        }
                        let ans = match solver.solve(0, v - 1, f) {
                            Some(flow) => flow,
                            None => -1,
                        };
                        sc.write(format!("{}\n", ans));
                    });
                }
                #[test]
                fn solve_grl_6_b_negative() {
                    let tester = Tester::new("./assets/GRL_6_B/in/", "./assets/GRL_6_B/out/");
                    tester.test_solution(|sc| {
                        let v: usize = sc.read();
                        let e: usize = sc.read();
                        let f: i64 = sc.read();
                        let mut solver = primal_dual::MinimumCostFlowSolver::new(v);
                        for _ in 0..e {
                            let u: usize = sc.read();
                            let v: usize = sc.read();
                            let c: i64 = sc.read();
                            let d: i64 = sc.read();
                            solver.add_edge(u, v, c, d);
                        }
                        let ans = match solver.neg_solve(0, v - 1, f) {
                            Some(flow) => flow,
                            None => -1,
                        };
                        sc.write(format!("{}\n", ans));
                    });
                }
            }
        }
        pub mod shortest_path {
            pub mod bellman_ford {
                pub fn shortest_path(
                    graph: &[Vec<(usize, i64)>],
                    start: usize,
                    inf: i64,
                ) -> (Vec<i64>, Vec<bool>) {
                    let n = graph.len();
                    let mut dist = vec![inf; n];
                    dist[start] = 0;
                    for _ in 0..n {
                        for v in 0..n {
                            for &(to, cost) in &graph[v] {
                                if dist[v] == inf || dist[to] <= dist[v] + cost {
                                    continue;
                                }
                                dist[to] = dist[v] + cost;
                            }
                        }
                    }
                    let mut negative = vec![false; n];
                    for _ in 0..n {
                        for v in 0..n {
                            for &(to, cost) in &graph[v] {
                                if dist[v] == inf {
                                    continue;
                                }
                                if dist[to] > dist[v] + cost {
                                    dist[to] = dist[v] + cost;
                                    negative[to] = true;
                                }
                                if negative[v] {
                                    negative[to] = true;
                                }
                            }
                        }
                    }
                    (dist, negative)
                }
            }
            #[cfg(test)]
            mod tests {
                use super::*;
                use crate::utils::test_helper::Tester;
                use std;
                #[test]
                fn solve_grl_1_b() {
                    let tester = Tester::new("./assets/GRL_1_B/in/", "./assets/GRL_1_B/out/");
                    tester.test_solution(|sc| {
                        let v: usize = sc.read();
                        let e: usize = sc.read();
                        let r: usize = sc.read();
                        let mut graph = vec![vec![]; v];
                        for _ in 0..e {
                            let s: usize = sc.read();
                            let t: usize = sc.read();
                            let d: i64 = sc.read();
                            graph[s].push((t, d));
                        }
                        let inf = std::i64::MAX;
                        let (dist, negative) = bellman_ford::shortest_path(&graph, r, inf);
                        let mut neg = false;
                        for &b in &negative {
                            neg = neg || b;
                        }
                        if neg {
                            sc.write("NEGATIVE CYCLE\n");
                        } else {
                            for i in 0..v {
                                if dist[i] == inf {
                                    sc.write("INF\n");
                                } else {
                                    sc.write(format!("{}\n", dist[i]));
                                }
                            }
                        }
                    });
                }
            }
        }
        pub mod strongly_connected_components {
            pub mod strongly_connected_components {
                use std::collections::VecDeque;
                pub fn decompose(graph: &[Vec<usize>]) -> Vec<usize> {
                    let mut vs = Vec::new();
                    let num_v = graph.len();
                    let mut cmp = vec![0; num_v];
                    let mut reverse_graph = vec![vec![]; num_v];
                    for (i, edges) in graph.iter().enumerate() {
                        for &v in edges.iter() {
                            reverse_graph[v].push(i);
                        }
                    }
                    let mut used = vec![false; num_v];
                    let mut stack = VecDeque::new();
                    let mut added = vec![false; num_v];
                    for i in 0..num_v {
                        if used[i] {
                            continue;
                        }
                        stack.push_front(i);
                        while let Some(v) = stack.pop_front() {
                            stack.push_front(v);
                            used[v] = true;
                            let mut pushed = false;
                            for &u in graph[v].iter().rev() {
                                if !used[u] {
                                    stack.push_front(u);
                                    pushed = true;
                                }
                            }
                            if !pushed {
                                stack.pop_front();
                                if !added[v] {
                                    vs.push(v);
                                    added[v] = true;
                                }
                            }
                        }
                    }
                    used = vec![false; num_v];
                    let mut k = 0;
                    vs.reverse();
                    for &i in vs.iter() {
                        if used[i] {
                            continue;
                        }
                        stack.push_front(i);
                        used[i] = true;
                        cmp[i] = k;
                        while let Some(v) = stack.pop_front() {
                            stack.push_front(v);
                            let mut pushed = false;
                            for &u in reverse_graph[v].iter() {
                                if used[u] {
                                    continue;
                                }
                                used[u] = true;
                                cmp[u] = k;
                                stack.push_front(u);
                                pushed = true;
                            }
                            if !pushed {
                                stack.pop_front();
                            }
                        }
                        k += 1;
                    }
                    cmp
                }
            }
            #[cfg(test)]
            mod tests {
                use super::*;
                use crate::utils::test_helper::Tester;
                #[test]
                fn solve_grl_3_c() {
                    let tester = Tester::new("./assets/GRL_3_C/in/", "./assets/GRL_3_C/out/");
                    tester.test_solution(|sc| {
                        let v: usize = sc.read();
                        let e: usize = sc.read();
                        let mut graph = vec![vec![]; v];
                        for _ in 0..e {
                            let s: usize = sc.read();
                            let t: usize = sc.read();
                            graph[s].push(t);
                        }
                        let cmp = strongly_connected_components::decompose(&graph);
                        let q: usize = sc.read();
                        for _ in 0..q {
                            let u: usize = sc.read();
                            let v: usize = sc.read();
                            if cmp[u] == cmp[v] {
                                sc.write("1\n");
                            } else {
                                sc.write("0\n");
                            }
                        }
                    });
                }
            }
        }
    }
    #[doc = " Structures that can efficiently operate data."]
    pub mod data_structure {
        pub mod bitset {
            pub mod bitset {
                const ONE_VALUE_LENGTH: usize = 63;
                const MAXIMUM: u64 = (1u64 << ONE_VALUE_LENGTH as u64) - 1;
                pub fn get_bit_position(index: usize) -> (usize, usize) {
                    let data_index = index / ONE_VALUE_LENGTH;
                    let bit_index = index % ONE_VALUE_LENGTH;
                    (data_index, bit_index)
                }
                #[derive(PartialEq, Clone, Debug)]
                pub struct BitSet {
                    data: Vec<u64>,
                }
                impl std::ops::BitOrAssign for BitSet {
                    fn bitor_assign(&mut self, rhs: Self) {
                        if self.data.len() < rhs.data.len() {
                            self.data.resize(rhs.data.len(), 0);
                        }
                        let n = if self.data.len() > rhs.data.len() {
                            rhs.data.len()
                        } else {
                            self.data.len()
                        };
                        for i in 0..n {
                            assert!(self.data[i] <= MAXIMUM);
                            assert!(rhs.data[i] <= MAXIMUM);
                            self.data[i] |= rhs.data[i];
                        }
                    }
                }
                impl std::ops::Shl<usize> for BitSet {
                    type Output = Self;
                    fn shl(self, rhs: usize) -> Self {
                        self.shift_left(rhs)
                    }
                }
                impl BitSet {
                    pub fn new(n: usize) -> Self {
                        let size = (n + ONE_VALUE_LENGTH - 1) / ONE_VALUE_LENGTH;
                        BitSet {
                            data: vec![0; size],
                        }
                    }
                    pub fn new_from(value: u64) -> Self {
                        BitSet { data: vec![value] }
                    }
                    pub fn set(&mut self, index: usize, value: bool) {
                        let (data_index, bit_index) = get_bit_position(index);
                        assert!(self.data.len() > data_index);
                        if value {
                            self.data[data_index] |= (1 << bit_index) as u64;
                        } else {
                            let tmp = MAXIMUM ^ (1 << bit_index) as u64;
                            self.data[data_index] &= tmp;
                        }
                    }
                    pub fn get(&mut self, index: usize) -> bool {
                        let (data_index, bit_index) = get_bit_position(index);
                        assert!(self.data.len() > data_index);
                        self.data[data_index] & (1u64 << bit_index as u64) != 0
                    }
                    pub fn shift_left(&self, shift: usize) -> Self {
                        let mut next_data = Vec::new();
                        let prefix_empty_count = shift / ONE_VALUE_LENGTH;
                        let shift_count = (shift % ONE_VALUE_LENGTH) as u64;
                        for _ in 0..prefix_empty_count {
                            next_data.push(0);
                        }
                        let mut from_previous = 0;
                        let room = ONE_VALUE_LENGTH as u64 - shift_count;
                        for &data in self.data.iter() {
                            let overflow = (data >> room) << room;
                            let rest = data - overflow;
                            let value = (rest << shift_count) + from_previous;
                            assert!(value <= MAXIMUM);
                            next_data.push(value);
                            from_previous = overflow >> room;
                        }
                        if from_previous > 0 {
                            next_data.push(from_previous);
                        }
                        BitSet { data: next_data }
                    }
                }
            }
            #[cfg(test)]
            mod test {
                use super::bitset::*;
                #[test]
                fn test_set_bit() {
                    let n = 10;
                    let value = 717;
                    let mut bitset = BitSet::new(n);
                    for i in 0..n {
                        if value & (1 << i) != 0 {
                            bitset.set(i, true);
                        }
                    }
                    for i in 0..n {
                        if value & (1 << i) != 0 {
                            assert!(bitset.get(i));
                        } else {
                            assert!(!bitset.get(i));
                        }
                    }
                }
                #[test]
                fn test_bitset_or() {
                    let mut value1 = 717;
                    let mut bitset1 = BitSet::new_from(value1);
                    let value2 = 127;
                    let bitset2 = BitSet::new_from(value2);
                    value1 |= value2;
                    bitset1 |= bitset2;
                    for i in 0..50usize {
                        if value1 & (1u64 << i as u64) != 0 {
                            assert!(bitset1.get(i));
                        } else {
                            assert!(!bitset1.get(i));
                        }
                    }
                }
                #[test]
                fn test_bitset_shift_left() {
                    let value1 = 717;
                    let first_shift = 30;
                    let second_shift = 40;
                    let bitset1 = BitSet::new_from(value1) << (first_shift + second_shift);
                    let bitset2 = BitSet::new_from(value1 << first_shift as u64) << second_shift;
                    assert!(bitset1 == bitset2);
                }
            }
        }
        pub mod fenwick_tree {
            pub mod fenwick_tree {
                #[doc = " `FenwickTree` is a data structure that can efficiently update elements"]
                #[doc = " and calculate prefix sums in a table of numbers."]
                #[doc = " [https://en.wikipedia.org/wiki/Fenwick_tree](https://en.wikipedia.org/wiki/Fenwick_tree)"]
                pub struct FenwickTree<T> {
                    n: usize,
                    data: Vec<T>,
                    init: T,
                }
                impl<T: Copy + std::ops::AddAssign + std::ops::Sub<Output = T>> FenwickTree<T> {
                    #[doc = " Constructs a new `FenwickTree`. The size of `FenwickTree` should be specified by `size`."]
                    pub fn new(size: usize, init: T) -> FenwickTree<T> {
                        FenwickTree {
                            n: size + 1,
                            data: vec![init; size + 1],
                            init,
                        }
                    }
                    pub fn add(&mut self, k: usize, value: T) {
                        let mut x = k;
                        while x < self.n {
                            self.data[x] += value;
                            x |= x + 1;
                        }
                    }
                    #[doc = " Returns a sum of range `[l, r)`"]
                    pub fn sum(&self, l: usize, r: usize) -> T {
                        self.sum_one(r) - self.sum_one(l)
                    }
                    #[doc = " Returns a sum of range `[0, k)`"]
                    pub fn sum_one(&self, k: usize) -> T {
                        assert!(k < self.n, "k={} n={}", k, self.n);
                        let mut result = self.init;
                        let mut x = k as i32 - 1;
                        while x >= 0 {
                            result += self.data[x as usize];
                            x = (x & (x + 1)) - 1;
                        }
                        result
                    }
                }
            }
            #[cfg(test)]
            mod test {
                use super::fenwick_tree::FenwickTree;
                use rand::{thread_rng, Rng};
                #[test]
                fn random_array() {
                    let n = 1000;
                    let mut bit = FenwickTree::new(n, 0);
                    let mut v = vec![0; n];
                    for _ in 0..10000 {
                        let value = thread_rng().gen_range(0, 1000);
                        let k = thread_rng().gen_range(0, n);
                        v[k] += value;
                        bit.add(k, value);
                        let mut sum = 0;
                        for i in 0..n {
                            sum += v[i];
                            assert_eq!(sum, bit.sum(0, i + 1));
                        }
                    }
                }
            }
        }
        pub mod fibonacci_heap {
            pub mod fibonacci_heap {
                fn store_to_map<T, F>(
                    map: &mut std::collections::HashMap<usize, Node<T>>,
                    mut node: Node<T>,
                    ordering: F,
                ) where
                    T: Copy + PartialEq,
                    F: Fn(T, T) -> T,
                {
                    let d = node.children.len();
                    match map.remove(&d) {
                        Some(mut other) => {
                            let node = if (ordering)(node.key, other.key) == node.key {
                                node.children.push(other);
                                node
                            } else {
                                other.children.push(node);
                                other
                            };
                            store_to_map(map, node, ordering);
                        }
                        None => {
                            map.insert(d, node);
                        }
                    }
                }
                pub struct FibonacciHeap<T, F> {
                    pub nodes: Vec<Node<T>>,
                    min_index: usize,
                    ordering: F,
                }
                impl<T, F> FibonacciHeap<T, F>
                where
                    T: Copy + PartialEq,
                    F: Fn(T, T) -> T + Copy,
                {
                    pub fn new(ordering: F) -> Self {
                        Self {
                            nodes: Vec::new(),
                            min_index: 0,
                            ordering,
                        }
                    }
                    pub fn push(&mut self, x: T) {
                        let node = Node::new(x);
                        self.nodes.push(node);
                        let cur_min = self.nodes[self.min_index].key;
                        if (self.ordering)(cur_min, x) == x {
                            self.min_index = self.nodes.len() - 1;
                        }
                    }
                    pub fn pop(&mut self) -> Option<T> {
                        let mut map = std::collections::HashMap::<usize, Node<T>>::new();
                        let mut popped = None;
                        let mut nodes = Vec::new();
                        std::mem::swap(&mut self.nodes, &mut nodes);
                        for (i, node) in nodes.into_iter().enumerate() {
                            if i == self.min_index {
                                popped = Some(node.key);
                                for node in node.children.into_iter() {
                                    store_to_map(&mut map, node, self.ordering);
                                }
                            } else {
                                store_to_map(&mut map, node, self.ordering);
                            }
                        }
                        self.nodes = map.into_iter().map(|(_, node)| node).collect();
                        if !self.nodes.is_empty() {
                            let mut min = self.nodes[0].key;
                            for i in 0..self.nodes.len() {
                                if (self.ordering)(min, self.nodes[i].key) == self.nodes[i].key {
                                    min = self.nodes[i].key;
                                }
                            }
                            self.min_index = self
                                .nodes
                                .iter()
                                .enumerate()
                                .find(|(_, node)| node.key == min)
                                .unwrap()
                                .0;
                        } else {
                            self.min_index = 0;
                        }
                        popped
                    }
                }
                #[derive(Debug)]
                pub struct Node<T> {
                    pub key: T,
                    pub children: Vec<Node<T>>,
                }
                impl<T> Node<T> {
                    fn new(x: T) -> Self {
                        Self {
                            key: x,
                            children: Vec::new(),
                        }
                    }
                }
            }
            #[cfg(test)]
            mod tests {
                use super::fibonacci_heap::*;
                use rand::Rng;
                use std::cmp;
                use std::collections::BinaryHeap;
                #[test]
                fn test_fibonacci_heap() {
                    let mut min_heap = FibonacciHeap::new(cmp::min);
                    min_heap.push(1);
                    assert_eq!(min_heap.pop(), Some(1));
                    min_heap.push(1);
                    min_heap.push(2);
                    min_heap.push(3);
                    assert_eq!(min_heap.pop(), Some(1));
                    assert_eq!(min_heap.pop(), Some(2));
                    assert_eq!(min_heap.pop(), Some(3));
                    min_heap.push(3);
                    min_heap.push(2);
                    min_heap.push(1);
                    assert_eq!(min_heap.pop(), Some(1));
                    assert_eq!(min_heap.pop(), Some(2));
                    assert_eq!(min_heap.pop(), Some(3));
                }
                #[test]
                fn compare_to_binary_heap() {
                    let mut rng = rand::thread_rng();
                    let mut max_heap = FibonacciHeap::new(cmp::max);
                    let mut binary_heap = BinaryHeap::new();
                    for _ in 0..2000 {
                        let x = rng.gen::<usize>() % 10;
                        if x == 0 {
                            assert_eq!(max_heap.pop(), binary_heap.pop());
                        } else {
                            let v = rng.gen::<u8>();
                            max_heap.push(v);
                            binary_heap.push(v);
                        }
                    }
                }
            }
        }
        pub mod persistent_array {
            pub mod persistent_array {
                use std::rc::Rc;
                const N: usize = 20;
                #[derive(Clone)]
                pub struct Node<T: Clone> {
                    data: Option<T>,
                    children: [Option<Rc<Node<T>>>; N],
                }
                impl<T: Clone> Node<T> {
                    pub fn new(data: Option<T>, children: [Option<Rc<Node<T>>>; N]) -> Self {
                        Self { data, children }
                    }
                }
                impl<T: Clone> Default for Node<T> {
                    fn default() -> Self {
                        Self {
                            data: None,
                            children: Default::default(),
                        }
                    }
                }
                pub fn set<T: Clone>(
                    index: usize,
                    data: T,
                    node: Option<Rc<Node<T>>>,
                ) -> Rc<Node<T>> {
                    if index == 0 {
                        match node {
                            Some(node) => {
                                let new_node = Node::new(Some(data), node.children.clone());
                                Rc::new(new_node)
                            }
                            None => Rc::new(Node::new(Some(data), Default::default())),
                        }
                    } else {
                        let child = match node
                            .as_ref()
                            .and_then(|node| node.children[index % N].as_ref())
                        {
                            Some(next_node) => set(index / N, data, Some(next_node.clone())),
                            None => set(index / N, data, None),
                        };
                        let mut new_node = match node {
                            Some(node) => node.as_ref().clone(),
                            None => Node::default(),
                        };
                        new_node.children[index % N] = Some(child);
                        Rc::new(new_node)
                    }
                }
                pub fn get<T: Clone>(index: usize, node: &Rc<Node<T>>) -> Option<T> {
                    if index == 0 {
                        node.data.clone()
                    } else {
                        match node.children[index % N].as_ref() {
                            Some(next_node) => get(index / N, next_node),
                            None => None,
                        }
                    }
                }
            }
            #[cfg(test)]
            mod tests {
                use crate::data_structure::persistent_array::persistent_array::{get, set, Node};
                use rand::distributions::Uniform;
                use rand::{thread_rng, Rng};
                use std::rc::Rc;
                #[test]
                fn test_persistent_array() {
                    let mut rng = thread_rng();
                    let n: usize = 20;
                    let mut vs = vec![vec![None; n]];
                    let mut nodes = vec![Rc::new(Node::default())];
                    for _ in 0..10000 {
                        let pick = rng.sample(Uniform::from(0..vs.len()));
                        let mut new_vec = vs[pick].clone();
                        let node = nodes[pick].clone();
                        let pos = rng.sample(Uniform::from(0..n));
                        let value: i64 = rng.gen();
                        new_vec[pos] = Some(value);
                        let new_node = set(pos, value, Some(node));
                        for i in 0..n {
                            let expected = new_vec[i];
                            let actual = get(i, &new_node);
                            assert_eq!(expected, actual);
                        }
                        vs.push(new_vec.clone());
                        nodes.push(new_node.clone());
                        let value: i64 = rng.gen();
                        new_vec[pos] = Some(value);
                        let new_node = set(pos, value, Some(new_node));
                        for i in 0..n {
                            let expected = new_vec[i];
                            let actual = get(i, &new_node);
                            assert_eq!(expected, actual);
                        }
                        vs.push(new_vec.clone());
                        nodes.push(new_node);
                    }
                }
            }
        }
        pub mod range_add_segment_tree {
            pub mod range_add_segment_tree {
                type Range = std::ops::Range<usize>;
                pub struct RangeAddSegmentTree<T, F> {
                    data: Vec<T>,
                    lazy: Vec<T>,
                    size: usize,
                    f: F,
                    init: T,
                }
                impl<T, F> RangeAddSegmentTree<T, F>
                where
                    T: PartialOrd
                        + ::std::ops::Add<Output = T>
                        + ::std::ops::Sub<Output = T>
                        + Copy,
                    F: Fn(T, T) -> T + Copy,
                {
                    pub fn new(n: usize, init: T, f: F, zero: T) -> Self {
                        let size = n.next_power_of_two();
                        RangeAddSegmentTree {
                            data: vec![init; size * 2],
                            lazy: vec![zero; size * 2],
                            size,
                            init,
                            f,
                        }
                    }
                    pub fn add(&mut self, range: Range, value: T) {
                        self.add_to_range(range, value, 0, 0..self.size);
                    }
                    fn add_to_range(
                        &mut self,
                        add_range: Range,
                        value: T,
                        mut k: usize,
                        seg_range: Range,
                    ) {
                        if add_range.end <= seg_range.start || seg_range.end <= add_range.start {
                            return;
                        }
                        if add_range.start <= seg_range.start && seg_range.end <= add_range.end {
                            self.lazy[k] = self.lazy[k] + value;
                            while k > 0 {
                                k = (k - 1) / 2;
                                self.data[k] = (self.f)(
                                    self.data[k * 2 + 1] + self.lazy[k * 2 + 1],
                                    self.data[k * 2 + 2] + self.lazy[k * 2 + 2],
                                );
                            }
                        } else {
                            let mid = (seg_range.start + seg_range.end) / 2;
                            self.add_to_range(
                                add_range.clone(),
                                value,
                                k * 2 + 1,
                                seg_range.start..mid,
                            );
                            self.add_to_range(add_range, value, k * 2 + 2, mid..seg_range.end);
                        }
                    }
                    pub fn update(&mut self, pos: usize, value: T) {
                        let cur = self.get(pos..(pos + 1));
                        let mut k = pos + self.size - 1;
                        let raw = self.data[k];
                        self.data[k] = raw + value - cur;
                        while k > 0 {
                            k = (k - 1) / 2;
                            self.data[k] = (self.f)(self.data[k * 2 + 1], self.data[k * 2 + 2]);
                        }
                    }
                    pub fn get(&self, range: Range) -> T {
                        self.get_from_range(range, 0, 0..self.size)
                    }
                    fn get_from_range(&self, get_range: Range, k: usize, seg_range: Range) -> T {
                        if get_range.end <= seg_range.start || seg_range.end <= get_range.start {
                            self.init
                        } else if get_range.start <= seg_range.start
                            && seg_range.end <= get_range.end
                        {
                            self.data[k] + self.lazy[k]
                        } else {
                            let mid = (seg_range.start + seg_range.end) / 2;
                            let x = self.get_from_range(
                                get_range.clone(),
                                k * 2 + 1,
                                seg_range.start..mid,
                            );
                            let y = self.get_from_range(get_range, k * 2 + 2, mid..seg_range.end);
                            (self.f)(x, y) + self.lazy[k]
                        }
                    }
                }
            }
            #[cfg(test)]
            mod test {
                use super::*;
                use rand::Rng;
                use std::cmp;
                const INF: i64 = 1 << 60;
                #[test]
                fn edge_case() {
                    let n = 5;
                    let mut seg_min = range_add_segment_tree::RangeAddSegmentTree::new(
                        n,
                        INF as usize,
                        |a, b| if a > b { b } else { a },
                        0,
                    );
                    let mut values = vec![0; n];
                    for i in 0..n {
                        values[i] = i;
                        seg_min.update(i, i);
                    }
                    let from = 1;
                    let to = 4;
                    let add = 2;
                    for i in from..to {
                        values[i] += add;
                    }
                    seg_min.add(from..to, add);
                    let pos = 2;
                    let value = 1;
                    let cur = seg_min.get(pos..(pos + 1));
                    seg_min.update(pos, cur - value);
                    values[pos] -= value;
                    for l in 0..n {
                        for r in (l + 1)..(n + 1) {
                            let min1 = seg_min.get(l..r);
                            let &min2 = values[l..r].iter().min().unwrap();
                            assert_eq!(min1, min2);
                        }
                    }
                }
                #[test]
                fn random_add() {
                    let n = 32;
                    let mut array = vec![0; n];
                    let mut seg_min = range_add_segment_tree::RangeAddSegmentTree::new(
                        n,
                        INF,
                        |a, b| if a > b { b } else { a },
                        0,
                    );
                    let mut seg_max = range_add_segment_tree::RangeAddSegmentTree::new(
                        n,
                        -INF,
                        |a, b| if a < b { b } else { a },
                        0,
                    );
                    for i in 0..n {
                        let value = rand::thread_rng().gen::<i16>() as i64;
                        array[i] = value;
                        seg_min.update(i, value);
                        seg_max.update(i, value);
                    }
                    for l in 0..n {
                        for r in (l + 1)..n {
                            let value = rand::thread_rng().gen::<i16>() as i64;
                            seg_min.add(l..r, value);
                            seg_max.add(l..r, value);
                            for i in l..r {
                                array[i] += value;
                            }
                            for l in 0..n {
                                for r in (l + 1)..n {
                                    let mut min = INF;
                                    let mut max = -INF;
                                    for i in l..r {
                                        min = cmp::min(min, array[i]);
                                        max = cmp::max(max, array[i]);
                                    }
                                    assert_eq!(seg_min.get(l..r), min);
                                    assert_eq!(seg_max.get(l..r), max);
                                }
                            }
                        }
                    }
                }
            }
        }
        pub mod segment_tree {
            #[doc = " Segment Tree for range queries"]
            pub struct SegmentTree<T, F> {
                seg: Vec<T>,
                n: usize,
                f: F,
                initial_value: T,
            }
            impl<T: Copy, F> SegmentTree<T, F>
            where
                F: Fn(T, T) -> T,
            {
                pub fn new(size: usize, initial_value: T, f: F) -> SegmentTree<T, F> {
                    let mut m = 1;
                    while m <= size {
                        m <<= 1;
                    }
                    SegmentTree {
                        seg: vec![initial_value; m * 2],
                        n: m,
                        f,
                        initial_value,
                    }
                }
                pub fn update(&mut self, k: usize, value: T) {
                    let mut k = k;
                    k += self.n - 1;
                    self.seg[k] = value;
                    while k > 0 {
                        k = (k - 1) >> 1;
                        self.seg[k] = (self.f)(self.seg[k * 2 + 1], self.seg[k * 2 + 2]);
                    }
                }
                #[doc = " Get the minimum value in the array in the range"]
                pub fn query(&self, range: std::ops::Range<usize>) -> T {
                    self.query_range(range, 0, 0..self.n)
                }
                fn query_range(
                    &self,
                    range: std::ops::Range<usize>,
                    k: usize,
                    seg_range: std::ops::Range<usize>,
                ) -> T {
                    if seg_range.end <= range.start || range.end <= seg_range.start {
                        self.initial_value
                    } else if range.start <= seg_range.start && seg_range.end <= range.end {
                        self.seg[k]
                    } else {
                        let mid = (seg_range.start + seg_range.end) >> 1;
                        let x = self.query_range(range.clone(), k * 2 + 1, seg_range.start..mid);
                        let y = self.query_range(range, k * 2 + 2, mid..seg_range.end);
                        (self.f)(x, y)
                    }
                }
            }
            #[cfg(test)]
            mod test {
                use super::*;
                use rand::Rng;
                use std::cmp;
                use std::i64::MAX;
                #[test]
                fn random_array() {
                    let n = 1000;
                    let arr = (0..n)
                        .map(|_| {
                            return rand::thread_rng().gen::<i64>();
                        })
                        .collect::<Vec<_>>();
                    let mut seg = SegmentTree::new(n, MAX, |a, b| cmp::min(a, b));
                    for i in 0..n {
                        let mut minimum = MAX;
                        for j in 0..(i + 1) {
                            minimum = cmp::min(minimum, arr[j]);
                        }
                        seg.update(i, arr[i]);
                        assert_eq!(seg.query(0..n), minimum);
                        assert_eq!(seg.query(0..(i + 1)), minimum);
                    }
                }
                #[test]
                fn random_array_online_update() {
                    let n = 1000;
                    let mut arr = vec![MAX; n];
                    let mut seg = SegmentTree::new(n, MAX, |a, b| cmp::min(a, b));
                    for _ in 0..n {
                        let value = rand::thread_rng().gen::<i64>();
                        let k = rand::thread_rng().gen_range(0, n);
                        seg.update(k, value);
                        arr[k] = value;
                        let mut minimum = MAX;
                        for i in 0..n {
                            minimum = cmp::min(minimum, arr[i]);
                        }
                        assert_eq!(seg.query(0..n), minimum);
                    }
                }
            }
        }
        pub mod sparse_table {
            pub mod sparse_table {
                pub struct SparseTable<T, F> {
                    data: Vec<Vec<T>>,
                    op: F,
                }
                impl<T, F> SparseTable<T, F>
                where
                    T: Copy,
                    F: Fn(T, T) -> T,
                {
                    pub fn from(v: &[T], init: T, op: F) -> Self {
                        let size = v.len().next_power_of_two();
                        let count = size.trailing_zeros() as usize + 1;
                        let mut data = vec![vec![init; size]; count];
                        for (i, v) in v.iter().cloned().enumerate() {
                            data[0][i] = v;
                        }
                        for c in 1..count {
                            for i in 0..size {
                                let next = std::cmp::min(size - 1, i + (1 << (c - 1)));
                                data[c][i] = op(data[c - 1][i], data[c - 1][next]);
                            }
                        }
                        Self { data, op }
                    }
                    #[doc = " get the result for [l, r)"]
                    pub fn get(&self, l: usize, r: usize) -> T {
                        assert!(l < r);
                        let length = r - l;
                        if length == 1 {
                            return self.data[0][l];
                        }
                        let block_size = length.next_power_of_two() >> 1;
                        let c = block_size.trailing_zeros() as usize;
                        let left = self.data[c][l];
                        let right = self.data[c][r - block_size];
                        (self.op)(left, right)
                    }
                }
            }
            #[cfg(test)]
            mod test {
                use super::*;
                use rand::{thread_rng, Rng};
                use std::cmp;
                #[test]
                fn test_small() {
                    let v = vec![1, 9, 9, 1, 0, 7, 1, 7];
                    let sparse_table =
                        sparse_table::SparseTable::from(&v, 0, |a, b| cmp::min(a, b));
                    for l in 0..8 {
                        for r in (l + 1)..9 {
                            let &min = v[l..r].iter().min().unwrap();
                            assert_eq!(sparse_table.get(l, r), min);
                        }
                    }
                }
                #[test]
                fn test_sparse_table_with_random_array() {
                    let n = 1000;
                    let v: Vec<u64> = (0..n)
                        .map(|_| thread_rng().gen_range(0, 1000000000))
                        .collect();
                    let sparse_table = sparse_table::SparseTable::from(&v, 0, cmp::min);
                    for l in 0..n {
                        for r in (l + 1)..(n + 1) {
                            let &min = v[l..r].iter().min().unwrap();
                            assert_eq!(sparse_table.get(l, r), min);
                        }
                    }
                }
            }
        }
        pub mod suffix_array {
            pub struct SuffixArray {
                n: usize,
                s: Vec<u8>,
                array: Vec<usize>,
            }
            fn compare_node(i: usize, j: usize, k: usize, rank: &[i32]) -> std::cmp::Ordering {
                if rank[i] != rank[j] {
                    rank[i].cmp(&rank[j])
                } else {
                    let ri = if i + k <= rank.len() { rank[i + k] } else { -1 };
                    let rj = if j + k <= rank.len() { rank[j + k] } else { -1 };
                    ri.cmp(&rj)
                }
            }
            impl SuffixArray {
                pub fn new(s: &[u8]) -> SuffixArray {
                    let n = s.len();
                    let mut rank = vec![0; n + 1];
                    let mut array = vec![0; n + 1];
                    for i in 0..(n + 1) {
                        array[i] = i;
                        rank[i] = if i < n { s[i] as i32 } else { -1 };
                    }
                    let mut tmp = vec![0; n + 1];
                    let mut k = 1;
                    while k <= n {
                        array.sort_by(|a, b| compare_node(*a, *b, k, &rank));
                        tmp[array[0]] = 0;
                        for i in 1..(n + 1) {
                            tmp[array[i]] = tmp[array[i - 1]]
                                + if compare_node(array[i - 1], array[i], k, &rank)
                                    == std::cmp::Ordering::Less
                                {
                                    1
                                } else {
                                    0
                                }
                        }
                        rank[..(n + 1)].clone_from_slice(&tmp[..(n + 1)]);
                        k *= 2;
                    }
                    SuffixArray {
                        n,
                        array,
                        s: Vec::from(s),
                    }
                }
                pub fn contains(&self, t: &[u8]) -> bool {
                    let b = self.lower_bound(t);
                    if b >= self.array.len() {
                        false
                    } else {
                        let start = self.array[b];
                        let end = std::cmp::min(t.len() + start, self.s.len());
                        let sub = &self.s[start..end];
                        sub.cmp(t) == std::cmp::Ordering::Equal
                    }
                }
                fn binary_search<F>(&self, string: &[u8], f: F) -> usize
                where
                    F: Fn(&[u8], &[u8]) -> bool,
                {
                    let (mut ng, mut ok) = (-1, self.n as i32 + 1);
                    while ok - ng > 1 {
                        let pos = (ng + ok) / 2;
                        let start = self.array[pos as usize];
                        let end = std::cmp::min(start + string.len(), self.s.len());
                        let substring = &self.s[start..end];
                        if f(substring, string) {
                            ng = pos;
                        } else {
                            ok = pos;
                        }
                    }
                    ok as usize
                }
                pub fn lower_bound(&self, t: &[u8]) -> usize {
                    let check_function =
                        |sub: &[u8], s: &[u8]| sub.cmp(s) == std::cmp::Ordering::Less;
                    self.binary_search(t, check_function)
                }
                pub fn upper_bound(&self, t: &[u8]) -> usize {
                    let check_function =
                        |sub: &[u8], s: &[u8]| sub.cmp(s) != std::cmp::Ordering::Greater;
                    self.binary_search(t, check_function)
                }
            }
            #[cfg(test)]
            mod test {
                use super::*;
                use crate::data_structure::segment_tree::SegmentTree;
                use crate::utils::test_helper::Tester;
                use std;
                use std::cmp;
                #[test]
                fn small_test() {
                    let string = "abcdeabcde".to_owned().bytes().collect::<Vec<_>>();
                    let sa = SuffixArray::new(&string);
                    assert_eq!(
                        sa.lower_bound(&"a".to_owned().bytes().collect::<Vec<_>>()),
                        1
                    );
                    assert_eq!(
                        sa.upper_bound(&"a".to_owned().bytes().collect::<Vec<_>>()),
                        3
                    );
                    assert!(sa.contains(&"abcde".to_owned().bytes().collect::<Vec<_>>()));
                    assert!(!sa.contains(&"abce".to_owned().bytes().collect::<Vec<_>>()));
                }
                #[test]
                fn corner_case() {
                    let string = "cba".to_owned().bytes().collect::<Vec<_>>();
                    let sa = SuffixArray::new(&string);
                    assert_eq!(
                        sa.lower_bound(&"c".to_owned().bytes().collect::<Vec<_>>()),
                        3
                    );
                    assert_eq!(
                        sa.upper_bound(&"c".to_owned().bytes().collect::<Vec<_>>()),
                        4
                    );
                }
                #[test]
                fn jag2014summer_day4_f() {
                    let tester = Tester::new(
                        "./assets/jag2014summer-day4/F/in/",
                        "./assets/jag2014summer-day4/F/out/",
                    );
                    tester.test_solution(|sc| {
                        let s: Vec<u8> = sc.read::<String>().bytes().collect();
                        let n = s.len();
                        let reverse_s = {
                            let mut r = s.clone();
                            r.reverse();
                            r
                        };
                        let sa = SuffixArray::new(&s);
                        let reverse_sa = SuffixArray::new(&reverse_s);
                        let mut rmq = SegmentTree::new(n + 1, std::i64::MAX, |a, b| cmp::min(a, b));
                        let mut reverse_rmq =
                            SegmentTree::new(n + 1, std::i64::MAX, |a, b| cmp::min(a, b));
                        for i in 0..(n + 1) {
                            rmq.update(i, sa.array[i] as i64);
                            reverse_rmq.update(i, reverse_sa.array[i] as i64);
                        }
                        let m: usize = sc.read();
                        for _ in 0..m {
                            let x = sc.read::<String>().bytes().collect::<Vec<_>>();
                            let y = {
                                let mut y: Vec<u8> =
                                    sc.read::<String>().bytes().collect::<Vec<_>>();
                                y.reverse();
                                y
                            };
                            if !sa.contains(&x) {
                                sc.write("0\n");
                                continue;
                            }
                            let low = sa.lower_bound(&x);
                            let up = sa.upper_bound(&x);
                            if !reverse_sa.contains(&y) {
                                sc.write("0\n");
                                continue;
                            }
                            let reverse_low = reverse_sa.lower_bound(&y);
                            let reverse_up = reverse_sa.upper_bound(&y);
                            if low >= up || reverse_low >= reverse_up {
                                sc.write("0\n");
                            }
                            let s = rmq.query(low..up) as usize;
                            let t = n - reverse_rmq.query(reverse_low..reverse_up) as usize;
                            if s + x.len() <= t && s <= t - y.len() {
                                sc.write(format!("{}\n", t - s));
                            } else {
                                sc.write("0\n");
                            }
                        }
                    });
                }
            }
        }
        pub mod treap {
            pub mod treap {
                use std::cmp::Ordering::*;
                type Link<T> = Option<Box<Node<T>>>;
                #[derive(Debug)]
                struct Node<T> {
                    left: Link<T>,
                    right: Link<T>,
                    key: T,
                    priority: u32,
                    count: usize,
                }
                impl<T> Node<T> {
                    fn new(key: T, priority: u32) -> Link<T> {
                        Some(Box::new(Node {
                            left: None,
                            right: None,
                            key,
                            priority,
                            count: 1,
                        }))
                    }
                    fn update(&mut self) {
                        self.count = 1 + count(&self.left) + count(&self.right);
                    }
                }
                #[doc = " `Treap` is a binary search tree data structure that maintain a dynamic set"]
                #[doc = " of ordered keys and allow binary searches among the keys,"]
                #[doc = " [https://en.wikipedia.org/wiki/Treap](https://en.wikipedia.org/wiki/Treap)"]
                #[derive(Debug)]
                pub struct Treap<T> {
                    random_state: XorShift,
                    root: Link<T>,
                }
                impl<T: PartialOrd> Treap<T>
                where
                    T: Clone,
                {
                    pub fn new(seed: u32) -> Self {
                        Treap {
                            random_state: XorShift { state: seed },
                            root: None,
                        }
                    }
                    pub fn clear(&mut self) {
                        self.root = None
                    }
                    pub fn is_empty(&self) -> bool {
                        count(&self.root) == 0
                    }
                    pub fn insert(&mut self, key: T) {
                        if !self.contains(&key) {
                            self.root = insert(self.root.take(), key, &mut self.random_state);
                        }
                    }
                    pub fn contains(&self, key: &T) -> bool {
                        find(&self.root, key).is_some()
                    }
                    pub fn erase(&mut self, key: &T) {
                        self.root = erase(self.root.take(), key);
                    }
                    pub fn nth(&self, n: usize) -> &T {
                        match rank(&self.root, n) {
                            Some(r) => &r.key,
                            None => panic!(),
                        }
                    }
                }
                fn find<T: PartialOrd>(node: &Link<T>, key: &T) -> Option<usize> {
                    match node {
                        None => None,
                        Some(node) => match node.key.partial_cmp(key).unwrap() {
                            Equal => Some(count(&node.left)),
                            Greater => find(&node.left, key),
                            Less => match find(&node.right, key) {
                                None => None,
                                Some(pos) => Some(count(&node.left) + 1 + pos),
                            },
                        },
                    }
                }
                fn count<T>(node: &Link<T>) -> usize {
                    match node {
                        None => 0,
                        Some(node) => node.count,
                    }
                }
                fn rotate_left<T>(node: Link<T>) -> Link<T> {
                    let mut node = node.unwrap();
                    let mut r = node.right.take().unwrap();
                    node.right = r.left.take();
                    node.update();
                    r.left = Some(node);
                    Some(r)
                }
                fn rotate_right<T>(node: Link<T>) -> Link<T> {
                    let mut node = node.unwrap();
                    let mut l = node.left.take().unwrap();
                    node.left = l.right.take();
                    node.update();
                    l.right = Some(node);
                    Some(l)
                }
                fn insert<T: PartialOrd>(node: Link<T>, key: T, rand: &mut XorShift) -> Link<T> {
                    match node {
                        None => Node::new(key, rand.next()),
                        Some(mut node) => {
                            match node.key.partial_cmp(&key).unwrap() {
                                Less => {
                                    node.right = insert(node.right.take(), key, rand);
                                    if priority(&node.right) < node.priority {
                                        node = rotate_left(Some(node)).unwrap();
                                    }
                                }
                                _ => {
                                    node.left = insert(node.left.take(), key, rand);
                                    if priority(&node.left) < node.priority {
                                        node = rotate_right(Some(node)).unwrap();
                                    }
                                }
                            }
                            node.update();
                            Some(node)
                        }
                    }
                }
                fn priority<T>(node: &Link<T>) -> u32 {
                    match *node {
                        None => panic!(),
                        Some(ref node) => node.priority,
                    }
                }
                fn min<T>(node: &Link<T>) -> &Link<T> {
                    match node {
                        Some(x) => match x.left {
                            Some(_) => min(&x.left),
                            None => node,
                        },
                        None => panic!(),
                    }
                }
                fn erase<T: PartialOrd>(node: Link<T>, key: &T) -> Link<T>
                where
                    T: Clone,
                {
                    match node {
                        None => panic!(),
                        Some(mut node) => match node.key.partial_cmp(key).unwrap() {
                            Equal => {
                                if node.left.is_none() {
                                    node.right
                                } else if node.right.is_none() {
                                    node.left
                                } else {
                                    node.key = match min(&node.right) {
                                        Some(m) => m.key.clone(),
                                        None => panic!(),
                                    };
                                    node.right = erase(node.right.take(), &node.key);
                                    node.update();
                                    Some(node)
                                }
                            }
                            Less => {
                                node.right = erase(node.right.take(), key);
                                node.update();
                                Some(node)
                            }
                            Greater => {
                                node.left = erase(node.left.take(), key);
                                node.update();
                                Some(node)
                            }
                        },
                    }
                }
                fn rank<T>(node: &Link<T>, r: usize) -> &Link<T> {
                    match node {
                        Some(c) => {
                            let left = count(&c.left);
                            match left.cmp(&r) {
                                std::cmp::Ordering::Equal => node,
                                std::cmp::Ordering::Less => rank(&c.right, r - left - 1),
                                std::cmp::Ordering::Greater => rank(&c.left, r),
                            }
                        }
                        None => panic!(),
                    }
                }
                #[derive(Debug)]
                struct XorShift {
                    state: u32,
                }
                impl XorShift {
                    fn next(&mut self) -> u32 {
                        self.state = xor_shift(self.state);
                        self.state
                    }
                }
                fn xor_shift(state: u32) -> u32 {
                    let mut x = state;
                    x ^= x << 13;
                    x ^= x >> 17;
                    x ^= x << 5;
                    x
                }
            }
            #[cfg(test)]
            mod test {
                use super::*;
                #[test]
                fn test_treap_insert_erase() {
                    let mut treap = treap::Treap::new(71);
                    let max = 1000000;
                    for i in 0..max {
                        assert!(!treap.contains(&i));
                        treap.insert(i);
                        assert!(treap.contains(&i));
                    }
                    for i in 0..max {
                        assert!(treap.contains(&i));
                        treap.erase(&i);
                        assert!(!treap.contains(&i));
                    }
                }
                #[test]
                fn test_treap_nth() {
                    let mut treap = treap::Treap::new(71);
                    let max = 100000;
                    for i in 0..max {
                        treap.insert(i * 2);
                    }
                    for i in 0..max {
                        assert_eq!(treap.nth(i), &(i * 2));
                    }
                }
            }
        }
        pub mod union_find {
            pub struct UnionFind {
                parent: Vec<usize>,
                sizes: Vec<usize>,
                size: usize,
            }
            impl UnionFind {
                pub fn new(n: usize) -> UnionFind {
                    UnionFind {
                        parent: (0..n).map(|i| i).collect::<Vec<usize>>(),
                        sizes: vec![1; n],
                        size: n,
                    }
                }
                pub fn find(&mut self, x: usize) -> usize {
                    if x == self.parent[x] {
                        x
                    } else {
                        let px = self.parent[x];
                        self.parent[x] = self.find(px);
                        self.parent[x]
                    }
                }
                pub fn unite(&mut self, x: usize, y: usize) -> bool {
                    let parent_x = self.find(x);
                    let parent_y = self.find(y);
                    if parent_x == parent_y {
                        return false;
                    }
                    let (large, small) = if self.sizes[parent_x] < self.sizes[parent_y] {
                        (parent_y, parent_x)
                    } else {
                        (parent_x, parent_y)
                    };
                    self.parent[small] = large;
                    self.sizes[large] += self.sizes[small];
                    self.sizes[small] = 0;
                    self.size -= 1;
                    true
                }
            }
            #[cfg(test)]
            mod test {
                use super::*;
                use crate::utils::test_helper::Tester;
                #[doc = " Solve http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DSL_1_A"]
                #[test]
                fn solve_dsl_1_a() {
                    let tester = Tester::new("./assets/DSL_1_A/in/", "./assets/DSL_1_A/out/");
                    tester.test_solution(|sc| {
                        let n = sc.read();
                        let q = sc.read();
                        let mut uf = UnionFind::new(n);
                        for _ in 0..q {
                            let com: usize = sc.read();
                            let x = sc.read();
                            let y = sc.read();
                            if com == 0 {
                                uf.unite(x, y);
                            } else {
                                let ans = if uf.find(x) == uf.find(y) { 1 } else { 0 };
                                sc.write(format!("{}\n", ans));
                            }
                        }
                    });
                }
            }
        }
    }
    #[doc = " Mathematical algorithms."]
    pub mod math {
        pub mod chinese_remainder_theorem {
            pub fn extended_gcd(a: i64, b: i64, p: &mut i64, q: &mut i64) -> i64 {
                if b == 0 {
                    *p = 1;
                    *q = 0;
                    a
                } else {
                    let d = extended_gcd(b, a % b, q, p);
                    *q -= a / b * *p;
                    d
                }
            }
            pub fn chinese_remainder_theorem(b: &[i64], modulo: &[i64]) -> Option<(i64, i64)> {
                let (mut result, mut m) = (0, 1);
                for i in 0..b.len() {
                    let (mut p, mut q) = (0, 0);
                    let d = extended_gcd(m, modulo[i], &mut p, &mut q);
                    if (b[i] - result) % d != 0 {
                        return None;
                    }
                    let tmp = ((b[i] - result) / d * p) % (modulo[i] / d);
                    result += m * tmp;
                    m *= modulo[i] / d;
                }
                Some(((result % m + m) % m, m))
            }
            #[cfg(test)]
            mod tests {
                use super::*;
                use rand;
                use rand::Rng;
                #[test]
                fn test_crt() {
                    let mut rng = rand::thread_rng();
                    let n = 10;
                    let max_m = 100;
                    for _ in 0..1000 {
                        let ans = rng.gen::<u32>() as i64;
                        let mut b = vec![0; n];
                        let mut m = vec![0; n];
                        for i in 0..n {
                            m[i] = rng.gen::<u8>() as i64;
                            m[i] %= max_m;
                            m[i] += 1;
                            b[i] = ans % m[i];
                        }
                        let (a, _) = chinese_remainder_theorem(&b, &m).unwrap();
                        for i in 0..n {
                            assert_eq!(a % m[i], b[i]);
                        }
                    }
                }
            }
        }
        pub mod combination {
            pub struct Combination {
                fact: Vec<usize>,
                inv_fact: Vec<usize>,
                modulo: usize,
            }
            impl Combination {
                pub fn new(max: usize, modulo: usize) -> Self {
                    let mut inv = vec![0; max + 1];
                    let mut fact = vec![0; max + 1];
                    let mut inv_fact = vec![0; max + 1];
                    inv[1] = 1;
                    for i in 2..(max + 1) {
                        inv[i] = inv[modulo % i] * (modulo - modulo / i) % modulo;
                    }
                    fact[0] = 1;
                    inv_fact[0] = 1;
                    for i in 0..max {
                        fact[i + 1] = fact[i] * (i + 1) % modulo;
                    }
                    for i in 0..max {
                        inv_fact[i + 1] = inv_fact[i] * inv[i + 1] % modulo;
                    }
                    Self {
                        fact,
                        inv_fact,
                        modulo,
                    }
                }
                pub fn get(&self, x: usize, y: usize) -> usize {
                    assert!(x >= y);
                    self.fact[x] * self.inv_fact[y] % self.modulo * self.inv_fact[x - y]
                        % self.modulo
                }
                pub fn h(&self, n: usize, r: usize) -> usize {
                    self.get(n + r - 1, r)
                }
            }
            #[cfg(test)]
            mod test {
                use super::*;
                fn gcd(a: usize, b: usize) -> usize {
                    if b == 0 {
                        a
                    } else {
                        gcd(b, a % b)
                    }
                }
                #[test]
                fn random_combination() {
                    let modulo = 1_000_000_007;
                    for n in 100..200 {
                        let comb = Combination::new(n, modulo);
                        for m in 0..(n + 1) {
                            let mut upper = (0..m).map(|i| n - i).collect::<Vec<_>>();
                            for i in 0..m {
                                let mut divisor = i + 1;
                                for j in 0..(i + 1) {
                                    if divisor == 1 {
                                        break;
                                    }
                                    let g = gcd(divisor, upper[j]);
                                    upper[j] /= g;
                                    divisor /= g;
                                }
                            }
                            let mut check = 1;
                            for u in &upper {
                                check = (check * u) % modulo;
                            }
                            assert_eq!(comb.get(n, m), check);
                        }
                    }
                }
            }
        }
        pub mod cumulative_sum {
            pub struct CumulativeSum<T>(Vec<Vec<T>>);
            impl<T> CumulativeSum<T>
            where
                T: Copy + std::ops::Add<Output = T> + std::ops::Sub<Output = T>,
            {
                pub fn new(a: &[Vec<T>], init: T) -> CumulativeSum<T> {
                    assert!(!a.is_empty());
                    let h = a.len();
                    let w = a[0].len();
                    let mut sum = vec![vec![init; w + 1]; h + 1];
                    for i in 0..h {
                        for j in 0..w {
                            sum[i + 1][j + 1] = a[i][j] + sum[i][j + 1] + sum[i + 1][j] - sum[i][j];
                        }
                    }
                    CumulativeSum(sum)
                }
                pub fn get_sum(
                    &self,
                    h_range: std::ops::Range<usize>,
                    w_range: std::ops::Range<usize>,
                ) -> T {
                    assert!(h_range.end <= self.0.len());
                    assert!(w_range.end <= self.0[0].len());
                    self.0[h_range.end][w_range.end] + self.0[h_range.start][w_range.start]
                        - self.0[h_range.start][w_range.end]
                        - self.0[h_range.end][w_range.start]
                }
            }
            #[cfg(test)]
            mod test {
                use super::*;
                use rand::distributions::Uniform;
                use rand::Rng;
                #[test]
                fn random_array() {
                    let h = 30;
                    let w = 20;
                    let mut rng = rand::thread_rng();
                    for _ in 0..10 {
                        let mut array = vec![vec![0; w]; h];
                        for i in 0..h {
                            for j in 0..w {
                                array[i][j] = rng.sample(Uniform::from(10..10000));
                            }
                        }
                        let sum = CumulativeSum::new(&array, 0);
                        for from_i in 0..h {
                            for to_i in (from_i + 1)..=h {
                                for from_j in 0..w {
                                    for to_j in (from_j + 1)..=w {
                                        let mut check = 0;
                                        for i in from_i..to_i {
                                            for j in from_j..to_j {
                                                check += array[i][j];
                                            }
                                        }
                                        assert_eq!(check, sum.get_sum(from_i..to_i, from_j..to_j));
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        pub mod floor_sum {
            pub fn floor_sum(n: i64, m: i64, mut a: i64, mut b: i64) -> i64 {
                let mut ans = 0;
                if a >= m {
                    ans += (n - 1) * n * (a / m) / 2;
                    a %= m;
                }
                if b >= m {
                    ans += n * (b / m);
                    b %= m;
                }
                let y_max = (a * n + b) / m;
                let x_max = y_max * m - b;
                if y_max == 0 {
                    ans
                } else {
                    ans += (n - (x_max + a - 1) / a) * y_max;
                    ans += floor_sum(y_max, a, m, (a - x_max % a) % a);
                    ans
                }
            }
            #[cfg(test)]
            mod tests {
                use super::*;
                #[test]
                fn test_floor_sum() {
                    assert_eq!(3, floor_sum(4, 10, 6, 3));
                    assert_eq!(13, floor_sum(6, 5, 4, 3));
                    assert_eq!(0, floor_sum(1, 1, 0, 0));
                    assert_eq!(314095480, floor_sum(31415, 92653, 58979, 32384));
                    assert_eq!(
                        499999999500000000,
                        floor_sum(1000000000, 1000000000, 999999999, 999999999)
                    );
                }
            }
        }
        pub mod lagrange_interpolation {
            pub fn lagrange_interpolation<T>(xs: &[T], ys: &[T], one: T, zero: T) -> Vec<T>
            where
                T: Clone
                    + Copy
                    + std::ops::Sub<Output = T>
                    + std::ops::Mul<Output = T>
                    + std::ops::Div<Output = T>
                    + std::ops::AddAssign
                    + std::ops::SubAssign
                    + std::ops::MulAssign,
            {
                let n = xs.len();
                let mut all_c = vec![zero; n + 1];
                all_c[0] = one;
                for &x in xs.iter() {
                    let mut next = vec![zero; n + 1];
                    next[1..(n + 1)].clone_from_slice(&all_c[..n]);
                    for j in 0..n {
                        next[j] -= x * all_c[j];
                    }
                    all_c = next;
                }
                let mut c = vec![zero; n];
                for i in 0..n {
                    let mut qi = one;
                    for j in 0..n {
                        if i == j {
                            continue;
                        }
                        qi *= xs[i] - xs[j];
                    }
                    let ri = ys[i] / qi;
                    let mut tmp_c = all_c.clone();
                    for j in (0..n).rev() {
                        c[j] += ri * tmp_c[j + 1];
                        let next_c = tmp_c[j + 1] * xs[i];
                        tmp_c[j] += next_c;
                    }
                }
                c
            }
            #[cfg(test)]
            mod tests {
                use super::*;
                use crate::math::mod_int::mod_int::ModInt;
                use rand::{thread_rng, Rng};
                const MOD: u64 = 1e9 as u64 + 7;
                #[test]
                fn test_lagrange_interpolation() {
                    let mut rng = thread_rng();
                    let n = 500;
                    for _ in 0..10 {
                        let mut xs = vec![];
                        let mut ys = vec![];
                        for _ in 0..n {
                            xs.push(ModInt::new(rng.gen(), MOD));
                            ys.push(ModInt::new(rng.gen(), MOD));
                        }
                        let c = lagrange_interpolation(
                            &xs,
                            &ys,
                            ModInt::new(1, MOD),
                            ModInt::new(0, MOD),
                        );
                        for i in 0..n {
                            let mut y = ModInt::new(0, MOD);
                            let x = xs[i];
                            for i in 0..n {
                                y += x.pow(i as u64) * c[i];
                            }
                            assert_eq!(y.value(), ys[i].value());
                        }
                    }
                }
            }
        }
        pub mod max_rectangle {
            pub mod max_rectangle {
                use std::cmp;
                use std::collections::VecDeque;
                fn calc(hist: &[usize]) -> usize {
                    let n = hist.len();
                    let mut ans = 0;
                    let mut q: VecDeque<(usize, usize)> = VecDeque::new();
                    for (i, &hist) in hist.iter().enumerate() {
                        let mut reachable_min = i;
                        while let Some((pos, height)) = q.pop_front() {
                            if height <= hist {
                                q.push_front((pos, height));
                                break;
                            }
                            reachable_min = pos;
                            ans = cmp::max(ans, (i - reachable_min) * height);
                        }
                        if q.is_empty() || q.iter().next().unwrap().1 < hist {
                            q.push_front((reachable_min, hist));
                        }
                    }
                    while let Some((pos, height)) = q.pop_front() {
                        ans = cmp::max(ans, (n - pos) * height);
                    }
                    ans
                }
                pub fn maximize(map: &[Vec<bool>]) -> usize {
                    let h = map.len();
                    let w = map[0].len();
                    let mut hist = vec![vec![0; w]; h];
                    for i in 0..h {
                        for j in 0..w {
                            if !map[i][j] {
                                continue;
                            }
                            if i == 0 {
                                hist[i][j] = 1;
                            } else {
                                hist[i][j] = hist[i - 1][j] + 1;
                            }
                        }
                    }
                    let mut ans = 0;
                    for hist in hist.iter() {
                        ans = cmp::max(ans, calc(hist));
                    }
                    ans
                }
            }
            #[cfg(test)]
            mod test {
                use super::*;
                use crate::utils::test_helper::Tester;
                #[test]
                fn solve_dpl_3_b() {
                    let tester = Tester::new("./assets/DPL_3_B/in/", "./assets/DPL_3_B/out/");
                    tester.test_solution(|sc| {
                        let h: usize = sc.read();
                        let w: usize = sc.read();
                        let mut c = vec![vec![false; w]; h];
                        for i in 0..h {
                            for j in 0..w {
                                c[i][j] = sc.read::<usize>() == 0;
                            }
                        }
                        let ans = max_rectangle::maximize(&c);
                        sc.write(format!("{}\n", ans));
                    });
                }
            }
        }
        pub mod mod_int {
            pub mod mod_int {
                use std::ops::{
                    Add, AddAssign, BitAnd, Div, DivAssign, Mul, MulAssign, RemAssign, ShrAssign,
                    Sub, SubAssign,
                };
                pub struct ModInt<T> {
                    v: T,
                    m: T,
                }
                impl<T> ModInt<T>
                where
                    T: Copy,
                {
                    pub fn value(&self) -> T {
                        self.v
                    }
                    pub fn modulo(&self) -> T {
                        self.m
                    }
                }
                impl<T> ModInt<T> {
                    fn new_unchecked(v: T, modulo: T) -> Self {
                        Self { v, m: modulo }
                    }
                }
                impl<T> ModInt<T>
                where
                    T: Copy + RemAssign + PartialOrd,
                {
                    pub fn new(mut v: T, modulo: T) -> Self {
                        if v >= modulo {
                            v %= modulo;
                        }
                        Self::new_unchecked(v, modulo)
                    }
                }
                impl<T> ModInt<T>
                where
                    T: Copy
                        + Sub<Output = T>
                        + ShrAssign
                        + BitAnd<Output = T>
                        + PartialEq
                        + PartialOrd
                        + Div<Output = T>
                        + RemAssign,
                    ModInt<T>: MulAssign,
                {
                    pub fn pow(self, e: T) -> Self {
                        let zero = self.modulo() - self.modulo();
                        let one = self.modulo() / self.modulo();
                        let mut e = e;
                        let mut result = Self::new_unchecked(one, self.modulo());
                        let mut cur = self;
                        while e > zero {
                            if e & one == one {
                                result *= cur;
                            }
                            e >>= one;
                            cur *= cur;
                        }
                        result
                    }
                }
                impl<T> Copy for ModInt<T> where T: Copy {}
                impl<T> Clone for ModInt<T>
                where
                    T: Copy,
                {
                    fn clone(&self) -> Self {
                        Self::new_unchecked(self.value(), self.modulo())
                    }
                }
                impl<T> Add<T> for ModInt<T>
                where
                    T: AddAssign + SubAssign + RemAssign + Copy + PartialOrd,
                {
                    type Output = Self;
                    fn add(self, mut rhs: T) -> Self::Output {
                        if rhs >= self.modulo() {
                            rhs %= self.modulo();
                        }
                        rhs += self.value();
                        if rhs >= self.modulo() {
                            rhs -= self.modulo();
                        }
                        Self::new_unchecked(rhs, self.modulo())
                    }
                }
                impl<T> Sub<T> for ModInt<T>
                where
                    T: AddAssign + SubAssign + RemAssign + Copy + PartialOrd,
                {
                    type Output = Self;
                    fn sub(self, mut rhs: T) -> Self::Output {
                        if rhs >= self.modulo() {
                            rhs %= self.modulo();
                        }
                        let mut result = self.value();
                        result += self.modulo();
                        result -= rhs;
                        if result >= self.modulo() {
                            result -= self.modulo();
                        }
                        Self::new_unchecked(result, self.modulo())
                    }
                }
                impl<T> Mul<T> for ModInt<T>
                where
                    T: MulAssign + RemAssign + Copy + PartialOrd,
                {
                    type Output = Self;
                    fn mul(self, mut rhs: T) -> Self::Output {
                        if rhs >= self.modulo() {
                            rhs %= self.modulo();
                        }
                        rhs *= self.value();
                        rhs %= self.modulo();
                        Self::new_unchecked(rhs, self.modulo())
                    }
                }
                impl<T> Add<ModInt<T>> for ModInt<T>
                where
                    T: Copy,
                    ModInt<T>: Add<T, Output = ModInt<T>>,
                {
                    type Output = Self;
                    fn add(self, rhs: ModInt<T>) -> Self::Output {
                        self + rhs.value()
                    }
                }
                impl<T> Sub<ModInt<T>> for ModInt<T>
                where
                    T: Copy,
                    ModInt<T>: Sub<T, Output = ModInt<T>>,
                {
                    type Output = Self;
                    fn sub(self, rhs: ModInt<T>) -> Self::Output {
                        self - rhs.value()
                    }
                }
                impl<T> Mul<ModInt<T>> for ModInt<T>
                where
                    T: Copy,
                    ModInt<T>: Mul<T, Output = ModInt<T>>,
                {
                    type Output = Self;
                    fn mul(self, rhs: ModInt<T>) -> Self::Output {
                        self * rhs.value()
                    }
                }
                impl<T> Div<ModInt<T>> for ModInt<T>
                where
                    T: Copy,
                    ModInt<T>: Div<T, Output = ModInt<T>>,
                {
                    type Output = Self;
                    fn div(self, rhs: ModInt<T>) -> Self::Output {
                        self / rhs.value()
                    }
                }
                impl<T> AddAssign<T> for ModInt<T>
                where
                    T: Copy,
                    ModInt<T>: Add<T, Output = ModInt<T>>,
                {
                    fn add_assign(&mut self, other: T) {
                        *self = *self + other;
                    }
                }
                impl<T> AddAssign<ModInt<T>> for ModInt<T>
                where
                    T: Copy,
                    ModInt<T>: Add<ModInt<T>, Output = ModInt<T>>,
                {
                    fn add_assign(&mut self, other: ModInt<T>) {
                        *self = *self + other;
                    }
                }
                impl<T> SubAssign<T> for ModInt<T>
                where
                    T: Copy,
                    ModInt<T>: Sub<T, Output = ModInt<T>>,
                {
                    fn sub_assign(&mut self, other: T) {
                        *self = *self - other;
                    }
                }
                impl<T> SubAssign<ModInt<T>> for ModInt<T>
                where
                    T: Copy,
                    ModInt<T>: Sub<ModInt<T>, Output = ModInt<T>>,
                {
                    fn sub_assign(&mut self, other: ModInt<T>) {
                        *self = *self - other;
                    }
                }
                impl<T> DivAssign<T> for ModInt<T>
                where
                    T: Copy,
                    ModInt<T>: Div<T, Output = ModInt<T>>,
                {
                    fn div_assign(&mut self, rhs: T) {
                        *self = *self / rhs
                    }
                }
                impl<T> DivAssign<ModInt<T>> for ModInt<T>
                where
                    T: Copy,
                    ModInt<T>: Div<ModInt<T>, Output = ModInt<T>>,
                {
                    fn div_assign(&mut self, rhs: ModInt<T>) {
                        *self = *self / rhs
                    }
                }
                impl<T> MulAssign<T> for ModInt<T>
                where
                    T: Copy,
                    ModInt<T>: Mul<T, Output = ModInt<T>>,
                {
                    fn mul_assign(&mut self, rhs: T) {
                        *self = *self * rhs;
                    }
                }
                impl<T> MulAssign<ModInt<T>> for ModInt<T>
                where
                    T: Copy,
                    ModInt<T>: Mul<ModInt<T>, Output = ModInt<T>>,
                {
                    fn mul_assign(&mut self, rhs: ModInt<T>) {
                        *self = *self * rhs;
                    }
                }
                impl<T> Div<T> for ModInt<T>
                where
                    T: Copy
                        + Add<Output = T>
                        + Sub<Output = T>
                        + Div<Output = T>
                        + BitAnd<Output = T>
                        + PartialEq
                        + PartialOrd
                        + ShrAssign
                        + RemAssign
                        + MulAssign,
                {
                    type Output = Self;
                    fn div(self, mut rhs: T) -> Self::Output {
                        if rhs >= self.modulo() {
                            rhs %= self.modulo();
                        }
                        let one = self.modulo() / self.modulo();
                        let two = one + one;
                        self * Self::new_unchecked(rhs, self.modulo()).pow(self.modulo() - two)
                    }
                }
            }
            #[cfg(test)]
            mod test {
                use super::mod_int::*;
                use rand::distributions::Uniform;
                use rand::Rng;
                const MOD: u64 = 1_000_000_007;
                #[test]
                fn random_add_sub() {
                    let mut rng = rand::thread_rng();
                    for _ in 0..1000 {
                        let x: u64 = rng.sample(Uniform::from(0..MOD));
                        let y: u64 = rng.sample(Uniform::from(0..MOD));
                        let mx = ModInt::new(x, MOD);
                        let my = ModInt::new(y, MOD);
                        assert_eq!((mx + my).value(), (x + y) % MOD);
                        assert_eq!((mx + y).value(), (x + y) % MOD);
                        assert_eq!((mx - my).value(), (x + MOD - y) % MOD);
                        assert_eq!((mx - y).value(), (x + MOD - y) % MOD);
                        let mut x = x;
                        let mut mx = mx;
                        x += y;
                        mx += my;
                        assert_eq!(mx.value(), x % MOD);
                        mx += y;
                        x += y;
                        assert_eq!(mx.value(), x % MOD);
                        mx -= my;
                        x = (x + MOD - y % MOD) % MOD;
                        assert_eq!(mx.value(), x);
                        mx -= y;
                        x = (x + MOD - y % MOD) % MOD;
                        assert_eq!(mx.value(), x);
                    }
                }
                #[test]
                fn random_mul() {
                    let mut rng = rand::thread_rng();
                    for _ in 0..1000 {
                        let x: u64 = rng.sample(Uniform::from(0..MOD));
                        let y: u64 = rng.sample(Uniform::from(0..MOD));
                        let mx = ModInt::new(x, MOD);
                        let my = ModInt::new(y, MOD);
                        assert_eq!((mx * my).value(), (x * y) % MOD);
                        assert_eq!((mx * y).value(), (x * y) % MOD);
                    }
                }
                #[test]
                fn zero_test() {
                    let a = ModInt::new(1_000_000_000, MOD);
                    let b = ModInt::new(7, MOD);
                    let c = a + b;
                    assert_eq!(c.value(), 0);
                }
                #[test]
                fn pow_test() {
                    let a = ModInt::new(3, MOD);
                    let a = a.pow(4);
                    assert_eq!(a.value(), 81);
                }
                #[test]
                fn div_test() {
                    for i in 1..100000 {
                        let mut a = ModInt::new(1, MOD);
                        a /= i;
                        a *= i;
                        assert_eq!(a.value(), 1);
                    }
                }
                #[test]
                fn edge_cases() {
                    let a = ModInt::new(1_000_000_000, MOD) * std::u64::MAX;
                    assert_eq!(a.value(), 923591986);
                    let mut a = ModInt::new(1_000_000_000, MOD);
                    a *= std::u64::MAX;
                    assert_eq!(a.value(), 923591986);
                    let a = ModInt::new(1_000_000_000, MOD) + std::u64::MAX;
                    assert_eq!(a.value(), 582344000);
                    let mut a = ModInt::new(1_000_000_000, MOD);
                    a += std::u64::MAX;
                    assert_eq!(a.value(), 582344000);
                    let a = ModInt::new(1_000_000_000, MOD) - std::u64::MAX;
                    assert_eq!(a.value(), 417655993);
                    let mut a = ModInt::new(1_000_000_000, MOD);
                    a -= std::u64::MAX;
                    assert_eq!(a.value(), 417655993);
                    let a = ModInt::new(1_000_000_000, MOD) / std::u64::MAX;
                    assert_eq!(a.value(), 605455209);
                    let mut a = ModInt::new(1_000_000_000, MOD);
                    a /= std::u64::MAX;
                    assert_eq!(a.value(), 605455209);
                }
                #[test]
                fn overflow_guard() {
                    let a = ModInt::new(MOD * 10, MOD);
                    assert_eq!(a.value(), 0);
                }
            }
        }
        pub mod next_permutation {
            pub trait NextPermutation {
                fn next_permutation(&mut self) -> bool;
            }
            impl<T> NextPermutation for [T]
            where
                T: PartialOrd,
            {
                fn next_permutation(&mut self) -> bool {
                    if self.len() < 2 {
                        return false;
                    }
                    let mut i = self.len() - 1;
                    while i > 0 && self[i - 1] >= self[i] {
                        i -= 1;
                    }
                    if i == 0 {
                        return false;
                    }
                    let mut j = self.len() - 1;
                    while j >= i && self[j] <= self[i - 1] {
                        j -= 1;
                    }
                    self.swap(j, i - 1);
                    self[i..].reverse();
                    true
                }
            }
            #[cfg(test)]
            mod tests {
                use super::NextPermutation;
                use std::collections::BTreeSet;
                #[test]
                fn test_next_permutation() {
                    let mut x = vec![1, 2, 3, 4, 5];
                    let mut set = BTreeSet::new();
                    let mut count = 0;
                    while x.next_permutation() {
                        count += 1;
                        set.insert(x.clone());
                    }
                    assert_eq!(count + 1, 5 * 4 * 3 * 2);
                    assert_eq!(set.len(), count);
                }
            }
        }
    }
    #[doc = " Geometry algorithms."]
    pub mod geometry {
        pub mod circle {
            pub fn cc_intersect((p1, r1): (Point, f64), (p2, r2): (Point, f64)) -> Vec<Point> {
                let dist = (p1 - p2).abs();
                if dist > r1 + r2 {
                    return Vec::new();
                }
                let rc = (dist * dist + r1 * r1 - r2 * r2) / (2. * dist);
                let rs = (r1 * r1 - rc * rc).sqrt();
                let diff = (p2 - p1) / dist;
                vec![p1 + diff * Point(rc, rs), p1 + diff * Point(rc, -rs)]
            }
            #[derive(Copy, Clone)]
            pub struct Point(f64, f64);
            impl Point {
                fn abs(self) -> f64 {
                    let x = self.0;
                    let y = self.1;
                    (x * x + y * y).sqrt()
                }
            }
            impl ::std::ops::Add<Point> for Point {
                type Output = Point;
                fn add(self, rhs: Point) -> Point {
                    Point(self.0 + rhs.0, self.1 + rhs.1)
                }
            }
            impl ::std::ops::Sub<Point> for Point {
                type Output = Point;
                fn sub(self, rhs: Point) -> Point {
                    Point(self.0 - rhs.0, self.1 - rhs.1)
                }
            }
            impl ::std::ops::Div<f64> for Point {
                type Output = Point;
                fn div(self, rhs: f64) -> Point {
                    Point(self.0 / rhs, self.1 / rhs)
                }
            }
            impl ::std::ops::Mul<Point> for Point {
                type Output = Point;
                fn mul(self, rhs: Point) -> Point {
                    let Point(x1, y1) = self;
                    let Point(x2, y2) = rhs;
                    Point(x1 * x2 - y1 * y2, x1 * y2 + y1 * x2)
                }
            }
            #[cfg(test)]
            mod tests {
                use super::*;
                use crate::utils::test_helper::Tester;
                #[test]
                fn solve_cgl_7_e() {
                    let tester = Tester::new("./assets/CGL_7_E/in/", "./assets/CGL_7_E/out/");
                    tester.test_solution_with(
                        |sc| {
                            let c1 = (Point(sc.read(), sc.read()), sc.read());
                            let c2 = (Point(sc.read(), sc.read()), sc.read());
                            let mut points = cc_intersect(c1, c2)
                                .into_iter()
                                .map(|Point(x, y)| (x, y))
                                .collect::<Vec<_>>();
                            if points[0] > points[1] {
                                points.swap(0, 1);
                            }
                            sc.write(format!(
                                "{} {} {} {}\n",
                                points[0].0, points[0].1, points[1].0, points[1].1
                            ));
                        },
                        |expected, actual| {
                            assert!((expected.read::<f64>() - actual.read::<f64>()).abs() < 1e-6);
                            assert!((expected.read::<f64>() - actual.read::<f64>()).abs() < 1e-6);
                            assert!((expected.read::<f64>() - actual.read::<f64>()).abs() < 1e-6);
                            assert!((expected.read::<f64>() - actual.read::<f64>()).abs() < 1e-6);
                        },
                    );
                }
            }
        }
        pub mod convex_hull {
            pub fn extract_convex_hull(points: &[Point], contain_on_segment: bool) -> Vec<usize> {
                let n = points.len();
                if n <= 1 {
                    return vec![0];
                }
                let mut ps: Vec<usize> = (0..n).collect();
                ps.sort_by(|&a, &b| {
                    if (points[a].x - points[b].x).abs() < std::f64::EPSILON {
                        points[a].y.partial_cmp(&points[b].y).unwrap()
                    } else {
                        points[a].x.partial_cmp(&points[b].x).unwrap()
                    }
                });
                let mut qs: Vec<usize> = Vec::new();
                for &i in &ps {
                    while qs.len() > 1 {
                        let k = qs.len();
                        let det = (points[qs[k - 1]] - points[qs[k - 2]])
                            .det(&(points[i] - points[qs[k - 1]]));
                        if det < 0.0 || (det <= 0.0 && !contain_on_segment) {
                            qs.pop();
                        } else {
                            break;
                        }
                    }
                    qs.push(i);
                }
                let t = qs.len();
                for i in (0..(n - 1)).rev() {
                    let i = ps[i];
                    while qs.len() > t {
                        let k = qs.len();
                        let det = (points[qs[k - 1]] - points[qs[k - 2]])
                            .det(&(points[i] - points[qs[k - 1]]));
                        if det < 0.0 || (det <= 0.0 && !contain_on_segment) {
                            qs.pop();
                        } else {
                            break;
                        }
                    }
                    qs.push(i);
                }
                qs.pop();
                qs
            }
            #[derive(Debug, Copy, Clone)]
            pub struct Point {
                x: f64,
                y: f64,
            }
            impl std::ops::Sub for Point {
                type Output = Point;
                fn sub(self, other: Point) -> Point {
                    Point {
                        x: self.x - other.x,
                        y: self.y - other.y,
                    }
                }
            }
            impl Point {
                pub fn det(&self, other: &Point) -> f64 {
                    self.x * other.y - self.y * other.x
                }
            }
            #[cfg(test)]
            mod test {
                use super::*;
                use crate::utils::test_helper::Tester;
                #[doc = " Solve http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=CGL_4_A"]
                #[test]
                fn solve_cgl_4_a() {
                    let tester = Tester::new("./assets/CGL_4_A/in/", "./assets/CGL_4_A/out/");
                    tester.test_solution(|sc| {
                        let n: usize = sc.read();
                        let mut points = Vec::new();
                        for _ in 0..n {
                            let x: f64 = sc.read();
                            let y: f64 = sc.read();
                            points.push(Point { x, y });
                        }
                        let convex_hull = extract_convex_hull(&points, true);
                        sc.write(format!("{}\n", convex_hull.len()));
                        let n = convex_hull.len();
                        let mut start = 0;
                        for i in 0..n {
                            if points[convex_hull[i]].y < points[convex_hull[start]].y
                                || (points[convex_hull[i]].y == points[convex_hull[start]].y
                                    && points[convex_hull[i]].x < points[convex_hull[start]].x)
                            {
                                start = i;
                            }
                        }
                        for i in 0..n {
                            let i = (i + start) % n;
                            let i = convex_hull[i];
                            sc.write(format!("{} {}\n", points[i].x, points[i].y));
                        }
                    });
                }
            }
        }
        pub mod minimum_bounding_circle {
            pub mod minimum_bounding_circle {
                pub fn make_circle(ps: &[Point<f64>]) -> (Point<f64>, f64) {
                    let n = ps.len();
                    assert!(n >= 2);
                    let mut c = make_circle2(ps[0], ps[1]);
                    for i in 2..n {
                        if is_included(ps[i], c) {
                            continue;
                        }
                        c = make_circle2(ps[0], ps[i]);
                        for j in 1..i {
                            if is_included(ps[j], c) {
                                continue;
                            }
                            c = make_circle2(ps[i], ps[j]);
                            for k in 0..j {
                                if is_included(ps[k], c) {
                                    continue;
                                }
                                c = make_circle3(ps[i], ps[j], ps[k]);
                            }
                        }
                    }
                    c
                }
                fn make_circle3(a: Point<f64>, b: Point<f64>, c: Point<f64>) -> (Point<f64>, f64) {
                    let ea = (b - c).norm();
                    let eb = (c - a).norm();
                    let ec = (a - b).norm();
                    let s = (b - a).det(&(c - a));
                    let center = (a * ea * (eb + ec - ea)
                        + b * eb * (ec + ea - eb)
                        + c * ec * (ea + eb - ec))
                        / (s * s * 4.0);
                    let r2 = (center - a).norm();
                    (center, r2)
                }
                fn make_circle2(a: Point<f64>, b: Point<f64>) -> (Point<f64>, f64) {
                    let c = (a + b) / 2.0;
                    let r2 = (a - c).norm();
                    (c, r2)
                }
                fn is_included(a: Point<f64>, circle: (Point<f64>, f64)) -> bool {
                    let (center, r2) = circle;
                    (a - center).norm() <= r2
                }
                pub struct Point<T> {
                    pub x: T,
                    pub y: T,
                }
                impl<T> Copy for Point<T> where T: Copy {}
                impl<T> Clone for Point<T>
                where
                    T: Clone,
                {
                    fn clone(&self) -> Point<T> {
                        Point {
                            x: self.x.clone(),
                            y: self.y.clone(),
                        }
                    }
                }
                impl<T> std::ops::Sub for Point<T>
                where
                    T: std::ops::Sub<Output = T>,
                {
                    type Output = Point<T>;
                    fn sub(self, other: Point<T>) -> Point<T> {
                        Point {
                            x: self.x - other.x,
                            y: self.y - other.y,
                        }
                    }
                }
                impl<T> std::ops::Mul<T> for Point<T>
                where
                    T: Copy + std::ops::Mul<Output = T>,
                {
                    type Output = Point<T>;
                    fn mul(self, rhs: T) -> Point<T> {
                        Point {
                            x: self.x * rhs,
                            y: self.y * rhs,
                        }
                    }
                }
                impl<T> std::ops::Div<T> for Point<T>
                where
                    T: Copy + std::ops::Div<Output = T>,
                {
                    type Output = Point<T>;
                    fn div(self, rhs: T) -> Point<T> {
                        Point {
                            x: self.x / rhs,
                            y: self.y / rhs,
                        }
                    }
                }
                impl<T> std::ops::Add<Point<T>> for Point<T>
                where
                    T: std::ops::Add<Output = T>,
                {
                    type Output = Point<T>;
                    fn add(self, rhs: Point<T>) -> Point<T> {
                        Point {
                            x: self.x + rhs.x,
                            y: self.y + rhs.y,
                        }
                    }
                }
                impl<T> Point<T>
                where
                    T: Copy
                        + std::ops::Mul<Output = T>
                        + std::ops::Sub<Output = T>
                        + std::ops::Add<Output = T>,
                {
                    pub fn det(&self, other: &Point<T>) -> T {
                        self.x * other.y - self.y * other.x
                    }
                    pub fn norm(&self) -> T {
                        self.x * self.x + self.y * self.y
                    }
                }
            }
            #[cfg(test)]
            mod tests {
                use super::minimum_bounding_circle::*;
                use crate::utils::test_helper::Tester;
                #[test]
                fn solve_aoj2423() {
                    let tester = Tester::new("./assets/AOJ2423/in/", "./assets/AOJ2423/out/");
                    tester.test_solution(|sc| {
                        let circles: usize = sc.read();
                        let people: usize = sc.read();
                        let rs: Vec<f64> = sc.vec(circles);
                        let mut people_r2 = vec![0.0; people];
                        let mut people_list = vec![];
                        for i in 0..people {
                            let n: usize = sc.read();
                            let mut ps = vec![];
                            for _ in 0..n {
                                let x: f64 = sc.read();
                                let y: f64 = sc.read();
                                ps.push(Point { x, y });
                            }
                            let (_, r2) = make_circle(&ps);
                            people_list.push((r2, i));
                            people_r2[i] = r2;
                        }
                        let mut circle_list = rs
                            .iter()
                            .enumerate()
                            .map(|(i, &r)| (r, i))
                            .collect::<Vec<_>>();
                        circle_list.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
                        people_list.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
                        let mut ans = vec![0; people];
                        for _ in 0..people {
                            let mut circle_buf = 0;
                            let mut people_buf = people_list.len();
                            for p_pos in (0..people_list.len()).rev() {
                                for c_pos in (0..(circle_list.len() - circle_buf)).rev() {
                                    if circle_list[c_pos].0 * circle_list[c_pos].0
                                        >= people_list[p_pos].0
                                    {
                                        circle_buf += 1;
                                    } else {
                                        break;
                                    }
                                }
                                if people_list.len() - p_pos > circle_buf {
                                    sc.write("NG\n");
                                    return;
                                } else if people_list.len() - p_pos == circle_buf {
                                    people_buf = people_list.len() - p_pos;
                                    break;
                                }
                            }
                            let youngest_people = people_list
                                .iter()
                                .rev()
                                .take(people_buf)
                                .map(|p| p.1)
                                .min()
                                .unwrap();
                            let youngest_circle = circle_list
                                .iter()
                                .rev()
                                .take(circle_buf)
                                .map(|c| c.1)
                                .filter(|&i| rs[i] * rs[i] >= people_r2[youngest_people])
                                .min()
                                .unwrap();
                            ans[youngest_people] = youngest_circle;
                            people_list = people_list
                                .into_iter()
                                .filter(|p| p.1 != youngest_people)
                                .collect::<Vec<_>>();
                            circle_list = circle_list
                                .into_iter()
                                .filter(|c| c.1 != youngest_circle)
                                .collect::<Vec<_>>();
                        }
                        for i in ans.into_iter() {
                            sc.write(format!("{}\n", i + 1));
                        }
                    });
                }
            }
        }
    }
    #[doc = " Utilities for tests, stdin, and so on."]
    pub mod utils {
        #[doc = " Functions to test this library with contest-style IO files."]
        #[cfg(test)]
        pub(crate) mod test_helper {
            use crate::utils::scanner::IO;
            use std::fs;
            use std::fs::File;
            use std::io::Read;
            use std::str;
            pub(crate) struct Tester {
                input: Vec<(String, Vec<u8>)>,
                output: Vec<(String, Vec<u8>)>,
            }
            impl Tester {
                pub(crate) fn new(input_directory: &str, output_directory: &str) -> Tester {
                    let input = read_from_directory(input_directory);
                    let output = read_from_directory(output_directory);
                    Tester { input, output }
                }
                pub(crate) fn test_solution<F>(self, solution: F)
                where
                    F: Fn(&mut IO<&[u8], &mut Vec<u8>>),
                {
                    for ((input_label, input), (output_label, output)) in
                        self.input.into_iter().zip(self.output)
                    {
                        eprintln!("Testing {} {}", input_label, output_label);
                        let mut writer = vec![];
                        {
                            let mut sc = IO::new(&input[..], &mut writer);
                            solution(&mut sc);
                        }
                        assert_eq!(writer, output);
                    }
                }
                pub(crate) fn test_solution_with<F1, F2>(self, solution: F1, assertion: F2)
                where
                    F1: Fn(&mut IO<&[u8], &mut Vec<u8>>),
                    F2: Fn(&mut IO<&[u8], &mut Vec<u8>>, &mut IO<&[u8], &mut Vec<u8>>),
                {
                    for ((input_label, input), (output_label, output)) in
                        self.input.into_iter().zip(self.output)
                    {
                        eprintln!("Testing {} {}", input_label, output_label);
                        let mut writer = vec![];
                        {
                            let mut sc = IO::new(&input[..], &mut writer);
                            solution(&mut sc);
                        }
                        let mut actual_writer = vec![];
                        let mut expected_writer = vec![];
                        let mut actual = IO::new(&writer[..], &mut actual_writer);
                        let mut expected = IO::new(&output[..], &mut expected_writer);
                        assertion(&mut expected, &mut actual);
                    }
                }
            }
            fn read_file(filepath: &str) -> Vec<u8> {
                let mut file = File::open(filepath).unwrap();
                let mut buf = Vec::new();
                file.read_to_end(&mut buf).unwrap();
                buf
            }
            fn read_from_directory(directory_path: &str) -> Vec<(String, Vec<u8>)> {
                let mut filenames: Vec<String> = fs::read_dir(directory_path)
                    .unwrap()
                    .map(|result| result.unwrap().path().display().to_string())
                    .collect();
                filenames.sort();
                filenames
                    .into_iter()
                    .map(|file| {
                        let data = read_file(&file);
                        (file, data)
                    })
                    .collect()
            }
        }
        pub mod scanner {
            pub struct IO<R, W: std::io::Write>(R, std::io::BufWriter<W>);
            impl<R: std::io::Read, W: std::io::Write> IO<R, W> {
                pub fn new(r: R, w: W) -> IO<R, W> {
                    IO(r, std::io::BufWriter::new(w))
                }
                pub fn write<S: ToString>(&mut self, s: S) {
                    use std::io::Write;
                    self.1.write_all(s.to_string().as_bytes()).unwrap();
                }
                pub fn read<T: std::str::FromStr>(&mut self) -> T {
                    use std::io::Read;
                    let buf = self
                        .0
                        .by_ref()
                        .bytes()
                        .map(|b| b.unwrap())
                        .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r' || b == b'\t')
                        .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r' && b != b'\t')
                        .collect::<Vec<_>>();
                    unsafe { std::str::from_utf8_unchecked(&buf) }
                        .parse()
                        .ok()
                        .expect("Parse error.")
                }
                pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
                    (0..n).map(|_| self.read()).collect()
                }
                pub fn chars(&mut self) -> Vec<char> {
                    self.read::<String>().chars().collect()
                }
            }
            #[cfg(test)]
            mod tests {
                use super::*;
                #[test]
                fn test_io() {
                    let input = br"10
        1 2 3 4 5 6 7 8 9 10
        abcde fghij
        
        3.14 -1592
        no_empty_line";
                    let mut sc = IO::new(&input[..], Vec::new());
                    let n: usize = sc.read();
                    assert_eq!(n, 10);
                    let a: Vec<u64> = sc.vec(n);
                    assert_eq!(&a, &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
                    let s = sc.chars();
                    let t = sc.chars();
                    assert_eq!(&s, &['a', 'b', 'c', 'd', 'e']);
                    assert_eq!(&t, &['f', 'g', 'h', 'i', 'j']);
                    let f: f64 = sc.read();
                    assert_eq!(f, 3.14);
                    let neg: i64 = sc.read();
                    assert_eq!(neg, -1592);
                    let s = sc.read::<String>();
                    assert_eq!(&s, "no_empty_line");
                    sc.write(format!("1\n"));
                    let mut output = Vec::new();
                    {
                        let mut sc = IO::new(&b""[..], &mut output);
                        sc.write(format!("{}\n", 1));
                        sc.write(format!("{}\n", 2));
                        sc.write(format!("{}\n", 3));
                    }
                    let output = String::from_utf8(output).expect("Not UTF-8");
                    assert_eq!(&output, "1\n2\n3\n");
                }
            }
        }
    }
    #[doc = " String algorithms."]
    pub mod string {
        pub mod rolling_hash {
            pub mod rolling_hash {
                const MASK_30: u64 = (1 << 30) - 1;
                const MASK_31: u64 = (1 << 31) - 1;
                const MOD: u64 = (1 << 61) - 1;
                pub struct RollingHash {
                    hash: Vec<u64>,
                    pow: Vec<u64>,
                }
                impl RollingHash {
                    pub fn new(s: &[u8], base: u64) -> RollingHash {
                        let n = s.len();
                        let mut hash: Vec<u64> = vec![0; n + 1];
                        let mut pow: Vec<u64> = vec![0; n + 1];
                        pow[0] = 1;
                        for i in 0..n {
                            pow[i + 1] = modulo(mod_mul(pow[i], base));
                            hash[i + 1] = modulo(mod_mul(hash[i], base) + s[i] as u64);
                        }
                        RollingHash { hash, pow }
                    }
                    #[doc = " Get hash of [l, r)"]
                    pub fn get_hash(&self, l: usize, r: usize) -> u64 {
                        modulo(self.hash[r] + MOD - mod_mul(self.hash[l], self.pow[r - l]))
                    }
                }
                fn mod_mul(a: u64, b: u64) -> u64 {
                    let (a_prefix, a_suffix) = (a >> 31, a & MASK_31);
                    let (b_prefix, b_suffix) = (b >> 31, b & MASK_31);
                    let m = a_suffix * b_prefix + a_prefix * b_suffix;
                    modulo(
                        a_prefix * b_prefix * 2
                            + (m >> 30)
                            + ((m & MASK_30) << 31)
                            + a_suffix * b_suffix,
                    )
                }
                fn modulo(v: u64) -> u64 {
                    let v = (v & MOD) + (v >> 61);
                    if v >= MOD {
                        v - MOD
                    } else {
                        v
                    }
                }
            }
            #[cfg(test)]
            mod tests {
                use super::*;
                use rand::distributions::Uniform;
                use rand::Rng;
                const BASE: u64 = 1_000_000_007;
                #[test]
                fn test_rolling_hash() {
                    let n = 30;
                    let mut rng = rand::thread_rng();
                    for _ in 0..100 {
                        let mut s = String::new();
                        for _ in 0..n {
                            let c = (rng.sample(Uniform::from(0..26)) as u8 + 'a' as u8) as char;
                            s.push(c);
                        }
                        let t = String::new() + s.as_str() + s.as_str();
                        let n = t.len();
                        let rolling_hash = rolling_hash::RollingHash::new(&t.as_bytes(), BASE);
                        for i in 0..n {
                            for j in i..n {
                                for k in (j + 1)..n {
                                    let same = t[i..k] == t[j..k];
                                    let same_hash =
                                        rolling_hash.get_hash(i, k) == rolling_hash.get_hash(j, k);
                                    assert_eq!(
                                        same,
                                        same_hash,
                                        "{:?} {:?} {} {}",
                                        &t[i..k],
                                        &t[j..k],
                                        rolling_hash.get_hash(i, k),
                                        rolling_hash.get_hash(j, k)
                                    );
                                }
                            }
                        }
                    }
                }
            }
        }
        pub mod z_algorithm {
            pub mod z_algorithm {
                pub fn calc_z_array<T: PartialEq>(s: &[T]) -> Vec<usize> {
                    let n = s.len();
                    let mut z_array = vec![0; n];
                    let mut l = 0;
                    let mut r = 1;
                    for i in 1..n {
                        if i >= r {
                            l = i;
                            r = i + 1;
                            while r <= n && s[r - 1 - l] == s[r - 1] {
                                r += 1;
                            }
                            z_array[i] = r - l - 1;
                            r -= 1;
                        } else if z_array[i - l] < r - i {
                            z_array[i] = z_array[i - l];
                        } else {
                            l = i;
                            while r <= n && s[r - 1 - l] == s[r - 1] {
                                r += 1;
                            }
                            z_array[i] = r - l - 1;
                            r -= 1;
                        }
                    }
                    z_array[0] = n;
                    z_array
                }
            }
            #[cfg(test)]
            mod tests {
                use super::*;
                use rand::distributions::Uniform;
                use rand::Rng;
                #[test]
                fn test_z() {
                    let n = 1000;
                    let mut rng = rand::thread_rng();
                    for _ in 0..100 {
                        let mut s = String::new();
                        for _ in 0..n {
                            let c = (rng.sample(Uniform::from(0..26)) as u8 + 'a' as u8) as char;
                            s.push(c);
                        }
                        let t = String::new() + s.as_str() + s.as_str();
                        let z_array = z_algorithm::calc_z_array(&t.as_bytes());
                        let n = t.len();
                        for i in 0..n {
                            let l = z_array[i];
                            assert_eq!(&t[0..l], &t[i..(i + l)]);
                            assert!(i + l >= t.len() || t[l..(l + 1)] != t[(i + l)..(i + l + 1)]);
                        }
                    }
                }
            }
        }
    }
}