// 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.597039092733977x):
#include <iostream>

#include <cmath>

#include <vector>

#include <algorithm>

#include <string>

#include <set>

#include <map>

#include <list>

#include <time.h>

#include <math.h>

#include <random>

#include <deque>

#include <queue>

#include <cassert>

#include <unordered_map>

#include <unordered_set>

#include <iomanip>

#include <bitset>

#include <sstream>

#include <chrono>

#include <cstring>

#include<bits/stdc++.h>



using namespace std;



typedef long long ll;

typedef double db;



#define ft first

#define sd second

#define flag bool fl=true



#define mod 1000003

#define N 100001

#define MX 1000000001

#define MXX 1000000000000000001



#define pb push_back

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

#define T int t, qq=0; cin>>t; while(qq++<t)

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

#define scarr(array, size) for(int i=0;i<size;i++) cin>>array[i]



#define deg(rad) (rad*180.0)/pi

#define pi acos(-1)

#define log(n) (int)log2(n)

#define logg(a)(b) log(b)/log(a)





/*

//----------useful_functions----------



long long extended_euclid(ll a, ll b, ll &x, ll &y){//ax+by=c

    if(b==0)

    {

        x=1, y=0;

        return a;

    }



    ll x1, y1;

    ll d=extended_euclid(b, a%b, x1, y1);

    x=y1;

    y=x1-y1*(a/b);

    return d;

}

long long bigMod(ll a, ll b){//(a^b)%mod

    ll ans=1;

    while(b)

    {

        if(b%2==1) ans=(ans*a)%mod;

        a=(a*a)%mod;

        b/=2;

    }

    return ans%mod;

}

long long modInverse(ll a, ll b){//a*x=1 mod b

    ll x, y;

    ll gcd=extended_euclid(a, b, x, y);



    if(gcd==1) return ((x%b)+b)%b;

    else return 1;

}

long long nCr(ll n, ll r){//n<=1e6

    //declare globally-> ll fact[1000001];

    fact[1]=1;

    for(ll i=2;i<1000001;i++)

        fact[i]=(i*fact[i-1])%mod;



    return (fact[n]*modInverse(fact[r], mod)*modInverse(fact[n-r], mod))%mod;

}

long long josephus(ll n, ll k){//k'th person is killed out of n in the circle

    if(n==1) return 1;

    else return (josephus(n-1, k)+k-1)%n+1;

}

vector<int> sieve(ll n){//get primes up to n<=1e6 and the numbers can be handled up to 1e12

    bool fl[n+1];

    vector<int> primes;

    for(int i=0;i<=n;i++) fl[i]=false;



    for(int i=3;i*i<=n;i+=2)

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

            fl[j]=true;



    primes.pb(2);

    for(int i=3;i<=n;i+=2) if(!fl[i]) primes.pb(i);

    return primes;

}



*/



int main()

{

    int n, x, y;

    cin>>n>>x>>y;

    int ans[n+1]= {};



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

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

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



//        cout<<"Case "<<qq<<": ";

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

        cout<<ans[i]<<endl;

}