CodeEff/ECCO huggingface dataset:
# Original solution
n,x,y=list(map(int,input().split()))
ans=[0 for _ in range(n+1)]
d=[]
for i in range(n+1):
    d.append([abs(i-j) for j in range(n+1)])
#    print(d[i])
d[x][y]=1
d[y][x]=1

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

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

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

for i in range(1,n):
    print((ans[i]))
# Original solution
n,x,y=list(map(int,input().split()))
dist=[[0 for i in range(n)] for j in range(n)]
m=n
connection=[[] for i in range(n)]
for i in range(n-1):
  connection[i].append(i+1)
for i in range(1,n):
  connection[i].append(i-1)
connection[x-1].append(y-1)
connection[y-1].append(x-1)

def bfs(v):
  distance=[-1]*n
  distance[v]=0
  next=connection[v]
  next2=set()
  visited=[-1]*n
  visited[v]=1
  visitct=1
  ct=0
  while len(next)!=0 and visitct!=n:
    ct+=1
    for i in range(len(next)):
      if visited[next[i]]==-1:
        distance[next[i]]=ct
        visited[next[i]]=1
        visitct+=1
        for j in range(len(connection[next[i]])):
          if visited[connection[next[i]][j]]==-1:
            next2.add(connection[next[i]][j])
    next=list(next2)
    next2=set()
  return distance

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

for i in range(n):
  b=bfs(i)
  for j in range(n):
    ct[b[j]]+=1

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

# Optimized solution
n,x,y=list(map(int,input().split()))
ct=[0 for i in range(n)]
for i in range(n):
  for j in range(i+1,n):
    ct[min(j-i,abs(j-y+1)+abs(i-x+1)+1)]+=1
for i in range(1,n):
  print((ct[i]))
# Original solution
from collections import defaultdict

N, X, Y = list(map(int, input().split()))
dists = defaultdict(lambda: N)
for k in range(1, N):
    for i in range(1 + k, N + 1):
        dists[(i - k, i)] = min(dists[(i - k, i)], k)
    for i in range(k):
        for a, b in (
            (X - i, Y + k - 1 - i),
            (X - i, Y - (k - 1 - i)),
            (X + i, Y + k - 1 - i),
            (X + i, Y - (k - 1 - i)),
        ):
            if 1 <= a <= N and 1 <= b <= N and a < b:
                dists[(a, b)] = min(dists[(a, b)], k)

d = defaultdict(int)
for v in list(dists.values()):
    d[v] += 1
for k in range(1, N):
    print((d.get(k, 0)))

# Optimized solution
N, X, Y = list(map(int, input().split()))
dists = [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)
        dists[d] += 1

for k in range(1, N):
    print((dists[k]))
# Original solution
from collections import *
nxy=input().rstrip().split(" ")
n=int(nxy[0])
x=int(nxy[1])
y=int(nxy[2])
dis=[]
for i in range(1,n):
    #print(i)
    j=i+1
    while j>i and j<=n:
        l1=abs(x-i)+1+abs(y-j)
        l2=j-i
        if l1>=l2:
            L=l2
        else:
            L=l1
        #print(L)
        dis.append(L)
        j=j+1
#print(dis)
for k in range(1,n):
    print((dis.count(k)))

# Optimized solution
import collections 
nxy=input().rstrip().split(" ")
n=int(nxy[0])
x=int(nxy[1])
y=int(nxy[2])
dis=[]
for i in range(1,n):
    #print(i)
    j=i+1
    while j>i and j<=n:
        l1=abs(x-i)+1+abs(y-j)
        l2=j-i
        if l1>=l2:
            L=l2
        else:
            L=l1
        #print(L)
        dis.append(L)
        j=j+1
#print(dis)
c=collections.Counter(dis)
#print(c)
for k in range(1,n):
    print((c[k]))
# Original solution
import queue

n,x,y = list(map(int,input().split()))
l = [0] * n
for z in range(n):
    q = queue.Queue()
    q.put(z)
    d = [-1] * n
    d[z] = 0
    while(not q.empty()):
        i = q.get()
        if(d[i] > 0 and i > z):l[d[i]] += 1
        j = i + 1
        if(j < n):
            if(d[j] == -1):
                d[j] = d[i] + 1
                q.put(j)
        j = i - 1
        if(j >= 0):
            if(d[j] == -1):
                d[j] = d[i] + 1
                q.put(j)
        if(i == x - 1):
            j = y - 1
            if(d[j] == -1):
                d[j] = d[i] + 1
                q.put(j)
