CodeEff/ECCO huggingface dataset:
# Original solution
n, x, y = list(map(int, input().split()))
ans = [0] * n
for i in range(1, n+1):
    for j in range(1, n+1):
        r = min(
            abs(i-j),
            abs(x-i) + 1 + abs(y-j),
            abs(y-i) + 1 + abs(x-j)
        )
        if r > n-1:
            continue
        ans[r] += 1

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

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

print(("\n".join(map(str, ans[1:]))))
# Original solution
from collections import deque, Counter
N, X, Y = list(map(int, input().split()))
G = [[0]*N for _ in range(N)]
for i in range(N-1):
    G[i][i+1] = 1
    G[i+1][i] = 1
G[X-1][Y-1] = 1
G[Y-1][X-1] = 1

def bfs():
    C = Counter([i+1 for i in range(N)])
    for i in range(N):
        color = ['W']*N
        D = [10**5]*N
        D[i] = 0
        color[i] = 'B'
        Q = deque([])
        Q.append(i)
        idx = 1
        while Q:
            q = Q.popleft()
            for j in range(N):
                if q == j:
                    continue
                if G[q][j] == 1 and color[j] != 'B':
                    color[j] = 'G'
                    D[j] = min(D[q]+1, D[j])
                    Q.append(j)
                color[q] = 'B'
        for d in D:
            C[d] += 1
    return C

C = bfs()

for k in range(1, N):
    ans = C[k]//2
    print(ans)

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

print(*ans, sep='\n')
# Original solution
import itertools

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

for i in range(1, N+1):
    for j in range(i, N+1):
        result.append(min(abs(j-i), abs(X-i) + 1 + abs(j-Y), abs(Y-i)+1+abs(j-X)))

for i in range(1, N):
    print((result.count(i)))


# Optimized solution
import itertools

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

# dp = [[float('inf')] * (N+1) for _ in range(N+1)]
# # dp[Y][X] = 1
# dp[X][Y] = 1

# for i in range(1,N+1):
#     for j in range(i,N+1):
#         if i == j:
#             dp[i][j] = 0
#         elif i == X and j == Y:
#             dp[X][Y] = 1
#         elif i <= X:
#             dp[i][j] = min(dp[i][j-1] + 1, dp[i][X] + abs(Y - j) + 1)
#         else:
#             dp[i][j] = min(dp[i][j-1]+ 1, abs(i - X)+ abs(Y - j) + 1 )

# dp = list(itertools.chain.from_iterable(dp))
# for i in range(1,N):
#     print(dp.count(i))

result = [0] * N

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

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

import heapq

def dijkstra(s):
    hq = [(0, s)]
    heapq.heapify(hq) # リストを優先度付きキューに変換
    cost = [float('inf')] * n # 行ったことのないところはinf
    cost[s] = 0 # 開始地点は0
    while hq:
        c, v = heapq.heappop(hq)
        if c > cost[v]: # コストが現在のコストよりも高ければスルー
            continue
        for d, u in e[v]:
            tmp = d + cost[v]
            if tmp < cost[u]:
                cost[u] = tmp
                heapq.heappush(hq, (tmp, u))
    return cost

e = [[] for _ in range(n)]
for i in range(n-1):
    e[i].append((1, i+1))
    e[i+1].append((1, i)) # 有向グラフでは削除
e[x-1].append((1, y-1))
e[y-1].append((1, x-1))

d = [dijkstra(i) for i in range(n)]
d = [sorted(d[i][i:]) for i in range(n)]

import bisect

for i in range(1,n):
    ans = 0
    for j in range(n):
        ans += bisect.bisect_right(d[j], i) - bisect.bisect_left(d[j], i)
    print(ans)

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

import heapq

def dijkstra(s):
    hq = [(0, s)]
    heapq.heapify(hq) # リストを優先度付きキューに変換
    cost = [float('inf')] * n # 行ったことのないところはinf
    cost[s] = 0 # 開始地点は0
    while hq:
        c, v = heapq.heappop(hq)
        if c > cost[v]: # コストが現在のコストよりも高ければスルー
            continue
        for d, u in e[v]:
            tmp = d + cost[v]
            if tmp < cost[u]:
                cost[u] = tmp
                heapq.heappush(hq, (tmp, u))
    return cost

