We have an undirected graph G with N vertices numbered 1 to N and N edges as follows:
 - For each i=1,2,...,N-1, there is an edge between Vertex i and Vertex i+1.
 - There is an edge between Vertex X and Vertex Y.
For each k=1,2,...,N-1, solve the problem below:
 - Find the number of pairs of integers (i,j) (1 \leq i < j \leq N) such that the shortest distance between Vertex i and Vertex j in G is k.

-----Constraints-----
 - 3 \leq N \leq 2 \times 10^3
 - 1 \leq X,Y \leq N
 - X+1 < Y
 - All values in input are integers.

-----Input-----
Input is given from Standard Input in the following format:
N X Y

-----Output-----
For each k=1, 2, ..., N-1 in this order, print a line containing the answer to the problem.

-----Sample Input-----
5 2 4

-----Sample Output-----
5
4
1
0

The graph in this input is as follows:





There are five pairs (i,j) (1 \leq i < j \leq N) such that the shortest distance between Vertex i and Vertex j is 1: (1,2)\,,(2,3)\,,(2,4)\,,(3,4)\,,(4,5).


There are four pairs (i,j) (1 \leq i < j \leq N) such that the shortest distance between Vertex i and Vertex j is 2: (1,3)\,,(1,4)\,,(2,5)\,,(3,5).


There is one pair (i,j) (1 \leq i < j \leq N) such that the shortest distance between Vertex i and Vertex j is 3: (1,5).


There are no pairs (i,j) (1 \leq i < j \leq N) such that the shortest distance between Vertex i and Vertex j is 4.

Difficulty: interview

Starter code:

Solutions:
#!/usr/bin/env python3
import sys

input = sys.stdin.readline


def S():
    return input().rstrip()


def I():
    return int(input())


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


N, X, Y = MI()
cnt = [0] * N

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

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


import scipy.sparse as sparse
from scipy.sparse.csgraph import shortest_path 
import numpy as np

n, x, y = [int(i) for i in input().split()]
x -= 1
y -= 1

one = np.ones((2,n),dtype=int)
c = sparse.spdiags(one, np.array([-1, 1]), n, n, format='lil')

c[x, y], c[y, x] = 1, 1

c = c.tocsr()

path = shortest_path(c, directed=False, unweighted=True)

u, counts = np.unique(path, return_counts=True)
counts = counts//2

for i in range(1, int(u[-1])+1):
	print((counts[i]))
for i in range(int(u[-1])+1, n):
	print((0))



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)

def __starting_point():
    main()

__starting_point()

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

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

for i in ans:
  print(i)


def main():
  N, X, Y = map(int, input().split())
  G = [[i] for i in range(1,N+1)]
  ans=[0]*(N-1)
  for i in range(1,N+1):
    for j in range(i+1,N+1):
      d = min(j-i, abs(X-i)+1+abs(j-Y), abs(Y-i)+1+abs(j-X))
      #print(i,j,d)
      ans[d-1]+=1
  for a in ans:
    print(a)

def __starting_point():
  main()
__starting_point()

from collections import defaultdict
ans = defaultdict(int)
N, X, Y = map(int, input().split())
for i in range(1, N+1):
  for j in range(1+i, N+1):
    l1 = j-i
    l2 = abs(X-i) + 1 + abs(Y-j)
    ans[min(l1, l2)] += 1
for i in range(1, N):
  print(ans[i])

from itertools import *
from numpy import *
from scipy.sparse.csgraph import *
N,X,Y = map(int,input().split())
A = (N-1)*[0]
G = zeros((N,N))
G[X-1][Y-1] = 1
G[Y-1][X-1] = 1

for n in range(N-1):
  G[n][n+1] = 1
  G[n+1][n] = 1

S = shortest_path(G)

for i,j in combinations(range(N),2):
  A[int(S[i][j])-1]+=1

print(*A,sep="\n")

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

p = Y-X+1
arm_a = X-1
arm_b = N-Y

