{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE UndecidableInstances #-}

module Main where

import Control.Category hiding (id, (.))
import Control.Monad
import Control.Monad.ST
import Control.Monad.State.Strict
import qualified Data.ByteString.Char8 as BS
import Data.List as List
import Data.Maybe
import Data.Set as Set
import qualified Data.Vector.Unboxing as U
import qualified Data.Vector.Unboxing.Mutable as UM
import Debug.Trace
import GHC.Generics

readInt :: BS.ByteString -> Int
readInt = fst . fromJust . BS.readInt

readIntList :: BS.ByteString -> [Int]
readIntList = Prelude.map readInt . BS.words

getInt :: IO Int
getInt = readInt <$> BS.getLine

getIntList :: IO [Int]
getIntList = readIntList <$> BS.getLine

-- data Point = Pt {-# UNPACK #-} Int {-# UNPACK #-} Int
--   deriving (Generic)
--   deriving (U.Unboxable) via U.Generics Point

-- ptX :: Point -> Int
-- ptX (Pt x y) = x

-- ptY :: Point -> Int
-- ptY (Pt x y) = y

range :: (Num a, Enum a) => a -> a -> [a]
range begin end = [begin .. (end - 1)]

partitionIdx :: U.Unboxable a => U.Vector a -> (a -> Bool) -> Int
partitionIdx vec pred =
  if pred (vec U.! 0) == False
    then 0
    else loop 0 (U.length vec)
  where
    loop begin end =
      if end == begin + 1
        then end
        else
          let !mid = (begin + end) `div` 2
           in if pred (vec U.! mid) then loop mid end else loop begin mid

main :: IO ()
main = do
  n <- getInt
  ls <- getIntList
  let sortedVec = U.fromList . fmap fst . Set.toList . Set.fromList $ zip ls [0 ..]
      count = sum $ do
        i <- range 0 n
        j <- range (i + 1) n
        let a = sortedVec U.! i
            b = sortedVec U.! j
            k = partitionIdx sortedVec (< a + b)
        return (k - j - 1)
  print count

{-
9
218 786 704 704 704 233 645 728 389

-}