#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <map>
#include <unordered_map>
#include <set>
#include <deque>
#include <bitset>

long long mod = 1e9+7;
class Mint {
public:
  long long x;
  Mint(){}; // 引数なしでも定義できるように引数なしコンストラクタも用意しておく
  Mint(long long a){
    x = a%mod;
    while(x<0){
      x += mod;
    }
  };
  Mint& operator += (const Mint &a){
    x+=a.x;
    x%=mod;
    return *this;
  }
  Mint& operator -= (const Mint &a){
    x += (mod - a.x);
    x%=mod;
    return *this;
  }
  Mint& operator *= (const Mint &a){
    x*=a.x;
    x%=mod;
    return *this;
  }

  // a^n mod を計算する
  // Useaeg: Mint z = Mint(2).pow(n);
  Mint pow(long long n) const {
    if (n==0) return Mint(1);
    Mint y = pow(n>>1); // pow(n/2)を計算する
    y *= y;
    if (n%2==1) y *= *this;
    return y;
  }

  // a^{-1} mod を計算する
  Mint modinv(const Mint &a) const {
    return a.pow(mod-2);
  }

  Mint& operator /= (const Mint &a) {
    x *= modinv(a).x;
    x %= mod;
    return *this;
  }

  Mint operator + (Mint &a) const {
    Mint y(*this);
    y += a;
    return y;
  }

  Mint operator - (Mint &a) const {
    Mint y(*this);
    y -= a;
    return y;
  }

  Mint operator * (Mint &a) const {
    Mint y(*this);
    y *= a;
    return y;
  }

  Mint operator / (Mint &a) const {
    Mint y(*this);
    y/=a;
    return y.x;
  }

  // nCk @mod を計算する
  Mint nCk(Mint &n, const long long k) const {
    Mint y = Mint(1);
    Mint one = Mint(1);
    for (Mint i(0); (i.x)<k; i.x++){
      y *= (n-i);
      y /= (i + one);
    }
    return y;
  }

  // nPk @mod を計算する
  Mint nPk(Mint &n, long long k) const {
    Mint y(1);
    for (Mint i(0); (i.x)<k; i.x++){
      y *= (n-i);
    }
    return y;
  }
};

int getgcd(int a, int b) {
  int max = std::max(a, b);
  int min = std::min(a, b);
  if (min==0) return max;
  return getgcd(min, max%min);
}

int main() {
  int N;
  std::cin >> N;
  std::vector<int> A(N);
  for (int i=0; i<N; i++) {
    std::cin >> A[i];
  }
  int gcd = A[0];
  for (int i=1; i<N; i++) {
    gcd = getgcd(gcd, A[i]);
    // printf("gcd (i=%d)=%d\n", i, gcd);
  }
  std::vector<int> prime;
  std::vector<bool> use(3001, false);
  for (int i=2; i*i<=1000000; i++){
    if (!use[i]) {
      prime.push_back(i);
      for (int j=i*2; j*j<=1000000; j+=i) {
        use[j] = true;
      }
    }
  }
  // printf("kuso\n");
  bool ng = false;
  for (int p : prime) {
    // printf("p=%d\n", p);
    bool find = false;
    for (int j=0; j<N; j++) {
      if (find && A[j]%p==0) {
        // printf("find: A[%d]=%d, p=%d\n", j, A[j], p);
        ng = true;
        break;
      }
      //while (A[j]>=1 && A[j]%p==0){
      // printf("A[%d]=%d\n", j, A[j]);
      while (A[j]%p==0){
        // printf("A[%d]=%d\n", j,A[j]);
        A[j] /= p;
        find = true;
      }
    }
  }
  // printf("hoge\n");
  std::vector<int > amari;
  for (int i=0; i<N; i++) {
    if (A[i]!=1) amari.push_back(A[i]);
  }
  if (amari.size() >= 2) {
    std::sort(amari.begin(), amari.end());
    for (int i=0; i<amari.size()-1; i++) {
      if (amari[i]==amari[i+1]) {
        ng = true;
        break;
      }
    }
  }

  // printf("gcd=%d\n", gcd);
  if (!ng) {
    printf("pairwise coprime\n");
  } else if (gcd==1) {
    printf("setwise coprime\n");
  } else {
    printf("not coprime\n");
  }
  return 0;
}


Measured memory_bytes: 10836