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

using namespace std;

typedef long long ll;

int main()

{

    int i,j,k,n,m,c,t,y,mx,x;

    cin>>n>>x>>y;

    if(x>y) swap(x,y);k=y-x-1;//k=max(k,0);

    map<int,int>mp;

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

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

            c=j-i;

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

           // c=min(c,abs(i-y)+abs(j-x));

            mp[c]++;

           // cout<<i<<" "<<j<<" ="<<c<<endl;

        }

    }

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

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

    }

    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 = 2100;

int n, x, y, a, b;

set<pair<int, int>> resp[MAXN];

int mark[MAXN];



void bfs(int u){

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

	queue<int> Q;

	Q.push(u);

	mark[u] = 0;

	while(!Q.empty()){

		int v = Q.front();

		Q.pop();

		resp[mark[v]].insert({min(u, v), max(u, v)});

		if (v < n-1 && mark[v+1] == -1){

			mark[v+1] = mark[v] + 1;

			Q.push(v+1);

		}

		if (v > 0 && mark[v-1] == -1){

			mark[v-1] = mark[v] + 1;

			Q.push(v-1);

		}

		if(v == x && mark[y] == -1){

			mark[y] = mark[v]+1;

			Q.push(y);

		}

		if (v == y && mark[x] == -1){

			mark[x] = mark[v]+1;

			Q.push(x);

		}

	}

}



int main(){

	//memset(resp, 0, sizeof(resp));

	cin >> n >> a >> b;

	a--; b--;	

	x = min(a, b);

	y = max(a, b);



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

		bfs(i);

	}



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

		//cout << "I ----- " << i << endl;

		cout << resp[i].size() << endl;

	}

	return 0;

}

// Optimized solution to the same problem (faster):
//Bismillahir Rahmanir Rahim

#include <bits/stdc++.h>

using namespace std;



typedef long long              ll;

typedef long double            ld;

typedef pair<int, int>         pi;

typedef vector<int>            vi;

typedef vector<pair<int, int>> vpi;



#define pb       push_back

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

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

#define ff       first

#define ss       second

#define mp       make_pair

#define lb       lower_bound

#define ub       upper_bound

#define tcase()  int t; cin >> t; while(t--)



const int MOD = 1e9 + 7; // 998244353;

const int MX  = 2e5 + 5;

const ll  INF = 1e18;

const ld  PI  = acos((ld) -1);



void setIO(string name = "") {

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

    if(sz(name)){

        freopen((name+".in").c_str(), "r", stdin);

        freopen((name+".out").c_str(), "w", stdout);

    }

}



int main(){



    setIO();



    int n, l, r;

    cin >> n >> l >> r;



    int dif = r - l - 1;



    int arr[n + 1] = {0};



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

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

            arr[min({j - i, abs(l - i) + 1 + abs(j - r)})]++;

        }

    }



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

}


// 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;

    }





   

}

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

# include <cstdio>

# include <cmath>

using namespace std;



// long long A[1000000];

long long N,X,Y;

long long K[40000];

int main(void)

{

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

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

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

    {

        for (long long j=i+1;j<=N;j++)

        {

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

            K[kk]++;

        }

    }

    for (int i=1;i<N;i++) printf("%lld\n",K[i]);

    return 0;

}

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

using namespace std;



#define pb push_back

#define fr(i, n) for(int i = 0; i < n; i++)

#define frr(i, n) for(int i = 1; i <= n; i++)



#define dbg(x) cout << #x << " = " << x << endl

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

#define ms(x, i) memset(x, i, sizeof(x))



#define p(x) cout << x << "\n"

#define pv(x) fr(i, x.size()) cout << x[i] << " \n"[i==x.size()-1]



#define f first

#define s second



#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)



typedef long long int ll;

typedef long double ld;

typedef pair<int,int> pii;

typedef pair<ll,ll> pll;

typedef vector<int> vi;

typedef vector<ll> vl;



const int INF = 0x3f3f3f3f;

const ll LINF = 0x3f3f3f3f3f3f3f;



#define maxn 2123



