CodeEff/ECCO huggingface dataset:
# Original solution
from collections import deque
# import sys
# input = sys.stdin.readline
n, x, y = list(map(int, input().split()))
g = dict()
for i in range(n):
    if i == 0:
        g[i] = [i+1]
    elif i == n-1:
        g[i] = [i-1]
    else:
        g[i] = [i-1, i+1]
g[x-1].append(y-1)
g[y-1].append(x-1)
# print(g)
distance = [0]*(n-1)
# 1番ノードから各ノードへの最短距離を求めていく.
for i in range(n):
    queue = deque()
    visited = [0]*n
    # まず処理される予定のノードが格納されているqueueに最初のノードを格納する
    queue.append(i)
    while queue:
        target = queue.popleft()
        for j in g[target]:
                if visited[j] == 0 or visited[j] > visited[target] + 1:
                    visited[j] = visited[target] + 1
                    queue.append(j)
    for k, a in enumerate(visited):
        if k > i:
            if a >= 1:
                distance[a-1] += 1
    # print(f"{i}番ノードからの各ノードへの最短距離は{visited}である")
for l in distance:
    print(l)

# Optimized solution
from collections import deque
def main():
    n, x, y = list(map(int, input().split()))
    g = dict()
    for i in range(n):
        if i == 0:
            g[i] = [i+1]
        elif i == n-1:
            g[i] = [i-1]
        else:
            g[i] = [i-1, i+1]
    g[x-1].append(y-1)
    g[y-1].append(x-1)
    distance = [0]*(n-1)
# 1番ノードから各ノードへの最短距離を求めていく.
    for i in range(n):
        queue = deque()
        visited = [0]*n
    # まず処理される予定のノードが格納されているqueueに最初のノードを格納する
        queue.append(i)
        while queue:
            target = queue.popleft()
            for j in g[target]:
                if visited[j] == 0 or visited[j] > visited[target] + 1:
                    visited[j] = visited[target] + 1
                    queue.append(j)
        for k, a in enumerate(visited):
            if k > i:
                if a >= 1:
                    distance[a-1] += 1
    # print(f"{i}番ノードからの各ノードへの最短距離は{visited}である")
    for l in distance:
        print(l)

if __name__ == "__main__":
    main()
# Original solution
import itertools

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

l=list(range(1,N+1))

for k in range(1, N):
    cnt=0
    for p in itertools.combinations(l, 2):
        a=p[1]-p[0]
        b=abs(p[1]-Y)+abs(p[0]-X)+1
        if k==min(a,b):cnt+=1
    print(cnt)

# Optimized solution
import itertools

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

l=list(range(1,N+1))
cnt=[0]*(N-1)

for p in itertools.combinations(l, 2):
    a=p[1]-p[0]
    b=abs(p[1]-Y)+abs(p[0]-X)+1
    cnt[min(a,b)-1]+=1

for k in cnt:
    print(k)
# Original solution
import itertools

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

l=list(range(1,N+1))
cnt=[0]*(N-1)

for p in itertools.combinations(l, 2):
    a=p[1]-p[0]
    b=abs(p[1]-Y)+abs(p[0]-X)+1
    cnt[min(a,b)-1]+=1

for k in cnt:
    print(k)

# Optimized solution
N,X,Y=list(map(int, input().split()))
ans=[0]*(N-1)
for i in range(1,N):
    for j in range(i+1, N+1):
        ans[min(j-i, abs(j-Y)+abs(i-X)+1)-1]+=1
for a in ans:
    print(a)
# Original 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):
   dist1=j-i
   dist2=abs(x-i)+abs(y-j)+1
   dist3=abs(y-i)+abs(x-j)+1
   d=min(dist1,dist2,dist3)
   ans[d]+=1
for i in range(1,n):
 print((ans[i]))

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

def largest(a,b,c):
  if a <= b:
    if a<= c:
      return a
    else:
      return c
  else:
    if b<=c:
      return b
    else:
      return c
    
def absol(d):
  if d < 0:
    return -d
  else:
    return d
    
def dist(i,j):
  return largest(j-i, absol(x-i) + absol(y-j) + 1, absol(x-j) + absol(y-i) + 1)

listlist = [0]*(n-1)

for i in range(1,n):
  for j in range(i+1,n+1):
    distance = dist(i,j)
    listlist[distance-1] = listlist[distance-1] + 1
    
for k in listlist:
  print(k)


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

