import heapq





def dijkstra(start: int, edges: list):

    """print the shortet path  O(|E|log|V|)

    maybe verified

    """

    dist = [float('inf') for _ in range(N)]  # list dist[|V|]

    dist[start] = 0

    prev_v = [-1]*(len(dist))  # 最短経路でのひとつ前の頂点

    q = [(0, start)]  # （暫定的な距離，頂点）

    while q:

        d_cur, cur = heapq.heappop(q)

        if dist[cur] < d_cur:  # すでに探索済み

            continue

        for nex, cost in edges[cur]:

            if dist[nex] > dist[cur]+cost:

                dist[nex] = dist[cur]+cost

                heapq.heappush(q, (dist[nex], nex))

                prev_v[nex] = cur

    return dist



    # # 以下 path の復元

    # path = []

    # v = goal

    # while v != -1:

    #     path.append(v)

    #     v = prev_v[v]

    # path = path[::-1]  # reverse

    # print("Shortest path: ", path)





if __name__ == "__main__":

    N, X, Y = map(int, input().split())

    X, Y = X-1, Y-1

    edges = [[] for _ in range(N)]

    for i in range(1, N):

        edges[i].append((i-1, 1))

    for i in range(N-1):

        edges[i].append((i+1, 1))

    edges[X].append((Y, 1))

    edges[Y].append((X, 1))

    # print(edges)



    cnt = [0]*N

    for i in range(N):

        d = dijkstra(i, edges)

        for di in d:

            cnt[di] += 1

    cnt = [ci//2 for ci in cnt]

    print(*cnt[1:], sep="\n")

from collections import deque





def dijkstra(start: int, edges: list):

    """print the shortet path  O(|E|log|V|)

    maybe verified

    """

    dist = [float('inf') for _ in range(N)]  # list dist[|V|]

    dist[start] = 0

    prev_v = [-1]*(len(dist))  # 最短経路でのひとつ前の頂点

    q = deque([(0, start)])  # （暫定的な距離，頂点）

    while q:

        d_cur, cur = q.pop()

        if dist[cur] < d_cur:  # すでに探索済み

            continue

        for nex, cost in edges[cur]:

            if dist[nex] > dist[cur]+cost:

                dist[nex] = dist[cur]+cost

                q.append((dist[nex], nex))

                prev_v[nex] = cur

    return dist



    # # 以下 path の復元

    # path = []

    # v = goal

    # while v != -1:

    #     path.append(v)

    #     v = prev_v[v]

    # path = path[::-1]  # reverse

    # print("Shortest path: ", path)





if __name__ == "__main__":

    N, X, Y = map(int, input().split())

    X, Y = X-1, Y-1

    edges = [[] for _ in range(N)]

    for i in range(1, N):

        edges[i].append((i-1, 1))

    for i in range(N-1):

        edges[i].append((i+1, 1))

    edges[X].append((Y, 1))

    edges[Y].append((X, 1))

    # print(edges)



    cnt = [0]*N

    for i in range(N):

        d = dijkstra(i, edges)

        for di in d:

            cnt[di] += 1

    cnt = [ci//2 for ci in cnt]

    print(*cnt[1:], sep="\n")

import heapq


def dijkstra(start: int, edges: list):
    """print the shortet path  O(|E|log|V|)
    maybe verified
    """
    dist = [float("inf") for _ in range(N)]  # list dist[|V|]
    dist[start] = 0
    prev_v = [-1] * (len(dist))  # 最短経路でのひとつ前の頂点
    q = [(0, start)]  # （暫定的な距離，頂点）
    while q:
        d_cur, cur = heapq.heappop(q)
        if dist[cur] < d_cur:  # すでに探索済み
            continue
        for nex, cost in edges[cur]:
            if dist[nex] > dist[cur] + cost:
                dist[nex] = dist[cur] + cost
                heapq.heappush(q, (dist[nex], nex))
                prev_v[nex] = cur
    return dist
    # # 以下 path の復元
    # path = []
    # v = goal
    # while v != -1:
    #     path.append(v)
    #     v = prev_v[v]
    # path = path[::-1]  # reverse
    # print("Shortest path: ", path)


if __name__ == "__main__":
    N, X, Y = map(int, input().split())
    X, Y = X - 1, Y - 1
    edges = [[] for _ in range(N)]
    for i in range(1, N):
        edges[i].append((i - 1, 1))
    for i in range(N - 1):
        edges[i].append((i + 1, 1))
    edges[X].append((Y, 1))
    edges[Y].append((X, 1))
    # print(edges)
    cnt = [0] * N
    for i in range(N):
        d = dijkstra(i, edges)
        for di in d:
            cnt[di] += 1
    cnt = [ci // 2 for ci in cnt]
    print(*cnt[1:], sep="\n")

from collections import deque


def dijkstra(start: int, edges: list):
    """print the shortet path  O(|E|log|V|)
    maybe verified
    """
    dist = [float("inf") for _ in range(N)]  # list dist[|V|]
    dist[start] = 0
    prev_v = [-1] * (len(dist))  # 最短経路でのひとつ前の頂点
    q = deque([(0, start)])  # （暫定的な距離，頂点）
    while q:
        d_cur, cur = q.pop()
        if dist[cur] < d_cur:  # すでに探索済み
            continue
        for nex, cost in edges[cur]:
            if dist[nex] > dist[cur] + cost:
                dist[nex] = dist[cur] + cost
                q.append((dist[nex], nex))
                prev_v[nex] = cur
    return dist
    # # 以下 path の復元
    # path = []
    # v = goal
    # while v != -1:
    #     path.append(v)
    #     v = prev_v[v]
    # path = path[::-1]  # reverse
    # print("Shortest path: ", path)


if __name__ == "__main__":
    N, X, Y = map(int, input().split())
    X, Y = X - 1, Y - 1
    edges = [[] for _ in range(N)]
    for i in range(1, N):
        edges[i].append((i - 1, 1))
    for i in range(N - 1):
        edges[i].append((i + 1, 1))
    edges[X].append((Y, 1))
    edges[Y].append((X, 1))
    # print(edges)
    cnt = [0] * N
    for i in range(N):
        d = dijkstra(i, edges)
        for di in d:
            cnt[di] += 1
    cnt = [ci // 2 for ci in cnt]
    print(*cnt[1:], sep="\n")

-import heapq +from collections import deque -    q = [(0, start)]  # （暫定的な距離，頂点） +    q = deque([(0, start)])  # （暫定的な距離，頂点） -        d_cur, cur = heapq.heappop(q) +        d_cur, cur = q.pop() -                heapq.heappush(q, (dist[nex], nex)) +                q.append((dist[nex], nex))