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

print(*ans[1:], sep='\n')


# Optimized solution
n, x, y = [int(i) for i in input().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)+abs(j-y)+1)] += 1

print(*ans[1:], sep='\n')
# Original solution
import heapq
def set_heapq(que, edge, used, v, add_dist=0):
    '''
    確定地点vからつながる辺を全てqueに設定し、返却する

    Parameters
    que : heapque(touple or list)
        辺を管理するキュー (距離、次の行き先)のtopuleまたはlistにて管理
    edge : list
        全ての辺を格納する二次元のリスト edge[0]にてノード0から伸びる辺であることを表し、
        edge[0] → [距離、次の行き先] を表すlistが格納されている
    v : int
        グラフ上のノード ダイクストラでは確定したノードがvにあたる
    add_dist : int
        確定した地点に足し合わせる距離 スタート地点以外では何かしらの値が追加されることになる

    Returns
    que : heapque(touple or list)
        引数queにvからつながる辺を追加したキュー
    '''
    for a,b in edge[v]:
        if used[b]:
            heapq.heappush(que,(a+add_dist,b))
    return que

def dijkstra_heap(n, s, edge):
    '''
    ダイクストラ法でsで指定された地点からの全てのノードまでの最短距離を返却
    
    Parameters
    n : int
        ノードの数
    s : int
        スタート地点
    edge : list
        全ての辺を格納する二次元のリスト edge[0]にてノード0から伸びる辺であることを表し、
        edge[0] → [距離、次の行き先] を表すlistが格納されている

    Returns
    d : list
        スタート地点から全てのノードの最短距離のリスト
    '''
    d = [float("inf")] * n
    used = [True] * n #True:未確定
    d[s], used[s] = 0, False
    edgelist = set_heapq([], edge, used, s)
    while len(edgelist):
        a, b = heapq.heappop(edgelist)
        #まだ使われてない頂点の中から最小の距離のものを探す
        if not used[b]:
            continue
        d[b], used[b] = a, False
        # 確定地点vからつながる辺を全て優先度付きキューに入れる
        edgelist = set_heapq(edgelist, edge, used, b, d[b])
    return d

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

edge[X].append((1, Y))
edge[Y].append((1, X))

tmp = []
for i in range(N):
    tmp.append(dijkstra_heap(N, i, edge))

#print(tmp)
ans = []
for i in range(N):
    for j in range(i+1,N):
        ans.append(tmp[i][j])

from collections import Counter
c = Counter(ans)
for i in range(1, N):
    print((c[i]))


# Optimized solution

from itertools import combinations
from collections import Counter
N, X, Y = list(map(int, input().split()))
X, Y = X-1, Y-1
ans = []
for i, j in combinations(list(range(N)), 2):
    ans.append(min(j-i, 1+abs(i-X)+abs(j-Y)))
c = Counter(ans)
for i in range(1,N):
    print((c[i]))
# Original solution
import sys
from itertools import combinations
from collections import Counter

N, X, Y = list(map(int, sys.stdin.readline().rstrip().split()))

nodes = list(range(1, N + 1))
distance_counter = Counter()
a = Y - X - 1
p = (Y - X) // 2 + X
ans = []
for i, j in combinations(nodes, 2):
    if j - i == 1:
        continue
    distance = min(abs(X - i) + abs(Y - j) + 1, j - i)
    distance_counter[distance] += 1

for k in range(1, N):
    if k == 1:
        ans.append(N)
    else:
        ans.append(distance_counter.get(k, 0))

print(('\n'.join(map(str, ans))))


# Optimized solution
import sys

N, X, Y = list(map(int, sys.stdin.readline().rstrip().split()))

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

for k in range(1, N):
    if k == 1:
        print(N)
    else:
        print((ans[k]))
# 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(1,N+1):
        if i != j:
            min_distance = min(abs(i-j), abs(i-X)+abs(j-Y)+1, abs(j-X)+abs(i-Y)+1)
            ans[min_distance-1] += 1
for i in range(N-1):
    print((int(ans[i]/2)))

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

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

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

graph = [[i-1,i+1] for i in range(n+1)]
graph[1]=[2]
graph[n]=[n-1]
graph[0]=[0]

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

def bfs(start,graph2):
    dist = [-1] * (n+1)
    dist[0] = 0
    dist[start] = 0

    d = deque()
    d.append(start)
    while d:
        v = d.popleft()
        for i in graph2[v]:
            if dist[i] != -1:
                continue
            dist[i] = dist[v] + 1
            d.append(i)
        
    dist = dist[start+1:]
    return dist

ans = [0]*n
for j in range(1,n):
    dist = bfs(j,graph)
    for k in range(1,n):
        ans[k] += dist.count(k)
    
for x in range(1,n):
    print((ans[x]))



# Optimized solution
from collections import deque

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

graph = [[i-1,i+1] for i in range(n+1)]
graph[1]=[2]
graph[n]=[n-1]
graph[0]=[0]

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

def bfs(start,graph2):
    dist = [-1] * (n+1)
    dist[0] = 0
    dist[start] = 0

    d = deque()
    d.append(start)
    while d:
        v = d.popleft()
        for i in graph2[v]:
            if dist[i] != -1:
                continue
            dist[i] = dist[v] + 1
            d.append(i)
        
    dist = dist[start+1:]
    return dist

ans=[0 for _ in range(n-1)]
for i in range(1,n+1):
    for j in bfs(i,graph):
        ans[j-1] +=1
 
for i in ans:
    print(i)
# Original solution
from collections import Counter
n,x,y = list(map(int, input().split()))
x -= 1
y -= 1
ans = [0]*n
dp = [[0]*n for _ in range(n)]
for i in range(n):
    for j in range(n):
         ans[min(abs(i-j),(abs(i-x)+abs(j-y)+1),(abs(i-y)+abs(j-x)+1))]+=1