def dist(i,j):
  return min(j-i, abs(x-i) + abs(y-j) + 1, abs(x-j) + abs(y-i) + 1)

listlist = [0]*(n-1)

for i in range(1,n):
  for j in range(i+1,n+1):
    distance = dist(i,j)
    listlist[distance-1] = listlist[distance-1] + 1
    
for k in listlist:
  print(k)
# Original solution
from collections import defaultdict

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

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

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


# Optimized solution
from collections import defaultdict

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

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

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


NUM = [0] * (N-1)

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


for i in range(len(NUM)):
    print((NUM[i]))




# Optimized solution
def main():
    n, x, y = (int(i) for i in input().split())
    num_list = [0] * (n - 1)

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

    for i in range(len(num_list)):
        print((num_list[i]))


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

for k in range(1,N):
    ans = 0
    for i in range(1,N):
        for j in range(i,N+1):
            min_dis = min((j-i), abs(X-i)+1+abs(j-Y))
            if min_dis == k:
                ans += 1
    print(ans)





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

memo = [0] *(N)

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

for k in range(1,N):
    print((memo[k]))
# Original solution
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)]
#d[u][v] : 辺uvのコスト(存在しないときはinf)

ans = [0]*(n-1)

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

for i in range(n):
    d[i][i] = 0 #自身のところに行くコストは０
d = warshall_floyd(d)

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

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

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

X -= 1
Y -= 1
ans = [0]*(N)

d = [[N]*N for i in range(N)]

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



for i in range(N):
    for j in range(i+1,N):
        ans[d[i][j]] += 1

for i in range(1,N):
    print((ans[i]))
# Original solution
n,x,y = list(map(int,input().split()))
ko = [0 for i in range(10**4)]
for i in range(1,n):
  for j in range(i+1,n+1):
    c1 = j-i
    if i<=x and y<=j:
      c2 = (x-i)+1+(j-y)
    elif i<=x and j<y:
      c2 = (x-i)+1+(y-j)
    elif x<i and y<=j:
      c2 = (i-x)+1+(j-y)
    else:
      c2 = (i-x)+1+(y-j)
    ko[min(c1,c2)] += 1
  #  print(i,j,j-i,c1,c2,ko[:10])
for i in range(1,n):
  print((ko[i]))

# Optimized solution
n,x,y = list(map(int,input().split()))
ko = [0 for i in range(10**4)]
for i in range(1,n):
  for j in range(i+1,n+1):
    c1 = j-i
    c2 = abs(x-i)+1+abs(y-j)
    ko[min(c1,c2)] += 1
  #  print(i,j,j-i,c1,c2,ko[:10])
for i in range(1,n):
  print((ko[i]))
# Original solution
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

if __name__ == '__main__':
    n,x,y = list(map(int, input().split()))
    costList = [0]*n

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


    for i in range(n):
        if i >0:
            print((costList[i]))

# Optimized solution
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

if __name__ == '__main__':
    n,x,y = list(map(int, input().split()))
    costList = [0]*n

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


    for i in range(n):
        if i >0:
            print((costList[i]))
# Original solution
n,x,y = list(map(int,input().split()))
k = [0]*(n)

for i in range(1,n):
  for j in range(i+1,n+1):
    if i < x and j <= x:
      k[j-i] += 1
    elif i >= y and j > y:
      k[j-i] += 1
    elif x <= i < y and x< j <= y:
      ind = min(j-i,i-x+y-j+1)
      k[ind] += 1
    elif i < x and x < j <= y:
      ind = min(j-i,x-i+y-j+1)
      k[ind] += 1
    elif x <= i < y and y < j:
      ind = min(j-i,i-x+1+j-y)
      k[ind] += 1
    elif i< x and j > y:
      ind = x - i + 1 + j - y
      k[ind] += 1
      
for i in range(1,n):
  print((k[i]))

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

for i in range(1,n):
    ans = 0
    for j in range(n):
        ans += p[j].count(i)
    print(ans)

# Optimized solution
n , x , y = list(map(int,input().split()))
p = [0 for i in range(n)]
for i in range(1,n+1):
    for j in range(1,i+1):
        p[min(abs(i-j),abs(i-x)+1+abs(j-y),abs(j-x)+1+abs(i-y))] += 1
for i in range(1,n):
    print((p[i]))
# Original solution
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
n,x,y = [int(i) for i in readline().split()]

INF = 1001001001

from collections import deque

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

