def Binary_Search_Small_Count(A,x,sort=True,equal=False):
    """2分探索によって,x未満の要素の個数を調べる.

    A:リスト
    x:調べる要素
    sort:ソートをする必要があるかどうか(Trueで必要)
    equal:Trueのときはx"未満"がx"以下"になる
    """
    if sort:
        A.sort()
        
    N=len(A)
    if A[-1]<x:
        return N
    elif x<A[0] or (not equal and x==A[0]):
        return 0

    L,R=0,N
    while R-L>1:
        C=L+(R-L)//2
        if x<A[C] or (not equal and x==A[C]):
            R=C
        else:
            L=C
    return R
#=======================================
N=int(input())
L=list(map(lambda x:int(x),input().split()))
inf=float("inf")

T={}
for i in range(N):
    x=L[i]
    if x in T:
        T[x]+=1
    else:
        T[x]=0
        
    L[i]=(x,T[L[i]])
L.sort()

D=0
for i in range(N):
    (b,y)=L[i]
    for j in range(i+1,N):
        (c,z)=L[j]

        X=Binary_Search_Small_Count(L,(b,y),False,False)
        Y=Binary_Search_Small_Count(L,(c-b,inf),False,True)

        D+=max(0,X-Y)
print(D) def Binary_Search_Small_Count(A,x,sort=True,equal=False):
    """2分探索によって,x未満の要素の個数を調べる.

    A:リスト
    x:調べる要素
    sort:ソートをする必要があるかどうか(Trueで必要)
    equal:Trueのときはx"未満"がx"以下"になる
    """
    if sort:
        A.sort()
        
    N=len(A)
    if A[-1]<x:
        return N
    elif x<A[0] or (not equal and x==A[0]):
        return 0

    L,R=0,N
    while R-L>1:
        C=L+(R-L)//2
        if x<A[C] or (not equal and x==A[C]):
            R=C
        else:
            L=C
    return R
