CodeEff/ECCO huggingface dataset:
# Original solution
N,X,Y = list(map(int,input().split()))

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

from collections import deque
def bfs(u):
    queue = deque([u])
    d = [None]*(N+1)
    d[u]=0
    while queue:
        v = queue.popleft()
        for i in g[v]:
            if d[i] is None:
                d[i]=d[v]+1
                queue.append(i)
    return d

ans = [0]*(N-1)
for i in range(1,N+1):
    d = bfs(i)
    for j in range(1,N+1):
        if d[j]>0:
            ans[d[j]-1] += 1
for a in ans:
    print((a//2))

# Optimized solution
N,X,Y = list(map(int,input().split()))
g = [[] for _ in range(N+1)]
for i in range(1,N+1):
    if i != 1:
        g[i].append(i-1)
    if i != N:
        g[i].append(i+1)
g[X].append(Y)
g[Y].append(X)
from collections import deque
answer = [0]*(N+1)
for i in range(1,N+1):
    q = deque([i])
    d = [None]*(N+1)
    d[i] = 0
    while q:
        p = q.popleft()
        for j in g[p]:
            if d[j] == None:
                d[j] = d[p]+1
                q.append(j)
    for k in d[1:]:
        answer[k] += 1
for l in answer[1:-1]:
    print((l//2))
# Original solution
n, x, y = list(map(int, input().split()))
x -= 1
y -= 1

ans = [0] * n

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

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


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

ans = [0] * (n-1)

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

print(("\n".join([str(d) for d in ans])))
# Original solution
n, x, y = list(map(int,input().split()))
x, y = x-1, y-1
d=[0 for i in range(n)]

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

# Optimized solution
n, x, y = list(map(int,input().split()))
x, y = x-1, y-1
d=[0 for i in range(n)]

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


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

# Optimized solution
N, X, Y = list(map(int,input().split()))
X -= 1
Y -= 1
out = [0]*N #最低距離が1からNまでの個数を表示するリストを作る
for i in range(N-1):
  for j in range(i+1,N):
    out[min(j-i, abs(i-X)+1+abs(j-Y))] += 1 #各最低距離の個数カウント
for i in range(1,N):
  print((out[i]))
# Original solution
INF = float('inf')
from heapq import *
from collections import defaultdict

N,X,Y = list(map(int,input().split()))
X -= 1
Y -= 1
cost_pri = defaultdict(list)
for i in range(N-1):
    cost_pri[i].append((i+1,1))
    cost_pri[i+1].append((i,1))
cost_pri[X].append((Y,1))
cost_pri[Y].append((X,1))
ans = [0]*(N-1)
for s in range(N):
    dist = [2**60]*N
    dist[s] = 0
    que = [[0,s]]
    heapify(que)
    while que:
        p = heappop(que)
        v = p[1]
        if dist[v] < p[0]:continue
        for e in cost_pri[v]:
            if dist[e[0]] > dist[v] + e[1]:
                dist[e[0]] = dist[v] + e[1]
                heappush(que,[dist[e[0]],e[0]])
    
    for a in dist[s+1:]:
        ans[a-1] += 1

for a in ans:
    print(a)

# Optimized solution
from heapq import *
from collections import defaultdict

N,X,Y = list(map(int,input().split()))
X -= 1
Y -= 1
cost_pri = defaultdict(list)
for i in range(N-1):
    cost_pri[i].append((i+1,1))
    cost_pri[i+1].append((i,1))
cost_pri[X].append((Y,1))
cost_pri[Y].append((X,1))
ans = [0]*(N-1)
for s in range(N):
    dist = [2**60]*N
    dist[s] = 0
    que = [(0,s)]
    heapify(que)
    while que:
        p = heappop(que)
        v = p[1]
        if dist[v] < p[0]:continue
        for e in cost_pri[v]:
            if dist[e[0]] > dist[v] + e[1]:
                dist[e[0]] = dist[v] + e[1]
                heappush(que,(dist[e[0]],e[0]))
    
    for a in dist[s+1:]:
        ans[a-1] += 1

for a in ans:
    print(a)
# Original solution
from queue import Queue
def bfs(target, graph, ans):
    visited = [False]*len(graph)
    que = Queue()
    que.put(target)
    visited[target] = True
    distance = [0]*len(graph)
    while not que.empty():
        root = que.get()
        for dst in graph[root]:
            if visited[dst] is False:
                visited[dst] = True
                que.put(dst)
                dist = distance[root] + 1
                distance[dst] = dist
                ans[dist-1] += 1 

n, x, y = list(map(int, input().split()))
graph = {i:[] for i in range(n)}
for i in range(n-1):
    graph[i].append(i+1)
    graph[i+1].append(i)
graph[x-1].append(y-1)
graph[y-1].append(x-1)
ans = [0]*(n-1)
for target in range(n):
    bfs(target, graph, ans)

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

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

for d in dist:
    print(d)
# Original solution
n, x, y = list(map(int, input().split()))
x -= 1
y -= 1

k = [0 for _ in range(n)]
for i in range(n):
    for j in range(i + 1, n):
        dist = min([j-i, abs(x-i)+1+abs(j-y), abs(y-i)+1+abs(j-x)])
        if dist < n:
            k[dist] += 1
for i in range(1, len(k)):
    print((k[i]))


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

k = [0 for _ in range(n)]
for i in range(n):
    for j in range(i + 1, n):
        dist = min(j-i, abs(x-i)+1+abs(j-y))
        if dist < n:
            k[dist] += 1
for i in range(1, len(k)):
    print((k[i]))
# Original solution
"""
"""
n,x,y=list(map(int,input().split()))
k_mins=[]
for i in range(1,n):
    for j in range(i+1,n+1):
        k_mins.append(min(j-i,abs(x-i)+1+abs(y-j),abs(x-j)+1+abs(y-i)))
ret=[]
k_mins.sort(reverse=True)
for i in range(1,n):
    c=0
    while len(k_mins) > 0 and k_mins[len(k_mins)-1]==i:
        k_mins.pop() 
        c+=1
    ret.append(c)
for r in ret:
    print(r)




# Optimized solution
"""
"""
n,x,y=list(map(int,input().split()))
ret=[0]*(n-1)
for i in range(1,n):
    for j in range(i+1,n+1):
        ret[min(j-i,abs(x-i)+1+abs(y-j),abs(x-j)+1+abs(y-i))-1]+=1
for r in ret:
    print(r)
# Original solution
from collections import deque
n,x,y = [int(x) for x in input().split()]
l = [[] for i in range(n+1)]
p = []
q = []
l[1].append(2)
for i in range(2,n):
    l[i].append(i+1)
    l[i].append(i-1)
l[n].append(n-1)
l[x].append(y)
l[y].append(x)
clist = [0]*(n+1)
#ここまでで、グラフが隣接リスト表記で表される
for k in range(1,n+1):
    d = deque()
    dist = [-1]*(n+1)
    dist[k] = 0
    d.append(k)
    while True:
        v = d.popleft()
        for i in l[v]:
            if dist[i] != -1:
                continue
            dist[i] = dist[v] + 1
            d.append(i)
        if not d:
            break
    for j in dist[k+1:]:
        clist[j] += 1
for i in range(1,n):
    print((clist[i]))

# Optimized solution
n,x,y = [int(x) for x in input().split()]
count = [0]*(n+1)
for i in range(1,n):
    for j in range(i+1,n+1):
        if i < x and j <= x:
            nagasa = j - i
        elif i < x and x < j and j < y:
            nagasa = x-i + min(j-x,y-j+1)
        elif i < x and y <= j:
            nagasa = x-i + j - y + 1
        elif x <= i and i < y and j <= y:
            nagasa = min(j-i,i-x+y-j+1)
        elif x <= i and i < y and y < j:
            nagasa = j - y + min(y-i,i-x+1)
        elif y <= i:
            nagasa = j -i
        count[nagasa] += 1
for i in range(1,n):
    print((count[i]))
# Original solution
from collections import deque, defaultdict

N, X, Y = list(map(int, input().split()))
# 全探索でいけるのでは？
# 有向グラフとしてN回幅優先すれば良いのでは？
tree = [[] for _ in range(N)]
for i in range(N-1):
    tree[i].append(i+1)
    tree[i+1].append(i)
tree[X-1].append(Y-1)
tree[Y-1].append(X-1)
ans = defaultdict(int)
q = deque()
# 更新されない時はqに追加しない
for i in range(N):
    distant = [N]*N
    q.append(i)  # 始まりのノード
    distant[i] = 0
    while len(q):
        # vは数字, 親のノードのインデックス
        v = q.pop()
        for e in tree[v]:
            if distant[e] < distant[v]+1:  # 到達済みなら次のノードへ
                continue
            distant[e] = min(distant[v]+1, distant[e])
            q.append(e)
    for d in distant:
        ans[d] += 1
for i in range(1, N):
    print((ans[i]//2))


# Optimized solution
from collections import deque, defaultdict

N, X, Y = list(map(int, input().split()))
# 全探索でいけるのでは？
# 有向グラフとしてN回幅優先すれば良いのでは？
tree = [[] for _ in range(N)]
for i in range(N-1):
    tree[i].append(i+1)
    tree[i+1].append(i)
tree[X-1].append(Y-1)
tree[Y-1].append(X-1)
ans = defaultdict(int)
q = deque()
# 更新されない時はqに追加しない
for i in range(N):
    distant = [N]*N
    q.append(i)  # 始まりのノード
    distant[i] = 0
    while len(q):
        # vは数字, 親のノードのインデックス
        v = q.pop()
        for e in tree[v]:
            if distant[e] < distant[v]+1:  # 到達済みなら次のノードへ
                continue
            distant[e] = distant[v]+1
            q.append(e)
    for d in distant:
        ans[d] += 1
for i in range(1, N):
    print((ans[i]//2))
# Original solution
import heapq

INF = float('inf')

class Edge():
    def __init__(self, a, b, cost):
        self.a = a
        self.b = b
        self.cost = cost
    def __str__(self):
        return 'Edge: {} -> {}, cost {}'.format(self.a, self.b, self.cost)

def dijkstra(n, G, s):
    dist = [INF] * n
    dist[s] = 0
    h = []
    heapq.heappush(h, (0, s))

    while h:
        # 使っていない頂点のうち、現時点で最も距離の近いものを選びvとする
        d, v = heapq.heappop(h)
        if dist[v] < d:
            continue
        # vから到達可能な頂点について、距離が短くなれば更新
        for e in G[v]:
            if dist[e.b] > dist[v] + e.cost:
                dist[e.b] = dist[v] + e.cost
                heapq.heappush(h, (dist[e.b], e.b))
    return dist

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

g = [[] for i in range(n)]

for i in range(n-1):
    g[i].append(Edge(i, i+1, 1))
    g[i+1].append(Edge(i+1, i, 1))

g[x-1].append(Edge(x-1, y-1, 1))
g[y-1].append(Edge(y-1, x-1, 1))

ans = [0] * n

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

for item in ans[1:]:
    print((item // 2))



# Optimized solution
import heapq

INF = float('inf')

def dijkstra(n, G, s):
    dist = [INF] * n
    dist[s] = 0
    h = []
    heapq.heappush(h, (0, s))

    while h:
        # 使っていない頂点のうち、現時点で最も距離の近いものを選びvとする
        d, v = heapq.heappop(h)
        if dist[v] < d:
            continue
        # vから到達可能な頂点について、距離が短くなれば更新
        for b, cost in G[v]:
            if dist[b] > dist[v] + cost:
                dist[b] = dist[v] + cost
                heapq.heappush(h, (dist[b], b))
    return dist

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

g = [[] for i in range(n)]

for i in range(n-1):
    g[i].append((i+1, 1))
    g[i+1].append((i, 1))

g[x-1].append((y-1, 1))
g[y-1].append((x-1, 1))

ans = [0] * n

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

for item in ans[1:]:
    print((item // 2))
# Original solution
# coding: utf-8
DATA = """
10 4 8
""".split("\n")

def get_debug_line():
	for i in DATA:
		yield i

if 1:
	get_line = input
else:
	get_line = get_debug_line().__next__
	get_line()

N, X, Y = [int(i) for i in get_line().strip().split(" ")]
X-=1
Y-=1
INF = 10 * 20
m = [[0] * N for _ in range(N)]
tt = [0] * N

#print(ret)
#print(len(ret))

for r in range(N):
	for c in range(r+1, N):
		m[r][c] = c - r
		#m[c][r] = m[r][c]
		tt[m[r][c]] += 1
		m[c][r] = m[r][c]

def Set(r, c, v):
	tt[m[r][c]] -= 1
	m[r][c] = v
	tt[m[r][c]] += 1

for r in range(N):
	if m[r][X] < m[r][Y]:
		Set(r, Y, m[r][X]+1)
	for c in range(Y+1, N):
		if m[r][c] <= m[r][c-1]:
			break
		Set(r, c, m[r][c-1]+1)
	for c in range(Y-1, X, -1):
		if m[r][c] <= m[r][c+1]:
			break
		Set(r,c, m[r][c+1]+1)

for t in tt[1:]:
	print (t)

# Optimized solution
# coding: utf-8
DATA = """
10 4 8
""".split("\n")

def get_debug_line():
	for i in DATA:
		yield i

if 1:
	get_line = input
else:
	get_line = get_debug_line().__next__
	get_line()

N, X, Y = [int(i) for i in get_line().strip().split(" ")]
X-=1
Y-=1
INF = 10 * 20
m = [[0] * N for _ in range(N)]
tt = [0] * N

#print(ret)
#print(len(ret))

for r in range(N):
	for c in range(r+1, N):
		m[r][c] = c - r
		#m[c][r] = m[r][c]
		tt[m[r][c]] += 1
		m[c][r] = m[r][c]

def Set(r, c, v):
	if m[r][c] < v:
		return False
	else:
		tt[m[r][c]] -= 1
		m[r][c] = v
		tt[m[r][c]] += 1
		return True

for r in range(N):
	if not Set(r, Y, m[r][X]+1):
		continue
	for c in range(Y+1, N):
		if not Set(r, c, m[r][c-1]+1):
			break
	for c in range(Y-1, X, -1):
		if not Set(r,c, m[r][c+1]+1):
			break

for t in tt[1:]:
	print (t)
# Original solution
#!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
import heapq
n,x,y = list(map(int,input().split()))
G = [[]*n for i in range(n)]
for i in range(n-1):
  G[i].append((i+1))
  G[i+1].append(i)
x-=1;y-=1
G[x].append((y))
G[y].append((x))
# print(G)
def bfs(g,s):
    n=len(g)
    dist = [inf]*n
    dist[s] = 0
    q = collections.deque()
    q.append(s)
    while q:
        u = q.popleft()
        for v in g[u]:
            if dist[v] != inf:continue
            dist[v] = dist[u] + 1
            q.append(v)
    return dist
sets = [set() for i in range(n)]
for i in range(n-1):
  dist = bfs(G,i)
  for j in range(n):
    sets[dist[j]].add((min(i,j),max(i,j)))
for i in range(1,n):
  print((len(sets[i])))
    


# Optimized solution
#!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
import heapq
n,x,y = list(map(int,input().split()))
G = [[]*n for i in range(n)]
for i in range(n-1):
  G[i].append((i+1))
  G[i+1].append(i)
x-=1;y-=1
G[x].append((y))
G[y].append((x))
# print(G)
def bfs(g,s):
    n=len(g)
    dist = [inf]*n
    dist[s] = 0
    q = collections.deque()
    q.append(s)
    while q:
        u = q.popleft()
        for v in g[u]:
            if dist[v] != inf:continue
            dist[v] = dist[u] + 1
            q.append(v)
    return dist
D = [0]*n
for i in range(n-1):
  dist = bfs(G,i)
  for j in range(i+1,n):
    D[dist[j]] += 1
for i in range(1,n):
  print((D[i]))
# Original solution
#abc160 d
from collections import deque
import itertools
n,x,y=list(map(int,input().split()))
g=[[False]*n for _ in range(n)]

for i in range(n-1):
    g[i][i+1]=True
    g[i+1][i]=True
g[x-1][y-1]=True
g[y-1][x-1]=True

def bfs(s,e):
    color=[False]*n
    dis=[0]*n
    q=deque()
    q.append(s-1)
    color[s-1]=True

    while q:
        now=q.popleft()

        if now==(e-1):
            break
        for i in range(n):
            if g[now][i]==True and color[i]==False:
                dis[i]+=dis[now]+1
                color[i]=True
                q.append(i)
    return dis[e-1]
l=[i for i in range(1,n+1)]
c=itertools.combinations(l,2)
ans=[0]*n
for s,e in c:
    distance=bfs(s,e)
    ans[distance]+=1
for i in range(1,n):
    print((ans[i]))

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

ans=[0]*(n+1)



for i in range(n):
    for j in range(i+1,n):
        a=abs(i-j)
        b=abs(i-x)+1+abs(y-j)
        c=abs(y-i)+1+abs(x-j)
        ans[min(a,b,c)]+=1
for i in range(1,n):
    print((ans[i]))
# Original solution
N, x, y = list(map(int, input().split()))
INF = 10 ** 100
adj_mtx = [ [INF] * (N+1) for _ in range(N+1) ]

for i in range(1, N+1):
  if i != N:
    adj_mtx[i][i] = 0
    adj_mtx[i][i+1] = 1
    adj_mtx[i+1][i] = 1
adj_mtx[x][y] = 1
adj_mtx[y][x] = 1

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

for i in range(1, N):
  print((sum([ r.count(i) for r in adj_mtx ]) // 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):
    step = min( j-i, abs(i-X)+1+abs(j-Y), abs(i-Y)+1+abs(j-X))
    result[step] += 1

for e in result[1:]: print(e)
# Original solution
N, X, Y= list(map(int, input().split())) 
Count = []
for i in range(N-1):
  Count.append(0)
  
for k in range(1, N):
  for i in range(1, N):
    for j in range(i+1, N+1):
      if (j-i > k) & ((abs(i-X) +abs(j-Y) +1)>k) & ((abs(i-X) +abs(j+1-Y) +1 )>(abs(i-X) +abs(j-Y) +1)>k):
        break
      if j-i <= (abs(i-X) +abs(j-Y) +1):
        if j-i == k:
          Count[k-1] = Count[k-1]+1
      else:
        if (abs(i-X) +abs(j-Y) +1) == k:
          Count[k-1] = Count[k-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):
    Count[min(j-i, (abs(i-X) +abs(j-Y) +1),  (abs(i-Y) +abs(j-X) +1))-1] += 1

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

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

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

# Optimized solution
n,x,y = list(map(int, input().split()))
ans = [0]*(n-1)

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

for m in range(n-1):
    print((ans[m]))
# Original solution
import itertools
import collections

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

pos = [i for i in range(1,N+1)]
ways = list(itertools.combinations(pos,2))

dist_l = [min(abs(i-j), abs(i - X) + 1 + abs(Y - j)) for i,j in ways]

dic = collections.Counter(dist_l)
for i in range(1,N):
    print((dic[i]))

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

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

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


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

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

for k in range(1, N):
    print((dis.count(k)))

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

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

for k in range(1, N):
    print((dis[k]))
# Original solution
def warshallFloyd(n,l):
    for k in range(n):
        for i in range(n):
            for j in range(n):
                l[i][j]=min(l[i][j],l[i][k]+l[k][j])
    return l

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

for i in range(n):
    l[i][i]=0
for i in range(n-1):
    l[i][i+1]=1
    l[i+1][i]=1
l[x-1][y-1]=1
l[y-1][x-1]=1

distance=warshallFloyd(n,l)

ans=[0]*n

for i in range(n-1):
    for j in range(i+1,n):
        ans[distance[i][j]]+=1
        
for i in range(1,n):
    print((ans[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):
        distance=min(j-i,abs(x-i)+1+abs(j-y))
        ans[distance]+=1
for i in range(1,n):
    print((ans[i]))
# Original solution
n,x,y = map(int,input().split())
ans = [0]*(n-1)
for i in range(n):
    tbl = [0]*n
    for j in range(i,n):
        tbl[j] = min(abs(j+1-i-1),abs(i+1-x)+1+abs(j+1-y))
    for i in range(1,n):
        ans[i-1] += tbl.count(i)
[print(i) for i in ans]


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

X = X - 1
Y = Y - 1

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

for i in range(N):
    if i != N - 1:
        D[i].append(i + 1)
        if i != 0:
            D[i].append(i - 1)
    else:
        D[i].append(i - 1)

D[X].append(Y)
D[Y].append(X)


def search(start):
    queue = [start]
    depth = 0
    dic = {start: 0}

    while len(queue) > 0:
        depth += 1
        nextQueue = []
        while len(queue) > 0:
            now = queue[0]
            del(queue[0])
            neighbors = D[now]
            for n in neighbors:
                if n not in dic:
                    nextQueue.append(n)
                    dic[n] = depth
        queue = nextQueue
    return dic
    
lenD = []
for i in range(N):
    d = search(i)
    lenD.append(d)

kcounter = [0 for _ in range(N - 1)]

for i in range(N):
    for j in range(i + 1, N):
        k = lenD[i][j]
        kcounter[k - 1] += 1

for k in kcounter:
    print(k)

# Optimized solution

def search(start, N, X, Y):
    dist = [0 for _ in range(N)]
    if start <= X:
        for i in range(X):
            dist[i] = abs(start - i)
        for i in range(Y, N):
            dist[i] = (X - start) + 1 + (i - Y)
        for i in range(X, (Y - X) // 2 + X + 1):
            dist[i] = (i - start)
        for i in range((Y - X) // 2 + X + 1, Y):
            dist[i] = (X - start) + 1 + (Y - i)
    elif start >= Y:
        for i in range(Y, N):
            dist[i] = abs(start - i)
        for i in range(X):
            dist[i] = (start - Y) + 1 + (X - i)
        for i in range(X, (Y - X) // 2 + X):
            dist[i] = (start - Y) + 1 + (i - X)
        for i in range((Y - X) // 2 + X, Y):
            dist[i] = (start - i)
    else:
        toX = min(start - X, Y - start + 1)
        toY = min(Y - start, start - X + 1)
        dist[start] = 0
        for i in range(X):
            dist[i] = (X - i) + toX
        for i in range(Y, N):
            dist[i] = toY + (i - Y)
        for i in range(X, start):
            dist[i] = min(start - i, Y - start + 1 + i - X)
        for i in range(start + 1, Y):
            dist[i] = min(i - start, start - X + 1 + Y - i)
    return dist


def main():
    N, X, Y = [int(n) for n in input().split(" ")]
    #N, X, Y = 10, 3, 8

    X = X - 1
    Y = Y - 1

    lenD = []
    for i in range(N):
        d = search(i, N, X, Y)
        lenD.append(d)

    kcounter = [0 for _ in range(N - 1)]

    for i in range(N):
        for j in range(i + 1, N):
            k = lenD[i][j]
            kcounter[k - 1] += 1

    for k in kcounter:
        print(k)

main()
# 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):
        ans[min(abs(i-j),min(abs(i-x)+1+abs(j-y),abs(i-y)+1+abs(j-x)))]+=1
for i in range(1,n):
    print((ans[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[min(j-i,abs(i-x)+1+abs(j-y))]+=1
for i in range(1,n):
    print((ans[i]))