import java.lang.Math.abs
import java.lang.Math.min

fun main(args: Array<String>) = ABC160D2.main()

object ABC160D2 {
    fun log(message: Any?) {
        println(message)// TODO: ←消す
    }

    val N: Int
    val X: Int
    val Y: Int

    init {
        val (n, x, y) = readInts()
        N = n
        X = x
        Y = y
    }

    fun main() {
        val combinations = (1..N).combination(2)
            .map { it.first() to it.last() }
        val distances = combinations.map { minDist(it.first, it.second) }

        // k -> count
        val distCounts = distances.toList().bucketCount()
        (1..N - 1).forEach { k ->
            val ans = distCounts[k] ?: 0
            println(ans)
        }
    }

    fun minDist(i: Int, j: Int): Int {
        val choice1 = abs(i - j)
        val choice2 = abs(i - X) + 1 + abs(Y - j)
        val choice3 = abs(i - Y) + 1 + abs(X - j)
        return min(choice1, min(choice2, choice3))
    }

    /*####################################################################################*/

    fun readInt() = readLine()!!.toInt()
    fun readInts() = readLine()!!.split(" ").map { it.toInt() }

    fun <T> List<T>.bucketCount(): Map<T, Int> {
        val bucket = hashMapOf<T, Int>()
        this.forEach {
            val current = bucket[it] ?: 0
            bucket[it] = current + 1
        }
        return bucket
    }

    fun IntRange.combination(k: Int): Sequence<List<Int>> = this.toList().combination(k)
    fun <T> List<T>.combination(k: Int): Sequence<List<T>> = Combination<T>().generate(this, k)
    class Combination<T> : BasicCombinator<T>() {
        override fun List<T>.chooseRemains(i: Int): List<T> = this.drop(i + 1)
    }

    abstract class BasicCombinator<T> {
        abstract fun List<T>.chooseRemains(i: Int): List<T>

        fun generate(items: List<T>, k: Int): Sequence<List<T>> {
            when {
                (k < 0) ->
                    throw IllegalArgumentException()
                (k == 0) ->
                    return emptySequence()
                (k == 1) ->
                    return items.asSequence().map { listOf(it) }
                else ->
                    return items.asSequence().mapIndexed { index, first ->
                        val remains = items.chooseRemains(index)
                        generate(remains, k - 1).map { first + it }
                    }.flatten()
            }
        }

        private operator fun T.plus(other: List<T>): List<T> {
            val list = mutableListOf(this)
            list.addAll(other)
            return list
        }
    }
}