
import qualified Data.Vector.Unboxed as U
import qualified Data.Vector as V
import qualified Data.ByteString.Char8 as C
import qualified Data.Array.IO as A
import Debug.Trace
import Data.List
import Control.Monad
import Data.Ord


r :: Int -> IO (U.Vector Int)
r n = U.unfoldrN n (C.readInt . C.dropWhile (==' ')) <$> C.getLine

r' :: IO [Int]
r'  =   unfoldr    (C.readInt . C.dropWhile (==' ')) <$> C.getLine

rp :: IO (Int,Int)
rp  = toTup . unfoldr    (C.readInt . C.dropWhile (==' ')) <$> C.getLine

toTup [a,b] = (a,b)

type Point = (Int,Int)
type Dist = (Int,Int)

main :: IO ()
main = do
    n <- readLn
    ws <- replicateM n rp
    let difs = sort $ map (ptNorm . uncurry ptDif) (pair ws)
    --print difs
    let difs' = sortBy (flip (comparing snd)) $ map lenP (group difs)
    --print difs'
    let winDif = fst (head difs')
    --print winDif
    let res = groupCount 0 winDif ws
    print res


groupCount :: Int -> Dist -> [Point] -> Int
groupCount ac _ []  = ac
groupCount ac d ls  = groupCount (ac+1) d (grouperLR d ls)

grouperLR :: Point -> [Point] -> [Point]
grouperLR d = grouper (ptNeg d) . grouper d

grouper :: Dist -> [Point] -> [Point]
grouper d [] = []
grouper d (p:ps) = let newp = ptAdd d p in
                    case find ((newp ==)) ps of
                        Nothing -> ps
                        Just r  -> grouper d (newp:(delete r ps))


lenP ls = (head ls, length ls)

ptDif (a,b) (x,y) = (a-x,b-y)
ptAdd (a,b) (x,y) = (a+x,b+y)

ptNorm p@(x,y) = if x<0 then ptNeg p
                else if x==0 && y<0 then ptNeg p
                else p

ptNeg (x,y) = (-x,-y)


pair :: [a] -> [(a,a)]
pair []     = []
pair (a:as) = map (\x->(a,x)) as ++ pair as