//code_board
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef double db;
typedef pair<int,int> pa;
typedef vector<int> vec;
typedef string str;

const int bias = 5;

int T = 1;




class SegmentTree {
private:
    struct Node {
        int left, right;
        int minValue, lazy;
        int minCount;
    };

    vector<Node> tree;

    int n;

    void build(int node, int start, int end) {
        tree[node].left = start;
        tree[node].right = end;
        tree[node].lazy = 0;
        tree[node].minValue = 0;
        tree[node].minCount = end - start + 1;

        if (start == end) {
            // 叶子节点
            tree[node].minValue = 0;
            tree[node].minCount = c[start + 1] - c[start];
            // cout << c[start] << " " << c[start + 1] << endl;
            // cout << "minValue: " << tree[node].minValue << " minCount: " << tree[node].minCount << " start: " << start << " end: " << end << endl;
        } else {
            int mid = (start + end) / 2;
            build(2 * node, start, mid);
            build(2 * node + 1, mid + 1, end);
            tree[node].minValue = min(tree[2 * node].minValue, tree[2 * node + 1].minValue);
            tree[node].minCount = (tree[2 * node].minValue == tree[node].minValue ? tree[2 * node].minCount : 0) +
                                  (tree[2 * node + 1].minValue == tree[node].minValue ? tree[2 * node + 1].minCount : 0);
        }
    }

    void propagate(int node) {
        if (tree[node].lazy != 0) {
            tree[node].minValue += tree[node].lazy;
            if (tree[node].left != tree[node].right) {
                tree[2 * node].lazy += tree[node].lazy;
                tree[2 * node + 1].lazy += tree[node].lazy;
            }
            tree[node].lazy = 0;
        }
    }

    void updateRange(int node, int start, int end, int l, int r, int val) {
        propagate(node);

        if (start > r || end < l) {
            return;
        }

        if (start >= l && end <= r) {
            tree[node].lazy += val;
            propagate(node);
            return;
        }

        int mid = (start + end) / 2;
        updateRange(2 * node, start, mid, l, r, val);
        updateRange(2 * node + 1, mid + 1, end, l, r, val);

        tree[node].minValue = min(tree[2 * node].minValue, tree[2 * node + 1].minValue);
        tree[node].minCount = (tree[2 * node].minValue == tree[node].minValue ? tree[2 * node].minCount : 0) +
                              (tree[2 * node + 1].minValue == tree[node].minValue ? tree[2 * node + 1].minCount : 0);
    }

    pair<int, int> queryRange(int node, int start, int end, int l, int r) {
        propagate(node);

        if (start > r || end < l) {
            return {INT_MAX, 0};
        }

        if (start >= l && end <= r) {
            return {tree[node].minValue, tree[node].minCount};
        }

        int mid = (start + end) / 2;
        auto leftQuery = queryRange(2 * node, start, mid, l, r);
        auto rightQuery = queryRange(2 * node + 1, mid + 1, end, l, r);

        if (leftQuery.first == rightQuery.first) {
            return {leftQuery.first, leftQuery.second + rightQuery.second};
        } else if (leftQuery.first < rightQuery.first) {
            return leftQuery;
        } else {
            return rightQuery;
        }
    }

public:
    vec c;
    SegmentTree(int size) { 
        n = size;
        tree.resize(4 * n);
    }
    
    void init(int size){
        n = size;
        build(1, 0, n - 1);
    }

    void updateRange(int l, int r, int val) {
        updateRange(1, 0, n - 1, l, r, val);
    }

    pair<int, int> queryRange(int l, int r) {
        return queryRange(1, 0, n - 1, l, r);
    }
}Tree(200005);

map<pa,int> mp;


void solve(){
    int n, p;
    cin >> n >> p;
    // Tree.init();
    vector<pa> query(n);
    
    for(int i = 0, a, b; i < n; i++){
        cin >> a >> b;
        int L = max(0, a - b);
        int R = min(p, a + b);
        query[i] = {L, R};
        Tree.c.push_back(L);
        Tree.c.push_back(R);
    }
    Tree.c.push_back(0);
    Tree.c.push_back(p);
    sort(Tree.c.begin(), Tree.c.end());
    Tree.c.erase(unique(Tree.c.begin(), Tree.c.end()), Tree.c.end());
    for(int i = 0; i < query.size(); i++){
        query[i].first = lower_bound(Tree.c.begin(), Tree.c.end(), query[i].first) - Tree.c.begin();
        query[i].second = lower_bound(Tree.c.begin(), Tree.c.end(), query[i].second) - Tree.c.begin();
        // cout << "query: " << query[i].first << " " << query[i].second << endl;
    }

    Tree.init(Tree.c.size() - 1);

    for(int i = 0; i < n; i++){
        if(mp[query[i]] == 0){
            mp[query[i]]++;
            Tree.updateRange(query[i].first, query[i].second - 1, 1);
        }else{
            mp[query[i]]--;
            Tree.updateRange(query[i].first, query[i].second - 1, -1);
        }
        // cout << query[i].first << " " << query[i].second << endl;
        auto ans = Tree.queryRange(0, Tree.c.size() - 2);
        // cout << "ans: " << ans.first << " " << ans.second << endl;
        ans.second = (ans.first == 0)? p - ans.second : p;
        cout << fixed << setprecision(10) << (db) ans.second * sqrt(2) << endl;
    }
}


int main(){

//  freopen(".in","r",stdin);
//  freopen(".out","w",stdout);    
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    // cin >> T;
    while(T--) solve();

    return 0;
}