#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return true; } return false; }
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define mp make_pair
#define si(x) int(x.size())
const int mod=1000000007,MAX=100005,INF=1<<30;

template<typename T,typename E>
struct LazySegmentTree{
    using F=function<T(T,T)>;
    using G=function<T(T,E)>;
    using H=function<E(E,E)>;
    
    int n;
    vector<T> dat;
    vector<E> lazy;
    F f;
    G g;
    H h;
    T ti;
    E ei;
    
    LazySegmentTree(int n_,F f,G g,H h,T ti,E ei) :f(f),g(g),h(h),ti(ti),ei(ei){
        n=1;
        while(n<n_) n*=2;
        dat.assign(2*n-1,ti);
        for(int i=n-2;i>=0;i--) dat[i]=f(dat[i*2+1],dat[i*2+2]);
        
        lazy.assign(2*n-1,ei);
    }
    
    LazySegmentTree(int n_,vector<T> &v,F f,G g,H h,T ti,E ei) :f(f),g(g),h(h),ti(ti),ei(ei){
        n=1;
        while(n<n_) n*=2;
        dat.assign(2*n-1,ti);
        
        for(int i=n-1;i-(n-1)<v.size();i++) dat[i]=v[i-(n-1)];
        
        for(int i=n-2;i>=0;i--) dat[i]=f(dat[i*2+1],dat[i*2+2]);
        
        lazy.assign(2*n-1,ei);
    }
    
    inline void eval(int k,int l,int r){
        
        if(lazy[k]==ei) return;
        
        dat[k]=g(dat[k],lazy[k]);
        
        if(r-l>1){
            lazy[k*2+1]=h(lazy[k*2+1],lazy[k]);
            lazy[k*2+2]=h(lazy[k*2+2],lazy[k]);
        }
        
        lazy[k]=ei;
    }
    
    void update_(int a,int b,E x,int k,int l,int r){
        
        eval(k,l,r);
        
        if(r<=a||b<=l) return;
        
        if(a<=l&&r<=b){
            lazy[k]=h(lazy[k],x);
            eval(k,l,r);
        }
        
        else{
            update_(a,b,x,2*k+1,l,(l+r)/2);
            update_(a,b,x,2*k+2,(l+r)/2,r);
            dat[k]=f(dat[2*k+1],dat[2*k+2]);
        }
        
    }
    
    void update(int a,int b,E x){
        return update_(a,b,x,0,0,n);
    }
    
    T query_(int a,int b,int k,int l,int r){
        
        eval(k,l,r);
        
        if(r<=a||b<=l) return ti;
        if(a<=l&&r<=b) return dat[k];
        
        T vl=query_(a,b,2*k+1,l,(l+r)/2);
        T vr=query_(a,b,2*k+2,(l+r)/2,r);
        return f(vl,vr);
    }
    
    T query(int a,int b){
        return query_(a,b,0,0,n);
    }
    
    void set(int k,T x){
        dat[n-1+k]=x;
    }
    
    void built(){
        for(int i=n-2;i>=0;i--) dat[i]=f(dat[i*2+1],dat[i*2+2]);
    }
    
};

int main(){
    
    std::ifstream in("text.txt");
    std::cin.rdbuf(in.rdbuf());
    cin.tie(0);
    ios::sync_with_stdio(false);
    
    int H,W;cin>>H>>W;
    vector<int> A(H),B(H),def(W,0),def2(W,0);
    for(int i=0;i<H;i++){
        cin>>A[i]>>B[i];
        A[i]--;
        B[i]--;
    }
    
    iota(all(def2),0);
    
    LazySegmentTree<int,int> seg(W,
                                 def,
                                 [](ll a,ll b){return min(a,b);},
                                 [](ll a,ll b){return b;},
                                 [](ll a,ll b){return b;},
                                 INF,
                                 INF);
    
    LazySegmentTree<int,int> lazy(W,
                                 def2,
                                 [](ll a,ll b){return min(a,b);},
                                 [](ll a,ll b){return b;},
                                 [](ll a,ll b){return b;},
                                 INF,
                                 INF);
    
    for(int i=0;i<H;i++){
        if(A[i]==0){
            if(B[i]+1<W&&lazy.query(B[i]+1,B[i]+2)!=B[i]+1){
                int f=lazy.query(B[i]+1,B[i]+2);
                
                int left=B[i]+1,right=W;
                while(right-left>1){
                    int mid=(left+right)/2;
                    if(lazy.query(mid,mid+1)==f) left=mid;
                    else right=mid;
                }
                seg.update(B[i]+1,left+1,B[i]+1-f+seg.query(f,f+1));
                lazy.update(B[i]+1,left+1,B[i]+1);
            }
            
            seg.update(A[i],B[i]+1,INF-2*W);
            lazy.update(A[i],B[i]+1,0);
        }else{
            int a=lazy.query(A[i]-1,A[i]);
            int to=A[i]-a+seg.query(a,a+1);
            
            if(B[i]+1<W&&lazy.query(B[i]+1,B[i]+2)!=B[i]+1){
                int f=lazy.query(B[i]+1,B[i]+2);
                
                int left=B[i]+1,right=W;
                while(right-left>1){
                    int mid=(left+right)/2;
                    if(lazy.query(mid,mid+1)==f) left=mid;
                    else right=mid;
                }
                seg.update(B[i]+1,left+1,B[i]+1-f+seg.query(f,f+1));
                lazy.update(B[i]+1,left+1,B[i]+1);
            }
            seg.update(A[i],B[i]+1,to);
            lazy.update(A[i],B[i]+1,A[i]);
            
        }
        
        int x=seg.query(0,W);
        
        if(x>10*(H+W)) cout<<-1<<"\n";
        else cout<<i+1+x<<"\n";
    }
}


Measured memory_bytes: 14544