if p%2:
    for i in range(1, N):
        ans = 0

        if i*2 < p:
            ans += p
        
        if 1 < i <= p//2+arm_a:
            ans += 2*min(arm_a, p//2, arm_a+p//2-i+1, i-1)

        if 1 < i <= p//2+arm_b:
            ans += 2*min(arm_b, p//2, arm_b+p//2-i+1, i-1)

        if i <= arm_a:
            ans += arm_a-i+1

        if i <= arm_b:
            ans += arm_b-i+1

        if 2 < i <= arm_a+arm_b+1:
            ans += min(arm_a, arm_b, arm_a+arm_b-i+2, i-2)

        print(ans)
else:
    for i in range(1, N):
        ans = 0

        if i*2 < p:
            ans += p
        elif i*2 == p:
            ans += p//2

        if 1 < i < p//2+arm_a:
            ans += 2*min(arm_a, p//2-1, arm_a+p//2-i, i-1)
        if p//2 < i <= p//2+arm_a:
            ans += 1

        if 1 < i < p//2+arm_b:
            ans += 2*min(arm_b, p//2-1, arm_b+p//2-i, i-1)
        if p//2 < i <= p//2+arm_b:
            ans += 1

        if i <= arm_a:
            ans += arm_a-i+1

        if i <= arm_b:
            ans += arm_b-i+1

        if 2 < i <= arm_a+arm_b+1:
            ans += min(arm_a, arm_b, arm_a+arm_b-i+2, i-2)

        print(ans)

def main():

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

    cnt = 0

    ans=[0]*n

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

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

N,X,Y=map(int,input().split())
A=[0]*(N-1)
for i in range(1,N):
  for j in range(i+1,N+1):
    A[min(j-i,abs(X-i)+1+abs(j-Y),abs(Y-i)+1+abs(j-X))-1]+=1
for a in A:
  print(a)

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

for i in range(1,n+1):
    for j in range(i+1,n+1):
        dist1 = j-i
        dist2 = abs(x-i)+abs(y-j)+1
        dist3 = abs(y-i)+abs(x-j)+1
        d = min(dist1,dist2,dist3)
        b[d] += 1

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


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


def f(i, j):
    v1 = j - i
    v2 = abs(X - i) + 1 + abs(j - Y)
    v3 = abs(Y - i) + 1 + abs(j - X)
    return min(v1, v2, v3)


D = [0] * N
for i in range(1, N):
    for j in range(i + 1, N + 1):
        d = f(i, j)
        D[d] += 1

for d in D[1:]:
    print(d)


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

res = [0]*(N-1)

for i in range(1, N+1):
    for j in range(i+1, N+1):
        # i -> j
        d1 = abs(j - i)
        # i -> X -> Y -> j
        d2 = abs(X-i) + abs(Y-j) + 1
        # i -> Y -> X -> j
        d3 = abs(Y-i) + abs(X-j) + 1

        min_d = min(d1, d2, d3)
        res[min_d-1] += 1

print(*res, sep='\n')


import math
import itertools
def comb(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
N, X, Y =list(map(int,input().split()))

L = [i for i in range(1,N+1)]
c_list = list(itertools.combinations(L,2))

Answer = {}
for i in range(1,N):
    inti = str(i)
    Answer[inti] = 0
def des(a,b):
    if b <= X or a >=  Y:
        return (b-a)
    else:
        return min(b-a, abs(Y-b)+abs(X-a)+1)
for cl in c_list:
    a = cl[0]
    b = cl[1]
    inti = des(a,b)
    inti = str(inti)
    Answer[inti] += 1
for n, m in list(Answer.items()):
    print(m)


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

anss = [0] * N
for i in range(1, N+1):
    for j in range(i+1, N+1):
        d1 = j-i
        d2 = abs(i-X) + 1 + abs(Y-j)
        d = d1 if d1 <= d2 else d2
        anss[d] += 1

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


N, X, Y = map(int, input().split())
A = [N - i for i in range(1, N)]
for i in range(N-1):
  for j in range(i+1, N):
    c = min(abs(X-i-1)+abs(Y-j-1)+1, abs(X-j-1)+abs(Y-i-1)+1)
    if c < j-i:
      A[j-i-1] -= 1
      A[c-1] += 1
for a in A:
  print(a)

from collections import deque
from collections import Counter

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

graph = [[] for _ in range(n+1)]

for i in range(1,n):
  a,b = i,i+1
  graph[a].append(b)
  graph[b].append(a)
graph[x].append(y)
graph[y].append(x)

l = []
for j in range(1,n+1):
  dist = [-1] * (n+1)
  dist[0] = 0
  dist[j] = 0

  d = deque()
  d.append(j)

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

  l.extend(dist[1:])

c = Counter(l)
for i in range(1,n):
  print(int(c[i]/2))

n, x, y = list(map(int, input().split()))
ans = [0 for _ in range(n)]

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


n,x,y=list(map(int,input().split()))
dic={}
for i in range(1,n+1):
  for j in range(i+1,n+1):
    l=min(j-i,abs(x-i)+1+abs(y-j))
    if l in dic:
      dic[l]+=1
    else:
      dic[l]=1
for l in range(1,n):
  if l in dic:
    print((dic[l]))
  else:
    print((0))


N, X, Y = list(map(int, input().split()))
ds = [0] * (N - 1)

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))
        ds[d - 1] += 1

for d in ds:
    print(d)
return


import sys
from collections import deque
r=sys.stdin.readline
N,X,Y=map(int,r().split())
res=[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 bfs(start):
    q=deque([(start,0)])
    visited=[False]*(N+1)
    visited[start]=True
    cnt=0
    while q:
        cur,d=q.popleft()
        if d!=0:
            res[d]+=1
        for v in G[cur]:
            if not visited[v]:
                visited[v]=True
                q.append((v,d+1))
    return cnt
for i in range(1,N+1):
    bfs(i)
for j in range(1,N):    
    print(res[j]//2)

import sys
readline = sys.stdin.readline

N,X,Y = map(int,readline().split())
X -= 1
Y -= 1
ans = [0] * N
for i in range(N - 1):
  for j in range(i + 1, N):
    val = min(abs(i - j),abs(i - X) + 1 + abs(j - Y), abs(i - Y) + 1 + abs(j - X))
    ans[val] += 1
    
for i in range(1, len(ans)):
  print(ans[i])

N, X, Y = map(int, input().split())
L = [0]*(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(Y-j)))] += 1
for i in range(1, N):
  print(L[i])

n,x,y=list(map(int,input().split()))
x-=1
y-=1
half=(x+y)//2
ans=[0]*n
for i in range(n):
    for j in range(i,n):
        if i<=x:
            if j<=half:
                ans[j-i]+=1
            else:
                ans[x-i+1+abs(y-j)]+=1
        elif x<i and i<=y:
            ans[min(j-i,i-x+1+abs(y-j))]+=1
        else:
            ans[j-i]+=1
for i in range(1,n):
    print((ans[i]))


N, X, Y = map(int, input().split())
lst = [0 for i in range(N-1)]
for i in range(1, N+1):
    for j in range(i+1, N+1):
        k = min(abs(j-i), abs(X-i) + abs(Y-j) + 1)
        lst[k-1] += 1
for i in lst:
    print(i)

from collections import deque

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

ans_list = [0 for _ in range(N-1)]

for i in range(1, N+1): #1 ～ N start
    for j in range(i+1, N+1): # i+1 ～ N goal
        ans1 = j - i
        ans2 = abs(i-X) + 1 + abs(j-Y)
        ans_list[min(ans1, ans2)-1] += 1
print(*ans_list, sep="\n")

n, x, y = map(int, input().split())
counter = {i + 1: 0 for i in range(n - 1)}

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

print(*[counter[i + 1] for i in range(n - 1)], sep='\n')

def main():
    n, x, y = map(int, input().split())
    ans = [0] * (n+1)
    for i in range(1, n):
        for j in range(i+1, n+1):
            # x->yを通らない
            d1 = abs(j-i)
            # i->x->y->jの順 +1はx->yの分
            d2 = abs(x-i) + 1 + abs(j-y) 
            # i->y->x->jの順 +1はy->xの分
            d3 = abs(y-i) + 1 + abs(j-x)
            dist = min(min(d1, d2), d3)
            ans[dist] += 1
    print(*ans[1:n], sep='\n')

def __starting_point():
    main()
__starting_point()

N,X,Y=map(int,input().split())
X,Y=X-1,Y-1
d=[0]*N
for i in range(N-1):
  for j in range(i+1,N):
    a=min(abs(j-i),abs(X-i)+1+abs(j-Y))
    d[a]+=1
for i in range(1,N):
  print(d[i])

import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from collections import defaultdict
def main():
    n, x, y= list(map(int, input().split()))
    edges = {e:[] for e in range(n)}
    for i1 in range(1, n - 1):
        edges[i1].append(i1-1)
        edges[i1].append(i1+1)
    edges[0].append(1)
    edges[n-1].append(n-2)
    edges[x-1].append(y-1)
    edges[y-1].append(x-1)

    dis = defaultdict(int)
    for j1 in range(n):
        seen = set()
        cnt = 0
        dis_each = [n] * n
        nexts = [j1]
        nextnext = []
        while len(seen) < n:
            for next in nexts:
                if next not in seen:
                    seen.add(next)
                    dis_each[next] = cnt
                    nextnext += edges[next]
            nexts = nextnext
            nextnext = []
            cnt += 1
        for d in dis_each:
            dis[d] += 1
    for k1 in range(1, n):
        print((dis[k1]//2))

def __starting_point():
    main()

__starting_point()

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

x -= 1
y -= 1

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

for k in range(1, n):
    print(dist[k])

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

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

for i in li:
    print(i)

N,X,Y = map(int,input().split())
X-=1;Y-=1
ans = [0 for _ in range(N-1)]
for i in range(N):
  for j in range(i+1,N):
    direct = j-i
    shortcut = abs(X-i)+1+abs(Y-j)
    shortest = min(direct,shortcut)
    ans[shortest-1] += 1
print(*ans,sep="\n")

from collections import Counter
n, x, y = list(map(int, input().split()))
c = Counter()
for i in range(1, n):
    for j in range(i+1, n+1):
        dist = min(abs(j-i), abs(x-i)+1+abs(j-y), abs(y-i)+1+abs(j-x))
        c[dist] += 1

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


n,x,y = map(int, input().split())
g = [0]*(n)
for i in range(1,n+1):
  for j in range(1,i):
    e = abs(y-i)+1+abs(x-j)
    f = i-j
    g[min(e,f)]+=1
for i in g[1:]:
  print(i)

def main():
	N, X, Y = [int(n) for n in input().split(" ")]
	vertex = [[1]] + [[i - 1, i + 1] for i in range(1, N - 1)] + [[N - 2]]
	vertex[X - 1].append(Y - 1)
	vertex[Y - 1].append(X - 1)

	count = [0] * N
	for i in range(N):
		to_visit = [i]
		checked = [0] * N
		steps = [0] * N
		checked[i] = 1

		while len(to_visit) > 0:
			visiting = to_visit.pop(0)
			vs = vertex[visiting]
			step = steps[visiting]
			for v in vs:
				if checked[v] == 0:
					checked[v] = 1
					to_visit.append(v)
					steps[v] = step + 1
					count[step + 1] += 1

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

main()

from collections import deque

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

g = [[] for _ in range(n)]

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


def bfs(g, n_node, start_node):
    dist = [-1] * n_node
    dist[start_node] = 0
    que = deque([start_node])

    while que:
        node = que.popleft()
        for j in g[node]:
            if dist[j] != -1:
                continue
            dist[j] = dist[node] + 1
            que.append(j)
    return dist


ans = [0] * n

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

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

from collections import defaultdict
from collections import deque
from collections import Counter
import math

def readInt():
	return int(input())
def readInts():
	return list(map(int, input().split()))
def readChar():
	return input()
def readChars():
	return input().split()

n,x,y = readInts()

d = defaultdict(int)

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

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

n, x, y = map(int, input().split())
a = [0]*(n-1)
for i in range(1, n):
    for j in range(i+1, n+1):
        b = min(j-i, abs(x-i)+1+abs(y-j))
        a[b-1] += 1
print(*a, sep="\n")

import sys

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

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

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

N,X,Y=map(int,input().split())
L=[0]*(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(Y-j)))]+=1
for i in range(1,N):
  print(L[i])

from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))

n,x,y=nii()
x-=1
y-=1
ans=[0 for i in range(n)]

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

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

### ----------------
### ここから
### ----------------

import sys
from io import StringIO
import unittest

def yn(b):
    print(("Yes" if b==1 else "No"))
    return

def resolve():
    readline=sys.stdin.readline

    n,x,y=list(map(int, readline().rstrip().split()))
    ans = [0] * (n-1)
    for i in range(1,n+1):
        for j in range(i+1,n+1):
            d1 = abs(i-x) + abs(j-x)
            d2 = abs(i-y) + abs(j-y)
            d3 = abs(i-x) + abs(j-y) + 1
            d4 = abs(i-y) + abs(j-x) + 1
            d5 = abs(i-j)
            d=min(d1,d2,d3,d4,d5)
            ans[d-1]+=1
    for a in ans:
        print(a)
    #arr=list(map(int, readline().rstrip().split()))
    #n=int(readline())
    #ss=readline().rstrip()
    #yn(1)

    return

if 'doTest' not in globals():
    resolve()
    return

### ----------------
### ここまで 
### ----------------


from collections import deque

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

g = [[] for _ in range(n)]

# make graph
for i in range(n - 1):
    g[i].append(i + 1)
    g[i + 1].append(i)

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

def bfs(g, n_node, start_node):
    dist = [-1] * n_node
    dist[start_node] = 0
    queue = deque([start_node])

    while queue:
        node = queue.popleft()
        for n in g[node]:
            if dist[n] != -1:
                continue
            dist[n] = dist[node] + 1
            queue.append(n)
    return dist


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

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

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

dis_list = [0] * (N-1)

#Xからの距離を求める
dis_X = [0] * N

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

#
    #スタート位置
for start in range(N):
    for goal in range(start+1,N):
        dis = min(abs(X - (start + 1)) + abs(Y - (goal + 1)) + 1,goal-start)
        dis_list[dis-1] += 1

for ans in dis_list:
    print(ans)


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

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

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

dp=[[0]*N for i in range(N)]
dist=[0]*N
X-=1
Y-=1
for i in range(N):
  for j in range(N):
    if not i<j:continue
    dp[i][j]=min(j-i,abs(j-Y)+1+abs(X-i))
    dist[dp[i][j]]+=1

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

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

dis_list = [0]*(n)

for start in range(1,n+1):
    for end in range(start+1,n+1):
        dis1 = end - start
#        dis2 = (end-start) - (y-(x+1))
        dis3 = abs(x-start)+abs(y-end)+1
        a = min(dis1,dis3)
        dis_list[a] += 1


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


def main():
    n, x, y = map(int, input().split())
    ans = [0] * (n+1)
    d = list()
    for i in range(1, n):
        for j in range(i+1, n+1):
            # x->yを通らない
            d1 = abs(j-i)
            # i->x->y->jの順 +1はx->yの分
            d2 = abs(x-i) + 1 + abs(j-y) 
            # i->y->x->jの順 +1はy->xの分
            d3 = abs(y-i) + 1 + abs(j-x)
            dist = min(min(d1, d2), d3)
            d.append(dist)
            ans[dist] += 1
    print(*ans[1:n], sep='\n')

def __starting_point():
    main()
__starting_point()

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

cnt = 0

ans=[0]*n

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

import math
from math import gcd,pi,sqrt
INF = float("inf")

import sys
sys.setrecursionlimit(10**6)
import itertools
from collections import Counter,deque
def i_input(): return int(input())
def i_map(): return map(int, input().split())
def i_list(): return list(i_map())
def i_row(N): return [i_input() for _ in range(N)]
def i_row_list(N): return [i_list() for _ in range(N)]
def s_input(): return input()
def s_map(): return input().split()
def s_list(): return list(s_map())
def s_row(N): return [s_input for _ in range(N)]
def s_row_str(N): return [s_list() for _ in range(N)]
def s_row_list(N): return [list(s_input()) for _ in range(N)]

def main():
    n, x, y = i_map()
    ans = [0] * n

    for fr in range(1, n+1):
        for to in range(fr+1, n+1):
            cost = min(to - fr, abs(x-fr) + abs(to - y) + 1)
            ans[cost] += 1
    print(*ans[1:], sep="\n")

def __starting_point():
    main()

__starting_point()

n,x,y=map(int,input().split())
anslist = [0]*(n)
temp = 0
for i in range(1,n):
    for j in range(i+1,n+1):
        temp = min(abs(j-i),(abs(x-i)+1+abs(y-j)),(abs(y-i)+1+abs(x-j)))
        anslist[temp] += 1

anslist.pop(0)

for i in anslist:
    print(i)

import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from collections import defaultdict
def main():
    n, x, y = map(int, input().split())
    x -= 1
    y -= 1
    dis = defaultdict(int)
    for i1 in range(n):
        for i2 in range(i1+1, n):
            d = min(abs(i2-i1), abs(x-i1)+abs(y-i2)+1, abs(x-i2)+abs(y-i1)+1)
            dis[d] += 1

    for k1 in range(1, n):
        print(dis[k1])

def __starting_point():
    main()
__starting_point()

N, X, Y = [int(x) for x in input().split()]

D = [0 for _ in range(N)]

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

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


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)


n,x,y = list(map(int,input().split()))
ans_ls = [0] * (n-1)
for start in range(1,n):
    for end in range(start+1,n+1):
        cost_1 = end - start
        cost_2 = abs(start - x) + abs(end - y) + 1
        cost = min(cost_1,cost_2)
        ans_ls[cost-1] += 1
for ans in ans_ls:
    print(ans)



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


import collections

N, X, Y = [int(x) for x in input().split()]

c = collections.Counter()

for i in range(1, N + 1):
    for j in range(i, N + 1):
        if (i == X and j == Y) or (i == Y and j == X):
            c[1] += 1
        else:
            c[min([j - i, abs(X - i) + 1 + abs(Y - j), abs(X - j) + 1 + abs(Y - i)])] += 1

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


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

N, X, Y = [int(_) for _ in input().split()]
X -= 1
Y -= 1

V = [0 for _ in range(N)]
for i in range(N):
    for j in range(i+1, N):
        v1 = j - i
        v2 = abs(i - X) + abs(j - Y) + 1
        V[min(v1, v2)] += 1
        
for v in V[1:]:
    print(v)


# import itertools
# import math
# import sys
# sys.setrecursionlimit(500*500)
# import numpy as np

# N = int(input())
# S = input()
# n, *a = map(int, open(0))
N, X, Y = map(int, input().split())
# A = list(map(int, input().split()))
# B = list(map(int, input().split()))
# tree = [[] for _ in range(N + 1)]
# B_C = [list(map(int,input().split())) for _ in range(M)]
# S = input()