vi adj[maxn];

int ans[maxn], vis[maxn];



int main() {

    fastio;

    int n, x, y;

    cin >> n >> x >> y;



    frr(i, n-1) {

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

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

    }



    adj[x].pb(y);

    adj[y].pb(x);



    frr(i, n) {

        ms(vis, 0);



        queue<pii> q;

        q.push({0, i});

        while (!q.empty()) {

            int u = q.front().s;

            int d = q.front().f;

            q.pop();



            if (vis[u]) continue;

            vis[u] = 1;



            if (u > i) ans[d]++;

            for (auto v: adj[u]) q.push({d+1, v});

        }

    }



    frr(i, n-1) p(ans[i]);

}


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

# include <cstdio>

# include <cmath>

using namespace std;



// long long A[1000000];

long long N,X,Y;

long long K[40000];

int main(void)

{

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

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

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

    {

        for (long long j=i+1;j<=N;j++)

        {

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

            K[kk]++;

        }

    }

    for (int i=1;i<N;i++) printf("%lld\n",K[i]);

    return 0;

}

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

using namespace std;



#define pb push_back

#define inf INT_MAX

#define pii pair<int,int>

#define f first

#define s second

#define mp make_pair

#define mod 1000000009

#define ld long double

#define eps 1e-8

#define MAXN 2123



vector<pii> are[MAXN];

int dis[MAXN];

int val[MAXN];



void dij(int x){

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

    priority_queue<pii> q;

    dis[x]=0;q.push(mp(0,x));

    while(!q.empty()){

        x=q.top().s;int c=-q.top().f;q.pop();

        if(dis[x]!=c)continue;

        for(pii at:are[x]){

            int y=at.s,c=at.f;

            if(dis[y]==-1||dis[x]+c<dis[y]){

                dis[y]=dis[x]+c;

                q.push(mp(-dis[y],y));

            }

        }

    }

    for(int i=0;i<MAXN;i++)val[dis[i]]++;

}



int32_t main (){



    ios::sync_with_stdio(false);

    cin.tie(0);

    cout<<setprecision(2)<<fixed;



    int n,x,y;

    cin>>n>>x>>y;

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

        are[i].pb(mp(1,i+1));

        are[i+1].pb(mp(1,i));

    }

    x--;y--;

    are[x].pb(mp(1,y));

    are[y].pb(mp(1,x));



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



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

        cout<<val[i]/2<<endl;

    }



    return 0;

}




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

# include <cstdio>

# include <cmath>

using namespace std;



// long long A[1000000];

long long N,X,Y;

long long K[40000];

int main(void)

{

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

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

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

    {

        for (long long j=i+1;j<=N;j++)

        {

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

            K[kk]++;

        }

    }

    for (int i=1;i<N;i++) printf("%lld\n",K[i]);

    return 0;

}

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

using namespace std;

typedef long long ll;

const int MOD=1000000007;

#define INF 1LL<<30

#define rep(i,n) for (int i = 0; i < (n); ++i)

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



// ダイクストラ法

// 参照：蟻本　p97

// O(mlogn)

struct edge{int to,cost;};

typedef pair<int,int> P; // firstは最短距離、secondは頂点の番号



int n; // 頂点の数

vector<edge> G[100010];

int d[100010];



void dijkstra(int s){

    priority_queue<P,vector<P>, greater<P>> que;

    fill(d,d+n,INF);

    d[s]=0;

    que.push(P(0,s));



    while(!que.empty()){

        P p=que.top(); que.pop();

        int v=p.second;

        if(d[v]<p.first) continue;

        rep(i,G[v].size()){

            edge e=G[v][i];

            if(d[e.to]>d[v]+e.cost){

                d[e.to]=d[v]+e.cost;

                que.push(P(d[e.to],e.to));

            }

        }

    }

}



int main(){

    int x,y;

    cin >> n>>x>>y;

    x--,y--;

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

        G[i].push_back({i+1,1});

        G[i+1].push_back({i,1});

    }

    G[x].push_back({y,1});

    G[y].push_back({x,1});

    

    map<int,int> m;

    rep(i,n){

        dijkstra(i);

        rep(j,n) m[d[j]]++;

    }



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

        cout<<m[k]/2<<endl;

    }

}




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

