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

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

connect=[[i-1,i+1] for i in range(1,n-1)]
connect.insert(0,[1])
connect.append([n-2])
connect[x-1].append(y-1)
connect[y-1].append(x-1)

dist_from_i = []

for i in range(0,n):
    
    d=0
    dist = [10**6]*n
    
    dq=deque()
    dq.append([i,d])
    dist[i]=d
    
    while len(dq):
        
        x,d = dq.popleft()
                
        for nextx in connect[x]:
            if d<dist[nextx]:
                dq.append([nextx,d+1])
                dist[nextx] = d+1
                
    dist_from_i.append(dist)
            
    c = collections.Counter(sum(dist_from_i,[]))

for k in range(1,n):
    print((c[k]//2))
    

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

dist = [0]*n

for i in range(0,n-1):
    for j in range(i,n):
        
        #xy使わない距離
        dist1 = j-i
        
        #xy使う距離
        dist2 = abs((x-1) - i) + 1 + abs((y-1) - j)
        
        
        # print(i,j,dist1,dist2)
        
        #最短距離
        dist_min = min(dist1,dist2)
        
        dist[dist_min] += 1
        
for k in range(1,n):
    print((dist[k]))
# Original solution
def main():
    import collections
    n,x,y = list(map(int,input().split(" ")))
    dp = [[0]*n for i in range(n)]

    for i in range(0,n):
        for j in range(i+1,n):
            if i < x-1:
                if j < x:
                    dp[i][j] =dp[i][j-1] +1
                if j >= x and j < y:
                    dp[i][j] = dp[i][x-1]+min(j-x+1,y-j)
                if j >=y:
                    dp[i][j] = dp[i][y-1]+j-y+1
            
            if i >= x-1 and i < y-1:
                if j < y:
                    dp[i][j] = dp[i][x-1]+min(j-i,y-x+1-(j-i))
                if j >=y:
                    dp[i][j] = dp[i][y-1]+j-y+1
            
            if i >= y-1:
                dp[i][j] = dp[i][j-1] + 1
    
    dp_fl = dp[0]
    for i in range(1,n):
        dp_fl += dp[i]

    cnts = collections.Counter(dp_fl)

    for i in range(1,n):
        print((cnts.get(i,0)))
main()

# Optimized solution
def main2():
    n,x,y = list(map(int,input().split(" ")))
    cnts = [0]*n
    for i in range(n):
        for j in range(i+1,n):
            dis = min(j-i,abs(x-1-i)+1+abs(y-1-j))
            cnts[dis]+=1
    
    for i in range(1,n):
        print((cnts[i]))
main2()
# 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):
        dist = min(j-i, min(abs(X-1-i)+1+abs(Y-1-j), abs(Y-1-i)+1+abs(X-1-j)))
        ans[dist-1] += 1
for i in range(N-1):
    print((ans[i]))

# Optimized solution
import sys
def input(): return sys.stdin.readline().rstrip()
sys.setrecursionlimit(10 ** 7)

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

# N = 2000
# X = 100
# Y = 1900

X -= 1
Y -= 1


# @profile
def main(N, X, Y):
    ans = [0]*N
    for sv in range(N):
        # dist[v] = dist from sv to v
        dist = [float("inf")]*N
        visited = deque()
        dist[sv] = 0
        visited.appendleft(sv)
        while visited:
            v = visited.pop()
            d = dist[v]
            if v+1 < N and dist[v+1] == float("inf"):
                dist[v+1] = d+1
                visited.appendleft(v+1)
            if v-1 >= 0 and dist[v-1] == float("inf"):
                dist[v-1] = d+1
                visited.appendleft(v-1)
            if v == X and dist[Y] == float("inf"):
                dist[Y] = d+1
                visited.appendleft(Y)
            if v == Y and dist[X] == float("inf"):
                dist[X] = d+1
                visited.appendleft(X)
        # print(dist)
        for d in dist:
            ans[d] += 1

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


main(N, X, Y)


# Optimized solution

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

# N = 2000
# X = 100
# Y = 1900


X -= 1
Y -= 1

# @profile


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

    for a in ans[1:]:
        print(a)


main(N, X, Y)
# Original solution
#!usr/bin/env pypy3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect


def LI(): return [int(x) for x in sys.stdin.readline().split()]


def I(): return int(sys.stdin.readline())


def LS(): return [list(x) for x in sys.stdin.readline().split()]


def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res


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 LSR(n):
    return [LS() for i in range(n)]


sys.setrecursionlimit(1000000)


def main():
    N, X, Y = LI()
    X -= 1
    Y -= 1
    dist = [[N] * N for _ in range(N)]

    q = deque()
    for i in range(N):
        q.append(i)
        dist[i][i] = 0
        while q:
            u = q.popleft()
            t = dist[i][u] + 1
            if u < N - 1:
                if dist[i][u + 1] > t:
                    q.append(u + 1)
                    dist[i][u + 1] = t
            if u >= 1:
                if dist[i][u - 1] > t:
                    q.append(u - 1)
                    dist[i][u - 1] = t
            if u == X:
                if dist[i][Y] > t:
                    q.append(Y)
                    dist[i][Y] = t
            if u == Y:
                if dist[i][X] > t:
                    q.append(X)
                    dist[i][X] = t

    cnt = [0] * N

    for i in range(N):
        for j in range(i + 1, N):
            cnt[dist[i][j]] += 1

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


main()


# Optimized solution
#!usr/bin/env pypy3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect


def LI(): return [int(x) for x in sys.stdin.readline().split()]


def I(): return int(sys.stdin.readline())


def LS(): return [list(x) for x in sys.stdin.readline().split()]


def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res


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 LSR(n):
    return [LS() for i in range(n)]


sys.setrecursionlimit(1000000)


def main():
    N, X, Y = LI()
    X -= 1
    Y -= 1
    cnt = [0] * N

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

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


main()
# Original solution
N,X,Y=list(map(int,input().split()))
def shortest(x,y,a,b):
    ans=min(y-x,abs(y-b)+1+abs(a-x),abs(y-a)+1+abs(b-x))
    return ans
distance=[0]*N
for x in range(1,N+1):
    for y in range(1,N+1):
        if y<=x:
            continue
        else:
            a=shortest(x,y,X,Y)
            distance[a-1]+=1
for i in range(N-1):
    print((distance[i]))

# Optimized solution
N,X,Y=list(map(int,input().split()))
def shortest(x,y,a,b):
    ans=min(y-x,abs(y-b)+1+abs(a-x))
    return ans
distance=[0]*(N-1)
for x in range(1,N):
    for y in range(2,N+1):
        if y<=x:
            continue
        a=shortest(x,y,X,Y)
        distance[a-1]+=1
for i in distance:
    print(i)
# Original solution
from collections import deque
from itertools import combinations

def main():
    n, x, y = [int(e) for e in input().split()]

    D = dict()
    D[1] = {2}
    D[n] = {n - 1}
    for i in range(2, n):
        D[i] = {i - 1, i + 1}

    D[x].add(y)
    D[y].add(x)

    A = [0]*(n - 1)
    for c in combinations(list(range(1, n + 1)), 2):
        Q = deque()
        Q.extend(D[c[0]])
        cnt = 0
        end = False
        while not end:
            cnt += 1
            Qex = set()
            while len(Q) != 0:
                e = Q.popleft()
                if e == c[1]:
                    Q.clear()
                    end = True
                    break

                Qex |= D[e]

            Q.extend(Qex)

        A[cnt - 1] += 1

    for a in A:
        print(a)

if __name__ == "__main__":
    main()


# Optimized solution
from itertools import combinations

def main():
    n, x, y = [int(e) for e in input().split()]

    A = [0]*(n - 1)
    for c in combinations(list(range(1, n + 1)), 2):
        cnt = min(abs(c[1] - c[0]), abs(c[1] - y) + abs(c[0] - x) + 1, abs(c[1] - x) + abs(c[0] - y) + 1)
        A[cnt - 1] += 1

    for a in A:
        print(a)

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

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

for i in range(n):
    if i==0:
        r[i].append(i+1)
    elif i==n-1:
        r[i].append(n-2)
    else:
        r[i].append(i-1)
        r[i].append(i+1)

#x,yの間に道を追加
x,y = x-1,y-1

r[x].append(y)
r[y].append(x)

from collections import deque

q = deque([0])

dist = [-1]*n
dist[0]=0

ans=[]
for p in range(n):
    
    dist = [-1]*n
    dist[p]=0
    q = deque([p])

    while q:
        v = q.popleft()

        for j in r[v]:
            if dist[j]==-1:
                dist[j] = dist[v] + 1
                q.append(j)
    
    ans.append(dist)


d={}
for k in range(1,n+1):
    d[k]=0


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

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


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

x,y = x-1,y-1

d={}
for k in range(1,n):
    d[k]=0


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

        d[dist]+=1

for k in range(1,n):
    print((d[k]))
# Original solution
import sys
from collections import deque
input = sys.stdin.buffer.readline


def bfs(v):
    dist = [f_inf for _ in range(n)]
    dist[v] = 0
    q = deque()
    q.append(v)
    while q:
        u = q.popleft()
        for nv in tree[u]:
            if dist[nv] == f_inf:
                dist[nv] = dist[u] + 1
                q.append(nv)
    for d in dist:
        res[d] += 1


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

tree = [[] for _ in range(n)]
for i in range(n - 1):
    tree[i].append(i + 1)
    tree[i + 1].append(i)
tree[x - 1].append(y - 1)
tree[y - 1].append(x - 1)

f_inf = float("inf")
res = [0 for _ in range(n)]
for i in range(n):
    bfs(i)

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


# Optimized solution
def main():
    import sys
    from collections import deque
    input = sys.stdin.buffer.readline


    def bfs(v):
        dist = [f_inf for _ in range(n)]
        dist[v] = 0
        q = deque()
        q.append(v)
        while q:
            u = q.popleft()
            for nv in tree[u]:
                if dist[nv] == f_inf:
                    dist[nv] = dist[u] + 1
                    q.append(nv)
        for d in dist:
            res[d] += 1


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

    tree = [[] for _ in range(n)]
    for i in range(n - 1):
        tree[i].append(i + 1)
        tree[i + 1].append(i)
    tree[x - 1].append(y - 1)
    tree[y - 1].append(x - 1)

    f_inf = float("inf")
    res = [0 for _ in range(n)]
    for i in range(n):
        bfs(i)

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

if __name__ == '__main__':
    main()
# Original solution
import sys
from collections import deque
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7


def resolve():
    n, x, y = list(map(int, input().split()))
    tree = [[] for _ in range(n)]
    for i in range(1, n):
        tree[i - 1].append(i)
        tree[i].append(i - 1)

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

    def bfs(v):
        dist = [f_inf for _ in range(n)]
        dist[v] = 0
        q = deque()
        q.append(v)
        while q:
            u = q.popleft()
            for nv in tree[u]:
                if dist[nv] == f_inf:
                    dist[nv] = dist[u] + 1
                    q.append(nv)

        for d in dist:
            res[d] += 1

    res = [0 for _ in range(n)]
    for i in range(n):
        bfs(i)

    for j in range(1, n):
        print((res[j] // 2))


if __name__ == '__main__':
    resolve()


# Optimized solution
import sys
from collections import deque

sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7


def resolve():
    def bfs(root):
        dist = [f_inf] * n
        dist[root] = 0
        que = deque()
        que.append(root)
        while que:
            prev = que.popleft()
            for next in tree[prev]:
                if dist[next] == f_inf:
                    dist[next] = dist[prev] + 1
                    que.append(next)
        return dist

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

    cnt = [0] * n
    for i in range(n):
        dist = bfs(i)
        for d in dist:
            cnt[d] += 1

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


if __name__ == '__main__':
    resolve()
# 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):
        dis = min(j-i, abs(j-(x-1))+1+abs((y-1)-i), abs(j-(y-1))+1+abs((x-1)-i))
        ans[dis-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):
        dis = min(j-i, abs(j-x)+1+abs(y-i), abs(j-y)+1+abs(x-i))
        ans[dis-1] += 1
for i in range(n-1):
    print((ans[i]))
# Original solution
n, x, y = list(map(int, input().split())) 

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

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

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

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

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

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

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

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

if __name__ == "__main__":
    main()

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

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

for a in ans[1:]:
    print(a)
# Original 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):
        if j <= X:
            ans[j-i-1] += 1
        elif i <= X:
            ans[min(j-i, X-i+1+abs(Y-j))-1] += 1
        elif i < Y:
            ans[min(j-i, i-X+abs(j-Y)+1)-1] += 1
        else:
            ans[j-i-1] += 1
for a in ans:
    print(a)

# 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+1, N+1):
        d = min(j-i, abs(i-X)+1+abs(j-Y))
        ans[d] += 1

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

# Optimized solution
N,X,Y=list(map(int,input().split()))
X-=1#0-indexへ
Y-=1
dist=[0]*(N+1)
for i in range(N):
  for j in range(i+1,N):
    d=min(j-i,abs(j-X)+1+abs(i-Y),abs(j-Y)+1+abs(i-X))
    #通常ルートとバイパスを通った時を比べて小さい方を取る
    dist[d]+=1#該当の距離に相応するパスの個数を１個追加する
for i in range(1,N):#距離が1以上のパスの個数を順番に出力
  print((dist[i]))
# Original solution
import heapq


def dijkstra_heap(s):
    #始点sから各頂点への最短距離
    d = [float("inf")] * n
    used = [True] * n  #True:未確定
    d[s] = 0
    used[s] = False
    edgelist = []
    for e in edge[s]:
        heapq.heappush(edgelist, e)
    while len(edgelist):
        minedge = heapq.heappop(edgelist)
        #まだ使われてない頂点の中から最小の距離のものを探す
        if not used[minedge[1]]:
            continue
        v = minedge[1]
        d[v] = minedge[0]
        used[v] = False
        for e in edge[v]:
            if used[e[1]]:
                heapq.heappush(edgelist, [e[0] + d[v], e[1]])
    return d


################################
n, x, y = list(map(int, input().split()))  #n:頂点数
w = n
edge = [[] for i in range(n)]
#edge[i] : iから出る道の[重み,行先]の配列
for i in range(w - 1):
    edge[i + 1].append([1, i])
    edge[i].append([1, i + 1])
edge[x - 1].append([1, y - 1])
edge[y - 1].append([1, x - 1])

dic = {i: 0 for i in range(1, n)}

for i in range(n):
    tmp = dijkstra_heap(i)
    zero = False
    for j in tmp:
        if zero:
            dic[j] += 1
        if j == 0:
            zero = True

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


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

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


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

a=[[0 for _ in range(n)] for _ in range(n)]
ans=[0 for _ in range(n-1)]

for i in range(n-1):
  for j in range(i+1,n):
    t=i+1
    u=j+1
    a[i][j]=min(abs(u-t),abs(t-x)+1+abs(y-u),abs(t-y)+1+abs(x-u))
    X=a[i][j]
    ans[X-1]+=1
    
for l in ans:
  print(l)

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

ans=[0 for _ in range(n-1)]

for i in range(n-1):
  for j in range(i+1,n):
    t=i+1
    u=j+1
    H=min(abs(u-t),abs(t-x)+1+abs(y-u),abs(t-y)+1+abs(x-u))
    ans[H-1]+=1
    
for l in ans:
  print(l)
# Original solution
##？
n,x,y = list(map(int,input().split( )))
x-=1;y-=1
cnt = [0]*n

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


# Optimized solution
n,x,y=list(map(int, input().split()))
cnts=[0]*n
for i in range(1,n+1):
    for j in range(1,i):
        mn=min(abs(i-j),abs(i-x)+abs(j-y)+1,abs(i-y)+abs(j-x)+1)
        cnts[mn]+=1
for ci in cnts[1:]:
    print(ci)
# Original solution
def resolve():
    N, X, Y = list(map(int, input().split()))
    X -= 1
    Y -= 1
    from collections import defaultdict, deque
    matrix = [[0]*N for _ in range(N)]
    for i in range(N-1):
        matrix[i][i+1] = matrix[i+1][i] = 1
    matrix[X][Y] = matrix[Y][X] = 1

    ans = [0] * N
    for i in range(N):
        queue = deque([(i, 0)])
        d = [float('inf')] * N
        while queue:
            node, dist = queue.popleft()
            if d[node] != float('inf'):
                continue
            d[node] = dist
            for adj in range(N):
                if matrix[node][adj]:
                    queue.append([adj, dist+1])
        for j in range(N):
            ans[d[j]] += 1
    for i in range(1, N):
        print((ans[i]//2))
resolve()

# Optimized solution
def resolve():
    N, X, Y = list(map(int, input().split()))
    X -= 1
    Y -= 1
    from collections import defaultdict, deque
    matrix = defaultdict(list)
    for i in range(N-1):
        matrix[i].append(i+1)
        matrix[i+1].append(i)
    matrix[X].append(Y)
    matrix[Y].append(X)

    ans = [0] * N
    for i in range(N):
        queue = deque([(i, 0)])
        d = [float('inf')] * N
        while queue:
            node, dist = queue.popleft()
            if d[node] != float('inf'):
                continue
            d[node] = dist
            for adj in matrix[node]:
                queue.append([adj, dist+1])
        for j in range(N):
            ans[d[j]] += 1
    for i in range(1, N):
        print((ans[i]//2))
resolve()
# Original solution
# -*= coding: utf-8 -*-
import queue

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

q = queue.Queue()

ans = [0] * N

# BFS
for i in range(N):
  # 0 〜 N-1の各頂点からスタート
  
  cost = [-1] * N
  cost[i] = 0
  q.put(i) # 基準とする頂点をノードiにする
  
  while not q.empty():
    
    # 現在のノードのインデックス
    current = q.get()
    
    if current - 1 >= 0 and cost[current - 1] == -1:
      # 1つ前のノードを登録
      
      q.put(current - 1)
      cost[current - 1] = cost[current] + 1
      
    if current + 1 < N and cost[current + 1] == -1:
      # 1つ後ろのノードを登録
      
      q.put(current + 1)
      cost[current + 1] = cost[current] + 1
      
    if current == X - 1 and cost[Y - 1] == -1:
      # XからYへのルートを登録
      
      q.put(Y - 1)
      cost[Y - 1] = cost[current] + 1
    
    if current == Y - 1 and cost[X - 1] == -1:
      # YからXへのルートを登録
      
      q.put(X - 1)
      cost[X - 1] = cost[current] + 1
      
  # この時点でcostにはノードiから各ノードへの最小コストが格納されている
  
  #print(cost)
  for j in range(N):
    ans[cost[j]] += 1

for i in range(1, N):
  print((ans[i]//2)) # ノードA→Bと、逆向きのB→Aが、両方カウントされているので2分の1する

# Optimized solution
# -*= coding: utf-8 -*-
from collections import deque

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

d = deque() # 初期化

ans = [0] * N

# BFS
for i in range(N):
  # 0 〜 N-1の各頂点からスタート
  
  cost = [-1] * N
  cost[i] = 0
  d.append(i) # 基準とする頂点をノードiにする
  
  while len(d) > 0:
    # dequeueが空でない間ループ
    
    # 現在のノードのインデックス
    current = d.popleft()
    
    if current - 1 >= 0 and cost[current - 1] == -1:
      # 1つ前のノードを登録
      
      d.append(current - 1)
      cost[current - 1] = cost[current] + 1
      
    if current + 1 < N and cost[current + 1] == -1:
      # 1つ後ろのノードを登録
      
      d.append(current + 1)
      cost[current + 1] = cost[current] + 1
      
    if current == X - 1 and cost[Y - 1] == -1:
      # XからYへのルートを登録
      
      d.append(Y - 1)
      cost[Y - 1] = cost[current] + 1
    
    if current == Y - 1 and cost[X - 1] == -1:
      # YからXへのルートを登録
      
      d.append(X - 1)
      cost[X - 1] = cost[current] + 1
      
  # この時点でcostにはノードiから各ノードへの最小コストが格納されている
  
  #print(cost)
  for j in range(N):
    ans[cost[j]] += 1

for i in range(1, N):
  print((ans[i]//2)) # ノードA→Bと、逆向きのB→Aが、両方カウントされているので2分の1する
# Original solution
from itertools import combinations as cb
node = []
n,x,y = list(map(int, input().split()))
for i in range(1, n+1):
  node.append(i)
pair = list(cb(node, 2))
dist = [0]*n
for a in pair:
  if a[1] <= x or a[0] >= y:
    dist[a[1]-a[0]] += 1
  else:
    dist[min(abs(x-a[0])+abs(y-a[1])+1,a[1]-a[0])] += 1
for i in range(1, n):
  print((dist[i]))

# Optimized solution
from itertools import combinations as cb
n,x,y = list(map(int, input().split()))
pair = list(cb(list(range(1,n+1)), 2))
dist = [0]*n
for a in pair:
  if a[1] <= x or a[0] >= y:
    dist[a[1]-a[0]] += 1
  else:
    dist[min(abs(x-a[0])+abs(y-a[1])+1,a[1]-a[0])] += 1
for i in range(1, n):
  print((dist[i]))