CodeEff/ECCO huggingface dataset:
# Original solution
N, X, Y = list(map(int, input().split(' ')))
X -= 1
Y -= 1
dist_map = {}

def search(origin):
  dist = []
  # X, Yの辺がない場合
  for i in range(N):
    dist.append(abs(origin - i))
  # X, Yの辺がある場合
  if dist[X] < dist[Y]:
    dist[Y] = dist[X] + 1
  elif dist[Y] < dist[X]:
    dist[X] = dist[Y] + 1
  for i in range(N):
    if i - 1 >= 0:
      dist[i] = min(dist[i], dist[i-1]+1)
    if i + 1 < N:
      dist[i] = min(dist[i], dist[i+1]+1)
  for i in reversed(list(range(N))):
    if i - 1 >= 0:
      dist[i] = min(dist[i], dist[i-1]+1)
    if i + 1 < N:
      dist[i] = min(dist[i], dist[i+1]+1)
  #print(*dist)
  return dist


for i in range(N):
  dist_map[i] = search(i)

#print(N)
count = [0 for i in range(N)]
for i in range(N):
  #print('i='+str(i))
  #dist = dist_map[i]
  #print(*dist)
  dist = dist_map[i]
  for dis in dist:
    count[dis] += 1
for i in range(1, N):
  print((count[i]//2))

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

def search(origin):
  dist = []
  # X, Yの辺がない場合
  for i in range(N):
    dist.append(abs(origin - i))
  # X, Yの辺がある場合
  if dist[X] < dist[Y]:
    dist[Y] = dist[X] + 1
  elif dist[Y] < dist[X]:
    dist[X] = dist[Y] + 1
  for i in range(N):
    if i - 1 >= 0:
      dist[i] = min(dist[i], dist[i-1]+1)
    if i + 1 < N:
      dist[i] = min(dist[i], dist[i+1]+1)
  for i in reversed(list(range(N))):
    if i - 1 >= 0:
      dist[i] = min(dist[i], dist[i-1]+1)
    if i + 1 < N:
      dist[i] = min(dist[i], dist[i+1]+1)
  #print(*dist)
  return dist

count = [0 for i in range(N)]
for i in range(N):
  dist = search(i)
  for dis in dist:
    count[dis] += 1

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

# Optimized solution
N,X,Y = list(map(int,input().split()))
li = [0]*(N-1)
for i in range(0,N-1):
    for j in range(i+1,N):
        dis = min(j-i,abs(i-(X-1))+1+abs(j-(Y-1)))
        li[dis-1] += 1
for ans in li:
    print(ans)
# Original solution
N,X,Y = list(map(int,input().split(' ')))
ls = {}
for i in range(1,N):
	for j in range(i+1,N+1):
		l = min(abs(j-i),abs(i-X)+1+abs(j-Y),abs(i-Y)+1+abs(j-X))
		if l not in list(ls.keys()):
			ls[l] = 1
		else:
			ls[l] = ls[l] + 1

for i,(k,v) in enumerate(sorted(list(ls.items()),key=lambda x:x[0])):
	print(v)

for j in range(i+2,N):
	print((0))

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

ls = [0 for i in range(N-1)]

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

for i in range(N-1):
	print((ls[i]))
# Original solution
from collections import deque

if __name__ == '__main__':

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

    ans = [0] * (n+1)

    g = [[i+1, i-1] for i in range(n+1)]
    g[0].clear()
    g[1].pop(1)
    g[n].pop(0)

    g[x].append(y)
    g[y].append(x)

    for i in range(1,n+1):
        q = deque()
        time = 0

        visit = [False] * (n+1)

        q.append((i, time))

        while(len(q) > 0):
            item = q.popleft()

            if visit[item[0]] == False:
                visit[item[0]] = True
                ans[item[1]] += 1
                for k in g[item[0]]:
                    q.append((k, item[1]+1))

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


# Optimized solution
from collections import deque

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

ans = [0] * (n+1)

g = [[i+1, i-1] for i in range(n+1)]
#g[0].clear() pypyにclearなし
g[1].pop(1)
g[n].pop(0)

g[x].append(y)
g[y].append(x)

for i in range(1,n+1):
    q = deque()
    time = 0
    visit = [False] * (n+1)
    q.append((i, time))

    while(len(q) > 0):
        item = q.popleft()

        if visit[item[0]] == False:
            visit[item[0]] = True
            ans[item[1]] += 1
            for k in g[item[0]]:
                q.append((k, item[1]+1))

for i in range(1,n):
    print((ans[i]//2))
# Original solution
def main():
    N, X, Y = list(map(int, input().split()))
    X -= 1
    Y -= 1

    answer = [0 for i in range(N+1)]

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

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


if __name__ == '__main__':
    main()


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

    answer = [0 for i in range(N+1)]

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

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


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

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

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

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

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

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


def bfs(start, end):
    Q = deque()
    Q.append(start)
    dist[start] = 0

    while Q:
        v = Q.popleft()

        for nv in G[v]:
            if dist[nv] != -1:
                continue
            Q.append(nv)
            dist[nv] = dist[v] + 1

            if nv == end:
                return dist[nv]


N, X, Y = list(map(int, input().split()))
G = [[] for _ in range(N)]
res = [0] * N

for i in range(N - 1):
    G[i].append(i + 1)
    G[i + 1].append(i)

if abs(X - Y) != 1:
    G[X - 1].append(Y - 1)
    G[Y - 1].append(X - 1)

for i in range(N - 1):
    for j in range(i + 1, N):
        dist = [-1] * N
        res[bfs(i, j)] += 1

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


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

print(('\n'.join(map(str, ans[1:]))))


# 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[min(j - i, abs(i - x) + abs(j - y) + 1)] += 1
print(('\n'.join(map(str, ans[1:]))))
# Original solution
N,X,Y = list(map(int,input().split()))
Alist = [[0 for i in range(N)] for j in range(N)]
for i in range(N):
    for j in range(i,N):
        Alist[i][j] = j-i
Alist[X-1][Y-1] = 1
for i in range(N):
    for j in range(i,N):
        Alist[i][j] = min(Alist[i][j],abs(X-1-i)+abs(Y-1-j)+1)
p = [0 for i in range(N)]
for i in range(N):
    for j in range(i,N):
        k = Alist[i][j]
        p[k] = p[k] + 1
for s in range(1,N):
    print((p[s]))

# Optimized solution
N,X,Y = list(map(int,input().split()))
Alist = [[0 for i in range(N)] for j in range(N)]
p = [0 for i in range(N)]
for i in range(N):
    for j in range(i,N):
        k = min(j-i,abs(X-1-i)+abs(Y-1-j)+1)
        p[k] = p[k] + 1        
for s in range(1,N):
    print((p[s]))
# Original solution
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
 
i_i = lambda: int(i_s())
i_l = lambda: list(map(int, stdin.readline().split()))
i_s = lambda: stdin.readline().rstrip()

n,x,y = i_l()
x -= 1
y -= 1
a = []

for i in range(n):
    for j in range(i+1, n):
        a.append(min(abs(i-j), abs(x-i)+1+abs(y-j), abs(y-j)+1+abs(y-i)))
for i in range(1, n):
    count = a.count(i)
    if count>0:
        print(count)
    else:
        print((0))

# Optimized solution
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
 
i_i = lambda: int(i_s())
i_l = lambda: list(map(int, stdin.readline().split()))
i_s = lambda: stdin.readline().rstrip()

n,x,y = i_l()
x -= 1
y -= 1
a = [0]*n

for i in range(n):
    for j in range(i+1, n):
        b = min(abs(i-j), abs(x-i)+1+abs(y-j), abs(y-j)+1+abs(y-i))
        a[b] += 1
        
for i in a[1:]:
    print(i)
# Original solution
import collections
import heapq


class Dijkstra():
    def __init__(self):
        self.e = collections.defaultdict(list)

    def add(self, u, v, d, directed=False):
        """
        #0-indexedでなくてもよいことに注意
        #u = from, v = to, d = cost
        #directed = Trueなら、有向グラフである
        """
        if directed is False:
            self.e[u].append([v, d])
            self.e[v].append([u, d])
        else:
            self.e[u].append([v, d])

    def delete(self, u, v):
        self.e[u] = [_ for _ in self.e[u] if _[0] != v]
        self.e[v] = [_ for _ in self.e[v] if _[0] != u]

    def search(self, s):
        """
        #0-indexedでなくてもよいことに注意
        #:param s: 始点
        #:return: 始点から各点までの最短経路と最短経路を求めるのに必要なprev
        """
        d = collections.defaultdict(lambda: float('inf'))
        prev = collections.defaultdict(lambda: None)
        d[s] = 0
        q = []
        heapq.heappush(q, (0, s))
        v = collections.defaultdict(bool)
        while len(q):
            k, u = heapq.heappop(q)
            if v[u]:
                continue
            v[u] = True

            for uv, ud in self.e[u]:
                if v[uv]:
                    continue
                vd = k + ud
                if d[uv] > vd:
                    d[uv] = vd
                    prev[uv] = u
                    heapq.heappush(q, (vd, uv))

        return d

    def getDijkstraShortestPath(self, start, goal):
        _, prev = self.Dijkstra_search(start)
        shortestPath = []
        node = goal
        while node is not None:
            shortestPath.append(node)
            node = prev[node]
        return shortestPath[::-1]
        
n, x, y = list(map(int,input().split()))
ans = collections.defaultdict(int)

edges = [[i, i+1, 1] for i in range(1, n)]
edges += [[x, y, 1]]

graph1 = Dijkstra()

for u, v, a in edges:
    graph1.add(u,v,a)

for i in range(1,n+1):
    result_a = graph1.search(i)
    for j in range(i+1, n+1):
        ans[result_a[j]] += 1

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

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

ans = [0] * (n+10)

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

t = [0] * (N - 1)
for i in range(1, N):
    for j in range(i + 1, N + 1):
        t[min(j - i, abs(X - i) + 1 + abs(Y - j)) - 1] += 1
print(('\n'.join(map(str, t))))


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

t = [0] * (N - 1)
for i in range(1, N):
    for j in range(i + 1, N + 1):
        t[min(j - i, abs(X - i) + 1 + abs(Y - j)) - 1] += 1
print(('\n'.join(map(str, t))))
#print(*result, sep='\n')
# Original solution
n,x,y=[int(j) for j in input().split()]
l=[[0]*n for i in range(n)]
ans=[0]*n
x-=1
y-=1
s=y-x-1
for i in range(n):
    for j in range(n):
        if i<j:
            ans[min(j-i,abs(i-x)+abs(j-y)+1,)]+=1

print(('\n'.join(map(str,ans[1:]))))





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

res = [0] * (N)

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

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


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

res = [0] * (N)

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

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

x -= 1
y -= 1
ans = [0] * n

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

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


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

x -= 1
y -= 1
ans = [0] * n

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

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

ans = [0] * (N - 1)
for i in range(N):
    for j in range(i + 1, N):
        dist = min(abs(i - j), abs((X - 1) - i) + abs((Y - 1) - j) + 1, abs((Y - 1) - i) + abs((X - 1) - j) + 1)
        ans[dist - 1] += 1
        # print("i:{}, j:{}, dist:{}".format(i, j, dist))
for k in ans:
    print(k)


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

X -= 1
Y -= 1

ans = [0] * (N - 1)
for i in range(N):
    for j in range(i + 1, N):
        dist = min(abs(i - j), abs(X - i) + abs(Y - j) + 1, abs(Y - i) + abs(X - j) + 1)
        ans[dist - 1] += 1
        # print("i:{}, j:{}, dist:{}".format(i, j, dist))
for k in ans:
    print(k)
# Original solution
from collections import Counter
N,X,Y = list(map(int, input().split()))
X -= 1
Y -= 1
L = []
for i in range(N-1):
  for j in range(i+1,N):
    L.append(min(abs(i-j),abs(X-i)+abs(Y-j)+1,abs(Y-i)+abs(X-j)+1))
D = Counter(L)
for k in range(1,N):
  print((D[k]))

# Optimized solution
N,X,Y = map(int, input().split())
D = [0] * N
for i in range(1,N):
  for j in range(i+1,N+1):
    D[min(abs(i-j),abs(X-i)+abs(Y-j)+1,abs(Y-i)+abs(X-j)+1)] += 1 
print (*D[1:], sep="\n")
# Original solution
N,X,Y = map(int, input().split())
D = [0] * N
for i in range(1,N):
  for j in range(i+1,N+1):
    D[min(abs(i-j),abs(X-i)+abs(Y-j)+1,abs(Y-i)+abs(X-j)+1)] += 1 
print (*D[1:], sep="\n")


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

ans = [0] * (N - 1)

for i in range(1, N + 1, 1):
    for j in range(i + 1, N + 1, 1):
        tmp = min(
            abs(j - i),
            abs(X - i) + 1 + abs(j - Y),
            abs(X - j) + 1 + abs(i - Y) # このパターンは
        )
        ans[tmp - 1] += 1

for a in ans:
    print(a)

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

ans = [0] * (N - 1)

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

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

# Optimized solution
# coding: utf-8
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):
        l = min(j-i, abs(X-i)+1+abs(Y-j))
        ans[l] += 1
for k in range(1,N):
    print((ans[k]))
# Original solution
import sys
input = sys.stdin.buffer.readline
from itertools import chain
from collections import Counter

def floyd_warshall(V, dist):                                               # 動的計画法。頂点 k まで経由することが可能な場合の最短距離という部分問題を考えて、k = 0 から漸化式的に計算する
    for k in range(V):
        for i in range(V):
            for j in range(V):
                if dist[i][j] > dist[i][k] + dist[k][j]:
                    dist[i][j] = dist[i][k] + dist[k][j]                # dist は頂点 k までを経由した場合の最短距離。dist[i][k]は k を経由することは無いので、dist[i][k]は k ステップ目で更新されることはない。
                                                                        # よって、min の中身は全て k-1 ステップ目の情報で構成されており、漸化式となっている。
    return dist

##############################
V, X, Y = list(map(int, input().split()))                                        # V:頂点数　E:辺の数

INF = float("inf")                                                      # 10**18 にすると、負のコストがある場合に少し面倒になる

dist = [[INF] * V for _ in range(V)]                                    # 辺が存在しない事をコスト無限大で表現
for k in range(V-1):
    i,j,weight = k, k+1, 1
    # i -= 1                                                            # 番号のデクリメントが必要な場合、コメントアウトを消す
    # j -= 1
    dist[i][j] = weight
    dist[j][i] = weight                                               # 無向グラフの場合はコメントアウトを消す
for i in range(V):
    dist[i][i] = 0                                                      # 自身のところに行くコストは０

dist[X-1][Y-1] = 1
dist[Y-1][X-1] = 1

d = floyd_warshall(V, dist)                                                # 各点間の距離が隣接行列の形で与えられる

res = Counter(chain.from_iterable(d))

for i in range(1,V):
    print((res.get(i,0)//2))


# Optimized solution
N, X, Y = 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(j-i, abs(X-i) + 1 + abs(Y-j))-1] += 1

print(*dist, sep="\n")
# Original solution
def main():
    import sys
    input = sys.stdin.readline
    from collections import deque
    n,x,y = list(map(int,input().split()))
    ans = [0]*(n)
    E = [[] for i in range(n)]
    E[0].append(1)
    E[n-1].append(n-2)
    for i in range(1,n-1):
        E[i].append(i-1)
        E[i].append(i+1)
    E[x-1].append(y-1)
    E[y-1].append(x-1)
    ans = [0]*(n)
    def search(x):
        d = [float("INF")]*n
        d[x] = 0
        q = deque([])
        q.append((x,0))
        while q:
            bef,l = q.pop()

            for nex in E[bef]:
                if d[nex] > l+1:
                    d[nex] = l+1
                    q.append((nex,l+1))
        
        d = d[x:]
        for j in range(n):
            ans[j] += d.count(j)
    for i in range(n-1):
        search(i)

    for i in ans[1:]:
        print(i)
if __name__ == "__main__":
    main()



# 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):
        d = min(j-i,abs(x-i)+abs(y-j)+1)
        ans[d] += 1
for i in ans[1:]:
    print(i)
# Original solution
from heapq import *
from collections import Counter
import itertools


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

def dijkstra(s, edges):
    d = [float('inf')] * n
    d[s] = 0
    heap = [(0, s)]
    while heap:
        c, node = heappop(heap)
        for cost, v in edges[node]:
            if c + cost < d[v]:
                d[v] = c + cost
                heappush(heap, (d[v], v))
    return d

for i in range(n-1):
    u, v = i, i+1
    edges[u].append([1,v])
    edges[v].append([1,u])
edges[x-1].append([1, y-1])
edges[y-1].append([1, x-1])

ans = []

for s in range(n):
    ans.append(dijkstra(s, edges))

f_ans = []
for i in range(n):
    f_ans.append(ans[i][i+1:])
f_ans = list(itertools.chain.from_iterable(f_ans))
f_ans = Counter(f_ans)

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

# Optimized solution
from heapq import *
from collections import Counter
import itertools


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

def dijkstra(s, edges):
    d = [float('inf')] * n
    d[s] = 0
    heap = [(0, s)]
    while heap:
        c, node = heappop(heap)
        for cost, v in edges[node]:
            if c + cost < d[v]:
                d[v] = c + cost
                heappush(heap, (d[v], v))
    return d

for i in range(n-1):
    u, v = i, i+1
    edges[u].append([1,v])
    edges[v].append([1,u])
edges[x-1].append([1, y-1])
edges[y-1].append([1, x-1])

ans = []

for s in range(n):
    ans.append(dijkstra(s, edges))

f_ans = []
for i in range(n):
    f_ans.append(ans[i][i+1:])
f_ans = Counter(list(itertools.chain.from_iterable(f_ans)))

for i in range(1, n):
    print((f_ans[i]))
# Original solution
from collections import Counter
 
def flatten(array):
    return [item for sublist in array for item in sublist]

n, x, y = list(map(int, input().split()))
c = [[10**4]*n for i in range(n)]
for i in range(n):
    c[i-1][i] = 1
    c[i][i-1] = 1
c[-1][0] = 10**4
c[0][-1] = 10**4
c[x-1][y-1] = 1
c[y-1][x-1] = 1
 
for k in range(n):
    for i in range(n):
        for j in range(n):
            c[i][j]=min(c[i][j],c[i][k]+c[k][j])
            c[j][j]=0

p = sorted(list(Counter(flatten(c)).items()), key=lambda x: x[0])[1:]
t = 0
for _, cnt in p:
    print((cnt // 2))
for _ in range(n-1-len(p)):
    print((0))

# Optimized solution
#!/usr/bin/env python3
n, x, y = map(int, input().split())
a = abs
d = [0] * n
for i in range(1, n+1):
    for j in range(i + 1, n+1):
        d[min(j-i, a(x-i)+a(y-j)+1, a(x-j)+a(y-i)+1)] += 1
print(*d[1:], sep="\n")
# Original solution
from collections import deque

def count_pair(k):
    cnt = 0
    for i in range(1, N+1):
        visited = [-1]*(N+1)
        visited[i] = 0
        s = 0
        q = deque([[i]])
        while s != k:
            p = []
            A = q.popleft()
            for a in A:
                if a == X and visited[Y] == -1:
                    p.append(Y)
                    visited[Y] = 0
                if a == Y and visited[X] == -1:
                    p.append(X)
                    visited[X] = 0
                if a+1 <=N and visited[a+1] == -1:
                    p.append(a+1)
                    visited[a+1] = 0
                if a-1 >= 1 and visited[a-1] == -1:
                    p.append(a-1)
                    visited[a-1] = 0
            q.append(p)
            s += 1
        r = q[0]
        t = 0
        for j in range(len(r)):
            if r[j] > i:
                t += 1
        cnt += t
    return cnt

N, X, Y = list(map(int, input().split()))
for k in range(1, N):
    print((count_pair(k)))

# Optimized solution
N, X, Y = list(map(int, input().split()))
t = [0]*N
for i in range(1, N):
    for j in range(i+1, N+1):
        t[min(j-i, abs(X-i)+1+abs(j-Y))] += 1
for k in range(1, N):
    print((t[k]))
# Original solution
#!/usr/bin/python3

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

cs = [0 for i in range(n)]

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(j - y), abs(y - i) + 1 + abs(j - x))
        if d == (abs(y - i) + 1 + abs(j - x)):
            print((i, j, d))
        cs[d] += 1

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


# Optimized solution
#!/usr/bin/python3

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

cs = [0 for i in range(n)]

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(j - y))
        cs[d] += 1

for i in range(1, n):
    print((cs[i]))
# Original solution
#!/usr/bin/python3

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

cs = [0 for i in range(n)]

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(j - y))
        cs[d] += 1

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

# Optimized solution

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

cs = [0 for i in range(n)]

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(j - y))
        cs[d] += 1

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