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

#include <algorithm>

#include <math.h>

using namespace std;

const double eps=1e-7;

const int maxn=110;

const int maxm=110;

double lin[maxm][maxm],tmp[maxm][maxm],c[maxm][maxm],ans[maxm],p[maxm],v[maxm],t[maxm];

int main()

{

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

	{

		c[i][0]=c[i][i]=1;

		for(int j=1;j<i;j++) c[i][j]=c[i-1][j]+c[i-1][j-1];

	}

	int n,m;

	double l;

	while(scanf("%d%d%lf",&n,&m,&l)!=EOF)

	{

		for(int i=0;i<n;i++) scanf("%lf%lf%lf",&p[i],&t[i],&v[i]);

		for(int i=0;i<n;i++) p[i]/=100;

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

		{

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

			{

				tmp[i][j]=l/v[i]+j*t[i];

				lin[i][j]=pow(p[i],j)*pow((1-p[i]),m-j)*c[m][j];

			}

			for(int j=m-1;j>=0;j--) lin[i][j]+=lin[i][j+1];

			//for(int j=0;j<=m;j++) printf("%f ",lin[i][j]);

			//printf("\n");

			lin[i][m+1]=0;	

		}

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

		{

			for(int k=0;k<=m;k++) ans[k]=pow(p[i],k)*pow((1-p[i]),m-k)*c[m][k];

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

				if(j!=i)

				{

					int q=m;

					for(int p=m;p>=0;p--)

					{

						while(q>=0 && tmp[i][q]>=tmp[j][p]-eps) 

						{

							ans[q]*=lin[j][p+1];

							q--;

						}

						if(q==-1) break;

					}

				}

			double sum=0;

			for(int k=0;k<=m;k++) sum+=ans[k];

			printf("%.9f\n",sum);

		}

	}

}

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

#include <cstring>

#include <cmath>

#include <algorithm>

#include <vector>



using namespace std;



#define MAXN 110

#define INF 0x3f3f3f3f

#define PI acos(-1.0)

#define MAX(a,b) (a>b?a:b)

#define MIN(a,b) (a<b?a:b)

#define ABS(m) (m<0?-m:m)

typedef long long LL;



int n,m,l;

LL c[MAXN][MAXN];

int p[MAXN],t[MAXN],v[MAXN];



void Init()

{

    int i,j;

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

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

        scanf("%d%d%d",p+i,t+i,v+i);

    c[0][0]=1;

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

        for(j=1,c[i][0]=1;j<=i;++j)

            c[i][j]=c[i-1][j]+c[i-1][j-1];

}



long double C(long double P,int N,int M)

{

    int i; long double ans=c[N][M];

    for(i=1;i<=M;++i) ans*=P;

    for(;i<=N;++i) ans*=(1-P);

    return ans;

}



void Work()

{

    int i,j,k,x;

    long double ans,r1,r2;

    long double P[MAXN][2];

    LL t1,t2;

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

        for(ans=0,j=0;j<=m;++j){

            t1=l+1LL*j*t[i]*v[i];

            r1=C(p[i]/100.0,m,j);

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

                if(k==i) continue;

                for(x=1,P[0][0]=P[0][1]=1;x<=m;++x)

                    P[x][0]=P[x-1][0]*p[k]/100.0,P[x][1]=P[x-1][1]*(1-p[k]/100.0);

                for(x=r2=0,t2=l;x<=m&&t2*v[i]<=t1*v[k];t2+=1LL*t[k]*v[k],++x);

                for(r2=0;x<=m;++x) r2+=((long double)c[m][x])*P[x][0]*P[m-x][1];

                r1*=r2;

            }

            ans+=r1;

        }

        printf("%.12f\n",(double)ans);

    }

}



int main()

{

    Init();

    Work();

    return 0;

}

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

#include<cstdio>

#include<string>

#include<cstring>

#include<cstdlib>

#include<iostream>

#include<algorithm>

using namespace std;

int N,M,L;

struct node

{   double t,p;

}per[101][51];

long long c[51][51]={0};

void prepare()

{   c[0][0]=1;c[1][0]=1;

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

    for(int j=0;j<51;j++)

    {   if(j==0) c[i][j]=1;

        else c[i][j]=c[i-1][j]+c[i-1][j-1];

    }

}

