stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#include<iostream>

#include<string>

#include<stdio.h>

#include<stdlib.h>

#include<set>

#include<map>

#include<vector>

#include<queue>

#include<cstring>

using namespace std;

#define mp(a,b) make_pair(a,b)

#define pb push_back



int main(){

    long long n,k;

    cin>>n>>k;

    int a[200010], b[200010], c[200010];

    int cnt = 0;

    int start = 1;

    int over = 1;

    memset(a,0,sizeof(a));

    memset(b,0,sizeof(b));

    memset(c,-1,sizeof(c));

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

        cin>>a[i];

    }

    b[0] = 1;

    c[1] = 0;

    while (true){

        //cout<<a[b[cnt]]<<" "<<cnt<<" "<<b[cnt]<<endl;

        long long cur = a[b[cnt]];

        if (c[cur] >= 0){

            start = c[cur];

            over  = cnt;

            break;

        }

        cnt++;

        b[cnt] = cur;

        c[cur] = cnt;

    }

    int total = over - start + 1;

    int ex = (k - start +1) % total;

    //cout<<start<<" "<<over<<" "<<ex<<endl;

    if (k <= over){

         cout<<b[k];

    }else{

        if (ex == 0){

            cout<<b[over];

        }else{

            cout<<b[start - 1 + ex];

        }

    }





//    system("pause");

}


// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

long long n,k,a[200050],tag[200050],cnt;

bool vis[200050];

int main()

{

	cin>>n>>k;

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

		cin>>a[i],a[i]--;

	long long now=0,len=1;

	while(vis[now]!=1)

	{

		vis[now]=1;

		tag[now]=++cnt;

		if(cnt>k)

		{

			cout<<now+1;

			return 0;

		}

		now=a[now];

		len++;

	}

	k-=tag[now];

	k++;

	len=cnt-tag[now]+1;

//	cout<<now<<' '<<len<<' ';

	k%=len;

	for(int i=0;i<k;i++)

	{

		now=a[now];

	}

	cout<<now+1;

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;

vector<int> Edge[200005],vec;

int mark[200005];

void dfs(int u)

{

    vec.push_back(u);

    for(int i=0; i<Edge[u].size(); i++)

    {

        int v=Edge[u][i];

        if(mark[v]==0)

        {

            mark[v]=1;

            dfs(v);

        }

    }

}

int main()

{

    ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);

    ll n,k;

    cin>>n>>k;

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

    {

        ll v;

        cin>>v;

        Edge[i].push_back(v);

    }

    mark[1]=1;

    dfs(1);

    ll len=vec.size();

    if(k<len)

    {

        cout<<vec[k]<<endl;

        return 0;

    }

    ll idx=Edge[vec[len-1]][0];

    memset(mark,0,sizeof(mark));

    vec.clear();

    k-=(len-1);

    mark[idx]=1;

    dfs(idx);

    len=vec.size();

    idx=k%len;

    idx--;

    if(idx==-1)

        idx=len-1;

    cout<<vec[idx]<<endl;





    return 0;

}


// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

#define ll         long long

#define mod        1000000007

#define setbits(x) __builtin_popcountll(x)

#define zrobits(x) __builtin_ctzll(x)

#define inf        1e18

#define ps(x,y)    fixed<<setprecision(y)<<x



int main() {

// #ifndef ONLINE_JUDGE

// 	freopen("input.txt", "r", stdin);

// 	freopen("output.txt", "w", stdout);

// #endif



	ll n, k;

	cin >> n >> k;

	ll a[n + 1];

	a[0] = 0;

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

	{

		cin >> a[i];

	}

	std::vector<ll> v(n + 1, 0);



	ll start = 1;

	int l ;

	while (1)

	{

		if (v[start] == 1)

		{

			l = start;

			break;

		}



		v[start] = 1;

		start = a[start];

		k--;

		if (k == 0)

		{

			cout << start << endl;

			return 0;

		}

	}



	ll cnt = 0;

	int end = start;

	vector<int > v1;

	while (1)

	{



		v1.push_back(start);

		start = a[start];

		cnt++;

		if (start == end)

			break;

	}

	// for (auto i : v1)

	// {

	// 	cout << i << " ";

	// }

	cout << v1[k % cnt] << endl;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const ll inf = 1e9;

#define Fast    ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);

#define sz      200005



ll arr[sz];

int brr[sz];





int main(){

    Fast;

    ll n,k,i;



    cin>>n>>k;

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

        cin>>arr[i];

    }

    memset(brr,0,sizeof(brr));



    i=1;

    while(k && brr[i]==0){

        k--;

        brr[i]=1;

        i=arr[i];

    }

    if(k==0){

        cout<<i<<endl;

        return 0;

    }



    ll cnt=0;

    memset(brr,0,sizeof(brr));

    while(k && brr[i]==0){

        k--;

        cnt++;

        brr[i]=1;

        i=arr[i];

    }

    if(k==0){

        cout<<i<<endl;

        return 0;

    }

    k=k%cnt;

    memset(brr,0,sizeof(brr));

    while(k && brr[i]==0){

        k--;

        brr[i]=1;

        i=arr[i];

    }

    cout<<i<<endl;



    return 0;

}




// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

#define ll         long long

#define mod        1000000007

#define setbits(x) __builtin_popcountll(x)

#define zrobits(x) __builtin_ctzll(x)

#define inf        1e18

#define ps(x,y)    fixed<<setprecision(y)<<x



int main() {

// #ifndef ONLINE_JUDGE

// 	freopen("input.txt", "r", stdin);

// 	freopen("output.txt", "w", stdout);

// #endif



	ll n, k;

	cin >> n >> k;

	ll a[n + 1];

	a[0] = 0;

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

	{

		cin >> a[i];

	}

	std::vector<ll> v(n + 1, 0);



	ll start = 1;

	int l ;

	while (1)

	{

		if (v[start] == 1)

		{

			l = start;

			break;

		}



		v[start] = 1;

		start = a[start];

		k--;

		if (k == 0)

		{

			cout << start << endl;

			return 0;

		}

	}



	ll cnt = 0;

	int end = start;

	vector<int > v1;

	while (1)

	{



		v1.push_back(start);

		start = a[start];

		cnt++;

		if (start == end)

			break;

	}

	// for (auto i : v1)

	// {

	// 	cout << i << " ";

	// }

	cout << v1[k % cnt] << endl;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <cstdio>

#include <cstring>

#include <cmath>

#include <utility>

#include <iostream>

#include <functional>

#include <bitset>

#include <algorithm>

#include <vector>

#include <forward_list>

#include <set>

#include <map>

#include <queue>

#include <deque>

#include <stack>

#include <tuple>

#include <numeric>

#define rep(i, s, g) for ((i) = (s); (i) < (g); ++(i))

using namespace std;

using ll = long long;

using P = pair<ll, ll>;

const ll MOD = 1e9 + 7;

const ll INF = (1ll << 60);



ll c = 0;

vector<ll> a(300000), b;

set<ll> p;

ll z;



void dfs(ll x)

{

    if (p.find(x) != p.end() && c > 0)

    {

        z = x;

        return;

    }



    p.insert(x);

    b.push_back(x);

    c++;

    dfs(a[x]);

}



int main(void)

{

    ll n, k;



    cin >> n >> k;



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

    {

        cin >> a[i];

        a[i]--;

    }



    dfs(0);



    ll t = 0;



    for (int i = 0; i < c; i++)

    {

        if (b[i] == z)

        {

            t = i;

            break;

        }

    }



    if (k - t <= 0)

    {

        cout << b[k] + 1 << endl;

        return 0;

    }



    cout << b[((k - t) % (c - t)) + t] + 1 << endl;

}


// Optimized solution to the same problem (faster):
#include <cstdio>

#include <cstring>

#include <cmath>

#include <utility>

#include <iostream>

#include <functional>

#include <bitset>

#include <algorithm>

#include <vector>

#include <forward_list>

#include <set>

#include <map>

#include <queue>

#include <deque>

#include <stack>

#include <tuple>

#include <numeric>

#define rep(i, s, g) for ((i) = (s); (i) < (g); ++(i))

using namespace std;

using ll = long long;

using P = pair<ll, ll>;

const ll MOD = 1e9 + 7;

const ll INF = (1ll << 60);



int main(void)

{

    ll n, k;

    cin >> n >> k;



    vector<ll> a(n), p;

    map<ll, ll> m;



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

    {

        cin >> a[i];

        a[i]--;

        m[i] = INF;

    }



    ll time = 0;

    ll city = 0;

    ll start, end;



    while (true)

    {

        if (m[city] == INF)

        {

            m[city] = time;

            p.push_back(city);

            city = a[city];

        }

        else

        {

            start = m[city];

            end = time;

            break;

        }



        time++;

    }





    if (start > k)

    {

        cout << p[k] + 1 << endl;

        return 0;

    }



    cout << p[(k - start) % (start - end) + start] + 1 << endl;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<cstdio>

#include<cstring>

#include<vector>

#include<algorithm>

using namespace std;

int n,m,l[310000],r[310000],tree[110000];

vector<int> vec[110000];

void add(int x,int y){

    for (;x<=m;x+=x&-x) tree[x]+=y;

}

int getsum(int x){

    int sum=0;

    for (;x;x-=x&(-x)) sum+=tree[x];

    return sum;

}

int main(){

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

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

        scanf("%d%d",&l[i],&r[i]);

        vec[r[i]-l[i]+1].push_back(i);

    }

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

        int ans=0;

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

            add(l[vec[i][j]],1),add(r[vec[i][j]]+1,-1);

        for (int j=i;j<=m;j+=i) ans+=getsum(j);

        n-=vec[i].size();

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

    }

    return 0;

}

