CodeEff/ECCO huggingface dataset:
# Original solution
n, x, y = list(map(int, input().split()))
x -= 1
y -= 1

cnt = [0] * n
for i in range(n):
    for j in range(n):
        if i >= j:
            continue
        dist = min(j - i, abs(j - y) + 1 + abs(i - x), abs(j - x) + 1 + abs(i - y))
        cnt[dist] += 1
for i in range(1, n):
    print((cnt[i]))


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

cnt = [0] * n

dist = []
for i in range(n):
    dist.append([-1] * n)
for i in range(n):
    dist[i][x] = abs(i-x)
    dist[i][y] = abs(i-y)
    dist[x][i] = abs(i-x)
    dist[y][i] = abs(i-y)

for i in range(n):
    for j in range(n):
        if i >= j:
            continue
        dis = min(j - i, dist[j][y] + 1 + dist[i][x], dist[j][x] + 1 + dist[i][y])
        cnt[dis] += 1
for i in range(1, n):
    print((cnt[i]))
# Original solution
n, x, y = list(map(int, input().split()))
x -= 1
y -= 1

cnt = [0] * n

dist = []
for i in range(n):
    dist.append([-1] * n)
for i in range(n):
    dist[i][x] = abs(i-x)
    dist[i][y] = abs(i-y)
    dist[x][i] = abs(i-x)
    dist[y][i] = abs(i-y)

for i in range(n):
    for j in range(n):
        if i >= j:
            continue
        dis = min(j - i, dist[i][x] + 1 + dist[y][j])
        cnt[dis] += 1
for i in range(1, n):
    print((cnt[i]))


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

from collections import deque
from collections import Counter

def bfs(i): # i番目の頂点を起点にしたbfs
    visited=[0]*n
    visited[i]=1
    que=deque([])
    que.append((i,1))
    
    while len(que)>0:
        di,c=que.popleft()
        nm=di-1
        np=di+1
        no=-1
        if di==x-1:
            no=y-1
        if di==y-1:
            no=x-1
        if 0<=nm and visited[nm]==0:
            visited[nm]=c+1
            que.append((nm,c+1))
        if np<=n-1 and visited[np]==0:
            visited[np]=c+1
            que.append((np,c+1))
        if no>=0 and visited[no]==0:
            visited[no]=c+1
            que.append((no,c+1))
    return visited

l=[0]
myc=Counter(l)
for i in range(n):
    myc += Counter(bfs(i))
ans=list(myc.values())
p=len(ans)
for i in range(2,n+1):
    if i>=p:
        print((0))
    else:
        print((ans[i]//2))

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

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

n_iter = itertools.combinations(list(range(1,N+1)), 2)

count_list = []

for i, j in n_iter:
  #1. abs(X - i) + abs(Y - j) + 1
  #2. abs(Y - i) + abs(X - j) + 1
  #3. abs(j - i)
  x = min(
    abs(X - i) + abs(Y - j) + 1,
    abs(Y - i) + abs(X - j) + 1,
    abs(j - i)
  )
  count_list.append(x)

# 要素数の数え上げと取り出し
num_counter = Counter(count_list)
for i in range(1, N):
  if i in num_counter:
    print((num_counter[i]))
  else:
    print((0))

# Optimized solution
import itertools

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

n_iter = itertools.combinations(list(range(1,N+1)), 2)

count_list = [0]*(N-1)

for i, j in n_iter:
  #1. abs(X - i) + abs(Y - j) + 1
  #2. abs(Y - i) + abs(X - j) + 1
  #3. abs(j - i)
  x = min(
    abs(X - i) + abs(Y - j) + 1,
    abs(Y - i) + abs(X - j) + 1,
    abs(j - i)
  )
  count_list[x-1] += 1

for i in count_list:
  print(i)
# Original solution
N, X, Y = list(map(int, input().split()))

INF = 1 << 30
dis = [ [abs(i-j) if abs(i-j) < 2 else INF for i in range(N)] for j in range(N)]
dis[X-1][Y-1] = 1
dis[Y-1][X-1] = 1

for k in range(N):
  for i in range(N):
    for j in range(N): dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j])

