#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x,vector<x>,greater<x>>
#define all(x) (x).begin(),(x).end()
#define CST(x) cout<<fixed<<setprecision(x)
#define rev(x) reverse(x);
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
using pl=pair<ll,ll>;
using vpl=vector<pl>;
using vvpl=vector<vpl>;
const ll MOD=1000000007;
const ll MOD9=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-1};
template<class T> inline bool chmin(T& a, T b) {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
}
template<class T> inline bool chmax(T& a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

template <class T>
class SegTreeLazy {
    int n;// 葉の数
    vector<T> data;// データを格納するvector
    vector<T> lazy;//
    T ex; // 初期値かつ単位元
    T em;//更新の単位元
    function<T(T, T)> fx; // 区間クエリで使う処理
    function<T(T, T)> fa;// 区間更新で使う処理、要素←遅延
    function<T(T, T)> fm;

    // 区間[a,b)の総和。ノードk=[l,r)に着目している。
    void eval(int k) {
        if (lazy[k] == em) return;  // 更新するものが無ければ終了
        if (k < n - 1) {            // 葉でなければ子に伝搬
            lazy[k * 2 + 1] = fm(lazy[k * 2 + 1], lazy[k]);
            lazy[k * 2 + 2] = fm(lazy[k * 2 + 2], lazy[k]);
        }
        // 自身を更新
        data[k] = fa(data[k], lazy[k]);
        lazy[k] = em;
    }

    T _query(int a, int b, int k, int l, int r) {
        eval(k);
        if (r <= a || b <= l) return ex; // 交差しない
        if (a <= l && r <= b)
            return data[k]; // a,l,r,bの順で完全に含まれる
        else {
            T c1 = _query(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
            T c2 = _query(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
            return fx(c1, c2);
        }
    }
    void _update(int a, int b, T x, int k, int l, int r) {
        eval(k);
        if (a <= l && r <= b){
            lazy[k]= fm(lazy[k], x);
            eval(k);
        }
        else if( a < r &&l < b ){
            _update(a, b, x, 2 * k + 1, l, (l + r) / 2); // 左の子
            _update(a, b, x, 2 * k + 2, (l + r) / 2, r); // 右の子
            data[k]=fx(data[k*2+1],data[k*2+2]);
        }
    }   
    using FT=function<T(T, T)>;
    public:
    //n:サイズ、fx:区間クエリの関数、fa:要素←遅延、fm:遅延←遅延、ex:fxの単位元、em:fmの単位元
    SegTreeLazy(int n_, FT fx_, FT fa_, FT fm_, T ex_, T em_)
        : n(), fx(fx_), fa(fa_), fm(fm_), ex(ex_), em(em_) {
        int x = 1;
        while (n_ > x) x *= 2;
        n = x;
        data = vector<T>(2 * n - 1, ex);
        lazy = vector<T>(2 * n - 1, em);
    }

    // [a,b)をxで更新
    void update(int a, int b, T x) {
        _update(a,b,x,0,0,n);
    }

    // [a, b)の区間クエリを実行
    T query(int a, int b) {
        return _query(a, b, 0, 0, n);
    }
    T operator[](int i){
        return query(i,i+1);
    }
};


int main(){
    ll h,w;cin >> h >>w;
    auto fx=[](ll a,ll b){return min(a,b);};
    auto fx2=[](ll a,ll b){return max(a,b);};
    auto fa=[](ll a,ll b){return b;};
    SegTreeLazy<ll> st(w,fx,fa,fa,INF,INF),sst(w,fx2,fa,fa,-INF,-INF);
    st.update(0,w,0);
    rep(i,w)sst.update(i,i+1,i);
    rep(i,h){
        ll l,r;cin >> l >>r;l--;
        ll x=sst.query(l,r);
        st.update(l,r,INF/10);
        sst.update(l,r,-INF/10);
        if(r<w&&x!=-INF/10){
            ll z=sst[r];
            st.update(r,r+1,r-max(z,x));
            sst.update(r,r+1,max(z,x));
        }
        ll ans=st.query(0,w)+i+1;
        if(ans>=INF/10)ans=-1;
        cout << ans <<endl;
    }
}

Measured memory_bytes: 19560