CodeEff/ECCO huggingface dataset:
# Original solution
from sys import stdin


def main():
    n, x, y = map(int, stdin.readline().split())
    x -= 1
    y -= 1

    summary = [0] * (n - 1)
    for i in range(n):
        for j in range(i + 1, n):
            d = min(j - i, abs(i - x) + abs(j - y) + 1, abs(i - y) + abs(j - x) + 1)
            summary[d - 1] += 1
    print(*summary, sep='\n')


if __name__ == "__main__":
    main()


# Optimized solution
from sys import stdin, setrecursionlimit


def main():
    input = stdin.buffer.readline
    n, x, y = map(int, input().split())
    ans = [0] * (n - 1)
    for i in range(1, n + 1):
        for j in range(i + 1, n + 1):
            d = min(j - i, abs(i - x) + abs(j - y) + 1, abs(i - y) + abs(j - x) + 1)
            ans[d - 1] += 1
    print(*ans, sep='\n')


if __name__ == "__main__":
    setrecursionlimit(10000)
    main()
# Original solution
#!/usr/bin/env python3
# coding: utf-8
# import pprint
# import numpy as np
# import code
import functools

def debug(arg):
    if __debug__:
        pass
    else:
        import sys
        debug = lambda *x: None
        print(arg, file=sys.stderr)

n, x, y = (int(x) for x in input().split())
d = dict.fromkeys(range(1, n), 0)
debug(d)
for i in range(1, n):
    for j in range(i + 1, n + 1):
        debug([i, j, x, y])
        dd1=abs(x - i) + 1 + abs(y - j)
        dd2= j - i
        d[min(dd1, dd2)] += 1
        debug(d)

for n in d.values():
    print(n)




# Optimized solution
#!/usr/bin/env python3
# coding: utf-8
# import pprint
# import numpy as np
# import code
import functools

if __debug__:
    def debug(arg):
        pass
else:
    import sys
    def debug(arg):
        debug = lambda *x: None
        print(arg, file=sys.stderr)

n, x, y = (int(x) for x in input().split())
d = dict.fromkeys(range(1, n), 0)
debug(d)
for i in range(1, n):
    for j in range(i + 1, n + 1):
        debug([i, j, x, y])
        dd1=abs(x - i) + 1 + abs(y - j)
        dd2= j - i
        if dd1 < dd2:
            d[dd1] += 1
        else:
            d[dd2] += 1
        debug(d)

for n in d.values():
    print(n)
# Original solution
N, X, Y = map(int, input().split())

def dist(fr, to):
    return min(
        to - fr,
        abs(to - Y) + 1 + abs(fr - X),
        abs(fr - Y) + 1 + abs(to - X)
    )

cnt = [0] * N

ans = 0
for fr in range(1, N + 1):
    for to in range(fr + 1, N + 1):
        cnt[dist(fr, to)] += 1

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


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

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

print(*ans[1:], sep='\n')
# Original solution
from collections import Counter
import itertools

def warshall_floyd(d):
    #d[i][j]: iからjへの最短距離
    for k in range(n):
        for i in range(n):
            for j in range(n):
                d[i][j] = min(d[i][j],d[i][k] + d[k][j])
    return d

n, x, y = list(map(int, input().split()))
d = [[float("inf")]*n for i in range(n)] 

for i in range(n-1):
    d[i][i+1] = 1
    d[i+1][i] = 1
d[x-1][y-1] = 1
d[y-1][x-1] = 1
for i in range(n):
    d[i][i] = 0
