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

using ll = long long;
using ull = unsigned long long;

string to_string(const string &s) {
  return '"' + s + '"';
}

string to_string(bool b) {
  return b ? "true" : "false";
}

template <typename A, typename B>
string to_string(const pair<A, B> &p) {
  return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}

template <typename T>
string to_string(const T &v) {
  string s = "{";
  bool first = true;
  for (const auto &it : v) {
    if (!first)
      s += ", ";
    else
      first = false;
    s += to_string(it);
  }
  return s += "}";
}

void debug_out() {
  cerr << endl;
}

template <typename T, typename... Args>
void debug_out(const T &first, const Args&... rest) {
  cerr << to_string(first) << " ";
  debug_out(rest...);
}

#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

auto startTime = high_resolution_clock::now();
int get_time() {
  auto stopTime = chrono::high_resolution_clock::now();
  auto duration = duration_cast<milliseconds>(stopTime - startTime);
  return duration.count(); // in ms
}

struct nod {
  nod(int x) : l(nullptr), r(nullptr), lzy(0), mn(0), cmn(x) {}
  nod *l, *r;
  int lzy, mn, cmn; 
};

int q, w;

inline void merge(nod *n, int st, int dr, int mij) {
  if (n->l == nullptr && n->r == nullptr) {
    n->mn = 0;
    n->cmn = dr - st + 1;
    return;
  }

  if (n->l == nullptr) {
    n->mn = 0;
    n->cmn = mij - st + 1;

    if (n->r->mn == n->mn)
      n->cmn += n->r->cmn;

    return;
  }

  if (n->r == nullptr) {
    n->mn = 0;
    n->cmn = dr - mij; 

    if (n->l->mn == n->mn)
      n->cmn += n->l->cmn;

    return;
  }

  n->mn = min(n->l->mn, n->r->mn);
  n->cmn = 0;

  if (n->l->mn == n->mn)
    n->cmn += n->l->cmn;

  if (n->r->mn == n->mn)
    n->cmn += n->r->cmn;
}

inline void push(nod *n) {
  if (n->l != nullptr) {
    n->l->lzy += n->lzy;
    n->l->mn += n->lzy;
  }
  
  if (n->r != nullptr) {
    n->r->lzy += n->lzy;
    n->r->mn += n->lzy;
  }

  n->lzy = 0;
}

void update(int x, int y, int v, nod *n, int st = 0, int dr = w - 1) {
  if (x <= st && dr <= y) {
    n->lzy += v;
    n->mn += v;
    return;
  }

  int mij = (st + dr) / 2;

  if (n->lzy != 0) {
    if (n->l == nullptr)
      n->l = new nod(mij - st + 1);

    if (n->r == nullptr)
      n->r = new nod(dr - mij);

    push(n);
  }

  if (x <= mij) {
    if (n->l == nullptr)
      n->l = new nod(mij - st + 1);
    update(x, y, v, n->l, st, mij);
  }

  if (mij + 1 <= y) {
    if (n->r == nullptr)
      n->r = new nod(dr - mij);
    update(x, y, v, n->r, mij + 1, dr);
  }

  merge(n, st, dr, mij);
}

void solve() {
  cin >> q >> w;

  auto root = new nod(w);

  set<pair<int, int>> s;
  for (int i = 1; i <= q; ++i) {
    int x, y;
    cin >> x >> y;

    if (s.find({x, y}) != s.end()) {
      s.erase({x, y});
      update(max(0, x - y), min(w, y + x) - 1, -1, root);
    } else {
      s.insert({x, y});
      update(max(0, x - y), min(w, y + x) - 1, 1, root);
    }

    cout << fixed << setprecision(18) << (w - (root->mn == 0 ? root->cmn : 0)) * sqrt(2.0) << "\n";
  }
}

int main() {
  cin.tie(NULL);
  ios_base::sync_with_stdio(false);

  int t = 1;
//  cin >> t;
  while (t--)
    solve();

  return 0;
}