#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
const long long INF_L = 1LL << 60;
const int MOD = 1e9 + 7;
void coi(long long i) { cout << i << endl; }
void cois(long long i) { cout << i << " "; }
void cod(long double d) {
  cout << fixed << setprecision(16);
  cout << d << endl;
}
void cods(long double d) {
  cout << fixed << setprecision(16);
  cout << d << " ";
}
void coc(char c) { cout << c << endl; }
void cocs(char c) { cout << c << " "; }
void cos(string s) { cout << s << endl; }
void coss(string s) { cout << s << " "; }
void coynl(bool b) { cos(b ? "Yes" : "No"); }
void coYNU(bool b) { cos(b ? "YES" : "NO"); }
int ctoi(char c) {
  if (isdigit(c))
    return c - '0';
  else if (islower(c))
    return c - 'a';
  else if (isupper(c))
    return c - 'A';
  else
    return -1;
}
char itocd(int i) {
  char c = i + '0';
  if (isdigit(c))
    return c;
  else
    return 0x00;
}
char itocl(int i) {
  char c = i + 'a';
  if (islower(c))
    return c;
  else
    return 0x00;
}
char itocu(int i) {
  char c = i + 'A';
  if (isupper(c))
    return c;
  else
    return 0x00;
}
template <class T>
inline bool chmax(T& a, T b) {
  if (a < b) {
    a = b;
    return 1;
  }
  return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
  if (a > b) {
    a = b;
    return 1;
  }
  return 0;
}
struct edge {
  long long to, cost;
};
struct graph_list {
  long long V;
  vector<vector<edge>> graph;
  vector<long long> dist;
  graph_list(long long n) { init(n); }
  void init(long long n) {
    V = n;
    graph.resize(V);
    dist.resize(V);
    for (int i = 0; i < V; i++) {
      dist[i] = INF_L;
    }
  }
  void add_edge(long long from, long long to, long long cost) {
    edge e;
    e.to = to;
    e.cost = cost;
    graph[from].push_back(e);
  }
  void dijkstra(long long s) {
    for (int i = 0; i < V; i++) {
      dist[i] = INF_L;
    }
    dist[s] = 0;
    priority_queue<pair<long long, long long>,
                   vector<pair<long long, long long>>,
                   greater<pair<long long, long long>>>
        que;
    que.push(pair<long long, long long>(0, s));
    while (!que.empty()) {
      pair<long long, long long> p = que.top();
      que.pop();
      long long v = p.second;
      if (dist[v] < p.first) continue;
      for (auto e : graph[v]) {
        if (dist[e.to] > dist[v] + e.cost) {
          dist[e.to] = dist[v] + e.cost;
          que.push(pair<long long, long long>(dist[e.to], e.to));
        }
      }
    }
  }
  void bellman_ford(long long s) {
    for (int i = 0; i < V; i++) {
      dist[i] = INF_L;
    }
    dist[s] = 0;
  }
};
struct graph_matrix {
  long long vertex;
  vector<vector<edge>> graph;
  vector<long long> dist;
  graph_matrix(long long n) { init(n); }
  void init(long long n) {
    vertex = n;
    graph.resize(vertex);
    dist.resize(vertex);
    for (int i = 0; i < vertex; i++) {
      dist[i] = INF;
    }
  }
  void add_edge(long long s, long long t, long long cost) {
    edge e;
    e.to = t;
    e.cost = cost;
    graph[s].push_back(e);
  }
  void warshall_floyd(long long s) {
    for (int i = 0; i < vertex; i++) {
      dist[i] = INF;
    }
    dist[s] = 0;
  }
};
long long gcd(long long A, long long B) {
  if (A % B == 0) {
    return (B);
  } else {
    return (gcd(B, A % B));
  }
}
long long lcm(long long A, long long B) { return A * B / gcd(A, B); }
long long getDigit(long long N) { return (long long)(to_string(N).length()); }
long long getDigitForBase(long long N, long long B) {
  if (B < 2) {
    return -1;
  } else if (B == 10) {
    return getDigit(N);
  } else {
    long long r = 0;
    while (N != 0) {
      N /= B;
      r++;
    }
    return r;
  }
}
long long getDigitSum(long long N) {
  long long r = 0;
  string Ns = to_string(N);
  for (int i = 0; i < getDigit(N); i++) {
    r += ctoi(Ns[i]);
  }
  return r;
}
long long getDivTimes(long long N, long long D) {
  long long r = 0;
  while (N % D == 0) {
    N /= D;
    r++;
  }
  return r;
}
long long powMod(long long B, long long P) {
  if (P == 0) return 1;
  if (P % 2 == 0) {
    long long t = powMod(B, P / 2);
    return t * t % MOD;
  }
  return B * powMod(B, P - 1) % MOD;
}
const int FAC_INIT_SIZE = 1e6 + 9;
vector<long long> fac, finv, inv;
void factModInit() {
  fac.resize(FAC_INIT_SIZE);
  finv.resize(FAC_INIT_SIZE);
  inv.resize(FAC_INIT_SIZE);
  fac[0] = fac[1] = 1;
  finv[0] = finv[1] = 1;
  inv[1] = 1;
  for (int i = 2; i < FAC_INIT_SIZE; i++) {
    fac[i] = fac[i - 1] * i % MOD;
    inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
    finv[i] = finv[i - 1] * inv[i] % MOD;
  }
}
long long factMod(long long N) { return fac[N] % MOD; }
long long factInvMod(long long N) { return finv[N] % MOD; }
long long permMod(long long N, long long K) {
  if (N < 0 || K < 0 || N < K)
    return 0;
  else
    return factMod(N) * factInvMod(N - K) % MOD;
}
long long combMod(long long N, long long K) {
  if (N < 0 || K < 0 || N < K)
    return 0;
  else if (N < FAC_INIT_SIZE) {
    return factMod(N) * (factInvMod(K) * factInvMod(N - K) % MOD) % MOD;
  } else {
    long long ans = 1;
    long long Ks = K < N - K ? K : N - K;
    for (long long i = N; i > N - Ks; i--) {
      ans *= i;
      ans %= MOD;
    }
    return ans * factInvMod(Ks) % MOD;
  }
}
vector<bool> sieve;
void sieveInit(long long size) {
  sieve.clear();
  if (size < 0 || size > INF) return;
  int ss = (int)size + 9;
  int ssq = sqrt(ss + 0.1);
  sieve.resize(ss);
  sieve[2] = sieve[3] = true;
  int n = 0;
  for (int z = 1; z <= 5; z += 4) {
    for (int y = z; y <= ssq; y += 6) {
      for (int x = 1; x <= ssq && (n = 4 * x * x + y * y) < ss; x++)
        sieve[n] = !sieve[n];
      for (int x = y + 1; x <= ssq && (n = 3 * x * x - y * y) < ss; x += 2)
        sieve[n] = !sieve[n];
    }
  }
  for (int z = 2; z <= 4; z += 2) {
    for (int y = z; y <= ssq; y += 6) {
      for (int x = 1; x <= ssq && (n = 3 * x * x + y * y) < ss; x += 2)
        sieve[n] = !sieve[n];
      for (int x = y + 1; x <= ssq && (n = 3 * x * x - y * y) < ss; x += 2)
        sieve[n] = !sieve[n];
    }
  }
  for (int z = 1; z <= 2; z++) {
    for (int y = 3; y <= ssq; y += 6) {
      for (int x = z; x <= ssq && (n = 4 * x * x + y * y) < ss; x += 3)
        sieve[n] = !sieve[n];
    }
  }
  for (int k = 5; k <= ssq; k++)
    if (sieve[k])
      for (int n = k * k; n < ss; n += k * k) sieve[n] = false;
}
map<long long, map<long long, long long>> primeFactorMap;
map<long long, set<long long>> primeFactorSet;
void primeFactorizeInit() {
  primeFactorMap.clear();
  primeFactorSet.clear();
}
void primeFactorize(long long N) {
  if (N < 0 || N > INF_L) return;
  long long Nc = N, Nsq = sqrt(N + 0.1);
  for (int k = 2; k <= Nsq; k++) {
    long long dt = 0;
    while (Nc % k == 0) {
      dt++;
      Nc /= k;
    }
    if (dt > 0) primeFactorMap[N][k] = dt;
    if (N % k == 0) {
      primeFactorSet[N].insert(k);
      primeFactorSet[N].insert(N / k);
    }
  }
  if (Nc != 1) primeFactorMap[N][Nc] = 1;
  primeFactorSet[N].insert(1);
  primeFactorSet[N].insert(N);
}
void input() {}
void solve() {
  int N;
  cin >> N;
  vector<long long> A(N);
  long long Amax = 0;
  cin >> A[0];
  long long ALLGCD = A[0];
  for (int i = 1; i < N; i++) {
    cin >> A[i];
    chmax(Amax, A[i]);
    ALLGCD = gcd(ALLGCD, A[i]);
  }
  if (ALLGCD != 1) {
    cos("not coprime");
  } else {
    map<long long, int> mp;
    vector<long long> Ac = A;
    long long Asq = sqrt(Amax + 0.1);
    for (int k = 2; k <= Asq; k++) {
      for (int i = 0; i < N; i++) {
        if (Ac[i] % k == 0) {
          mp[k]++;
        }
        Ac[i] /= pow(getDivTimes(Ac[i], k), k);
      }
    }
    for (int i = 0; i < N; i++) {
      if (Ac[i] != 1) {
        mp[Ac[i]]++;
      }
    }
    bool fg = true;
    for (auto a : mp) {
      if (a.second > 1) fg = false;
    }
    if (!fg)
      cos("setwize coprime");
    else
      cos("pairwize coprime");
  }
}
int main() {
  std::ifstream in("input.txt");
  std::cin.rdbuf(in.rdbuf());
  cin.tie(0);
  ios::sync_with_stdio(false);
  input();
  solve();
  return 0;
}
