import Data.Either (either, isLeft, isRight, lefts, partitionEithers, rights)
import Data.Maybe
    ( catMaybes
    , fromJust
    , fromMaybe
    , isJust
    , isNothing
    , listToMaybe
    , mapMaybe
    , maybe
    , maybeToList
    )

import           Data.Array.IArray (IArray, (!))
import qualified Data.Array.IArray as I (Array, array, assocs, elems, listArray)
import           Data.Array.MArray (MArray)
import qualified Data.Array.MArray as M
    ( freeze
    , getAssocs
    , getElems
    , newArray
    , newListArray
    , readArray
    , writeArray
    )

import Data.Array.IO (IOArray)
import Data.Array.ST (STArray)

import Data.Bifunctor (bimap, first, second)
import Data.Foldable  (and, or, product, sum)
import Data.Function
import Data.Monoid    ((<>))

import qualified Data.List as L

import Control.Applicative
import Control.Monad
import Control.Monad.ST    (ST, runST)

main :: IO ()
main = do
    n <- read <$> getLine
    as <- getSeq
    print $ solve n as

getSeq  = map read . words <$> getLine   :: Read a => IO [a]

data Winner = First | Second deriving Show

solve :: Int -> [Int] -> Winner
solve n as =
    let
      x = L.minimum as
      (y, z) = L.foldr (\x -> if odd x then first succ else second succ) (0, 0) $ L.filter (x <) as
    in if odd x && (even y || even z)
        then First
        else Second
