CodeEff/ECCO huggingface dataset:
# Original solution
from collections import defaultdict

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

d = defaultdict(int)

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

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

# Optimized solution
from collections import defaultdict

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

d = defaultdict(int)

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)] += 1

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

# Optimized solution
N, X, Y = list(map(int, input().split()))
a = [0]*N
for i in range(1,N+1):
    for j in range(i+1,N+1):
        a[min(j-i, abs(i-X)+1+abs(j-Y))-1]+= 1
for i in range(N-1):
    print((a[i]))
# Original solution
n,x,y=map(int,input().split())
G=[[i,i+2] for i in range(n)]
G[0],G[-1]=[2],[n-1]
G[x-1].append(y)
G[y-1].append(x)
#print(G)
ans=[0]*(n-1)
#X,Yのショートカットに気を付けて上から見ていく
for i in range(n-1):
    for j in range(i+1,n):
    #i+1<=XかつY<=j+1の時ショートカットするのが最短
        temp1=j-i
        temp2=abs(x-(i+1))+1+abs(y-(j+1))
        dis=min(temp1,temp2)
        ans[dis-1]+=1
print(*ans,sep='\n')


# Optimized solution
n,x,y=map(int,input().split())
G=[[i,i+2] for i in range(n)]
G[0],G[-1]=[2],[n-1]
G[x-1].append(y)
G[y-1].append(x)
#print(G)
ans=[0]*(n-1)
for i in range(n-1):
    for j in range(i+1,n):
        temp1=j-i
        temp2=abs(x-(i+1))+1+abs(y-(j+1))
        dis=min(temp1,temp2)
        ans[dis-1]+=1
print(*ans,sep='\n')
# Original solution
n, x, y = map(int,input().split())

dis = [0] * (n - 1)
for i in range(n - 1):
    for j in range(i + 1, n):
        d = min(abs(x - i - 1) + abs(y - j - 1) + 1, j - i)
        dis[d - 1] += 1
print(*dis, sep = '\n')


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

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

print(*cnt, sep='\n')
# Original solution
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(j-Y), abs(Y-i)+1+abs(j-X)))
for k in range(1, N):
  print((List.count(k)))

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

for i in range(n):
    for j in range(n):
        if list1[n * j + i]  != 0:
            continue
        
        list1[n * i + j] = min([abs(j - i), abs(x - i) + 1 + abs(j - y), abs(y - i) + 1 + abs(x - j)])
        
#list2 = list(itertools.chain.from_iterable(list1))

for k in range(1,n):
    print((list1.count(k)))

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

cnt_list = [0] * (n - 1)

for i in range(n):
    for j in range(n):
        if j <= i:
            continue
        
        #i < j,x < yのとき、i→y→x→jが最短になることはない
        num = min([j - i, abs(x - i) + 1 + abs(y - j)]) - 1 #距離 - 1、距離ゼロはif文で排除
        cnt_list[num] += 1

for n in cnt_list:
    print(n)
# Original solution
import itertools

N,X,Y = list(map(int,input().split()))
n = list(range(1,N+1))
l = []
for v in itertools.combinations(n,2):
  l.append(min(abs(Y-v[1]) + abs(X-v[0]) + 1,abs(X-v[1]) + abs(Y-v[0]) + 1,v[1] - v[0]))
for k in range(1,N):
  print((l.count(k)))

# Optimized solution
import itertools

N,X,Y = list(map(int,input().split()))
n = list(range(1,N+1))
l = [0]*N
for v in itertools.combinations(n,2):
  l[min(abs(Y-v[1]) + abs(X-v[0]) + 1,v[1] - v[0])] += 1
for k in range(1,N):
  print((l[k]))
# Original solution
from collections import Counter
import queue


def bfs(d, s, N):
    dist = [-1]*N
    q = queue.Queue()
    q.put(s)
    dist[i] = 0
    while not q.empty():
        From = q.get()
        for To in d[From]:
            if dist[To-1] == -1:
                q.put(To)
                dist[To-1] = dist[From-1]+1
    return dist