for i in range(1, N):
  ans = 0
  for j in range(N): ans += dis[j].count(i)
  print((ans//2))

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

X -= 1
Y -= 1

ans = [0] * (N-1)

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

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

list =[]
for i in range(n):
  for j in range(i):
    b = i+1
    a = j+1
    if a<=x and b>=y:
      list.append(b-y+x-a+1)
    elif a>x and b>=y:
      d =min(a-x+1,y-a)
      list.append(d+b-y)
    elif a<=x and b<y:
      d =min(b-x,y-b+1)
      list.append(x-a+d)
    elif a>x and b<y:
      list.append(min(b-a,y-b+a-x+1))
    else:
      list.append(b-a)
for i in range(n-1):
  print((list.count(i+1)))

# Optimized solution
n,x,y=list(map(int,input().split()))
 
ans=[0]*n
 
list =[]
for i in range(n):
  for j in range(i):
    b = i+1
    a = j+1
    if a<=x and b>=y:
      k =b-y+x-a+1
    elif a>x and b>=y:
      d =min(a-x+1,y-a)
      k =d+b-y
    elif a<=x and b<y:
      d =min(b-x,y-b+1)
      k =x-a+d
    elif a>x and b<y:
      k = min(b-a,y-b+a-x+1)
    ans[k]+=1
    
for i in range(1,n):
  print((ans[i]))
# Original solution
N,X,Y = list(map(int,input().split()))
data = [[3000]*N for _ in range(N)]
for i in range(N-1):
  data[i][i+1] = 1
  data[i+1][i] = 1
  data[i][i] = 0
data[0][0] = 0
data[X-1][Y-1] = 1
data[Y-1][X-1] = 1
for k in range(N):
  for i in range(N):
    for j in range(N):
      data[i][j] = min(data[i][j],data[i][k]+data[k][j])
for i in range(N-1):
  counter = 0
  for j in range(N):
    counter += data[j].count(i+1)
  print((int(counter//2)))

# Optimized solution
N,X,Y = list(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)
# Original solution
import heapq
import sys
from collections import defaultdict

input = sys.stdin.readline

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

def main():
    N, X, Y = list(map(int, input().split()))
    X -= 1
    Y -= 1
    edge = [[] for _ in range(N)]
    for i in range(N-1):
        edge[i].append((1,i+1))
        edge[i+1].append((1,i))
    
    edge[X].append((1,Y))
    edge[Y].append((1,X))
    d = []
    for i in range(N):
        tmp = dijkstra_heap(i, edge, N)
        d.append(tmp)

    e = defaultdict(int)
    for i in range(N):
        for j in range(i,N):
            if i == j:
                continue
            e[d[i][j]] += 1

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

if __name__ == "__main__":
    main()

# Optimized solution
def main():
    N, X, Y = list(map(int, input().split()))
    tree = [[float('inf')] * N for _ in range(N)]
    ans = [0] * (N + 1)
    X -= 1
    Y -= 1
    for i in range(N):
        for j in range(i,N):
            dist = min(j - i, abs(X - i) + 1 + abs(Y - j))
            ans[dist] += 1

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


if __name__ == "__main__":
    main()
# Original solution
N, X, Y = list(map(int, input().split(" ")))

counts = [0 for i in range(N-1)]

distances = [[] for i in range(N-1)] 

for i in range(N):
    for j in range(i+1, N):
        dis = j-i
        if i <= X-1 :
            if j >= Y-1:
                dis -= Y-X-1
            elif j < Y-1:
                dis = min([j-i, (X-1)-i+1+abs(j-(Y-1))])             
        else:
            dis = min([j-i, i-(X-1)+1+abs(j-(Y-1))])
        
        distances[i].append(dis)
for i in range(N-1):
    for j in range(N-i-1):
        k = distances[i][j]-1
        counts[k] += 1
        
for k in range(N-1):
    print((counts[k]))

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

counts = [0 for i in range(N-1)]

for i in range(N):
    for j in range(i+1, N):
        if i <= X-1 :
            if j >= Y-1:
                dis = j-i -(Y-X-1)
            elif j < Y-1:
                dis = min([j-i, (X-1)-i+1+abs(j-(Y-1))])
                
        else:
            dis = min([j-i, i-(X-1)+1+abs(j-(Y-1))])
        
        # distances[i].append(dis)
        k = dis-1
        counts[k] += 1
        
for k in range(N-1):
    print((counts[k]))
# Original solution
from collections import deque
infty = 10 ** 4

def BFS(G, D, u):
    queue = deque()
    queue.append(u)
    visit = [False for k in range(len(D))]
    d = 0
    L = 1
    visit[i] = True
    while queue:
        add_v = 0
        while L > 0:
            v = queue.popleft()
            D[v] = d
            L -= 1
            for j in G[v]:
                if not visit[j]:
                    queue.append(j)
                    visit[j] = True
                    add_v += 1
        d += 1
        L = add_v
    return D

N, X, Y = list(map(int, input().split()))
G = [[1]]
for i in range(1, N - 1):
    G.append([i - 1, i + 1])
G.append([N - 2])
G[X - 1].append(Y - 1)
G[Y - 1].append(X - 1)
dist = [[infty for j in range(N)] for i in range(N)]
for i in range(N):
    dist[i] = BFS(G, dist[i], i)
count = [0 for i in range(N)]
for i in range(N):
    for j in range(N):
        count[dist[i][j]] += 1
for i in range(N - 1):
    print((count[i + 1] // 2))

# Optimized solution
N, X, Y = list(map(int, input().split()))
count = [0 for i in range(N)]
dist = [[-1 for j in range(N)] for i in range(N)]
for i in range(N):
    for j in range(i + 1, N):
        dist[i][j] = min(abs(j - i), abs(X - 1 - i) + 1 + abs(Y - 1 - j))
for i in range(N):
    for j in range(i + 1, N):
        count[dist[i][j]] += 1
for i in range(1, N):
    print((count[i]))
# Original solution
import heapq
import sys
def main():
    input = sys.stdin.readline

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

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

    edge = [[] for i in range(n)]
    #edge[i] : iから出る道の[重み,行先]の配列
    for i in range(n-1):
        edge[i].append((1,i+1))
        edge[i+1].append((1,i))
    edge[x-1].append((1,y-1))
    edge[y-1].append((1,x-1))

    for i in range(n):
        edge[i] = tuple(edge[i])
    edge = tuple(edge)

    ans = [0 for _ in range(n)]
    for i in range(n):
        #dijkstra(始点,edge)
        res = dijkstra(i,edge)
        for j in range(i+1,n):
            ans[res[j]] += 1

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

if __name__ == '__main__':
    main()


# Optimized solution
import heapq
import sys

input = sys.stdin.readline

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

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

edge = [[] for i in range(n)]
#edge[i] : iから出る道の[重み,行先]の配列
for i in range(n-1):
    edge[i].append((1,i+1))
    edge[i+1].append((1,i))
edge[x-1].append((1,y-1))
edge[y-1].append((1,x-1))

for i in range(n):
    edge[i] = tuple(edge[i])
edge = tuple(edge)

ans = [0 for _ in range(n)]
for i in range(n):
    #dijkstra(始点,edge)
    res = dijkstra(i,edge)
    for j in range(i+1,n):
        ans[res[j]] += 1

for i in range(1,n):
    print((ans[i]))
# Original solution
import heapq
import sys

input = sys.stdin.readline

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

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

edge = [[] for i in range(n)]
#edge[i] : iから出る道の[重み,行先]の配列
for i in range(n-1):
    edge[i].append([1,i+1])
    edge[i+1].append([1,i])
edge[x-1].append([1,y-1])
edge[y-1].append([1,x-1])

ans = [0 for _ in range(n)]
for i in range(n):
    #dijkstra(始点,edge)
    res = dijkstra(i,edge)
    for j in range(i+1,n):
        ans[res[j]] += 1

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


# Optimized solution
import heapq
import sys
def main():
    input = sys.stdin.readline

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

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

    edge = [[] for i in range(n)]
    #edge[i] : iから出る道の[重み,行先]の配列
    for i in range(n-1):
        edge[i].append((1,i+1))
        edge[i+1].append((1,i))
    edge[x-1].append((1,y-1))
    edge[y-1].append((1,x-1))

    for i in range(n):
        edge[i] = tuple(edge[i])
    edge = tuple(edge)

    ans = [0 for _ in range(n)]
    for i in range(n):
        #dijkstra(始点,edge)
        res = dijkstra(i,edge)
        for j in range(i+1,n):
            ans[res[j]] += 1

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

if __name__ == '__main__':
    main()
# Original solution
n, x, y = list(map(int, input().split()))
ans = [0 for i in range(n-1)]
for i in range(n-1):
  for j in range(i+1, n):
    k = i + 1
    l = j + 1
    a = l - k
    b_1 = k - x
    b_2 = l - y
    c_1 = k - y
    c_2 = l - x
    if b_1 < 0:
      b_1 = - b_1
    if b_2 < 0:
      b_2 = - b_2
    if c_1 < 0:
      c_1 = - c_1
    if c_2 < 0:
      c_2 = - c_2
    b = b_1 + b_2 + 1
    c = c_1 + c_2 + 1
    if b < a:
      a = b
    if c < a:
      a = c
    ans[a-1] += 1
for i in ans:
  print(i)

# Optimized solution
n, x, y = list(map(int, input().split()))
ans = [0 for i in range(n-1)]
for i in range(n-1):
  k = i + 1
  b_1 = k - x
  c_1 = k - y
  if b_1 < 0:
      b_1 = - b_1
  if c_1 < 0:
      c_1 = - c_1
  for j in range(i+1, n):
    l = j + 1
    a = l - k
    b_2 = l - y
    c_2 = l - x
    if b_2 < 0:
      b_2 = - b_2
    if c_2 < 0:
      c_2 = - c_2
    b = b_1 + b_2 + 1
    c = c_1 + c_2 + 1
    if b < a:
      a = b
    if c < a:
      a = c
    ans[a-1] += 1
for i in range(n-1):
  print((ans[i]))
# Original solution
n, x, y = list(map(int, input().split()))
ans = [0 for i in range(n-1)]
for i in range(n-1):
  k = i + 1
  b_1 = k - x
  if b_1 < 0:
      b_1 = - b_1
  for j in range(i+1, n):
    l = j + 1
    a = l - k
    b_2 = l - y
    if b_2 < 0:
      b_2 = - b_2
    b = b_1 + b_2 + 1
    if b < a:
      a = b
    ans[a-1] += 1
for i in range(n-1):
  print((ans[i]))

# Optimized solution
n, x, y = list(map(int, input().split()))
ans = [0 for i in range(n-1)]
for i in range(n-1):
  k = i + 1
  b_1 = k - x
  for j in range(i+1, n):
    l = j + 1
    a = l - k
    b = abs(k - x) + abs(l - y) + 1
    if b < a:
      a = b
    ans[a-1] += 1
for i in range(n-1):
  print((ans[i]))
# Original solution
n, x, y = list(map(int, input().split()))
ans = [0 for i in range(n-1)]
for i in range(n-1):
  k = i + 1
  b_1 = k - x
  for j in range(i+1, n):
    l = j + 1
    a = l - k
    b = abs(k - x) + abs(l - y) + 1
    if b < a:
      a = b
    ans[a-1] += 1
for i in range(n-1):
  print((ans[i]))

# Optimized solution
n, x, y = list(map(int, input().split()))
ans = [0 for i in range(n-1)]
for i in range(n-1):
  k = i + 1
  b_1 = k - x
  for j in range(i+1, n):
    l = j + 1
    a = l - k
    b = abs(k - x) + abs(l - y) + 1
    if b < a:
      ans[b-1] += 1
    else:
      ans[a-1] += 1
for i in range(n-1):
  print((ans[i]))
# Original solution
[N, X, Y] = [int(item) for item in input().split()]
X -= 1
Y -= 1
array=[[-1 for _ in range(N)]for _ in range(N)]
for i in range(N):
    for j in range(i,N):
        array[i][j]=min(abs(i-j),abs(i-X)+1+abs(Y-j),abs(i-Y)+1+abs(X-j))
#print(array)

count=[0 for _ in range(N)]
for i in range(N):
    for j in range(i,N):
        count[array[i][j]]+=1
for i in range(1,N):
        print((count[i]))

#print(count)

# Optimized solution
[N, X, Y] = [int(item) for item in input().split()]
X -= 1
Y -= 1
count=[0 for _ in range(N)]
for i in range(N):
    for j in range(i,N):
        count[min(abs(i-j),abs(i-X)+1+abs(Y-j),abs(i-Y)+1+abs(X-j))]+=1
#print(array)


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

#print(count)
# Original solution
n,x,y = list(map(int,input().split()))

mn_ln = [[0 for _ in range(n-1)] for _ in range(n)]

dic = {}
x = x-1
y = y-1
for i in range(n):
    for j in range(n):
        if(i == j):
            break

        nm = abs(j - i)
        if(abs(x-i) > abs(y-i)):
            lp = abs(y-i) + abs(x-j) + 1
        else:
            lp = abs(x-i) + abs(y-j) + 1
        
        k = min(nm,lp)
        if(k in dic):
            dic[k] += 1
        else:
            dic[k] = 1
#print(dic[2])


for i in range(1,n):
    if not (i in dic):
        print((0))
    else:
        print((dic[i]))


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


dic = {}
x = x-1
y = y-1
for i in range(n):
    for j in range(n):
        if(i == j):
            break

        nm = abs(j - i)
        if(abs(x-i) > abs(y-i)):
            lp = abs(y-i) + abs(x-j) + 1
        else:
            lp = abs(x-i) + abs(y-j) + 1
        
        k = min(nm,lp)
        if(k in dic):
            dic[k] += 1
        else:
            dic[k] = 1



for i in range(1,n):
    if not (i in dic):
        print((0))
    else:
        print((dic[i]))
# Original solution
# coding: utf-8
# Your code here!

#保存
import heapq
import sys
import itertools
 
sys.setrecursionlimit(10**7)

def bfs(cost,node):
    root[node]=min(root[node],cost)
    visited[node]=1
    for next_n in way[node]:
        if visited[next_n]==0:
            heapq.heappush(q,[cost+1,next_n])
    return
    
N,X,Y=list(map(int,input().split()))
r=[i for i in range(N)]

way=[[] for i in range(N)]

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

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

#print(way)

made=[]


#print(q)
for start in r:
    root=[10**9]*N
    visited=[0]*N
    #print(root)
    q=[[0,start]]
    heapq.heapify(q)#costとnode
    while q:
        temp=heapq.heappop(q)
        #print(temp)
        #print(temp)
        if visited[temp[1]]==0:
            bfs(temp[0],temp[1])
    made.append(root)
#print(made)

ans=[0]*(N)
for item in made:
    for num in item:
        ans[num]+=1

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

"""
ans=10**9
for order in itertools.permutations([i for i in range(len(r))]):
    #print(order)
    temp=0
    for i in range(len(order)-1):
        fro=r[order[i]]
        aft=r[order[i+1]]
        #print("YES")
        #print(order[i]-1,order[i+1]-1)
        #print(root[order[i]-1][0])
        temp+=abs(made[order[i]][aft-1]-made[order[i]][fro-1])
    ans=min(ans,temp)
print(ans)
"""



# Optimized solution
# coding: utf-8
# Your code here!
N,X,Y=list(map(int,input().split()))
X-=1
Y-=1

ans=[0]*N
for n in range(N-1):
    for tgt in range(n+1,N):
        temp=min(abs(tgt-n),abs(n-X)+abs(Y-tgt)+1)
        #print(n,tgt,temp)
        ans[temp]+=1


for a in ans[1:]:
    print(a)
# Original solution
INF = float('inf')
N, X, Y = list(map(int, input().split()))
G = [[0 if i == j else INF for j in range(N)] for i in range(N)]
for i in range(N-1):
  G[i][i+1] = G[i+1][i] = 1
G[X-1][Y-1] = G[Y-1][X-1] = 1
for k in range(N):
  for i in range(N):
    for j in range(N):
      G[i][j] = min(G[i][j], G[i][k] + G[k][j])
for k in range(1, N):
  rk = 0
  for i in range(N):
    for j in range(N):
      if j <= i: continue
      if G[i][j] == k:
        rk += 1
  print(rk)

# Optimized solution
N, X, Y = list(map(int, input().split()))
X -= 1
Y -= 1
R = [0 for j in range(N)]
for i in range(N-1):
  for j in range(N):
    if j <= i:
      continue
    xd = abs(i - X)
    yd = abs(j - Y)
    dist = min(
      j - i,
      xd + yd + 1
    )
    R[dist] += 1
for r in R[1:]:
  print(r)
# Original solution
from collections import deque

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

inf = 100100100

x -= 1
y -= 1

ans = [0] * n

for i in range(n):
    dist = [inf] * n
    queue = deque()
    queue.append(i)
    dist[i] = 0
    while queue:
        current = queue.popleft()
        d = dist[current]

        if current - 1 >= 0 and dist[current - 1] == inf:
            queue.append(current - 1)
            dist[current - 1] = d + 1
        if current + 1 < n and dist[current + 1] == inf:
            queue.append(current + 1)
            dist[current + 1] = d + 1
        if current == x and dist[y] == inf:
            queue.append(y)
            dist[y] = d + 1
        if current == y and dist[x] == inf:
            queue.append(x)
            dist[x] = d + 1

    for j in range(n):
        ans[dist[j]] += 1

for k in range(1, n):
    print((ans[k] // 2))


# Optimized solution
from collections import deque, Counter

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

inf = 100100100
x -= 1
y -= 1

ans = [0] * n

for i in range(n):
    dist = [inf] * n
    queue = deque()
    queue.append(i)
    dist[i] = 0
    while queue:
        current = queue.popleft()
        d = dist[current]

        if current - 1 >= 0 and dist[current - 1] == inf:
            queue.append(current - 1)
            dist[current - 1] = d + 1
        if current + 1 < n and dist[current + 1] == inf:
            queue.append(current + 1)
            dist[current + 1] = d + 1
        if current == x and dist[y] == inf:
            queue.append(y)
            dist[y] = d + 1
        if current == y and dist[x] == inf:
            queue.append(x)
            dist[x] = d + 1

    for j in range(n):
        ans[dist[j]] += 1

for k in range(1, n):
    print((ans[k] // 2))
# Original solution
# D
# -*- coding: utf-8 -*-
N, X, Y = list(map(int, input().split()))
X -= 1
Y -= 1

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

for i in range(1, N):
    ans = 0
    for j in range(N):
        ans += ans_list[j].count(i)
    print(ans)

# Optimized solution
# D
# -*- coding: utf-8 -*-
N, X, Y = list(map(int, input().split()))
X -= 1
Y -= 1

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

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