CodeEff/ECCO huggingface dataset:
# Original solution
#!/usr/bin/env python3
import sys
import collections

def solve(N: int, X: int, Y: int):
    def len_shortest_path(i, j, X, Y):
        return min(abs(j-i), abs(X-i) + abs(Y-j) + 1)
    result = collections.defaultdict(int)
    for i in range(1, N+1):
        for j in range(i+1, N+1):
            shortest_path = len_shortest_path(i, j, X, Y)
            result[shortest_path] += 1

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


def solve_slow(N: int, X: int, Y: int):
    d = [[100000000 for i in range(N)] for j in range(N)]
    X -= 1
    Y -= 1

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

    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])

    count_dict = collections.defaultdict(int)
    for row in d:
        for i in row:
            count_dict[i] += 1
    for i in range(1, N):
        print((count_dict[i]))
    return


def solve_slow(N: int, X: int, Y: int):
    d = [[100000000 for i in range(N)] for j in range(N)]
    X -= 1
    Y -= 1

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

    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])

    count_dict = collections.defaultdict(int)
    for row in d:
        for i in row:
            count_dict[i] += 1
    for i in range(1, N):
        print((count_dict[i]))
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
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
import collections

def solve(N: int, X: int, Y: int):
    X = X - 1
    Y = Y - 1

    counter = collections.defaultdict(int)
    for i in range(N):
        for j in range(i+1, N):
            k = min(j - i, abs(Y-j) + abs(X-i) + 1)
            counter[k] += 1
    for i in range(1, N):
        print((counter[i]))
    return


# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools  (tips: You use the default template now. You can remove this line by using your custom template)
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
N, X, Y = list(map(int, input().split()))
neighbor = { i: [] for i in range(1, N+1) }
for i in range(1,N):
    neighbor[i].append(i+1)
    neighbor[N-i+1].append(N-i)
neighbor[X].append(Y)
neighbor[Y].append(X)

distanced_neighbor = { i: { j: [] for j in range(1, N)} for i in range(1, N+1) }
for i in range(1, N+1):
    visited = [i]
    next_nodes = neighbor[i]
    for j in range(1, N):
        distanced_neighbor[i][j] = next_nodes[:]
        queue = next_nodes[:]
        visited += next_nodes
        next_nodes = []
        for q in queue:
            for node in neighbor[q]:
                if node in visited:
                    continue
                else:
                    next_nodes.append(node)
        next_nodes = list(set(next_nodes))

