{-# 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 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

main :: IO ()
main = do
  n <- getIntList
  ls <- getIntList
  let lsVec = U.fromList ls
      appCnt = runST $ do
        table <- UM.new (10 ^ 3 + 1)
        forM_ ls $ \val -> do
          UM.modify table (+ (1 :: Int)) val
        U.freeze table
      uniqSortedVec = U.fromList . Set.toList . Set.fromList $ ls
      cnt = U.length uniqSortedVec
      accumAppCnt = runST $ do
        ans <- UM.new (10 ^ 3 + 2)
        forM_ [1 .. 10 ^ 3 + 1] $ \i -> do
          if i == 0
            then return ()
            else do
              prev <- UM.read ans (i -1)
              if appCnt U.! (i - 1) > 0
                then UM.write ans i (prev + 1)
                else UM.write ans i prev
        U.freeze $ ans
      count0 = (flip execState) (0 :: Int) $ do
        forM_ [0 .. cnt - 1] $ \i -> do
          forM_ [i + 1 .. cnt - 1] $ \j -> do
            let a = uniqSortedVec U.! i
                b = uniqSortedVec U.! j
                begin = b + 1
                end = min (10 ^ 3 + 1) (a + b)
                add = accumAppCnt U.! end - accumAppCnt U.! begin
            modify' (+ add)
      count1 = (flip execState) (0 :: Int) $ do
        forM_ [0 .. cnt - 1] $ \i -> do
          let a = uniqSortedVec U.! i
          if appCnt U.! a >= 2
            then do
              let begin = 1
                  end = min (10 ^ 3 + 1) (2 * a)
                  add0 = accumAppCnt U.! end - accumAppCnt U.! begin
                  add1 = add0 + if appCnt U.! a == 2 then -1 else 0
              modify' (+ add1)
            else return ()
  print (count0 + count1)

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

-}