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

def f(i,j):
  if j <= X:
    return j-i
  elif Y <= i:
    return j-i
  elif X <= i and j <= Y:
    return min(j-i,(i-X)+1+(Y-j))
  elif i <= X and Y <= j:
    return (X-i)+1+(j-Y)
  elif i <= X and X <= j and j <= Y:
    return (X-i)+min(j-X,1+(Y-j))
  else:
    return (j-Y)+min(Y-i,(i-X)+1)

A = []

for k in range(1,N,1):
  for l in range(k+1,N+1,1):
    A.append(f(k,l))

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

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

def f(i,j):
  if j <= X:
    return j-i
  elif Y <= i:
    return j-i
  elif X <= i and j <= Y:
    return min(j-i,(i-X)+1+(Y-j))
  elif i <= X and Y <= j:
    return (X-i)+1+(j-Y)
  elif i <= X and X <= j and j <= Y:
    return (X-i)+min(j-X,1+(Y-j))
  else:
    return (j-Y)+min(Y-i,(i-X)+1)

A = [0]*(N-1)

for k in range(1,N,1):
  for l in range(k+1,N+1,1):
    A[f(k,l)-1] += 1

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

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

dic = defaultdict(int)

X = X - 1
Y = Y - 1

for i in range(N):
    for j in range(i + 1, N):
        if i <= X and Y <= j:
            v = X - i + 1 + j - Y
        elif (i <= X) and (X <= j and j <= Y):
            v = min(j - i, X - i + 1 + Y - j)
        elif (X <= i and i <= Y) and Y <= j:
            v = min(j - i, i - X + 1 + j - Y)
        elif (X <= i and i <= Y) and (X <= j and j <= Y):
            v = min(j - i, i - X + 1 + Y - j)
        else:
            v = j - i

        dic[v] += 1


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


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


dic = {}

X = X - 1
Y = Y - 1

for i in range(N):
    for j in range(i + 1, N):
        if i <= X and Y <= j:
            v = X - i + 1 + j - Y
        elif (i <= X) and (X <= j and j <= Y):
            v = min(j - i, X - i + 1 + Y - j)
        elif (X <= i and i <= Y) and Y <= j:
            v = min(j - i, i - X + 1 + j - Y)
        elif (X <= i and i <= Y) and (X <= j and j <= Y):
            v = min(j - i, i - X + 1 + Y - j)
        else:
            v = j - i

        if v in dic:
            dic[v] += 1
        else:
            dic[v] = 1


for i in range(1, N):
    if i in dic:
        print((dic[i]))
    else:
        print((0))
# Original solution
# D - Line++
from collections import deque

INF = 1001001001

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

for i in range(n):
    dist = [INF]*n
    q = deque()
    dist[i] = 0
    q.append(i)
    
    while len(q)>0:
        v = q.popleft()
        d = dist[v]
        if v-1 >= 0:
            if dist[v-1]==INF:
                q.append(v-1)
                dist[v-1]=d+1
        if v+1 < n:
            if dist[v+1]==INF:
                q.append(v+1)
                dist[v+1]=d+1
        if v==x:
            if dist[y]==INF:
                q.append(y)
                dist[y]=d+1
        if v==y:
            if dist[x]==INF:
                q.append(x)
                dist[x]=d+1
    for d in dist:
        if d!=0 and d!=INF:
            ans[d] += 1

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


# Optimized solution
# D - Line++
from collections import deque

INF = 1001001001

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

for i in range(n):
    dist = [INF]*n
    q = deque()
    dist[i] = 0
    q.append(i)
    
    while len(q)>0:
        v = q.popleft()
        d = dist[v]
        if v-1 >= 0 and dist[v-1]==INF:
            q.append(v-1)
            dist[v-1]=d+1
        if v+1 < n and dist[v+1]==INF:
            q.append(v+1)
            dist[v+1]=d+1
        if v==x and dist[y]==INF:
            q.append(y)
            dist[y]=d+1
        if v==y and dist[x]==INF:
            q.append(x)
            dist[x]=d+1
    for d in dist:
        ans[d] += 1