//

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

#define F first

#define S second

using namespace std;

const int N=200003;

int n,m,cnt,f[N],kq[N];

pair< pair<int,int>,int> p[N*17];

void ud(int i)

{

    for (;i<=m*2;i+=(i&-i)) f[i]++;

}

int tv(int i)

{

    int res=0;

    for (;i>0;i-=(i&-i)) res+=f[i];

    return res;

}

int main()

{

   

    ios_base::sync_with_stdio(0);

    cin.tie(0);cout.tie(0);

    cin>>n>>m;

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

    {

        cnt++;

        cin>>p[cnt].S>>p[cnt].F.F;

        p[cnt].F.S=-1;

    }

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

    for (int j=i;j<=m*2;j+=i)

    {

        cnt++;

        p[cnt].F.F=j-1;

        p[cnt].F.S=i;

        p[cnt].S=j-i+1;

    }

    sort(p+1,p+cnt+1);

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

    {

        int cs=p[i].F.S;

        //cout<<p[i].F.F<<" "<<p[i].S<<" "<<p[i].F.S<<"\n";

        if (cs<0) ud(p[i].S);

        else

        {

            kq[cs]+=tv(p[i].F.F)-tv(p[i].S-1);

            //cout<<cs<<" "<<p[i].F.F<<" "<<p[i].S-1<<"\n";

        }

    }

    for (int i=1;i<=m;i++) cout<<n-kq[i]<<"\n";

    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}


// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

using namespace std;

int n,m,f[100005],g[100005];



void zzk(int L,int R){

	for (int k=1,kk,kkk,a,Max,Min; k<=m && k<=R;){

		// k<=kk<=(l-1)/a

		a=(L-1)/k;

		if (a==0) Max=99999999; else Max=(L-1)/a; Min=k-1;

		kk=R/(a+1);

		kk=min(kk,Max); kk=max(kk,Min);

		f[k]++; f[kk+1]--;

		k=Max+1;

	}

}



int main(){

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

	for (int i=1,l,r; i<=n; i++){

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

		zzk(l,r);

	}

	for (int i=1; i<=m; i++) g[i]=g[i-1]+f[i],printf("%d\n",g[i]);

}



/*

3 3

1 2

2 3

3 3



*/

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<set>

#include<map>

#include<stack>

#include<queue>

#include<deque>

#include<cmath>

#include<cstdio>

#include<cctype>

#include<string>

#include<vector>

#include<cstdlib>

#include<cstring>

#include<sstream>

#include<iostream>

#include<algorithm>

#define MAXN 300000

#define MAXM 100000

#define lowbit(x) (x&(-x))



using namespace std;



int n,m;

vector<int>gg[MAXM+80];

struct node{

	int a[MAXM+80];

	void add(int x,int A)

	{

		while(x<=m)

		{

			a[x]+=A;

			x+=lowbit(x);

		}

		return ;

	}

	int S(int x)

	{

		int sum=0;

		while(x)

		{

			sum+=a[x];

			x-=lowbit(x);

		}

		return sum;

	}

}tree;