int main()

{   int T;

    prepare();

    cin>>N>>M>>L;

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

    {   double p,t,v;

        cin>>p>>t>>v;p*=0.01;

        per[i][0].t=L/v;

        per[i][0].p=pow(1-p,M);

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

        {   per[i][j].p=c[M][j]*pow(1-p,M-j)*pow(p,j);

            per[i][j].t=per[i][j-1].t+t;

        }

    }

//    for(int i=0;i<N;i++){

//    for(int j=0;j<=M;j++)

//    {   cout<<per[i][j].t<<'('<<per[i][j].p<<')'<<' ';

//

//    }puts("");}

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

    {   double s=0;

        for(int j=0;j<=M;j++)

        {   double tt=per[i][j].p;

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

            if(k!=i)

            {   double ts=0;

                for(int t=M;t>=0 && per[k][t].t>per[i][j].t;t--)

                {   ts+=per[k][t].p;

                }

                tt*=ts;

               // cout<<ts<<endl;

            }

            s+=tt;

        }

        printf("%.8lf\n",s);

    }

}

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

#include <cstring>

#include <cmath>

#include <algorithm>

#include <vector>



using namespace std;



#define MAXN 110

#define INF 0x3f3f3f3f

#define PI acos(-1.0)

#define MAX(a,b) (a>b?a:b)

#define MIN(a,b) (a<b?a:b)

#define ABS(m) (m<0?-m:m)

typedef long long LL;



int n,m,l;

LL c[MAXN][MAXN];

int p[MAXN],t[MAXN],v[MAXN];



void Init()

{

    int i,j;

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

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

        scanf("%d%d%d",p+i,t+i,v+i);

    c[0][0]=1;

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

        for(j=1,c[i][0]=1;j<=i;++j)

            c[i][j]=c[i-1][j]+c[i-1][j-1];

}



long double C(long double P,int N,int M)

{

    int i; long double ans=c[N][M];

    for(i=1;i<=M;++i) ans*=P;

    for(;i<=N;++i) ans*=(1-P);

    return ans;

}



void Work()

{

    int i,j,k,x;

    long double ans,r1,r2;

    long double P[MAXN][2];

    LL t1,t2;

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

        for(ans=0,j=0;j<=m;++j){

            t1=l+1LL*j*t[i]*v[i];

            r1=C(p[i]/100.0,m,j);

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

                if(k==i) continue;

                for(x=1,P[0][0]=P[0][1]=1;x<=m;++x)

                    P[x][0]=P[x-1][0]*p[k]/100.0,P[x][1]=P[x-1][1]*(1-p[k]/100.0);

                for(x=r2=0,t2=l;x<=m&&t2*v[i]<=t1*v[k];t2+=1LL*t[k]*v[k],++x);

                for(r2=0;x<=m;++x) r2+=((long double)c[m][x])*P[x][0]*P[m-x][1];

                r1*=r2;

            }

            ans+=r1;

        }

        printf("%.12f\n",(double)ans);

    }

}



int main()

{

    Init();

    Work();

    return 0;

}

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

#define mp make_pair

#define pb push_back

#define sz(x) (int)x.size()

#define all(x) begin(x), end(x)

#define fi first

#define se second

#define debug(x) cerr << #x << " " << x << '\n'

using namespace std;

using ll = long long;

using pii = pair<int,int>;

using pli = pair<ll,int>;

const int INF = 0x3f3f3f3f, N = 2e3 + 5;

const ll LINF = 1e18 + 5;

constexpr int mod = 1e9 + 7;

int n, x, y, dis[N], cnt[N];

vector <int> G[N];

void bfs(int u)

{

	for(int i=1; i<=n; i++) dis[i] = -1;

	dis[u] = 0;

	queue <int> q;

	q.push(u);

	while(sz(q))

	{

		int v = q.front(); q.pop();

		cnt[dis[v]]++;

		for(int to : G[v])

		{

			if(dis[to]==-1)

			{

				dis[to] = dis[v] + 1;

				q.push(to);

			}

		}

	}

}

int main()

