// #include <bits/stdc++.h>
// using namespace std;
// typedef long long ll;
// #define lson root << 1, l, midd
// #define rson root << 1 | 1, midd + 1, r
// const int M = 2e5 + 5;
// const int inf = 0x3f3f3f3f;
// const ll INF = 1e18;
// struct Segtree
// {
//     ll tr[M << 2], lz[M << 2];
//     void build(int root, int l, int r)
//     {
//         tr[root] = 0, lz[root] = 0;
//         if (l == r)
//             return;
//         int midd = (l + r) >> 1;
//         build(lson);
//         build(rson);
//     }
//     void pushdown(int root)
//     {
//         ll c = lz[root];
//         tr[root << 1] += c, tr[root << 1 | 1] += c;
//         lz[root << 1] += c, lz[root << 1 | 1] += c;
//         lz[root] = 0;
//     }
//     void update(int L, int R, ll val, int root, int l, int r)
//     {
//         if (L <= l && r <= R)
//         {
//             tr[root] += val;
//             lz[root] += val;
//             return;
//         }
//         if (lz[root])
//             pushdown(root);
//         int midd = (l + r) >> 1;
//         if (L <= midd)
//             update(L, R, val, lson);
//         if (R > midd)
//             update(L, R, val, rson);
//         tr[root] = min(tr[root << 1], tr[root << 1 | 1]);
//     }
//     ll search(int L, int R, int root, int l, int r)
//     {
//         if (L <= l && r <= R)
//         {
//             return tr[root];
//         }
//         if (lz[root])
//             pushdown(root);
//         ll res = INF;
//         int midd = (l + r) >> 1;
//         if (L <= midd)
//             res = min(res, search(L, R, lson));
//         if (R > midd)
//             res = min(res, search(L, R, rson));
//         return res;
//     }
// } x, y;

// int main()
// {
//     int n, m;
//     scanf("%d%d", &n, &m);
//     x.build(1, 1, m), y.build(1, 1, m);
//     for (int i = 1; i <= m; i++)
//         y.update(i, i, -i, 1, 1, m);
//     for (int i = 1; i <= n; i++)
//     {
//         int a, b;
//         scanf("%d%d", &a, &b);
//         ///b+1
//         x.update(b + 1, b + 1, min(1ll * (b + 1 + y.search(1, b, 1, 1, m)) - x.search(b + 1, b + 1, 1, 1, m), 0ll), 1, 1, m);
//         y.update(b + 1, b + 1, min(y.search(1, b, 1, 1, m) - y.search(b + 1, b + 1, 1, 1, m), 0ll), 1, 1, m);
//         ///a~b
//         x.update(a, b, 1e9, 1, 1, m);
//         y.update(a, b, 1e9, 1, 1, m);
//         ///向下
//         x.update(1, m, 1, 1, 1, m);
//         y.update(1, m, 1, 1, 1, m);
//         ll ans = x.search(1, m, 1, 1, m);
//         if (ans >= 1e9)
//             puts("-1");
//         else
//             printf("%lld\n", ans);
//     }
//     return 0;

#include <bits/stdc++.h>

using namespace std;
typedef long long LL;

const LL inf = 1e18;
const int MAXN = 2e5 + 5;
struct Segtree
{
    struct node
    {
        int l, r;
        LL mx, lazy;
    } tree[MAXN * 3];
    LL a[MAXN]; //you can put the num to this first
    inline void push_down(int i)
    {
        if (tree[i].lazy != 0)
        {
            tree[i * 2].lazy += tree[i].lazy;
            tree[i * 2 + 1].lazy += tree[i].lazy;
            int mid = (tree[i].l + tree[i].r) >> 1;
            tree[i * 2].mx += tree[i].lazy;
            tree[i * 2 + 1].mx += tree[i].lazy;
            tree[i].lazy = 0;
        }
    }
    inline void build(int i, int l, int r)
    {
        tree[i].l = l;
        tree[i].r = r;
        tree[i].lazy = 0;
        if (l == r)
        {
            tree[i].mx = a[l];
            return;
        }
        int mid = (l + r) >> 1;
        build(i * 2, l, mid);
        build(i * 2 + 1, mid + 1, r);
        tree[i].mx = std::min(tree[i * 2].mx, tree[i * 2 + 1].mx);
    }
    inline void add(int i, int l, int r, LL k)
    {
        if (tree[i].l >= l && tree[i].r <= r)
        {
            tree[i].mx += k;
            tree[i].lazy += k;
            return;
        }
        if (tree[i].r < l || tree[i].l > r)
            return;
        push_down(i);
        if (tree[i * 2].r >= l)
            add(i * 2, l, r, k);
        if (tree[i * 2 + 1].l <= r)
            add(i * 2 + 1, l, r, k);
        tree[i].mx = std::min(tree[i * 2].mx, tree[i * 2 + 1].mx);
    }
    inline LL search(int i, int l, int r)
    {
        if (tree[i].l >= l && tree[i].r <= r)
        {
            return tree[i].mx;
        }
        if (tree[i].r < l || tree[i].l > r)
            return 0;
        push_down(i);
        LL ans = inf;
        if (tree[i * 2].r >= l)
            ans = std::min(ans, search(i * 2, l, r));
        if (tree[i * 2 + 1].l <= r)
            ans = std::min(ans, search(i * 2 + 1, l, r));
        return ans;
    }
} t1, t2;
int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    t1.build(1, 1, m), t2.build(1, 1, m);
    for (int i = 1; i <= m; i++)
        t2.add(1,i, i, -i);
    for (int i = 1; i <= n; i++)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        ///b+1
        t1.add(1, b + 1, b + 1, min(1ll * (b + 1 + t2.search(1, 1, b)) - t1.search(1, b + 1, b + 1), 0ll));
        t2.add(1, b + 1, b + 1, min(t2.search(1,1, b) - t2.search(1,b + 1, b + 1), 0ll));
        ///a~b
        t1.add(1, a, b, 1e9);
        t2.add(1, a, b, 1e9);
        ///向下
        t1.add(1, 1, m, 1);
        t2.add(1, 1, m, 1);
        LL ans = t1.search(1, 1, m);
        if (ans >= 1e9)
            puts("-1");
        else
            printf("%lld\n", ans);
    }
    // int T;
    // cin >> T;
}

Measured memory_bytes: 28348