//2020年4月17日現在

#include<stdio.h>
#include<cmath>
#include<math.h>
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<complex>
#include<queue>
#include<set>
#include<utility>
#include<iomanip>
#include<limits>
#include<thread>
#include<map>
#include<stack>
#include<numeric>
#include<cassert>
#include<random>
#include<chrono>
#include<unordered_set>
#include<unordered_map>
#include<fstream>
#include<list>
#include<functional>
#include<bitset>
#include<tuple>
#include <cstdio>

using namespace std;


template <class... A>
void prints() { cout << "\n"; }
template <class... A>
void prints_rest() { cout << "\n"; }
template <class T, class... A>
void prints_rest(const T &first, const A &... rest) { cout << " " << first; prints_rest(rest...); }
template <class T, class... A>
void prints(const T &first, const A &... rest) { cout << first; prints_rest(rest...); }
template <class T, class... A>
void printd(const T &first, const A &... rest) { cout << fixed << setprecision(15) << first; prints_rest(rest...); }


namespace {
	// printElems(&a[0], &a[n]);　みたいな感じで使う。
	void printElems(const int* begin, const int* end)
	{
		for (const int* p = begin; p != end; ++p) {
			cout << *p << ' ';
		}
		cout << endl;
	}
}

#define rep(i,n) for(ll i=0; i<n; i++)
#define rep1(i,n) for(ll i=1; i<n+1; i++)
#define repr(i,n) for(ll i=n-1; i>=0; i--)
#define repr1(i,n) for(ll i=n; i>0; i--)
#define FOR(i,j,n) for(ll i=j; i < n; i++)
#define souatari(i,j,n) rep1(i,n-1)rep(j,i)
#define souatari1(i,j,n) for(ll i=2; i<n+1; i++)rep1(j,i-1)
#define mp make_pair
#define F first
#define S second
#define elif else if

typedef long long ll;
typedef vector<int>  vi;
typedef vector<vi>  vvi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef array<ll,3> arr3;
typedef long double D;


const ll llinf =  numeric_limits<ll>::max();
const ll _llinf = numeric_limits<ll>::lowest();
const int inf = numeric_limits<int>::max();
const int _inf = numeric_limits<int>::lowest();
const double dinf = numeric_limits<double>::infinity();
const ll MOD = 1000000007;
//const ll MOD = 998244353;
const ll BIG = 1LL<<60;
const string yes = "Yes";
const string no = "No";

//----------------------------------------------

//RMQ<int> segtree(200005);みたいな感じ
template <typename T>
struct RMQ {
	const T INF = numeric_limits<T>::max();
	int n;		 // 葉の数
	vector<T> dat; // 完全二分木の配列
	RMQ(int n_) : n(), dat(n_ * 4, INF) { // 葉の数は 2^x の形
		int x = 1;
		while (n_ > x) {
			x *= 2;
		}
		n = x;
	}

	void update(int i, T x) {
		i += n - 1;
		dat[i] = x;
		while (i > 0) {
			i = (i - 1) / 2;  // parent
			dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
		}
	}

	// the minimum element of [a,b)
	T query(int a, int b) { return query_sub(a, b, 0, 0, n); }
	T query_sub(int a, int b, int k, int l, int r) {
		if (r <= a || b <= l) {
			return INF;
		} else if (a <= l && r <= b) {
			return dat[k];
		} else {
			T vl = query_sub(a, b, k * 2 + 1, l, (l + r) / 2);
			T vr = query_sub(a, b, k * 2 + 2, (l + r) / 2, r);
			return min(vl, vr);
		}
	}
};


int main(){
	RMQ<int> seg(200005);
	int h,w;
	cin >> h >> w;
	vi ans;
	set<int> s;
	rep(i,w){
		s.insert(i);
	}
	rep(i,w){
		seg.update(i,0);
	}

	rep1(i,h){
		int a,b;
		cin >> a >> b;
		a--;b--;

		decltype(s)::iterator f = s.lower_bound(a);
		decltype(s)::iterator ftmp = s.lower_bound(a);
		decltype(s)::iterator e = s.lower_bound(b+1);
		int tmp = inf;
		while(f!=e){
			int tt = *f;
			int ttt = seg.query(tt,tt+1);
			if(ttt!=inf){
				tmp = min(ttt+b+1-tt,tmp);
			}
			seg.update(tt,inf);
			++f;
		}
		if(tmp!=inf){
			seg.update(b+1,min(tmp,seg.query(b+1,b+2)));

		}
		int anstmp = seg.query(0,w);
		if(anstmp!=inf){
		ans.push_back(seg.query(0,w)+i);
		}
		else{
			ans.push_back(-1);
		}
		s.erase(ftmp,e);

		if(tmp!=inf){
			s.insert(b+1);
		}

/*
		rep(i,w){
			cout << seg.query(i,i+1) << ' ';
		}
		prints();
*/

	}
	for(int x : ans){
		prints(x);
	}



	return 0;
}




Measured memory_bytes: 16824