e = [[] for _ in range(n)]
for i in range(n-1):
    e[i].append((1, i+1))
    e[i+1].append((1, i)) # 有向グラフでは削除
e[x-1].append((1, y-1))
e[y-1].append((1, x-1))

d = [sorted(dijkstra(i)[i:]) for i in range(n)]

import bisect

for i in range(1,n):
    ans = 0
    for j in range(n):
        ans += bisect.bisect_right(d[j], i) - bisect.bisect_left(d[j], i)
    print(ans)
# Original solution
from collections import deque

class Node:
    def __init__(self, idx):
        self.idx = idx
        self.a = []


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

for i in range(n):
    node = Node(i+1)
    nodes.append(node)

for i in range(n-1):
    cur = nodes[i]
    next = nodes[i+1]

    cur.a.append(next)
    next.a.append(cur)

X = nodes[x-1]
Y = nodes[y-1]
X.a.append(Y)
Y.a.append(X)
dp = [[None] * (n+1) for _ in range(n+1)]

for i in range(n):
    node = nodes[i]
    q = deque()
    q.append((node, 0))
    done = set()

    while q:
        t = q.popleft()
        node, d = t[0], t[1]

        if node.idx not in done:
            dp[i + 1][node.idx] = d
            done.add(node.idx)
            for adj in node.a:
                q.append((adj, d + 1))

# for i in range(1, n+1):
#     print(dp[i])