{

	ios::sync_with_stdio(false);

	cin.tie(0);

	cin >> n >> x >> y;

	for(int i=1; i<n; i++) G[i].pb(i+1), G[i+1].pb(i);

	G[x].pb(y); G[y].pb(x);

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

	for(int i=1; i<n; i++) cout << cnt[i]/2 << '\n';

	return 0;

}

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

#include<algorithm>

#include<cstdlib>

using namespace std;

const int MAXN = 1 << 11;



int N, X, Y;

int res[MAXN];



int main(){

	int d;

	scanf("%d %d %d", &N, &X, &Y);

	X--, Y--;



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

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

			d = min( abs(i - X) + abs(j - Y) + 1, abs(i - Y) + abs(j - X) + 1 );

			d = min( d, j - i );

			res[d]++;

		}

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

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

	return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#pragma GCC optimize(2)

#pragma warning(disable:4996)

#include <iostream>

#include <cmath>

#include <cstdio>

#include <algorithm>

#include<cstring>

#include <stack>

#include<vector>

#include<queue>

#include<set>

#include<map>

#include <string>

#define itn int

#define F(i,a,b) for(int i=a;i<=(b);++i)

#define F2(i,a,b) for(int i=a;i<(b);++i)

#define dF(i,a,b) for(int i=a;i>=(b);--i)

const int maxn = 2000 + 6;

const int maxa = 1000 * 1000 * 1000 + 7;

typedef long long ll;

const int mod = 1000 * 1000 * 1000 + 7;

using namespace std;

int t, n, m, T;

int res[maxn];

int main()

{

#ifdef _DEBUG

	freopen("D:\\input.txt", "r", stdin);

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

#endif

	int i, j;

	std::ios::sync_with_stdio(false); cin.tie(0);	cout.tie(0);

	int n, x, y;

	cin >> n >> x >> y;

	int a = n - (y - x);

	int b = y - x;

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

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

			int dis = j - i;

			dis = min(dis, 1+abs(i - x) + abs(j - y));

			dis = min(dis, 1+abs(j - x) + abs(i - y));

			res[dis]++;

		}

	}



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

		cout<<res[i]<<"\n";

	}

	return 0;

}

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

#include<algorithm>

#include<cstdlib>

using namespace std;

const int MAXN = 1 << 11;



int N, X, Y;

int res[MAXN];



int main(){

	int d;

	scanf("%d %d %d", &N, &X, &Y);

	X--, Y--;



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

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

			d = min( abs(i - X) + abs(j - Y) + 1, abs(i - Y) + abs(j - X) + 1 );

			d = min( d, j - i );

			res[d]++;

		}

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

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

	return 0;

}


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

using namespace std;



int node;

vector<int>adj[2005];

int ara[2005];



vector<int>bfs(int st)

{

    vector<int>dis(node+1,-1);

    dis[st]=0;

    queue<int>q;

    q.push(st);

    int d=0;

    while(!q.empty())

    {

        int u=q.front();

        q.pop();



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

        {

            int y=adj[u][i];

            if(dis[y]==-1)

            {

                dis[y]=1;

                q.push(y);

                dis[y]=dis[u]+1;

            }

        }

    }

    return dis;

}

int main()

{

    cin>>node;

    int x,y;

    cin>>x>>y;

    adj[x].push_back(y);

    adj[y].push_back(x);

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

    {

        adj[i].push_back(i+1);

        adj[i+1].push_back(i);

    }

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

    {

        vector<int>dis=bfs(i);

        for(int j=i;j<=node;j++)

        {

          ara[dis[j]]++;

        }

    }

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

    {

        cout<<ara[i]<<endl;

    }



	return 0;

}


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

#include<algorithm>

#include<cstdlib>

using namespace std;

const int MAXN = 1 << 11;



int N, X, Y;

int res[MAXN];



int main(){

	int d;

	scanf("%d %d %d", &N, &X, &Y);

	X--, Y--;



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

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

			d = min( abs(i - X) + abs(j - Y) + 1, abs(i - Y) + abs(j - X) + 1 );

			d = min( d, j - i );

			res[d]++;

		}

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

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

	return 0;

}


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

using namespace std;



