import java.io.IOException
import java.lang.NumberFormatException
import java.lang.StringBuilder
import java.util.ArrayList

object AMain{
    fun solve(){
        val n = nextInt()
        val a = ArrayList<Long>()
        for(i in 1..n){
            a.add(nextLong())
        }

        a.sort()
        var pre = a[0]
        var mi = 1
        while(mi < a.size){
            if(a[mi] == pre){
                a.removeAt(mi)
            }else{
                mi++
            }
        }


        val isprime = IntArray(1000001){1}
        val prime = ArrayList<Int>()
        isprime[0] = 0
        isprime[1] = 0
        for(i in 2..1000000){
            if(isprime[i] > 0){
                for(j in i until 1000001 step i){
                    isprime[j] = 0
                }
                prime.add(i)
            }
        }
        println(prime.size)

        var ispair = true
        prime.forEach {
            var num = 0
            for(i in a.indices){
                if(a[i] % it == 0L) num++
                if(num >= 2){
                    ispair = false
                    return@forEach
                }
            }
        }

        if(ispair){
            println("pairwise coprime")
            return
        }

        var cur = a[0]
        for(i in 1 until a.size){
            cur = gcd(cur, a[i])
        }

        if(cur == 1L){
            println("setwise coprime")
        }else{
            println("not coprime")
        }

    }

    fun gcd(a: Long, b: Long): Long{
        if(b == 0L) return a
        return gcd(b, a % b)
    }





    // Scanner based on uwi-san's Java code
    val stream = System.`in`
    val buffer = ByteArray(1024)
    var ptr = 0
    var buflen = 0

    fun hasNextByte(): Boolean{
        if(ptr < buflen){
            return true
        }else{
            ptr = 0
            try{
                buflen = stream.read(buffer)
            }catch (e: IOException){
                e.printStackTrace()
            }
            if(buflen <= 0){
                return false
            }
        }
        return true
    }

    fun readByte() =
        if(hasNextByte()) buffer[ptr++]
        else -1

    fun isPrintableChar(c: Byte) = c in 33..126

    fun hasNext(): Boolean{
        while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++
        return hasNextByte()
    }

    fun next(): String{
        if(!hasNext()) throw NoSuchElementException()
        val sb = StringBuilder()
        var b = readByte()
        while(isPrintableChar(b)){
            sb.appendCodePoint(b.toInt())
            b = readByte()
        }
        return sb.toString()
    }

    fun nextLong(): Long{
        if(!hasNext()) throw NoSuchElementException()
        var n = 0L
        var minus = false
        var b = readByte()
        if(b == '-'.toByte()){
            minus = true
            b = readByte()
        }
        if(b !in '0'.toByte()..'9'.toByte())
            throw NumberFormatException()
        while(true){
            if(b in '0'.toByte()..'9'.toByte()){
                n *= 10
                n += b - '0'.toByte()
            }else if(!isPrintableChar(b)){
                return if(minus) -n else n
            }else{
                throw NumberFormatException()
            }
            b = readByte()
        }
    }

    fun nextInt(): Int{
        val n1 = nextLong()
        if(n1 !in Int.MIN_VALUE..Int.MAX_VALUE)
            throw NumberFormatException()
        return n1.toInt()
    }

    fun NextDouble() = next().toDouble()
}

fun main(){
    AMain.solve()
}