for i in range(1, N):
    print((sum([len(distanced_neighbor[j][i]) for j in range(1, N+1)])//2))
    

# Optimized solution
N, X, Y = list(map(int, input().split()))
for K in range(1,N):
    res = 0
    for i in range(N-1):
        for j in range(i+1,N):
            min_dist = min(abs(j-i), abs(X-1-i)+1+abs(Y-1-j), abs(Y-1-i)+1+abs(X-1-j))
            if min_dist == K:
                res += 1
    print(res)
# Original solution
import sys
import os
import math

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

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

    for r in ret:
        print(r)


if __name__ == '__main__':
    main()


# Optimized solution
import sys
import os
import math

ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]

iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

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

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


if __name__ == '__main__':
    main()
# Original solution
from collections import Counter
N, X, Y = list(map(int, input().split()))

def dijkstra(s, n, w, cost):
    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

cost = [[float("inf") for _ in range(N)] for _ 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

res = Counter()
for i in range(N):
    res += Counter(dijkstra(i, N, N, cost)[:i])

for i in range(N-1):
    print((res[i+1]))

# Optimized solution
from collections import Counter, defaultdict, deque

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

d = defaultdict(set)
for i in range(N-1):
    d[i].add(i+1)
    d[i+1].add(i)
d[X-1].add(Y-1)
d[Y-1].add(X-1)


cost = [[N]*N for _ in range(N)]

q = deque()

for i in range(N):
    q.append((i, 0))
    cost[i][i] = 0

    while q:
        u, st = q.popleft()

        for v in d[u]:
            if v != u and cost[i][v] > st+1:
                cost[i][v] = st+1
                q.append((v, st+1))

res = Counter()
for i, c in enumerate(cost):
    res += Counter(c[:i])

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

# Optimized solution
n, x, y = list(map(int, input().split()))
li = [0 for i in range(n-1)]
x -= 1
y -= 1
for i in range(n-1):
  for j in range(i+1, n):
    a = min(j-i, abs(x-i)+abs(y-j)+1)
    li[a-1] += 1
for x in li:
  print(x)
# Original solution
import heapq
INFTY = 10**4
N,X,Y = list(map(int,input().split()))
C = {k:0 for k in range(N)}
G = {i:[] for i in range(1,N+1)}
G[1].append(2)
G[N].append(N-1)
for i in range(2,N):
    G[i].append(i-1)
    G[i].append(i+1)
G[X].append(Y)
G[Y].append(X)
for i in range(1,N+1):
    heap = [(0,i)]
    dist = [INFTY for _ in range(N+1)]
    dist[i] = 0
    hist = [0 for _ in range(N+1)]
    while heap:
        d,x = heapq.heappop(heap)
        if dist[x]<d:continue
        hist[x]=1
        for y in G[x]:
            if hist[y]==0 and dist[y]>d+1:
                dist[y] = d+1
                heapq.heappush(heap,(dist[y],y))
    for j in range(1,N+1):
        C[dist[j]] += 1
for k in range(1,N):
    print((C[k]//2))

# Optimized solution
import heapq
INFTY = 10**4
N,X,Y = list(map(int,input().split()))
G = {i:[] for i in range(1,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)
dist = [[INFTY for _ in range(N+1)] for _ in range(N+1)]
for i in range(N+1):
    dist[i][i] = 0
for i in range(1,N+1):
    hist = [0 for _ in range(N+1)]
    heap = [(0,i)]
    hist[i] = 1
    while heap:
        d,x = heapq.heappop(heap)
        if d>dist[i][x]:continue
        hist[x] = 1
        for y in G[x]:
            if hist[y]==0:
                if dist[i][y]>d+1:
                    dist[i][y] = d+1
                    heapq.heappush(heap,(d+1,y))
C = {k:0 for k in range(1,N)}
for i in range(1,N):
    for j in range(i+1,N+1):
        C[dist[i][j]] += 1
for k in range(1,N):
    print((C[k]))
# Original solution
# -*- coding: utf-8 -*-
import queue

n, x, y = map(int, input().split())
x -= 1
y -= 1
INF = 10010101010101
ans = [0]*n
def put(v, d):
    if dist[v] != INF:
        return
    dist[v] = d
    q.put(v)
for sv in range(n):
    q = queue.Queue()
    dist = [INF for _ in range(n)]
    put(sv, 0)
    while not q.empty():
        v = q.get()
        d = dist[v]
        if v-1 >= 0:
            put(v-1, d+1)
        if v+1 < n:
            put(v+1, d+1)
        if v == x:
            put(y, d+1)
        if v == y:
            put(x, d+1)
    for i in range(n):
        ans[dist[i]] += 1
for i in range(n):
    ans[i] = int(ans[i] / 2)

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


# Optimized solution
# -*- coding: utf-8 -*-
n, x, y = map(int, input().split())
x -= 1
y -= 1
ans = [0]*n
for i in range(n):
    for j in range(i + 1, n):
        dist1 = j - i
        dist2 = abs(x - i) + abs(y - j) + 1
        ans[min(dist1, dist2)] += 1
print(*ans[1:], sep='\n')
# Original solution
from collections import defaultdict, deque
def solve():
    N, X, Y = list(map(int, input().split()))
    cnter = [0] * N

    for start in range(N-1):
        deq = deque()
        deq.append(start)
        n_step = [float('inf')] * N
        n_step[start] = 0
        visited = [False] * N

        while len(deq) > 0:
            fr = deq.popleft()
            visited[fr] = True

            if fr == X-1:
                if not visited[Y-1] or n_step[Y-1] > n_step[X-1]+1:
                    n_step[Y-1] = n_step[X-1]+1
                    deq.append(Y-1)
                    visited[Y-1] = True

            if fr == Y-1:
                if not visited[X-1] or n_step[X-1] > n_step[Y-1]+1:
                    n_step[X-1] = n_step[Y-1]+1
                    deq.append(X-1)
                    visited[X-1] = True
                    
            if fr != N-1:
                if not visited[fr+1] or n_step[fr+1] > n_step[fr]+1:
                    deq.append(fr+1)
                    n_step[fr+1] = n_step[fr]+1
                    visited[fr+1] = True

            if fr != 0:
                if not visited[fr-1] or n_step[fr-1] > n_step[fr]+1:
                    deq.append(fr-1)
                    n_step[fr-1] = n_step[fr]+1
                    visited[fr-1] = True
        
        for i in range(start,N):
            cnter[n_step[i]] += 1
            
    for i in range(1,N):
        print((cnter[i]))

if __name__ == '__main__':
    solve()


# Optimized solution
from collections import defaultdict, deque
def solve():
    N, X, Y = list(map(int, input().split()))
    X -= 1
    Y -= 1
    cnter = defaultdict(int)

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


if __name__ == '__main__':
    solve()
# Original solution
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(eval(input()))
def i_map(): return list(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 eval(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()
    p = [[INF]*n for i in range(n)]
    for i in range(n-1):
        p[i][i] = 0
        p[i][i+1] = p[i+1][i] = 1
    p[-1][-1] = 0

    x -= 1
    y -= 1
    p[x][y] = p[y][x] = 1

    for k in range(n):
        for i in range(n):
            for j in range(n):
                p[i][j] = min(p[i][j], p[i][k] + p[k][j])
    p = list(itertools.chain.from_iterable(p))
    p.sort()
    p = [i for i in p if i != 0]
    start = 1
    cnt = 0
    for i in p:
        if start != i:
            start = i
            print((cnt//2))
            cnt = 1
        else:
            cnt += 1
    print((cnt//2))
    for i in range(n-start-1):
        print((0))


if __name__=="__main__":
    main()


# Optimized solution
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")

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

edges = defaultdict(lambda: [])
for i in range(1, n):
    edges[i].append(i+1)
    edges[i+1].append(i)
edges[x].append(y)
edges[y].append(x)

# 幅優先
counter = [0 for i in range(n)]
for i in range(1, n+1):
    d = deque()
    is_checked = [False for _ in range(n+1)]
    dist = [-1 for _ in range(n+1)]
    dist[i] = 0
    d.append((i, 0))
    while len(d) > 0:
        e, pre_dist = d.popleft()
        if is_checked[e]:
            continue
        else:
            is_checked[e] = True
            dist[e] = pre_dist + 1
            for next_e in edges[e]:
                if not is_checked[next_e]:
                    d.append((next_e, pre_dist+1))
    for j in range(i+1, n+1):
        counter[dist[j]-1] += 1
print(("\n".join(list(map(str, counter[1:])))))


# Optimized solution
from collections import deque, defaultdict
n, x, y = list(map(int, input().split()))
 
edges = defaultdict(lambda: [])
for i in range(1, n):
    edges[i].append(i+1)
    edges[i+1].append(i)
edges[x].append(y)
edges[y].append(x)
 
# 幅優先
counter = [0 for i in range(n)]
for i in range(1, n+1):
    d = deque()
    dist = [-1 for _ in range(n+1)]
    d.append((i, -1))
    while len(d) > 0:
        e, pre_dist = d.popleft()
        if dist[e] > -1:
            continue
        else:
            dist[e] = pre_dist + 1
            for next_e in edges[e]:
                if dist[next_e] == -1:
                    d.append((next_e, pre_dist+1))
    for j in range(i+1, n+1):
        counter[dist[j]] += 1
print(("\n".join(list(map(str, counter[1:])))))
# Original solution
N, X, Y = list(map(int, input().split()))
X -= 1
Y -= 1
D = [0] * N

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

for v in D[1:N]:
    print(v)

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

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

for v in D[1:N]:
    print(v)
# Original solution

from collections import defaultdict
import heapq


def dijkstra(n, s, edges, count):
    dist = [float('inf') for _ in range(n)]
    dist[s] = 0
    q = []
    heapq.heappush(q, (0, s))
    while len(q):
        d, p = heapq.heappop(q)
        if s < p:
            count[d] += 1
        if dist[p] < d:
            continue
        for e in edges[p]:
            if d + 1 < dist[e]:
                dist[e] = d + 1
                heapq.heappush(q, (dist[e], e))
    return dist, count


def submit():
    n, x, y = list(map(int, input().split()))
    
    edges = {i: [] for i 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)
    
    dist_list = {}
    count = defaultdict(int)
    for s in range(n):
        dist_list[s], count = dijkstra(n, s, edges, count)

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


submit()

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

    count = {i: 0 for i in range(1, n)}
    for i in range(1, n + 1):
        for j in range(i + 1, n + 1):
            # i, j <= X, or Y <= i, j
            if (i <= x and j <= x) or (x <= i and y <= j):
                d = j - i
            
            # X < i, j < Y
            if x < i and j < y:
                d = min(j - i, i - x + 1 + y - j)
            
            # i <= X and X < j < Y
            if i <= x and x < j < y:
                d = min(j - i,
                        x - i + 1 + y - j)            

            # X < i < Y and Y <= j
            if x < i < y and y <= j:
                d = min(j - i,
                        j - y + 1 + i - x)

            if i <= x and y <= j:
                d = min(j - i,
                        x - i + j - y + 1)
            count[d] += 1            
            

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

submit()
# Original solution
N, X, Y = list(map(int, input().split()))
l = []
for i in range(1, N):
    for j in range(i+1, N+1):
        s = j -i
        if 0 < i < Y:
            ss = abs(j - Y) + abs(X - i) + 1 
            l.append(min(s, ss))
        elif i >= Y:
            l.append(s)
for i in range(1, N):
    print((l.count(i)))

# Optimized solution
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):
        s = j -i
        if 0 < i < Y:
            ss = abs(j - Y) + abs(X - i) + 1 
            l[min(s, ss)-1] += 1
        elif i >= Y:
            l[s-1] += 1
for i in range(N-1):
    print((l[i]))
# Original solution
n,x,y=list(map(int, input().split()))
dist=[]

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

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

for i in range(1,n+1):
    for j in range(i+1,n+1):
        dist[min(j-i,abs(j-y)+1+abs(i-x))]+=1
for i in range(1,n):
    print((dist[i]))
# Original solution
from collections import deque
n,x,y = list(map(int,input().split()))
x,y = x-1 ,y-1
g = [[float('inf')]*n for _ in range(n)]
for i in range(n):
    que = deque([(i, 0)])
    while que:
        node, cost = que.popleft()
        if g[i][node]!=float('inf'):
            continue
        else:
            g[i][node] = cost
            if node>0:
                que.append((node-1, cost+1))
            if node<n-1:
                que.append((node+1, cost+1))
            if node==x:
                que.append((y, cost+1))
            if node==y:
                que.append((x, cost+1))
cnt = [0]*n
for i in range(n):
    for j in range(i+1, n):
        cnt[g[i][j]] += 1
for c in cnt[1:]:
    print(c)

# Optimized solution
from collections import deque
def main():
    n,x,y = list(map(int,input().split()))
    cnt = [0]*n
    for i in range(n):
        d = [float('inf')]*n
        que = deque([(i, 0)])
        while que:
            idx, c = que.popleft()
            if d[idx]!=float('inf'):
                d[idx] = min(d[idx], c)
                continue
            else:
                d[idx] = min(d[idx], c)
                if idx!=0:
                    que.append((idx-1, c+1))
                if idx!=n-1:
                    que.append((idx+1, c+1))
                if idx==x-1:
                    que.append((y-1, c+1))
                if idx==y-1:
                    que.append((x-1, c+1))
        for j in range(i+1, n):
            cnt[d[j]] += 1
    for c in cnt[1:]:
        print(c)
    
if __name__ == '__main__':
    main()
# Original solution
def wf(d):
    N = len(d)
    for k in range(N):
        for j in range(N):
            for i in range(N):
                d[j][i] = min(d[j][i], d[j][k] + d[k][i])
    return d


N, x, y = list(map(int, input().split()))
x -= 1
y -= 1
d = [[float('inf') for _ in range(N)] for _ in range(N)]

for i in range(N-1):
    d[i][i + 1] = 1
    d[i + 1][i] = 1

d[x][y] = 1
d[y][x] = 1

for n in range(N):
    d[n][n] = 0

d = wf(d)

cnt = {n: 0 for n in range(N)}
for i in range(N):
    for j in range(i, N):
        cnt[d[i][j]] += 1

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


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

cnt = {n: 0 for n in range(1, N)}
for i in range(1, N + 1):
    for j in range(i+1, N + 1):
        d1 = abs(i - j)
        d2 = 1 + min(abs(x - i) + abs(y - j), abs(x - j) + abs(y - i))
        cnt[min(d1, d2)] += 1

for k in range(1, N):
    print((cnt[k]))
# Original solution
from collections import deque
import sys
input = sys.stdin.readline
n,x,y = list(map(int,input().split()))
to = [[] for _ in range(n)]
for i in range(n-1):
    to[i].append(i+1)
    to[i+1].append(i)
x -= 1
y -= 1
to[x].append(y)
to[y].append(x)

ans = [0]*(n-1)
d = {}
Q = deque()
flag = [False]*n
for i in range(n-1):
    Q.clear()
    Q.append((i,-1,0))
    for j in range(n): flag[j] = False
    flag[i] = True
    while Q:
        cur,prev,dist = Q.popleft()
        for nxt in to[cur]:
            if nxt == prev: continue
            if flag[nxt]: continue
            flag[nxt] = True
            if (i,nxt) not in d: ans[dist] += 1
            Q.append((nxt,cur,dist+1))
            d[(i,nxt)] = 1
            d[(nxt,i)] = 1

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

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

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

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


# Optimized solution
def solve():
    N, X, Y = map(int, input().split())
    ans = [0]*(N)
    for i in range(1,N):
        for j in range(i+1,N+1):
            ans[min(abs(X-i)+abs(Y-j)+1,abs(j-i))] += 1
    return ans[1:]
print(*solve(),sep='\n')