int main()

{

    int n, x, y;

    cin >> n >> x >> y;

    int ara[n+1];

    memset(ara,0,sizeof(ara));

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

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

            ara[min(j-i,abs(x-i) + 1 + abs(j-y))]++;

        }

    }

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

        cout << ara[i] << endl;

    }

    return 0;

}

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

#include<algorithm>

#include<cstdlib>

using namespace std;

const int MAXN = 1 << 11;



int N, X, Y;

int res[MAXN];



int main(){

	int d;

	scanf("%d %d %d", &N, &X, &Y);

	X--, Y--;



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

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

			d = min( abs(i - X) + abs(j - Y) + 1, abs(i - Y) + abs(j - X) + 1 );

			d = min( d, j - i );

			res[d]++;

		}

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

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

	return 0;

}


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

using namespace std;

const int N=2005;

int n,x,y;

int cnt[N];

int main() {

	int i,j;

	cin>>n>>x>>y;

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

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

			if (i<x&&j<x) cnt[j-i]++;

			else if (i>y&&j>y) cnt[j-i]++;

			else if (i<x&&j>y) cnt[j-y+x-i+1]++;

			else if (i<x&&j>=x) cnt[min(j-i,y-j+1+x-i)]++;

			else if (i<=y&&j>y) cnt[min(j-i,i-x+1+j-y)]++;

			else cnt[min(j-i,i-x+y-j+1)]++;

//			cout<<i<<' '<<j<<' '<<cnt[1]<<endl; 

		}

	for (i=1;i<=n-1;i++) cout<<cnt[i]<<endl;

	return 0;

}

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

#include<algorithm>

#include<cstdlib>

using namespace std;

const int MAXN = 1 << 11;



int N, X, Y;

int res[MAXN];



int main(){

	int d;

	scanf("%d %d %d", &N, &X, &Y);

	X--, Y--;



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

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

			d = min( abs(i - X) + abs(j - Y) + 1, abs(i - Y) + abs(j - X) + 1 );

			d = min( d, j - i );

			res[d]++;

		}

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

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

	return 0;

}


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

using namespace std;



int n,x,y,a,b,c,d[2005][2005],cnt[2005];







int main()

{

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



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

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

			{

				a=abs(j-i);

				b=abs(i-x)+1+abs(j-y);

				c=abs(i-y)+1+abs(j-x);

				d[i][j]=min(a,min(b,c));

			}

			

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

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

    	{

    		cnt[d[i][j]]++;	

		}

  



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

		{

			printf("%d",cnt[i]);

       		printf("\n");

		}	 	



        

	return 0;

}

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

#include<algorithm>

#include<cstdlib>

using namespace std;

const int MAXN = 1 << 11;



int N, X, Y;

int res[MAXN];



int main(){

	int d;

	scanf("%d %d %d", &N, &X, &Y);

	X--, Y--;



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

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

			d = min( abs(i - X) + abs(j - Y) + 1, abs(i - Y) + abs(j - X) + 1 );

			d = min( d, j - i );

			res[d]++;

		}

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

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

	return 0;

}


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

//omo ta tori da

#include<bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp> // Common file

#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update

#include <ext/pb_ds/detail/standard_policies.hpp>

#define pi acos(-1);

#define fs first

#define sc second

#define pb push_back

#define mp make_pair

#define f(i,a,b) for( int i = a; i < b ; i++ )

#define sor(a) sort( a.begin(), a.end() )

#define rsor(a) sort( a.rbegin(), a.rend() )

#define fastio ios_base::sync_with_stdio(0);cin.tie(0)

#define inf 1LL<<62

typedef long long ll;

typedef double ld;

using namespace std;

using namespace __gnu_pbds;

//const ll inf=1e10;

const ll MOD=1e9+7;

const ll mod=998244353;

const ll N = 1e7 + 5;

// ac cmtr;

const int MAX_N = 2e5+5;

typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>ordered_set;

 

#define TRACE

#ifdef TRACE

#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)

template <typename Arg1>

void __f(const char* name, Arg1&& arg1) {

  cout << name << " : " << arg1 << endl;}

 

template <typename Arg1, typename... Args>

