#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
using ll = long long;
using ld = long double;
const ll INF = (1ll<<61) - 1;
#define all(p) p.begin(),p.end()
template<class T> bool chmin(T &a,T b){
    if(a>b){
        a=b;
        return true;
    }
    return false;
}

template<class T> bool chmax(T &a,T b){
    if(a<b){
        a=b;
        return true;
    }
    return false;
}

namespace atcoder {

    namespace internal {

        // @param n `0 <= n`
        // @return minimum non-negative `x` s.t. `n <= 2**x`
        int ceil_pow2(int n) {
            int x = 0;
            while ((1U << x) < (unsigned int)(n)) x++;
            return x;
        }

        // @param n `1 <= n`
        // @return minimum non-negative `x` s.t. `(n & (1 << x)) != 0`
        int bsf(unsigned int n) {
#ifdef _MSC_VER
            unsigned long index;
            _BitScanForward(&index, n);
            return index;
#else
            return __builtin_ctz(n);
#endif
        }

    }  // namespace internal

    template <class S,
             S (*op)(S, S),
             S (*e)(),
             class F,
             S (*mapping)(F, S),
             F (*composition)(F, F),
             F (*id)()>
    struct lazy_segtree {
    public:
        lazy_segtree() : lazy_segtree(0) {}
        lazy_segtree(int n) : lazy_segtree(std::vector<S>(n, e())) {}
        lazy_segtree(const std::vector<S>& v) : _n(int(v.size())) {
            log = internal::ceil_pow2(_n);
            size = 1 << log;
            d = std::vector<S>(2 * size, e());
            lz = std::vector<F>(size, id());
            for (int i = 0; i < _n; i++) d[size + i] = v[i];
            for (int i = size - 1; i >= 1; i--) {
                update(i);
            }
        }

        void set(int p, S x) {
            assert(0 <= p && p < _n);
            p += size;
            for (int i = log; i >= 1; i--) push(p >> i);
            d[p] = x;
            for (int i = 1; i <= log; i++) update(p >> i);
        }

        S get(int p) {
            assert(0 <= p && p < _n);
            p += size;
            for (int i = log; i >= 1; i--) push(p >> i);
            return d[p];
        }

        S prod(int l, int r) {
            assert(0 <= l && l <= r && r <= _n);
            if (l == r) return e();

            l += size;
            r += size;

            for (int i = log; i >= 1; i--) {
                if (((l >> i) << i) != l) push(l >> i);
                if (((r >> i) << i) != r) push(r >> i);
            }

            S sml = e(), smr = e();
            while (l < r) {
                if (l & 1) sml = op(sml, d[l++]);
                if (r & 1) smr = op(d[--r], smr);
                l >>= 1;
                r >>= 1;
            }

            return op(sml, smr);
        }

        S all_prod() { return d[1]; }

        void apply(int p, F f) {
            assert(0 <= p && p < _n);
            p += size;
            for (int i = log; i >= 1; i--) push(p >> i);
            d[p] = mapping(f, d[p]);
            for (int i = 1; i <= log; i++) update(p >> i);
        }
        void apply(int l, int r, F f) {
            assert(0 <= l && l <= r && r <= _n);
            if (l == r) return;

            l += size;
            r += size;

            for (int i = log; i >= 1; i--) {
                if (((l >> i) << i) != l) push(l >> i);
                if (((r >> i) << i) != r) push((r - 1) >> i);
            }

            {
                int l2 = l, r2 = r;
                while (l < r) {
                    if (l & 1) all_apply(l++, f);
                    if (r & 1) all_apply(--r, f);
                    l >>= 1;
                    r >>= 1;
                }
                l = l2;
                r = r2;
            }

            for (int i = 1; i <= log; i++) {
                if (((l >> i) << i) != l) update(l >> i);
                if (((r >> i) << i) != r) update((r - 1) >> i);
            }
        }

        template <bool (*g)(S)> int max_right(int l) {
            return max_right(l, [](S x) { return g(x); });
        }
        template <class G> int max_right(int l, G g) {
            assert(0 <= l && l <= _n);
            assert(g(e()));
            if (l == _n) return _n;
            l += size;
            for (int i = log; i >= 1; i--) push(l >> i);
            S sm = e();
            do {
                while (l % 2 == 0) l >>= 1;
                if (!g(op(sm, d[l]))) {
                    while (l < size) {
                        push(l);
                        l = (2 * l);
                        if (g(op(sm, d[l]))) {
                            sm = op(sm, d[l]);
                            l++;
                        }
                    }
                    return l - size;
                }
                sm = op(sm, d[l]);
                l++;
            } while ((l & -l) != l);
            return _n;
        }