N, X, Y = list(map(int, input().split()))
d = [[] for _ in range(N+1)]
d[X].append(Y)
d[Y].append(X)
for i in range(1, N):
    d[i].append(i+1)
    d[i+1].append(i)

ans = [0]*(N+1)

for i in range(N):
    s = i+1
    c = Counter(bfs(d, i+1, N))
    for i, m in list(c.items()):
        ans[i] += m

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



# Optimized solution
from collections import Counter, deque


def bfs(d, s, N):
    dist = [-1]*N
    q = deque()
    q.append(s)
    dist[i] = 0
    while len(q) != 0:
        From = q.popleft()
        for To in d[From]:
            if dist[To-1] == -1:
                q.append(To)
                dist[To-1] = dist[From-1]+1
    return dist


N, X, Y = list(map(int, input().split()))
d = [[] for _ in range(N+1)]
d[X].append(Y)
d[Y].append(X)
for i in range(1, N):
    d[i].append(i+1)
    d[i+1].append(i)

ans = [0]*(N+1)

for i in range(N):
    s = i+1
    c = Counter(bfs(d, i+1, N))
    for i, m in list(c.items()):
        ans[i] += m

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

distances = []
for ind1 in range(1,n+1):
    for ind2 in range(ind1+1,n+1):
        cur_dist = min(ind2-ind1, abs(x-ind1)+abs(y-ind2)+1)
        # print(ind1,ind2,cur_dist)
        distances.append(cur_dist)
    
# print(distances)
for k in range(1,n):
    print((len([x for x in distances if x == k])))

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

cnt = [0] *n
for ind1 in range(1,n+1):
    for ind2 in range(ind1+1,n+1):
        cur_dist = min(ind2-ind1, abs(x-ind1)+abs(y-ind2)+1)
        # print(ind1,ind2,cur_dist)
        cnt[cur_dist] += 1
# print(cnt)            
for k in range(1,n):
    print((cnt[k]))
# Original solution
import itertools

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

a = [i for i in range(1, n+1)]
b = list(itertools.combinations(a, 2))
c = [0]*(n-1)

for j in range(len(b)):
    d = min(abs(b[j][0]-b[j][1]), abs(x-b[j][0])+1+abs(b[j][1]-y), abs(y-b[j][0])+1+abs(b[j][1]-x))
    c[d-1] += 1

for k in range(n-1):
    print((c[k]))

# Optimized solution
import itertools

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

a = [i for i in range(1, n+1)]
b = [0]*(n-1)

for j in range(n):
    for k in range(j+1, n):
        c = min(abs(k-j),abs(j-(x-1)) +abs(k-(y-1))+1)
        b[c-1] += 1
    

for l in range(n-1):
    print((b[l]))
# Original solution
#!/usr/bin/env python3
import sys


def solve(N: int, X: int, Y: int):
    distances = [0] * (N - 1)
    for i in range(0, N - 1):
        for j in range(i + 1, N):
            if j < X - 1 or Y - 1 < i:
                distance = j - i
            else:
                distance = min(j - i, abs(X - 1 - i) + abs(Y - 1 - j) + 1)
            distances[distance - 1] += 1

    for k in distances:
        print(k)

            
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    X = int(next(tokens))  # type: int
    Y = int(next(tokens))  # type: int
    solve(N, X, Y)

if __name__ == '__main__':
    main()


# Optimized solution
#!/usr/bin/env python3
import sys


def solve(N: int, X: int, Y: int):
    distances = [0] * (N - 1)
    for i in range(0, N - 1):
        for j in range(i + 1, N):
            distance = min(j - i, abs(X - 1 - i) + abs(Y - 1 - j) + 1)
            distances[distance - 1] += 1

    for k in distances:
        print(k)
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    X = int(next(tokens))  # type: int
    Y = int(next(tokens))  # type: int
    solve(N, X, Y)

if __name__ == '__main__':
    main()
# Original solution
import sys

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

d = [[sys.maxsize for _ in range(N)] for _ in range(N)]

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

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

for h in range(N):
  for i in range(h+1, N):
    if h != i:
      answer[d[h][i]-1] += 1

for k in range(N-1):
  print((answer[k]))

