#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define PI acos(-1)
#define vi vector<int>
#define pi pair<int, int>
#define pl pair<ll, ll>
template<class T> istream &operator>>(istream&is,vector<T>&v){for(auto &elemnt:v)is>>elemnt;return is;}
template<class T,class U> istream &operator>>(istream&is,pair<T,U>&p){is>>p.first>>p.second;return is;}
const int MOD = 1e9+ 7;
const int INF = numeric_limits<int>::max() - (int)1e8;
const ll INFLL = numeric_limits<ll>::max() - (ll)1e17;

template<typename T>
struct edge {
    pair<int, int> arrow;
    T cost;

    edge(int source, int to, T cost) : arrow(source, to), cost(cost) {}
    edge(int to, T cost) : arrow(-1, to), cost(cost) {}

    edge &operator=(const int &vertex) {
        arrow.second = vertex;
        return *this;
    }

    operator int() const { return arrow.second; }
};

template<typename T>
struct UnWeightedGraph {
    bool is_directed_graph;
    vector<vector<edge<T>>> data;
    explicit UnWeightedGraph(size_t size, bool is_directed_graph) : data(size), is_directed_graph(is_directed_graph) {}

    void add_edge(int source, int to) {
        data[source].emplace_back(to, 0);
        if (!is_directed_graph) data[to].emplace_back(source, 0);
    }

    vector<edge<T>> &operator[] (const size_t index) { return data[index]; }

    const size_t size() const { return data.size(); }
};

template<typename T>
struct WeightedGraph : UnWeightedGraph<T> {
    explicit WeightedGraph(size_t size, bool is_directed_graph) : UnWeightedGraph<T>(size, is_directed_graph) {}

    void add_edge(int source, int to, T cost) {
        UnWeightedGraph<T>::operator[](source).emplace_back(to, cost);
        if (!UnWeightedGraph<T>::is_directed_graph) UnWeightedGraph<T>::operator[](to).emplace_back(source, cost);
    }
};

template<typename T>
class Dijkstra {
private:
    WeightedGraph<T> &graph;
    vector<vector<T>> shortest_distance;

    void init_and_exec_dijkstra(size_t start_vertex, const T MAX_INF, function<bool(int, T)> update_function) {
        shortest_distance[start_vertex] = vector<T>(graph.size(), MAX_INF);
        exec_dijkstra(start_vertex, update_function, shortest_distance[start_vertex]);
    }

    void default_dijkstra(size_t start_vertex, const T MAX_INF) {
        init_and_exec_dijkstra(start_vertex, MAX_INF, [&](size_t next_vertex, T next_cost) {
            return shortest_distance[start_vertex][next_vertex] == next_cost;
        });
    }

protected:
    void exec_dijkstra(size_t start_vertex, function<bool(size_t, T)> update_function, vector<T> &now_distance) {
        priority_queue<pair<T, size_t>, vector<pair<T, size_t>>, greater<>> next_edges;
        now_distance[start_vertex] = 0;
        next_edges.emplace(now_distance[start_vertex], start_vertex);
        while (!next_edges.empty()) {
            size_t now_vertex;
            T now_cost;
            tie(now_cost, now_vertex) = next_edges.top();
            next_edges.pop();
            if (now_distance[now_vertex] < now_cost) continue;
            for (auto &next_vertex : graph[now_vertex]) {
                T next_cost = now_cost + next_vertex.cost;
                if (now_distance[next_vertex.arrow.second] < next_cost) continue;
                if (update_function(next_vertex.arrow.second, next_cost)) continue;
                now_distance[next_vertex] = next_cost;
                next_edges.emplace(next_cost, next_vertex);
            }
        }
    }

public:
    explicit Dijkstra(WeightedGraph<T> &graph) : graph(graph), shortest_distance(graph.size()) {}

    T query_overwrite(size_t start_vertex, size_t end_vertex, const T MAX_INF) {
        default_dijkstra(start_vertex, MAX_INF);
        return shortest_distance[start_vertex][end_vertex];
    }

    T query(size_t start_vertex, size_t end_vertex, const T MAX_INF)  {
        if (shortest_distance[start_vertex].empty()) default_dijkstra(start_vertex, MAX_INF);
        return shortest_distance[start_vertex][end_vertex];
    }

    void query(size_t start_vertex, const T MAX_INF) { if (shortest_distance[start_vertex].empty()) default_dijkstra(start_vertex, MAX_INF); }

    // read only
    constexpr vector<T> &operator[] (const size_t start_vertex) const { return shortest_distance[start_vertex]; }
};

int main() {
    int N, X, Y;
    cin >> N >> X >> Y;
    X--; Y--;
    WeightedGraph<ll> graph(N, false);
    for (int i = 0; i < N - 1; i++) graph.add_edge(i, i + 1, 1);
    graph.add_edge(X, Y, 1);
    auto dist = Dijkstra<ll>(graph);
    vector<ll> ans(N + 1);
    for (int i = 0; i < N; i++) for (int j = i + 1; j < N; j++) ans[dist.query(i, j, INF)]++;
    for (int i = 1; i < N; i++) cout << ans[i] << endl;
}


Measured memory_bytes: 31744