package main

import (
  "bufio"
  "os"
  "strconv"
  "strings"
  "fmt"
)

func Eratosthenes(N int) []int {
  P := make([]int, 0)
  E := make([]int, N + 1)
  for i := range E[2:] { E[i + 2]++ }
  for i, e := range E {
    if e == 0 { continue }
    P = append(P, i)
    for j := 2 * i; j <= N; j += i { E[j] = 0 }
  }
  return P
}

func Solve() {
  var N int
  NextInt(&N)
  var A []int
  NextIntSlice(&A)
  C := make([]int, MaxInt(A...) + 1)
  P := Eratosthenes(MaxInt(A...))
  for _, a := range A {
    for _, p := range P {
      if p > a { break }
      if a % p > 0 { continue }
      C[p]++
      for a % p == 0 { a /= p }
    }
  }
  M := MaxInt(C...)
  if M <= 1 {
    Write("pairwise coprime")
  } else if M < N {
    Write("setwise coprime")
  } else {
    Write("not coprime")
  }
}

func main() {
  Solve()
  Output()
}

var reader = bufio.NewReaderSize(os.Stdin, 1000000)
var writer = bufio.NewWriter(os.Stdout)
func NextLine() string {
  buffer := make([]byte, 0)
  for true {
    line, isPrefix, err := reader.ReadLine()
    if err != nil { panic(err) }
    buffer = append(buffer, line...)
    if !isPrefix { break }
  }
  return string(buffer)
}
func NextInt(A ...*int) {
  L := strings.Split(NextLine(), " ")
  for i, a := range A {
    *a, _ = strconv.Atoi(L[i])
  }
}
func NextIntSlice(A *[]int) {
  L := strings.Split(NextLine(), " ")
  if len(L) == 1 && L[0] == "" {
    (*A) = make([]int, 0)
    return
  }
  (*A) = make([]int, len(L))
  for i, l := range L {
    (*A)[i], _ = strconv.Atoi(l)
  }
}
func NextFloat(A ...*float64) {
  L := strings.Split(NextLine(), " ")
  for i, a := range A {
    *a, _ = strconv.ParseFloat(L[i], 64)
  }
}
func NextFloatSlice(A *[]float64) {
  L := strings.Split(NextLine(), " ")
  if len(L) == 1 && L[0] == "" {
    (*A) = make([]float64, 0)
    return
  }
  (*A) = make([]float64, len(L))
  for i, l := range L {
    (*A)[i], _ = strconv.ParseFloat(l, 64)
  }
}
func Write(S ...interface{}) {
  fmt.Fprintln(writer, S...)
}
func WriteIntSlice(A []int) {
  B := make([]interface{}, len(A))
  for i, a := range A { B[i] = a }
  fmt.Fprintln(writer, B...)
}
func Output() {
  _ = writer.Flush()
}
func MaxInt(A ...int) int {
  max := A[0]
  for _, a := range A {
    if max < a { max = a }
  }
  return max
}
func MinInt(A ...int) int {
  min := A[0]
  for _, a := range A {
    if a < min { min = a }
  }
  return min
}
func SumInt(A ...int) int {
  sum := 0
  for _, a := range A {
    sum += a
  }
  return sum
}
func AbsInt(x int) int {
  if x < 0 { x = -x }
  return x
}