x -= 1
y -= 1
ans = [0]*n
for sv in range(n):
    dist = [INF]*n
    q = deque()
    push(sv, 0) # 初期状態
    while len(q):
        v = q.popleft()
        d = dist[v]
        if v-1 >= 0: push(v-1, d+1)
        if v+1 < n: push(v+1, d+1)
        if v == x: push(y, d+1)
        if v == y: push(x, d+1)
    for i in range(n):
        ans[dist[i]] += 1
for i in range(n):
    ans[i] //= 2 # (1,2)と(2,1)を2度数えてしまっているので2で割る
for i in range(1,n):
    print((ans[i]))

# Optimized solution
import sys
sys.setrecursionlimit(10**6)
readline = sys.stdin.readline
n,x,y = [int(i) for i in readline().split()]

ans = [0] * n

for a in range(1, n+1):
    for b in range(a+1, n+1):
        d = b - a
        d2 = abs(x-a) + abs(y-b) + 1
        d = d if d < d2 else d2
        ans[d] += 1

for i in range(1, n):
    print((ans[i]))
# Original solution
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

################################
n, x, y = list(map(int,input().split())) #n:頂点数　w:辺の数
w = n
ans = [0 for _ in range(n-1)]
# print(ans)
cost = [[float("inf") for i in range(n)] for i in range(n)] 
#cost[u][v] : 辺uvのコスト(存在しないときはinf この場合は10**10)
for i in range(w-1):
    # x,y = map(int,input().split())
    cost[i][i+1] = 1
    cost[i+1][i] = 1
cost[x-1][y-1] = 1
cost[y-1][x-1] = 1

# print(dijkstra(0,n,w,cost))
for i in range(n-1):
    aa = dijkstra(i, n, w, cost)
    # print(aa)
    for j in range(i+1, n):
        ans[aa[j]] += 1
ans = ans[1:] + [0]
# print(*ans)
for A in ans:
    print(A)

# Optimized solution
n, x, y = map(int, input().split())
ans = [0 for _ in range(n-1)]
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)
        ans[d-1] += 1

print(*ans, sep='\n')
# Original solution
N, X, Y = list(map(int,input().split()))
X -= 1
Y -= 1

nallpath = N*(N-1)//2
distance = [0] * nallpath

indx = 0
for j in range(N-1):
    for i in range(j+1,N):
        if i <= X:
            distance[indx] = i - j
        elif j >= Y:
            distance[indx] = i - j
        elif j <= X and Y<= i:
            distance[indx] = i - j - (Y-X-1)
        elif  X <= j < i <= Y:
            distance[indx] = min(i-j, (j-X)+(Y-i)+1)
        elif j <= X and X < i <= Y:
            distance[indx] = (X-j) + min(i-X, Y-i+1)
        else:
            distance[indx] = (i-Y) + min(Y-j, j-X+1)
        indx += 1
for i in range(N-1):print((distance.count(i+1)))


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

npath = [0] * (N-1)

indx = 0
for j in range(N-1):
    for i in range(j+1,N):
        if i <= X:
            distance = i - j
        elif j >= Y:
            distance = i - j
        elif j <= X and Y<= i:
            distance = i - j - (Y-X-1)
        elif  X <= j < i <= Y:
            distance = min(i-j, (j-X)+(Y-i)+1)
        elif j <= X and X < i <= Y:
            distance = (X-j) + min(i-X, Y-i+1)
        else:
            distance = (i-Y) + min(Y-j, j-X+1)
        npath[distance-1] +=1
for i in range(N-1):print((npath[i]))
# Original solution
def main():
    from collections import deque
    N, X, Y = (int(i) for i in input().split())
    X -= 1
    Y -= 1
    edge = [[] for _ in range(N)]
    for i in range(N-1):
        edge[i].append(i+1)
        edge[i+1].append(i)
    edge[X].append(Y)
    edge[Y].append(X)

    def bfs(s):
        d = [-1 for _ in range(N)]
        que = deque()
        d[s] = 0
        que.append(s)
        while que:
            u = que.popleft()
            for v in edge[u]:
                if d[v] != -1:
                    continue
                d[v] = d[u] + 1
                que.append(v)
        return d

    dist = [[] for _ in range(N)]
    for i in range(N):
        dist[i] = bfs(i)
    cnt = [0]*N
    for i in range(N):
        for j in range(i+1, N):
            cnt[dist[i][j]] += 1
    for c in cnt[1:]:
        print(c)


if __name__ == '__main__':
    main()


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


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

pat = defaultdict(int)

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

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

# Optimized solution

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

pat = [0]*(N-1)

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

for i in range(N-1):
  print((pat[i]))
# Original solution
# coding: utf-8

import collections

# 標準入力 <int><int>
N, X, Y = list(map(int, input().split()))

br = []

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

c = collections.Counter(br)

for k, v in list(c.items()):
  print(v)

for _ in range(N - 1 - len(c)):
  print((0))


# Optimized solution
# coding: utf-8

import collections

# 標準入力 <int><int>
N, X, Y = list(map(int, input().split()))

br = []

for i in range(N - 1):
  for j in range(i + 1, N):
    """
    #print("(" , i+1, j+1, ")", j-i, abs(X - (i + 1)) + 1 + abs(Y - (j + 1)), abs(Y - (i + 1)) + 1 + abs(X - (j + 1)))
    """
    br.append(min(j - i, abs(X - (i + 1)) + 1 + abs(Y - (j + 1)), abs(Y - (i + 1)) + 1 + abs(X - (j + 1))))

c = collections.Counter(br)

for k, v in list(c.items()):
  print(v)

for _ in range(N - 1 - len(c)):
  print((0))
# Original solution
n,x,y=list(map(int,input().split()))
#a<b
def dis(a,b):
    return min (b-a,abs(a-x)+1+abs(b-y))

for k in range(1,n):
  count=0
  #i<j
  for i in range(1,n):
    for j in range(i+1,n+1):
      if dis(i,j)==k:
        count+=1
  print(count)

# Optimized solution
n,x,y=map(int,input().split())
#a<b
def dis(a,b):
    return min (b-a,abs(a-x)+1+abs(b-y))

# for k in range(1,n):
#   count=0
#   #i<j
#   for i in range(1,n):
#     for j in range(i+1,n+1):
#       if dis(i,j)==k:
#         count+=1
#   print(count)
ans=[0]*(n-1)
#i<j
for i in range(1,n):
  for j in range(i+1,n+1):
    ans[dis(i,j)-1]+=1
print(*ans,sep="\n")
# Original solution
n,x,y=map(int,input().split())
#a<b
def dis(a,b):
    return min (b-a,abs(a-x)+1+abs(b-y))

# for k in range(1,n):
#   count=0
#   #i<j
#   for i in range(1,n):
#     for j in range(i+1,n+1):
#       if dis(i,j)==k:
#         count+=1
#   print(count)
ans=[0]*(n-1)
#i<j
for i in range(1,n):
  for j in range(i+1,n+1):
    ans[dis(i,j)-1]+=1
print(*ans,sep="\n")


# Optimized solution
n,x,y=list(map(int,input().split()))
#a<b
def dis(a,b):
    return min (b-a,abs(a-x)+1+abs(b-y))

# for k in range(1,n):
#   count=0
#   #i<j
#   for i in range(1,n):
#     for j in range(i+1,n+1):
#       if dis(i,j)==k:
#         count+=1
#   print(count)
ans=[0]*(n-1)
#i<j
for i in range(1,n):
  for j in range(i+1,n+1):
    ans[dis(i,j)-1]+=1
#print(*ans,sep="\n")
print(("\n".join(map(str,ans))))
# Original solution
N, X, Y = list(map(int, input().split()))

dp = [[N+10] * N for i in range(N)]
for i in range(N-1):
    dp[i][i+1] = 1
for i in range(1, N):
    dp[i][i-1] = 1
dp[X-1][Y-1] = 1
dp[Y-1][X-1] = 1
    
for k in range(N):
    for i in range(N):
        for j in range(N):
            dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j])

mindcnt = {}
for i in range(N):
    mindcnt[i] = 0

for i in range(N):
    for j in range(i+1, N):
        mind = dp[i][j]
        mindcnt[mind] += 1

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


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

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

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

for k in range(1, N):
    print((mindcnt[k]))
# Original solution
N, X, Y = list(map(int, input().split()))
dic = {}


def Warshall_Floyd(N):
    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


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

for i in range(N):
    d[i][i] = 0

d[X-1][Y-1] = 1
d[Y-1][X-1] = 1

d = Warshall_Floyd(N)


for i in range(N):
    for j in range(N):
        if dic.get(d[i][j]) is None:
            dic[d[i][j]] = 1
        else:
            dic[d[i][j]] += 1

