#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
bool chmin(T1 &a, T2 b) {
  return b < a && (a = b, true);
}
template <class T1, class T2>
bool chmax(T1 &a, T2 b) {
  return a < b && (a = b, true);
}
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
using P = pair<ll, ll>;
using ld = long double;
using vld = vector<ld>;
using vi = vector<int>;
using vvi = vector<vi>;
vll conv(vi &v) {
  vll r(v.size());
  for (long long i = 0; i < (long long)(v.size()); i++) r[i] = v[i];
  return r;
}
inline void input(int &v) {
  v = 0;
  char c = 0;
  int p = 1;
  while (c < '0' || c > '9') {
    if (c == '-') p = -1;
    c = getchar();
  }
  while (c >= '0' && c <= '9') {
    v = (v << 3) + (v << 1) + c - '0';
    c = getchar();
  }
  v *= p;
}
template <typename T, typename U>
ostream &operator<<(ostream &o, const pair<T, U> &v) {
  o << "(" << v.first << ", " << v.second << ")";
  return o;
}
template <size_t...>
struct seq {};
template <size_t N, size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
template <size_t... Is>
struct gen_seq<0, Is...> : seq<Is...> {};
template <class Ch, class Tr, class Tuple, size_t... Is>
void print_tuple(basic_ostream<Ch, Tr> &os, Tuple const &t, seq<Is...>) {
  using s = int[];
  (void)s{0, (void(os << (Is == 0 ? "" : ", ") << get<Is>(t)), 0)...};
}
template <class Ch, class Tr, class... Args>
auto operator<<(basic_ostream<Ch, Tr> &os, tuple<Args...> const &t)
    -> basic_ostream<Ch, Tr> & {
  os << "(";
  print_tuple(os, t, gen_seq<sizeof...(Args)>());
  return os << ")";
}
ostream &operator<<(ostream &o, const vvll &v) {
  for (long long i = 0; i < (long long)(v.size()); i++) {
    for (long long j = 0; j < (long long)(v[i].size()); j++)
      o << v[i][j] << " ";
    o << endl;
  }
  return o;
}
template <typename T>
ostream &operator<<(ostream &o, const vector<T> &v) {
  o << '[';
  for (long long i = 0; i < (long long)(v.size()); i++)
    o << v[i] << (i != v.size() - 1 ? ", " : "");
  o << "]";
  return o;
}
template <typename T>
ostream &operator<<(ostream &o, const deque<T> &v) {
  o << '[';
  for (long long i = 0; i < (long long)(v.size()); i++)
    o << v[i] << (i != v.size() - 1 ? ", " : "");
  o << "]";
  return o;
}
template <typename T>
ostream &operator<<(ostream &o, const set<T> &m) {
  o << '[';
  for (auto it = m.begin(); it != m.end(); it++)
    o << *it << (next(it) != m.end() ? ", " : "");
  o << "]";
  return o;
}
template <typename T>
ostream &operator<<(ostream &o, const unordered_set<T> &m) {
  o << '[';
  for (auto it = m.begin(); it != m.end(); it++)
    o << *it << (next(it) != m.end() ? ", " : "");
  o << "]";
  return o;
}
template <typename T, typename U>
ostream &operator<<(ostream &o, const map<T, U> &m) {
  o << '[';
  for (auto it = m.begin(); it != m.end(); it++)
    o << *it << (next(it) != m.end() ? ", " : "");
  o << "]";
  return o;
}
template <typename T, typename U, typename V>
ostream &operator<<(ostream &o, const unordered_map<T, U, V> &m) {
  o << '[';
  for (auto it = m.begin(); it != m.end(); it++) o << *it;
  o << "]";
  return o;
}
vector<int> range(const int x, const int y) {
  vector<int> v(y - x + 1);
  iota(v.begin(), v.end(), x);
  return v;
}
template <typename T>
istream &operator>>(istream &i, vector<T> &o) {
  for (long long j = 0; j < (long long)(o.size()); j++) i >> o[j];
  return i;
}
template <typename T, typename S, typename U>
ostream &operator<<(ostream &o, const priority_queue<T, S, U> &v) {
  auto tmp = v;
  while (tmp.size()) {
    auto x = tmp.top();
    tmp.pop();
    o << x << " ";
  }
  return o;
}
template <typename T>
ostream &operator<<(ostream &o, const queue<T> &v) {
  auto tmp = v;
  while (tmp.size()) {
    auto x = tmp.front();
    tmp.pop();
    o << x << " ";
  }
  return o;
}
template <typename T>
ostream &operator<<(ostream &o, const stack<T> &v) {
  auto tmp = v;
  while (tmp.size()) {
    auto x = tmp.top();
    tmp.pop();
    o << x << " ";
  }
  return o;
}
template <typename T>
unordered_map<T, ll> counter(vector<T> vec) {
  unordered_map<T, ll> ret;
  for (auto &&x : vec) ret[x]++;
  return ret;
};
string substr(string s, P x) { return s.substr(x.first, x.second - x.first); }
void vizGraph(vvll &g, int mode = 0, string filename = "out.png") {
  ofstream ofs("./out.dot");
  ofs << "digraph graph_name {" << endl;
  set<P> memo;
  for (long long i = 0; i < (long long)(g.size()); i++)
    for (long long j = 0; j < (long long)(g[i].size()); j++) {
      if (mode && (memo.count(P(i, g[i][j])) || memo.count(P(g[i][j], i))))
        continue;
      memo.insert(P(i, g[i][j]));
      ofs << "    " << i << " -> " << g[i][j]
          << (mode ? " [arrowhead = none]" : "") << endl;
    }
  ofs << "}" << endl;
  ofs.close();
  system(((string) "dot -T png out.dot >" + filename).c_str());
}
size_t random_seed;
namespace std {
using argument_type = P;
template <>
struct hash<argument_type> {
  size_t operator()(argument_type const &x) const {
    size_t seed = random_seed;
    seed ^= hash<ll>{}(x.first);
    seed ^= (hash<ll>{}(x.second) << 1);
    return seed;
  }
};
};  // namespace std
struct timeval start;
double sec() {
  struct timeval tv;
  gettimeofday(&tv, NULL);
  return (tv.tv_sec - start.tv_sec) + (tv.tv_usec - start.tv_usec) * 1e-6;
}
struct init_ {
  init_() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    gettimeofday(&start, NULL);
    struct timeval myTime;
    struct tm *time_st;
    gettimeofday(&myTime, NULL);
    time_st = localtime(&myTime.tv_sec);
    srand(myTime.tv_usec);
    random_seed = RAND_MAX / 2 + rand() / 2;
  }
} init__;
template <int N>
class FID {
  static const int bucket = 512, block = 16;
  static char popcount[];
  int n, B[N / bucket + 10];
  unsigned short bs[N / block + 10] = {};
  unsigned short b[N / block + 10] = {};

 public:
  FID() {}
  FID(int n, bool s[]) : n(n) {
    if (!popcount[1])
      for (int i = 0; i < (1 << block); i++)
        popcount[i] = __builtin_popcount(i);
    bs[0] = B[0] = b[0] = 0;
    for (int i = 0; i < n; i++) {
      if (i % block == 0) {
        bs[i / block + 1] = 0;
        if (i % bucket == 0) {
          B[i / bucket + 1] = B[i / bucket];
          b[i / block + 1] = b[i / block] = 0;
        } else
          b[i / block + 1] = b[i / block];
      }
      bs[i / block] |= short(s[i]) << (i % block);
      b[i / block + 1] += s[i];
      B[i / bucket + 1] += s[i];
    }
    if (n % bucket == 0) b[n / block] = 0;
  }
  int count(bool val, int r) {
    return val ? B[r / bucket] + b[r / block] +
                     popcount[bs[r / block] & ((1 << (r % block)) - 1)]
               : r - count(1, r);
  }
  int count(bool val, int l, int r) { return count(val, r) - count(val, l); }
  int select(bool val, int i) {
    if (i < 0 or count(val, n) <= i) return -1;
    i++;
    int lb = 0, ub = n, md;
    while (ub - lb > 1) {
      md = (lb + ub) >> 1;
      if (count(val, md) >= i)
        ub = md;
      else
        lb = md;
    }
    return ub - 1;
  }
  int select(bool val, int i, int l) { return select(val, i + count(val, l)); }
  bool operator[](int i) { return bs[i / block] >> (i % block) & 1; }
  void print(void) {
    for (long long i = 0; i < (long long)(1 + (N - 1) / block); i++) {
      cout << bits_to_string(
                  bs[i],
                  (i != (N - 1) / block ? 16 : N - (N - 1) / block * block))
           << " ";
    }
    cout << endl;
  }
};
template <int N>
char FID<N>::popcount[1 << FID<N>::block];
template <class T, int N, int D>
class wavelet {
  int n, zs[D];
  FID<N> dat[D];