warshall_floyd(d)
D = Counter(list(itertools.chain.from_iterable(d)))
for i in range(1, n):
    print((D[i]//2))

# Optimized solution
from collections import Counter
import itertools

def warshall_floyd(d):
    #d[i][j]: iからjへの最短距離
    for k in range(n):
        for i in range(n):
            for j in range(n):
                d[i][j] = min(d[i][j],d[i][k] + d[k][j])
    return d

n, x, y = list(map(int, input().split()))
d = [[n]*n for i in range(n)] 

for i in range(n-1):
    d[i][i+1] = 1
    d[i+1][i] = 1
d[x-1][y-1] = 1
d[y-1][x-1] = 1
for i in range(n):
    d[i][i] = 0
warshall_floyd(d)
D = Counter(list(itertools.chain.from_iterable(d)))
for i in range(1, n):
    print((D[i]//2))
# Original solution
from collections import Counter
import itertools

def warshall_floyd(d):
    #d[i][j]: iからjへの最短距離
    for k in range(n):
        for i in range(n):
            for j in range(n):
                d[i][j] = min(d[i][j],d[i][k] + d[k][j])
    return d

n, x, y = list(map(int, input().split()))
d = [[n]*n for i in range(n)] 

for i in range(n-1):
    d[i][i+1] = 1
    d[i+1][i] = 1
d[x-1][y-1] = 1
d[y-1][x-1] = 1
for i in range(n):
    d[i][i] = 0
warshall_floyd(d)
D = Counter(list(itertools.chain.from_iterable(d)))
for i in range(1, n):
    print((D[i]//2))

# Optimized solution
import collections
n, x, y = list(map(int, input().split()))
d = [[0]*(i+1) for i in range(n)]
x -= 1
y -= 1
for i in range(n):
    for j in range(i+1):
        d[i][j] = min(i-j, abs(x-j)+abs(y-i)+1)
L = []
for i in range(n):
    for dd in d[i]:
        L.append(dd)
C = collections.Counter(L)
for i in range(1, n):
    print((C[i]))
# Original solution
def warshall_floyd(d, n):
    for k in range(n):
        for i in range(n):
            for j in range(n):
                if (d[i][k] == 0 or d[k][j] == 0):
                    continue
                if (i == j):
                    continue
                if (d[i][j] == 0):
                    d[i][j] = d[i][k] + d[k][j]
                else:
                    d[i][j] = min(d[i][j], d[i][k] + d[k][j])

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

result = [[0] * n for i in range(n)]
for i in range(n):
    if (i-1 >= 0):
        result[i][i-1] = 1
    if (i+1 < n):
        result[i][i+1] = 1
result[x-1][y-1] = 1
result[y-1][x-1] = 1

warshall_floyd(result, n)

result_hash = [0] * (n-1)
for i in range(n):
    for j in range(n):
        if result[i][j] == 0:
            continue
        result_hash[result[i][j] - 1] += 1

for i in range(n-1):
    print((int(result_hash[i] / 2)))


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

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

count = [0] * (N-1)


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


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

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

count = [0] * (N-1)


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


print(("\n".join(map(str,count))))
# Original solution
# Using BFS
import queue
from collections import defaultdict
import sys


def input():
    return sys.stdin.readline()


def push(v, d, dist, q, INF=1e10):
    if dist[v] != INF:
        return
    dist[v] = d
    q.put(v)


def main():
    n, x, y = list(map(int, input().split()))
    # modify the values of x, y so that they start from zero
    x, y = x - 1, y - 1
    INF = 1e10
    ans = defaultdict(int)
    for i in range(n):
        # dist[idx]: distance between i and idx.
        dist = [INF] * n
        q = queue.Queue()
        push(i, 0, dist, q)
        while not q.empty():
            v = q.get()
            d = dist[v]
            if v - 1 >= 0:
                push(v-1, d+1, dist, q)
            if v + 1 < n:
                push(v+1, d+1, dist, q)
            if v == x:
                push(y, d+1, dist, q)
            if v == y:
                push(x, d+1, dist, q)

            ans[dist[v]] += 1

    for i in range(n):
        if i != 0:
            print((ans[i] // 2))


if __name__ == "__main__":
    main()

# Optimized solution
# Using BFS
from collections import defaultdict, deque
import sys


def input():
    return sys.stdin.readline()


def push(v, d, dist, q, INF=1e10):
    if dist[v] != INF:
        return
    dist[v] = d
    q.append(v)


def main():
    n, x, y = list(map(int, input().split()))
    # modify the values of x, y so that they start from zero
    x, y = x - 1, y - 1
    INF = 1e10
    ans = defaultdict(int)
    for i in range(n):
        # dist[idx]: distance between i and idx.
        dist = [INF] * n
        q = deque()
        push(i, 0, dist, q)
        while len(q) != 0:
            v = q.popleft()
            d = dist[v]
            if v - 1 >= 0:
                push(v-1, d+1, dist, q)
            if v + 1 < n:
                push(v+1, d+1, dist, q)
            if v == x:
                push(y, d+1, dist, q)
            if v == y:
                push(x, d+1, dist, q)

            ans[dist[v]] += 1

    for i in range(n):
        if i != 0:
            print((ans[i] // 2))


if __name__ == "__main__":
    main()
# Original solution
N, X, Y = list(map(int, input().split()))

dist = [[0 for _ in range(N)] for _ in range(N)]
ans = [0 for _ in range(N)]

for i in range(N):
    for j in range(i, N):
        tmp1 = abs(i - X + 1) + abs(j - Y + 1) + 1
        tmp2 = abs(i - Y + 1) + abs(j - X + 1) + 1
        min_dist = min(abs(i - j), tmp1, tmp2)

        ans[min_dist - 1] += 1

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

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

ans = [0 for _ in range(N)]

for i in range(N):
    for j in range(i+1, N):
        tmp1 = abs(i - X + 1) + abs(j - Y + 1) + 1
        tmp2 = abs(i - Y + 1) + abs(j - X + 1) + 1
        min_dist = min(abs(i - j), tmp1, tmp2)

        ans[min_dist - 1] += 1

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

# Optimized solution
n,x,y=list(map(int,input().split()))
ans=[0]*n
for i in range(1,n):
    for j in range(i+1,n+1):
        ans[int(min(j-i,abs(x-i)+abs(y-j)+1))]+=1
for i in range(1,n):
    print((ans[i]))
# Original solution
# -*- coding: utf-8 -*-
# D - Line++
# 標準入力の取得
N,X,Y = list(map(int, input().split()))

# 求解
# (i, j)間の最短距離はmin{|j-i|, |X-i|+1+|j-Y|, |Y-i|+1+|j-X|}であるため、
# (i, j)が決まれば、最短距離はO(1)で決まる。したがって、全(i, j)について、最短距離を求める。
k_list = [0 for i in range(1,N)]
for i in range(1, N):
    for j in range(i+1, N+1):
        min_path = min([abs(j-i), abs(X-i)+1+abs(j-Y), abs(Y-i)+1+abs(j-X)])
        k_list[min_path-1] += 1

# 結果出力
for k in k_list:
    print(k)

# Optimized solution
# -*- coding: utf-8 -*-
# D - Line++
# 標準入力の取得
N,X,Y = list(map(int, input().split()))

# 求解
# (i, j)間の最短距離はmin{|j-i|, |X-i|+1+|j-Y|, |Y-i|+1+|j-X|}であるため、
# (i, j)が決まれば、最短距離はO(1)で決まる。したがって、全(i, j)について、最短距離を求める。
k_list = [0 for i in range(1,N)]
for i in range(1, N):
    diff_X_i = abs(X - i)
    diff_Y_i = abs(Y - i)
    for j in range(i+1, N+1):
        diff_j_i = abs(j - i)
        diff_j_X = abs(j - X)
        diff_j_Y = abs(j - Y)
        min_path = min([diff_j_i, diff_X_i+1+diff_j_Y, diff_Y_i+1+diff_j_X])
        k_list[min_path-1] += 1

# 結果出力
for k in k_list:
    print(k)
# Original solution
# -*- coding: utf-8 -*-
# D - Line++
# 標準入力の取得
N,X,Y = list(map(int, input().split()))

# 求解
# (i, j)間の最短距離はmin{|j-i|, |X-i|+1+|j-Y|, |Y-i|+1+|j-X|}であるため、
# (i, j)が決まれば、最短距離はO(1)で決まる。したがって、全(i, j)について、最短距離を求める。
k_list = [0 for i in range(1,N)]
for i in range(1, N):
    diff_X_i = abs(X - i)
    diff_Y_i = abs(Y - i)
    for j in range(i+1, N+1):
        diff_j_i = abs(j - i)
        diff_j_X = abs(j - X)
        diff_j_Y = abs(j - Y)
        min_path = min([diff_j_i, diff_X_i+1+diff_j_Y, diff_Y_i+1+diff_j_X])
        k_list[min_path-1] += 1

# 結果出力
for k in k_list:
    print(k)

# Optimized solution
# -*- coding: utf-8 -*-
# D - Line++
# 標準入力の取得
N,X,Y = list(map(int, input().split()))

# 求解
# (i, j)間の最短距離はmin{|j-i|, |X-i|+1+|j-Y|}であるため、
# (i, j)が決まれば、最短距離はO(1)で決まる。したがって、全(i, j)について、最短距離を求める。
k_list = [0 for i in range(1,N)]
for i in range(1, N):
    for j in range(i+1, N+1):
        min_path = min([abs(j-i), abs(X-i)+1+abs(j-Y)])
        k_list[min_path-1] += 1

# 結果出力
for k in k_list:
    print(k)
# Original solution
# -*- coding: utf-8 -*-

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

mid = (X + Y + 1) * 0.5

# GUCHOKU

ans = [0] * N

for i in range(1, N):
    for j in range(i, N + 1):
        # (i, j)について距離を調べる
        # if j >= mid:
        #    dis = X - i + 1 + abs(j - Y)
        # else:
        #    j - i
        dis = min(abs(i - X) + abs(j - Y) + 1, j - i)
        ans[dis] += 1

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


# Optimized solution
# -*- coding: utf-8 -*-

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

mid = (X + Y + 1) * 0.5

# GUCHOKU
ans = [0] * N

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

print(*ans[1:], sep='\n')
# Original solution
import collections
def main():
    N,X,Y = list(map(int, input().split()))
    # 扱いやすいようにX,Yはインデックス表記にしておく
    X -= 1
    Y -= 1
    # i<jを満たす(i,j)について6通りの場合分けして全最短距離を求められる
    shortest = [[-1]*N for _ in range(N)]
    for i in range(N):
        k1 = abs(X-i)
        for j in range(i+1,N):
            k2 = abs(j-Y)
            shortest[i][j] = min(j-i, k1+1+k2)

    coll = [collections.Counter(s) for s in shortest]
    for i in range(1,N):
        count = 0
        for j in range(N):
            count += coll[j].get(i,0)
        print(count)
main()


# Optimized solution
import collections
def main():
    N,X,Y = list(map(int, input().split()))
    # 扱いやすいようにX,Yはインデックス表記にしておく
    X -= 1
    Y -= 1
    # i<jを満たす(i,j)について6通りの場合分けして全最短距離を求められる
    shortest = [[-1]*N for _ in range(N)]
    coll = collections.Counter()
    for i in range(N):
        k1 = abs(X-i)
        for j in range(i+1,N):
            k2 = abs(j-Y)
            shortest[i][j] = min(j-i, k1+1+k2)
        coll += collections.Counter(shortest[i])

    for i in range(1,N):
        print((coll.get(i,0)))
        
main()
# Original solution
N, X, Y = [int(n) for n in input().split(' ')]

cnt = [0]*N

for i in range(1, N):  # 1~N-1
    for j in range(i+1, N+1):  # 2~N
        p = []
        p += [j - i]
        if i <= X:
            if j >= Y:
                p += [X-i + j-Y + 1]
            else:
                p += [X-i + Y-j + 1]
        else:
            if j >= Y:
                p += [i-X + j-Y + 1]
            else:
                p += [i-X + Y-j + 1]
        cnt[min(p)] += 1


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


# Optimized solution
N, X, Y = [int(n) for n in input().split(' ')]

cnt = [0]*N

for i in range(1, N):  # 1~N-1
    for j in range(i+1, N+1):  # 2~N
        if i <= X:
            if j >= Y:
                p = min(X-i + j-Y + 1, j - i)
            else:
                p = min(X-i + Y-j + 1, j - i)
        else:
            if j >= Y:
                p = min(i-X + j-Y + 1, j - i)
            else:
                p = min(i-X + Y-j + 1, j - i)
        cnt[p] += 1


for i in range(1, N):
    print((cnt[i]))
# Original solution
from collections import Counter
def min_distance(i,j):
    return min(abs(i-j),abs(x-i)+1+abs(y-j),abs(y-i)+1+abs(x-j))
               
n,x,y=list(map(int,input().split()))
x=x-1
y=y-1
dp=[]
for i in range(n):
    for j in range(n):
        dp.append(min_distance(i,j))
dic=Counter(dp)
for i in range(1,n):
    print((int(dic[i]/2)))
    
        
     

# Optimized solution
from collections import Counter
def min_distance(i,j):
    return min(abs(i-j),abs(x-i)+1+abs(y-j),abs(y-i)+1+abs(x-j))
               
n,x,y=list(map(int,input().split()))
x=x-1
y=y-1
dp=[]
for i in range(n-1):
    for j in range(i+1,n):
        dp.append(min_distance(i,j))
dic=Counter(dp)
for i in range(1,n):
    print((int(dic[i])))
# Original solution
from collections import deque
from collections import Counter

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

    counter = Counter()
    for i in range(1,N+1):
        distance = [float("inf")]*(N+1)
        q = deque()
        q.append(i)
        distance[i] = 0
        while q:
            p = q.popleft()
            if p != 1 and p != N:
                if distance[p+1] == float("inf"):
                    if distance[p]+1 < distance[p+1]:
                        distance[p+1] = distance[p]+1
                        q.append(p+1)
                        counter[distance[p]+1] += 1
                if distance[p-1] == float("inf"):
                    if distance[p]+1 < distance[p-1]:
                        distance[p-1] = distance[p]+1
                        q.append(p-1)
                        counter[distance[p]+1] += 1
            elif p == 1:
                if distance[p+1] == float("inf"):
                    if distance[p]+1 < distance[p+1]:
                        distance[p+1] = distance[p]+1
                        q.append(p+1)
                        counter[distance[p]+1] += 1
            else:
                if distance[p-1] == float("inf"):
                    if distance[p]+1 < distance[p-1]:
                        distance[p-1] = distance[p]+1
                        q.append(p-1)
                        counter[distance[p]+1] += 1
            if p == X:
                if distance[p]+1 < distance[Y]:
                    distance[Y] = distance[p]+1
                    q.append(Y)
                    counter[distance[p]+1] += 1
            if p == Y:
                if distance[p]+1 < distance[X]:
                    distance[X] = distance[p]+1
                    q.append(X)
                    counter[distance[p]+1] += 1

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

if __name__ == "__main__":
    main()

# Optimized solution
from collections import Counter

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

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

if __name__ == "__main__":
    main()
# Original solution
N,X,Y = map(int,input().split())
X,Y = X-1,Y-1
from collections import deque

DP = [[-1]*N for _ in range(N)]

ans = [0]*N

for i in range(N):
    for j in range(i+1,N):
        x = j - (i+1)
        y = j
        if j <= X or Y <= i:
            DP[i][j] = j - i
        elif i <= X and Y <= j:
            DP[i][j] = X-i + 1 + j-Y
        elif i <= X and j <= Y:
            DP[i][j] = min(j-i,X-i + 1 + Y-j)
        elif X <= i and j <= Y:
            DP[i][j] = min(j-i,i-X+1+Y-j)
        else:
            DP[i][j] = min(j-i,i-X+1+j-Y)
        ans[DP[i][j]] += 1

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


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

ans = [0]*N

for i in range(N):
    for j in range(i+1,N):
        if j <= X or Y <= i:
            a = j - i
        elif i <= X and Y <= j:
            a = X-i + 1 + j-Y
        elif i <= X and j <= Y:
            a = min(j-i,X-i + 1 + Y-j)
        elif X <= i and j <= Y:
            a = min(j-i,i-X+1+Y-j)
        else:
            a = min(j-i,i-X+1+j-Y)
        ans[a] += 1

print(*ans[1:],sep='\n')
# Original solution
n, x, y = list(map(int, input().split()))

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

for a in ans:
    print(a)
 


# 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):
    d = min(j-i, abs(i-x+1)+abs(j-y+1)+1)
    ans[d] += 1

ans=ans[1:]

for a in ans:
    print(a)
# Original solution
N,X,Y=list(map(int,input().split()))
count=[0]*(N-1)
for i in range(1,N+1):
    for j in range(i+1,N+1):
        d=[]
        d.append(abs(j-i))
        d.append(abs(X-i)+1+abs(j-Y))
        d.append(abs(Y-i)+1+abs(j-X))
        count[min(d)-1]+=1
for k in count:
    print(k)

# Optimized solution
N,X,Y=list(map(int,input().split()))
count=[0]*(N-1)
for i in range(1,N):
    for j in range(i+1,N+1):
        num=min(abs(j-i),abs(X-i)+1+abs(j-Y),abs(Y-i)+1+abs(j-X))
        #d=[]
        
        #d.append(abs(j-i))
        #d.append(abs(X-i)+1+abs(j-Y))
        #d.append(abs(Y-i)+1+abs(j-X))
        count[num-1]+=1
for k in count:
    print(k)
# Original solution
from queue import Queue
N, X, Y = list(map(int, input().split()))

X -= 1
Y -= 1

q = Queue()

ans = [0] * N

def BFS(x, cnt):
    if dist[x] != (N + 1):
        return
    cnt += 1
        
    dist[x] = cnt
    if x + 1 < N:
        q.put((x + 1, cnt))
    if x - 1 >= 0:
        q.put((x - 1, cnt))
    if x == X:
        q.put((Y, cnt))
    if x == Y:
        q.put((X, cnt))


for x in range(N):
    dist = [N + 1] * N
    q.put((x, -1))
    while not q.empty():
        BFS(*q.get())

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

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






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

X -= 1
Y -= 1

q = deque()

ans = [0] * N

def BFS(x, cnt):
    if dist[x] != (N + 1):
        return
    cnt += 1
        
    dist[x] = cnt
    if x + 1 < N:
        q.append((x + 1, cnt))
    if x - 1 >= 0:
        q.append((x - 1, cnt))
    if x == X:
        q.append((Y, cnt))
    if x == Y:
        q.append((X, cnt))


for x in range(N):
    dist = [N + 1] * N
    q.append((x, -1))
    while q:
        BFS(*q.popleft())

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

for x in range(1, N):
    print((ans[x] // 2))
# Original solution
#!/usr/bin/env python3
N, X, Y = [int(str) for str in input().strip().split()]

INF = 100000
d = [[INF] * N for _ in range(N)]

for i in range(N - 1):
    d[i][i + 1] = 1
    d[i + 1][i] = 1
d[X - 1][Y - 1] = 1
d[Y - 1][X - 1] = 1

for k in range(N):
    for i in range(N):
        for j in range(N):
            d[i][j] = min(d[i][j], d[i][k] + d[k][j])

dists = dict()
for i in range(N):
    for j in range(i + 1, N):
        k = d[i][j]
        dists[k] = dists.get(k, 0) + 1

for k in range(1, N):
    print((dists.get(k, 0)))

# Optimized solution
#!/usr/bin/env python3
N, X, Y = [int(str) for str in input().strip().split()]

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

for k in range(1, N):
    print((dists[k]))
# Original solution
n, x, y = list(map(int, input().split()))

dis_list = [0] * (n - 1)

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

for i in dis_list:
    print(i)

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

dis_list = [0] * (n - 1)

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

for i in dis_list:
    print(i)
# Original solution
import collections

N,X,Y=list(map(int,input().split()))
if X > Y:
    exc=X
    X=Y
    Y=exc
L=[]
for i in range(N-1):
    for j in range(i+1,N):
        if i >= Y-1 or j <= X-1:
            L.append(j-i)
        elif j-i == 1:
            L.append(1)
        elif i <= X-1 and j >= Y-1:
            L.append(1+abs(X-1-i)+abs(Y-1-j))
        elif i >= X-1 and i-(X-1) > (Y-1)-i:
            L.append(j-i)            
        else:
            L1=j-i
            L2=min(j-i,1+abs(X-1-i)+abs(Y-1-j))
            L.append(min(L1,L2))

c=collections.Counter(L)

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




# Optimized solution
N,X,Y=list(map(int,input().split()))
if X > Y:
    exc=X
    X=Y
    Y=exc
L=[0]*N
for i in range(N-1):
    for j in range(i+1,N):
        if i >= Y-1 or j <= X-1 or j-i ==1:
            L[j-i]+=1
        elif i <= X-1 and j >= Y-1:
            L[1+abs(X-1-i)+abs(Y-1-j)]+=1
        elif i >= X-1 and i-(X-1) > (Y-1)-i:
            L[j-i]+=1
        else:
            L1=j-i
            L2=min(j-i,1+abs(X-1-i)+abs(Y-1-j))
            L[min(L1,L2)]+=1

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