void __f(const char* names, Arg1&& arg1, Args&&... args) {

  const char* comma = strchr(names + 1, ',');

  cout.write(names, comma - names) << " : " << arg1<<" | ";

  __f(comma+1, args...);}

#else

#define trace(...)

#endif

//---------------------------



ll dp[2005][2005];

ll cnt[MAX_N];

ll n;

vector <pair <ll,ll > > adj[MAX_N];



void dij(ll a){



    set <pair <ll,ll> > s;

    f(i,0,n+1) {dp[i][a]=inf;}

    s.insert(mp(0,a));

    dp[a][a] = 0;

    //ans[a] = 1;

    while(!s.empty()){

        ll ini  = s.begin()->sc;s.erase(s.begin());

        for(auto xd : adj[ini]){

            if(dp[xd.fs][a] > dp[ini][a] + xd.sc){

                s.erase(mp(dp[xd.fs][a],xd.fs)); 

                //ans[xd.fs] = ans[ini];

                dp[xd.fs][a] = dp[ini][a] + xd.sc;

                s.insert(mp(dp[xd.fs][a],xd.fs));

            }

        }

        

    }

  return;

}



int main(){

    fastio;

    ll x,y;

    cin>>n>>x>>y;

    f(i,1,n){

        adj[i].pb({i+1,1});

        adj[i+1].pb({i,1});

    }

    adj[x].pb({y,1});

    adj[y].pb({x,1});

    f(i,1,n+1){

        dij(i);

    }

    f(i,1,n+1){

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

            cnt[dp[i][j]]++;

        }

    }

    f(i,1,n){

        cout<<cnt[i]/2<<" "<<endl;

    }

//ga



   

}

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

using namespace std;

int i,j,n,m,x,y,ans[2100],minn;

int main()

{

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

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

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

	  if (i>=y||j<=x)  ans[j-i]++;else

	  if (i<=x&&j>=y) ans[j-i-(y-x)+1]++;else

	  {

	  	minn=j-i;

	  	minn=min(minn,abs(i-x)+1+abs(j-y));

	  	minn=min(minn,abs(i-y)+1+abs(j-x));

	  	minn=min(minn,abs(j-y)+1+abs(i-x));

		minn=min(minn,abs(j-x)+1+abs(i-y)); 

		ans[minn]++;

	  }

	for (i=1;i<n;i++) printf("%d\n",ans[i]);

}

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

using namespace std;

typedef long long ll;

int ans[2222];

int main()

{

    int n,x,y;cin >> n >> x >> y;

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

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

            ans[min(j-i,min(abs(x-i)+abs(y-j),abs(y-i)+abs(x-j))+1)]++;

    for(int i=1;i<n;i++)cout << ans[i] << endl;

    return 0;

}

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

#include <cstdio>

#include <cstring>

using namespace std;

typedef long long ll;

const int maxn = 2010;



int n, x, y;

int ans[maxn];



int main() {

    int len;

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

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

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

            if (i <= x) {

                len = min(j - i, x - i + 1 + abs(y - j));

            } else {

                len = min(j - i, i - x + 1 + abs(y - j));

            }

            ans[len]++;

        }

    }

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

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

    }

    return 0;

}

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

#define debug(x) cerr << #x << " " << x << '\n'

using namespace std;

typedef long long ll;

const int maxn=2e3+7;

int a[maxn];

int main()

{

    ios::sync_with_stdio(false);

    cin.tie(0);

    int n, x, y, ans;

    cin>>n>>x>>y;

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

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

        {

            ans=j-i;

            ans=min(ans, abs(x-i)+1+abs(y-j));

            a[ans]++;

        }

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

    return 0;

}


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

#include <cstdio>

#include <cstring>

using namespace std;

typedef long long ll;

const int maxn = 2010;



int n, x, y;

int ans[maxn];



int main() {

    int len;

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

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

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

            if (i <= x) {

                len = min(j - i, x - i + 1 + abs(y - j));

            } else {

                len = min(j - i, i - x + 1 + abs(y - j));

            }

            ans[len]++;

        }

    }

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

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

    }

    return 0;

}

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

using namespace std;

 

#define fastio ios_base::sync_with_stdio(0);cin.tie(0)