for i in range(1, N):
    if dic.get(i) is None:
        print((0))
    else:
        print((dic[i]//2))

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


for i in range(1, N):
    for j in range(i+1, N+1):
        m = min(j-i, abs(X-i) + 1 + abs(Y-j))
        if d.get(m) is None:
            d[m] = 1
        else:
            d[m] += 1

for i in range(1, N):
    if d.get(i) is None:
        print((0))
    else:
        print((d[i]))
# Original solution
N, X, Y = list(map(int, input().split()))
dist_list = []*N

for i in range(N):
    for j in range(i+1, N):
        a = j - i
        b = abs(i+1 - X) + abs(j+1 -Y) + 1
        if a > b:
            dist_list.append(b)
        else:
            dist_list.append(a)

for k in range(N-1):
    print((dist_list.count(k+1)))



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

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

for k in range(N-1):
    print((dist_list[k+1]))
# Original solution
N, X, Y = list(map(int, input().split()))
dist = [0]*N
for i in range(N):
    for k in range(i,N):
        if i == X - 1 and k == Y - 1:
            dist[1] += 1
            continue
        if X - 1 <= k <= Y - 1 and i <= X - 1:
            tmp = min(k-i,(X-1)-i+1+(Y-1-k))
            dist[tmp] += 1
            continue
        if X - 1 < i < Y - 1 and k >= Y - 1:
            tmp = min(k-i,i-(X-1)+1+k-(Y-1))
            dist[tmp] += 1
            continue
        if X - 1 <= k <= Y - 1 and X - 1 <= i <= Y - 1:
            tmp = min(k-i,i-(X-1)+1+(Y-1-k))
            dist[tmp] += 1
            continue
        if i <= X - 1 and k >= Y - 1:
            dist[k-i-(Y-X-1)] += 1
            continue
        dist[k-i] += 1
for i in range(1,N):
    print((dist[i]))

# Optimized solution
N, X, Y = list(map(int, input().split()))
dist = [0]*N
for i in range(N):
    for k in range(i+1,N):
        if i == X - 1 and k == Y - 1:
            dist[1] += 1
            continue
        if X - 1 <= k <= Y - 1 and i <= X - 1:
            tmp = min(k-i,(X-1)-i+1+(Y-1-k))
            dist[tmp] += 1
            continue
        if X - 1 < i < Y - 1 and k >= Y - 1:
            tmp = min(k-i,i-(X-1)+1+k-(Y-1))
            dist[tmp] += 1
            continue
        if X - 1 <= k <= Y - 1 and X - 1 <= i <= Y - 1:
            tmp = min(k-i,i-(X-1)+1+(Y-1-k))
            dist[tmp] += 1
            continue
        if i <= X - 1 and k >= Y - 1:
            dist[k-i-(Y-X-1)] += 1
            continue
        dist[k-i] += 1
for i in range(1,N):
    print((dist[i]))
# Original solution
N,X,Y = list(map(int,input().split()))
D = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
    for j in range(i,N):
        D[i][j] = j-i
D[X-1][Y-1] = 1
for i in range(N):
    for j in range(i,N):
        c,d = max(i,X-1),min(i,X-1)
        e,f = max(Y-1,j),min(j,Y-1)
        a = min(D[i][j],D[d][c]+D[f][e]+1)
        D[i][j] = a
A = [0]*(N-1)
for i in range(N):
    for j in range(i,N):
        k = D[i][j]
        if k == 0:
            continue
        A[k-1] += 1
for a in A:
    print(a)

# Optimized solution
N,X,Y = list(map(int,input().split()))
D = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
    for j in range(i+1,N):
        D[i][j] = j-i
D[X-1][Y-1] = 1
A = [0]*(N-1)
for i in range(N):
    for j in range(i+1,N):
        c,d = max(i,X-1),min(i,X-1)
        e,f = max(Y-1,j),min(j,Y-1)
        a = min(D[i][j-1]+1,D[d][c]+D[f][e]+1)
        D[i][j] = a
        if a == 0:
            continue
        A[a-1] += 1
for a in A:
    print(a)
# Original solution
import collections

N, X, Y = list(map(int, input().split()))
x = X-1
y = Y-1
dist = dict()
for i in range(N-1):
    for j in range(i+1, N):
        dist_ = min(abs(j-i), abs(x-i) + 1 + abs(j-y), abs(y-i) +1 + abs(j - x))
        dist[i, j] = dist_

out = collections.Counter(list(dist.values()))
for i in range(N-1):
    print((out[i+1]))



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