for i in range(1,n):print((l[i]))

# Optimized solution
import queue

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

Q = deque()
N, X, Y = list(map(int, input().split()))
K = [0 for i in range(N)]

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

for i in range(1, N):
    Done = [-1 for j in range(N+1)]
    Q.append(i)
    Done[0] = 0
    Done[i] = 0
    while len(Q) > 0:
        x = Q.popleft()
        for y in edge[x]:
            if Done[y] >= 0:
                continue
            else:
                Done[y] = Done[x] + 1
                Q.append(y)
                if y > i:
                    K[Done[y]] += 1

for z in K[1:]:
    print(z)


# Optimized solution
N, X, Y = list(map(int, input().split()))
X -= 1
Y -= 1
K = [0 for i in range(N)]

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

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

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

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


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

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

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

g = [[]  for i in range(N)]
for i in range(N):
    u = i
    v = i + 1
    if v < N:
        g[u].append(v)
        g[v].append(u)

g[X - 1].append(Y - 1)
g[Y - 1].append(X - 1)

from collections import deque
dis = [[float('Inf')] * N for _ in range(N)]
count = [0] * (N - 1)
def bfs(i):
    d = [False] * N
    que = deque()
    #for j in g[i]:
    que.append(i)
    d[i] = True
    dis[i][i] = 0
    pre = i
    while que:
        p = que.popleft()

        for k in g[p]:
            if d[k]:
                continue
            else:
                d[k] = True
                que.append(k)
                dis[i][k] = dis[i][p] + 1
                dis[k][i] = dis[i][p] + 1
                count[dis[i][k] - 1] += 1 
                #count[dis[k][i] - 1] += 1
        pre = p

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

