stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.534122011761202x):
#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;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.179890270799149x):
#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;

}
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 5.480955798790877x):
#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;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.110002451394371x):
#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;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.108114017810009x):
#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;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.079658428737461x):
#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;

}
// Slower C++ solution:
//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



   

}

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

#pragma optimize("Ofast")

using namespace std;



using ll = long long;

const int N = 1e5+5;



int main()

{

    ios_base::sync_with_stdio(0);



    int n,x,y;

    cin >> n >> x >> y;

    map<int,int> cnt;

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

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

            int no_edge = j-i;

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

            cnt[min(no_edge, pp)]++;

        }

    }

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

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

    return 0;

}
// Slower C++ solution:
//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



   

}

// Faster C++ solution for the same problem (measured speedup: 6.677380049571855x):
#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]);

}
// Slower C++ solution:
//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



   

}

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

using namespace std;

int main()

{

	int n,x,y;

	cin>>n>>x>>y;

	int A[n]={0};

	int dist;

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

	{

		for(int j=n;j>i;j--)

		{

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

			A[dist]++;

		}

	}

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

	{

		cout<<A[i]<<endl;

	}

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.126337439502187x):
#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;

}
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 5.179884600773302x):
#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;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.593378214925068x):
#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;

}
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 5.184382136771539x):
#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;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 5.067045135436775x):
#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;

}