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

def main():
    # n, x, y = 7, 3, 7
    n, x, y = [int(s) for s in sys.stdin.readline().strip().split()]
    score = {i: 0 for i in range(1, n)}
    total_pair = set()

    def bfs(start):
        seen = set()
        q = deque()
        q.append((0, start))
        while q:
            dist, cur = q.popleft()
            pair = (min(start, cur), max(start, cur))
            if pair in seen:
                continue
            seen.add(pair)
            if dist > 0:
                if pair not in total_pair:
                    score[dist] += 1
                    total_pair.add(pair)
            if cur < n-1:
                q.append((dist+1, cur+1))
            if cur > 0:
                q.append((dist+1, cur-1))
            if cur == x-1:
                q.append((dist+1, y-1))
            if cur == y-1:
                q.append((dist+1, x-1))

    for i in range(n-1):
        bfs(i)
    for i in range(1, n):
        print((score[i]))

main()


# Optimized solution
import sys

def main():
    n, x, y = [int(s) for s in sys.stdin.readline().strip().split()]
    x1 = x-1
    y1 = y-1

    score = {i:0 for i in range(n)}

    for i in range(n-1):
        for j in range(i+1, n):
            diff = j - i
            cand = abs(x1 - i) + 1 + abs(y1 - j)
            cand2 = abs(y1 - i) + 1 + abs(x1 - j)
            result = min(diff, cand, cand2)
            score[result] += 1

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

main()
# Original solution
N, X, Y = [int(i) for i in input().split()]
gp = [[float('inf')]*N for _ in range(N)]

def warshall_floyd(d,n):
    #d[i][j]: iからjへの最短距離
    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])
    return d



for i in range(N-1):
    gp[i][i+1] = 1
    gp[i+1][i] = 1
    if(i==X-1):
        gp[i][Y-1] = 1
        gp[Y-1][i] = 1

d = warshall_floyd(gp, N)
li = [0]*(N-1)
for i in range(N):
    for j in range(i+1, N):
        li[d[i][j]-1] += 1

for i in li:
    print(i)



# Optimized solution
N, X, Y = [int(i) for i in input().split()]
li = [0]*(N-1)
for i in range(1, N+1):
    for j in range(i+1, N+1):
        k = 0
        if(i<X and j<X):
            k = j-i
        if(i<X and X<=j<=Y):
            k = min(j-i, X-i+1+Y-j)
        if(i<X and Y<j):
            k = X-i+1+j-Y
        if(X<=i<=Y and X<=j<=Y):
            k = min(j-i, i-X+1+Y-j)
        if(X<=i<=Y and Y<j):
            k = min(j-i, i-X+1+j-Y)
        if(Y<i and Y<j):
            k = j-i
        li[k-1] += 1

for i in li:
    print(i)
# Original solution
n, a1, a2 = list(map(int, input().split(" ")))
anscount = [0 for i in range(n + 1)]

for i in range(1, n):
    for j in range(i + 1, n + 1):
        anscount[min(abs(j - i), abs(i - a1) + abs(j - a2) + 1, abs(i - a2) + abs(j - a1) + 1)] += 1

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

# Optimized solution
n, a1, a2 = list(map(int, input().split(" ")))
print(n)
wa = a2 - a1 + 1
l1 = a1 - 1
l2 = n - a2
hwa = wa // 2
pari = wa % 2
# print(wa,l1,l2,hwa,pari)
 
tmp = 0
for i in range(2, n):
    if l1 + l2 + 1 >= i:
        tmp += l1 + l2 - i + 2
    if i - 1 <= l1:
        tmp -= 1
    if i - 1 <= l2:
        tmp -= 1
    # print("himonokazu",tmp)
    if hwa > i:
        tmp += wa
    elif hwa == i:
        if pari == 1:
        	tmp += wa
        else:
            tmp += hwa
    # print("wamoirete",tmp)
    # print((i-1),(hwa-1),(l1-1),l2-1)
    if i <= hwa + l1:
        # print(min(hwa,l1,hwa+l1-i+1,i-1))
        tmp += min(hwa, l1, hwa + l1 - i + 1, i - 1) * 2
        if pari == 0 and hwa < i:
            tmp -= 1
            # print("l1gen")
        # print("l1",tmp)
    if i <= hwa + l2:
        # print(min(hwa,l2,hwa+l2-i+1,i-1))
        tmp += min(hwa, l2, hwa + l2 - i + 1, i - 1) * 2
        if pari == 0 and hwa < i:
            tmp -= 1
            # print("l2gen")
        # print("l2", tmp)
    print(tmp)
    tmp = 0