 public:
  wavelet(void) {}
  wavelet(int n, T seq[]) : n(n) {
    T f[N], l[N], r[N];
    bool b[N];
    memcpy(f, seq, sizeof(T) * n);
    for (int d = 0; d < D; d++) {
      int lh = 0, rh = 0;
      for (int i = 0; i < n; i++) {
        bool k = (f[i] >> (D - d - 1)) & 1;
        if (k)
          r[rh++] = f[i];
        else
          l[lh++] = f[i];
        b[i] = k;
      }
      dat[d] = FID<N>(n, b);
      zs[d] = lh;
      swap(l, f);
      memcpy(f + lh, r, rh * sizeof(T));
    }
  }
  void print(void) {
    for (long long i = 0; i < (long long)(D); i++) cout << zs[i] << " ";
    cout << endl;
    for (long long i = 0; i < (long long)(D); i++) dat[i].print();
  }
  T get(int i) {
    T ret = 0;
    bool b;
    for (int d = 0; d < D; d++) {
      ret <<= 1;
      b = dat[d][i];
      ret |= b;
      i = dat[d].count(b, i) + b * zs[d];
    }
    return ret;
  }
  T operator[](int i) { return get(i); }
  int count(T val, int l, int r) {
    for (int d = 0; d < D; d++) {
      bool b = (val >> (D - d - 1)) & 1;
      l = dat[d].count(b, l) + b * zs[d];
      r = dat[d].count(b, r) + b * zs[d];
    }
    return r - l;
  }
  int count(T val, int r) { return count(val, 0, r); }
  int select(T val, int k) {
    int ls[D], rs[D], l = 0, r = n;
    for (int d = 0; d < D; d++) {
      ls[d] = l;
      rs[d] = r;
      bool b = val >> (D - d - 1) & 1;
      l = dat[d].count(b, l) + b * zs[d];
      r = dat[d].count(b, r) + b * zs[d];
    }
    for (int d = D - 1; d >= 0; d--) {
      bool b = val >> (D - d - 1) & 1;
      k = dat[d].select(b, k, ls[d]);
      if (k >= rs[d] or k < 0) return -1;
      k -= ls[d];
    }
    return k;
  }
  int select(T val, int k, int l) { return select(val, k + count(val, l)); }
  void list_max_dfs(int d, int l, int r, int &k, T val, vector<T> &vs) {
    if (l >= r or !k) return;
    if (d == D) {
      while (l++ < r and k > 0) vs.push_back(val), k--;
      return;
    }
    int lc = dat[d].count(1, l), rc = dat[d].count(1, r);
    list_max_dfs(d + 1, lc + zs[d], rc + zs[d], k, 1ULL << (D - d - 1) | val,
                 vs);
    list_max_dfs(d + 1, l - lc, r - rc, k, val, vs);
  }
  vector<T> list_max(int l, int r, int k) {
    if (r - l < k) k = r - l;
    if (k < 0) return {};
    vector<T> ret;
    list_max_dfs(0, l, r, k, 0, ret);
    return ret;
  }
  T rangemax_dfs(int d, int l, int r, T val, T a, T b) {
    if (r - l <= 0 or val >= b) return -1;
    if (d == D) return val >= a ? val : -1;
    int lc = dat[d].count(1, l), rc = dat[d].count(1, r);
    T ret = rangemax_dfs(d + 1, lc + zs[d], rc + zs[d],
                         1ULL << (D - d - 1) | val, a, b);
    if (~ret) return ret;
    return rangemax_dfs(d + 1, l - lc, r - rc, val, a, b);
  }
  T rangemax(int l, int r, T a, T b) { return rangemax_dfs(0, l, r, 0, a, b); }
  T quantile(int l, int r, int k) {
    if (r - l <= k or k < 0) return -1;
    T ret = 0;
    for (int d = 0; d < D; d++) {
      int lc = dat[d].count(1, l), rc = dat[d].count(1, r);
      if (rc - lc > k) {
        l = lc + zs[d], r = rc + zs[d];
        ret |= 1ULL << (D - d - 1);
      } else {
        k -= rc - lc;
        l -= lc, r -= rc;
      }
    }
    return ret;
  }
  T min(int l, int r) { return quantile(l, r, 0); }
  T max(int l, int r) { return quantile(l, r, r - l - 1); }
  void list_freq_dfs(int d, int l, int r, T val, T a, T b,
                     vector<pair<T, int>> &vs) {
    if (val >= b or r - l <= 0) return;
    if (d == D) {
      if (a <= val) vs.push_back(make_pair(val, r - l));
      return;
    }
    T nv = val | (1LL << (D - d - 1)), nnv = nv | (((1LL << (D - d - 1)) - 1));
    if (nnv < a) return;
    int lc = dat[d].count(1, l), rc = dat[d].count(1, r);
    list_freq_dfs(d + 1, l - lc, r - rc, val, a, b, vs);
    list_freq_dfs(d + 1, lc + zs[d], rc + zs[d], nv, a, b, vs);
  }
  vector<pair<T, int>> list_freq(int l, int r, T a, T b) {
    vector<pair<T, int>> ret;
    list_freq_dfs(0, l, r, 0, a, b, ret);
    return ret;
  }
  vector<pair<int, T>> get_rect(int l, int r, T a, T b) {
    vector<pair<T, int>> res = list_freq(l, r, a, b);
    vector<pair<int, T>> ret;
    for (auto &e : res)
      for (int i = 0; i < e.second; i++)
        ret.push_back(make_pair(select(e.first, i, l), e.first));
    return ret;
  }
  ll freq_dfs(int d, int l, int r, T val, T a, T b) {
    if (l == r) return 0;
    if (d == D) return (a <= val and val < b) ? r - l : 0;
    T nv = 1ULL << (D - d - 1) | val, nnv = ((1ULL << (D - d - 1)) - 1) | nv;
    if (nnv < a or b <= val) return 0;
    if (a <= val and nnv < b) return r - l;
    int lc = dat[d].count(1, l), rc = dat[d].count(1, r);
    return freq_dfs(d + 1, l - lc, r - rc, val, a, b) +
           freq_dfs(d + 1, lc + zs[d], rc + zs[d], nv, a, b);
  }
  ll freq(int l, int r, T a, T b) { return freq_dfs(0, l, r, 0, a, b); }
};
class PointCloud2D {
  ll countBrutal(ll ax, ll ay, ll bx, ll by) {
    if (ax > bx || ay > by) return 0;
    ll ret = 0;
    for (long long i = 0; i < (long long)(n); i++) {
      ret += (ax <= xy[i].first && xy[i].first <= bx && ay <= xy[i].second &&
              xy[i].second <= by);
    }
    return ret;
  }