# B_C = sorted(B_C, reverse=True, key=lambda x:x[1])
# all_cases = list(itertools.permutations(P))
# a = list(itertools.combinations_with_replacement(range(1, M + 1), N))
# itertools.product((0,1), repeat=n)

# A = np.array(A)
# cum_A = np.cumsum(A)
# cum_A = np.insert(cum_A, 0, 0)

# def dfs(tree, s):
#     for l in tree[s]:
#         if depth[l[0]] == -1:
#             depth[l[0]] = depth[s] + l[1]
#             dfs(tree, l[0])
# dfs(tree, 1)

# def factorization(n):
#     arr = []
#     temp = n
#     for i in range(2, int(-(-n**0.5//1))+1):
#         if temp%i==0:
#             cnt=0
#             while temp%i==0:
#                 cnt+=1
#                 temp //= i
#             arr.append([i, cnt])
#     if temp!=1:
#         arr.append([temp, 1])
#     if arr==[]:
#         arr.append([n, 1])
#     return arr

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

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

def main():
    import itertools
    n,x,y = list(map(int,input().split()))
    stat = [i for i in range(n)]
    ans = [0 for i in range(n-1)]
    for s in itertools.combinations(stat,2):
        d = min(s[1]-s[0],abs(x-1-s[0])+1+abs(y-1-s[1]))
        ans[d-1] += 1
    for i in range(len(ans)):
        print((ans[i]))