        template <bool (*g)(S)> int min_left(int r) {
            return min_left(r, [](S x) { return g(x); });
        }
        template <class G> int min_left(int r, G g) {
            assert(0 <= r && r <= _n);
            assert(g(e()));
            if (r == 0) return 0;
            r += size;
            for (int i = log; i >= 1; i--) push((r - 1) >> i);
            S sm = e();
            do {
                r--;
                while (r > 1 && (r % 2)) r >>= 1;
                if (!g(op(d[r], sm))) {
                    while (r < size) {
                        push(r);
                        r = (2 * r + 1);
                        if (g(op(d[r], sm))) {
                            sm = op(d[r], sm);
                            r--;
                        }
                    }
                    return r + 1 - size;
                }
                sm = op(d[r], sm);
            } while ((r & -r) != r);
            return 0;
        }

    private:
        int _n, size, log;
        std::vector<S> d;
        std::vector<F> lz;

        void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
        void all_apply(int k, F f) {
            d[k] = mapping(f, d[k]);
            if (k < size) lz[k] = composition(f, lz[k]);
        }
        void push(int k) {
            all_apply(2 * k, lz[k]);
            all_apply(2 * k + 1, lz[k]);
            lz[k] = id();
        }
    };

}  // namespace atcoder
using namespace atcoder;


struct lazy_S {
    ll sum;
    ll val;
};

using lazy_F = int;

lazy_S lazy_op(lazy_S l, lazy_S r) {
    if(l.val>r.val) swap(l,r);
    if(l.val==r.val) l.sum+=r.sum;
    return l;
}

lazy_S lazy_e() { return lazy_S{0, INF}; }

lazy_S mapping(lazy_F l, lazy_S r) {
    r.val+=l;
    return r;
}

//l(r(x))
lazy_F composition(lazy_F l, lazy_F r) {
    return l+r;
}

lazy_F lazy_id(){return 0;}

#define lazy_calc lazy_S,lazy_op,lazy_e,lazy_F,mapping,composition,lazy_id


int main(){
    ll N,W;
    cin>>N>>W;
    vector<ll> X(N),Y(N);
    rep(i,0,N) cin>>X[i]>>Y[i];
    vector<ll> L1(N),R1(N),L2(N),R2(N);
    set<ll> s1,s2;
    map<ll,ll> m1,m2;
    s1.insert(0);
    s2.insert(0);
    s1.insert(W);
    s2.insert(W);
    rep(i,0,N){
        if(Y[i]>W){
            L1[i]=X[i]-Y[i]+W;
            R1[i]=X[i]+Y[i]-W;
        }
        L2[i]=X[i]-Y[i];
        R2[i]=X[i]+Y[i];
        chmax(L1[i],0ll);
        chmax(L2[i],0ll);
        chmin(R1[i],W);
        chmin(R2[i],W);
        //cout<<L1[i]<<" "<<R1[i]<<" "<<L2[i]<<" "<<R2[i]<<endl;
        s1.insert(L1[i]);
        s2.insert(R2[i]);
        s2.insert(L2[i]);
        s1.insert(R1[i]);
    }
    vector<ll> v1,v2;
    for(auto x:s1) m1[x]=m1.size(),v1.push_back(x);
    for(auto x:s2) m2[x]=m2.size(),v2.push_back(x);
    lazy_segtree<lazy_calc> seg1(m1.size()),seg2(m2.size());
    rep(i,0,v1.size()-1) seg1.set(i,{v1[i+1]-v1[i],0});
    rep(i,0,v2.size()-1) seg2.set(i,{v2[i+1]-v2[i],0});
    seg1.set(v1.size()-1,{0,0});
    seg2.set(v2.size()-1,{0,0});
    //rep(i,0,v2.size()) cout<<v2[i]<<" ";
    //cout<<endl;
    set<pair<ll,ll>> ap;
    rep(i,0,N){
        if(!ap.count({X[i],Y[i]})){
            ap.insert({X[i],Y[i]});
            seg1.apply(m1[L1[i]],m1[R1[i]],1);
            seg2.apply(m2[L2[i]],m2[R2[i]],1);
        }
        else{
            ap.erase({X[i],Y[i]});
            seg1.apply(m1[L1[i]],m1[R1[i]],-1);
            seg2.apply(m2[L2[i]],m2[R2[i]],-1);
        }
        //cout<<seg1.all_prod().sum<<" "<<seg2.all_prod().sum<<endl;
        cout<<fixed<<setprecision(20)<<(ld)(seg1.all_prod().sum-seg2.all_prod().sum)*sqrtl(2)<<"\n";
    }
}
/*
5 100
31 41
59 26
31 41
59 26
31 41
 */