Problem:
Score : 600 points

Problem Statement

There is a grid of squares with H+1 horizontal rows and W vertical columns.

You will start at one of the squares in the top row and repeat moving one square right or down. However, for each integer i from 1 through H, you cannot move down from the A_i-th, (A_i + 1)-th, \ldots, B_i-th squares from the left in the i-th row from the top.

For each integer k from 1 through H, find the minimum number of moves needed to reach one of the squares in the (k+1)-th row from the top. (The starting square can be chosen individually for each case.) If, starting from any square in the top row, none of the squares in the (k+1)-th row can be reached, print -1 instead.

Constraints

1 \leq H,W \leq 2\times 10^5

1 \leq A_i \leq B_i \leq W

Input

Input is given from Standard Input in the following format:

H W
A_1 B_1
A_2 B_2
:
A_H B_H

Output

Print H lines. The i-th line should contain the answer for the case k=i.

Sample Input 1

4 4
2 4
1 1
2 3
2 4

Sample Output 1

1
3
6
-1

Let (i,j) denote the square at the i-th row from the top and j-th column from the left.

For k=1, we need one move such as (1,1) → (2,1).

For k=2, we need three moves such as (1,1) → (2,1) → (2,2) → (3,2).

For k=3, we need six moves such as (1,1) → (2,1) → (2,2) → (3,2) → (3,3) → (3,4) → (4,4).

For k=4, it is impossible to reach any square in the fifth row from the top.

Solution in Rust (1.42.0) (judge verdict: Wrong Answer)

use std::cmp;
use std::fmt::Debug;
use std::str::FromStr;
#[allow(dead_code)]
fn read_as_vec<T>() -> Vec<T>
where
    T: FromStr,
    <T as FromStr>::Err: Debug,
{
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim()
        .split_whitespace()
        .map(|c| T::from_str(c).unwrap())
        .collect()
}

#[allow(dead_code)]
fn read_as_string() -> String {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).unwrap();
    s.trim().to_string()
}

fn main() {
    let line = read_as_vec::<usize>();
    let (h, w) = (line[0], line[1]);
    let mut walls: Vec<(usize, usize)> = vec![];
    let mut walk_ranges: Vec<(usize, usize)> = vec![];
    for _ in 0..h {
        let line: Vec<usize> = read_as_vec();
        walls.push((line[0] - 1, line[1] - 1));
        walk_ranges.push((line[0] - 1, line[1]));
    }

    let mut ans: Vec<usize> = vec![];
    let mut cur_column = 0;
    let mut passed_flag = false;
    for i in 0..walk_ranges[0].0 {
        cur_column = i;
        passed_flag = true;
        break;
    }
    if !passed_flag {
        for i in walk_ranges[0].1..w {
            cur_column = i;
            passed_flag = true;
            break;
        }
    }
    if !passed_flag {
        for _ in 0..h {
            println!("-1");
            return;
        }
    }
    ans.push(1);
    let mut cur_cost = 1;
    //println!("{}", cur_column);
    for hi in 1..h {
        // println!("\nhi = {}", hi);
        // println!("cur_column ={}", cur_column);
        // println!("cost ={}", cur_cost);
        let mut passed_flag = false;
        for j in cur_column..walk_ranges[hi].0 {
            passed_flag = true;
            cur_cost += j - cur_column + 1;
            cur_column = j;
            ans.push(cur_cost);
            break;
        }

        if !passed_flag {
            for j in walk_ranges[hi].1..w {
                passed_flag = true;
                cur_cost += j - cur_column + 1;
                cur_column = j;
                ans.push(cur_cost);
                break;
            }
        }

        if !passed_flag {
            for _ in hi..h {
                for elem in &ans {
                    println!("{}", *elem);
                }
                println!("-1");
                return;
            }
        }
    }

    for elem in &ans {
        println!("{}", *elem);
    }
}