from bisect import bisect_left

from bisect import bisect_right





N = int(eval(input()))

L = list(map(int, input().split()))

L.sort()



"""

短いほうから２本固定して条件に合うものをさがす（長いほうから２本固定でもOK）

最長と最短を固定するとややこしくなるから、こういう場合は最長/最短どちらかから固定するほうがいいか

"""





ans = 0

for i in range(N-2):

    a = L[i]

    for j in range(i+1, N-1):

        b = L[j]

        # そもそもcがaやbより大きいので、下の解法のようにilを求める必要などなく、il=で考えれば良かったんや！

        k = bisect_left(L, a+b)

        ans += k - j - 1







"""

ans = 0

for i in range(N):

    for j in range(i+1, N):

        l = L[j] - L[i]

        r = L[j] + L[i]

        #  a < b < c（場合によっては等号を含む）で考えたときの、b - a < cを満たすもの 

        il = bisect_right(L, l, lo=j)

        #  a < b < c（場合によっては等号を含む）で考えたときの、c < a + bを満たすもの

        ir = bisect_left(L, r, lo=j)

        # b - a < cを満たすものがない場合、飛ばす

        if il == N-1:

            break

        

        ans += ir - il - 1

"""



print(ans)

from bisect import bisect_left

from bisect import bisect_right





N = int(eval(input()))

L = list(map(int, input().split()))

L.sort()



"""

短いほうから２本固定して条件に合うものをさがす（長いほうから２本固定でもOK）

最長と最短を固定するとややこしくなるから、こういう場合は最長/最短どちらかから固定するほうがいいか

"""





ans = 0

for i in range(N-2):

    a = L[i]

    for j in range(i+1, N-1):

        #b = L[j]

        # そもそもcがaやbより大きいので、下の解法のようにilを求める必要などなく、il=で考えれば良かったんや！

        k = bisect_left(L, a+L[j])

        ans += k - j - 1







"""

ans = 0

for i in range(N):

    for j in range(i+1, N):

        l = L[j] - L[i]

        r = L[j] + L[i]

        #  a < b < c（場合によっては等号を含む）で考えたときの、b - a < cを満たすもの 

        il = bisect_right(L, l, lo=j)

        #  a < b < c（場合によっては等号を含む）で考えたときの、c < a + bを満たすもの

        ir = bisect_left(L, r, lo=j)

        # b - a < cを満たすものがない場合、飛ばす

        if il == N-1:

            break

        

        ans += ir - il - 1

"""



print(ans)

from bisect import bisect_left
from bisect import bisect_right

N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
"""
短いほうから２本固定して条件に合うものをさがす（長いほうから２本固定でもOK）
最長と最短を固定するとややこしくなるから、こういう場合は最長/最短どちらかから固定するほうがいいか
"""
ans = 0
for i in range(N - 2):
    a = L[i]
    for j in range(i + 1, N - 1):
        b = L[j]
        # そもそもcがaやbより大きいので、下の解法のようにilを求める必要などなく、il=で考えれば良かったんや！
        k = bisect_left(L, a + b)
        ans += k - j - 1
"""
ans = 0
for i in range(N):
    for j in range(i+1, N):
        l = L[j] - L[i]
        r = L[j] + L[i]
        #  a < b < c（場合によっては等号を含む）で考えたときの、b - a < cを満たすもの 
        il = bisect_right(L, l, lo=j)
        #  a < b < c（場合によっては等号を含む）で考えたときの、c < a + bを満たすもの
        ir = bisect_left(L, r, lo=j)
        # b - a < cを満たすものがない場合、飛ばす
        if il == N-1:
            break
        ans += ir - il - 1
"""
print(ans)

from bisect import bisect_left
from bisect import bisect_right

N = int(eval(input()))
L = list(map(int, input().split()))
L.sort()
"""
短いほうから２本固定して条件に合うものをさがす（長いほうから２本固定でもOK）
最長と最短を固定するとややこしくなるから、こういう場合は最長/最短どちらかから固定するほうがいいか
"""
ans = 0
for i in range(N - 2):
    a = L[i]
    for j in range(i + 1, N - 1):
        # b = L[j]
        # そもそもcがaやbより大きいので、下の解法のようにilを求める必要などなく、il=で考えれば良かったんや！
        k = bisect_left(L, a + L[j])
        ans += k - j - 1
"""
ans = 0
for i in range(N):
    for j in range(i+1, N):
        l = L[j] - L[i]
        r = L[j] + L[i]
        #  a < b < c（場合によっては等号を含む）で考えたときの、b - a < cを満たすもの 
        il = bisect_right(L, l, lo=j)
        #  a < b < c（場合によっては等号を含む）で考えたときの、c < a + bを満たすもの
        ir = bisect_left(L, r, lo=j)
        # b - a < cを満たすものがない場合、飛ばす
        if il == N-1:
            break
        ans += ir - il - 1
"""
print(ans)

-        b = L[j] +        # b = L[j] -        k = bisect_left(L, a + b) +        k = bisect_left(L, a + L[j])