#define mod 1000000007LL

#define nax 200009LL

#define FOR(i,n,m) for(int i = (n); i < (m); i++)

#define REP(i,n) FOR(i,0,n)

#define pb push_back

#define mp make_pair

#define fst first

#define snd second

#define all(v) v.begin(),v.end()

#define sz(v) int(v.size())

 

 

typedef long long ll;

typedef vector<int> vi; 

typedef pair<int,int> ii;





int main(){

	fastio;



    int n, x, y, ans[2009];

    bool vis[2009];

    vi adj[2009];

    cin>>n>>x>>y;



    FOR(i,1,n){

        adj[i].pb(i+1); adj[i+1].pb(i);

    }

    

    adj[x].pb(y); adj[y].pb(x);



    REP(i,2009) ans[i]=0;

    queue<int> q;

    int dist[2009];



    FOR(i,1,n+1){

        memset(vis, 0, sizeof vis);

        q.push(i);

        vis[i]=1;

        dist[i]=0;

        while(!q.empty()){

            int x=q.front(); q.pop();

            for(auto u : adj[x]){

                if(vis[u]) continue;

                vis[u]=1;

                dist[u]=dist[x]+1;

                q.push(u);

                ans[dist[u]]++;

            }

        }



    }



    FOR(i,1,n) cout<<ans[i]/2<<"\n";



	return 0;

}

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

#include <cstdio>

#include <cstring>

using namespace std;

typedef long long ll;

const int maxn = 2010;



int n, x, y;

int ans[maxn];



int main() {

    int len;

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

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

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

            if (i <= x) {

                len = min(j - i, x - i + 1 + abs(y - j));

            } else {

                len = min(j - i, i - x + 1 + abs(y - j));

            }

            ans[len]++;

        }

    }

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

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

    }

    return 0;

}

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

#define ff first

#define ss second

#define pb push_back

#define mp make_pair

#define sz(x) ll((x).size())

#define all(v) (v).begin(),(v).end()

#define trace(x) cerr << #x << " = " << x << endl

#define fastio ios_base::sync_with_stdio(0);cin.tie(0)

#define For(i,a,b) for(ll i = ll(a); i < ll(b); ++i)

#define roF(i,a,b) for(ll i = ll(a); i >= ll(b); i--)

using namespace std;



typedef long long ll;

typedef pair<ll,ll> ii;

typedef vector<ll> vi;

typedef vector<ii> vii;



const ll N=1e6;



int ans[N];



int main(){

	fastio;

	int n, x, y; cin>>n>>x>>y;

	For(i,1,n+1){

		For(j,i+1,n+1){

			ans[min(j-i,abs(i-x)+abs(y-j)+1)]++;

		}

	}

	For(i,1,n) cout << ans[i] << endl;

	return 0;

}


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

#include <cstdio>

#include <cstring>

using namespace std;

typedef long long ll;

const int maxn = 2010;



int n, x, y;

int ans[maxn];



int main() {

    int len;

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

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

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

            if (i <= x) {

                len = min(j - i, x - i + 1 + abs(y - j));

            } else {

                len = min(j - i, i - x + 1 + abs(y - j));

            }

            ans[len]++;

        }

    }

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

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

    }

    return 0;

}

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

using namespace std;



const int maxn = 2e3 + 10;



int n, x, y;

int d[maxn];



void solve() {

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

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

      int d_min = j - i;

      d_min = min(d_min, abs(i - x) + 1 + abs(j - y));

      d_min = min(d_min, abs(i - y) + 1 + abs(j - x));

      ++d[d_min];

    }

}



int main() {

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

  solve();

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

    printf("%d\n", d[k]);

  return 0;

}

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

#include <cstdio>

#include <cstring>

using namespace std;

typedef long long ll;

const int maxn = 2010;



int n, x, y;

int ans[maxn];



int main() {

    int len;

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

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

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

            if (i <= x) {

                len = min(j - i, x - i + 1 + abs(y - j));

            } else {

                len = min(j - i, i - x + 1 + abs(y - j));

            }

            ans[len]++;

        }

    }

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

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

    }

    return 0;

}

// Fastest known solution for this problem: