#include <bits/stdc++.h>
#define _ ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define int long long
#define sz(i) (int)(i.size())
#define F first
#define S second
#define L long double
#define P pair<int, int>
const int inf = 0x3f3f3f3f3f3f3f3LL;
const int mod = (int)1e9 + 7;
using namespace std;
#if LOCAL
#include "../../tr.h"
#else
#define tr(...)
#define endl '\n'
#endif
template<class T> void smin(T& a, T val) {if (a > val) a = val;}template<class T> void smax(T& a, T val) {if (a < val) a = val;}
const int N = 5*(int)1e5 + 10;

int n, a[N];

 
struct log_lca {
    int n = 0;
    vector<int> parent, depth;
    vector<vector<int>> adj;
    vector<vector<int>> ancestor;
 
    log_lca(int _n = 0) {
        init(_n);
    }
 
    void init(int _n) {
        n = _n;
        parent.resize(n);
        depth.resize(n);
        adj.assign(n, {});
    }
 
    static int largest_bit(int x) {
        return 31 - __builtin_clz(x);
    }
 
    void add_edge(int a, int b) {
        adj[a].push_back(b);
        adj[b].push_back(a);
    }
 
    void dfs(int node, int par) {
        depth[node] = par < 0 ? 0 : depth[par] + 1;
        parent[node] = par;
 
        for (int neighbor : adj[node])
            if (neighbor != par)
                dfs(neighbor, node);
    }
 
    void build() {
        dfs(0, -1);
        ancestor.assign(largest_bit(n) + 1, vector<int>(n));
        ancestor[0] = parent;
 
        for (int k = 0; k < largest_bit(n); k++)
            for (int i = 0; i < n; i++)
                ancestor[k + 1][i] = ancestor[k][i] < 0 ? -1 : ancestor[k][ancestor[k][i]];
    }
 
    int get_lca(int a, int b) const {
        if (depth[a] > depth[b])
            swap(a, b);
 
        int difference = depth[b] - depth[a];
 
        for (int k = 0; 1 << k <= difference; k++)
            if (difference & 1 << k)
                b = ancestor[k][b];
 
        if (a == b)
            return a;
 
        assert(a != b && depth[a] == depth[b]);
 
        for (int k = largest_bit(depth[a]); k >= 0; k--)
            if (ancestor[k][a] != ancestor[k][b]) {
                a = ancestor[k][a];
                b = ancestor[k][b];
            }
 
        assert(parent[a] == parent[b]);
        return parent[a];
    }
 
    int get_dist(int a, int b) const {
        return depth[a] + depth[b] - 2 * depth[get_lca(a, b)];
    }
 
    int get_kth_ancestor(int v, int k) const {
        for (int i = 0; 1 << i <= k; i++)
            if (k & 1 << i) {
                v = ancestor[i][v];
 
                if (v < 0)
                    break;
            }
 
        return v;
    }
 
    int get_kth_node_on_path(int a, int b, int k) const {
        int anc = get_lca(a, b);
        int first_half = depth[a] - depth[anc];
        int second_half = depth[b] - depth[anc];
        assert(0 <= k && k <= first_half + second_half);
 
        if (k < first_half)
            return get_kth_ancestor(a, k);
        else
            return get_kth_ancestor(b, first_half + second_half - k);
    }
};
 
 
log_lca lca;

int32_t main(){_
   
   int n, x, y;
   cin >> n >> x >> y;
   --x, --y;
   lca.init(n);
   
   for (int i = 0; i+1 < n; ++i)
   {
      int x = i, y = i+1;
      lca.add_edge(x, y);
   }

   lca.build();
   
   vector<int> ans(n, 0);

   for (int i = 0; i < n; ++i)
   {
      for (int j = i+1; j < n; ++j)
      {
         int dist = lca.get_dist(i, j);
         int mi = lca.get_dist(i, x) + 1 + lca.get_dist(y, j);
         int mi2 = lca.get_dist(i, y) + 1 + lca.get_dist(x, j);
         ans[min({dist, mi, mi2})]++;
      }
   }

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


   return 0;
}

Measured memory_bytes: 640