for k in range(1, n):
    temp = 0
    for i in range(1, n+1):
        for j in range(1, n+1):
            if dp[i][j] == k:
                temp += 1
    print((temp//2))

# Optimized solution
from collections import deque

class Node:
    def __init__(self, idx):
        self.idx = idx
        self.a = []


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

for i in range(n):
    node = Node(i+1)
    nodes.append(node)

for i in range(n-1):
    cur = nodes[i]
    next = nodes[i+1]

    cur.a.append(next)
    next.a.append(cur)

X = nodes[x-1]
Y = nodes[y-1]
X.a.append(Y)
Y.a.append(X)
dp = [[None] * (n+1) for _ in range(n+1)]

for i in range(n):
    node = nodes[i]
    q = deque()
    q.append((node, 0))
    done = set()

    while q:
        t = q.popleft()
        node, d = t[0], t[1]

        if node.idx not in done:
            dp[i + 1][node.idx] = d
            done.add(node.idx)
            for adj in node.a:
                q.append((adj, d + 1))

# for i in range(1, n+1):
#     print(dp[i])

m = {}

for i in range(1, n + 1):
    for j in range(1, n + 1):
        dis = dp[i][j]
        if dis in m:
            m[dis] += 1
        else:
            m[dis] = 1

for k in range(1, n):
    if k in m:
        print((m[k] // 2))
    else:
        print((0))
# Original solution
import sys
from heapq import heapify, heappop, heappush

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

def dijkstra(start):
    INF = 10 ** 10
    dist = [INF] * (N+1)
    dist[start] = 0
    que = [(0,start)]
    while que:
        d, prev = heappop(que)
        if dist[prev] < d:
            continue
        for next in graph[prev]:
            d1 = d + 1
            if dist[next] > d1:
                dist[next] = d1
                heappush(que, (d1, next))
    return dist

N, X, Y = lr()
answer = [0] * N # 1-indexed
graph = [[] for _ in range(N+1)] # 1-indexed
for i in range(1, N):
    graph[i].append(i+1)
    graph[i+1].append(i)
graph[X].append(Y)
graph[Y].append(X)

dist_X = dijkstra(X)
dist_Y = dijkstra(Y)
for i in range(1, N):
    for j in range(i+1, N+1):
        d = min(j-i, dist_X[i] + dist_X[j], dist_Y[i] + dist_Y[j])
        answer[d] += 1

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


# Optimized solution
# coding: utf-8
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

N, X, Y = lr()
dis = [[0] * (N+1) for _ in range(N+1)]
for i in range(1, N):
    for j in range(i+1, N+1):
        dis[i][j] = j - i
        dis[j][i] = j - i

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

answer = [0] * (N)
for i in range(1, N):
    for j in range(i+1, N+1):
        d = dis[i][j]
        answer[d] += 1

print(('\n'.join(map(str, answer[1:]))))
# Original solution
# -*- coding: utf-8 -*-
import collections
N,X,Y = list(map(int,input().split()))
ToltN=N*(N-1)/2
Dist=[[0 for i in range(N)] for i in range(N)]
for i in range(N):
    for j in range(i,N):    
        MyDist=abs(i-(X-1))+abs(j-(Y-1))+1
        if MyDist<j-i:
            Dist[i][j]=MyDist
        else:
            Dist[i][j] = j-i
for j in range(N-1):
    ans=[0]
    for i in range(N):
        ans+=Dist[i]
c = collections.Counter(ans)
for i in range(N-1):
    print((c[i+1]))


# Optimized solution
# -*- coding: utf-8 -*-
import collections
N,X,Y = list(map(int,input().split()))
ToltN=N*(N-1)/2
Dist=[[0 for i in range(N)] for i in range(N)]
c=[0]*N
for i in range(N):
    for j in range(i+1,N):
        MyDist=abs(i-(X-1))+abs(j-(Y-1))+1
        if MyDist<j-i:
            Dist[i][j]=MyDist
            c[MyDist-1]+=1
        else:
            Dist[i][j] = j-i
            c[j-i-1]+=1
for i in range(N-1):
    print((c[i]))
# Original solution
n, x, y = list(map(int, input().split()))

ans = dict.fromkeys(list(range(1, n)), 0)

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

for v in list(ans.values()):
    print(v)


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

ans = [0] * n

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

for e in ans[1:]:
    print(e)
# Original solution
from itertools import combinations
N,X,Y = list(map(int, input().split()))
ans = [0]*(N-1)
for a,b in combinations(list(range(N)),2):
    c = min([abs(a-b), abs(X-1-a)+abs(Y-1-b)+1, abs(Y-1-a)+abs(X-1-b)+1])
    ans[c-1] += 1
print(("\n".join([str(i) for i in ans])))

# Optimized solution
from itertools import combinations
N,X,Y = list(map(int, input().split()))
ans = [0]*(N-1)
for a,b in combinations(list(range(N)),2):
  c = min([abs(a-b), abs(X-1-a)+abs(Y-1-b)+1, abs(Y-1-a)+abs(X-1-b)+1])
  ans[c-1] += 1
for i in ans: print(i)
# Original solution
from collections import deque, Counter

INF = float("inf")

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

E = [[] for _ in range(N + 1)]
for i in range(1, N):
    E[i].append(i + 1)
    E[i + 1].append(i)
E[X].append(Y)
E[Y].append(X)

C = Counter()
for s in range(1, N + 1):
    dist = [INF] * (N + 1)
    dist[s] = 0
    Q = deque([s])
    while Q:
        p = Q.popleft()
        for c in E[p]:
            if dist[c] > dist[p] + 1:
                dist[c] = dist[p] + 1
                Q.append(c)
    C.update(dist)

for k in range(1, N):
    print((C[k] // 2))

# Optimized solution
from itertools import combinations

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

A = [0] * N
for i, j in combinations(list(range(1, N + 1)), 2):
    A[min(abs(i - j), abs(X - i) + abs(Y - j) + 1, abs(X - j) + abs(Y - i) + 1)] += 1

for a in A[1:]:
    print(a)
# Original solution
n, x, y = list(map(int,input().split()))

cnt = 0

ans=[0]*n

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

# Optimized solution
def main():

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

    cnt = 0

    ans=[0]*n

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

    for i in range(1,n):
        print((ans[i]))
   
if __name__ == "__main__":
    main()
# Original solution
n, x, y = list(map(int, input().split()))

inf = 1000000000
edges = [[inf] * n for _ in range(n)]
for i in range(n - 1):
    edges[i][i + 1] = 1
    edges[i + 1][i] = 1

edges[x - 1][y - 1] = 1

for k in range(n):
    for i in range(n):
        for j in range(n):
            edges[i][j] = min(edges[i][j], edges[i][k] + edges[k][j])

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

for x in cnts:
    print(x)


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

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

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

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

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

for i in range(1,n):
    print((ans[i]))
# Original solution
N,X,Y = list(map(int,input().split()))
ans = [0]*(N-1)
X , Y = X-1 , Y-1#配列の場所に合わせる

for i in range(N):
  for k in range(N):
    if i == k:
      pass
    else:
      if i < k:
        ans_ = min(abs(k-i),abs(X-i)+abs(Y-k)+1)
        ans[ans_-1] += 1
      else:
        ans_ = min(abs(k-i),abs(X-k)+abs(Y-i)+1)
        ans[ans_-1] += 1

ans = [int(i/2) for i in ans]

for i in ans:
  print(i)

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

L=[[i+1 for i in range(j+1)][::-1]+[0]*(N-1-j) for j in range(N-1)]
for i in range(len(L)):
    L[i]=[0]+L[i]+[0]
L.append([0]*(N+2))
L.insert(0,[0]*(N+2))
L.insert(0,[0]*(N+2))

H=[i+1 for i in range(N-1)][::-1]

L[Y][X]=1
task=[(Y,X,1)]
while len(task)>0:
    P=task.pop()
    y,x,c=P[0],P[1],P[2]
    if y<0 or x<0 or y>N or x>N:
        continue
    if L[y+1][x]>c+1:
        L[y+1][x]=c+1
        task.append((y+1,x,c+1))
    if L[y-1][x]>c+1:
        L[y-1][x]=c+1
        task.append((y-1,x,c+1))
    if L[y][x+1]>c+1:
        L[y][x+1]=c+1
        task.append((y,x+1,c+1))
    if L[y][x-1]>c+1:
        L[y][x-1]=c+1
        task.append((y,x-1,c+1))
    #print(y,x,c)
    #print(numpy.array(L))

LL=[]
for i in range(len(L)):
    LL+=L[i]

import collections
D=collections.Counter(LL)
d=list(D.values())
d.pop(0)
d+=[0]*(max(N-len(d)-1,0))

for i in d:
    print(i)


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

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

ans.pop(0)
for i in ans:
    print(i)
# Original solution
n, x, y = list(map(int, input().split()))
ans = [0] * n
a = [n] * n
x -= 1
y -= 1
for i in range(0, n):
    a = [n] * n
    a[i] = 0
    for j in range(i, 0, -1):
        if j == x:
            a[y] = min(a[y], a[j] + 1)
        if j == y:
            a[x] = min(a[x], a[j] + 1)
        a[j - 1] = min(a[j - 1], a[j] + 1)
    for j in range(i, n - 1):
        if j == x:
            a[y] = min(a[y], a[j] + 1)
        if j == y:
            a[x] = min(a[x], a[j] + 1)
        a[j + 1] = min(a[j + 1], a[j] + 1)
    for j in range(x, 0, -1):
        if j == x:
            a[y] = min(a[y], a[j] + 1)
        if j == y:
            a[x] = min(a[x], a[j] + 1)
        a[j - 1] = min(a[j - 1], a[j] + 1)
    for j in range(x, n - 1):
        if j == x:
            a[y] = min(a[y], a[j] + 1)
        if j == y:
            a[x] = min(a[x], a[j] + 1)
        a[j + 1] = min(a[j + 1], a[j] + 1)
    for j in range(y, 0, -1):
        if j == x:
            a[y] = min(a[y], a[j] + 1)
        if j == y:
            a[x] = min(a[x], a[j] + 1)
        a[j - 1] = min(a[j - 1], a[j] + 1)
    for j in range(y, n - 1):
        if j == x:
            a[y] = min(a[y], a[j] + 1)
        if j == y:
            a[x] = min(a[x], a[j] + 1)
        a[j + 1] = min(a[j + 1], a[j] + 1)
    for k in range(0, n):
        if k != i:
            ans[a[k]] += 1
for i in range(1, n):
    print((ans[i] // 2))


# Optimized solution
n, x, y = list(map(int, input().split()))
ans = [0] * n
a = [n] * n
x -= 1
y -= 1
for i in range(0, n):
    a = [n] * n
    a[i] = 0
    b = [i, x, y, x, y]
    for k in b:
        for j in range(k, 0, -1):
            if j == x:
                a[y] = min(a[y], a[j] + 1)
            if j == y:
                a[x] = min(a[x], a[j] + 1)
            a[j - 1] = min(a[j - 1], a[j] + 1)
        for j in range(k, n - 1):
            if j == x:
                a[y] = min(a[y], a[j] + 1)
            if j == y:
                a[x] = min(a[x], a[j] + 1)
            a[j + 1] = min(a[j + 1], a[j] + 1)
    for k in range(0, n):
        ans[a[k]] += 1
for i in range(1, n):
    print((ans[i] // 2))
# Original solution
from itertools import combinations
N, X, Y = list(map(int, input().split()))

result = []
for i, j in combinations(list(range(1, N+1)), 2):
    mins = min([j-i, abs(Y-j)+abs(X-i)+1])
    result.append(mins)
print(N)
for i in range(1, N-1):
    print((result.count(i+1)))

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

result = [0]*N
for i, j in combinations(list(range(1, N+1)), 2):
    mins = min([j-i, abs(Y-j)+abs(X-i)+1])
    result[mins] += 1
    
for i in range(1, N):
    print((result[i]))
# Original solution
n,x,y = list(map(int,input().split()))

def dijkstra(s,n,w,cost):
    #始点sから各頂点への最短距離
    #n:頂点数, w:辺の数, cost[u][v] : 辺uvのコスト(存在しないときはinf)
    d = [float("inf")] * n
    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(n):
               d[j] = min(d[j],d[v]+cost[v][j])
    return d

dis = [[float('inf')] * n for _ in range(n)]
ans = [0] * (n-1)
for i in range(n):
    for j in range(n):
        if abs(i - j) == 1:
            dis[i][j] = 1
dis[x-1][y-1] = 1
dis[y-1][x-1] = 1

for i in range(n):
    d = dijkstra(i, n, n, dis)
    for j in d:
        if j > 0:
            ans[j-1] += 1

for i in ans:
    print((i//2))


# Optimized solution
import heapq

def dijkstra(edges, s):
    hq = []
    d = [-1] * n
    d[s] = 0
    heapq.heappush(hq, (0, s))
    while hq:
        d1, p = heapq.heappop(hq)
        for i in edges[p]:
            if d[i] == -1 or d[i] > d1 + 1:
                d[i] = d1 + 1
                heapq.heappush(hq, (d1+1, i))
    return d

n,x,y = list(map(int,input().split()))
edges = [[] for _ in range(n)]

for i in range(n):
    if i == 0:
        edges[i].append(i+1)
    elif i == n-1:
        edges[i].append(i-1)
    else:
        edges[i].append(i-1)
        edges[i].append(i+1)
edges[x-1].append(y-1)
edges[y-1].append(x-1)

ans = [0] * (n-1)

for i in range(n):
    d = dijkstra(edges, i)
    for j in d:
        if j != 0:
            ans[j-1] += 1

for i in ans:
    print((i//2))
# Original solution
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from bisect import bisect_left #bisect_left(list, value)
import heapq
#from fractions import gcd
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
def pri(x): print(('\n'.join(map(str, x))))

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

def dijkstra_heap(s):
    #始点sから各頂点への最短距離
    d = [float("inf")] * N
    used = [True] * N #True:未確定
    d[s] = 0
    used[s] = False
    edgelist = []
    for e in edge[s]:
        heapq.heappush(edgelist,e)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        if not used[minedge[1]]:
            continue
        v = minedge[1]
        d[v] = minedge[0]
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,[e[0]+d[v],e[1]])
    return d

# n,w = map(int,input().split()) #n:頂点数　w:辺の数

edge = [[] for i in range(N)]

for i in range(1, N-1):
    edge[i].append([1, i+1])
    edge[i].append([1, i-1])
edge[0].append([1, 1])
edge[N-1].append([1, N-2])
edge[X-1].append([1, Y-1])
edge[Y-1].append([1, X-1])

dd = defaultdict(int)
for i in range(N):
    dists = dijkstra_heap(i)
    for j in dists[i+1:]:
        dd[j] += 1

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


# Optimized solution
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from bisect import bisect_left #bisect_left(list, value)
import heapq
#from fractions import gcd
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
def pri(x): print(('\n'.join(map(str, x))))

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

def dijkstra_heap(s,edge):
    d = [10**20] * N
    used = [True] * N #True:未確定
    d[s] = 0
    used[s] = False
    edgelist = []
    for a,b in edge[s]:
        heapq.heappush(edgelist,a*(10**6)+b)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        if not used[minedge%(10**6)]:
            continue
        v = minedge%(10**6)
        d[v] = minedge//(10**6)
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist,(e[0]+d[v])*(10**6)+e[1])
    return d
# n,w = map(int,input().split()) #n:頂点数　w:辺の数

edge = [[] for i in range(N)]

for i in range(1, N-1):
    edge[i].append([1, i+1])
    edge[i].append([1, i-1])
edge[0].append([1, 1])
edge[N-1].append([1, N-2])
edge[X-1].append([1, Y-1])
edge[Y-1].append([1, X-1])

dd = defaultdict(int)
for i in range(N):
    dists = dijkstra_heap(i, edge)
    for j in dists[i+1:]:
        dd[j] += 1

for k in range(1, N):
    print((dd[k]))
# Original solution
#設定
import sys
input = sys.stdin.buffer.readline

#ライブラリインポート
from collections import defaultdict
import queue

INF = float("inf")

class Graph(object):
	def __init__(self):
		self.graph = defaultdict(list)

	def __len__(self):
		return len(self.graph)

	def add_edge(self, a, b):
		self.graph[a].append(b)

	def get_nodes(self):
		return list(self.graph.keys())

class BFS(object):
	def __init__(self, graph, s, N):
		self.g = graph.graph
		self.Q = queue.Queue()
		self.Q.put(s)
		self.dist = [INF] * N
		self.dist[s] = 0
		self.visit = ["No"] * N
		self.visit[s] = "Yes"
		while not self.Q.empty():
			v = self.Q.get()
			for i in self.g[v]:
				if self.visit[i] == "No":
					self.dist[i] = self.dist[v] + 1
					self.Q.put(i)
					self.visit[i] = "Yes"

#入力受け取り
def getlist():
	return list(map(int, input().split()))

#処理内容
def main():
	N, X, Y = getlist()
	G = Graph()
	G.add_edge(X - 1, Y - 1)
	G.add_edge(Y - 1, X - 1)
	for i in range(N - 1):
		G.add_edge(i, i + 1)
		G.add_edge(i + 1, i)

	ans = [0] * N
	for i in range(N):
		BF = BFS(G, i, N)
		dist = BF.dist
		for j in range(N):
			ans[dist[j]] += 1

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




if __name__ == '__main__':
	main()

# Optimized solution
import sys; input = sys.stdin.buffer.readline
from collections import defaultdict
con = 10 ** 9 + 7; INF = float("inf")

def getlist():
	return list(map(int, input().split()))

#処理内容
def main():
	N, X, Y = getlist()
	X -= 1; Y -= 1
	D = defaultdict(int)
	for i in range(N):
		for j in range(i + 1, N):
			var = min(j - i, abs(X - i) + abs(Y - j) + 1)
			D[var] += 1

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




if __name__ == '__main__':
	main()