for i in range(N - 1):
    print((count[i] // 2))


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

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

from collections import deque
dis = [[0] * N for _ in range(N)]
def bfs(i):
    visited = [False] * N
    que = deque([i])
    dis[i][i] = 0
    visited[i] = True
    
    while que:
        p = que.popleft()
        for new in g[p]:
            if visited[new]:
                continue
            else:
                visited[new] = True
                que.append(new)
                dis[i][new] = dis[i][p] + 1
                count[dis[i][new] - 1] += 1

count = [0] * (N - 1)
for i in range(N):
    bfs(i)

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

g = [[]  for i in range(N)]
for i in range(N):
    u = i
    v = i + 1
    if v < N:
        g[u].append(v)
        g[v].append(u)

g[X - 1].append(Y - 1)
g[Y - 1].append(X - 1)

from collections import deque
dis = [[float('Inf')] * N for _ in range(N)]
count = [0] * (N - 1)
def bfs(i):
    d = [False] * N
    que = deque()
    #for j in g[i]:
    que.append(i)
    d[i] = True
    dis[i][i] = 0
    pre = i
    while que:
        p = que.popleft()

        for k in g[p]:
            if d[k]:
                continue
            else:
                d[k] = True
                que.append(k)
                dis[i][k] = dis[i][p] + 1
                dis[k][i] = dis[i][p] + 1
                count[dis[i][k] - 1] += 1 
                #count[dis[k][i] - 1] += 1
        pre = p

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

for i in range(N - 1):
    print((count[i] // 2))


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

g = [[]  for i in range(N)]
for i in range(N):
    u = i
    v = i + 1
    if v < N:
        g[u].append(v)
        g[v].append(u)

g[X - 1].append(Y - 1)
g[Y - 1].append(X - 1)

from collections import deque
dis = [[float('Inf')] * N for _ in range(N)]
count = [0] * (N - 1)
def bfs(i):
    d = [False] * N
    que = deque()
    #for j in g[i]:
    que.append(i)
    d[i] = True
    dis[i][i] = 0
    #pre = i
    while que:
        p = que.popleft()

        for k in g[p]:
            if d[k]:
                continue
            else:
                d[k] = True
                que.append(k)
                dis[i][k] = dis[i][p] + 1
                #dis[k][i] = dis[i][p] + 1
                count[dis[i][k] - 1] += 1 
                #count[dis[k][i] - 1] += 1
        #pre = p

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

for i in range(N - 1):
    print((count[i] // 2))
# Original solution
# -*- coding: utf-8 -*-
if True:
    n,x,y = list(map(int, input().split()))


else:
    # n=5
    # x=2
    # y=4
    # n=3
    # x=1
    # y=3
    n=7
    x=3
    y=7

# print(n)
# print(x)
# print(y)
#
ret = [0] * (n-1)
for i in range(1, n):
    for j in range(i+1, n+1):
        # print(str(i) + "," + str(j))
        p =[]
        p.append(j - i)
        p.append(abs(i - x) + 1 + abs(j - y))
        p.append(abs(i - y) + 1 + abs(j - x))

        # print(p)
        # print(min(p))
        ret[min(p)-1] += 1

# print(ret)
# print("=======")
for data in ret:
    print(data)

# 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):
        p1 = j-i
        p2 = abs(i - x) + 1 + abs(j - y)
        p3 = abs(i - y) + 1 + abs(j - x)
        if p1 > p2:
            p1 = p2
        if p1 > p3:
            p1 = p3
        ret[p1-1] += 1

for data in ret:
    print(data)
# Original solution
n, x, y = list(map(int, input().split()))
king_li = []
for i in range(1, n+1):
    for j in range(i+1,n+1):
        li = []
        li.append(abs(y-j)+abs(x-i)+1)
        li.append(j-i)
        king_li.append(min(li))
for z in range(1,n):
    print((king_li.count(z)))

# Optimized solution
n, x, y = list(map(int, input().split()))
dic={}
for i in range(1, n+1):
    for j in range(i+1,n+1):
        m = min(abs(y-j)+abs(x-i)+1,j-i)
        if m in list(dic.keys()):
            dic[m] += 1
        else:
            dic[m] =1

for z in range(1,n):
    if z in list(dic.keys()):
        print((dic[z]))
    else:
        print((0))
# Original solution
N, X, Y = list(map(int, input().split()))
minus = []
plus = []
for A in range(1,N):
    for B in range(A+1,N+1):
        if B - A > abs(X -A) + abs(Y - B) + 1:
            minus.append(B-A)
            plus.append(abs(X -A) + abs(Y - B) + 1)
for k in range(1,N):
    print((N - k - minus.count(k) + plus.count(k)))

# Optimized solution
N, X, Y = list(map(int, input().split()))
ks = [0]*(N-1)
for A in range(1,N):
    for B in range(A+1,N+1):
        if B - A > abs(X -A) + abs(Y - B) + 1:
            ks[B-A-1] -= 1
            ks[abs(X -A) + abs(Y - B)] += 1
for k in range(1,N):
    print((N - k + ks[k-1]))
# Original solution
def solve(string):
    n, x, y = list(map(int, string.split()))
    ans = [0] * (n - 1)
    for s in range(1, n + 1):
        d = [abs(i - s) for i in range(1, n + 1)]
        if d[x - 1] < d[y - 1]:
            p = y - 1
            d[p] = min(d[p], d[x - 1] + 1)
        else:
            p = x - 1
            d[p] = min(d[p], d[y - 1] + 1)
        for i in range(p + 1, n):
            d[i] = min(d[i], d[i - 1] + 1)
        for i in range(p - 1, -1, -1):
            d[i] = min(d[i], d[i + 1] + 1)
        for _d in d[s:]:
            ans[_d - 1] += 1
    return "\n".join(map(str, ans))


if __name__ == '__main__':
    import sys
    print((solve(sys.stdin.read().strip())))


# Optimized solution
def solve(string):
    n, x, y = list(map(int, string.split()))
    ans = [0] * n
    for i in range(1, n):
        for j in range(i + 1, n + 1):
            ans[min(j - i, abs(x - i) + 1 + abs(j - y), abs(y - i) + 1 + abs(j - x))] += 1
    return "\n".join(map(str, ans[1:]))


if __name__ == '__main__':
    import sys
    print((solve(sys.stdin.read().strip())))
# Original solution
if __name__ == '__main__':
	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):
			l1 = abs(j-i)
			l2 = abs(X-i) + 1 + abs(j-Y)
			l3 = abs(Y-i) + 1 + abs(j-X)
			lm = min(l1,l2,l3)
			ans[lm - 1] += 1

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

# Optimized solution
if __name__ == '__main__':
	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):
			l1 = abs(j-i)
			l2 = abs(X-i) + 1 + abs(j-Y)
			lm = min(l1,l2)
			ans[lm - 1] += 1

	for k in range(N-1):
		print((ans[k]))
# Original solution
N, X, Y = list(map(int, input().split()))
graph = [[] for _ in range(N)]
for i in range(1, N):
    graph[i-1].append(i)
    graph[i].append(i-1)
graph[X-1].append(Y-1)
graph[Y-1].append(X-1)
from collections import deque, defaultdict
dic = defaultdict(int)

def bfs(s):
    checked = [0]*N
    queue = deque([(s, 0)])
    while queue:
        v, c = queue.pop()
        if checked[v]:
            continue
        checked[v] = 1
        dic[c] += 1
        for i in graph[v]:
            if not checked[i]:
                queue.appendleft((i, c+1))

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

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

# Optimized solution
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)

N, X, Y = mapint()
X, Y = X-1, Y-1
dist = [0]*(N-1)
for i in range(N-1):
    for j in range(i+1, N):
        d = min(j-i, abs(i-X)+abs(j-Y)+1, abs(i-Y)+abs(j-X)+1)
        dist[d-1] += 1
for k in range(N-1):
    print((dist[k]))
# Original solution
# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *
from string import *				# alpha = ascii_lowercase
from random import *				# l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import *				# bisect_left(arr,x,start,end)  => start and end parameters are temporary
from sys import stdin				# bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize
from operator import *				# d = sorted(d.items(), key=itemgetter(1))
from itertools import *
from collections import Counter		# d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''
5 2 4
'''

def solve(n,x,y):
	adj = [[] for i in range(n+1)]
	adj[x].append(y)
	adj[y].append(x)
	for i in range(1,n):
		adj[i].append(i+1)
		adj[i+1].append(i)
	# print(adj)
	ans = []
	d = {}
	for i in range(1,n):
		d[i] = 0
	for k in range(1,n+1):
		q = [k]
		dis = [maxsize]*(n+1)
		dis[k] = 0
		while(q):
			src = q.pop()
			for nn in adj[src]:
				if(dis[nn] > dis[src]+1):
					dis[nn] = dis[src] + 1
					q.append(nn)
		curr = 0
		# print('k:',k,dis)
		for ii in range(k+1,n+1):
			d[dis[ii]] += 1
	return d

N,X,Y = list(map(int, stdin.readline().rstrip().split()))
ans = solve(N,X,Y)
for i in range(1,N):
	print((ans[i]))



# Optimized solution
# ANSHUL GAUTAM
# IIIT-D

from math import *
from copy import *
from string import *				# alpha = ascii_lowercase
from random import *				# l.sort(key=lambda l1:l1[0]-l1[1]) => ex: sort on the basis difference
from bisect import *				# bisect_left(arr,x,start,end)  => start and end parameters are temporary
from sys import stdin				# bisect_left return leftmost position where x should be inserted to keep sorted
from sys import maxsize
from operator import *				# d = sorted(d.items(), key=itemgetter(1))
from itertools import *
from collections import Counter		# d = dict(Counter(l))
from collections import defaultdict # d = defaultdict(list)

'''
5 2 4
'''

def solve(n,x,y):
	adj = [[] for i in range(n+1)]
	adj[x].append(y)
	adj[y].append(x)
	for i in range(1,n):
		adj[i].append(i+1)
		adj[i+1].append(i)
	# print(adj)
	ans = []
	d = {}
	for i in range(1,n):
		d[i] = 0
	for k in range(1,n+1):
		q = [k]
		dis = [maxsize]*(n+1)
		dis[k] = 0
		while(q):
			src = q.pop()
			for nn in adj[src]:
				# if(nn > k or nn == X or nn == Y):
				if(dis[nn] > dis[src]+1):
					# if(src == 4):
						# print('src:',src,'nn:',nn)
					dis[nn] = dis[src] + 1
					q.append(nn)
				# else:
				# 	dis[nn] = 
			# if(k == 3):
			# 	print('src:',src)
			# 	print('dis:',dis)
		curr = 0
		# if(k == 3):
		# print('k:',k,dis)
		for ii in range(k+1,n+1):
			d[dis[ii]] += 1
	return d

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

from collections import defaultdict
ans = defaultdict(int)
for i in range(N):
    for j in range(i + 1, N):
        idx = min(j - i, abs(j + 1 - Y) + 1 + abs(X - i - 1))
        ans[idx] += 1
        
for i in range(1, N):
    print((ans[i]))


# Optimized solution

from collections import defaultdict

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

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

for i in range(1, N):
    print((ctr[i]))
# Original solution

from collections import defaultdict

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

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

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



# Optimized solution

from collections import defaultdict

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

ctr = defaultdict(int)
for u in range(1, N):
    for v in range(u + 1, N + 1):
        d = min(v - u, abs(u - X) + 1 + abs(Y - v))
        ctr[d] += 1

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

cnt = [0] * (N)
for i in range(1, N+1):
  for j in range(i+1, N+1):
    temp = min(abs(x-i) + 1 + abs(j-y), abs(y-i) + 1 + abs(j-x))
    cnt[min(abs(j-i), temp)] += 1

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

# Optimized solution
N, x, y = [int(i) for i in input().split()]

cnt = [0] * N
for i in range(1, N+1):
  for j in range(i+1, N+1):
    temp = min(abs(j-i), abs(x-i) + 1 + abs(j-y), abs(y-i) + 1 + abs(j-x))
    cnt[temp] += 1

for i in range(1, N):
  print((cnt[i]))
# Original solution
# encoding:utf-8
import copy
import random
import bisect #bisect_left　これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections

mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))


N, X, Y = LI()
X -= 1
Y -= 1
path = [[mod for i in range(N)] for i in range(N)]
for i in range(N):
    for j in range(i, N):
        path[i][j] = j - i
        path[j][i] = j- i
    
path[X][Y] = 1
path[Y][X] = 1

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

anss = [0 for i in range(N)]
# for p in path:
#     print(p)

for i in range(N):
    for j in range(i + 1, N):
        anss[path[i][j]] += 1

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

# Optimized solution
# encoding:utf-8
import copy
import random
import bisect #bisect_left　これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections

mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))


N, X, Y = LI()
X -= 1
Y -= 1
anss = [0 for i in range(N)]

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

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

from copy import deepcopy

import sys
sys.setrecursionlimit(100000)

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

# from time import time
# start = time()

# neighbor = {}
# for i in range(1, N):
#     neighbor[i] = [i+1]
# for i in range(X+4, Y):
#     neighbor[i] = [i-1, i+1]
# neighbor[X] = [X+1, Y]
# neighbor[Y] = [Y-1, Y+1]
# neighbor[N] = [] if Y < N else [N-1] 
# print(neighbor)

neighbor = {}
for i in range(1, X):
    neighbor[i] = [i+1]
for i in range(Y+1, N):
    neighbor[i] = [i+1]
for i in range(X+1, Y):
    neighbor[i] = [i-1, i+1]
neighbor[X] = [X+1, Y]
neighbor[Y] = [Y-1, Y+1]
neighbor[N] = [] if Y < N else [N-1]
# print(neighbor)

# print(neighbor)

# neighbor = {i: [i-1, i+1] for i in range(2, N)}
# neighbor[1] = [2]
# neighbor[N] = [N-1]
# neighbor[X].append(Y)
# neighbor[Y].append(X)

# appeared_st = set([])
appeared_st = [set([]) for _ in range(N+1)]
# appeared_st[0] = 0
n_k = [0] * N
s_t_dist_dict = {}


# def rec(n, dist, s, k, appeared):
#     # print(appeared_st)
#     if dist == k:
#         # if k == 2:
#         #     input()
#         if s < n and n not in appeared_st[s]:
#             appeared_st[s].add(n)
#             appeared_st[0] += 1
#             # print(appeared_st)

#     toes = [node for node in neighbor[n] if node not in appeared]
#     for to in toes:
#         appeared_copy = deepcopy(appeared)
#         appeared_copy.add(to)
#         rec(to, dist+1, s, k, appeared_copy)


def rec(n, dist, s, limit, appeared, X, Y):
    if s < n:
        ke = "{}.{}".format(s, n)
        if ke in s_t_dist_dict:
            if dist < s_t_dist_dict[ke]:
                n_k[s_t_dist_dict[ke]] -= 1
                s_t_dist_dict[ke] = dist
                n_k[dist] += 1
        else:
            s_t_dist_dict[ke] = dist
            n_k[dist] += 1
            
    # if s < n and n not in appeared_st[s]:
    #     appeared_st[s].add(n)
    #     n_k[dist] += 1
    #     print(appeared_st)
    #     print(n_k)
    #     input()

    if dist == limit:
        return None
    
    if X < n < Y and n - X + 1 > limit - dist:
        return None

    toes = [node for node in neighbor[n] if node not in appeared]
    for to in toes:
        appeared_copy = deepcopy(appeared)
        appeared_copy.add(to)
        rec(to, dist+1, s, limit, appeared_copy, X, Y)


for s in range(1, N):
    rec(s, 0, s, N-1, {s}, X, Y)

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

# for k in range(1, N):
#     tmp = appeared_st[0]

#     for s in range(1, N+1):
#         rec(s, 0, s, k, {s})

    # print(appeared_st[0] - tmp)

# print(appeared_st)
# print(len(appeared_st))
            
# print(time() - start)


# Optimized solution
# coding: utf-8

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

n_k = [0] * (N+1)

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

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