# Optimized solution
import sys

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

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

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

for k in range(N-1):
  print((answer[k]))
# Original solution
from collections import defaultdict
n,x,y=list(map(int,input().split()))
d=defaultdict(list)
for i in range(1,n):
    for j in range(i+1,n+1):
        r=min(abs(i-j),abs(x-i)+1+abs(y-j),abs(x-j)+1+abs(y-i))
        d[r].append((i,j))
for i in range(1,n):
    print((len(d[i])))


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

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

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

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

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

for i in range(1,N):
    print((distances[i]))
# Original solution
from collections import defaultdict
import math
N, X, Y = list(map(int, input().split()))
res = defaultdict(int)
x = []
for i in range(1, N + 1):
    for j in range(1, N + 1):
        if i >= j:
            continue
        if i == X and Y == j:
            key = 1
        else:
            key = int(min(j - i, math.fabs(X - i) + math.fabs(Y - j) + 1))
        res[key] += 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(1, N + 1):
    for j in range(1, N + 1):
        if i >= j:
            continue
        if i == X and Y == j:
            key = 1
        else:
            key = int(min(j - i, abs(X - i) + abs(Y - j) + 1))
        res[key] += 1

for i in range(1, N):
    print((res[i]))
# Original solution
N, X, Y = list(map(int, input().split()))
res = [0] * N
for j in range(1, N + 1):
    for i in range(1, j):
        if i == X and Y == j:
            key = 1
        else:
            key = int(min(j - i, abs(X - i) + abs(Y - j) + 1))
        res[key] += 1

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

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

for i in range(1, N):
    print((res[i]))
# Original solution
from collections import defaultdict
import math
N, X, Y = list(map(int, input().split()))
res = defaultdict(int)
x = []
for i in range(1, N + 1):
    for j in range(1, N + 1):
        if i >= j:
            continue
        if i == X and Y == j:
            key = 1
        else:
            key = int(min(j - i, math.fabs(X - i) + math.fabs(Y - j) + 1))
        res[key] += 1


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


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

for i in range(1, N):
    print((res[i]))
# Original solution
n,x,y=map(int,input().split())
x-=1;y-=1
l=[[10**4 for g in range(n)] for i in range(n)]
fl=[0 for i in range(n-1)]
for i in range(n):
    for j in range(i+1,n):
        fl[min(abs(j-i),abs(j-x)+1+abs(y-i),abs(i-x)+1+abs(y-j))]+=1
print(*fl[1:],sep="\n")
print(fl[0])


# Optimized solution
n,x,y=map(int,input().split())
x-=1;y-=1
fl=[0 for i in range(n-1)]
for i in range(n):
    for j in range(i+1,n):
        fl[min(abs(j-i),abs(j-x)+1+abs(y-i),abs(i-x)+1+abs(y-j))]+=1
print(*fl[1:],sep="\n")
print(0)
# Original solution
n,x,y = list(map(int,input().split()))
INF = 10**5
d = [[INF]*n for _ in range(n)]
def wf(d):
  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])

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

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

for a in ans:
  print(a)

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

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

G = [[] for _ in range(N)]
# print(G)
# ぐらふの作成
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)

# print(G)

from collections import deque
def bfs(G,v):
    que = deque([v])
    dist[v] = 0
    while que:
        v = que.popleft()
        d = dist[v]
        for w in G[v]:
            if dist[w] > -1:
                continue
            dist[w] = d + 1
            que.append(w)

D = [0]*(N-1)
for i in range(N):
    dist = [-1]*N
    bfs(G,i)
    # print(dist)
    for d in dist:
        if d>0:
            D[d-1] += 1
