#include <algorithm>
#include <cassert>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>

using namespace std;

typedef long long ll;

template<class T>
inline bool chmax(T &a, T b) {
    if(a < b) {
        a = b;
        return true;
    }
    return false;
}

template<class T>
inline bool chmin(T &a, T b) {
    if(a > b) {
        a = b;
        return true;
    }
    return false;
}

map<int, int> dists;

void solve(const int N, const int X, const int Y) {
    for (int i = 1; i <= N; i++) {
        if (i <= X) {
            for (int j = 1; j <= N; j++) {
                if (j <= (X + Y) / 2) {
                    // not use bipass
                    int d = abs(i - j);
                    // printf("[1] i: %d, j: %d, d: %d\n", i, j, d);
                    dists[d]++;
                } else {
                    // use bipass
                    int d = abs(i - X) + abs(Y - j) + 1;
                    // printf("[2] i: %d, j: %d, d: %d\n", i, j, d);
                    dists[d]++;
                }
            }
        } else if (i <= (X + Y) / 2) {
            for (int j = 1; j <= N; j++) {
                if (j <= X) {
                    // not use bipass
                    int d = abs(i - j);
                    // printf("[3] i: %d, j: %d, d: %d\n", i, j, d);
                    dists[d]++;
                } else if (j <= Y) {
                    // maybe use bipass
                    int d = min(abs(i - j),i - X + Y - j + 1);
                    // printf("[4] i: %d, j: %d, d: %d\n", i, j, d);
                    dists[d]++;
                } else {
                    // maybe use bipass?
                    int d = min(i - X + j - Y + 1, j - i);
                    // printf("[5] i: %d, j: %d, d: %d\n", i, j, d);
                    dists[d]++;
                }
            }
        } else if (i <= Y) {
            for (int j = 1; j <= N; j++) {
                if (j <= X) {
                    // maybe use bipass?
                    int d = min(Y - i + X - j + 1, i - j);
                    // printf("[6] i: %d, j: %d, d: %d\n", i, j, d);
                    dists[d]++;
                } else if (j <= Y) {
                    // maybe use bipass
                    int d = min(abs(i - j), Y - i + j - X + 1);
                    // printf("[7] i: %d, j: %d, d: %d\n", i, j, d);
                    dists[d]++;
                } else {
                    // not use bipass
                    int d = abs(j - i);
                    // printf("[8] i: %d, j: %d, d: %d\n", i, j, d);
                    dists[d]++;
                }
            }
        } else {
            for (int j = 1; j <= N; j++) {
                if (j <= X) {
                    // use bipass
                    int d = i - Y + X - j + 1;
                    // printf("[9] i: %d, j: %d, d: %d\n", i, j, d);
                    dists[d]++;
                } else if (j <= (X + Y) / 2) {
                    // maybe use bipass?
                    int d = min(i - Y + j - X + 1, i - j);
                    // printf("[10] i: %d, j: %d, d: %d\n", i, j, d);
                    dists[d]++;
                } else {
                    // not use bipass
                    int d = abs(i - j);
                    // printf("[11] i: %d, j: %d, d: %d\n", i, j, d);
                    dists[d]++;
                }
            }
        }
    }
}

int main(void) {
    int N, X, Y;
    cin >> N >> X >> Y;

    solve(N, X, Y);

    for (int i = 1; i <= N - 1; i++) {
        cout << dists[i] / 2 << endl;
    }

    return 0;
}


Measured memory_bytes: 384