Problem:
Score : 700 points

Problem Statement

Snuke has decided to play a game, where the player runs a railway company.
There are M+1 stations on Snuke Line, numbered 0 through M.
A train on Snuke Line stops at station 0 and every d-th station thereafter, where d is a predetermined constant for each train.
For example, if d = 3, the train stops at station 0, 3, 6, 9, and so forth.

There are N kinds of souvenirs sold in areas around Snuke Line. The i-th kind of souvenirs can be purchased when the train stops at one of the following stations: stations l_i, l_i+1, l_i+2, ..., r_i.

There are M values of d, the interval between two stops, for trains on Snuke Line: 1, 2, 3, ..., M.
For each of these M values, find the number of the kinds of souvenirs that can be purchased if one takes a train with that value of d at station 0.
Here, assume that it is not allowed to change trains.

Constraints

1 ≦ N ≦ 3 × 10^{5}

1 ≦ M ≦ 10^{5}

1 ≦ l_i ≦ r_i ≦ M

Input

The input is given from Standard Input in the following format:

N M
l_1 r_1
:
l_{N} r_{N}

Output

Print the answer in M lines. The i-th line should contain the maximum number of the kinds of souvenirs that can be purchased if one takes a train stopping every i-th station.

Sample Input 1

3 3
1 2
2 3
3 3

Sample Output 1

3
2
2

If one takes a train stopping every station, three kinds of souvenirs can be purchased: kind 1, 2 and 3.

If one takes a train stopping every second station, two kinds of souvenirs can be purchased: kind 1 and 2.

If one takes a train stopping every third station, two kinds of souvenirs can be purchased: kind 2 and 3.

Sample Input 2

7 9
1 7
5 9
5 7
5 9
1 1
6 8
3 4

Sample Output 2

7
6
6
5
4
5
5
3
2

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <cstdio>
#include <algorithm>

using namespace std;

#define REP(i,n)   for(int i=0; i<(int)(n); i++)
#define FOR(i,b,e) for(int i=(b); i<=(int)(e); i++)
#define DUMP(a, n) REP(i, n) printf("%d%c", a[i], i + 1 == n ? '\n' : ' ')

//------------------------------------------------------------------------------
#define SZ      (sz * 2 - 1)
#define LF(i)   (i + sz - 1)
#define PA(k)   ((k - 1) / 2)
#define LC(k)   (k * 2 + 1)
#define RC(k)   (k * 2 + 2)
#define M(l,r)  ((l + r) / 2)

const int ST_SIZE = 1 << 18;    // N_MAX * 2 - 1

int sz;
int dat[ST_SIZE];

void rmq_init(int n) {
  sz = 1;
  while (sz < n) sz <<= 1;
}

int query(int i) {
  int k = LF(i);
  int ret = dat[k];
  while (k > 0) {
    k = PA(k);
    ret += dat[k];
  }
  return ret;
}

void add_sub(int a, int b, int k, int l, int r) {
  if (r <= a || b <= l) return;
  if (a <= l && r <= b) dat[k]++;
  else {
    add_sub(a, b, LC(k), l, M(l, r));
    add_sub(a, b, RC(k), M(l, r), r);
  }
}

void add(int a, int b) {
  add_sub(a, b, 0, 0, sz);
}

//------------------------------------------------------------------------------
const int N_MAX = 300000;
const int M_MAX = 100000;

struct rng { int w, l, r; };
int N, M;
rng a[N_MAX];

bool compare_w(const rng& r1, const rng& r2) {
  return r1.w < r2.w;
}

void solve() {
  sort(a, a + N, compare_w);
  rmq_init(M + 1);
  int i = 0;
  FOR(d, 1, M) {
    while (i < N && a[i].w < d) {
      // printf("w: %d, l:%d, r: %d\n", a[i].w, a[i].l, a[i].r);
      add(a[i].l, a[i].r + 1);
      // DUMP(dat, SZ);
      i++;
    }
    int ans = N - i;
    if (i > 0) {
      for(int e = d; e <= M; e += d) {
        ans += query(e);
      }
    }
    printf("%d\n", ans);
  }
}

void input() {
  scanf("%d%d", &N, &M);
  REP(i, N) {
    int l, r, w;
    scanf("%d%d", &l, &r);
    a[i] = { r - l + 1, l, r };
  }
}

int main() {
  input();
  solve();
  return 0;
}