def __starting_point():
    main()

__starting_point()

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

dist_cnt = [0]*N

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

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

from collections import defaultdict

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

for i in range(1,N):
    for j in range(i+1, N+1):
        if j<=X or i>=Y:
            path = j-i
        else:
            path = min(j-i, abs(X-i)+abs(j-Y)+1)
        cnt_dict[path] += 1

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

N,X,Y=map(int,input().split())
ans=[0]*(N+1)
for i in range(1,N):
    for j in range(i+1,N+1):
        shortest=min(j-i,1+abs(X-i)+abs(Y-j))
        ans[shortest]+=1
for k in range(1,N):
    print(ans[k])

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

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

count = [0 for i in range(N)]
for i in range(N-1):
    for dis in distance[i]:
        count[dis] += 1
        
for i in range(1, len(count)):
    print(count[i])

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

ans = [0] * (N + 1)

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

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

N, X, Y = map(int, input().split())
ds = [0] * (N - 1)
 
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))
        ds[d - 1] += 1
 
for d in ds:
    print(d)
return

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

def min_dist(i, j):
    d1 = abs(i - j)

    d2 = abs(X - i) + abs(Y - j) + 1

    return min(d1, d2)


ans = [0] * N

for i in range(N):
    for j in range(i+1, N):
        ans[min_dist(i, j)] += 1

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

