CodeEff/ECCO huggingface dataset:
# Original solution
import queue
n, x, y = list(map(int, input().split()))

graph = {i: [] for i in range(1, n + 1)}
graph[x].append(y)
graph[y].append(x)
for i in range(1, n):
    graph[i].append(i + 1)
    graph[i + 1].append(i)

tf = [[False] * (n + 1) for i in range(n + 1)]
ans = [0] * (n + 1)
def bfs(v):
    q = queue.Queue()
    q.put([v, 0, v])
    voi[v] = True
    while not q.empty():
        sub = q.get()
        now = sub[0]
        depth = sub[1]
        before = sub[2]
        if tf[now][v] == False:
            ans[depth] += 1
            tf[now][v] = True
            tf[v][now] = True
        for next in graph[now]:
            if voi[next]:
                continue
            voi[next] = True
            q.put([next, depth + 1, now])

for i in range(1, n + 1):
    voi = [False] * (n + 1)
    bfs(i)

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

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

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

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

adj[x-1].append(y-1)
adj[y-1].append(x-1)

for i in range(n-1):
    adj[i].append(i+1) 
    adj[i+1].append(i)
        
ans = [0 for _ in range(n+1)]

def bfs(start):
    inf = 1001001001
    q = queue.Queue()
    q.put(start)
    dist = [inf]*n
    dist[start] = 0
    
    while not q.empty():
        v = q.get()

        for i in adj[v]:
            if dist[i] == inf:
                dist[i] = dist[v] + 1
                q.put(i)

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

for i in range(n):
    bfs(i)

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

# Optimized solution
from collections import deque

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

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

adj[x-1].append(y-1)
adj[y-1].append(x-1)

for i in range(n-1):
    adj[i].append(i+1) 
    adj[i+1].append(i)
        
ans = [0 for _ in range(n)]

def bfs(start):
    inf = 1001001001
    q = deque()
    q.append(start)
    dist = [inf]*n
    dist[start] = 0
    
    while q:
        v = q.popleft()

        for i in adj[v]:
            if dist[i] == inf:
                dist[i] = dist[v] + 1
                q.append(i)

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

for i in range(n):
    bfs(i)

for i in range(1,n):
    print((ans[i]//2))
# Original solution
n,x,y = list(map(int, input().split()))
import collections

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


inf = 10**5
dp = [[inf for i in range(n)] for j in range(n)]
todo = collections.deque()

for i in range(n):
    dp[i][i] = 0
    for j in g[i]:
        todo.append(j)
    while len(todo) > 0:
        now = todo.popleft()
        leng = inf
        for j in g[now]:
            if dp[i][j] == inf:
                todo.append(j)
            else:
                tem = dp[i][j] + 1
                if tem < leng:
                    leng = tem
        dp[i][now] = leng

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

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

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

for i in ans:
    print(i)
# Original solution
# -*- coding: utf-8 -*-
"""
Created on Sat Mar 28 20:51:45 2020

@author: naoki
"""
from collections import deque
N, X, Y = list(map(int,input().split()))

distance_count = [0] * (N + 1)
route = [[i-1, i+1] for i in range(N+1)]

del route[-1][-1]

All_distances = [0]*N
route[X].append(Y)
route[Y].append(X)
#%%
for j in range(1,N):
    todo = deque([j])
    seen = [0 for i in range(N+1)]
    distance = [float("inf")] * (N+1)
    distance[j] = 0
    while len(todo) > 0:
        now = todo.pop()
        if now == N+1 or now == 0:
            continue
        for checking in route[now]:
            if seen[checking] < 2 and distance[checking] > distance[now] + 1:
                distance[checking] = distance[now] + 1
                todo.append(checking)
                seen[checking] += 1
            elif distance[checking] > distance[now] + 1:
                distance[checking] = distance[now] + 1
    for i in range(j,len(distance)):
        if distance[i] != float("inf"):
            All_distances[distance[i]] += 1
for i in range(1,N):
    print((All_distances[i]))

# Optimized solution
# -*- coding: utf-8 -*-
"""
Created on Sat Mar 28 20:51:45 2020

@author: naoki
"""
from collections import deque
N, X, Y = list(map(int,input().split()))

distance_count = [0] * (N + 1)
route = [[i-1, i+1] for i in range(N+1)]

del route[-1][-1]

All_distances = [0]*N
route[X].append(Y)
route[Y].append(X)
#%%
for j in range(1,N):
    todo = deque([j])
    seen = [0 for i in range(N+1)]
    distance = [N+1] * (N+1)
    distance[j] = 0
    while len(todo) > 0:
        now = todo.pop()
        if now == N+1 or now == 0:
            continue
        for checking in route[now]:
            kari1 = distance[checking]
            kari2 = distance[now] + 1
            if seen[checking] < 2 and kari1 > kari2:
                distance[checking] = kari2
                todo.append(checking)
                seen[checking] += 1
            elif kari1 > kari2:
                distance[checking] = kari2
    for i in range(j,len(distance)):
        if distance[i] != N+1:
            All_distances[distance[i]] += 1
for i in range(1,N):
    print((All_distances[i]))
# Original solution
N,X,Y = list(map(int,input().split()))

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

for i in range(1,N):
    checking = i

    #まずスタート地点から幅優先探索を実装
    queue = [[i,0]]

    if i >= Y:
        checked = list(range(1,i+1))
    elif i <= X:
        checked = list(range(1,i+1))
    else:
        checked = list(range(1,X))
        checked.append(i)

    while(True):
        now = queue[0]

        #ショートカット確認
        if now[0] == X:
            if Y not in checked:
                queue.append([Y,now[1]+1])
                checked.append(Y)
                if not(checking > Y):
                    ans[now[1]+1] += 1
                    # print(now[0],Y,now[1]+1)

        if now[0] == Y:
            if X not in checked:
                queue.append([X,now[1]+1])
                checked.append(X)
                if not(checking > X):
                    ans[now[1]+1] += 1
                    # print(now[0],X,now[1]+1)

        #左
        if now[0]-1 >= 1 and now[0]-1 not in checked:
            queue.append([now[0]-1,now[1]+1])
            checked.append(now[0]-1)
            if not(checking > now[0]-1):
                ans[now[1]+1] += 1
                # print(now[0],now[0]-1,now[1]+1)

        #右
        if now[0]+1 <= N and now[0]+1 not in checked:
            queue.append([now[0]+1,now[1]+1])
            checked.append(now[0]+1)
            if not(checking > now[0]+1):
                ans[now[1]+1] += 1
                # print(now[0],now[0]+1,now[1]+1)

        queue.pop(0)

        if len(checked) == N or len(queue) == 0:
            break

#回答を出力
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+1)]