int main()//You'll know it's a copy.

{

	int i,j,l,r,tmp=0,S;

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

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

	{

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

		gg[r-l+1].push_back(l);

	}

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

	{

		S=0;

		for(j=i;j<=m;j+=i)

			S+=tree.S(j);

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

			tree.add(gg[i][j],-1),tree.add(i+gg[i][j],1);

		printf("%d\n",n-tmp-S);

		tmp+=gg[i].size();

	}

	return 0;

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

using namespace std;

int n,m,f[100005],g[100005];



void zzk(int L,int R){

	for (int k=1,kk,kkk,a,Max,Min; k<=m && k<=R;){

		// k<=kk<=(l-1)/a

		a=(L-1)/k;

		if (a==0) Max=99999999; else Max=(L-1)/a; Min=k-1;

		kk=R/(a+1);

		kk=min(kk,Max); kk=max(kk,Min);

		f[k]++; f[kk+1]--;

		k=Max+1;

	}

}



int main(){

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

	for (int i=1,l,r; i<=n; i++){

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

		zzk(l,r);

	}

	for (int i=1; i<=m; i++) g[i]=g[i-1]+f[i],printf("%d\n",g[i]);

}



/*

3 3

1 2

2 3

3 3



*/

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;



typedef long long ll;

typedef pair<int, int> PII;

typedef pair<int, PII> PIP;



const int MM = 1e9 + 7;

const double eps = 1e-8;

const int MAXN = 2e6 + 10;



int n, m;



void prework(){



}



void read(){



}



vector<PIP> E;



class BITree{

public:

    static const int SIZE = 100010, BIAS = 5;

    long long u[SIZE];

    void clear(){

        memset(u,0,sizeof(u));

    }

    void modify(int x, long long v){

        for(x+=BIAS;x<SIZE;x+=x&-x) u[x]+=v;

    }

    long long getsum(int x){

        long long s=0;

        for(x+=BIAS;x;x-=x&-x) s+=u[x];

        return s;

    }

} honoka;



int ans[MAXN];



void solve(int casi){

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

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

		int x, y;

		scanf("%d%d", &x, &y);

		E.push_back(PIP(y, PII(-1, x)));

	}

	ans[1] = 0;

	for(int i = 2; i <= m; i++){

		ans[i] = 0;

		for(int j = 0; j < m; j += i){

			E.push_back(PIP(min(j + i - 1, m), PII(i, j + 1)));

		}

	}

	sort(E.begin(), E.end());

	for(int i = 0; i < E.size(); i++){

		if (E[i].second.first < 0){

			honoka.modify(-1, 1);

			honoka.modify(E[i].second.second+1, -1);

		}

		else{

			ans[E[i].second.first] += honoka.getsum(E[i].second.second);

		}

	}

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

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

}



void printans(){



}





int main(){

	prework();

	int T = 1;

//	cin>>T;

	for(int i = 1; i <= T; i++){

		read();

		solve(i);

		printans();

	}

	return 0;

}






// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

using namespace std;

int n,m,f[100005],g[100005];



void zzk(int L,int R){

	for (int k=1,kk,kkk,a,Max,Min; k<=m && k<=R;){

		// k<=kk<=(l-1)/a

		a=(L-1)/k;

		if (a==0) Max=99999999; else Max=(L-1)/a; Min=k-1;

		kk=R/(a+1);

		kk=min(kk,Max); kk=max(kk,Min);

		f[k]++; f[kk+1]--;

		k=Max+1;

	}

}



int main(){

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

	for (int i=1,l,r; i<=n; i++){

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

		zzk(l,r);

	}

	for (int i=1; i<=m; i++) g[i]=g[i-1]+f[i],printf("%d\n",g[i]);

}



/*

3 3

1 2

2 3

3 3



*/

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>



typedef long long LL;



using namespace std;



int N,M;

struct Event

{

	int len,L,R;	

};

vector<Event>E;



Event Make(int len,int L,int R)

{

	return (Event){len,L,R};

}



int Tr[300010];

int lowbit(int x){return x&-x;}

int getsum(int x){int S=0;while(x){S+=Tr[x];x-=lowbit(x);}return S;}

void add(int x,int y){while(x<=M){Tr[x]+=y;x+=lowbit(x);}}