N, X, Y = [int(x) for x in input().split()]

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

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

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


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

for a in ans:
    print(a)



### ----------------
### ここから
### ----------------

import sys
from io import StringIO
import unittest

def yn(b):
    print(("Yes" if b==1 else "No"))
    return

def resolve():
    readline=sys.stdin.readline

    n,x,y=list(map(int, readline().rstrip().split()))
    ans = [0] * (n-1)
    for i in range(1,n+1):
        for j in range(i+1,n+1):
            d1 = abs(i-x) + abs(j-y) + 1
            d2 = abs(i-y) + abs(j-x) + 1
            d3 = abs(i-j)
            d=min(d1,d2,d3)
            ans[d-1]+=1
    for a in ans:
        print(a)

    return

if 'doTest' not in globals():
    resolve()
    return

### ----------------
### ここまで 
### ----------------


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

d = [0] * N
for i in range(1, N):
    for j in range(i + 1, N + 1):
        if j <= X:
            a = j - i
        elif i <= X and j >= Y:
            a = (X - i) + (j - Y) + 1
        else:
            a = min(j - i, abs(X - i) + 1 + abs(Y - j))

        d[a] += 1
for ans in d[1:]:
    print(ans)


N, X, Y = list(map(int, input().split()))
dict_lis = {i: 0 for i in range(1, N)}

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

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


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