# Original solution
N,X,Y=list(map(int,input().split()))

def count(k):
    ans=0
    for i in range(1,N):
        for j in range(i+1,N+1):
            if min(abs(j-i),abs(X-i)+abs(Y-j)+1)==k:
                ans+=1
    return ans

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


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

for i in range(1,N):
    print((ans[i]))
# Original solution
n, x, y = list(map(int, input().split()))
edge = [[] for _ in range(n+1)]
dist = [[abs(i-j) for i in range(n+1)] for j in range(n+1)]
counter = [0 for i in range(n)]
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(y+1):
    for j in range(x, n+1):
        new_dist = abs(x-i)+abs(y-j)+1
        if new_dist < dist[i][j]:
            dist[i][j] = new_dist
            dist[j][i] = new_dist

for i in range(1, n+1):
    for num in dist[i][1:]:
        counter[num] += 1
# print(dist)

for num in counter[1:]:
    print((num//2))


# Optimized solution
n, x, y = list(map(int, input().split()))
edge = [[] for _ in range(n+1)]
dist = [[abs(i-j) for i in range(n+1)] for j in range(n+1)]
counter = [0 for i in range(n)]
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(y+1):
    for j in range(x, n+1):
        if j > i:
            new_dist = abs(x-i)+abs(y-j)+1
            if new_dist < dist[i][j]:
                dist[i][j] = new_dist

for i in range(1, n+1):
    for num in dist[i][i+1:]:
        counter[num] += 1
# print(dist)

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

ans = [0] * N

X -= 1
Y -= 1
for i in range(N):
    for j in range(i+1, N):
        distance = abs(i-j)
        # X Y i j
        if Y <= i:
            pass
        # i j X Y
        elif j <= X:
            pass
        # X i Y j
        elif X <= i < Y <= j:
            dis = (i-X) + 1 + (j-Y)
            distance = min(distance, dis)
        # i X j Y
        elif i <= X < j <= Y:
            dis = (X-i) + 1 + (Y-j)
            distance = min(distance, dis)
        # i X Y j
        elif i <= X < Y <= j:
            dis = (X-i) + 1 + (j-Y)
            distance = min(distance, dis)
        # X i j Y
        elif X <= i < j <= Y:
            dis = (i-X) + 1 + (Y-j)
            distance = min(distance, dis)

        ans[distance] += 1

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


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

ans = [0] * N

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

for k in range(1, N):
    print((ans[k]))
# Original 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):
    if i <= X and j <= X:
      dic = j-i
    elif i >= Y and j >= Y:
      dic = j-i
    elif i <= X and j >= Y:
      dic = (j-i)-(Y-X)+1
    elif X < i < Y and j >= Y:
      dic = min(i-X+1,Y-i)+(j-Y)
    elif i<=X and X < j < Y:
      dic = (X-i)+min(Y-j+1,j-X)
    elif X < i < Y and X < j < Y:
      dic = min(j-i,(i-X+1)+(Y-j))
    ans[dic-1] = ans[dic-1]+1

for ret in ans:
  print(ret)

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


def f(N,X,Y):
  for i in range(1,N):
    for j in range(i+1,N+1):
      if i <= X and j <= X:
        dic = j-i
      elif i >= Y and j >= Y:
        dic = j-i
      elif i <= X and j >= Y:
        dic = (j-i)-(Y-X)+1
      elif X < i < Y and j >= Y:
        dic = min(i-X+1,Y-i)+(j-Y)
      elif i<=X and X < j < Y:
        dic = (X-i)+min(Y-j+1,j-X)
      elif X < i < Y and X < j < Y:
        dic = min(j-i,(i-X+1)+(Y-j))
      ans[dic-1] = ans[dic-1]+1
  
f(n,x,y)
for ret in ans:
  print(ret)
# Original solution
n, x, y = list(map(int, input().split()))
kyori = []

def clc(i1, i2):
    return min(1 + abs(i2 - y) + abs(i1 - x), i2 - i1)

for k in range(1, n+1):
    for l in range(k+1, n+1):
        tmp = clc(k, l)
        kyori.append(tmp)

for i in range(n-1):
    cnt = 0
    for k in kyori:
        if k == i + 1:
            cnt += 1
    print(cnt)

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

def clc(i1, i2):
    if (i1 < x and i2 <= x) or (y <= i1 and y < i2):
        return i2 - i1
    else:
        return min(1 + abs(i2 - y) + abs(i1 - x), i2 - i1)

for k in range(1, n+1):
    for l in range(k+1, n+1):
        tmp = clc(k, l)
        kyori.append(tmp)
outs = [0 for _ in range(n-1)]
for k in kyori:
    outs[k-1] += 1
for i in range(n-1):
    print((outs[i]))
# Original solution
from itertools import *
n,x,y=map(int,input().split())
a=[0]*n
for i,j in combinations(range(1,n+1),2):
    b=min(abs(i-j),abs(x-i)+1+abs(y-j),abs(x-j)+1+abs(y-i))
    a[b]+=1
print(*a[1:],sep="\n")   


# Optimized solution
n,x,y=map(int,input().split())
a=[0]*n
for i in range(1,n+1):
    for j in range(i,n+1):
        b=min(abs(i-j),abs(i-x)+1+abs(y-j),abs(x-j)+1+abs(y-i))
        a[b]+=1
print(*a[1:],sep="\n")
# Original solution
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())

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=LI()
  
  cost = [[inf for i in range(n)] for i in range(n)] 
  for i in range(n-1):
    cost[i][i+1]=1
    cost[i+1][i]=1
  cost[x-1][y-1]=1
  cost[y-1][x-1]=1

  ans=[0]*(n-1)
  for i in range(n):
    a=dijkstra(i,n,n,cost)
    for x in a[i:]:
      ans[x]+=1

  for x in ans[1:]:
    print(x)
  print((0))

main()
# print(main())


# Optimized solution
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy

sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())

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

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

