#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 29) + 5;
const long long int LLINF = (1ll << 59) + 5;
const int MOD = 1000 * 1000 * 1000 + 7;
const int MAX_N = 1000 * 100 + 5;
const int MAX_K = 305;
struct point {
  int x;
  int y;
};
struct ask {
  int l;
  int r;
  int ptr;
  int type;
};
bool cmp(const ask &a, const ask &b) { return a.ptr < b.ptr; }
int n, k;
point arr[MAX_N];
int cord[MAX_N * 2];
ask asks[MAX_N * 2];
int cord_len = 0;
int asks_len = 0;
bool have_prev_cord[MAX_N * 2];
bool have_prev_line[MAX_N * 2];
int last_of_cord[MAX_N * 2];
int last_of_line[MAX_N * 2];
int at_cord[MAX_N * 2];
int at_line[MAX_N * 2];
long long int answer[MAX_N];
int main() {
  ios_base::sync_with_stdio(false);
  cin >> n >> k;
  for (int i = 0; i < n; ++i) {
    cin >> arr[i].x >> arr[i].y;
    cord[cord_len++] = arr[i].x;
    cord[cord_len++] = arr[i].x - k + 1;
  }
  sort(cord, cord + 2 * n);
  cord_len = unique(cord, cord + 2 * n) - cord;
  for (int i = 0; i < n; ++i) {
    asks[asks_len].l =
        lower_bound(cord, cord + cord_len, arr[i].x - k + 1) - cord;
    asks[asks_len].r = lower_bound(cord, cord + cord_len, arr[i].x) - cord;
    asks[asks_len].ptr = arr[i].y - k + 1;
    asks[asks_len].type = 1;
    ++asks_len;
    asks[asks_len].l = asks[asks_len - 1].l;
    asks[asks_len].r = asks[asks_len - 1].r;
    asks[asks_len].ptr = arr[i].y + 1;
    asks[asks_len].type = -1;
    ++asks_len;
  }
  sort(asks, asks + asks_len, cmp);
  memset(answer, 0, sizeof(answer));
  memset(last_of_cord, 0, sizeof(last_of_cord));
  memset(last_of_line, 0, sizeof(last_of_line));
  memset(at_cord, 0, sizeof(at_cord));
  memset(at_line, 0, sizeof(at_line));
  memset(have_prev_cord, 0, sizeof(have_prev_cord));
  memset(have_prev_line, 0, sizeof(have_prev_cord));
  for (int i = 0; i < asks_len; ++i) {
    for (int j = asks[i].l; j <= asks[i].r; ++j) {
      if (!have_prev_cord[j]) {
        have_prev_cord[j] = true;
        last_of_cord[j] = asks[i].ptr;
        at_cord[j] += asks[i].type;
      } else {
        answer[at_cord[j]] += asks[i].ptr - last_of_cord[j];
        last_of_cord[j] = asks[i].ptr;
        at_cord[j] += asks[i].type;
      }
      if (j != asks[i].r) {
        if (!have_prev_line[j]) {
          have_prev_line[j] = true;
          last_of_line[j] = asks[i].ptr;
          at_line[j] += asks[i].type;
        } else {
          answer[at_line[j]] += 1ll * (cord[j + 1] - cord[j] - 1) *
                                (asks[i].ptr - last_of_line[j]);
          last_of_line[j] = asks[i].ptr;
          at_line[j] += asks[i].type;
        }
      }
    }
  }
  for (int i = 1; i <= n; ++i) {
    cout << answer[i] << ' ';
  }
  cout << endl;
}
