#include <iostream>
#include <iomanip>
#include <algorithm>
#include <array>
#include <cassert>
#include <utility>
#include <vector>

// 区間加算 & 点取得
template <typename element_t, const element_t id>
class RangeAddTree{
private:
    unsigned int size;
    std::vector<element_t> data;

    static unsigned int lsb(unsigned int x){
        #ifdef __has_builtin
            return __builtin_ctz(x);
        #else 
            unsigned int res = 32;
            if(x << 16){ x <<= 16; res -= 16; }
            if(x << 8){ x <<= 8; res -= 8; }
            if(x << 4){ x <<= 4; res -= 4; }
            if(x << 2){ x <<= 2; res -= 2; }
            return (x >> 31) ? res - 1: res;
        #endif
    }

    static unsigned int msb(unsigned int x){
        #ifdef __has_builtin
            return 31 - __builtin_clz(x);
        #else 
            unsigned int res = 0;
            if(x >> 16) { x >>= 16; res += 16; }
            if(x >> 8) { x >>= 8; res += 8; }
            if(x >> 4) { x >>= 4; res += 4; }
            if(x >> 2) { x >>= 2; res += 2; }
            return res + (x >> 1);
        #endif
    }

    inline void propagate(unsigned int idx){
        // if(idx == 0) return;
        const unsigned int boundary = lsb(idx);
        for(unsigned int i = msb(idx); i > boundary; --i){
            unsigned j = idx >> i;
            data[j << 1] += data[j]; data[(j << 1) | 1U] += data[j];
            data[j] = id;
        }
    }

    void initialize(const std::vector<element_t>& A){
        const unsigned int n = A.size();
        size = 1; while(size < n) size <<= 1;
        data.assign(size << 1, id);
        for(unsigned int i = 0, j = size; i < n; ++i, ++j) data[j] = A[i];
    }
    template <class InputIterator>
    void initialize(const InputIterator first, const InputIterator last){
        const unsigned int n = last - first;
        size = 1; while(size < n) size <<= 1;
        data.assign(size << 1, id);
        InputIterator itr = first;
        for(unsigned int i = size; itr != last; ++i, ++itr) data[i] = *itr;
    }
public:
    // コンストラクタ
    RangeAddTree(const unsigned int n){
        size = 1; while(size < n) size <<= 1;
        data.assign(size << 1, id);
    }
    RangeAddTree(const std::vector<element_t>& A){ initialize(A); }
    template <class InputIterator>
    RangeAddTree(const InputIterator first, const InputIterator last){
        initialize(first, last);
    }

    // 区間更新 : 半開区間[l, r) に値 val を加える (0-indexed)  | 計算量O(logN)
    inline void update(unsigned int l, unsigned int r, const element_t& val){
        if(l >= r) return;
        propagate(l += size); propagate((r += size) - 1);
        while(l < r){
            if(l & 1U) data[l++] += val; l >>= 1;
            if(r & 1U) data[--r] += val; r >>= 1;
        }
    }
    // 点取得 : idx番目の値を取得 (0-indexed) | 計算量 O(logN)
    inline element_t operator [](unsigned int idx) const {
        element_t res = data[idx += size];
        while(idx >>= 1) res += data[idx];
        return res;
    }
    inline element_t at(unsigned int idx) const {
        assert(0 <= idx and idx < size);
        return this[idx];
    }
};



int main(void){
    std::cin.tie(nullptr); std::ios_base::sync_with_stdio(false); 
    std::cout << std::fixed << std::setprecision(16);
    
    int n, m; std::cin >> n >> m;
    std::vector<std::array<int, 3>> A(n);
    for(int i = 0; i < n; ++i){
        std::cin >> A[i][1] >> A[i][2]; ++A[i][2];
        A[i][0] = A[i][2] - A[i][1];
    }
    std::sort(A.begin(), A.end());

    RangeAddTree<int, 0> Rat(m + 1);
    for(int d = 1, idx = 0; d <= m; ++d){
        for(; idx < n and A[idx][0] <= d; ++idx) Rat.update(A[idx][1], A[idx][2], 1);
        int res = n - idx;
        for(int i = 0; i <= m; i += d) res += Rat[i];
        std::cout << res << '\n';
    }
    return 0;
}

Measured memory_bytes: 7684