using namespace std;

typedef long long ll;

const int MOD=1000000007;

#define INF 1LL<<30

#define rep(i,n) for (int i = 0; i < (n); ++i)

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



int cnt[2010];



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++){

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

            cnt[tmp]++;

        }

    }



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

        cout<<cnt[i]<<endl;

    }

}




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



using namespace std;



set<int>gr[2][2010];

int depth[2][2010];

int spTab[2][15][2010];



void dfs(int gn, int u, int p, int d)

{

    depth[gn][u] = d;

    spTab[gn][0][u] = p;

    for(int v:gr[gn][u]){

        if(v != p)

            dfs(gn, v, u, d+1);

    }

}

int n;



void fill(){

    for(int gn = 0; gn < 2; gn++){

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

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

                if(spTab[gn][i-1][j] != -1){

                    spTab[gn][i][j] = spTab[gn][i-1][spTab[gn][i-1][j]];

                }

            }

        }

    }

}



int lca(int gn, int u, int v){

    if(depth[gn][u] > depth[gn][v]){

        swap(u, v);

    }

    for(int i = 14; i >= 0; i--){

        if(depth[gn][v]-(1<<i) >= depth[gn][u])

            v = spTab[gn][i][v];

    }

    if(u == v)return u;

    for(int i = 14; i >= 0; i--){

        if(spTab[gn][i][u] != spTab[gn][i][v]){

            u = spTab[gn][i][u];

            v = spTab[gn][i][v];

        }

    }

    return spTab[gn][0][u];

}



int dist(int u, int v){

    int d = max(u, v) - min(u, v);

    int l0 = lca(0, u, v);

    int l1 = lca(1, u, v);

    int d0 = depth[0][u] + depth[0][v] - 2*depth[0][l0];

    int d1 = depth[1][u] + depth[1][v] - 2*depth[1][l1];

    return min(d, min(d0, d1));

}



int main()

{

    cin >> n;

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

        gr[0][i].insert(i+1);

        gr[1][i].insert(i+1);

        

        gr[0][i+1].insert(i);

        gr[1][i+1].insert(i);

    }

    int x, y;

    cin >> x >> y;

    gr[0][x].insert(y);

    gr[0][y].insert(x);

    gr[1][x].insert(y);

    gr[1][y].insert(x);

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

    gr[0][x].erase(x+1);

    gr[0][x+1].erase(x);

    dfs(0, x, -1, 0);

    gr[1][y].erase(y-1);

    gr[1][y-1].erase(y);

    dfs(1, y, -1, 0);

    

    fill();

    vector<int>len;

    len.resize(n);

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

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

            //int d = dist(i, j);

            //cerr << i << " " << j << ": " << d << endl;

          int d = min({j-i, abs(y-j)+1+abs(x-i), abs(y-i)+1+abs(x-j)});

            len[d]++;

        }

    }

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

        cout << len[i] << endl;

    }

    return 0;

}


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



using namespace std;



int main()

{

  int n;

    cin >> n;

    int x, y;

    cin >> x >> y;

    vector<int>len;

    len.resize(n);

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

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

          int d = min({j-i, abs(y-j)+1+abs(x-i), abs(y-i)+1+abs(x-j)});

            len[d]++;

        }

    }

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

        cout << len[i] << endl;

    }

    return 0;

}


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

using namespace std;

int n,x,y;

int cnt[2020];

int dist[2020][2020];

vector<int> ga[2020];

queue<int> q;

void BFS(int src){

	q.push(src);

	memset(dist[src],63,sizeof(dist[src]));

	dist[src][src]=0;

	int pp;

	while(q.size()){

		pp=q.front();

		q.pop();

		for(int snk:ga[pp]){

			if(dist[src][snk]>dist[src][pp]+1){

				dist[src][snk]=dist[src][pp]+1;

				q.push(snk);

			} 

		}

	}

}

int main(){

	#ifdef FILIN

		#ifndef LOCAL

			freopen(FILIN,"r",stdin);

			freopen(FILOUT,"w",stdout);

		#endif

	#endif

	cin>>n>>x>>y;

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

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

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

	}

	ga[x].push_back(y);

	ga[y].push_back(x);

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

		BFS(i);

	}

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

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

			cnt[dist[i][j]]++;

		}

	}

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

		cout<<cnt[i]<<endl;

	return 0;

}


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

using namespace std;

int n,x,y;

int dist;

int cnt[2020];

int main(){

	#ifdef FILIN

		#ifndef LOCAL

			freopen(FILIN,"r",stdin);

			freopen(FILOUT,"w",stdout);

		#endif

	#endif

	cin>>n>>x>>y;

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

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

			dist=j-i;

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

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

			cnt[dist]++;

		}

	} 

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

		cout<<cnt[i]<<endl;

	return 0;

}


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

#include <string>

#define ft first

#define sc second

#define pt(sth) cout << sth << "\n"

#define chmax(a, b) (a)=(a>b)?(a):(b);

#define chmin(a, b) (a)=(a<b)?(a):(b);

#define moC(a, s, b) (a)=((a)s(b)+MOD)%MOD

using namespace std;

typedef long long ll;

typedef pair<ll, ll> pll;

static const ll INF=1e18;

static const ll MAX=101010;

static const ll MOD=1e9+7;





/*

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

   cin >> a[i];

*/



class Edge {

public:

  ll t, w;

  Edge() {}

  Edge(ll t, ll w): t(t), w(w) {}

};



ll N, M;

vector<Edge> g[2222];

ll d[2222][2222];



void dijkstra(ll s) {

  ll i, u;

  ll clr[2222]={};

  priority_queue<pll> q;

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

    d[s][i]=INF;

    clr[i]=0;

  }

  d[s][s]=0;

  q.push({0, s});

    

  while(q.size()) {

    pll f=q.top(); q.pop();

    u=f.second;

    clr[u]=1;

    if(d[s][u]<-f.first) continue;

    

    for(i=0; i<g[u].size(); i++) {

      Edge e=g[u][i];

      if(clr[e.t] || d[s][e.t]<=d[s][u]+e.w) continue;

      

      d[s][e.t]=d[s][u]+e.w;

      q.push({-d[s][e.t], e.t});

    }

  }

}

int main(void) {

  ll i, j, k;

  

  ll X, Y;

  cin >> N >> X >> Y;

  X--; Y--;

  

  for(i=0; i<N-1; i++) {

    g[i].push_back(Edge(i+1, 1));

    g[i+1].push_back(Edge(i, 1));

  }

  

  g[X].push_back(Edge(Y, 1));

  g[Y].push_back(Edge(X, 1));

  

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

  

  ll cnt[2222]={};

  for(i=0; i<N; i++) for(j=i+1; j<N; j++) cnt[d[i][j]]++;

  

  for(i=1; i<N; i++) pt(cnt[i]);

  

  

  

}






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

#include <string>

#define ft first

#define sc second

#define pt(sth) cout << sth << "\n"

#define chmax(a, b) (a)=(a>b)?(a):(b);

#define chmin(a, b) (a)=(a<b)?(a):(b);

#define moC(a, s, b) (a)=((a)s(b)+MOD)%MOD

using namespace std;

typedef long long ll;

typedef pair<ll, ll> pll;

static const ll INF=1e18;

static const ll MAX=101010;

static const ll MOD=1e9+7;





/*

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

   cin >> a[i];

*/







int main(void) {

  ll i, j, k;

  

  ll N, X, Y;

  cin >> N >> X >> Y;

  X--; Y--;

  

  

  ll cnt[2222]={};

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

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

      cnt[min(j-i, abs(X-i)+1+abs(Y-j))]++;

  

  for(i=1; i<N; i++) pt(cnt[i]);

  

  

  

}






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

#define N 100005

#define ll long long

#define inf 0x3f3f3f3f

#define m0(x) memset(x,0,sizeof(x))

#define m1(x) memset(x,-1,sizeof(x))

using namespace std;

int n,l,r,ans[2005];

int main()

{

	cin>>n>>l>>r;

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

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

	{

		int dis=j-i;

		dis=min(dis,abs(l-i)+abs(r-j)+1);

		dis=min(dis,abs(r-i)+abs(l-j)+1);

		ans[dis]++;

	}

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

	cout<<ans[i]<<endl;

	return 0;

}

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

#include<cmath>

#include<algorithm>

using namespace std;

int dis[2002];

int main(){

  int n,x,y;

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

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

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

      int cache;

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

      if(cache<n)dis[cache]++;

	}

  }

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

  return 0;

}


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

using namespace std;

const int maxn=20000+5;

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

int main(){

	cin>>n>>x>>y;

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

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

		{

			int dist1=i-j;

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

			int dist=min(dist1,dist2);

			ans[dist]++;

		}

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

	return 0;

}

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

#include<cmath>

#include<algorithm>

using namespace std;

int dis[2002];

int main(){

  int n,x,y;

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

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

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

      int cache;

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

      if(cache<n)dis[cache]++;

	}

  }

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

  return 0;

}


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

using namespace std;

int n,x,y,f[2004];



int main()

{

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

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

    {

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

        {

            if(j<=x||i>=y)

            {

                f[j-i]++;

            }

            else if(i>x&&i<y&&j<y&&j>x)

            {

                int p=min(j-i,y-j+1+i-x);

                f[p]++;

            }

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

            else if(i<=x&&j>x)

            {

                int p=min(j-i,y-j+1+x-i);

                f[p]++;

            }

            else 

            {

                int p=min(j-i,i-x+1+j-y);

                f[p]++;

            }

        }

    }

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

}

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

#include<cmath>

#include<algorithm>

using namespace std;

int dis[2002];

int main(){

  int n,x,y;

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

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

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

      int cache;

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

      if(cache<n)dis[cache]++;

	}

  }

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

  return 0;

}


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

#include<math.h>

#include<string>

#include<string.h>

#include<iostream>

#include<stdlib.h>

#include<stdio.h>

#include<vector>

#include<queue>

#define fo(n)for(int i = 0; i<n ; i++)

#define fo1(n)for(int i = 1; i<=n ; i++)

using namespace std;

vector<int>G[2005];

int vis[2005];

int len[2005];

queue<pair<int, int> >q;

void bfs(int now, int deep)

{

	memset(vis, 0, 2005*sizeof(int));

	

	q.push(make_pair(now, deep));

	int no, dep;

	vis[now] = 1;

	while (!q.empty())

	{

		no = q.front().first;

		dep = q.front().second;

		vis[no] = 1;

		len[dep]++;

		q.pop();

		fo(G[no].size())

		{

			if (!vis[G[no][i]])

			{

				q.push(make_pair(G[no][i], dep + 1));

				vis[G[no][i]] = 1;

			}

		}

	}

}

int main()

{

	ios::sync_with_stdio(false);

	cin.tie(0);

	int n, x, y;

	cin >> n >> x >> y;

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

	{

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

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

	}

	G[x].push_back(y);

	G[y].push_back(x);

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

	{

		bfs(i, 0);

	}

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

	{

		cout << len[i] / 2 << endl;

	}

	return 0;

}

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



using namespace std;



const int N = 2005;



int n, X, Y;



int cnt[2005];



int main(){

    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&&j<=Y){

                ++cnt[min(j-i,X-i+Y-j+1)];

            }else if(i<=X&&j>Y){

                ++cnt[X-i+j-Y+1];

            }else if(i<=Y&&j<=Y){

                ++cnt[min(j-i,i-X+Y-j+1)];

            }else if(i<=Y&&j>Y){

                ++cnt[min(j-i,i-X+j-Y+1)];

            }else{

                ++cnt[j-i];

            }

        }

    }



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

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

    }





    return 0;

}


// Fastest known solution for this problem: