CodeEff/ECCO huggingface dataset:
# Original solution
import sys
import itertools
import queue
input = sys.stdin.readline
sys.setrecursionlimit(100000)
mod = 10 ** 9 + 7

def read_values(): return list(map(int, input().split()))
def read_index(): return [int(x) - 1 for x in input().split()]
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]


class V:
    def __init__(self, f, v=None):
        self.f = f
        self.v = v
 
    def __str__(self):
        return str(self.v)
 
    def ud(self, n):
        if self.v is None:
            self.v = n
        else:
            self.v = self.f(self.v, n) 


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

    for i in range(N):
        q = queue.Queue()
        q.put((i, 0))
        close = set()
        while not q.empty():
            s, c = q.get()
            if s in close:
                continue
            
            close.add(s)
            res[c] += 1

            if s + 1 < N and s + 1 not in close:
                q.put((s + 1, c + 1))
            if s > 0 and s - 1 not in close:
                q.put((s - 1, c + 1))
            if s == X and Y not in close:
                q.put((Y, c + 1))
            if s == Y and X not in close:
                q.put((X, c + 1))

    res = [str(l // 2) for l in res[1:]]
    print(("\n".join(res)))


if __name__ == "__main__":
    main()


# Optimized solution
import sys
import itertools
import queue
input = sys.stdin.readline
sys.setrecursionlimit(100000)
mod = 10 ** 9 + 7

def read_values(): return list(map(int, input().split()))
def read_index(): return [int(x) - 1 for x in input().split()]
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]


class V:
    def __init__(self, f, v=None):
        self.f = f
        self.v = v
 
    def __str__(self):
        return str(self.v)
 
    def ud(self, n):
        if self.v is None:
            self.v = n
        else:
            self.v = self.f(self.v, n) 


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

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

            res[d] += 1

    for r in res[1:]:
        print(r)


if __name__ == "__main__":
    main()
# Original solution
n, x, y = list(map(int, input().split()))
lis = []
for i in range(1, n):
    for j in range(i+1, n+1):
        lis.append(min([j-i, abs(x-i)+1+abs(y-j), abs(y-i)+1+abs(x-j)]))
for i in range(1, n):
    print((lis.count(i)))

# Optimized solution
n, x, y = list(map(int, input().split()))
lis = [0]*(n-1)
for i in range(1, n):
    for j in range(i+1, n+1):
        lis[min([j-i, abs(x-i)+1+abs(y-j), abs(y-i)+1+abs(x-j)])-1] += 1
for i in range(n-1):
    print((lis[i]))
# Original solution
import queue
def main():
    n, x, y = list(map(int, input().split()))
    x -= 1
    y -= 1
    ans = [0]*n
    t = [[i+1, i-1] for i in range(n)]
    t[x].append(y)
    t[y].append(x)
    for i in range(n):
        for j in range(i+1, n):
            if j <= x:
                ans[j-i] += 1
            elif j <= y:
                buf = min(j-i, abs(i-x) + 1 + (y-j))
                ans[buf] += 1
            else:
                buf = min(y-i, abs(x-i)+1)
                ans[buf + (j-y)] += 1
    for i in range(1, n):
        print((ans[i]))
if __name__ == "__main__":
    main()

# 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):
            ans[min(j-i, abs(x-i)+abs(y-j)+1)] += 1
    for v in ans[1:]:
        print(v)

if __name__ == "__main__":
    main()
# Original solution
import sys
read = sys.stdin.read
from itertools import chain
from collections import Counter
def main():
    def warshall_floyd(d):
        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])
        # 更新したdを返す。d[i][j]はノードiからノードjまでの最短距離
        # 行きつけないノードはinfになる。
        # 負閉路があるなら「ノードｖからノードｖへのコスト」、つまりd[x][x]がマイナス値になる。
        return d

    # 入力
    n, x, y = list(map(int, input().split()))
    # ワーシャルフロイドで更新する変数dをつくる
    d = [[float("inf")] * n for _ in range(n)]
    d[x - 1][y - 1] = 1
    d[y - 1][x - 1] = 1
    for i1 in range(n-1):
        d[i1][i1+1] = 1
        d[i1+1][i1] = 1
    for j1 in range(n):
        d[j1][j1] = 0

    # ワーシャルフロイド実行。
    res = warshall_floyd(d)
    res1d = chain.from_iterable(res)
    res1dc = Counter(res1d)
    for i1 in range(1, n):
        r = res1dc[i1] // 2
        print(r)