bool cmp(Event A,Event B)

{

	return A.len<B.len;

}



int main()

{

	scanf("%d%d",&N,&M);

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

	{

		int LL,RR;

		scanf("%d%d",&LL,&RR);

		E.push_back(Make(RR-LL+1,LL,RR));

	}

	sort(E.begin(),E.end(),cmp);

	int now = 0;

	int cnt = N;

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

	{

		while(now<E.size() && E[now].len<i)

		{

			Event tmp = E[now];

			add(tmp.L,1);

			add(tmp.R+1,-1);

			now++;

			cnt--;

		}

		int ans = cnt;

		for (int j=i;j<=M;j+=i) ans+=getsum(j);

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

	}

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

using namespace std;

int n,m,f[100005],g[100005];



void zzk(int L,int R){

	for (int k=1,kk,kkk,a,Max,Min; k<=m && k<=R;){

		// k<=kk<=(l-1)/a

		a=(L-1)/k;

		if (a==0) Max=99999999; else Max=(L-1)/a; Min=k-1;

		kk=R/(a+1);

		kk=min(kk,Max); kk=max(kk,Min);

		f[k]++; f[kk+1]--;

		k=Max+1;

	}

}



int main(){

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

	for (int i=1,l,r; i<=n; i++){

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

		zzk(l,r);

	}

	for (int i=1; i<=m; i++) g[i]=g[i-1]+f[i],printf("%d\n",g[i]);

}



/*

3 3

1 2

2 3

3 3



*/

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>



using namespace std;



typedef long long LL;



const int N = 3e5 + 10, M = 1e5 + 10;

int n, m;

int l[N], r[N], idx[N], len[N];

int a[M];



bool cmp(int x, int y) {

    return len[x] < len[y];

}



void add(int x, int v) {

    for (; x <= m + 1; x += x & -x) a[x] += v;

}



int query(int x) {

    int ret = 0;

    for (; x; x -= x &-x) ret += a[x];

    return ret;

}



int main() {

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

    for (int i = 0; i < n; i++) {

        scanf("%d%d", l + i, r + i); 

        len[i] = r[i] - l[i] + 1;

        idx[i] = i;

    }

    sort(idx, idx + n, cmp);

    int j = 0;

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

        while (j < n && len[idx[j]] < i) {

            add(l[idx[j]], 1);

            add(r[idx[j]]+1, -1);

            j++;

        }

        int ans = 0;

        for (int k = i; k <= m; k += i) ans += query(k);

        printf("%d\n", ans + n - j);

    }

    return 0;

}


// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

using namespace std;

int n,m,f[100005],g[100005];



void zzk(int L,int R){

	for (int k=1,kk,kkk,a,Max,Min; k<=m && k<=R;){

		// k<=kk<=(l-1)/a

		a=(L-1)/k;

		if (a==0) Max=99999999; else Max=(L-1)/a; Min=k-1;

		kk=R/(a+1);

		kk=min(kk,Max); kk=max(kk,Min);

		f[k]++; f[kk+1]--;

		k=Max+1;

	}

}



int main(){

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

	for (int i=1,l,r; i<=n; i++){

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

		zzk(l,r);

	}

	for (int i=1; i<=m; i++) g[i]=g[i-1]+f[i],printf("%d\n",g[i]);

}



/*

3 3

1 2

2 3

3 3



*/

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<cstdio>  

#include<iostream>  

#include<algorithm>  

#include<cstdlib>  

#include<cstring>

#include<string>

#include<climits>

#include<vector>

#include<cmath>

#include<map>

#define LL long long



using namespace std;



inline char nc(){

  static char buf[100000],*p1=buf,*p2=buf;

  if (p1==p2) { p2=(p1=buf)+fread(buf,1,100000,stdin); if (p1==p2) return EOF; }

  return *p1++;

}



inline void read(int &x){

  char c=nc(),b=1;

  for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;

  for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;

}



inline void read(LL &x){

  char c=nc(),b=1;

  for (;!(c>='0' && c<='9');c=nc()) if (c=='-') b=-1;

  for (x=0;c>='0' && c<='9';x=x*10+c-'0',c=nc()); x*=b;

}



int wt,ss[19];