dists = [0] * (n-1)

for start in range(n):
    for end in range(start+1, n):
        dist = min(end-start, abs(((x-1)-start))+1+abs(end-(y-1)))
        dists[dist-1] += 1

for dist in dists:
    print(dist)

n, x, y = map(int,input().split())
x, y = x-1, y-1
d=[0 for i in range(n)]

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

N, X, Y = map(int, input().split())
ansvec = [0]*N
for a in range(N-1):
    for b in range(a+1, N):
        ansvec[min(b-a, abs(a-X+1)+abs(b-Y+1)+1)] += 1
for k in range(N-1):
    print(ansvec[k+1])

import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time, copy,bisect
#from operator import itemgetter
#from heapq import heappush, heappop
import numpy as np
from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
#from scipy.sparse import csr_matrix
#from decimal import Decimal, ROUND_HALF_UP, ROUND_HALF_EVEN
import sys

sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7

stdin = sys.stdin

ni = lambda: int(ns())
nf = lambda: float(ns())
na = lambda: list(map(int, stdin.readline().split()))
nb = lambda: list(map(float, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  # ignore trailing spaces

N, X, Y = na()
g = [[0] * N for _ in range(N)]
for i in range(N-1):
    g[i][i+1] = 1
    g[i+1][i] = 1

g[X-1][Y-1] = 1
g[Y-1][X-1] = 1
g = np.array(g)
d = shortest_path(g)
ct = [0] * N
for i in range(N):
    for j in range(i, N):
        ct[int(d[i][j])] += 1
for i in range(1, N):
    print((ct[i]))



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

ans = [0] * (N + 1)

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

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

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

a=[0]*n
# x-=1
# y-=1


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

for i in range(n-1):
    print((a[i]))


N, X, Y = map(int, input().split())
k = [0] * (N - 1)

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

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):
        if i <= x and j >= y:
            a = abs(j-i)-abs(y-x)+1
            b = abs(i-x)+abs(j-y)+1
            ans[min(a,b)] += 1
        else:
            c = abs(x-i)+abs(y-j)+1
            d = abs(j-i)
            ans[min(c,d)] += 1

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


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

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

def __starting_point():
    main()
__starting_point()

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

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


from collections import defaultdict

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

d = defaultdict(int)

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

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

N,X,Y = map(int,input().split())
a = [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(Y-j),abs(X-j)+1+abs(Y-i))
    a[ans -1] += 1
for item in a:
  print(item)

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

# -*- coding: utf-8 -*-
"""
Created on Mon Sep  7 15:49:02 2020

@author: liang
"""

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

for i in ans:
    print(i)

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


from collections import deque
def bfs(u):
    queue = deque([u])
    d = [None] * n # uからの距離の初期化
    d[u] = 0 # 自分との距離は0
    while queue:
        v = queue.popleft()
        for i in g[v]:
            if d[i] is None:
                d[i] = d[v] + 1
                queue.append(i)
    return d

ans_dist = [0 for i in range(n)]

for i in range(n):
    D = bfs(i)
    for d in D:
        ans_dist[d] += 1

for i in range(n-1):
    print(ans_dist[i+1]//2)


def search(start, N, X, Y):
    dist = [0 for _ in range(N)]
    if start <= X:
        for i in range(X):
            dist[i] = abs(start - i)
        for i in range(Y, N):
            dist[i] = (X - start) + 1 + (i - Y)
        for i in range(X, (Y - X) // 2 + X + 1):
            dist[i] = (i - start)
        for i in range((Y - X) // 2 + X + 1, Y):
            dist[i] = (X - start) + 1 + (Y - i)
    elif start >= Y:
        for i in range(Y, N):
            dist[i] = abs(start - i)
        for i in range(X):
            dist[i] = (start - Y) + 1 + (X - i)
        for i in range(X, (Y - X) // 2 + X):
            dist[i] = (start - Y) + 1 + (i - X)
        for i in range((Y - X) // 2 + X, Y):
            dist[i] = (start - i)
    else:
        toX = min(start - X, Y - start + 1)
        toY = min(Y - start, start - X + 1)
        dist[start] = 0
        for i in range(X):
            dist[i] = (X - i) + toX
        for i in range(Y, N):
            dist[i] = toY + (i - Y)
        for i in range(X, start):
            dist[i] = min(start - i, Y - start + 1 + i - X)
        for i in range(start + 1, Y):
            dist[i] = min(i - start, start - X + 1 + Y - i)
    return dist


def main():
    N, X, Y = [int(n) for n in input().split(" ")]
    #N, X, Y = 10, 3, 8

    X = X - 1
    Y = Y - 1

    lenD = []
    for i in range(N):
        d = search(i, N, X, Y)
        lenD.append(d)

    kcounter = [0 for _ in range(N - 1)]

    for i in range(N):
        for j in range(i + 1, N):
            k = lenD[i][j]
            kcounter[k - 1] += 1

    for k in kcounter:
        print(k)

main()

n,x,y=map(int,input().split())
x,y=x-1,y-1
c=[0 for i in range(n-1)]

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

for i in range(n-1):
  print(c[i])

#!/usr/bin/env python3
def main():
    from collections import deque
        
    N, X, Y = list(map(int, input().split()))

    G = [[1]] + [[x - 1, x + 1] for x in range(1, N - 1)] + [[N - 2]]
    G[X - 1].append(Y - 1)
    G[Y - 1].append(X - 1)

    dist = [[-1] * N for _ in [0] * N]
    for s in range(N):
        q = deque([s])
        dist[s][s] = 0
        while q:
            v = q.popleft()
            for nv in G[v]:
                if dist[s][nv] == -1:
                    dist[s][nv] = dist[s][v] + 1
                    q.append(nv)
    res = [0] * N
    for i in range(N):
        for j in range(i + 1, N):
            res[dist[i][j]] += 1
    for d in range(1, N):
        print((res[d]))


def __starting_point():
    main()

__starting_point()

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

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

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