def calc_goal(start,goal):
    if goal <= X:
        return goal-start
    if goal <= Y:
        if X >= start:
            return min(goal-start,X-start+Y-goal+1)
        else:
            return min(start-X+Y-goal+1,goal-start)
    else:
        if X >= start:
            return X-start+goal-Y+1
        else:
            return min(start-X+goal-Y+1,goal-start)

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

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

dlist = []
for i in range(1,N+1):
  for j in range(i,N+1):
    dis = min( abs(j-i), abs(X-i) +1+abs(j-Y), abs(Y-i) +1+abs(j-X) )
    dlist.append(dis)
    
for i in range(1,N):
  cnt = 0
  for val in dlist:
    if( val == i ):
      cnt+=1
  print( cnt )


# 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):
    dis = min( abs(j-i), abs(X-i) +1+abs(j-Y), abs(Y-i) +1+abs(j-X) )
    ans[dis]+=1
    
for i in range(1,N):
  print(( ans[i] ))
# Original solution
N,X,Y=list(map(int,input().split()))
def dist(i,j):
  return min([j-i,abs(X-1-i)+1+abs(Y-1-j),abs(Y-1-i)+1+abs(X-1-j)])
dists = []
for i in range(N-1):
  for j in range(i+1,N):
    dists.append(dist(i,j))
for i in range(1,N):
  print((len([str(v) for v in dists if v == i])))
  
    

# Optimized solution
N,X,Y=list(map(int,input().split()))
def dist(i,j):
  return min([j-i,abs(X-1-i)+1+abs(Y-1-j),abs(Y-1-i)+1+abs(X-1-j)])
dists = {v:0 for v in range(1,N)}
for i in range(N-1):
  for j in range(i+1,N):
    d = dist(i,j)
    dists[d]+=1
for i in range(1,N):
  print((dists[i]))
# Original solution
n,x,y = list(map(int,input().split()))
ps = []
for i in range(n):
    for j in range(i):
        ps.append([j+1,i+1])

dists = [0]*(n)
for p in ps:
    dist = min(abs(p[0]-p[1]),abs(p[0]-x)+1+abs(p[1]-y),abs(p[1]-x)+1+abs(p[0]-y))
    dists[dist] = dists[dist]+1

for i in range(len(dists) - 1):
    print((dists[i+1]))

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

# Optimized solution
n,x,y = list(map(int,input().split()))
dists = [0]*(n)
for i in range(1,n+1):
    for j in range(1,i):
        dists[min(i-j,abs(j-x)+1+abs(i-y))]+=1
    
for i in range(1,len(dists)):
    print((dists[i]))
# Original solution
# N=頂点数、X,Y=座標
N, X, Y = list(map(int, input().split()))
X -= 1
Y -= 1

# 未セットの値
INF = 10**4

# キューデータ(次の値、最短距離)
queue_list = []

# 最短距離ごとのリスト
min_e_list = [0 for i in range(N)]

for i in range(N):
    # キューデータ初期値をセット
    queue_list.append([i, 0])
    # 最短距離リスト(最短距離)
    min_dist_list = [INF for i in range(N)] 

    # キューデータが空になるまで繰り返す
    while(len(queue_list) != 0):
        
        # 先頭データを取り出す。
        pop_data = queue_list.pop(0)

        # 取り出した座標がセット済みの場合は何もしない
        if(min_dist_list[pop_data[0]] != INF):
            continue

        # 最短距離リストにデータセット
        min_dist_list[pop_data[0]] = pop_data[1]

        # 2重に数えないよう(i < 取り出した座標時)、最短距離ごとのリストにデータセット
        if(i < pop_data[0]):
            min_e_list[pop_data[1]] += 1

        # 1.隣の頂点(次の座標、+1,-1した値)
        if(pop_data[0]+1 < N):
            queue_list.append([pop_data[0]+1, pop_data[1]+1])
        if(pop_data[0] > 0 and pop_data[0]-1 < N):
            queue_list.append([pop_data[0]-1, pop_data[1]+1])
        
        # 2.X,Yで示した値
        if(pop_data[0] == X):
            queue_list.append([Y, pop_data[1]+1])
        if(pop_data[0] == Y):
            queue_list.append([X, pop_data[1]+1])

# 出力
for i,v in enumerate(min_e_list):
    if(i != 0):
        print(v)

# Optimized solution
# N=頂点数、X,Y=座標
N, X, Y = list(map(int, input().split()))

# 最短距離データ
min_dist_list = [0 for i in range(N+1)]

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

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


def input(): return sys.stdin.readline().strip()
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def S(): return input()
def LS(): return input().split()


INF = float('inf')


def bfs(n, g, start):
    d = [INF] * n
    que = deque([start])
    d[start] = 0
    while que:
        now = que.popleft()
        for next in g[now]:
            if d[next] != INF:
                continue
            que.append(next)
            d[next] = d[now] + 1
    return d


