import java.io.{BufferedOutputStream, BufferedReader, InputStreamReader, PrintWriter}

import scala.collection.mutable

object Main {
  def main(args: Array[String]): Unit = {
    val in = new BufferedReader(new InputStreamReader(System.in))
    val out = new PrintWriter(new BufferedOutputStream(System.out))
    val Array(n, x, y) = in.readLine().split("\\s+").map(_.toInt)

    val memo = Array.fill[Int](n, n)(n - 1)
    val count = Array.ofDim[Int](n)
    count(n - 1) = (n + 1) * n / 2

    val queue = mutable.PriorityQueue.empty[(Int, Int, Int)](Ordering.by((_: (Int, Int, Int))._3).reverse)

    @inline
    def lookup(x: Int, y: Int): Int = {
      if (x < y) {
        memo(y)(x)
      } else {
        memo(x)(y)
      }
    }

    @inline
    def update(x: Int, y: Int, value: Int): Unit = {
      count(lookup(x, y)) -= 1
      if (x < y) {
        memo(y)(x) = value
      } else {
        memo(x)(y) = value
      }
      count(value) += 1
      queue.enqueue((x, y, value))
    }

    for (i <- 0 until n) {
      update(i, i, 0)
    }

    for (i <- 0 until n - 1) {
      update(i + 1, i, 1)
    }
    update(x - 1, y - 1, 1)

    while (queue.nonEmpty) {
      val (x, y, step) = queue.dequeue()
      if (lookup(x, y) >= step) {
        for {
          nx <- 0 until n
        } {
          val current = lookup(nx, y)
          val trial = Math.min(lookup(nx, x) + step, n - 1)
          if (trial < current) {
            update(nx, y, trial)
          }
        }
        for {
          ny <- 0 until n
        } {
          val current = lookup(x, ny)
          val trial = Math.min(lookup(y, ny) + step, n - 1)
          if (trial < current) {
            update(x, ny, trial)
          }
        }
      }
    }

    for (i <- 1 until count.length) {
      out.println(count(i))
    }

    out.flush()
  }
}
