import Data.Array
import Data.Array.ST
import Control.Monad.ST
import Control.Monad
import qualified Data.ByteString.Char8 as BS
import Data.Maybe
import qualified          Data.Vector.Mutable as M
import qualified Data.Vector as V

tuplify2 (x:y:_) = (x,y)
tuplify2 _ = undefined


readInt = fst . fromJust . BS.readInt
readIntTuple = tuplify2 . map readInt . BS.words
readIntList = map readInt . BS.words

getInt = readInt <$> BS.getLine
getIntList = readIntList <$> BS.getLine
getIntNList n = map readIntList <$> replicateM (fromIntegral n) BS.getLine
getIntMatrix = map readIntList . BS.lines <$> BS.getContents
getIntTuple = readIntTuple <$> BS.getLine
getIntNTuples n = map readIntTuple <$> replicateM (fromIntegral n) BS.getLine
getIntTuples = map readIntTuple . BS.lines <$> BS.getContents
main=do
    getLine
    a <- getIntList
    let cnt = runST $ do
            --vec <- V.thaw $ V.fromList [1..m]
            --vec <- M.new m
            vec <- V.thaw $ V.replicate m 0
            forM_ a $ \ai ->
                forM_ (primeFactor ai) $ \j -> 
                    M.modify vec (+1) j
            V.freeze vec
        
    putStrLn$if (V.and $V.map (<=1) cnt) 
        then "pairwise coprime"
        else if (foldl1 gcd a == 1) 
            then  "setwise coprime"
            else  "not coprime"
    --print $ V.take 20 cnt


m = 10^6+1


table :: Array Int Int
table = runSTArray $ do
    arr <- newArray (2,m) 0
    forM_ [2..m] $ \i -> writeArray arr i i
    forM_ (takeWhile (\i -> i*i < m) [2..]) $ \i -> do
        arri <- readArray arr i
        when (arri >= i)$
            forM_ (takeWhile (\j -> i*j < m) [i..]) $ \j -> do
                v <- readArray arr (i*j)
                when (v == i*j) $ writeArray arr (i*j) i
    return arr

primeFactor :: Int -> [Int]
primeFactor 1 = []
primeFactor n = if (null prev || head prev /= p) then p:prev else prev
    where p = table ! n
          prev = primeFactor (n `div` p)