def main():
    n, x, y = LI()
    edges = defaultdict(list)
    edges[x - 1].append(y - 1)
    edges[y - 1].append(x - 1)
    for i in range(n - 1):
        edges[i].append(i + 1)
        edges[i + 1].append(i)
    ans = [0] * (n - 1)
    for i in range(n):
        d = bfs(n, edges, i)
        for k in range(1, n):
            ans[k - 1] += len([j for j in d if j == k])
    ans = list(map(lambda x: x//2, ans))
    print(*ans, sep='\n')


main()


# Optimized solution
import sys


def input(): return sys.stdin.readline().strip()
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def S(): return input()
def LS(): return input().split()


INF = float('inf')


def main():
    n, x, y = LI()
    x, y = x - 1, y - 1
    d = [[INF] * n for _ in range(n)]
    ans = [0] * n
    for i in range(n - 1):
        for j in range(i + 1, n):
            d[i][j] = min([j - i,
                           abs(x - i) + 1 + abs(j - y),
                           abs(y - i) + 1 + abs(j - x)])
            ans[int(d[i][j])] += 1
    print(*ans[1:], sep='\n')


main()
# Original solution
import math
nums = [int(i) for i in input().split()]
n = nums[0]
x = nums[1]
y = nums[2]
res = {}
for i in range(1, n):
    res[i] = 0
for i in range(1, n+1):
    for j in range(i+1, n+1):
        dis = j - i
        disI = min(abs(i-x), abs(i-y))
        disJ = min(abs(j-x), abs(j-y))
        dis = min(dis, disI+disJ+1)
        res[dis] += 1
for i in range(1, n):
    print((res[i]))


# Optimized solution
import math
nums = [int(i) for i in input().split()]
n = nums[0]
x = nums[1]
y = nums[2]
res = [0 for i in range(2010)]

for i in range(1, n+1):
    for j in range(i+1, n+1):
        dis = j - i
        dis = min(dis, abs(i-x)+abs(j-y)+1)
        res[dis] += 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_l = [0]*n
for i in range(n):
    for j in range(i, n):
        k = min(abs(j-i), abs(x-i)+1+abs(y-j), abs(x-j)+1+abs(y-i))
        ans_l[k] += 1
for ans in ans_l[1:]:
    print(ans)

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

def min_dist(a,b):
    return min(b-a, abs(x-a)+1+abs(y-b), abs(x-b)+1+abs(y-a))
for i in range(n):
    for j in range(i, n):
        k = min_dist(i,j)
        ans_l[k] += 1
for ans in ans_l[1:]:
    print(ans)
# Original solution
n, x, y = list(map(int, input().split()))
x -= 1
y -= 1
ans_l = [0]*n

def min_dist(a,b):
    return min(b-a, abs(x-a)+1+abs(y-b), abs(x-b)+1+abs(y-a))
for i in range(n):
    for j in range(i, n):
        k = min_dist(i,j)
        ans_l[k] += 1
for ans in ans_l[1:]:
    print(ans)

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

def min_dist(a,b):
    return min(b-a, abs(x-a)+1+abs(y-b), abs(x-b)+1+abs(y-a))
for i in range(n):
    for j in range(i, n):
        ans_l[min_dist(i,j)] += 1
for ans in ans_l[1:]:
    print(ans)
# Original solution
from heapq import heappush, heappop
n, x, y = list(map(int, input().split()))

links = [[] for i in range(n)]
for i in range(1, n):
        links[i-1].append(i)
        links[i].append(i-1)
links[x-1].append(y-1)
links[y-1].append(x-1)

ans = [0] * (n+1)
for i in range(n):
        dist = [1e5] * n
        used = [0] * n
        que = []
        heappush(que, [0, i])
        while len(que):
                dis, v = heappop(que)
                if used[v]: continue
                ans[dis] += 1
                used[v] = True
                for to in links[v]:
                        if not used[to]:
                                heappush(que, [dis+1, to])
for i in range(1, n): print((ans[i]//2))

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

ans = [0] * (n+1)
for i in range(1, n+1):
        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]))
# Original solution
def main():
    n, x, y = map(int, input().split())
    ans = [0] * (n+1)
    d = list()
    for i in range(1, n):
        for j in range(i+1, n+1):
            # x->yを通らない
            d1 = abs(j-i)
            # i->x->y->jの順 +1はx->yの分
            d2 = abs(x-i) + 1 + abs(j-y) 
            # i->y->x->jの順 +1はy->xの分
            d3 = abs(y-i) + 1 + abs(j-x)
            dist = min(min(d1, d2), d3)
            d.append(dist)
            ans[dist] += 1
    print(*ans[1:n], sep='\n')

if __name__ == '__main__':
    main()


# Optimized solution
def main():
    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):
            # x->yを通らない
            d1 = abs(j-i)
            # i->x->y->jの順 +1はx->yの分
            d2 = abs(x-i) + 1 + abs(j-y) 
            # i->y->x->jの順 +1はy->xの分
            d3 = abs(y-i) + 1 + abs(j-x)
            dist = min(min(d1, d2), d3)
            ans[dist] += 1
    print(*ans[1:n], sep='\n')

if __name__ == '__main__':
    main()
# Original solution
n,x,y = list(map(int,input().split()))
x -= 1
y -= 1
dis = [[0 for i in range(n)]for j in range(n)]
for i in range(n):
    for j in range(i+1,n):
        dis[i][j] = min(abs(j-i),min(abs(j-y)+abs(x-i)+1,abs(j-x)+abs(y-i)+1))
d = [0 for i in range(n)]
for i in range(n):
    for j in range(n):
        d[dis[i][j]] += 1
print(("\n".join(map(str,d[1:]))))

# Optimized solution
n,x,y = list(map(int,input().split()))
x -= 1
y -= 1
dis = [0 for i in range(n)]
for i in range(n):
    for j in range(i+1,n):
        dis[min(abs(j-i),min(abs(j-y)+abs(x-i)+1,abs(j-x)+abs(y-i)+1))] += 1
print(("\n".join(map(str,dis[1:]))))
# Original solution
s = input().split()
n=int(s[0])
x=int(s[1])-1
y=int(s[2])-1
inf=float('inf')
map=[]
for i in range(n):
    for j in range(i+1,n):
        map.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((map.count(i)))

# Optimized solution
s = input().split()
n=int(s[0])
x=int(s[1])-1
y=int(s[2])-1
inf=float('inf')
map={}
for i in range(n):
    map[i]=0
