CodeEff/ECCO huggingface dataset:
# Original solution
from collections import deque
# 全部ゼロ始まり
n, x, y = list(map(int, input().split()))
G = [[] for _ in range(n)]
for i in range(n-1):
    G[i].append(i+1)
for i in range(1, n):
    G[i].append(i-1)
x -= 1
y -= 1
G[x].append(y)
G[y].append(x)

# iとjの最短距離を返す
def bfs(i, j):
    i -= 1
    j -= 1
    q = deque()
    seen = [False] * n
    dist = [-1] * n

    q.append(i)
    seen[i] = True
    dist[i] = 0
    while len(q) > 0:
        now_v = q.popleft()
        for new_v in G[now_v]:
            if seen[new_v] is True:
                continue
            q.append(new_v)
            seen[new_v] = True
            dist[new_v] = dist[now_v] + 1
            if new_v == j:
                return dist[j]

cnt = [0] * (n-1)
for i in range(n-1):
    for j in range(i+1, n):
        cnt[bfs(i, j)-1] += 1

for ans in cnt:
    print(ans)

# Optimized solution
n, x, y = list(map(int, input().split()))
x -= 1
y -= 1
cnt = [0] * n
for i in range(n-1):
    for j in range(i+1, n):
        direct = j - i
        detour = abs(x-i) + abs(y-j) + 1
        d = min(direct, detour)
        cnt[d] += 1
for k in range(1, n):
    print((cnt[k]))
# Original solution
# Author: cr4zjh0bp
# Created: Sat Mar 28 11:53:27 UTC 2020
import sys
 
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni      = lambda: int(ns())
nin     = lambda y: [ni() for _ in range(y)]
na      = lambda: list(map(int, stdin.readline().split()))
nan     = lambda y: [na() for _ in range(y)]
nf      = lambda: float(ns())
nfn     = lambda y: [nf() for _ in range(y)]
nfa     = lambda: list(map(float, stdin.readline().split()))
nfan    = lambda y: [nfa() for _ in range(y)]
ns      = lambda: stdin.readline().rstrip()
nsn     = lambda y: [ns() for _ in range(y)]
ncl     = lambda y: [list(ns()) for _ in range(y)]
nas     = lambda: stdin.readline().split()

from collections import defaultdict, deque

n, x, y = na()
x -= 1
y -= 1
d = defaultdict(int)
g = [[] for _ in range(n)]
for i in range(n - 1):
    g[i].append(i + 1)
    g[i + 1].append(i)
g[x].append(y)
g[y].append(x)

def bfs(i):
    q = deque()
    q.append(i)
    dist = [-1] * n
    dist[i] = 0
    while len(q):
        p = q.popleft()
        for j in g[p]:
            if dist[j] != -1:
                continue
            dist[j] = dist[p] + 1
            q.append(j)

    return dist

dic = defaultdict(int)
for i in range(n):
    d = bfs(i)
    for j in range(n):
        dic[d[j]] += 1

