// Slower C++ solution:
#include <iostream>

#include <cstdio>

#include <cmath>

#include <cstring>

#include <algorithm>

#include <vector>

#include <map>

#include <cstdlib>

#include <set>

#include <stack>

#include <queue>

using namespace std;



#define X first

#define Y second

#define N 300010

#define M 400010

typedef long long ll;

typedef pair<int,int> pii;

const int Mod=1000000007;



int n,m;

int c[N];

vector<pii> g[N];



inline int Lowbit(int x){return x&(-x);}



void Add(int x,int v)

{

	while (x<=m)

	{

		c[x]+=v;

		x+=Lowbit(x);

	}

}



int Val(int x)

{

	int res=0;

	while (x)

	{

		res+=c[x];

		x-=Lowbit(x);

	}

	return res;

}



int main()

{

	//freopen("in.in","r",stdin);

	//freopen("out.out","w",stdout);

	

	scanf("%d%d",&n,&m);

	for (int i=1;i<=n;i++)

	{

		int l,r; scanf("%d%d",&l,&r);

		g[r-l+1].push_back(make_pair(l,r));

	}

	int sz=0;

	for (int i=1;i<=m;i++)

	{

		int x=i,res=0;

		do

		{

			res+=Val(x);

			x+=i;

		}while (x<=m);

		

		for (int j=0;j<g[i].size();j++)

		{

			Add(g[i][j].X,1);

			Add(g[i][j].Y+1,-1);

		}

		printf("%d\n",res+n-sz);

		sz+=g[i].size();

	}

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 9.48014554574697x):
#include<bits/stdc++.h>

using namespace std;

namespace Flandle_Scarlet

{

    #define N 300100

    int n,m;

    class BIT

    {

        public:

            int tree[N];

            int len;

            void BuildTree(int _len)

            {

                len=_len;

            }

            void Add(int pos,int x)

            {

                while(pos<=len)

                {

                    tree[pos]+=x;

                    pos+=(pos&(-pos));

                }

            }

            void RAdd(int l,int r,int x)

            {

                Add(l,x),Add(r+1,-x);

            }

            int Query(int pos)

            {

                int ans=0;

                while(pos>0)

                {

                    ans+=tree[pos];

                    pos-=(pos&(-pos));

                }

                return ans;

            }

    }T;

    struct node

    {

        int l,r;

    }c[N];bool operator<(node a,node b){return a.r-a.l<b.r-b.l;}



    void Input()

    {

        scanf("%d%d",&n,&m);

        for(int i=1;i<=n;++i)

        {

            int l,r;

            scanf("%d%d",&l,&r);

            c[i]=(node){l,r};

        }

        sort(c+1,c+n+1);

    }



    int ans[N];

    void Soviet()

    {

        T.BuildTree(m);

        int now=0;

        for(int d=1;d<=m;++d)

        {

            int ans=n-now;

            for(int i=d;i<=m;i+=d)

            {

                ans+=T.Query(i);

            }

            printf("%d\n",ans);

            while(now<n and c[now+1].r-c[now+1].l<=d)

            {

                T.RAdd(c[now+1].l,c[now+1].r,1);

                ++now;

            }

        }

    }

    void IsMyWife()

    {

        if (0)

        {

            freopen("","r",stdin);

            freopen("","w",stdout);

        }

        Input();

        Soviet();

    }

};

int main()

{

    Flandle_Scarlet::IsMyWife();

    return 0;

}