# print(D)
for d in D:
    print((d//2))




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

# print(X,Y)
for i in range(1,N+1):
    for j in range(i+1,N+1): # i<j
        # print((i,j))
        # ver 1
        if j<=X or Y<=i:
            d = j-i
            
        # ver 2
        elif i<=X and Y<=j:
            d = X-i + 1 + j-Y
            
        # ver 3
        else:
            d = min(j-i,abs(X-i)+abs(Y-j)+1)
        # print(d)
        D[d-1] += 1
# print(D)

for d in D:
    print(d)
# Original solution
N,X,Y = list(map(int,input().split()))
D= [0]*(N-1)

# print(X,Y)
for i in range(1,N+1):
    for j in range(i+1,N+1): # i<j
        # print((i,j))
        # ver 1
        if j<=X or Y<=i:
            d = j-i
            
        # ver 2
        elif i<=X and Y<=j:
            d = X-i + 1 + j-Y
            
        # ver 3
        else:
            d = min(j-i,abs(X-i)+abs(Y-j)+1)
        # print(d)
        D[d-1] += 1
# print(D)

for d in D:
    print(d)

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

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

R=[0]*n

def bfs(j):
	V=[-1]*n
	que=deque([])
	que.append(j)
	V[j]=0
	while que:
		p=que.popleft()
		for i in range(n):
			if V[i]==-1 and L[p][i]==1:
				que.append(i)
				V[i]=V[p]+1
	for i in range(n):
		R[V[i]]+=1
	
for j in range(n):
	bfs(j)
for i in range(1,n):
	print((R[i]//2))

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

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

R=[0]*n

def bfs(j):
	V=[-1]*n
	que=deque([])
	que.append(j)
	V[j]=0
	while que:
		p=que.popleft()
		for np in L[p]:
			if V[np]==-1:
				que.append(np)
				V[np]=V[p]+1
	for i in range(n):
		R[V[i]]+=1
	
for j in range(n):
	bfs(j)
for i in range(1,n):
	print((R[i]//2))
# Original solution
from collections import deque


def BFS(s):
    color=["white" for _ in range(n+1)]
    D=[0 for _ in range(n+1)]

    D[s]=0
    color[s]="gray"
    queue=deque([s])

    while len(queue)>0:
        u=queue.popleft()
        for i in M[u]:
            if color[i]=="white":
                D[i]=D[u]+1
                color[i]="gray"
                queue.append(i)
        color[u]="black"

    return D


n,x,y=list(map(int,input().split()))
M=[[] for _ in range(n+1)]
for i in range(1,n):
    M[i].append(i+1)
    M[i+1].append(i)
M[x].append(y)
M[y].append(x)

A=[0]*(n)
for i in range(1,n+1):
    for j in BFS(i)[i:]:
        A[j] +=1

for i in A[1:]:
    print(i)

# Optimized solution
from collections import deque
inf=10**9


def BFS(num):
    color=["white" for _ in range(n+1)]
    D=[inf for _ in range(n+1)]
    queue=deque([num])

    color[num]="gray"
    D[num]=0

    while len(queue)>0:
        u=queue.popleft()
        for i in M[u]:
            if color[i]=="white" and D[u]+1<D[i]:
                D[i]=D[u]+1
                color[i]="gray"
                queue.append(i)
        color[u]="black"

    return D


n,x,y=list(map(int,input().split()))
M=[[] for _ in range(n+1)]
for i in range(1,n):
    M[i].append(i+1)
    M[i+1].append(i)
M[x].append(y)
M[y].append(x)

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

for i in ans:
    print(i)
# Original solution
from collections import deque

def main():
    n, x, y = list(map(int, input().split()))
    cnt = [0]*n
    q = deque()
    
    for i in range(n):
        q.appendleft([i, 0])
        dist = [None]*n
        dist[i] = 0
        while q:
            j, d = q.pop()
            cnt[d] += 1
            if j > 0 and dist[j-1] is None:
                dist[j-1] = d+1
                q.appendleft([j-1, d+1])
            if j < n-1 and dist[j+1] is None:
                dist[j+1] = d+1
                q.appendleft([j+1, d+1])
            if j == x-1 and dist[y-1] is None:
                dist[y-1] = d+1
                q.appendleft([y-1, d+1])
            elif j == y-1 and dist[x-1] is None:
                dist[x-1] = d+1
                q.appendleft([x-1, d+1])
    for i in range(1, n):
        print((cnt[i]//2))
                

if __name__ == "__main__":
    main()

# Optimized solution
from collections import deque

def main():
    n, x, y = list(map(int, input().split()))
    cnt = [0]*n
    q = deque()
    
    for i in range(n):
        q.appendleft(i)
        dist = [None]*n
        dist[i] = 0
        while q:
            j = q.pop()
            d = dist[j]
            cnt[d] += 1
            if j > 0 and dist[j-1] is None:
                dist[j-1] = d+1
                q.appendleft(j-1)
            if j < n-1 and dist[j+1] is None:
                dist[j+1] = d+1
                q.appendleft(j+1)
            if j == x-1 and dist[y-1] is None:
                dist[y-1] = d+1
                q.appendleft(y-1)
            elif j == y-1 and dist[x-1] is None:
                dist[x-1] = d+1
                q.appendleft(x-1)
    for i in range(1, n):
        print((cnt[i]//2))
                

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

def push(n, dist, dist_list):
	if dist_list[n] > dist:
		dist_list[n] = dist
		q.put(n)



q = queue.Queue()
n, x, y = [int(i) for i in input().split()]
result = [0] * (n-1)

for p in range(n):
	dist_list = [111111] * n
	dist = 0
	q.put(p)
	dist_list[p] = dist 
	while not q.empty():
		p = q.get()
		dist = dist_list[p]
		if p+1 < n: push(p+1, dist+1, dist_list)
		if p-1 >= 0: push(p-1, dist+1, dist_list)
		if p == (x-1): push(y-1, dist+1, dist_list)
		if p == (y-1): push(x-1, dist+1, dist_list)
	
	for i in dist_list:
		if i != 0:
			result[i-1] += 1

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






# Optimized solution
n, x, y = [int(i) for i in input().split()]
# 0 index is 1 distance
result = [0] * (n-1)

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

for ans in result:
	print(ans)


# TLE

# import queue
	
# q = queue.Queue()
# n, x, y = [int(i) for i in input().split()]
# result = [0] * (n-1)

# for p in range(n):
# 	dist_list = [111111] * n
# 	dist = 0
# 	q.put(p)
# 	dist_list[p] = dist 
# 	while not q.empty():
# 		p = q.get()
# 		dist = dist_list[p]
# 		if p+1 < n: 
# 			if dist_list[p+1] > dist:
# 				dist_list[p+1] = dist
# 				q.put(p+1)
# 		if p-1 < n: 
# 			if dist_list[p-1] > dist:
# 				dist_list[p-1] = dist
# 				q.put(p-1)
# 		if p == (x-1): 
# 			if dist_list[y-1] > dist:
# 				dist_list[y-1] = dist
# 				q.put(y-1)
# 		if p == (y-1): 
# 			if dist_list[x-1] > dist:
# 				dist_list[x-1] = dist
# 				q.put(x-1)

# 	for i in dist_list:
# 		if i != 0:
# 			result[i-1] += 1

# for ans in result:
# 	print(ans//2)
# Original solution
def s0():return eval(input())
def s1():return input().split()
def s2(n):return [eval(input()) for x in range(n)]
def n0():return int(eval(input()))
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(eval(input())) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]

n,x,y=n1()

a=[]
for i in range(1,n+1):
    for j in range(i+1,n+1):
        if i<=x and j<=x:
            a.append([(i,j),j-i])
        elif i<=x and x<j<y:
            a.append([(i,j),min(j-i,y-j+1+x-i)])
        elif i<=x:
            a.append([(i,j),j-y+1+x-i])
        elif i<=y and j<=y:
            a.append([(i,j),min(j-i,y-j+1+i-x)])
        elif i<=y:
            a.append([(i,j),min(j-i,j-y+1+i-x)])
        else:
            a.append([(i,j),j-i])
for k in range(1,n):
    ans=0
    for h in range(len(a)):
        if a[h][1]==k:
            ans+=1
    print(ans)

# Optimized solution
def s0():return eval(input())
def s1():return input().split()
def s2(n):return [eval(input()) for x in range(n)]
def n0():return int(eval(input()))
def n1():return [int(x) for x in input().split()]
def n2(n):return [int(eval(input())) for _ in range(n)]
def n3(n):return [[int(x) for x in input().split()] for _ in range(n)]

n,x,y=n1()

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