#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <set>
#include <unordered_set>
#include <map>
#include <queue>
#include <cstring>
#include <cassert>
using namespace std;
using LL = long long;
#define FOR(i, x, y) for (decay<decltype(y)>::type i = (x), _##i = (y); i < _##i; ++i)
#define FORD(i, x, y) for (decay<decltype(x)>::type i = (x), _##i = (y); i > _##i; --i)
#ifdef zerol
#define dbg(x...) do { cout << "\033[32;1m" << #x << " -> "; err(x); } while (0)
void err() { cout << "\033[39;0m" << endl; }
template<template<typename...> class T, typename t, typename... A>
void err(T<t> a, A... x) { for (auto v: a) cout << v << ' '; err(x...); }
template<typename T, typename... A>
void err(T a, A... x) { cout << a << ' '; err(x...); }
#else
#define dbg(...)
#endif


#ifdef L_JUDGE
#pragma warning(disable:4996)
#endif

using namespace std;

template <typename T>
inline bool read(T& ret) {
    T x = 0, f = 1; char ch = getchar();
    while(ch!=EOF && (ch > '9' || ch < '0')) { if(ch == '-') f = -1; ch = getchar();  }
    if(EOF==ch)return false;
    do x = x * 10 + ch - 48, ch = getchar(); while(ch >= '0' && ch <= '9');
    ret = x * f;
    return true;
}


inline char nc() {
    static char buf[100000], *p1 = buf, *p2 = buf;
    return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2) ? EOF : *p1++;
}
template <typename T>
bool rn(T& v) {
    static char ch;
    while (ch != EOF && !isdigit(ch)) ch = nc();
    if (ch == EOF) return false;
    for (v = 0; isdigit(ch); ch = nc())
        v = v * 10 + ch - '0';
    return true;
}

template <typename T>
void o(T p) {
    static int stk[70], tp;
    if (p == 0) { putchar('0'); return; }
    if (p < 0) { p = -p; putchar('-'); }
    while (p) stk[++tp] = p % 10, p /= 10;
    while (tp) putchar(stk[tp--] + '0');
}


LL bin(LL x, LL n, LL MOD) {
    LL ret = MOD != 1;
    for (x %= MOD; n; n >>= 1, x = x * x % MOD)
        if (n & 1) ret = ret * x % MOD;
    return ret;
}
inline LL get_inv(LL x, LL p) { return bin(x, p - 2, p); }



void Solve(){
}


const int MAXN=1e6+10;
int A[MAXN], cnt[MAXN];
bool p[MAXN];
int sp[MAXN];
int N;

int gcd(int x, int y){
    if(y==0)return x;
    return gcd(y, x%y);
}

int main(){
#ifdef L_JUDGE
    freopen("in1.txt","r",stdin);
    //		freopen("out.txt","w",stdout);
#endif
    //std::ios::sync_with_stdio(false);
    //std::cin.tie(0);
    while(cin>>N){
        for(int i=0;i<N;i++){
            scanf("%d", A+i);
        }
        memset(p, true, sizeof(p));
        for(int i=2;i<MAXN;i++){
            if(!p[i])continue;
            for(int j=i+i;j<MAXN;j+=i){
                p[j]=false;
             }
            //cout<<i<<endl;
        }

        for(int i=1;i<MAXN;i++){
            sp[i]=i;
        }
        for(int i=2;i*i<MAXN;i++){
            if(!p[i])continue;
            for(int j=i*i;j<MAXN;j+=i){
                if(sp[j]==j){
                    sp[j]=i;
                }
            }
        }
        memset(cnt, 0, sizeof(cnt));
        for(int i=0;i<N;i++){
            int x=A[i];
            while(x!=1){
                int a=sp[x];
                while(x%a==0){
                    x/=a;
                }
                cnt[a]++;
            }
        }
        bool flag=true;
        for(int i=2;i<MAXN;i++){
            if(p[i]&&cnt[i]>1){
                flag=false;
            }
        }
        if(flag){
            puts("pairwise coprime");
        }else{
            int g=A[0];
            for(int i=1;i<N;i++){
                g=gcd(g, A[i]);
            }
            if(g==1){
                puts("setwise coprime");
            }else{
                puts("not coprime");
            }
        }

    }
    return 0;

#ifdef L_JUDGE
    fclose(stdin);
    fclose(stdout);
    //		system("out.txt");
#endif

	return 0;
}


Measured memory_bytes: 15800