ans=[0]*n
for i in range(n):
  a=dijkstra_heap(i,edge)
  # print(a)
  for x in a[i:]:
    ans[x]+=1

for x in ans[1:]:
  print(x)
# Original solution
from heapq import heappush, heappop


def solve(N, X, Y):
    ans = [0] * (N)

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

    def dfs(vertex):
        nears = [float('inf')] * (N + 1)
        depth = 0
        que = [[depth, vertex]]
        while que:
            d, v = heappop(que)
            if d < nears[v]:
                nears[v] = d
                for g in G[v]:
                    heappush(que, [d + 1, g])
        return nears

    for i in range(1, N):
        # dfs
        nears = dfs(i)
        # print(nears)
        for j in range(i + 1, N + 1):
            ans[nears[j]] += 1

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


if __name__ == '__main__':
    N, X, Y = list(map(int, input().split()))
    solve(N, X, Y)


# Optimized solution
# 解説を参考に作成


def solve(N, X, Y):
    ans = [0] * (N)

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

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


if __name__ == '__main__':
    N, X, Y = list(map(int, input().split()))
    solve(N, X, Y)
# Original solution
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)

import heapq
from collections import defaultdict
INF = float("inf")


class Graph(object):
    def __init__(self, N):
        self.N = N
        self.E = defaultdict(list)

    def add_edge(self, s, t, w=1):
        self.E[s].append((t, w))
        self.E[t].append((s, w))


def shortestPath(g: Graph, s: int):
    # 返り値 (dist, prev)
    # dist: 始点からの距離が格納されたリスト
    # prev: 始点から最短経路で移動する場合、各頂点に至る前の頂点のリスト
    dist = [INF]*g.N
    dist[s] = 0

    prev = [None]*g.N
    Q = []
    heapq.heappush(Q, (dist[s], s))

    while len(Q) > 0:
        _, u = heapq.heappop(Q)
        for v, w in g.E[u]:
            if dist[v] > dist[u] + w:
                dist[v] = dist[u] + w
                prev[v] = u
                heapq.heappush(Q, (dist[v], v))
    return dist, prev


def solve(N: int, X: int, Y: int):

    g = Graph(N)
    for i in range(1, N):
        g.add_edge(i-1, i)
    g.add_edge(X-1, Y-1)

    ans = [0]*N
    for i in range(N):
        dist, prev = shortestPath(g, i)
        for j, d in enumerate(dist):
            if i < j:
                ans[d] += 1
    print(*ans[1:], sep="\n")
    return


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
sys.setrecursionlimit(10**8)

