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

import scala.collection.mutable
import scala.collection.mutable.ArrayBuffer

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) match {
      case Array(n, x, y) => Array(n, x - 1, y - 1)
    }

    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(i: Int, j: Int): Int = {
      if (i < j) {
        memo(j)(i)
      } else {
        memo(i)(j)
      }
    }

    @inline
    def update(i: Int, j: Int, value: Int): Unit = {
      if (0 <= i && 0 <= j && i < n && j < n) {
        val current = lookup(i, j)
        if (current > value) {
          count(current) -= 1
          if (i < j) {
            memo(j)(i) = value
            queue.enqueue((j, i, value))
          } else {
            memo(i)(j) = value
            queue.enqueue((i, j, value))
          }
          count(value) += 1
        }
      }
    }

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

    while (queue.nonEmpty) {
      val (i, j, step) = queue.dequeue()
      update(i + 1, j, step + 1)
      update(i - 1, j, step + 1)
      update(i, j + 1, step + 1)
      update(i, j - 1, step + 1)
      if (i == x) {
        update(y, j, step + 1)
      }
      if (i == y) {
        update(x, j, step + 1)
      }
      if (j == x) {
        update(i, y, step + 1)
      }
      if (j == y) {
        update(i, x, step + 1)
      }
    }

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

    out.flush()
  }
}
