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 <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;

inline int getint()
{
	static char c;
	while ((c = getchar()) < '0' || c > '9');

	int res = c - '0';
	while ((c = getchar()) >= '0' && c <= '9')
		res = res * 10 + c - '0';
	return res;
}

const int MaxN = 300000;
const int MaxM = 100000;

int n, m;
int sum[MaxM + 2];

struct interval
{
	int l, r;
	interval() {}
	interval(const int &_l, const int &_r)
		: l(_l), r(_r) {}

	inline int length() const
	{
		return r - l + 1;
	}

	friend inline bool operator<(const interval &lhs, const interval &rhs)
	{
		return lhs.r - lhs.l < rhs.r - rhs.l;
	}
};
interval a[MaxN];

int bit[MaxM + 2];

void bit_add(int x, int d)
{
	for (int i = ++x; i <= m + 2; i += i & -i)
		bit[i] += d;
}

int bit_query(int x)
{
	int res = 0;
	for (int i = ++x; i; i ^= i & -i)
		res += bit[i];
	return res;
}

int main()
{
	cin >> n >> m;

	sum[1] = n;
	for (int i = 0; i < n; ++i)
	{
		a[i].l = getint();
		a[i].r = getint();
		--sum[min(m, a[i].r - a[i].l + 1) + 1];
	}

	for (int i = 2; i <= m; ++i)
		sum[i] += sum[i - 1];

	sort(a, a + n);

	int cur = 0;
	for (int i = 1; i <= m; ++i)
	{
		for (int k = 0; k <= m; k += i)
			sum[i] += bit_query(k);

		printf("%d\n", sum[i]);

		while (cur < n && a[cur].length() == i)
		{
			bit_add(a[cur].l, 1);
			bit_add(a[cur].r + 1, -1);
			++cur;
		}
	}

	return 0;
}