mod = 10**9 + 7



def iip(listed = False):

    ret = [int(i) for i in input().split()]

    if len(ret) == 1 and not listed:

        return ret[0]

    return ret



def soinsuu_bunkai(n):

    ret = []

    for i in range(2, int(n**0.5)+1):

        while n % i == 0:

            n //= i

            ret.append(i)

        if i > n:

            break

    if n != 1:

        ret.append(n)

    return ret





def conbination(n, r, mod, test=False):

    if n <=0:

        return 0

    if r == 0:

        return 1

    if r < 0:

        return 0

    if r == 1:

        return n

    ret = 1

    for i in range(n-r+1, n+1):

        ret *= i

        ret = ret % mod



    bunbo = 1

    for i in range(1, r+1):

        bunbo *= i

        bunbo = bunbo % mod



    ret = (ret * inv(bunbo, mod)) % mod

    if test:

        #print(f"{n}C{r} = {ret}")

        pass

    return ret





def inv(n, mod):

    return power(n, mod-2)



def power(n, p):

    if p == 0:

        return 1

    if p % 2 == 0:

        return (power(n, p//2) ** 2) % mod

    if p % 2 == 1:

        return (n * power(n, p-1)) % mod



#####################################################ライブラリ集ここまで



def main():

    N, X, Y = iip()

    X -= 1

    Y -= 1



    ret = 0



    result = []

    for k in range(1, N):

        ret = 0

        for i in range(N):

            ret += search(i, k, N, X, Y)

        result.append(str(ret))



    print(("\n".join(result)))



def search(a, k, N, X, Y):

    kouho = []



    if abs(a-X)+1+abs(a+k-Y) >= k and abs(a-Y) + 1 + abs(a+k-X) >= k:

        #print(f"追加 {a+k} a, k = {a}, {k} by 条件1")

        kouho.append(a+k)



    asy = k-abs(a-X)-1

    if asy < 0:

        pass

    elif asy == 0:

        if abs(a-X) + 1 <= abs(a-Y):

            kouho.append(Y)

            #print(f"追加 {Y} a, k = {a}, {k} by 条件6")

    else:

        if abs(a-(Y-asy)) > k:

            kouho.append(Y-asy)

            #print(f"追加 {Y-asy} a, k = {a}, {k} by 条件2")

        if abs(a-(Y+asy)) > k:

            #print(f"追加 {Y+asy} a, k = {a}, {k} by 条件3")

            kouho.append(Y+asy)



    asx = k-abs(a-Y)-1

    if asx < 0:

        pass

    elif asx == 0:

        if abs(a-Y) + 1 < abs(a-X):

            kouho.append(X)

            #print(f"追加 {X} a, k = {a}, {k} by 条件7")

    else:

        if abs(a-(X-asx)) > k:

            kouho.append(X-asx)

            #print(f"追加 {X-asx} a, k = {a}, {k} by 条件4")

        if abs(a-(X+asx)) > k:

            kouho.append(X+asx)

            #print(f"追加 {X+asx} a, k = {a}, {k} by 条件5")



    kakutei = []

    result = 0

    for kh in kouho:

        if kh == a:

            continue

        if kh < 0:

            continue

        if kh > N-1:

            continue

        if kh in kakutei:

            continue

        if kh < a:

            continue

        kakutei.append(kh)

        result += 1

    #print(f"--result開始 a, k = {a}, {k}")

    #print(result)

    #print(kakutei)

    #print("--result終了")

    return result







if __name__ == "__main__":

    main()
mod = 10**9 + 7



def iip(listed = False):

    ret = [int(i) for i in input().split()]

    if len(ret) == 1 and not listed:

        return ret[0]

    return ret



def soinsuu_bunkai(n):

    ret = []

    for i in range(2, int(n**0.5)+1):

        while n % i == 0:

            n //= i

            ret.append(i)

        if i > n:

            break

    if n != 1:

        ret.append(n)

    return ret





def conbination(n, r, mod, test=False):

    if n <=0:

        return 0

    if r == 0:

        return 1

    if r < 0:

        return 0

    if r == 1:

        return n

    ret = 1

    for i in range(n-r+1, n+1):

        ret *= i

        ret = ret % mod



    bunbo = 1

    for i in range(1, r+1):

        bunbo *= i

        bunbo = bunbo % mod



    ret = (ret * inv(bunbo, mod)) % mod

    if test:

        #print(f"{n}C{r} = {ret}")

        pass

    return ret





def inv(n, mod):

    return power(n, mod-2)



def power(n, p):

    if p == 0:

        return 1

    if p % 2 == 0:

        return (power(n, p//2) ** 2) % mod

    if p % 2 == 1:

        return (n * power(n, p-1)) % mod



#####################################################ライブラリ集ここまで



def main():

    N, X, Y = iip()

    X, Y = sorted((X-1, Y-1))

    #print(X, Y)



    result = [0 for i in range(1, N)]

    for a in range(0, N):

        for b in range(a+1, N):

            d1 = b-a

            d2 = abs(X-a)+abs(Y-b)+1

            d = min(d1, d2)-1

            #print(a, b, d)



            result[d] += 1



    print(("\n".join([str(i) for i in result])))





if __name__ == "__main__":

    main()
mod = 10**9 + 7


def iip(listed=False):
    ret = [int(i) for i in input().split()]
    if len(ret) == 1 and not listed:
        return ret[0]
    return ret


def soinsuu_bunkai(n):
    ret = []
    for i in range(2, int(n**0.5) + 1):
        while n % i == 0:
            n //= i
            ret.append(i)
        if i > n:
            break
    if n != 1:
        ret.append(n)
    return ret


def conbination(n, r, mod, test=False):
    if n <= 0:
        return 0
    if r == 0:
        return 1
    if r < 0:
        return 0
    if r == 1:
        return n
    ret = 1
    for i in range(n - r + 1, n + 1):
        ret *= i
        ret = ret % mod
    bunbo = 1
    for i in range(1, r + 1):
        bunbo *= i
        bunbo = bunbo % mod
    ret = (ret * inv(bunbo, mod)) % mod
    if test:
        # print(f"{n}C{r} = {ret}")
        pass
    return ret


def inv(n, mod):
    return power(n, mod - 2)


def power(n, p):
    if p == 0:
        return 1
    if p % 2 == 0:
        return (power(n, p // 2) ** 2) % mod
    if p % 2 == 1:
        return (n * power(n, p - 1)) % mod


#####################################################ライブラリ集ここまで
def main():
    N, X, Y = iip()
    X -= 1
    Y -= 1
    ret = 0
    result = []
    for k in range(1, N):
        ret = 0
        for i in range(N):
            ret += search(i, k, N, X, Y)
        result.append(str(ret))
    print(("\n".join(result)))


def search(a, k, N, X, Y):
    kouho = []
    if abs(a - X) + 1 + abs(a + k - Y) >= k and abs(a - Y) + 1 + abs(a + k - X) >= k:
        # print(f"追加 {a+k} a, k = {a}, {k} by 条件1")
        kouho.append(a + k)
    asy = k - abs(a - X) - 1
    if asy < 0:
        pass
    elif asy == 0:
        if abs(a - X) + 1 <= abs(a - Y):
            kouho.append(Y)
            # print(f"追加 {Y} a, k = {a}, {k} by 条件6")
    else:
        if abs(a - (Y - asy)) > k:
            kouho.append(Y - asy)
            # print(f"追加 {Y-asy} a, k = {a}, {k} by 条件2")
        if abs(a - (Y + asy)) > k:
            # print(f"追加 {Y+asy} a, k = {a}, {k} by 条件3")
            kouho.append(Y + asy)
    asx = k - abs(a - Y) - 1
    if asx < 0:
        pass
    elif asx == 0:
        if abs(a - Y) + 1 < abs(a - X):
            kouho.append(X)
            # print(f"追加 {X} a, k = {a}, {k} by 条件7")
    else:
        if abs(a - (X - asx)) > k:
            kouho.append(X - asx)
            # print(f"追加 {X-asx} a, k = {a}, {k} by 条件4")
        if abs(a - (X + asx)) > k:
            kouho.append(X + asx)
            # print(f"追加 {X+asx} a, k = {a}, {k} by 条件5")
    kakutei = []
    result = 0
    for kh in kouho:
        if kh == a:
            continue
        if kh < 0:
            continue
        if kh > N - 1:
            continue
        if kh in kakutei:
            continue
        if kh < a:
            continue
        kakutei.append(kh)
        result += 1
    # print(f"--result開始 a, k = {a}, {k}")
    # print(result)
    # print(kakutei)
    # print("--result終了")
    return result


if __name__ == "__main__":
    main()

mod = 10**9 + 7


def iip(listed=False):
    ret = [int(i) for i in input().split()]
    if len(ret) == 1 and not listed:
        return ret[0]
    return ret


def soinsuu_bunkai(n):
    ret = []
    for i in range(2, int(n**0.5) + 1):
        while n % i == 0:
            n //= i
            ret.append(i)
        if i > n:
            break
    if n != 1:
        ret.append(n)
    return ret


def conbination(n, r, mod, test=False):
    if n <= 0:
        return 0
    if r == 0:
        return 1
    if r < 0:
        return 0
    if r == 1:
        return n
    ret = 1
    for i in range(n - r + 1, n + 1):
        ret *= i
        ret = ret % mod
    bunbo = 1
    for i in range(1, r + 1):
        bunbo *= i
        bunbo = bunbo % mod
    ret = (ret * inv(bunbo, mod)) % mod
    if test:
        # print(f"{n}C{r} = {ret}")
        pass
    return ret


def inv(n, mod):
    return power(n, mod - 2)


def power(n, p):
    if p == 0:
        return 1
    if p % 2 == 0:
        return (power(n, p // 2) ** 2) % mod
    if p % 2 == 1:
        return (n * power(n, p - 1)) % mod


#####################################################ライブラリ集ここまで
def main():
    N, X, Y = iip()
    X, Y = sorted((X - 1, Y - 1))
    # print(X, Y)
    result = [0 for i in range(1, N)]
    for a in range(0, N):
        for b in range(a + 1, N):
            d1 = b - a
            d2 = abs(X - a) + abs(Y - b) + 1
            d = min(d1, d2) - 1
            # print(a, b, d)
            result[d] += 1
    print(("\n".join([str(i) for i in result])))


if __name__ == "__main__":
    main()

-    X -= 1 -    Y -= 1 -    ret = 0 -    result = [] -    for k in range(1, N): -        ret = 0 -        for i in range(N): -            ret += search(i, k, N, X, Y) -        result.append(str(ret)) -    print(("\n".join(result))) - - -def search(a, k, N, X, Y): -    kouho = [] -    if abs(a - X) + 1 + abs(a + k - Y) >= k and abs(a - Y) + 1 + abs(a + k - X) >= k: -        # print(f"追加 {a+k} a, k = {a}, {k} by 条件1") -        kouho.append(a + k) -    asy = k - abs(a - X) - 1 -    if asy < 0: -        pass -    elif asy == 0: -        if abs(a - X) + 1 <= abs(a - Y): -            kouho.append(Y) -            # print(f"追加 {Y} a, k = {a}, {k} by 条件6") -    else: -        if abs(a - (Y - asy)) > k: -            kouho.append(Y - asy) -            # print(f"追加 {Y-asy} a, k = {a}, {k} by 条件2") -        if abs(a - (Y + asy)) > k: -            # print(f"追加 {Y+asy} a, k = {a}, {k} by 条件3") -            kouho.append(Y + asy) -    asx = k - abs(a - Y) - 1 -    if asx < 0: -        pass -    elif asx == 0: -        if abs(a - Y) + 1 < abs(a - X): -            kouho.append(X) -            # print(f"追加 {X} a, k = {a}, {k} by 条件7") -    else: -        if abs(a - (X - asx)) > k: -            kouho.append(X - asx) -            # print(f"追加 {X-asx} a, k = {a}, {k} by 条件4") -        if abs(a - (X + asx)) > k: -            kouho.append(X + asx) -            # print(f"追加 {X+asx} a, k = {a}, {k} by 条件5") -    kakutei = [] -    result = 0 -    for kh in kouho: -        if kh == a: -            continue -        if kh < 0: -            continue -        if kh > N - 1: -            continue -        if kh in kakutei: -            continue -        if kh < a: -            continue -        kakutei.append(kh) -        result += 1 -    # print(f"--result開始 a, k = {a}, {k}") -    # print(result) -    # print(kakutei) -    # print("--result終了") -    return result +    X, Y = sorted((X - 1, Y - 1)) +    # print(X, Y) +    result = [0 for i in range(1, N)] +    for a in range(0, N): +        for b in range(a + 1, N): +            d1 = b - a +            d2 = abs(X - a) + abs(Y - b) + 1 +            d = min(d1, d2) - 1 +            # print(a, b, d) +            result[d] += 1 +    print(("\n".join([str(i) for i in result])))