for i in range(1, n):
    print((dic[i] // 2))

# Optimized solution
# Author: cr4zjh0bp
# Created: Sat Mar 28 11:53:27 UTC 2020
import sys
 
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni      = lambda: int(ns())
nin     = lambda y: [ni() for _ in range(y)]
na      = lambda: list(map(int, stdin.readline().split()))
nan     = lambda y: [na() for _ in range(y)]
nf      = lambda: float(ns())
nfn     = lambda y: [nf() for _ in range(y)]
nfa     = lambda: list(map(float, stdin.readline().split()))
nfan    = lambda y: [nfa() for _ in range(y)]
ns      = lambda: stdin.readline().rstrip()
nsn     = lambda y: [ns() for _ in range(y)]
ncl     = lambda y: [list(ns()) for _ in range(y)]
nas     = lambda: stdin.readline().split()

from collections import defaultdict

n, x, y = na()
x -= 1
y -= 1

dic = defaultdict(int)
for i in range(n):
    for j in range(i + 1, n):
        dist = min(j - i, 1 + abs(x - i) + abs(y - j))
        dic[dist] += 1

for i in range(1, n):
    print((dic[i]))
# Original solution
# D - Line++

import queue

N, X, Y = list(map(int, input().split()))
X, Y = X - 1, Y - 1
M = [(i, []) for i in range(N)]
for i in range(N):
    if i != 0:
        M[i][1].append(i - 1)
    if i != N - 1:
        M[i][1].append(i + 1)
    if i == X:
        M[X][1].append(Y)
    if i == Y:
        M[Y][1].append(X)

cost = [[-1] * N for _ in range(N)]
p = [[None] * N for _ in range(N)]
Q = queue.Queue()

for i in range(N):
    Q.put(M[i])
    key = M[i][0]
    cost[key][key] = 0
    p[key][key] = key
    while not Q.empty():
        q = Q.get()
        for j in q[1]:
            if cost[i][j] == -1:
                p[i][j] = q[0]
                cost[i][j] = cost[i][p[i][j]] + 1
                Q.put(M[j])

ans = [0] * N
for i in range(N):
    for j in range(N):
        ans[cost[i][j]] += 1

for i in range(1, N):
    print((int(ans[i] / 2)))


# Optimized solution
# D - Line++

n, x, y = list(map(int, input().split()))
x, y = x - 1, y - 1

cnt = [0] * n
for i in range(n):
    for j in range(i + 1, n):
        dist = min(j - i, abs(x - i) + abs(y - j) + 1)
        cnt[dist] += 1

for i in range(1, len(cnt)):
    print((cnt[i]))
# Original solution
import math

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

distnum = [0 for i in range(N)]
dist = [[0 for i in range(N+1)] for j in range(N+1)]


for i in range(1, N+1):
  for j in range(i, N+1):
    dist[i][j] = min(abs(X-i) + 1 + abs(Y-j), abs(X-j)+1+abs(Y-i), abs(i-j))
    distnum[dist[i][j]] += 1

for i in range(1, N):
  print((distnum[i]))

# Optimized solution
import math

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

distnum = [0 for i in range(N)]


for i in range(1, N+1):
  for j in range(i, N+1):
    dist = min(abs(X-i) + 1 + abs(Y-j), abs(X-j)+1+abs(Y-i), abs(i-j))
    distnum[dist] += 1

for i in range(1, N):
  print((distnum[i]))
# Original solution
N, X, Y = list(map(int,input().split()))
k_list = [0]*N

for p in range(1, N):
    for q in range(p, N+1):
        p2X = abs(p - X)
        p2Y = abs(p - Y)
        q2X = abs(q - X)
        q2Y = abs(q - Y)

        distance = min(q-p, p2X+1+q2Y)
        k_list[distance] += 1

for k in range(1, N):
    print((k_list[k]))

# Optimized solution
N, X, Y = list(map(int,input().split()))
k_list = [0]*N

for p in range(1, N):
    for q in range(p, N+1):
        p2X = abs(p - X)
        q2Y = abs(q - Y)

        distance = min(q-p, p2X+1+q2Y)
        k_list[distance] += 1

for k in range(1, N):
    print((k_list[k]))
# Original solution
from collections import deque
def bfs(start):
    global count
    d = [float('inf') for i in range(N)]
    d[start] = 0
    que = deque()
    que.append(start)
    alr = [start]
    while que:
        q = que.popleft()
        c = d[q]
        for i in path[q]:
            if i not in alr:
                que.append(i)
                alr.append(i)
                d[i] = c+1
    for i in range(start+1,N):
        count[d[i]-1] += 1

N,X,Y = list(map(int,input().split()))
path = [[] for i in range(N)]
path[0] = [1]
path[N-1] = [N-2]
for i in range(1,N-1):
    path[i] = [i-1,i+1]
path[X-1].append(Y-1)
path[Y-1].append(X-1)

count = [0 for i in range(N-1)]
for i in range(N-1):
    bfs(i)
for i in range(N-1):
    print((count[i]))

# Optimized solution
N,X,Y = list(map(int,input().split()))
ans = [0 for i in range(N-1)]
for i in range(1,N):
    for j in range(i+1,N+1):
        mina = min(j-i, abs(X-i)+1+abs(Y-j), abs(Y-i)+1+abs(X-j))
        ans[mina-1] += 1
for i in ans:
    print(i)
# Original solution
from heapq import heappush, heappop
from collections import deque
n, x, y = list(map(int, input().split()))
G = [[]*n for _ in range(n)]

for i in range(n-1):
    G[i].append((i+1, 1))
    G[i+1].append((i, 1))
G[x-1].append((y-1, 1))
G[y-1].append((x-1, 1))
# print(G)
INF = 10**30
N = n


# s: 開始頂点
# N: 頂点数
# G: グラフ
# G[v][i] = (w, d): 辺v-wのコストは d (0 or 1)
dd = []
for i in range(n):
    s = i
    dist = [10**9] * N
    S = deque([s])
    T = deque()
    dist[s] = 0

    d = 0
    while S:
        while S:
            v = S.popleft()
            for w, c in G[v]:
                if d+c < dist[w]:
                    dist[w] = d+c
                    if c:
                        T.append(w)
                    else:
                        S.append(w)
        S, T = T, S
        d += 1
    dd.append(dist)
for i in range(1, n):
    ans = 0
    for d in dd:
        ans += d.count(i)
    print((ans//2))


# Optimized solution
from collections import defaultdict
from heapq import heappush, heappop
from collections import deque
n, x, y = list(map(int, input().split()))
G = [[]*n for _ in range(n)]

for i in range(n-1):
    G[i].append((i+1, 1))
    G[i+1].append((i, 1))
G[x-1].append((y-1, 1))
G[y-1].append((x-1, 1))
# print(G)
INF = 10**30
N = n


# s: 開始頂点
# N: 頂点数
# G: グラフ
# G[v][i] = (w, d): 辺v-wのコストは d (0 or 1)
dd = []
for i in range(n):
    s = i
    dist = [10**9] * N
    S = deque([s])
    T = deque()
    dist[s] = 0

    d = 0
    while S:
        while S:
            v = S.popleft()
            for w, c in G[v]:
                if d+c < dist[w]:
                    dist[w] = d+c
                    if c:
                        T.append(w)
                    else:
                        S.append(w)
        S, T = T, S
        d += 1
    dd.append(dist)

ans = defaultdict(lambda: 0)
for dist in dd:
    for t in dist:
        ans[t] += 1
for i in range(n-1):
    print((ans[i+1]//2))
# Original solution
N,X,Y=list(map(int,input().split()))

X-=1
Y-=1

dist=[0]*(N+1)


for i in range(N):
    for j in range(N):
        dist[(min(abs(i-j),abs(i-Y)+abs(X-j)+1,abs(i-X)+abs(Y-j)+1))]+=1
for d in range(1,N):
    print((dist[d]//2))
    
    

# Optimized solution
N,X,Y=list(map(int,input().split()))

X-=1
Y-=1

dist=[0]*(N+1)


for i in range(N):
    for j in range(i+1,N):
        dist[(min(abs(i-j),abs(i-Y)+abs(X-j)+1,abs(i-X)+abs(Y-j)+1))]+=1
for d in range(1,N):
    print((dist[d]))
# Original solution
def dijkstra(s,n,w,cost, pre):
    #始点sから各頂点への最短距離
    #n:頂点数,　w:辺の数, cost[u][v] : 辺uvのコスト(存在しないときはinf)
    d = [float("inf")] * n
    for i in range(len(pre)):
        d[i] = pre[i]
    used = [False] * n
    d[s] = 0
    
    while True:
        v = -1
        #まだ使われてない頂点の中から最小の距離のものを探す
        for i in range(n):
            if (not used[i]) and (v == -1):
               v = i
            elif (not used[i]) and d[i] < d[v]:
                v = i
        if v == -1:
               break
        used[v] = True
               
        for j in range(len(pre), n):
               d[j] = min(d[j],d[v]+cost[v][j])
    return d

n, a, b = list(map(int, input().split()))

cost = [[float("inf") for i in range(n)] for i in range(n)] 

for i in range(n-1):
    # x,y,z = map(int,input().split())
    # cost[x][y] = z
    # cost[y][x] = z
    cost[i][i+1] = 1
    cost[i+1][i] = 1
cost[a-1][b-1] = 1
cost[b-1][a-1] = 1


ANS = []
for i in range(n):
    pre = []
    for j in range(i):
        pre.append(ANS[j][i])

    ANS.append(dijkstra(i, n, n, cost, pre))
# print(ANS)
from functools import reduce
A = reduce(lambda x,y: x+y,ANS)

import collections

c = collections.Counter(A)

for i in range(1, n):
    print((c[i]//2))


# Optimized solution
a, b, c = list(map(int, input().split()))

b = b - 1
c = c - 1
A = []

for i in range(a):
    for j in range(i+1, a):
        A.append(min(abs(i - b) + 1 + abs(j - c), abs(j - i)))
import collections
C = collections.Counter(A)

for i in range(1, a):
    print((C[i]))
# Original solution
from collections import deque


def main():
    N, X, Y = list(map(int, input().split()))
    ans = [0] * N  # 距離ごとの合計 [d=0, d=1, d=2, d=3, d=4]の数
    X -= 1
    Y -= 1

    for start_vertex in range(N):
        dist = [float('inf')] * N
        q = deque()

        def push(vertex, distance):
            if dist[vertex] != float('inf'):
                return
            dist[vertex] = distance
            q.append(vertex)

        push(start_vertex, 0)  # 始点をpush

        while len(q) != 0:
            vertex = q.popleft()
            distance = dist[vertex]

            if vertex - 1 >= 0:
                push(vertex - 1, distance + 1)
            if vertex + 1 < N:
                push(vertex + 1, distance + 1)
            if vertex == X:
                push(Y, distance + 1)
            if vertex == Y:
                push(X, distance + 1)

        for i in range(N):
            ans[dist[i]] += 1

    for i in range(N):
        ans[i] //= 2

    for i in range(1, N):
        print((ans[i]))


if __name__ == '__main__':
    main()


# Optimized solution
import sys
input = sys.stdin.readline

from collections import deque


def main():
    N, X, Y = list(map(int, input().split()))
    X -= 1
    Y -= 1
    ans = [0] * N

    for start_vertex in range(N):
        q = deque()
        distance_list = [float('inf')] * N

        def push(vertex, distance):
            if distance_list[vertex] != float('inf'):
                return
            q.append(vertex)
            distance_list[vertex] = distance

        push(start_vertex, 0)

        while len(q) != 0:
            vertex = q.popleft()
            distance = distance_list[vertex]

            if vertex - 1 >= 0:
                push(vertex - 1, distance + 1)
            if vertex + 1 < N:
                push(vertex + 1, distance + 1)
            if vertex == X:
                push(Y, distance + 1)
            if vertex == Y:
                push(X, distance + 1)

        for i in distance_list:
            ans[i] += 1

    print(('\n'.join([str(i // 2) for i in ans[1:]])))


if __name__ == '__main__':
    main()
# Original solution
N, X, Y = input().split()
N = int(N)
X = int(X)
x = X - 1
Y = int(Y)
y = Y -1

A = [[0] * N for _ in range(N)]
for i in range(N):
    for j in range(N-i):
        A[i][i + j] = min(abs(x- i) +1 +abs(y-i-j),j)
A[X-1][Y-1] = 1
ans = []
ans.append(sum(A, []))
for t in range(N):
    if t == 0:
        continue
    sum =  A.count(t)
    print((ans[0].count(t)))

# Optimized solution

N, X, Y = input().split()
N = int(N)
X = int(X)
x = X - 1
Y = int(Y)
y = Y -1
ans = [0] * (N)
A = [[] * N for _ in range(N)]
for i in range(N):
    for j in range(N-i):
        path = min(abs(x- i) +1 +abs(y-i-j),j)
        ans[path] += 1
for _ in range(len(ans)):
    if _ == 0:
        continue
    print((ans[_]))
# Original solution
def main():
    from collections import deque

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

    g = tuple(set() for _ in range(N))
    for v in range(N):
        if v > 0:
            g[v].add(v - 1)
        if v < N - 1:
            g[v].add(v + 1)

    g[X].add(Y)
    g[Y].add(X)

    ctr = [0] * N
    for v in range(N):
        dist = [-1] * N

        q = deque()
        q.append((v, 0))

        while q:
            v, d = q.popleft()
            if ~dist[v] and dist[v] < d: continue
            dist[v] = d
            for u in g[v]:
                if ~dist[u]: continue
                dist[u] = d + 1
                q.append((u, d + 1))

        for d in dist:
            ctr[d] += 1

    print(*map(lambda x: x // 2, ctr[1:]), sep='\n')


if __name__ == '__main__':
    main()


# Optimized solution
# https://atcoder.jp/contests/abc160/submissions/11310424

def main():
    N, X, Y = map(int, input().split())
    X -= 1
    Y -= 1

    def dist(a, b):
        return min(
            abs(a - b),
            abs(a - X) + abs(b - Y) + 1,
            abs(a - Y) + abs(b - X) + 1
        )

    ctr = [0] * N
    for b in range(N):
        for a in range(b):
            d = dist(a, b)
            ctr[d] += 1

    print(*ctr[1:], sep='\n')


if __name__ == '__main__':
    main()
# Original solution
# https://atcoder.jp/contests/abc160/submissions/11310424

def main():
    N, X, Y = map(int, input().split())
    X -= 1
    Y -= 1

    def dist(a, b):
        return min(
            abs(a - b),
            abs(a - X) + abs(b - Y) + 1,
            abs(a - Y) + abs(b - X) + 1
        )

    ctr = [0] * N
    for b in range(N):
        for a in range(b):
            d = dist(a, b)
            ctr[d] += 1

    print(*ctr[1:], sep='\n')


if __name__ == '__main__':
    main()


# Optimized solution
# https://atcoder.jp/contests/abc160/submissions/11310424

def main():
    N, X, Y = map(int, input().split())
    X -= 1
    Y -= 1

    def dist(a, b):
        return min(
            abs(a - b),
            abs(a - X) + abs(b - Y) + 1,
            abs(a - Y) + abs(b - X) + 1
        )

    ctr = [0] * N
    for b in range(N):
        for a in range(b):
            d = dist(a, b)
            ctr[d] += 1

    it = iter(ctr)
    next(it)
    print(*it, sep='\n')


if __name__ == '__main__':
    main()
# Original solution
def dist(a, b):
    return min(
        abs(a - b),
        abs(a - x) + 1 + abs(y - b),
        abs(a - y) + 1 + abs(x - b)
    )


n, x, y = map(int, input().split())
x -= 1
y -= 1

d = [0] * n

for j in range(n):
    for i in range(j):
        d[dist(i, j)] += 1

it = iter(d)
next(it)

print(*it, sep='\n')


# Optimized solution
def main():
    N, X, Y = map(int, input().split())
    X -= 1
    Y -= 1

    ans = [0] * N
    for j in range(N):
        for i in range(j):
            d = min(
                j - i,
                abs(j - X) + 1 + abs(Y - i),
                abs(j - Y) + 1 + abs(X - i)
            )
            ans[d] += 1

    print(*ans[1:], sep='\n')


if __name__ == '__main__':
    main()
# Original solution
import pprint
from itertools import chain
import collections
n, x, y = (int(each) for each in input().split(' '))

# table1 = [[0] * n for i in range(n)]
# table2 = [[0] * n for i in range(n)]
table_shortest = [[0] * n for i in range(n)]
# cntr = {}

# # 点iから点jまでの距離をテーブルにする

# # 抜け道を通らないルートの場合
# for i in range(n):
#     for j in range(n):
#         if j-i > 0:
#             table1[i][j] = j-i

# # 抜け道を通るルートの場合
# for i in range(n):
#     for j in range(n):
#         if j-i > 0:
#             table2[i][j] = abs(j-y+1)+abs(i-x+1)+1

# どちらか近いほうのルートが最短距離
for i in range(n):
    for j in range(n):
        if j-i > 0:
            table_shortest[i][j] = min(j-i, abs(j-y+1)+abs(i-x+1)+1)

# テーブルをflattenして数をかぞえる
cntr = collections.Counter(list(chain.from_iterable(table_shortest)))

cntr = dict(cntr)
for each in range(1,n):
    print((cntr.get(each, 0)))

# Optimized solution
import pprint
from itertools import chain
import collections
n, x, y = (int(each) for each in input().split(' '))

# table1 = [[0] * n for i in range(n)]
# table2 = [[0] * n for i in range(n)]
table = [[0] * n for i in range(n)]
# cntr = {}

# # 点iから点jまでの距離をテーブルにする

# # 抜け道を通らないルートの場合
# for i in range(n):
#     for j in range(n):
#         if j-i > 0:
#             table1[i][j] = j-i

# # 抜け道を通るルートの場合
# for i in range(n):
#     for j in range(n):
#         if j-i > 0:
#             table2[i][j] = abs(j-y+1)+abs(i-x+1)+1

# どちらか近いほうのルートが最短距離
for i in range(n):
    for j in range(i, n):
        if j-i > 0:
            table[i][j] = min(j-i, abs(j-y+1)+abs(i-x+1)+1)

# テーブルをflattenして数をかぞえる
cntr = collections.Counter(list(chain.from_iterable(table)))

# cntr = dict(cntr)
for each in range(1,n):
    print((cntr.get(each, 0)))
# Original solution
N, X, Y = map(int, input().split())
dis = [0] * (N - 1)

for i in range(1, N):
	for j in range(i + 1, N + 1):
		cmb = min(j - i, min(abs(X - i) + 1 + abs(Y - j), abs(Y - i) + 1 + abs(X - j)))
		dis[cmb - 1] += 1

[print(i) for i in dis]


# Optimized solution
N, X, Y = map(int, input().split())
dis = [0] * (N - 1)

for i in range(1, N):
	for j in range(i + 1, N + 1):
		cmb = min(j - i, abs(X - i) + 1 + abs(Y - j), abs(Y - i) + 1 + abs(X - j))
		dis[cmb - 1] += 1

[print(i) for i in dis]
# Original solution
n,x,y=list(map(int,input().split()))
s=[]
for i in range(1,n):
  for j in range(i+1,n+1):
    s.append(min(j-i,abs(x-j)+1+abs(y-i),abs(x-i)+1+abs(y-j)))
for l in range(1,n):
  print((s.count(l)))

# Optimized solution
n,x,y=list(map(int,input().split()))
res=[0]*n
for i in range(1,n):
  for j in range(i+1,n+1):
    s=(min(j-i,abs(x-j)+1+abs(y-i),abs(x-i)+1+abs(y-j)))
    res[s]+=1
for k in range(1,n):
  print((res[k]))
# Original solution
from collections import deque


def dfs(rel, s):
    dist = [-1] * len(rel)

    q = deque()
    q.append(s)
    dist[s] = 0

    while len(q):
        e = q.popleft()
        for ei in Rel[e]:
            if dist[ei] >= 0:
                continue
            q.append(ei)
            dist[ei] = dist[e] + 1

    ans = [0] * (len(rel) - 1)
    for d in dist:
        ans[d] += 1
    return ans


N, X, Y = list(map(int, input().split()))
Rel = [None] + [[] for _ in range(N)]
for i in range(1, N + 1):
    if i > 1:
        Rel[i].append(i - 1)
    if i < N:
        Rel[i].append(i + 1)
Rel[X].append(Y)
Rel[Y].append(X)

K = [0] * (N - 1)

for i in range(1, N + 1):
    dist = dfs(Rel, i)
    for k, v in enumerate(dist[1:]):
        K[k] += v

for k in K[:-1]:
    print((k // 2))
print((0))

# Optimized solution
N, X, Y = list(map(int, input().split()))
D = [None] + [0] * (N - 1)
for i in range(1, N):
    for j in range(i + 1, N + 1):
        d = min(abs(j - i),
                abs(X - i) + 1 + abs(j - Y),
                abs(Y - i) + 1 + abs(j - X))
        D[d] += 1

for d in D[1:]:
    print(d)
# Original solution
# coding: utf-8
from collections import deque
def main():
    N, X, Y = map(int, input().split())
    X -= 1
    Y -= 1
    D = [[float("inf") for _ in range(N)] for _ in range(N)]
    D[X][Y] = 1
    D[Y][X] = 1
    queue = deque([[X, Y]])
    visited = [[False for _ in range(N)] for _ in range(N)]
    visited[X][Y] = True 
    while queue:
        x,y = queue.popleft()
        for i, j in zip([1, 0, -1, 0], [0, 1, 0, -1]):
            nx, ny = x+i, y+j
            if nx < 0 or nx >= N or ny < 0 or ny >= N:
                continue
            if visited[nx][ny]:
                continue
            else:
                visited[nx][ny] = True
                D[nx][ny] = min(abs(ny-nx), D[x][y]+1)
                queue.append([nx, ny])
    ans = [0 for _ in range(N)]
    cnt = 0
    for i in range(N):
        for j in range(i+1, N):
            v = D[i][j]
            ans[v-1] += 1
    print(*ans[:-1], sep="\n")
main()


# Optimized solution
# coding: utf-8
from collections import deque
def main():
    N, X, Y = map(int, input().split())
    X -= 1
    Y -= 1
    D = [[0 for _ in range(N)] for _ in range(N)]
    D[X][Y] = 1
    D[Y][X] = 1
    queue = deque([[X, Y]])
    visited = [[False for _ in range(N)] for _ in range(N)]
    visited[X][Y] = True 
    while queue:
        x,y = queue.popleft()
        for i, j in zip([1, 0, -1, 0], [0, 1, 0, -1]):
            nx, ny = x+i, y+j
            if nx < 0 or nx >= N or ny < 0 or ny >= N:
                continue
            if visited[nx][ny]:
                continue
            else:
                visited[nx][ny] = True
                D[nx][ny] = min(abs(ny-nx), D[x][y]+1)
                queue.append([nx, ny])
    ans = [0 for _ in range(N)]
    cnt = 0
    for i in range(N):
        for j in range(i+1, N):
            v = D[i][j]
            ans[v-1] += 1
    print(*ans[:-1], sep="\n")
main()
# Original solution
n,x,y = list(map(int, input().split()))

ans = [0]*(n)
for i in range(n-1):
    for j in range(i+1, n):
        r1 = min(j-i, (abs(x-i-1) + 1 +  abs(y-j-1) ), (abs(y-i-1) + 1 +  abs(x-j-1) ) )
        ans[r1] += 1

for i in ans[1:]:
    print(i)

# Optimized solution
n,x,y = list(map(int, input().split()))

ans = [0]*(n)
for i in range(n-1):
    for j in range(i+1, n):
        #r1 = min(j-i, (abs(x-i-1) + 1 +  abs(y-j-1) ), (abs(y-i-1) + 1 +  abs(x-j-1) ) )
        r1 = min(j - i, (abs(x - i - 1) + 1 + abs(y - j - 1)))
        ans[r1] += 1

for i in ans[1:]:
    print(i)
# Original solution
n,x,y=list(map(int,input().split()))
x,y=x-1,y-1
adj=[[float("inf")]*n for i in range(n)]
for i in range(n):
    for j in range(n):
        adj[i][j]=abs(i-j)
adj[x][y]=adj[y][x]=1
for i in range(n):
    for j in range(n):
        for k in range(n):
            adj[j][k]=min(adj[j][k],adj[j][i]+adj[i][k])
ans=[0 for i in range(n)]
for i in range(n-1):
    for j in range(i+1,n):
        ans[adj[i][j]]+=1
for i in range(1,n):
    print((ans[i]))

# Optimized solution
n,x,y=list(map(int,input().split()))
x,y=x-1,y-1
adj=[[float("inf")]*n for i in range(n)]
adj[x][y]=adj[y][x]=1
for i in range(n):
    for j in range(n):
        adj[i][j]=min(abs(i-j),abs(i-x)+1+abs(y-j),abs(i-y)+1+abs(y-j))
ans=[0 for i in range(n)]
for i in range(n-1):
    for j in range(i+1,n):
        ans[adj[i][j]]+=1
for i in range(1,n):
    print((ans[i]))