if __name__ == '__main__':
    main()

# Optimized solution
from collections import defaultdict
def main():
    n, x, y = list(map(int, input().split()))
    x -= 1
    y -= 1
    klist = defaultdict(int)
    for i in range(n):
        for j in range(i+1, n):
            if (i <= x and j <= x) or (y <= i and y <= j):
                k = j - i
                klist[k] += 1
            elif i <= x and x < j <= y:
                k = min(j - i, (x - i + y - j) + 1)
                klist[k] += 1
            elif i <= x and y <= j:
                k = (j - i) - (y - x) + 1
                klist[k] += 1
            else:
                k = min((j - i), ((i - x) + abs(y - j) + 1))
                klist[k] += 1
    for i1 in range(1, n):
        print((klist[i1]))

if __name__ == '__main__':
    main()
# Original solution
# D - Line++
def main():
    N, X, Y = list(map(int, input().split()))
    dist = [0] * N
    calc_min_dist = lambda x, y: min(
        y - x, abs(X - x) + abs(y - Y) + 1, abs(Y - x) + abs(y - X) + 1
    )
    for i in range(1, N + 1):
        for j in range(i + 1, N + 1):
            dist[calc_min_dist(i, j)] += 1
    print(("\n".join(map(str, dist[1:]))))


if __name__ == "__main__":
    main()


# Optimized solution
# D - Line++
def main():
    N, X, Y = list(map(int, input().split()))
    dist = [0] * N
    calc_min_dist = lambda x, y: min(
        y - x, abs(X - x) + abs(y - Y) + 1, abs(Y - x) + abs(y - X) + 1
    )  # assume x < y
    for i in range(1, N + 1):
        for j in range(i + 1, N + 1):
            dist[calc_min_dist(i, j)] += 1
    print(("\n".join(map(str, dist[1:]))))


if __name__ == "__main__":
    main()
# Original solution
# D - Line++
def main():
    N, X, Y = list(map(int, input().split()))
    dist_cnt = [0] * N
    calc_min_dist = lambda x, y: min(y - x, abs(X - x) + abs(Y - y) + 1)  # assume x < y
    for i in range(1, N + 1):
        for j in range(i + 1, N + 1):
            dist_cnt[calc_min_dist(i, j)] += 1
    print(("\n".join(map(str, dist_cnt[1:]))))


if __name__ == "__main__":
    main()


# Optimized solution
# D - Line++
def main():
    N, X, Y = list(map(int, input().split()))
    dist_cnt = [0] * N
    for i in range(1, N + 1):
        for j in range(i + 1, N + 1):
            dist_cnt[min(j - i, abs(X - i) + abs(j - Y) + 1)] += 1
    print(("\n".join(map(str, dist_cnt[1:]))))


if __name__ == "__main__":
    main()
# Original solution
n,x,y = list(map(int,input().split()))
arr = [0] * (n-1)

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

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

ans = [0] * (n-1)

for i in range(1,n):
    for j in range(i+1,n+1):
        ans[min((j-i),abs(i-x)+1+abs(j-y),abs(i-y)+1+abs(j-x))-1] += 1
        
for i in ans:
    print(i)
# Original solution
#!/usr/bin/env python
# coding: utf-8

# In[18]:


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


# In[19]:


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


# In[ ]:






# Optimized solution
#!/usr/bin/env python
# coding: utf-8

# In[21]:


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


# In[24]:


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


# In[ ]:
# Original solution
import sys
import itertools
from collections import Counter

sys.setrecursionlimit(10**6)

def DFS(i,v,d):
  global dist
  
  if d > N:
    return
  # 頂点vに隣接する頂点でvより大きいものが未発見
  for u in adj[v]:
    # distは最短距離なので上書き禁止
    if i != u:
      #print(i,u,d)
      if dist[i][u] > d:
        dist[i][u] = d
        dist[u][i] = d
        # その先は追加で探索
      DFS(i,u,d+1)

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

# 隣接リストを作成する
adj = [[] for _ in range(N)]

# adjに入力
for i in range(N-1):
  adj[i].append(i+1)
  adj[i+1].append(i)

# X,Yをadj入力
adj[X-1].append(Y-1)
adj[Y-1].append(X-1)

# 頂点間の最短距離を保持するdist
dist = [[10**9 for _ in range(N)] for _ in range(N)]
for i in range(N):
  DFS(i,i,1)

  
# print(dist)
# distを１次元化
dist = list(itertools.chain.from_iterable(dist))
c = Counter(dist)

# 結果出力
for k in range(1,N):
  print((c[k]//2))
  

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

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

for k in range(1,N):
  print((ans[k]))
# Original solution
import heapq


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


class Graph:
    def __init__(self):
        self.edge = {}
        self.cost = {}
        self.vertex = set()
        return

    def addEdgeCost(self, i, j, c, directed=False):
        self.vertex.add(i)
        self.vertex.add(j)

        if i not in self.edge:
            self.edge[i] = []
        self.edge[i].append(j)
        self.cost[(i, j)] = c

        if directed is False:
            return

        if j not in self.edge:
            self.edge[j] = []
        self.edge[j].append(i)
        self.cost[(j, i)] = c
        return


def dijkstra(g: Graph, s=None) -> dict:
    def solve(v_start):
        ret_cost = {v: float("inf") for v in g.vertex}
        ret_cost[v_start] = 0
        heap = [(0, v_start)]

        while heap:
            _, v_from = heapq.heappop(heap)
            for v_to in g.edge.get(v_from, []):
                nc = ret_cost[v_from] + g.cost[(v_from, v_to)]
                if ret_cost[v_to] > nc:
                    ret_cost[v_to] = nc
                    heapq.heappush(heap, (nc, v_to))
        return ret_cost

    if s is None:
        V = g.vertex
    else:
        V = [s]

    ret = {}
    for v in V:
        ret[v] = solve(v)
    return ret


N, X, Y = inpl()

G = Graph()
for i in range(N - 1):
    G.addEdgeCost(i, i + 1, 1, directed=True)
G.addEdgeCost(X - 1, Y - 1, 1, directed=True)

ans_dict = {}
for g in list(dijkstra(G).values()):
    for v in list(g.values()):
        ans_dict[v] = ans_dict.get(v, 0) + 1

for i in range(1, N):
    print((ans_dict.get(i, 0) // 2))


# Optimized solution
def inpl():
    return list(map(int, input().split()))


N, X, Y = inpl()
X -= 1
Y -= 1
ans = {}
for i in range(N):
    for j in range(i + 1, N):
        c = min(j - i, abs(i - X) + 1 + abs(j - Y), abs(i - Y) + 1 + abs(j - X))
        ans[c] = ans.get(c, 0) + 1

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

# Optimized solution
n,x,y=list(map(int,input().split()))
x+=-1
y+=-1
k=[]
z=0
for i in range(n):
  k.append(0)
for i in range(n-1):
  for j in range(i+1,n):
    z=min(abs(x-i)+1+abs(j-y),abs(y-i)+1+abs(j-x),j-i)
    k[z]+=1
    z=0
for i in range(1,n):
  print((k[i]))
# Original solution
N,X,Y = list(map(int,input().split()))
cc = []
for i in range(1,N+1):
  for j in range(i+1,N+1):
    cc.append(min(j-i,abs(X-i)+1+abs(Y-j)))
for i in range(1,N):
  print((cc.count(i)))

# Optimized solution
N,X,Y = list(map(int,input().split()))
cc = [0]*(N-1)
for i in range(1,N+1):
  for j in range(i+1,N+1):
    cc[min(j-i,abs(X-i)+1+abs(Y-j))-1] += 1
for i in cc:
  print(i)
# Original solution
n,x,y = list(map(int,input().split()))
cnt_l = [0 for i in range(0,n)]
from collections import deque
def bfs(start):
    queue = deque()
    queue.append([start,0])
    isNotSearched = [False]*(n+1)
    
    while(len(queue)>0):
        i,cnt = queue.popleft()
        
        if(isNotSearched[i]):
            continue
        
        isNotSearched[i]=True
        cnt_l[cnt]+=1
        pre = (i-1)
        nex = (i+1)
        if(i==x):
            queue.append([y,cnt+1])
        if(i==y):
            queue.append([x,cnt+1])
        if(pre>=1):
            queue.append([pre,cnt+1])
        if(nex<=n):
            queue.append([nex,cnt+1])
            
        
 
        
for i in range(1,n+1):
    bfs(i)
 
 
for i in range(1,n):
    print((cnt_l[i]//2))

# Optimized solution
n,x,y = list(map(int,input().split()))
cnt_l = [0]*n
from collections import deque
def bfs(start):
    queue = deque()
    queue.append([start,0])
    isSearched = [False]*(n+1)
    
    while(len(queue)>0):
        i,cnt = queue.popleft()
        
        if(isSearched[i]):
            continue
        
        isSearched[i]=True
        cnt_l[cnt]+=1
        
        if(i==x):
            nex_l = (i-1,y,i+1)
        elif(i==y):
            nex_l = (i-1,x,i+1)
        else:
            nex_l = (i-1,i+1)

        for j in nex_l:
            if(j < 1 or n < j):
                continue
            if(isSearched[j]):
                continue
            queue.append([j,cnt+1])
            
        
 
        
for i in range(1,n+1):
    bfs(i)
 
 
for i in range(1,n):
    print((cnt_l[i]//2))
# Original solution
n,x,y = list(map(int,input().split()))
cnt_l = [0]*n
from collections import deque
def bfs(start):
    queue = deque()
    queue.append([start,0])
    isSearched = [False]*(n+1)
    
    while(len(queue)>0):
        i,cnt = queue.popleft()
        
        if(isSearched[i]):
            continue
        
        isSearched[i]=True
        cnt_l[cnt]+=1
        
        if(i==x):
            nex_l = (i-1,y,i+1)
        elif(i==y):
            nex_l = (i-1,x,i+1)
        else:
            nex_l = (i-1,i+1)

        for j in nex_l:
            if(j < 1 or n < j):
                continue
            if(isSearched[j]):
                continue
            queue.append([j,cnt+1])
            
        
 
        
for i in range(1,n+1):
    bfs(i)
 
 
for i in range(1,n):
    print((cnt_l[i]//2))

# Optimized solution
n,x,y = list(map(int,input().split()))
cnt_l = [0]*n
from collections import deque
def bfs(start):
    queue = deque()
    queue.append(start)
    isSearched = [-1]*(n+1)
    isSearched[start] = 0
    while(len(queue)>0):
        i = queue.popleft()
        cnt = isSearched[i]
        if(i==x):
            nex_l = (i-1,y,i+1)
        elif(i==y):
            nex_l = (i-1,x,i+1)
        else:
            nex_l = (i-1,i+1)

        cnt += 1
        for j in nex_l:
            if(j < 1 or n < j):
                continue
            if(isSearched[j]!=-1):
                continue
            queue.append(j)
            isSearched[j] = cnt
            cnt_l[cnt] += 1
            
        
 
        
for i in range(1,n+1):
    bfs(i)
 
 
for i in range(1,n):
    print((cnt_l[i]//2))
# Original solution
n,x,y = list(map(int,input().split()))
cnt_l = [0]*n
from collections import deque
def bfs(start):
    queue = deque()
    queue.append(start)
    isSearched = [-1]*(n+1)
    isSearched[start] = 0
    while(len(queue)>0):
        i = queue.popleft()
        cnt = isSearched[i]
        if(i==x):
            nex_l = (i-1,y,i+1)
        elif(i==y):
            nex_l = (i-1,x,i+1)
        else:
            nex_l = (i-1,i+1)

        cnt += 1
        for j in nex_l:
            if(j < 1 or n < j):
                continue
            if(isSearched[j]!=-1):
                continue
            queue.append(j)
            isSearched[j] = cnt
            cnt_l[cnt] += 1
            
        
 
        
for i in range(1,n+1):
    bfs(i)
 
 
for i in range(1,n):
    print((cnt_l[i]//2))

# Optimized solution
n,x,y = list(map(int,input().split()))
cnt_l = [0]*n
from collections import deque
def bfs(start):
    queue = deque()
    queue.append(start)
    isSearched = [-1]*(n+1)
    isSearched[start] = 0
    while(queue):
        i = queue.popleft()
        cnt = isSearched[i]
        if(i==x):
            nex_l = (i-1,y,i+1)
        elif(i==y):
            nex_l = (i-1,x,i+1)
        else:
            nex_l = (i-1,i+1)

        cnt += 1
        for j in nex_l:
            if(j < 1 or n < j):
                continue
            if(isSearched[j]!=-1):
                continue
            queue.append(j)
            isSearched[j] = cnt
            cnt_l[cnt] += 1
            
        
 
        
for i in range(1,n+1):
    bfs(i)
 
 
for i in range(1,n):
    print((cnt_l[i]//2))
# Original solution
from collections import Counter

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

x-=1
y-=1

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

c=Counter(dist)
for i in range(1,n):
  print((c[i]))

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

x-=1
y-=1

dist=[0 for i in range(n)]
for i in range(n-1):
  for j in range(i+1,n):
    dist[min(j-i,abs(x-i)+1+abs(y-j))]+=1
for i in dist[1:]:
  print(i)
# Original solution
# coding: utf-8

import sys
import math
import collections
import itertools
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(eval(input()))
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(eval(input())) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]

N, X, Y = LI()

dist = [[INF] * (N+1) for _ in range(N+1)]

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

for i in range(1, N):
    tmp = 0
    for d in dist:
        tmp += d.count(i)

    print(tmp)


# Optimized solution
# coding: utf-8

import sys
import math
import collections
import itertools
INF = 10 ** 10
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def gcd(x, y) : return y if x % y == 0 else gcd(y, x % y)
def lcm(x, y) : return (x * y) // gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def PL(L) : print(*L, sep="\n")

N, X, Y = LI()

ans = [0] * N

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

PL(ans[1:])
# Original solution
import sys


def input() -> str:
    return sys.stdin.readline().rstrip("\r\n")


def main():
    def min_dest(a, b):
        return min(b-a, abs(x-a)+1+abs(y-b), abs(x-b)+1+abs(y-a))

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

    for i in range(n):
        for j in range(i+1, n):
            ans[min_dest(i, j)-1] += 1
    for a in ans:
        print(a)


if __name__ == "__main__":

    main()


# Optimized solution
import sys


def input() -> str:
    return sys.stdin.readline().rstrip("\r\n")


def main():
    def min_dest(a, b):
        return min(b-a, abs(x-a)+1+abs(y-b))

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

    for i in range(n):
        for j in range(i+1, n):
            ans[min_dest(i, j)-1] += 1
    for a in ans:
        print(a)


if __name__ == "__main__":

    main()
# Original solution
K,X,Y = (int(x) for x in input().split())
num = K*(K-1)/2
distance = [0] *int(num)
ct = 0
for i in range(1,K):
    for j in range (i+1,K+1):
            distance[ct] = min(j-i,abs(i-X)+abs(j-Y)+1)
            ct += 1
for k in range (1,K):
    print((distance.count(k)))

# Optimized solution
K,X,Y = (int(x) for x in input().split())
ans = [0] * K
ct = 0
for i in range(1,K):
    for j in range (i+1,K+1):
            ans[min(j-i,abs(i-X)+abs(j-Y)+1)] += 1
for k in range (1,K):
    print((ans[k]))
# Original solution
n, x, y = list(map(int, input().split()))
a = []
for s in range(1, n): #start
    for g in range(s+1, n+1): #goal
        a.append(min(g-s, abs(x-s)+1+abs(g-y), abs(y-s)+1+abs(g-x)))

#print(a)
for i in range(1, n):
    print((a.count(i)))

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

#print(a)
for i in range(1, n):
    print((a[i]))
# Original solution
#６回目、2020-0612
#2重ループ　＋O(1)
#i,jがループの中か外で場合分け

#初期入力
N, x, y = list(map(int, input().split()))

ans ={i:[]for i in range(1,N)}
for i in range(1,N):
    for j in range(i+1,N+1):
         #（i,jがループより共に左、ともに右）
        if (j <=x or y <=i) :
            ans[j-i].append((i,j))
        # （iがループより左 and jがループより右）
        elif i <=x and y <=j:
            ans[x-i +1 +j-y].append((i,j))
        # i,jが共にループの中
        elif x <i and j <y:
            dist =min(j-i,i-x + y-j +1) #時計回りと反時計回りの短いほう、+1はxとyを結んだ部分
            ans[dist].append((i,j))
        # iがループより左、jがループの中
        elif i <=x and j < y:
            dist =x-i + min(j-x , y+1-j)
            ans[dist].append((i,j)) 
        # iがループの中、jがループの右
        elif x <i and y <=j:
            dist =min(y-i , 1 +i-x) + j-y
            ans[dist].append((i,j)) 

#答え出力
for i in range(1,N):        
    print((len(ans[i])))

# Optimized solution
#６回目、2020-0612
#2重ループ　＋O(1)
#i,jがループの中か外で場合分け

#初期入力
N, x, y = list(map(int, input().split()))

ans ={i:0 for i in range(1,N)}
for i in range(1,N):
    for j in range(i+1,N+1):
         #（i,jがループより共に左、ともに右）
        if (j <=x or y <=i) :
            ans[j-i] +=1
        # （iがループより左 and jがループより右）
        elif i <=x and y <=j:
            ans[x-i +1 +j-y] +=1
        # i,jが共にループの中
        elif x <i and j <y:
            dist =min(j-i,i-x + y-j +1) #時計回りと反時計回りの短いほう、+1はxとyを結んだ部分
            ans[dist] +=1
        # iがループより左、jがループの中
        elif i <=x and j < y:
            dist =x-i + min(j-x , y+1-j)
            ans[dist] +=1 
        # iがループの中、jがループの右
        elif x <i and y <=j:
            dist =min(y-i , 1 +i-x) + j-y
            ans[dist] +=1 

#答え出力
for i in range(1,N):        
    print((ans[i]))
# Original solution
#６回目、2020-0612
#2重ループ　＋O(1)
#i,jがループの中か外で場合分け

#初期入力
N, x, y = list(map(int, input().split()))

ans ={i:0 for i in range(1,N)}
for i in range(1,N):
    for j in range(i+1,N+1):
         #（i,jがループより共に左、ともに右）
        if (j <=x or y <=i) :
            ans[j-i] +=1
        # （iがループより左 and jがループより右）
        elif i <=x and y <=j:
            ans[x-i +1 +j-y] +=1
        # i,jが共にループの中
        elif x <i and j <y:
            dist =min(j-i,i-x + y-j +1) #時計回りと反時計回りの短いほう、+1はxとyを結んだ部分
            ans[dist] +=1
        # iがループより左、jがループの中
        elif i <=x and j < y:
            dist =x-i + min(j-x , y+1-j)
            ans[dist] +=1 
        # iがループの中、jがループの右
        elif x <i and y <=j:
            dist =min(y-i , 1 +i-x) + j-y
            ans[dist] +=1 

#答え出力
for i in range(1,N):        
    print((ans[i]))

# Optimized solution
#６回目、2020-0612
#2重ループ　＋O(1)
#場合分けを近道と通常のみ（絶対値を使う）

#初期入力
N, x, y = list(map(int, input().split()))
normal =0
short =0
ans ={i:0 for i in range(1,N)}
for i in range(1,N):
    for j in range(i+1,N+1):
         normal =j -i
         short  =abs(x-i) +1 +abs(j-y)
         dist =min(normal,short)
         ans[dist] +=1
      

#答え出力
for i in range(1,N):        
    print((ans[i]))
# 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):
        ans[min(min(j-i,abs(x-i)+1+abs(j-y)),abs(y-i)+1+abs(j-x))-1]+=1
for i in range(n-1):
    print((ans[i]))

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