import heapq
from collections import defaultdict
INF = float("inf")


def solve(N: int, X: int, Y: int):
    if X > Y:
        X, Y = Y, X
    ans = [0]*N
    for i in range(N):
        for j in range(i+1, N):
            d = min(abs(j-i), abs(i-(X-1))+1+abs(j-(Y-1)))
            ans[d] += 1
    print(*ans[1:], sep="\n")
    return


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
from collections import deque

n,x,y=list(map(int,input().split()))
g = [[i-1,i+1] for i in range(1,n-1)]
g.insert(0,[1])
g.append([n-2])
g[x-1].append(y-1)
g[y-1].append(x-1)
dist = []


def bfs(i):
    d = [float("inf")]*n
    
    que = deque([])
    que.append(i)
    d[i] = 0

    while que:
        idx = que.popleft()
        l = g[idx]
        
        for j in l:
            if d[j] == float("inf"):
                d[j] = d[idx] + 1
                que.append(j)
            elif d[j] > d[idx] + 1:
                d[j] = d[idx] + 1
                que.append(j)
    
    dist.extend(d)

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

dist.sort()
for i in range(1,n):
    print((dist.count(i)//2))


# 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):
		a = min(j-i, abs(x-i)+1+abs(y-j))
		ans[a-1] += 1
		
for i in range(n-1):
	print((ans[i]))
# Original solution
import bisect as bs

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

array = [[-1 for i in range(n)] for j in range(n)]

for i in range(n):
  for j in range(n):
    array[i][j] = abs(j-i)
    
for i in range(n):
  if array[i][x] == array[i][y]:
    pass
  
  elif array[i][x] > array[i][y]:
    array[i][x] = array[i][y] + 1
    
    index = x - 1
    while True:
      if index < 0 or array[i][index] <= array[i][index+1]:
        break
        
      array[i][index] = array[i][index+1] + 1
      index -= 1
      
    index = x + 1
    while True:
      if index >= n or array[i][index] <= array[i][index-1]:
        break
        
      array[i][index] = array[i][index-1] + 1
      index += 1
      
  else:
    array[i][y] = array[i][x] + 1
    
    index = y - 1
    while True:
      if index < 0 or array[i][index] <= array[i][index+1]:
        break
        
      array[i][index] = array[i][index+1] + 1
      index -= 1
      
    index = y + 1
    while True:
      if index >= n or array[i][index] <= array[i][index-1]:
        break
        
      array[i][index] = array[i][index-1] + 1
      index += 1
      
ans = [0] * (n+1)
for i in range(n):
  for j in range(i, n):
    tmp = array[i][j]
    ans[tmp] += 1
    
for i in range(1,n):
  print((ans[i]))
  

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

array1 = [0] * n
array2 = [0] * n

for i in range(x, y+1):
  array1[i] = min(i-x, y-i+1)
  array2[i] = min(i-x+1, y-i)

ans = [0] * (n+1)
dis = [[0 for i in range(n)] for i in range(n)]


for i in range(n):
  if i <= x:
    for j in range(i+1,n):
      if y <= j:
        tmp = (x-i) + (j-y) + 1
      elif j <= x:
        tmp = j-i
      else:
        tmp = (x-i) + array1[j]
        
      ans[tmp] += 1
      dis[i][j] = tmp
      
  elif y <= i:
    for j in range(i+1,n):
      ans[j-i] += 1
      dis[i][j] = j-i
      
  else:
    for j in range(i+1,n):
      if y <= j:
        tmp = (j-y) + array2[i]
      else:
        tmp = min(j-i, (y-x+1)-(j-i))
        
      ans[tmp] += 1
      dis[i][j] = tmp

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


def distance(i,j):
    d1 = abs(i-j)
    d2 = abs(i-x)+1+abs(j-y)
    d3 = abs(i-y)+1+abs(j-x)    
    d = min(d1,d2,d3)
    return d

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

for i in d:
    print(i)

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

for i in d:
    print(i)
# Original solution
from collections import deque, Counter


def bfs(start, graph):
    q = deque([(start, 0)])
    visited = set()

    while q:
        curr, dist = q.popleft()
        if curr not in visited:
            yield start, curr, dist
            visited.add(curr)
            for neighbor in graph[curr]:
                q.append((neighbor, dist + 1))


if __name__ == '__main__':
    n, x, y = tuple([int(i) for i in input().split()])
    graph = {i: [] for i in range(1, n + 1)}

    for i in range(1, n):
        graph[i].append(i + 1)
        graph[i + 1].append(i)
    graph[min(x, y)].append(max(x, y))
    graph[max(x, y)].append(min(x, y))

    dists = [0 for k in range(n)]
    distances = {}
    for i in range(1, n):
        for s, e, d in bfs(i, graph):
            if s != e:
                start = min(s, e)
                end = max(s, e)
                key = (start, end)
                if key in list(distances.keys()):
                    distances[key] = min(distances[key], d)
                else:
                    distances[key] = d

    dists = Counter(list(distances.values()))

    for k in range(1, n):
        print((dists[k] if k in list(dists.keys()) else 0))


# Optimized solution
def distance(i, j, x, y):
    return min([abs(j - i), abs(x - i) + 1 + abs(j - y), abs(y - i) + 1 + abs(j - x)])


if __name__ == '__main__':
    n, x, y = tuple([int(i) for i in input().split()])
    x, y = min(x, y), max(x, y)

    dists = [0 for k in range(n)]
    for i in range(1, n):
        for j in range(i + 1, n + 1):
            d = distance(i, j, x, y)
            dists[d] += 1

    for k in dists[1:]:
        print(k)
# Original solution
from collections import deque

ni = lambda: int(eval(input()))
nm = lambda: list(map(int, input().split()))
# nl = lambda: list(map(int, input().split()))

n,x,y=nm()

class Node:
  def __init__(self,x):
    self.val = x
    self.left=[]
    self.right=[]

nodes = [Node(i) for i in range(n)]
for i in range(n-1):
  nodes[i].right.append(nodes[i+1])
  nodes[i+1].left.append(nodes[i])

nodes[x-1].right.append(nodes[y-1])
nodes[y-1].left.append(nodes[x-1])

gl_dist = [0]*n


for i in range(n):
  dist = [-1]*n
  dist[i]=0
  q = deque()
  q.append(nodes[i])
  while len(q) > 0:
    node = q.popleft()
    nv = node.val
    nl = node.left
    nr = node.right

    for nli in nl:
      if dist[nli.val] == -1:
        dist[nli.val] = dist[nv]+1
        q.append(nli)
    for nri in nr:
      if dist[nri.val] == -1:
        dist[nri.val] = dist[nv]+1
        q.append(nri)

  for j in range(i+1,n):
    # print("{} to {} is {}".format(i,j,dist[j]))
    if dist[j] != -1:
      gl_dist[dist[j]]+=1

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


# Optimized solution
ni = lambda: int(eval(input()))
nm = lambda: list(map(int, input().split()))
nl = lambda: list(map(int, input().split()))

n,x,y = nm()

dist = [0]*n

for i in range(1,n+1):
  for j in range(i+1,n+1):
    naive = j-i
    cand = naive
    if i<x:
      if x<=j<=y:
        cand = x-i+1+y-j
      elif j>y:
        cand = x-i+1+j-y
    elif x<=i<=y:
      if j<=y:
        cand = i-x+1+y-j
      else:
        cand = i-x+1+j-y
    d = min(naive,cand)
    dist[d]+=1

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

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


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

    X -= 1
    Y -= 1

    G = [[] for _ in range(N)]
    for i in range(N - 1):
        G[i].append(i + 1)
        G[i + 1].append(i)

    G[X].append(Y)
    G[Y].append(X)

    count = [0] * N

    for i in range(N):
        dist = [-1] * N
        dist[i] = 0
        queue = deque([i])
        while queue:
            v = queue.popleft()
            for nv in G[v]:
                if dist[nv] == -1:
                    dist[nv] = dist[v] + 1
                    count[dist[nv]] += 1
                    queue.append(nv)

    ans = [c // 2 for c in count[1:]]
    print(('\n'.join(map(str, ans))))
    return


if __name__ == '__main__':
    main()


# Optimized solution
import sys
from collections import deque

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


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

    X -= 1
    Y -= 1

    ans = [0] * N

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

    print(('\n'.join(map(str, ans[1:]))))
    return


if __name__ == '__main__':
    main()