for i in range(n):
    for j in range(i+1,n):
        map[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((map[i]))
# Original solution
import sys
from collections import deque
def input(): return sys.stdin.readline().rstrip()

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

    ans = [0] * N
    for i in range(1, N+1):
        dist = [-1] * (N+1)
        dist[i] = 0
        q = deque()
        q.append(i)
        def push(l, m):
            if dist[l] > -1:
                return
            q.append(l)
            dist[l] = dist[m] + 1
            ans[dist[l]] += 1

        while q:
            j = q.popleft()
            if j < N: push(j+1, j)
            if j > 1: push(j-1, j)
            if j == X: push(Y, j)
            if j == Y: push(X, j)
    for i in range(1, N):
        print((ans[i]// 2))

if __name__ == '__main__':
    main()

# Optimized solution
import sys
from collections import deque
def input(): return sys.stdin.readline().rstrip()

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

    ans = [0] * N
    for i in range(1, N+1):
        dist = [-1] * (N+1)
        dist[i] = 0
        q = deque()
        q.append(i)
        def push(l, m):
            if dist[l] > -1:
                return
            q.append(l)
            dist[l] = dist[m] + 1
            ans[dist[l]] += 1

        while q:
            j = q.popleft()
            if j < N: push(j+1, j)
            if j > 1: push(j-1, j)
            if j == X: push(Y, j)
            if j == Y: push(X, j)
    print(*[i // 2for i in ans[1:]], sep='\n')

if __name__ == '__main__':
    main()
# Original solution
n,x,y = [int(x) for x in input().split()]

for k in range(1, n):
    ans = 0
    for i in range(1,n):
        for j in range(i+1, n+1):
            if min(abs(j-i), abs(x-i)+1+abs(j-y), abs(y-i)+1+abs(j-x)) == k:
                ans += 1
    print(ans)

# Optimized solution
n,x,y = [int(x) for x in input().split()]
d = {x: 0 for x in range(1, n)}
for i in range(1,n):
    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))] += 1
for v in list(d.values()):
    print(v)
# Original solution
import sys
from heapq import heappush, heappop

inf = float('inf')

n, x, y = list(map(int, sys.stdin.readline().split()))
g = [[] for _ in range(n)]
for i in range(n-1):
    g[i].append(i+1)
    g[i+1].append(i)
g[x-1].append(y-1)
g[y-1].append(x-1)

def dijkstra(i):
    dist = [inf] * n
    dist[i] = 0
    q = [(0, i)]
    visited = set()

    while q:
        d, x = heappop(q)
        if x in visited:
            continue
        dist[x] = d
        visited.add(x)
        for y in g[x]:
            if y in visited:
                continue
            heappush(q, (d+1, y))
    return dist
    
def main():
    res = [0] * (n + 1)
    for i in range(n):
        dist = dijkstra(i)
        for d in dist:
            res[d] += 1
    for c in res[1:-1]:
        print((c // 2))

if __name__ == "__main__":
    main()

# Optimized solution
import sys
from itertools import combinations

n, x, y = list(map(int, sys.stdin.readline().split()))
    
def main():
    res = [0] * (n + 1)
    for i, j in combinations(list(range(1, n+1)), 2):
        d = min(j - i, abs(i - x) + 1 + abs(j - y))
        res[d] += 1
        
    for i in range(1, n):
        print((res[i]))

if __name__ == "__main__":
    main()
# Original solution
N,X,Y = list(map(int, input().split()))
X = X-1
Y = Y-1
kyori  = []
for i in range(N):
    for j in range(i,N):
        l = min(abs(i-j), abs(i-X)+1+abs(j-Y), abs(i-Y)+1+abs(j-X))
        kyori.append(l)
for k in range(1,N):
    print((kyori.count(k)))

# Optimized solution
N,X,Y = list(map(int, input().split()))
X = X-1
Y = Y-1
kyori  = [0]*N
for i in range(N):
    for j in range(i+1,N):
        l = min(abs(i-j), abs(i-X)+1+abs(j-Y), abs(i-Y)+1+abs(j-X))
        kyori[l] += 1
for k in range(1,N):
    print((kyori[k]))
# Original solution
from collections import deque
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)
for i in range(n):
    queue = deque()
    visited = [0]*n
    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 in range(len(visited)):
        if k > i:
            if visited[k] >= 1:
                distance[visited[k]-1] += 1
for l in distance:
    print(l)

# Optimized solution
from collections import deque
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 in range(len(visited)):
        if k > i:
            if visited[k] >= 1:
                distance[visited[k]-1] += 1
    # print(f"{i}番ノードからの各ノードへの最短距離は{visited}である")
for l in distance:
    print(l)