#include <bits/stdc++.h>
using namespace std;

constexpr int inf = (1 << 30) - 1;

struct Mn {
    int mi;
    int sum;
    
    static Mn id() {
        return Mn{inf, 0};
    }
    Mn operator+(const Mn& t) const {
        const int m = min(mi, t.mi);
        const int s = (mi == m ? sum : 0) + (t.mi == m ? t.sum : 0);
        return {m, s};
    }
};

struct Segtree {
    int size, logn;
    vector<Mn> data;
    vector<int> lazy;

    void fetch(int k) {
        data[k] = data[2 * k] + data[2 * k + 1];
    }
    void apply(int k, int x) {
        data[k].mi += x;
        if (k < size) lazy[k] += x;
    }
    void flush(int k) {
        apply(2 * k, lazy[k]);
        apply(2 * k + 1, lazy[k]);
        lazy[k] = 0;
    }

    void push(int k) {
        const int lsb = countr_zero((unsigned)k);
        for (int d = logn; d > lsb; --d) flush(k >> d);
    }
    void pull(int k) {
        k >>= countr_zero((unsigned)k);
        while (k > 1) fetch(k >>= 1);
    }

    Segtree(const vector<int>& raw) {
        const int n = (int)raw.size();
        logn = 0;
        while ((1 << logn) < n) logn += 1;
        size = 1 << logn;
        data.assign(2 * size, Mn::id());
        lazy.assign(size, 0);
        for (int i = 0; i < n; ++i) {
            data[size + i] = Mn{0, raw[i]};
        }
        for (int k = size - 1; k > 0; --k) {
            fetch(k);
        }
    }

    void apply(int l, int r, int x) {
        l += size;
        r += size;
        push(l);
        push(r);
        const int lc = l;
        const int rc = r;
        while (l < r) {
            if (l & 1) {
                apply(l++, x);
            }
            if (r & 1) {
                apply(--r, x);
            }
            l >>= 1;
            r >>= 1;
        }
        pull(lc);
        pull(rc);
    }

    Mn get() {
        return data[1];
    }
};

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(20);

    int Q, W;
    cin >> Q >> W;

    vector<int> type(Q), L(Q), R(Q);
    {
        set<pair<int, int>> pts;
        for (int i = 0; i < Q; ++i) {
            int x, y;
            cin >> x >> y;
            L[i] = max(0, x - y);
            R[i] = min(W, x + y);
            if (auto itr = pts.find(pair(x, y)); itr != end(pts)) {
                type[i] = -1;
                pts.erase(itr);
            } else {
                type[i] = 1;
                pts.emplace(x, y);
            }
        }
    }

    vector<int> cx;
    cx.reserve(2 * Q + 2);
    cx.push_back(0);
    cx.push_back(W);
    for (int i = 0; i < Q; ++i) {
        cx.push_back(L[i]);
        cx.push_back(R[i]);
    }
    ranges::sort(cx);
    cx.erase(unique(begin(cx), end(cx)), end(cx));
    const int Nx = (int)cx.size();

    vector<int> data(Nx - 1);
    for (int i = 0; i < Nx - 1; ++i) {
        data[i] = cx[i + 1] - cx[i];
    }
    Segtree seg(data);

    for (int i = 0; i < Q; ++i) {
        const int l = lower_bound(begin(cx), end(cx), L[i]) - begin(cx);
        const int r = lower_bound(begin(cx), end(cx), R[i]) - begin(cx);
        seg.apply(l, r, type[i]);
        const Mn mn = seg.get();
        cout << (W - (mn.mi == 0 ? mn.sum : 0)) * sqrt(2) << '\n';
    }

    return 0;
}