#include <bits/stdc++.h>
#define int long long
#define lint long long
#define pii pair<int,int>
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(c) (c).begin(),(c).end()
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
#define MINF(a) memset(a,0x3f,sizeof(a))
#define POW(n) (1LL<<(n))
#define IN(i,a,b) (a <= i && i <= b)
using namespace std;
template <typename T> inline bool CHMIN(T& a,T b) { if(a>b) { a=b; return 1; } return 0; }
template <typename T> inline bool CHMAX(T& a,T b) { if(a<b) { a=b; return 1; } return 0; }
template <typename T> inline void SORT(T& a) { sort(ALL(a)); }
template <typename T> inline void REV(T& a) { reverse(ALL(a)); }
template <typename T> inline void UNI(T& a) { sort(ALL(a)); a.erase(unique(ALL(a)),a.end()); }
template <typename T> inline T LB(vector<T>& v, T a) { return *lower_bound(ALL(v),a); }
template <typename T> inline int LBP(vector<T>& v, T a) { return lower_bound(ALL(v),a) - v.begin(); }
template <typename T> inline T UB(vector<T>& v, T a) { return *upper_bound(ALL(v),a); }
template <typename T> inline int UBP(vector<T>& v, T a) { return upper_bound(ALL(v),a) - v.begin(); }
template <typename T1, typename T2> ostream& operator<< (ostream& os, const pair<T1,T2>& p) { os << p.first << " " << p.second; return os; }
template <typename T1, typename T2> istream& operator>> (istream& is, pair<T1,T2>& p) { is >> p.first >> p.second; return is; }
template <typename T> ostream& operator<< (ostream& os, const vector<T>& v) { REP(i,v.size()) { if (i) os << " "; os << v[i]; } return os; }
template <typename T> istream& operator>> (istream& is, vector<T>& v) { for(T& in : v) is >> in; return is; }
template <typename T = int> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) { return vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...)); }
template <typename T, typename V> typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) { t = v; }
template <typename T, typename V> typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) { for(auto &e : t) fill_v(e,v); }
const lint MOD = 1000000007;
const lint INF = 0x3f3f3f3f3f3f3f3f;
const double EPS = 1e-10;

template <typename M, typename OM = M>
struct LazySegmentTree {
	using F = function< M(M, M) >;
	using G = function< M(M, OM) >;
	using H = function< OM(OM, OM) >;
	using P = function< OM(OM, int) >;
	int n, lev;
	F f;
	G g;
	H h;
	P p;
	M M1;
	OM OM0;
	vector<M> d;
	vector<OM> lz;
	LazySegmentTree() {}
	LazySegmentTree(F f, G g, H h, M M1, OM OM0, 
		P p = [](OM a, int b) { return a; }):
		f(f), g(g), h(h), M1(M1), OM0(OM0), p(p) {}
	void init(int n_)
	{
		for (n = 1, lev = 0; n < n_; n <<= 1, lev++);
		d.assign(n << 1, M1);
		lz.assign(n << 1, OM0);
	}
	void build(const vector<M>& v)
	{
		int n_ = v.size();
		init(n_);
		for (int i = 0; i < n_; i++) {
			d[n + i] = v[i];
		}
		for (int i = n - 1; i > 0; i--) {
			d[i] = f(d[(i << 1) | 0], d[(i << 1) | 1]);
		}
	}
	inline M reflect(int k, int len)
	{
		return lz[k] == OM0 ? d[k] : g(d[k], p(lz[k], len));
	}
	inline void eval(int k, int len)
	{
		if (lz[k] == OM0) return;
		lz[(k << 1) | 0] = h(lz[(k << 1) | 0], lz[k]);
		lz[(k << 1) | 1] = h(lz[(k << 1) | 1], lz[k]);
		d[k] = reflect(k, len);
		lz[k] = OM0;
	}
	inline void thrust(int k)
	{
		for (int i = lev; i > 0; i--) {
			eval(k >> i, n >> (lev - i));
		}
	}
	inline void recalc(int k)
	{
		int len = 1;
		while (k >>= 1, len <<= 1) {
			M lhs = reflect((k << 1) | 0, len >> 1);
			M rhs = reflect((k << 1) | 1, len >> 1);
			d[k] = f(lhs, rhs);
		}
	}
	void update(int a, int b, OM x)
	{
		thrust(a += n);
		thrust(b += n - 1);
		for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
			if (l & 1) lz[l] = h(lz[l], x), l++;
			if (r & 1) --r, lz[r] = h(lz[r], x);
		}
		recalc(a);
		recalc(b);
	}
	M query(int a, int b)
	{
		thrust(a += n);
		thrust(b += n - 1);
		M L = M1, R = M1;
		int l = a, r = b + 1, len = 1;
		while (l < r) {
			if (l & 1) L = f(L, reflect(l++, len));
			if (r & 1) R = f(reflect(--r, len), R);
			l >>= 1, r >>= 1, len <<= 1;
		}
		return f(L, R);
	}
	void set(int k, M x)
	{
		thrust(k += n);
		d[k] = x;
		lz[k] = OM0;
		recalc(k);
	}
	M operator[] (int k)
	{
		return query(k, k + 1);
	}
};
template <typename M, typename OM = M>
using LST = LazySegmentTree<M, OM>;

int N, M;
vector<int> v[100010];
int cum[100010];

void _main() {
    cin >> N >> M;
    auto f = [](int a, int b) { return a + b; };
    auto g = [](int a, int b) { return a + b; };
    auto h = [](int a, int b) { return a + b; };
    auto p = [](int a, int b) { return a * b; };
    LST<int> lst(f, g, h, 0, 0, p);
    lst.init(M + 1);
    REP(i, N) {
        int l, r;
        cin >> l >> r;
        v[r - l].push_back(l);
        lst.update(l, r + 1, 1);
    }
    vector<int> ans;
    int cnt = 0;
    for (int d = M; d >= 1; d--) {
        for (int i = 0; i < v[d - 1].size(); ++i) {
            int l = v[d - 1][i];
            int r = l + d - 1;
            lst.update(l, r + 1, -1);
            cnt++;
        }
        int sum = cnt;
        for (int i = d; i <= M; i += d) {
            sum += lst.query(i, i + 1);
        }
        ans.push_back(sum);
    }
    REV(ans);
    REP(i, ans.size()) cout << ans[i] << endl;
}

signed main(signed argc, char **argv) {
    if (argc > 1) {
        freopen("input.txt", "r", stdin);
        freopen("output.txt", "w", stdout);
    }
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(10);
    _main();
    return 0;
}

Measured memory_bytes: 12664