for a in ans[1:]:
    print((int(a//2)))
# Original solution
N, X, Y= list(map(int, input().split()))
List=[]
for i in range(1,N+1,1):
	for j in range(i,N+1,1):
		saitan = min(abs(i-j), abs(i-X)+abs(Y-j)+1, abs(i-Y)+abs(X-j)+1)
		List.append(saitan)

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

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

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


for i in range(1,N):
    	print((List[i]))
# Original solution
N, X, Y = list(map(int, input().split()))
dist_list = []
for i in range(1, N+1):
    for j in range(i+1, N+1):
        dist_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((dist_list.count(k)))

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

N, X, Y = list(map(int, input().split()))
def check(num, distance):
    if num!=0:
        distance[num-1]=min(distance[num]+1, distance[num-1])
    if num!=N-1:
        distance[num+1]=min(distance[num+1], distance[num]+1)
    if num==X-1:
        distance[Y-1]=min(distance[Y-1], distance[X-1]+1)
    elif num==Y-1:
        distance[X-1] = min(distance[X-1], distance[Y-1]+1)
total_answer=[]
answer=[N]*N
for k in range(N):
    temp=copy.copy(answer)
    temp[k]=0
    #print(temp)
    for i in range(0, N):
        check(i, temp)
        #print(temp)
    #print(temp)
    for j in range(N-1,-1,-1):
        check(j, temp)
    #print(temp)
    #print('/n')

    for i in range(0, N):
        check(i, temp)

    for j in range(N - 1, -1, -1):
        check(j, temp)
    for i in range(0, N):
        check(i, temp)

    for j in range(N - 1, -1, -1):
        check(j, temp)

        #print(temp)
    #print(temp)
    total_answer+=temp
#print(total_answer)
import collections
dict=collections.Counter(total_answer)
#print(dict)
for i in range(1, N):
    print((dict[i]//2))

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

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

dis=[['NONE']*n for i in range(n)]
d = deque()
for i in range(n):
    d.append((i,0))
    c=0
    while d:
        p,j=d.popleft()
        if p==x and c==0:
            d.append((y,j+1))
            c=1
        if p==y and c==0:
            d.append((x,j+1))
            c=1
        if dis[i][p]=='NONE':
            dis[i][p]=j
            if p+1<n:
                if dis[i][p+1]=='NONE':
                    d.append((p+1,j+1))
            if p-1>=0:
                if dis[i][p-1]=='NONE':
                    d.append((p-1,j+1))
s=[]
for i in dis:
    s+=i
c=Counter(s)
for i in range(1,n):
    print((c[i]//2))


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

dis=[]

for i in range(n-1):
    for j in range(i,n):
        dis.append(min(abs(i-j),abs(i-x)+abs(j-y)+1,abs(i-y)+abs(j-x)+1))
c=Counter(dis)
for i in range(1,n):
    print((c[i]))
# Original solution
from collections import deque

n,x,y=list(map(int,input().split()))
x,y=x-1,y-1
e = [[2*10**3+1]*n for _ in range(n)]
for i in range(n):
    e[i][i] = 0

def main():
    for i in range(n):
        s = deque([i])  # サーチstack. 初期条件を設定
        dfs(s, e[i])
    #print(e)
    ans = [0]*n
    for i,ee in enumerate(e):
        for eee in ee[i:]:
            ans[eee] += 1
    for i in ans[1:]:
        print(i)

def dfs(s,e):
    while len(s) > 0:  # len(s) > 0 でループ
        t = s.popleft()
        for i in get_children(t):  # t の子ノードを列挙
            if e[i] != 2*10**3+1 and e[i] < e[t]+1:
                continue
            s.append(i)
            e[i] = min(e[i], e[t] + 1) # 探索済としつつ距離を入れる

def get_children(t):
    if t in (x,y):
        yield y if t == x else x
    if 0 < t:
        yield t-1
    if t < (n-1):
        yield t+1

if __name__ == "__main__":
    main()

# Optimized solution
from collections import Counter
def main():
    n,x,y=list(map(int,input().split()))
    x,y=x-1,y-1
    ans=[]
    for i in range(n):
        dp = [n]*n
        dp[i] = 0
        calcstep(i, dp)
        dp[y] = min(dp[y], dp[x]+1)
        dp[x] = min(dp[x], dp[y]+1)
        calcstep(x, dp)
        calcstep(y, dp)
        #print(i, dp)
        ans += dp
    ans = Counter(ans)
    for i in range(1,n):
        print((ans[i]//2))

def calcstep(i, dp):
    for j in range(i, len(dp)-1):
        if dp[j+1] > dp[j]+1:
            dp[j+1] = dp[j]+1
        else:
            break
    for j in range(1,i+1)[::-1]:
        if dp[j-1] > dp[j]+1:
            dp[j-1] = dp[j]+1
        else:
            break

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

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

ans = [0] * (N + 1)

def push(q, dist, index, dist_v):
    if dist[index] != -1:
        return
    q.put(index)
    dist[index] = dist_v

for i in range(N):
    q = queue.Queue()
    dist = [-1] * N
    push(q, dist, i, 0)
    while not q.empty():
        v = q.get()
        d = dist[v]
        if v - 1 >= 0: push(q, dist, v - 1, d + 1)
        if v + 1 < N: push(q, dist, v + 1, d + 1)
        if v == X: push(q, dist, Y, d + 1)
        if v == Y: push(q, dist, X, d + 1)
    for j in range(N):
        ans[dist[j]] += 1

for i in range(N):
    ans[i] //= 2

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


# Optimized solution
from collections import deque

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

ans = [0] * (N + 1)

def push(q, dist, index, dist_v):
    if dist[index] != -1:
        return
    q.appendleft(index)
    dist[index] = dist_v

for i in range(N):
    q = deque()
    dist = [-1] * N
    push(q, dist, i, 0)
    while len(q) > 0:
        v = q.pop()
        d = dist[v]
        if v - 1 >= 0: push(q, dist, v - 1, d + 1)
        if v + 1 < N: push(q, dist, v + 1, d + 1)
        if v == X: push(q, dist, Y, d + 1)
        if v == Y: push(q, dist, X, d + 1)
    for j in range(N):
        ans[dist[j]] += 1

for i in range(N):
    ans[i] //= 2

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

X = X-1
Y = Y-1

for kIndx in range(1, N):
    kNum = 0

    for jIndx in range(N):
        for iIndx in range(jIndx):
            if (jIndx <= X) or (iIndx >= Y):
                if jIndx - iIndx == kIndx:
                    kNum += 1
            elif (iIndx <= X) and (jIndx >= Y):
                if (jIndx - iIndx) - (Y - X -1) == kIndx:
                    kNum += 1
            elif (iIndx <= X) and ((jIndx > X) and (jIndx < Y)):
                if 2 * jIndx - (X + Y) - 1 > 0:
                    if (jIndx - iIndx) - (2 * jIndx - (X + Y) - 1) == kIndx:
                        kNum += 1
                else:
                    if jIndx - iIndx == kIndx:
                        kNum += 1
            elif ((iIndx > X) and (iIndx < Y)) and (jIndx >= Y):
                if (X + Y) - 2 * iIndx - 1 > 0:
                    if (jIndx - iIndx) - ((X + Y) - 2 * iIndx - 1) == kIndx:
                        kNum += 1
                else:
                    if jIndx - iIndx == kIndx:
                        kNum += 1
            else:
                if (2 * (jIndx - iIndx) - (Y - X) - 1) > 0:
                    if (jIndx - iIndx) - (2 * (jIndx - iIndx) - (Y - X) - 1) == kIndx:
                        kNum += 1
                else:
                    if jIndx - iIndx == kIndx:
                        kNum += 1
    print(kNum)


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

X = X-1
Y = Y-1

kDict = {}

for kIndx in range(1, N+1):
    kDict[kIndx] = 0

for jIndx in range(N):
    for iIndx in range(jIndx):
        if (jIndx <= X) or (iIndx >= Y):
            kDict[jIndx - iIndx] += 1
        elif (iIndx <= X) and (jIndx >= Y):
            kDict[(jIndx - iIndx) - (Y - X - 1)] += 1
        elif (iIndx <= X) and ((jIndx > X) and (jIndx < Y)):
            if 2 * jIndx - (X + Y) - 1 > 0:
                kDict[(jIndx - iIndx) - (2 * jIndx - (X + Y) - 1)] += 1
            else:
                kDict[jIndx - iIndx] += 1
        elif ((iIndx > X) and (iIndx < Y)) and (jIndx >= Y):
            if (X + Y) - 2 * iIndx - 1 > 0:
                kDict[(jIndx - iIndx) - ((X + Y) - 2 * iIndx - 1)] += 1
            else:
                kDict[jIndx - iIndx] += 1
        else:
            if (2 * (jIndx - iIndx) - (Y - X) - 1) > 0:
                kDict[(jIndx - iIndx) - (2 * (jIndx - iIndx) - (Y - X) - 1)] += 1
            else:
                kDict[jIndx - iIndx] += 1

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

for i in d:
  print(i)

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

for i in d:
  print(i)
# Original solution
import math
n, x, y = list(map(int,input().split()))
num = [0 for i in range(n)]

for i in range(n):
    for j in range(i+1,n):
        num[min([j-i,int(math.fabs(j-y+1))+1+int(math.fabs(i-x+1))])] += 1

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


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

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

for i in range(1,n):
    print((num[i]))
# Original solution
n, x, y = list(map(int, input().split()))
dp = [[0 for _ in range(n)] for _ in range(n)]
ans = [0 for _ in range(n-1)]
for i in range(1, n):
  for j in range(i+1, n+1):
    a = min(j-i, abs(x-i)+abs(y-j)+1, abs(x-j)+abs(y-i)+1)
    ans[a-1] += 1
for i in range(n-1):
  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):
  for j in range(i+1, n+1):
    a = min(j-i, abs(x-i)+abs(y-j)+1, abs(x-j)+abs(y-i)+1)
    ans[a-1] += 1
for i in range(n-1):
  print((ans[i]))
# Original solution
#import pysnooper
#import numpy
#import os,re,sys,operator
#from collections import Counter,deque
#from operator import itemgetter,mul
#from itertools import accumulate,combinations,groupby,combinations_with_replacement,permutations
from sys import stdin,setrecursionlimit
#from bisect import bisect_left,bisect_right
#from copy import deepcopy
#import heapq
#import math
#import string
#from time import time
#from functools import lru_cache,reduce
#from math import factorial,hypot
#import sys
#from fractions import gcd
setrecursionlimit(10**6+1)
input=stdin.readline

n,x,y=list(map(int,input().split()))
dis=[0]*(n-1)
for i in range(1,n+1):
    for j in range(1,n+1):
        if i>=j: continue
        now=min(abs(j-i),abs(i-x)+1+abs(j-y),abs(j-x)+1+abs(i-y))
        #print(i+1,j+1,now,(abs(j-i),abs(i-x)+1+abs(j-y),abs(j-x)+1+abs(i-y)))
        dis[now-1]+=1

for i in dis:
    print(i)

# Optimized solution
#import pysnooper
#import numpy
#import os,re,sys,operator
#from collections import Counter,deque
#from operator import itemgetter,mul
#from itertools import accumulate,combinations,groupby,combinations_with_replacement,permutations
from sys import stdin,setrecursionlimit
#from bisect import bisect_left,bisect_right
#from copy import deepcopy
#import heapq
#import math
#import string
#from time import time
#from functools import lru_cache,reduce
#from math import factorial,hypot
#import sys
#from fractions import gcd
setrecursionlimit(10**6+1)
input=stdin.readline

def main():
    n,x,y=list(map(int,input().split()))
    dis=[0]*(n-1)
    for i in range(1,n+1):
        for j in range(1,n+1):
            if i>=j: continue
            now=min(abs(j-i),abs(i-x)+1+abs(j-y),abs(j-x)+1+abs(i-y))
            #print(i+1,j+1,now,(abs(j-i),abs(i-x)+1+abs(j-y),abs(j-x)+1+abs(i-y)))
            dis[now-1]+=1

    for i in dis:
        print(i)

if __name__=="__main__":main()
# Original solution
def dijkstra(s,n,w,cost):
    #始点sから各頂点への最短距離
    #n:頂点数,　w:辺の数, cost[u][v] : 辺uvのコスト(存在しないときはinf)
    d = [float("inf")] * n
    used = [False] * n
    d[s] = 0
    
    while True:
        v = -1
        #まだ使われてない頂点の中から最小の距離のものを探す
        for i in range(n):
            if (not used[i]) and (v == -1):
               v = i
            elif (not used[i]) and d[i] < d[v]:
                v = i
        if v == -1:
               break
        used[v] = True
               
        for j in range(n):
               d[j] = min(d[j],d[v]+cost[v][j])
    return d

def main():
    n, x, y = list(map(int, input().split()))
    cost = [[float("inf") for i in range(n)] for i in range(n)] 
    for i in range(n):
        if i == n - 1:
            tmp_x, tmp_y = x-1, y-1
        else:
            tmp_x, tmp_y = i, i+1
        cost[tmp_x][tmp_y] = 1
        cost[tmp_y][tmp_x] = 1

    ans_list = [0]*n

    for i in range(n):
        di_list = dijkstra(i,n,n,cost)
        for j in range(i+1,n):
            ans_list[di_list[j]] += 1

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

if __name__ == '__main__':
    main()

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

    x -= 1
    y -= 1

    ans_list = [0]*n

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

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

if __name__ == '__main__':
    main()
# Original solution
n, x, y = list(map(int,input().split()))

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


# 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(x-i)+1+abs(y-j))-1] += 1
        #ans.append(min(j-i,abs(x-i)+1+abs(y-j)))
for k in range(n-1):
    print((ans[k]))
# Original solution
import sys
from collections import OrderedDict

sys.setrecursionlimit(10 ** 6)  # 再帰関数の再帰の深さを設定
to_index = lambda x: int(x) - 1  # 入力した数字に1を引いたものを返す
print_list_in_2D = lambda x: print(*x, sep="\n")  # リストの要素を改行を挟んで表示する関数


# 入力を整数に変換して受け取る
def input_int():
    return int(input())


def map_int_input():
    return map(int, input())


MII = map_int_input


def MII_split():
    return map(int, input().split())


def MII_to_index():
    return map(to_index, input())


def MII_split_to_index():
    return map(to_index, input().split())


# 入力全てを整数に変換したものの配列を受け取る
def list_int_inputs():
    return list(map(int, input()))


LII = list_int_inputs


def LII_split():
    return list(map(int, input().split()))


# 2次元リスト化
def LII_2D(rows_number):
    return [LII() for _ in range(rows_number)]


def LII_split_2D(rows_number):
    return [LII_split() for _ in range(rows_number)]


N, X, Y = MII_split()

dists = []
for start_node in range(N - 1):

    dists_from_start = OrderedDict()

    for i in range(start_node, N):
        dists_from_start[i] = i - start_node
    # if X - 1 >= start_node:
    #     dists_from_start[Y - 1] = dists_from_start[X - 1] + 1
    #     for i in range(start_node, N):
    #         dists_from_start[i] = dists_from_start[Y - 1] + abs(i - (Y - 1))
    # else:
    back_s = abs(start_node - (X - 1))
    for i in range(start_node, N):
        dist_t = back_s + 1 + abs(Y - 1 - i)
        dists_from_start[i] = min(dist_t, dists_from_start[i])

    dists += dists_from_start.values()

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


# Optimized solution
import sys

sys.setrecursionlimit(10 ** 6)  # 再帰関数の再帰の深さを設定
to_index = lambda x: int(x) - 1  # 入力した数字に1を引いたものを返す
print_list_in_2D = lambda x: print(*x, sep="\n")  # リストの要素を改行を挟んで表示する関数

# 入力を整数に変換して受け取る
def input_int():
    return int(input())

def map_int_input():
    return map(int, input())

MII = map_int_input

def MII_split():
    return map(int, input().split())

def MII_to_index():
    return map(to_index, input())

def MII_split_to_index():
    return map(to_index, input().split())

# 入力全てを整数に変換したものの配列を受け取る
def list_int_inputs():
    return list(map(int, input()))

LII = list_int_inputs

def LII_split():
    return list(map(int, input().split()))

# 2次元リスト化
def LII_2D(rows_number):
    return [LII() for _ in range(rows_number)]

def LII_split_2D(rows_number):
    return [LII_split() for _ in range(rows_number)]

N, X, Y = MII_split()

dist_counts = {}
for start_node in range(N - 1):
    back_s = abs(start_node - (X - 1))
    for i in range(start_node, N):
        dist_t = back_s + 1 + abs(Y - 1 - i)
        dist = min(dist_t, i - start_node)
        if dist in dist_counts:
            dist_counts[dist] += 1
        else:
            dist_counts[dist] = 1

for k in range(1, N):
    print(dist_counts[k] if k in dist_counts else 0)
# Original solution
#n=int(input())
n,x,y=list(map(int,input().split()))
#l=list(map(int,input().split()))
#l=[list(map(int,input().split())) for i in range(n)]

adjl=[[0 for i in range(n)] for j in range(n)]

dic={}

for i in range(n):
    for j in range(i,n):
        #if i>=j:
        #    continue
        dis=j-i
        maybe=abs(x-(i+1))+1+abs(y-(j+1))
        dis=min(dis,maybe)
        adjl[i][j]=dis

for i in range(n):
    for j in range(i,n):
        #if i>=j:
        #    continue
        dis=adjl[i][j]
        dic[dis]=dic.get(dis,0)+1
for k in range(1,n):
    print((dic.get(k,0)))


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

#adjl=[[0 for i in range(n)] for j in range(n)]

dic={}

for i in range(n):
    for j in range(i,n):
        #if i>=j:
        #    continue
        dis=j-i
        maybe=abs(x-(i+1))+1+abs(y-(j+1))
        dis=min(dis,maybe)
        #adjl[i][j]=dis
        dic[dis]=dic.get(dis,0)+1

for k in range(1,n):
    print((dic.get(k,0)))
# Original solution
n, x, y = list(map(int, input().split()))
x = x - 1
y = y - 1
kl = [0] * (n - 1)

for s in range(n - 1):
    for e in range(s+1, n):
        d = e-s
        if (e <= x)or(s >= y):
            kl[d - 1] += 1
        else:
            kl[min(d, abs(s-x)+abs(e-y)+1)-1] += 1

for i in kl:
    print(i)


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

for s in range(n - 1):
    for e in range(s+1, n):
        d = e-s
        kl[min(d, abs(s-x)+abs(e-y)+1)-1] += 1

for i in kl:
    print(i)