#======================================= Binary_Search_Small_Count """2分探索によって,x未満の要素の個数を調べる.

    A:リスト
    x:調べる要素
    sort:ソートをする必要があるかどうか(Trueで必要)
    equal:Trueのときはx"未満"がx"以下"になる
    """ if sort:
        A.sort()
        
     sort A.sort() A.sort A sort N=len(A) N len(A) len A if A[-1]<x:
        return N
    elif x<A[0] or (not equal and x==A[0]):
        return 0

     A[-1]<x A[-1] A -1 x return N N elif x<A[0] or (not equal and x==A[0]):
        return 0

     x<A[0] or (not equal and x==A[0]) x<A[0] x A[0] A 0 not equal and x==A[0] not equal equal x==A[0] x A[0] A 0 return 0 0 L,R=0,N L 0 R N while R-L>1:
        C=L+(R-L)//2
        if x<A[C] or (not equal and x==A[C]):
            R=C
        else:
            L=C
     R-L>1 R-L R L 1 C=L+(R-L)//2 C L+(R-L)//2 L (R-L)//2 R-L R L 2 if x<A[C] or (not equal and x==A[C]):
            R=C
        else:
            L=C
     x<A[C] or (not equal and x==A[C]) x<A[C] x A[C] A C not equal and x==A[C] not equal equal x==A[C] x A[C] A C R=C R C L=C L C return R R A A x x sort=True sort True equal=False equal False N=int(input()) N int(input()) int input() input L=list(map(lambda x:int(x),input().split())) L list(map(lambda x:int(x),input().split())) list map(lambda x:int(x),input().split()) map lambda x:int(x) int(x) int x x input().split() ().split () input split inf=float("inf") inf float("inf") float "inf" T={} T {} for i in range(N):
    x=L[i]
    if x in T:
        T[x]+=1
    else:
        T[x]=0
        
    L[i]=(x,T[L[i]]) i range(N) range N x=L[i] x L[i] L i if x in T:
        T[x]+=1
    else:
        T[x]=0
        
     x in T x T T[x]+=1 T[x] T x 1 T[x]=0 T[x] T x 0 L[i]=(x,T[L[i]]) L[i] L i (x,T[L[i]]) x T[L[i]] T L[i] L i L.sort() L.sort L sort D=0 D 0 for i in range(N):
    (b,y)=L[i]
    for j in range(i+1,N):
        (c,z)=L[j]

        X=Binary_Search_Small_Count(L,(b,y),False,False)
        Y=Binary_Search_Small_Count(L,(c-b,inf),False,True)

        D+=max(0,X-Y) i range(N) range N (b,y)=L[i] (b,y) b y L[i] L i for j in range(i+1,N):
        (c,z)=L[j]

        X=Binary_Search_Small_Count(L,(b,y),False,False)
        Y=Binary_Search_Small_Count(L,(c-b,inf),False,True)

        D+=max(0,X-Y) j range(i+1,N) range i+1 i 1 N (c,z)=L[j] (c,z) c z L[j] L j X=Binary_Search_Small_Count(L,(b,y),False,False) X Binary_Search_Small_Count(L,(b,y),False,False) Binary_Search_Small_Count L (b,y) b y False False Y=Binary_Search_Small_Count(L,(c-b,inf),False,True) Y Binary_Search_Small_Count(L,(c-b,inf),False,True) Binary_Search_Small_Count L (c-b,inf) c-b c b inf False True D+=max(0,X-Y) D max(0,X-Y) max 0 X-Y X Y print(D) print D D=0 0 D X=Binary_Search_Small_Count(L,(b,y),False,False) Binary_Search_Small_Count(L,(b,y),False,False) X x=L[i] L[i] x inf=float("inf") float("inf") inf D+=max(0,X-Y) max(0,X-Y) D T={} {} T def Binary_Search_Small_Count(A,x,sort=True,equal=False):
    """2分探索によって,x未満の要素の個数を調べる.

    A:リスト
    x:調べる要素
    sort:ソートをする必要があるかどうか(Trueで必要)
    equal:Trueのときはx"未満"がx"以下"になる
    """
    if sort:
        A.sort()
        
    N=len(A)
    if A[-1]<x:
        return N
    elif x<A[0] or (not equal and x==A[0]):
        return 0

    L,R=0,N
    while R-L>1:
        C=L+(R-L)//2
        if x<A[C] or (not equal and x==A[C]):
            R=C
        else:
            L=C
    return R
#======================================= def Binary_Search_Small_Count(A,x,sort=True,equal=False):
    """2分探索によって,x未満の要素の個数を調べる.

    A:リスト
    x:調べる要素
    sort:ソートをする必要があるかどうか(Trueで必要)
    equal:Trueのときはx"未満"がx"以下"になる
    """
    if sort:
        A.sort()
        
    N=len(A)
    if A[-1]<x:
        return N
    elif x<A[0] or (not equal and x==A[0]):
        return 0

    L,R=0,N
    while R-L>1:
        C=L+(R-L)//2
        if x<A[C] or (not equal and x==A[C]):
            R=C
        else:
            L=C
    return R
#======================================= Binary_Search_Small_Count L=list(map(lambda x:int(x),input().split())) list(map(lambda x:int(x),input().split())) L N=int(input()) int(input()) N Y=Binary_Search_Small_Count(L,(c-b,inf),False,True) Binary_Search_Small_Count(L,(c-b,inf),False,True) Y
def Binary_Search_Small_Count(A,x,sort=True,equal=False):
    """2分探索によって,x未満の要素の個数を調べる.

    A:リスト
    x:調べる要素
    sort:ソートをする必要があるかどうか(Trueで必要)
    equal:Trueのときはx"未満"がx"以下"になる
    """
    if sort:
        A.sort()
        
    N=len(A)
    if A[-1]<x:
        return N
    elif x<A[0] or (not equal and x==A[0]):
        return 0

    L,R=0,N
    while R-L>1:
        C=L+(R-L)//2
        if x<A[C] or (not equal and x==A[C]):
            R=C
        else:
            L=C
    return R
#=======================================
N=int(input())
L=list(map(lambda x:int(x),input().split()))
inf=float("inf")

T={}
for i in range(N):
    x=L[i]
    if x in T:
        T[x]+=1
    else:
        T[x]=0
        
    L[i]=(x,T[L[i]])
L.sort()

D=0
for i in range(N):
    (b,y)=L[i]
    for j in range(i+1,N):
        (c,z)=L[j]

        X=Binary_Search_Small_Count(L,(b,y),False,False)
        Y=Binary_Search_Small_Count(L,(c-b,inf),False,True)

        D+=max(0,X-Y)
print(D)
