{-# LANGUAGE FlexibleInstances    #-}
{-# LANGUAGE TypeSynonymInstances #-}

import           Control.Applicative
import           Control.DeepSeq
import           Control.Monad
import           Control.Monad.ST
import qualified Data.Array                  as A
import qualified Data.Array.IArray           as IA
import qualified Data.Array.IO               as AI
import qualified Data.Array.MArray           as MA
import qualified Data.Array.ST               as STA
import qualified Data.Array.Unboxed          as AU
import           Data.Bits
import qualified Data.ByteString.Char8       as BS
import           Data.Char
import qualified Data.Graph                  as G
import           Data.Int
import qualified Data.IntMap                 as IM
import qualified Data.IntSet                 as IS
import           Data.List
import qualified Data.Map.Strict             as M
import           Data.Maybe
import           Data.Ord
import qualified Data.Sequence               as SQ
import qualified Data.Set                    as S
import           Data.Time
import qualified Data.Tree                   as T
import qualified Data.Vector                 as V
import qualified Data.Vector.Mutable         as VM
import qualified Data.Vector.Unboxed         as VU
import qualified Data.Vector.Unboxed.Mutable as VUM

class Printable a where
  format :: a -> String

instance Printable Int where
  format = show

instance Printable Integer where
  format = show

instance Printable Double where
  format = show

instance Printable Float where
  format = show

instance Printable Char where
  format = show

instance Printable String where
  format x = x

instance Printable Bool where
  format = show

put :: Printable a => a -> IO ()
put = putStr . format

putLn :: Printable a => a -> IO ()
putLn = putStrLn . format

putList :: Printable a => [a] -> IO ()
putList [a] = put a
putList (a:as) = do
  put a
  putStr " "
  putList as

readInt :: IO [Int]
readInt = map (fst . fromJust . BS.readInt) . BS.words <$> BS.getLine

readInts :: Int -> IO [[Int]]
readInts n = replicateM n readInt

readInteger :: IO [Integer]
readInteger = map (fst . fromJust . BS.readInteger) . BS.words <$> BS.getLine

readIntegers :: Int -> IO [[Integer]]
readIntegers n = replicateM n readInteger

readString :: IO [String]
readString = map BS.unpack . BS.words <$> BS.getLine

readStrings :: Int -> IO [[String]]
readStrings n = replicateM n <$> readString

toPair :: [a] -> (a, a)
toPair [x, y] = (x, y)

count :: Eq a => a -> [a] -> Int
count a as = length $ filter (== a) as

main = do
  readInt
  a <- readInt
  putList $ solve a

solve :: [Int] -> [Int]
solve a
  | sum [grey, brown, green, lightblue, blue, yellow, orange, red] == 0 && other >= 1 = [1, other ]
  | otherwise =
    [ sum [grey, brown, green, lightblue, blue, yellow, orange, red]
    , (sum [grey, brown, green, lightblue, blue, yellow, orange, red] + other) 
    ]
  where
    grey = f (any (\x -> 1 <= x && x <= 399) a)
    brown = f (any (\x -> 400 <= x && x <= 799) a)
    green = f (any (\x -> 800 <= x && x <= 1199) a)
    lightblue = f (any (\x -> 1200 <= x && x <= 1599) a)
    blue = f (any (\x -> 1600 <= x && x <= 1999) a)
    yellow = f (any (\x -> 2000 <= x && x <= 2399) a)
    orange = f (any (\x -> 2400 <= x && x <= 2799) a)
    red = f (any (\x -> 2800 <= x && x <= 3199) a)
    other = length $ filter (\x -> 3200 <= x) a
    o' = f $ not $ null $ filter (\x -> 3200 <= x) a

f b
  | b = 1
  | otherwise = 0


Measured memory_bytes: 508