output_description: For each k=1, 2, ..., N-1 in this order, print a line containing the answer to
  the problem.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N X Y
attempt: # from sys import stdin
  
  # # 解説のコード
  # def get_result(data):
  #     N, X, Y = data
  #     dist_cnt = [0 for i in range(N)]
  #     for i in range(1, N+1):
  #         for j in range(i+1, N+1):
  #             min_dist = min([j-i, abs(X-i) + 1 + abs(Y-j), abs(Y-i) + 1 + abs(X-j)])
  #             dist_cnt[min_dist] += 1
  #     for i in range(1, N):
  #         print(dist_cnt[i])
  
  
  # if __name__ == '__main__':
  #     data = list(map(int, stdin.readline().rstrip('\n').split(' ')))
  #     get_result(data)
  
  from sys import stdin
  from collections import deque
  
  
  class BreadthFirstSearch:
      def __init__(self, num_nodes):
          self.n = num_nodes
          self.graph = [[] for _ in range(self.n)]
  
      # Edge数分回すことを想定
      def add_edge(self, start, end, undirected=True):
          self.graph[start].append(end)
          if undirected:
              self.graph[end].append(start)
  
      # depth = distance
      def search(self, start_node):
          order = [-1] * self.n  # a bfs ordering of each vertex
          parent = [-1] * self.n  # parent of each vertex in the bfs search tree
          depth = [-1] * self.n  # the depth of each vertex
          q = deque([(start_node, -1, 0)])  # (vertex, parent, depth)
          num = 0  # current ordering
          while len(q) > 0:
              v, p, d = q.popleft()
              if order[v] < 0:  # visited v for the first time
                  order[v] = num
                  parent[v] = p
                  depth[v] = d
                  num += 1
                  for u in self.graph[v]:
                      if order[u] >= 0:
                          continue
                      q.append((u, v, d + 1))
          return order, parent, depth
  
  
  # BFS pypyでAC
  def get_result(data):
      N, X, Y = data
      _data = [[i, i + 1] for i in range(1, N)]
      _data += [[X, Y]]
      bfs = BreadthFirstSearch(N)
      for val in _data:
          bfs.add_edge(val[0] - 1, val[1] - 1)
      dist_cnt = [0 for i in range(N)]
      for i in range(N):
          _, _, depth = bfs.search(i)
          for j in range(i, N):
              dist_cnt[depth[j]] += 1
      for i in range(1, N):
          print(dist_cnt[i])
  
  
  if __name__ == "__main__":
      data = list(map(int, stdin.readline().rstrip("\n").split(" ")))
      get_result(data)
  
problem_description: Statement
  
  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.
samples: [{"input": "5 2 4", "output": "5\n    4\n    1\n    0\n    \n\nThe graph in this input is as follows:  \n  \n![Figure](https://img.atcoder.jp/ghi/3ae0885a4aeda99694b9fde4efe39dc1.png)  \n  \nThere are five pairs (i,j) (1 \\leq i < j \\leq N) such that the shortest\ndistance between Vertex i and Vertex j is 1:\n(1,2)\\,,(2,3)\\,,(2,4)\\,,(3,4)\\,,(4,5).  \nThere are four pairs (i,j) (1 \\leq i < j \\leq N) such that the shortest\ndistance between Vertex i and Vertex j is 2: (1,3)\\,,(1,4)\\,,(2,5)\\,,(3,5).  \nThere is one pair (i,j) (1 \\leq i < j \\leq N) such that the shortest distance\nbetween Vertex i and Vertex j is 3: (1,5).  \nThere are no pairs (i,j) (1 \\leq i < j \\leq N) such that the shortest distance\nbetween Vertex i and Vertex j is 4.\n\n* * *"}, {"input": "3 1 3", "output": "3\n    0\n    \n\nThe graph in this input is as follows:  \n  \n![Figure](https://img.atcoder.jp/ghi/be2921b3b307fc993a390a59437e624e.png)  \n  \n\n* * *"}, {"input": "7 3 7", "output": "7\n    8\n    4\n    2\n    0\n    0\n    \n\n* * *"}, {"input": "10 4 8", "output": "10\n    12\n    10\n    8\n    4\n    1\n    0\n    0\n    0"}]