for k in range(1,n):
    print((ans[k]//2))

# Optimized solution
from collections import Counter
n,x,y = list(map(int, input().split()))
x -= 1
y -= 1
ans = [0]*n
dp = [[0]*n for _ in range(n)]
for i in range(n):
    for j in range(i,n):
         ans[min(abs(i-j),(abs(i-x)+abs(j-y)+1),(abs(i-y)+abs(j-x)+1))]+=1
for k in range(1,n):
    print((ans[k]))
# Original solution
import sys
input = lambda: sys.stdin.readline().rstrip()
from collections import deque

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

edges = [[] for _ in range(N)]

for i in range(N-1):
    edges[i].append(i+1)
    edges[i+1].append(i)


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

ans = [0] * (N-1)

queue = deque([])

def bfs(start):
    queue.extend(edges[start])
    visited = [False] *  N
    visited[start] = True
    i = 0
    while queue:
        length = len(queue)
        for l in range(length):
            current = queue.popleft()
            if not visited[current]:
                ans[i] += 1
                if edges[current]:
                    queue.extend(edges[current])
                visited[current] = True    
        i += 1

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

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


# Optimized solution
import sys
input = lambda: sys.stdin.readline().rstrip()
from collections import deque

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

queue = deque()

edges = [[] for _ in range(N)]

for i in range(N-1):
    edges[i].append(i+1)
    edges[i+1].append(i)

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

ans = [0] * N

for i in range(N):
    visited = [0] * N
    visited[i] = 1
    queue.append((i,0))
    while queue:
        current, dist = queue.popleft()
        ans[dist] += 1

        for e in edges[current]:
            if visited[e] != 1:
                queue.append((e, dist+1))
                visited[e] = 1

ans = ans[1:]
for a in ans:
    print((a//2))
# Original solution
"""
import random
import functools
import copy
import bisect
import array
import re
import collections
import heapq
import fractions
import itertools
import string
import math
from operator import itemgetter as ig
from bisect import bisect_left, bisect_right, insort_left, insort_right
from itertools import permutations, combinations, product, accumulate, groupby
from heapq import heappush, heappop
from collections import deque, defaultdict, Counter
import sys
sys.setrecursionlimit(10 ** 7)
# import numpy as np

inf = 10 ** 20
INF = float("INF")
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = dd + [(-1, 1), (1, 1), (1, -1), (-1, -1)]
ddn9 = ddn + [(0, 0)]
'''for dx, dy in dd:
        nx = j + dx; ny = i + dy
            if 0 <= nx < w and 0 <= ny < h:'''
"""
from collections import deque
from collections import deque, defaultdict, Counter
import math
import sys
sys.setrecursionlimit(10 ** 7)


def wi(): return list(map(int, sys.stdin.readline().split()))
# WideIntPoint


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


def ws(): return sys.stdin.readline().split()


def si(): return int(sys.stdin.readline())  # SingleInt


def ss(): return eval(input())


def hi(n): return [si() for _ in range(n)]


def hs(n): return [ss() for _ in range(n)]  # HeightString


def s_list(): return list(eval(input()))


def mi(n): return [wi() for _ in range(n)]  # MatrixInt


def mip(n): return [wip() for _ in range(n)]


def ms(n): return [ws() for _ in range(n)]


def num_grid(n): return [[int(i) for i in sys.stdin.readline().split()[
    0]] for _ in range(n)]  # NumberGrid


def grid(n): return [s_list() for _ in range(n)]


def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

# a/b の切り上げ


def round_up(a, b):
    """ a/b の切り上げ """
    c = (a + b - 1) / b
    return c


def lcm(a, b):
    """a,bの最小公倍数"""
    return a * b // gcd(a, b)


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

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

#print(G)

d = [0] * N

for i in range(1, N+1):
    q = deque()
    q.append(i)
    visit = [-1]*N
    visit[i-1] = 0
    while q:
        p = q.popleft()
        for next_p in G[p]:
            if visit[next_p-1] == -1:
                visit[next_p-1] = visit[p-1] + 1
                q.append(next_p)

    for l in range(N):
        d[visit[l]] += 1

for k in range(1, N):
    print((d[k]//2))


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

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

for i in range(1, N):
    print((d[i]))
# Original solution
import queue
N,X,Y=list(map(int,input().split()))
X -= 1
Y -= 1
INF = 1001001001
ans=[0]*N
def push(v, d):
  if dist[v]!= INF:
    return
  dist[v]=d
  q.put(v)

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

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

count=[0]*N

def bfs(start):
    dist=[-1]*(N+1)#indexと頂点の番号を合わせる
    q=queue.Queue()
    q.put([start,0])
    dist[start]=0
    while not q.empty():
        j,kyori=q.get()

        if j-1>=1:
            if dist[j-1]==-1:
                q.put([j-1,kyori+1])
                dist[j-1]=kyori+1

        if j+1<=N:
            if dist[j+1]==-1:
                q.put([j+1,kyori+1])
                dist[j+1]=kyori+1
        
        if j == X and dist[Y]==-1:
            q.put([Y,kyori+1])
            dist[Y]=kyori+1

        if j == Y and dist[X]==-1:
            q.put([X,kyori+1])
            dist[X]=kyori+1

    return dist[1:]

def main():
    for start in range(1,N+1):
        #dist=bfs(start)
        for d in bfs(start):
            count[d]+=1

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

main()

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

count=[0]*N

def bfs(start):
    dist=[-1]*(N+1)#indexと頂点の番号を合わせる
    q=deque()
    q.append([start,0])
    dist[start]=0
    while q:
        j,kyori=q.popleft()

        if j-1>=1:
            if dist[j-1]==-1:
                q.append([j-1,kyori+1])
                dist[j-1]=kyori+1

        if j+1<=N:
            if dist[j+1]==-1:
                q.append([j+1,kyori+1])
                dist[j+1]=kyori+1
        
        if j == X and dist[Y]==-1:
            q.append([Y,kyori+1])
            dist[Y]=kyori+1

        if j == Y and dist[X]==-1:
            q.append([X,kyori+1])
            dist[X]=kyori+1

    return dist[1:]

def main():
    for start in range(1,N+1):
        dist=bfs(start)
        for d in dist:
            count[d]+=1

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

main()
# Original solution
from collections import Counter, deque, defaultdict

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

v = defaultdict(list)
for i in range(n):
    if i + 1 < n: v[i].append(i + 1)
    if i - 1 >= 0: v[i].append(i - 1)
v[x - 1].append(y - 1)
v[y - 1].append(x - 1)

cnt = Counter()
for start in range(n):
    dist = [float("inf")] * n
    q = deque()
    q.append([start, 0])
    while q:
        c, d = q.popleft()
        for next in v[c]:
            if dist[next] == float("inf"):
                q.append([next, d + 1])
                dist[next] = d + 1
    cnt += Counter(dist[start + 1:])

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


# Optimized solution
from collections import Counter, deque, defaultdict


def main():
    n, x, y = list(map(int, input().split()))
    v = defaultdict(list)
    for i in range(n):
        if i + 1 < n: v[i].append(i + 1)
        if i - 1 >= 0: v[i].append(i - 1)
    v[x - 1].append(y - 1)
    v[y - 1].append(x - 1)

    cnt = Counter()
    for start in range(n):
        dist = [-1] * n
        q = deque()
        q.append([start, 0])
        while q:
            c, d = q.popleft()
            for next in v[c]:
                if dist[next] == -1:
                    q.append([next, d + 1])
                    dist[next] = d + 1
        cnt += Counter(dist[start + 1:])

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


if __name__ == '__main__':
    main()
# Original solution
  
n, x, y = list(map(int, input().split()))
x -= 1
y -= 1
d= [[float('inf')]*n for _ in range(n)]
for i in range(n-1):
  if i == 0:
    d[0][1] = 1
    d[n-1][n-2] = 1
  else:
    d[i][i+1] = 1
    d[i][i-1] = 1
for i in range(n):
  d[i][i] = 0

d[x][y] = 1
d[y][x] = 1
def warshall_floyd(d):
  #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

d = warshall_floyd(d)
  
from collections import defaultdict
di = defaultdict(int)
for i in range(n):
  for j in range(i+1, n):
    di[d[i][j]] += 1 

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

# Optimized solution
from collections import deque 
from collections import defaultdict
n, x, y = list(map(int, input().split()))
graph = [[] for _ in range(n)]     
for i in range(n-1):
  graph[i] += [i+1]
  graph[i+1] += [i]
graph[x-1] += [y-1]
graph[y-1] += [x-1]
moves = ((1, 0), (0, 1), (0, -1), (-1, 0)) 

def bfs(s):
  dist = [float('inf')]*n
  dist[s] = 0
  q = deque([s])

  while q:
    u = q.popleft() 
    for v in graph[u]:
      if dist[v] == float('inf'):
        q += [v]
        dist[v] = dist[u] + 1

  return dist

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

for i in range(1, n):
  if i in list(ans.keys()):
    print((ans[i]))
  else:
    print((0))
# Original solution
N, X, Y = list(map(int, input().split()))
X -= 1
Y -= 1
edge = []
for i in range(N):
    edge.append([])
    if i != 0:
        edge[i].append(i - 1)
    if i != N-1:
        edge[i].append(i + 1)
edge[X].append(Y)
edge[Y].append(X)

answer = [0] * (N - 1)
for i in range(N):
    queue = []
    for e in edge[i]:
        queue.append(e)
    counter = 0
    d = [N + 10] * N
    d[i] = 0
    # i is start
    while counter < len(queue):
        node = queue[counter]
        min_dist = N + 10
        for e in edge[node]:
            min_dist = min(d[e], min_dist)
        d[node] = min_dist + 1
        for e in edge[node]:
            if d[e] == N+10:
                queue.append(e)
        counter += 1
    for i in d:
        answer[i] += 1
for a in answer[1:]:
    print((a//2))
print('0')

# Optimized solution
N, X, Y = list(map(int, input().split()))
X -= 1
Y -= 1
edge = []
for i in range(N):
    edge.append([])
    if i != 0:
        edge[i].append(i - 1)
    if i != N-1:
        edge[i].append(i + 1)
edge[X].append(Y)
edge[Y].append(X)

answer = [0] * (N - 1)
for i in range(N):
    queue = []
    for e in edge[i]:
        queue.append(e)
    counter = 0
    d = [N + 10] * N
    d[i] = 0
    # i is start
    while counter < len(queue):
        node = queue[counter]
        min_dist = N + 10
        for e in edge[node]:
            if d[e] < min_dist:
                min_dist = d[e]
            if d[e] == N + 10:
                queue.append(e)
        d[node] = min_dist + 1
        counter += 1
    for i in d:
        answer[i] += 1
for a in answer[1:]:
    print((a//2))
print('0')
# Original solution
import queue

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

to = [[] * N for i in range(N)]

for i in range(N-1):
    to[i].append(i+1)
    to[i+1].append(i)

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

ans = [0] * N

for i in range(N):
    dis = [0] * N
    dis[i] = 0
    visited = [False] * N
    q = queue.Queue()
    q.put(i)
    visited[i] = True

    while not q.empty():
        tmp_v = q.get()
        for j in to[tmp_v]:
            if not visited[j]:
                dis[j] = dis[tmp_v] + 1
                visited[j] = True
                q.put(j)

    for j in range(N):
        ans[dis[j]] += 1

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

# Optimized solution
from collections import deque

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

to = [[] * N for i in range(N)]

for i in range(N-1):
    to[i].append(i+1)
    to[i+1].append(i)

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

ans = [0] * N

for i in range(N):
    dis = [0] * N
    dis[i] = 0
    visited = [False] * N
    q = deque([])
    q.append(i)
    visited[i] = True

    while len(q) != 0:
        tmp_v = q.popleft()
        for j in to[tmp_v]:
            if not visited[j]:
                dis[j] = dis[tmp_v] + 1
                visited[j] = True
                q.append(j)

    for j in range(N):
        ans[dis[j]] += 1

for i in range(1,N):
    print((ans[i]//2))
# Original solution
from collections import deque
N,X,Y = map(int,input().split())
edge = [[] for _ in range(N)]
for i in range(N):
    if i == 0:
        edge[i].append(i+1)
    elif i == N-1:
        edge[i].append(i-1)
    else:
        edge[i].append(i-1)
        edge[i].append(i+1)
edge[X-1].append(Y-1)
edge[Y-1].append(X-1)

ans = [0]*(N-1)

for i in range(N):
    visited = [0]*N
    dist = [0]*N
    q = deque([i])#i番目のノードを根とする探索
    visited[i] = 1
    while q:
        now = q.popleft()
        for connection in edge[now]:
            if visited[connection]:
                dist[connection] = min(dist[connection],dist[now]+1)
            else:
                visited[connection] = 1
                dist[connection] = dist[now] + 1
                q.append(connection)
    for d in dist:
        if d == 0:
            continue
        ans[d-1] += 1
ans = list(map(lambda x: x//2,ans))
print(*ans,sep="\n")


# Optimized solution
from collections import deque
import sys
input = sys.stdin.readline

def main():
    N,X,Y = map(int,input().split())
    edge = [[] for _ in range(N)]
    for i in range(N):
        if i == 0:
            edge[i].append(i+1)
        elif i == N-1:
            edge[i].append(i-1)
        else:
            edge[i].append(i-1)
            edge[i].append(i+1)
    edge[X-1].append(Y-1)
    edge[Y-1].append(X-1)
    
    ans = [0]*(N-1)
    
    for i in range(N):
        visited = [0]*N
        dist = [0]*N
        q = deque([i])#i番目のノードを根とする探索
        visited[i] = 1
        while q:
            now = q.popleft()
            for connection in edge[now]:
                if visited[connection]:
                    dist[connection] = min(dist[connection],dist[now]+1)
                else:
                    visited[connection] = 1
                    dist[connection] = dist[now] + 1
                    q.append(connection)
        for d in dist:
            if d == 0:
                continue
            ans[d-1] += 1
    ans = list(map(lambda x: x//2,ans))
    print(*ans,sep="\n")
if __name__ == '__main__':
    main()
# Original solution
N,X,Y=list(map(int,input().split()))
G=[]
for i in range(1,N):
    G.append([i,i+1])
G.append([X,Y])
graph=[[] for i in range(N+1)]
for i in range(N):
    u,*v=G[i]
    v.sort()
    for j in v:
        graph[u].append(j)
        graph[j].append(u)
counter=[[] for i in range(N+1)]
for j in range(1,N+1):
    stack=[j]
    visited=[-1 for i in range(N+1)]
    visited[j]=0
    while stack:
        n=stack.pop(0)
        for i in graph[n]:
            n_n=i
            if visited[n_n]<0:
                visited[n_n]=visited[n]+1
                stack.append(n_n)
    for i,value in enumerate(visited):
        for k in range(1,N):
            if value==k:
                counter[k].append([j,i])
for i,value in enumerate(counter):
    if not (i==0 or i==N):
        print((int(len(value)/2)))

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

# Optimized solution
N,X,Y=list(map(int,input().split()))
A=[0 for i in range(N)]
for i in range(1,N):
    for j in range(i+1,N+1):
        A[int(min(j-i,abs(X-i)+abs(Y-j)+1))]+=1  
del A[0]
print(*A,sep=('\n'))
# Original solution
n,x,y = list(map(int,input().split()))
a = [0 for _ in range(n-1)]
for i in range(1,n):
  for j in range(i+1,n+1):
    l = min(j-i,abs(x-i)+1+abs(j-y))
    a[l-1] += 1
print(("\n".join(map(str,a))))

# Optimized solution
def main():
  n,x,y = list(map(int,input().split()))
  a = [0 for _ in range(n-1)]
  for i in range(1,n):
    for j in range(i+1,n+1):
      l = min(j-i,abs(x-i)+1+abs(j-y))
      a[l-1] += 1
  print(("\n".join(map(str,a))))

main()