inline void print(int x){

	if (x<0) x=-x,putchar('-'); 

	if (!x) putchar(48); else {for (wt=0;x;ss[++wt]=x%10,x/=10);for (;wt;putchar(ss[wt]+48),wt--);}

}

inline void print(LL x){

	if (x<0) x=-x,putchar('-');

	if (!x) putchar(48); else {for (wt=0;x;ss[++wt]=x%10,x/=10);for (;wt;putchar(ss[wt]+48),wt--);}

}



LL n,m;



int main()

{

    read(n);read(m);    

    LL x,y,z;

	vector<LL> a(m+10);

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

	{

		read(x);read(y);

        z=y-x+1;a[0]+=1;a[z]-=1;

        LL t=z+1,s;

        while(t<=m)

		{

            LL v=((x+t-1)/t);

            if((x+t-1)/t<=0) break;

            s=y/((x+t-1)/t);

            if(s>=t) a[t-1]+=1,a[s]-=1;

            if((x+t-1)/t<=1) break;

            t=max(s+1,(x+(v-1)-1)/(v-1));

        }

    }

    LL ans=0;

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

    	ans+=a[i],cout<<ans<<endl;

    return 0;

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

using namespace std;

int n,m,f[100005],g[100005];



void zzk(int L,int R){

	for (int k=1,kk,kkk,a,Max,Min; k<=m && k<=R;){

		// k<=kk<=(l-1)/a

		a=(L-1)/k;

		if (a==0) Max=99999999; else Max=(L-1)/a; Min=k-1;

		kk=R/(a+1);

		kk=min(kk,Max); kk=max(kk,Min);

		f[k]++; f[kk+1]--;

		k=Max+1;

	}

}



int main(){

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

	for (int i=1,l,r; i<=n; i++){

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

		zzk(l,r);

	}

	for (int i=1; i<=m; i++) g[i]=g[i-1]+f[i],printf("%d\n",g[i]);

}



/*

3 3

1 2

2 3

3 3



*/

// Fastest known solution for this problem:
// Original C++ solution (slower):
//============================================================================

// Name        : test.cpp

// Author      : Qihan

// Version     :

// Copyright   : Your copyright notice

// Description : Hello World in C++, Ansi-style

//============================================================================



#include <bits/stdc++.h>

#define Lowbit(x) (x & (-x))

using namespace std;

typedef long long int LLI;

typedef pair<int,int> PII;

const int maxn = (300000 + 10);



struct Seg{

	int l,r,len;

}op[maxn];



bool cmp(Seg a,Seg b){

	return a.len < b.len;

}



int c[maxn];



void add(int x,int change,int n){

	while(x < n){

		c[x] += change;

		x += Lowbit(x);

	}

}



int sum(int x){

	int ans = 0;

	while(x > 0){

		ans += c[x];

		x -= Lowbit(x);

	}

	return ans;

}



int main(){

//	freopen("/home/qihan/Documents/in","r",stdin);

	int n,m;

	memset(c,0,sizeof(c));

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

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

		scanf("%d%d",&op[i].l,&op[i].r);

		op[i].len = op[i].r - op[i].l + 1;

	}

	sort(op + 1,op + 1 + n,cmp);

	int k = 1;

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

		for(;k <= n && op[k].len < i;k ++){

			add(op[k].l,1,300000);

			add(op[k].r + 1,-1,300000);

		}

		int ans = n - k + 1;

		for(int j = i;j <= m;j += i){

			ans += sum(j);

		}

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

	}

	return 0;

}


// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

using namespace std;

int n,m,f[100005],g[100005];



void zzk(int L,int R){

	for (int k=1,kk,kkk,a,Max,Min; k<=m && k<=R;){

		// k<=kk<=(l-1)/a

		a=(L-1)/k;

		if (a==0) Max=99999999; else Max=(L-1)/a; Min=k-1;

		kk=R/(a+1);

		kk=min(kk,Max); kk=max(kk,Min);

		f[k]++; f[kk+1]--;

		k=Max+1;

	}

}



int main(){

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

	for (int i=1,l,r; i<=n; i++){

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

		zzk(l,r);

	}

	for (int i=1; i<=m; i++) g[i]=g[i-1]+f[i],printf("%d\n",g[i]);

}



/*

3 3

1 2

2 3

3 3



*/

// Fastest known solution for this problem: