#include<bits/stdc++.h>
 
using namespace std;
 
using ll = long long;
using ld = long double;
 
ll fast_pow( ll a , ll b , ll m )
{
 
    ll res=1;
    while(b>0)
    {
        if(b&1) res =  (res*a)%m;
        a=(a*a)%m;
        b=b/2;
    }
    return res;
}
 
template <typename T,typename U>                                                   
std::pair<T,U> operator-(const std::pair<T,U> & l,const std::pair<T,U> & r) {   
    return {l.first-r.first,l.second-r.second};                                    
} 
 
template <typename T,typename U>                                                   
std::pair<T,U> operator+(const std::pair<T,U> & l,const std::pair<T,U> & r) {   
    return {l.first+r.first,l.second+r.second};                                    
} 
 
const ll maxn = 1000000;
const int inf = 0x3f3f3f;
const ll MOD = 1e9+7LL;
int ns;

ll lcm(ll a , ll b)
{
    return (a*b)/__gcd(a ,b);
}

/*
    java implementation of highestOneBit and NumberOfTrailingZeroes
*/

ll highestOnebit(ll x)
{
    x |= (x>>1);
    x |= (x>>2);
    x |= (x>>4);
    x |= (x>>8);
    x |= (x>>16);
    x |= (x>>32);
    
    return x-((unsigned ll)x>>1);
}   

int numberOfTrailingZeros(ll i)
{
    if (i == 0) return 64;
    ll x = i;
    ll y;
    int n = 63;
    y = x << 32; if (y != 0) { n -= 32; x = y; }
    y = x << 16; if (y != 0) { n -= 16; x = y; }
    y = x <<  8; if (y != 0) { n -=  8; x = y; }
    y = x <<  4; if (y != 0) { n -=  4; x = y; }
    y = x <<  2; if (y != 0) { n -=  2; x = y; }
    return (int) (n - ((unsigned ll)(x << 1) >> 63));
}


vector<int> parent;
vector<int> depth;
vector<vector<pair<int, int>>> adj;
vector<bool> vis;
vector<int> tin;
vector<int> tout;
int T = 0;

// void dfs(int u , int d)
// {
//     tin[u] = T++;
//     depth[u]=d;
//     vis[u]=true;
//     for(auto v : adj[u])
//     {
//         if(!vis[v])
//         {
//             dfs(v , d+1);
//             parent[v]=u;
//         }
//     }    
//     tout[u]=T++;
// }


//cp-algorithms.com
void dijkstra(int s, vector<int> & d, vector<int> & p) {
    int n = adj.size();
    d.assign(n, inf);
    p.assign(n, -1);

    d[s] = 0;
    set<pair<int, int>> q;
    q.insert({0, s});
    while (!q.empty()) {
        int v = q.begin()->second;
        q.erase(q.begin());

        for (auto edge : adj[v]) {
            int to = edge.first;
            int len = edge.second;

            if (d[v] + len < d[to]) {
                q.erase({d[to], to});
                d[to] = d[v] + len;
                p[to] = v;
                q.insert({d[to], to});
            }
        }
    }
}


int main()
{
    // freopen( "input.txt" , "w" , stdout );
    
    
 
    srand(time(0));
    // Using time point and system_clock 
    std::chrono::time_point<std::chrono::system_clock> start, end; 
  
    start = std::chrono::system_clock::now(); 
 
 
    //------- INPUT GENERATION ------
 
    // cout<<200000<<endl;
 
    //------- /INPUT GENERATION ------

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

    int n , x , y;

    cin>>n>>x>>y;

    adj.resize(n);

    for(int i=0;i<n-1;i++)
    {
        adj[ i ].push_back( { i+1 , 1 } );
        adj[ i+1 ].push_back( {i , 1} );
    }

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

    vector<int> nodesAtDistance(n , 0);

    for(int v=0;v<n;v++)
    {
        vector<int> d;
        vector<int> p;
        d.resize(n);
        p.resize(n);
        dijkstra( v , d , p );
        for(int u=0;u<n;u++) nodesAtDistance[d[u]]+=1;
    }

    for(int d=1;d<n;d++)
    {
        cout<<(nodesAtDistance[d])/2<<endl;
    }


    // vector<int> numberOfNodesAt(n+1, 0);

    // //calculate for X chain

    // for(int i=1;i<x;i++)
    // {
    //     numberOfNodesAt[i] += x-i;
    // }

    // // Y chain
    // int yChain = n - y + 1;
    // for(int i=1;i<yChain;i++)
    // {
    //     numberOfNodesAt[i] += yChain-i;
    // }


    // int cycleChain = y - x + 1;

    // for(int i=1; 2*i < cycleChain ; i++ )
    // {
    //     numberOfNodesAt[ i ] += cycleChain;
    // }

    // if(cycleChain%2==0)
    // {
    //     numberOfNodesAt[ cycleChain/2 ] += cycleChain/2;
    // }

    // vector<int> updateFinal(n+10 , 0);

    // for(int i=1;i<x;i++)
    // {
    //     updateFinal[ x+1 - i + 1 ] += 1;
    //     updateFinal[ x + y - i + 1 + 1 ] -= 1;
    // }













    

   
    // cout<<endl;
    // end = std::chrono::system_clock::now(); 
  
    // std::chrono::duration<double> elapsed_seconds = end - start; 
    // std::time_t end_time = std::chrono::system_clock::to_time_t(end); 
  
    // std::cout << "finished computation at " << std::ctime(&end_time) 
    //           << "elapsed time: " << elapsed_seconds.count() << "s\n"; 
 
 
 
 
}

Measured memory_bytes: 384