#include <bits/stdc++.h>
using namespace std;
template <typename float_t>
struct _complex_ {
  float_t x, y;
  _complex_<float_t>(float_t _x = 0, float_t _y = 0) : x(_x), y(_y) {}
  float_t real() const { return x; }
  void real(float_t _x) { x = _x; }
  float_t imag() const { return y; }
  void imag(float_t _y) { y = _y; }
  _complex_<float_t> &operator+=(const _complex_<float_t> &other) {
    x += other.x;
    y += other.y;
    return *this;
  }
  _complex_<float_t> &operator-=(const _complex_<float_t> &other) {
    x -= other.x;
    y -= other.y;
    return *this;
  }
  _complex_<float_t> operator+(const _complex_<float_t> &other) const {
    return _complex_<float_t>(*this) += other;
  }
  _complex_<float_t> operator-(const _complex_<float_t> &other) const {
    return _complex_<float_t>(*this) -= other;
  }
  _complex_<float_t> operator*(const _complex_<float_t> &other) const {
    return {x * other.x - y * other.y, x * other.y + other.x * y};
  }
  _complex_<float_t> operator*(float_t mult) const {
    return {x * mult, y * mult};
  }
};
template <typename float_t>
_complex_<float_t> conj(const _complex_<float_t> &c) {
  return {c.x, -c.y};
}
template <typename float_t>
_complex_<float_t> polar(float_t magnitude, float_t angle) {
  return {magnitude * cos(angle), magnitude * sin(angle)};
}
template <typename float_t>
ostream &operator<<(ostream &stream, const _complex_<float_t> &c) {
  return stream << '(' << c.x << ", " << c.y << ')';
}
const int mod = 1e9 + 7;
const long long inf = 9223372036854775807;
struct query {
  int y, pos, type;
  query(int a, int b, int c) { y = a, pos = b, type = c; }
};
bool query_sort(const query &a, const query &b) {
  if ((a.y ^ b.y)) {
    return (a.y < b.y);
  }
  return (a.pos ^ b.pos) ? (a.pos < b.pos) : (a.type < b.type);
}
int n, k;
int x_coor[300 * 100001], y_coor[300 * 100001], sorted_x[100001];
long long ans[100001];
map<int, int> pos;
signed main() {
  cin >> n >> k;
  for (int i = 0; i < n; ++i) {
    cin >> x_coor[i] >> y_coor[i];
    sorted_x[i] = x_coor[i];
  }
  sort(sorted_x, sorted_x + n);
  int oniichan = 0;
  sorted_x[n] = mod;
  for (int i = 0; i < n; ++i) {
    if (sorted_x[i] ^ sorted_x[i + 1]) {
      pos[sorted_x[i]] = oniichan + 1;
      oniichan += min(sorted_x[i] + k, sorted_x[i + 1]) - sorted_x[i];
    }
  }
  vector<query> q;
  for (int i = 0; i < n; ++i) {
    q.push_back(query(y_coor[i], pos[x_coor[i]], 1));
    q.push_back(query(y_coor[i] + k, pos[x_coor[i]], -1));
  }
  sort((q).begin(), (q).end(), query_sort);
  memset(x_coor, 0, sizeof(x_coor));
  memset(y_coor, 0, sizeof(y_coor));
  for (query &i : q) {
    for (int j = i.pos; j < i.pos + k; ++j) {
      ans[y_coor[j]] += i.y - x_coor[j];
      y_coor[j] += i.type;
      x_coor[j] = i.y;
    }
  }
  for (int i = 1; i < n + 1; ++i) cout << ans[i] << ' ';
  return 0;
}
