{-# LANGUAGE
  ScopedTypeVariables, BangPatterns, TupleSections, ExplicitForAll,
  LambdaCase, MultiWayIf, Unsafe, RecordWildCards, FlexibleContexts, CPP,
  NoMonomorphismRestriction, GADTs, PatternGuards, MagicHash, UnboxedTuples,
  RankNTypes, EmptyDataDecls, EmptyCase, ViewPatterns, PolyKinds,
  TypeFamilies, OverloadedStrings, FlexibleInstances, UndecidableInstances,
  DefaultSignatures, GeneralizedNewtypeDeriving, StandaloneDeriving,
  DeriveGeneric, DeriveFunctor, DeriveDataTypeable, DeriveFoldable,
  DeriveTraversable, DeriveDataTypeable, FlexibleInstances,
  MultiParamTypeClasses, TypeApplications, RecordWildCards,
  NumericUnderscores #-}
{-# OPTIONS_GHC -O2 #-}

#define PHASE_FUSED [1]
#define PHASE_INNER [0]
#define INLINE_FUSED INLINE PHASE_FUSED
#define INLINE_INNER INLINE PHASE_INNER

import Prelude
import Data.Bits
import Data.List
import Data.Maybe
import Data.Tuple
import Data.Ord
import Data.Int
import Data.Word
import Data.Char
import Data.Ratio
import Data.Function
import Data.STRef
import Data.IORef
import Data.Monoid
import Data.Functor
import Data.Functor.Identity
import Data.Data
import Data.Typeable
import GHC.Generics
import System.IO
import System.IO.Unsafe (unsafeDupablePerformIO, unsafePerformIO)
import Control.Arrow
import Control.Applicative
import Control.Monad
import Control.Monad.Primitive
import Control.Monad.State.Strict
import Control.Monad.ST
import Control.Monad.ST.Lazy (strictToLazyST, lazyToStrictST)
import qualified Control.Monad.ST.Lazy as STL
-- import Control.Monad.ST.Safe
import Control.DeepSeq
import Data.Coerce
import qualified Data.ByteString as BSW
import qualified Data.ByteString.Char8 as BS
import qualified Data.ByteString.Lazy as BSLW
import qualified Data.ByteString.Lazy.Char8 as BSL
import qualified Data.ByteString.Builder as BSB
import qualified Data.ByteString.Unsafe as BSU
import qualified Data.ByteString.Internal as BSU
import Data.IntMap (IntMap)
import qualified Data.IntMap.Strict as IMS
import qualified Data.IntMap.Lazy as IML
import Data.IntSet (IntSet)
import qualified Data.IntSet as IS
import qualified Data.Sequence as Seq
import Data.Sequence (Seq)
import qualified Data.Array.IArray as A
import qualified Data.Array.MArray.Safe as A
import qualified Data.Array.MArray as A
import Data.Array (Array)
import Data.Array.Unboxed (UArray)
import Data.Array.IArray (IArray)
import Data.Array.MArray.Safe (MArray)
import Data.Array.IO.Safe (IOArray, IOUArray)
import Data.Array.ST.Safe (STArray, STUArray, runSTArray, runSTUArray)
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
import qualified Data.Vector.Storable as VS
import qualified Data.Vector.Storable.Mutable as VSM
import qualified Data.Vector.Primitive as VP
import qualified Data.Vector.Primitive.Mutable as VPM
import qualified Data.Vector.Generic as VG
import qualified Data.Vector.Generic.Mutable as VGM
import qualified Data.Vector.Generic.New as VGN
import qualified Data.Vector.Fusion.Bundle.Monadic as VFBM
import qualified Data.Vector.Fusion.Bundle as VFB
import qualified Data.Vector.Fusion.Stream.Monadic as VFSM
import qualified Data.Vector.Fusion.Bundle.Size as VFBS
import qualified Data.Vector.Fusion.Util as VFU
import qualified Data.Vector.Algorithms.Intro as VAIT
import qualified Data.Attoparsec.ByteString.Char8 as Atto
import Debug.Trace
import Unsafe.Coerce
import Foreign.ForeignPtr
import GHC.Exts (build, Int(..), Int#,
                 (+#), (*#), (-#), (<#), (>=#), (==#), quotRemInt#,
                 remInt#, uncheckedIShiftRL#, andI#, orI#,
                isTrue#, Addr#, Ptr(..))

test :: VU.Vector Int -> Bool
test as = VU.all (<= 1) checkSheet
  where
    checkSheet = VU.create $ do
      checkSheet <- VUM.replicate (VU.length (primesInSieve pSv)) (0::Int)
      VU.forM_ as $ \ !a ->
        VU.forM_ (distinctPrimeIndices a) $ \ !p ->
        VUM.modify checkSheet (+1) p
      return checkSheet

main :: IO ()
main = do
  n <- readLn @Int
  as <- getVecULn n rIntS
  putStrLn
    $ if | VU.foldl' gcd 0 as /= 1 -> "not coprime"
         | test as -> "pairwise coprime"
         | otherwise -> "setwise coprime"
  return ()

distinctPrimeIndices :: Int -> VU.Vector Int
distinctPrimeIndices n
  = VU.backpermute (sievedFactorIndices pSv)
  $ VU.map fst $ factorizeWithSieve pSv n

pSv = makePSieve 1_000_001

data PSieve = PSieve { maxSieved :: {-# UNPACK #-} !Int,
                       primesInSieve :: {-# UNPACK #-} !(VU.Vector Int),
                       sievedFactorIndices :: {-# UNPACK #-} !(VU.Vector Int),
                       sievedFactorPrimes :: {-# UNPACK #-} !(VU.Vector Int)}
              deriving (Show, Generic)

instance NFData PSieve

makePSieve :: Int -> PSieve
makePSieve !till
  | till <= 1 = PSieve (max (-1) till)
                       VU.empty
                       (VU.replicate (1 + max (-1) till) (-1))
                       (VU.replicate (1 + max (-1) till) (-1))
  | till == 2 = PSieve 2 (VU.singleton 2)
                (VU.fromListN 3 [-1,-1,0])
                (VU.fromListN 3 [-1,-1,2])
makePSieve !till = runST $ do
  store <- VUM.new $ estimateSieveSize till
  checkIdx <- VUM.replicate (till+1) (-1::Int)
  checkPrm <- VUM.replicate (till+1) (-1::Int)
  let wrt !pidx !prm !pos = do VUM.unsafeWrite checkIdx pos pidx
                               VUM.unsafeWrite checkPrm pos prm
  VUM.unsafeWrite store 0 2
  VUM.unsafeWrite store 1 3
  VU.mapM_ (wrt 0 2) $ VU.tail $ VU.generate (tillD2+1) (`shiftL` 1)
  VU.mapM_ (wrt 1 3) $ VU.enumFromStepN 3 6 d3Cnt
  let go0 = makeGo (<=tillD7) checkComposites go1
      go1 = makeGo (<=tillD5) (\ !n _ -> wrt 2 5 $ n*5) go2
      go2 = makeGo ((<=wTill) . toWord)
            (\ !_ !_ -> return ()) (\ !_ !_ !x -> return x)
      {-# INLINE makeGo #-}
      makeGo test testComp next = fix $ \this !n !d !ptr ->
        if test n
        then checkPrime n ptr (testComp n) $ (this $! n+d) $! 6-d
        else next n d ptr
      {-# INLINE checkPrime #-}
      checkPrime !n !ptr f g = do
        !v <- VUM.unsafeRead checkIdx n
        if v > 0 then f v *> g ptr else do
          wrt ptr n n
          VUM.unsafeWrite store ptr n
          f ptr
          g $! ptr+1
      {-# INLINE checkComposites #-}
      checkComposites !n !v = 
        VU.imapM_ (\ !ix (!p,!np) -> wrt (ix+2) p np)
        . VU.takeWhile (\(!_,!np) -> toWord np <= wTill)
        . VU.map (\ !p -> (p,) $! n*p)
        =<< VU.unsafeFreeze (VUM.unsafeSlice 2 (v-1) store)
  !len <- go0 5 2 2
  PSieve till <$> VU.unsafeFreeze (VUM.unsafeTake len store)
              <*> VU.unsafeFreeze checkIdx
              <*> VU.unsafeFreeze checkPrm
  where
    !tillD2 = till `shiftR` 1
    !d3Cnt = fromIntegral $ (wTill+3) `quot` 6
    !tillD5 = till `quot` 5
    !tillD7 = till `quot` 7
    !wTill = toWord till
    toWord :: Int -> Word
    toWord = fromIntegral

-- Relies on
-- pi(x) <= x*(ln(x)^(-1) + ln(x)^(-2) + 2*ln(x)^(-3) + 7.59ln(x)^(-4))
-- See Theorem 5.1 in
--  Dusart, Pierre. (2016). Explicit estimates of some functions over primes.
--  The Ramanujan Journal. 10.1007/s11139-016-9839-4.  
estimateSieveSize :: Int -> Int
{-# INLINE estimateSieveSize #-}
estimateSieveSize n | n >= 23   = ceiling $ nextDouble res
                    | n >= 11   = 8
                    | n >=  5   = 4
                    | otherwise = 2
  where
    d = fromIntegral n :: Double
    r = nextDouble $ recip $ log d
    {-# INLINE amt #-}
    amt x y = nextDouble $ x + r * y
    {-# INLINE ml #-}
    ml x y = nextDouble $ x * y
    res = (/100) $ ml d $ ml r $ amt 100 $ amt 100 $ amt 200 759

-- | Given 'Double' @d@, returns the smallest IEEE 754 'Double' above @d@.
--   ASSUMES @d@ is a normalized number.
--   Otherwise the result is indeterminate.
nextDouble :: Double -> Double
{-# INLINE nextDouble #-}
nextDouble d = d + ulpCoeff * d

ulpCoeff :: Double
{-# INLINE ulpCoeff #-}
ulpCoeff = 2.220446049250313080847263336181640625e-16 -- = 2^^(-52)

factorizeWithSieve :: PSieve -> Int -> VU.Vector (Int,Int)
{-# INLINE factorizeWithSieve #-}
factorizeWithSieve !ps = VU.take . ubDistinctPrimeCnt
  <*> groupCountVec . factorizeSeqWithSieve ps

factorizeSeqWithSieve :: PSieve -> Int -> VU.Vector Int
{-# INLINE factorizeSeqWithSieve #-}
factorizeSeqWithSieve PSieve{..} = \ !x ->
  condError
  (factorizationOutOfRange "factorizeSeqWithSieve" maxSieved x)
  (x >= 0 && x <= maxSieved)
  $ flip (VU.unfoldrN $ floorLog2 x) x
  $ \ !x -> if x < 2 then Nothing else
              let !p = VU.unsafeIndex sievedFactorPrimes x
                  !q = x `quot` p
              in Just (p,q)


floorLog2 :: Int -> Int
floorLog2 x = finiteBitSize x - countLeadingZeros x - 1

ubDistinctPrimeCnt :: Int -> Int
{-# INLINE ubDistinctPrimeCnt #-}
ubDistinctPrimeCnt !x
  | x >= 2*3*5*7*11*13 = 6 + shiftR (log2x-14) 2
  | x >= 2*3*5         = 5
  | otherwise          = 2
    where log2x = floorLog2 x



factorizationOutOfRange :: String -> Int -> Int -> Err
{-# NOINLINE factorizationOutOfRange #-}
factorizationOutOfRange name !maxSv !x
  = mkErr $ (name ++) $  (": Prime factorization was attempted against: " ++)
    $ shows x $
    ("\n   which is out of range of the sieve."
    ++ "\n   The maximum value accepted was: ") ++ show maxSv



groupCountVec :: (VG.Vector v a, VG.Vector v (a,Int), Eq a) => v a -> v (a,Int)
{-# INLINE groupCountVec #-}
groupCountVec = groupCountVecBy (==)

groupCountVecBy :: (VG.Vector v a, VG.Vector v (a,Int)) =>
  (a -> a -> Bool) -> v a -> v (a,Int)
{-# INLINE groupCountVecBy #-}
groupCountVecBy eq
  = (VG.unstream .) $ (. VG.stream)
  $ VFB.inplace (VFSM.map (\(a,_,_,len) -> (a,len)) . groupIntvsStreamBy eq)
                VFBS.toMax

groupIntvsVecBy :: (VG.Vector v a, VG.Vector v (a,a,Int,Int)) =>
  (a -> a -> Bool) -> v a -> v (a,a,Int,Int)
{-# INLINE groupIntvsVecBy #-}
groupIntvsVecBy eq
  = VG.unstream . VFB.inplace (groupIntvsStreamBy eq) VFBS.toMax . VG.stream

groupIntvsVec :: (VG.Vector v a, VG.Vector v (a,a,Int,Int), Eq a)
  => v a -> v (a,a,Int,Int)
{-# INLINE groupIntvsVec #-}
groupIntvsVec = groupIntvsVecBy (==)

data GroupIntvsState a s = GCSInit s
                         | GCSAcc a a {-# UNPACK #-} !Int {-# UNPACK #-} !Int s
                         | GCSEnd

groupIntvsStreamBy :: Applicative m => (a -> a -> Bool) ->
  VFSM.Stream m a -> VFSM.Stream m (a,a,Int,Int)
{-# INLINE_FUSED groupIntvsStreamBy #-}
groupIntvsStreamBy eq (VFSM.Stream step0 s) = VFSM.Stream step1 $ GCSInit s
  where
    {-# INLINE_INNER step1 #-}
    step1 (GCSInit        s0) = (<$> step0 s0) $ \case
      VFSM.Yield a0 s1 -> VFSM.Skip $ GCSAcc a0 a0 0 1 s1
      VFSM.Skip     s1 -> VFSM.Skip $ GCSInit          s1
      VFSM.Done        -> VFSM.Done
    step1 (GCSAcc a0 a1 i0 len s0) = (<$> step0 s0) $ \case
      VFSM.Yield a2 s1
        | eq a1 a2  -> VFSM.Skip                 $ GCSAcc a0 a2 i0 (len+1) s1
        | otherwise -> VFSM.Yield (a0,a1,i0,len) $ GCSAcc a2 a2 (i0+len) 1 s1
      VFSM.Skip s1  -> VFSM.Skip                 $ GCSAcc a0 a1 1      len s1
      VFSM.Done     -> VFSM.Yield (a0,a1,i0,len)   GCSEnd
    step1 GCSEnd = pure VFSM.Done


mkErr :: String -> Err
{-# NOINLINE mkErr #-}
mkErr s = Err (error s)

newtype Err = Err { unErr :: forall a. a }

condError :: Err -> Bool -> a -> a
{-# INLINE_FUSED condError #-}
condError err test | test      = id
                   | otherwise = const $ unErr err

{-# RULES
"condError/True" forall err. condError err True = id
"condError/Data.Vector.Generic.New.new" forall err test gen.
  condError err test (VG.new gen) = VG.new (condError err test gen)
"condError/Data.Vector.Generic.New.unstream" forall err test bdl.
  condError err test (VGN.unstream bdl)
  = VGN.unstream (condErrorBundle err test bdl)
  #-}

condErrorBundle :: (Applicative m) => Err -> Bool ->
  VFBM.Bundle m v a -> VFBM.Bundle m v a
{-# INLINE_FUSED condErrorBundle #-}
condErrorBundle err test (VFBM.Bundle els chks vec sz)
  = VFBM.Bundle (condErrorStream err test els)
                (condErrorStream err test chks)
                (condError err test vec)
                sz

{-# RULES
"condErrorBundle/True" forall err. condErrorBundle err True = id
  #-}

condErrorStream :: (Applicative m) => Err -> Bool ->
  VFSM.Stream m a -> VFSM.Stream m a
{-# INLINE_FUSED condErrorStream #-}
condErrorStream err test (VFSM.Stream step0 t) = VFSM.Stream step1 Nothing
  where
    {-# INLINE_INNER step1 #-}
    step1 Nothing | test      = pure $ VFSM.Skip $ Just t
                  | otherwise = unErr err
    step1 (Just s0) = (<$> step0 s0) $ \case
      VFSM.Yield x s1 -> VFSM.Yield x $ Just s1
      VFSM.Skip    s1 -> VFSM.Skip    $ Just s1
      VFSM.Done       -> VFSM.Done

{-# RULES
"condErrorStream/True" forall err. condErrorStream err True = id
  #-}


#define IL(f) {-# INLINE f #-}; f

IL(putBuilder) = BSB.hPutBuilder stdout

printVecInLines, printVecInSpcSepLn ::
  (VG.Vector v a, ShowAsBuilder a) => v a -> IO ()
IL(printVecInLines) = putBuilder . v2BLines
IL(printVecInSpcSepLn) = putBuilder . v2BSpcSepLn

class ShowAsBuilder a where
  showAsBuilder :: a -> BSB.Builder
  default showAsBuilder :: (Show a) => a -> BSB.Builder
  IL(showAsBuilder) = BSB.string8 . show

-- Inconsistent with show
instance (ShowAsBuilder a, VG.Vector v a) => ShowAsBuilder (v a) where
  IL(showAsBuilder) = v2BSpcSep

#define INS(t,f) instance ShowAsBuilder t where { IL(showAsBuilder)=f }
INS(Int,BSB.intDec)
INS(Int8,BSB.int8Dec)
INS(Int16,BSB.int16Dec)
INS(Int32,BSB.int32Dec)
INS(Int64,BSB.int64Dec)
INS(Word,BSB.wordDec)
INS(Word8,BSB.word8Dec)
INS(Word16,BSB.word16Dec)
INS(Word32,BSB.word32Dec)
INS(Word64,BSB.word64Dec)
INS(Integer,BSB.integerDec)
INS(Float,BSB.floatDec)
INS(Double,BSB.doubleDec)
-- INS(String,BSB.string8) -- Inconsistent with Show
-- INS(BS.ByteString,BSB.byteString) -- Inconsistent with Show
-- INS(BSL.ByteString,BSB.lazyByteString) -- Inconsisitent with Show
#undef INS

-- Inconsistent with Show
instance (ShowAsBuilder a, ShowAsBuilder b) => ShowAsBuilder (a,b) where
  IL(showAsBuilder) = showTupAsBuilder
instance (ShowAsBuilder a, ShowAsBuilder b, ShowAsBuilder c) =>
  ShowAsBuilder (a,b,c) where
  IL(showAsBuilder) = showTup3AsBuilder
instance (ShowAsBuilder a, ShowAsBuilder b, ShowAsBuilder c, ShowAsBuilder d) =>
  ShowAsBuilder (a,b,c,d) where
  IL(showAsBuilder) = showTup4AsBuilder

IL(showTupAsBuilderWith)
  :: (a -> BSB.Builder) -> (b -> BSB.Builder) -> (a,b) -> BSB.Builder
showTupAsBuilderWith showA showB
  = \(a,b) -> (showA a <>) $ BSB.char7 ' ' <> showB b
IL(showTupAsBuilder) :: (ShowAsBuilder a, ShowAsBuilder b)
  => (a,b) -> BSB.Builder
showTupAsBuilder = showTupAsBuilderWith showAsBuilder showAsBuilder 

IL(showTup3AsBuilderWith) :: (a -> BSB.Builder) -> (b -> BSB.Builder) ->
  (c -> BSB.Builder) -> (a,b,c) -> BSB.Builder
showTup3AsBuilderWith showA showB showC
  = \(a,b,c) -> (showA a <>) $ (BSB.char7 ' ' <>) $ (showB b <>)
                $ (BSB.char7 ' ' <>) $ showC c
IL(showTup3AsBuilder) :: (ShowAsBuilder a, ShowAsBuilder b, ShowAsBuilder c)
  => (a,b,c) -> BSB.Builder
showTup3AsBuilder
  = showTup3AsBuilderWith showAsBuilder showAsBuilder showAsBuilder

IL(showTup4AsBuilderWith) :: (a -> BSB.Builder) -> (b -> BSB.Builder) ->
  (c -> BSB.Builder) -> (d -> BSB.Builder) -> (a,b,c,d) -> BSB.Builder
showTup4AsBuilderWith showA showB showC showD
  = \(a,b,c,d) -> (showA a <>) $ (BSB.char7 ' ' <>)
                  $ showTup3AsBuilderWith showB showC showD (b,c,d)
IL(showTup4AsBuilder) ::
  (ShowAsBuilder a, ShowAsBuilder b, ShowAsBuilder c, ShowAsBuilder d) =>
  (a,b,c,d) -> BSB.Builder
showTup4AsBuilder = showTup4AsBuilderWith showAsBuilder showAsBuilder
                    showAsBuilder showAsBuilder

v2BSpcSepLn, v2BSpcSep, v2BConcat, v2BLines ::
  (VG.Vector v a, ShowAsBuilder a)
  => v a -> BSB.Builder
IL(v2BSpcSepLn) = v2BSpcSepLnWith showAsBuilder
IL(v2BSpcSep) = v2BSpcSepWith showAsBuilder
IL(v2BConcat) = v2BConcatWith showAsBuilder
IL(v2BLines) = v2BLinesWith showAsBuilder


v2BSpcSepLnWith, v2BSpcSepWith, v2BConcatWith, v2BLinesWith ::
  (VG.Vector v a)
  => (a -> BSB.Builder) -- ^ show function
  -> v a -> BSB.Builder
IL(v2BSpcSepLnWith) = v2BSpcSepPostfWith $ BS.singleton '\n'
IL(v2BSpcSepWith) = v2BSpcSepPostfWith BS.empty
IL(v2BConcatWith) showFct = VG.foldr ((<>) . showFct) mempty
IL(v2BLinesWith) showFct
  = VG.foldr (\ a -> (showFct a <>) . (BSB.char7 '\n' <>)) mempty


v2BSpcSepPostf :: (VG.Vector v a, ShowAsBuilder a)
  => BS.ByteString -- ^ postfix
  -> v a -> BSB.Builder
IL(v2BSpcSepPostf) = (`v2BSpcSepPostfWith` showAsBuilder)

v2BSpcSepPostfWith :: (VG.Vector v a)
  => BS.ByteString -- ^ postfix
  -> (a -> BSB.Builder) -- ^ show function
  -> v a -> BSB.Builder
IL(v2BSpcSepPostfWith) = vecToBuilder BS.empty $ BS.singleton ' '

IL(vecToBuilder) :: (VG.Vector v a)
  => BS.ByteString -- ^ prefix
  -> BS.ByteString -- ^ separator
  -> BS.ByteString -- ^ postfix
  -> (a -> BSB.Builder) -- ^ show function
  -> v a -> BSB.Builder
vecToBuilder !prefix !separator !postfix
  = vecToBuilder_ (BSB.byteString prefix)
                  (BSB.byteString separator)
                  (BSB.byteString postfix)


IL(vecToBuilder_) :: (VG.Vector v a)
  => BSB.Builder -- ^ prefix
  -> BSB.Builder -- ^ separator
  -> BSB.Builder -- ^ postfix
  -> (a -> BSB.Builder) -- ^ show function
  -> v a -> BSB.Builder
vecToBuilder_ !prefix !separator !postfix showFct = \vec -> prefix <>
  VG.foldr
  (\ a rest !prefx -> prefx <> (showFct a <> rest separator))
  (const postfix) vec mempty

IL(evalVals) :: [a] -> [a]
evalVals xs = build $ \c n -> foldr (c $!) n xs
IL(forceVals) :: (NFData a) => [a] -> [a]
forceVals xs = build $ \c n -> foldr (c $!!) n xs

IL(readLnWith) :: StateT BS.ByteString Maybe a -> IO a
readLnWith parser = fromJust . evalStateT parser <$> BS.getLine
IL(readContentWith) :: StateT BSL.ByteString Maybe a -> IO a
readContentWith parser = fromJust . evalStateT parser <$> BSL.getContents

IL(getVecGLn) :: (VG.Vector v a) =>
  Int -> StateT BS.ByteString Maybe a -> IO (v a)
getVecGLn n s = VG.unfoldrN n (runStateT s) <$> BS.getLine
IL(getVecGRest) :: (VG.Vector v a) =>
  Int -> StateT BSL.ByteString Maybe a -> IO (v a)
getVecGRest n s = VG.unfoldrN n (runStateT s) <$> BSL.getContents
IL(getVecLn) :: Int -> StateT BS.ByteString Maybe a -> IO (V.Vector a)
getVecLn = getVecGLn
IL(getVecRest) :: Int -> StateT BSL.ByteString Maybe a -> IO (V.Vector a)
getVecRest = getVecGRest
IL(getVecULn) :: (VU.Unbox a) =>
  Int -> StateT BS.ByteString Maybe a -> IO (VU.Vector a)
getVecULn = getVecGLn
IL(getVecURest) :: (VU.Unbox a) =>
  Int -> StateT BSL.ByteString Maybe a -> IO (VU.Vector a)
getVecURest = getVecGRest

IL(rIntL) :: StateT BSL.ByteString Maybe Int
rIntL = skipSpecialL $ StateT BSL.readInt
IL(rIntS) :: StateT BS.ByteString Maybe Int
rIntS = skipSpecialS $ StateT BS.readInt
IL(rStrL) :: (MonadState BSL.ByteString m) => m BS.ByteString
rStrL = skipSpecialL $ BSL.toStrict <$> state (BSL.span (>='!'))
IL(rStrS) :: (MonadState BS.ByteString m) => m BS.ByteString
rStrS = skipSpecialS $ state $ BS.span (>='!')
IL(rCharL) :: StateT BSL.ByteString Maybe Char
rCharL = StateT BSL.uncons
IL(rCharS) :: StateT BS.ByteString Maybe Char
rCharS = StateT BS.uncons
IL(rCharWL) :: StateT BSL.ByteString Maybe Word8
rCharWL = StateT BSLW.uncons
IL(rCharWS) :: StateT BS.ByteString Maybe Word8
rCharWS = StateT BSW.uncons
IL(dropSpecialL) :: (MonadState BSL.ByteString m) => m ()
dropSpecialL = modify $ BSL.dropWhile (<'!')
IL(dropSpecialS) :: (MonadState BS.ByteString m) => m ()
dropSpecialS = modify $ BS.dropWhile (<'!')
IL(skipSpecialL) :: (MonadState BSL.ByteString m) => m a -> m a
skipSpecialL = (dropSpecialL *>)
IL(skipSpecialS) :: (MonadState BS.ByteString m) => m a -> m a
skipSpecialS = (dropSpecialS *>)

IL(linToMat) :: (VG.Vector v a) => Int -> Int -> v a -> V.Vector (v a)
linToMat h w lvec = vEvalElemsId $ V.generate h (\i -> VG.slice (i*w) w lvec)

IL(mLinToMat) :: (VGM.MVector v a) => Int -> Int -> v s a -> V.Vector (v s a)
mLinToMat h w lvec = vEvalElemsId $ V.generate h (\i -> VGM.slice (i*w) w lvec)
  
IL(unsafeAddrToSVec) :: Int -> Addr# -> VS.Vector Word8
unsafeAddrToSVec n addr
  = (`VS.unsafeFromForeignPtr0` n)
    $ unsafeDupablePerformIO
    $ newForeignPtr_ $ Ptr addr

IL(vEvalElemsId) :: (VG.Vector v a) => v a -> v a
vEvalElemsId = vMapFoldl (\ !_ !x -> (x,())) ()

IL(vEvalElems) :: (VG.Vector v a) => v a -> ()
vEvalElems = VG.foldl' (\ !_ !_ -> ()) () 

IL(vMapFoldl) :: (VG.Vector v b, VG.Vector v c) =>
  (a -> b -> (c,a)) -> a -> v b -> v c
vMapFoldl f a
  = VG.unstream . VFB.inplace (streamMapFoldl f a) id . VG.stream

streamMapFoldl :: (Functor m) =>
  (a -> b -> (c,a)) -> a -> VFSM.Stream m b -> VFSM.Stream m c
{-# INLINE_FUSED streamMapFoldl #-}
streamMapFoldl f a (VFSM.Stream step s) = VFSM.Stream step1 (a,s)
  where
    {-# INLINE_INNER step1 #-}
    step1 (a0,s0) =  (<$> step s0) $ \r -> case r of
      VFSM.Yield b s1 -> case f a0 b of (c,a1) -> VFSM.Yield c (a1,s1)
      VFSM.Skip    s1 -> VFSM.Skip (a0,s1)
      VFSM.Done       -> VFSM.Done

IL(svecToBS) :: VS.Vector Word8 -> BS.ByteString
svecToBS vec = BSU.fromForeignPtr ptr 0 len
  where (ptr, len) = VS.unsafeToForeignPtr0 vec


unlessM, whenM :: (Monad m) => m Bool -> m () -> m ()
IL(whenM) = (. flip when) . (>>=)
IL(unlessM) = (. flip unless) . (>>=)

IL(wrA) = A.writeArray
IL(rdA) = A.readArray
IL(mdA) = \arr f !i -> do
  ai <- rdA arr i
  let fai = f ai 
  wrA arr i fai
  return (ai,fai)
{-# INLINE mdA' #-}
mdA' = \arr f !i -> do
  !ai <- rdA arr i
  let !fai = f ai
  wrA arr i fai
  return (ai,fai)
IL(swapA) = \arr !i !j -> do
  ai <- rdA arr i
  wrA arr i =<< rdA arr j
  wrA arr j ai

#define D(f,r,d)\
  IL(f) :: Integral a=>a->d; f=fromIntegral;\
  IL(r) :: String->d; r=read
#define C(f,r,g,h,d) D(f,r,d);\
  g,h :: RealFrac a=>a->d; IL(g)=floor; IL(h)=ceiling
C(_toInteger_,readInteger,floorInteger,ceilInteger,Integer)
C(toInt,readInt,floorInt,ceilInt,Int)
C(toI8,readI8,floorI8,ceilI8,Int8)
C(toI16,readI16,floorI16,ceilI16,Int16)
C(toI32,readI32,floorI32,ceilI32,Int32)
C(toI64,readI64,floorI64,ceilI64,Int64)
C(toWord,readWord,floorWord,ceilWord,Word)
C(toW8,readW8,floorW8,ceilW8,Word8)
C(toW16,readW16,floorW16,ceilW16,Word16)
C(toW32,readW32,floorW32,ceilW32,Word32)
C(toW64,readW64,floorW64,ceilW64,Word64)
D(toDouble,readDouble,Double)
D(toFloat,readFloat,Float)
#undef D
#undef C

#define TS(f,a,m,init)\
  IL(f) :: forall e i s. (C(a,m) A.Ix i) => (i,i) -> init m (a i e); f
#define N(f,g,h,a,m)\
  TS(f,a,m,e->)=A.newArray;\
  TS(g,a,m,)=A.newArray_;\
  TS(h,a,m,[e]->)=A.newListArray
#define C(a,m)
N(newIOA,newIOA_,newIOAL,IOArray,IO)
N(newSTA,newSTA_,newSTAL,STArray s,ST s)
#undef C
#define C(a,m) MArray (a) e (m), 
N(newIOUA,newIOUA_,newIOUAL,IOUArray,IO)
N(newSTUA,newSTUA_,newSTUAL,STUArray s,ST s)
#undef C
#undef N
#undef TS

#undef IL


Measured memory_bytes: 46648