 public:
  ll n;
  ll *data;
  wavelet<ll, 200000, 18> w;
  vector<P> xy;
  vll sx, ty;
  map<ll, ll> xs;
  map<ll, ll> yt;
  void insert(ll x, ll y) { xy.push_back(P(x, y)); }
  void build(void) {
    xy.push_back(P(2ll * (ll)1e18, 2ll * (ll)1e18));
    n = xy.size();
    data = new ll[200000];
    sx.resize(n), ty.resize(n);
    sort((xy).begin(), (xy).end(),
         [&](P &x, P &y) { return x.second < y.second; });
    for (long long i = 0; i < (long long)(n); i++)
      if (!yt.count(xy[i].second)) {
        ll tmp = yt.size();
        yt[xy[i].second] = tmp;
        ty[tmp] = xy[i].second;
      }
    sort((xy).begin(), (xy).end());
    for (long long i = 0; i < (long long)(n); i++) sx[i] = xy[i].first;
    for (long long i = 0; i < (long long)(n); i++)
      if (!xs.count(xy[i].first)) xs[xy[i].first] = i;
    for (long long i = 0; i < (long long)(n); i++) {
      data[i] = yt[xy[i].second];
    }
    w = wavelet<ll, 200000, 18>(n, data);
  }
  ll count(ll ax, ll ay, ll bx, ll by) {
    if (ax > bx || ay > by) return 0;
    ll as = xs.lower_bound(ax)->second;
    ll bs = xs.upper_bound(bx)->second;
    ll at = yt.lower_bound(ay)->second;
    ll bt = yt.upper_bound(by)->second;
    ll ret = w.freq(as, bs, at, bt);
    return ret;
  }
  PointCloud2D(void) {}
};
int main(void) {
  ll n, m;
  cin >> n >> m;
  PointCloud2D pc;
  for (long long i = 0; i < (long long)(n); i++) {
    ll l, r;
    cin >> l >> r;
    pc.insert(l, r);
  }
  pc.build();
  for (long long d = (long long)(1); d < (long long)(m + 1); d++) {
    ll ret = 0;
    for (ll k = 0; k * d < m + 10; k++) {
      ret += pc.count((k - 1) * d + 1, k * d, k * d, (ll)1e18);
    }
    cout << ret << endl;
  }
  return 0;
}
