using System;
using System.Linq;
using System.Collections.Generic;

namespace Contest
{
  class Program
  {
    static void Main(string[] args)
    {
      ABC177.E();
    }
    class ABC177
    {
      public static void A()
      {
        var D = Read.Long();
        var T = Read.Long();
        var S = Read.Long();
        Console.WriteLine(S * T >= D ? "Yes" : "No");
      }
      public static void B()
      {
        var S = Read.Str();
        var T = Read.Str();
        int min = S.Length;
        for(int i = 0; i <= S.Length - T.Length; ++i)
        {
          int count = 0;
          for(int j = 0; j < T.Length; ++j)
          {
            if (S[i + j] != T[j]) { count++; }
          }
          min = Math.Min(min, count);
        }
        Console.WriteLine(min);
      }
      public static void C()
      {
        var N = Read.Int();
        var A = Read.LongN();
        var sum = new MOD(0);
        var sum2 = new MOD(0);
        foreach(var a in A)
        {
          sum += a;
          sum2 += new MOD(a * a);
        }
        Console.WriteLine((sum * sum - sum2) / 2);
      }
      public static void D()
      {
        var N = Read.Int();
        var M = Read.Int();
        var AB = Read.TupleInt(M);
        var uft = new Util.UnionFindTree(N);
        foreach(var ab in AB)
        {
          var A = ab.Item1 - 1;
          var B = ab.Item2 - 1;
          uft.Unite(A, B);
        }
        int max = 0;
        for(int i = 0; i < N; ++i)
        {
          max = Math.Max(max, uft.Count(i));
        }
        Console.WriteLine(max);
      }
      public static void E()
      {
        var N = Read.Int();
        var A = Read.LongN().Where(x => x > 1).ToArray();
        var M = A.Length;
        var A2 = A.Distinct().ToArray();
        var K = A2.Length;

        if (M <= 1) { Console.WriteLine("pairwise coprime"); return; }
        var gcd = A[0];
        for(int i = 1; i < M; ++i)
        {
          gcd = Util.GCD(gcd, A[i]);
        }
        if (gcd > 1 && N == M) { Console.WriteLine("not coprime"); return; }
        if (K > 300000 || M != K) { Console.WriteLine("setwise coprime"); return; }

        var primes = Enumerable.Range(0, 1000001).Select(i => true).ToArray();
        primes[0] = primes[1] = false;
        for(int i = 2; i <= 1000; ++i)
        {
          if (!primes[i]) { continue; }
          for (int j = i * 2; j <= 1000000; j += i)
          {
            primes[j] = false;
          }
        }
        HashSet<long> primesX = new HashSet<long>();
        for(int i = 2; i <= 1000; ++i)
        {
          if (primes[i]) { primesX.Add(i); }
        }

        var dict = new Dictionary<long, int>();
        foreach(var a in A2)
        {
          foreach(var p in E_Primes(primesX, a))
          {
            if (!dict.ContainsKey(p)) { dict.Add(p, 0); }
            dict[p]++;
          }
        }
        bool isPair = true;
        foreach(var kvp in dict)
        {
          if (kvp.Value > 1)
          {
            isPair = false;
          }
        }
        Console.WriteLine(isPair ? "pairwise coprime" : "setwise coprime");
      }
      public static HashSet<long> E_Primes(HashSet<long> primes, long x)
      {
        var hash = new HashSet<long>();
        long y = x;
        foreach (var p in primes)
        {
          if (y % p == 0)
          {
            hash.Add(p);
            while (y % p == 0)
            {
              y /= p;
            }
          }
          if (y == 1) { return hash; }
        }
        if (y > 1 && !hash.Contains(y))
        {
          hash.Add(y);
        }
        return hash;
      }
      public static void F()
      {

      }
    }

    class Bound
    {
      public static int Lowerbound<T1, T2>(SortedList<T1, T2> list, T1 x) where T1 : IComparable<T1>
      {
        return Lowerbound(list.Keys, x);
      }
      public static int Upperbound<T1, T2>(SortedList<T1, T2> list, T1 x) where T1 : IComparable<T1>
      {
        return Upperbound(list.Keys, x);
      }
      public static int Lowerbound<T>(IList<T> list, T x) where T : IComparable<T>
      {
        int min = 0;
        int max = list.Count;
        while (min < max)
        {
          var mid = (min + max) / 2;
          if (list[mid].CompareTo(x) >= 0)
          {
            max = mid;
          }
          else
          {
            min = mid + 1;
          }
        }
        return max;
      }
      public static int Upperbound<T>(IList<T> list, T x) where T : IComparable<T>
      {
        int min = 0;
        int max = list.Count;
        while (min < max)
        {
          var mid = (min + max) / 2;
          if (list[mid].CompareTo(x) > 0)
          {
            max = mid;
          }
          else
          {
            min = mid + 1;
          }
        }
        return max;
      }

    }


    class Util
    {
      public static T[,] Gen<T>(int r, int c, T v)
      {
        var matrix = new T[r, c];
        for (int i = 0; i < r; ++i)
        {
          for (int j = 0; j < c; ++j)
          {
            matrix[i, j] = v;
          }
        }
        return matrix;
      }
      public static long[] ASum(long[] array)
      {
        var res = new long[array.Length + 1];
        for (int i = 0; i < array.Length; ++i)
        {
          res[i + 1] = res[i] + array[i];
        }
        return res;
      }
      public static long[,] ASum(long[,] matrix)
      {
        var N = matrix.GetLength(0);
        var M = matrix.GetLength(1);
        var res = new long[N + 1, M + 1];
        for(int i = 0; i < N; ++i)
        {
          for(int j = 0; j < M; ++j)
          {
            res[i + 1, j + 1] = res[i, j + 1] + res[i + 1, j] - res[i, j] + matrix[i, j];
          }
        }
        return res;
      }
      public static MyDict<T, long> Frequency2<T>(T[] array)
      {
        var dict = new MyDict<T, long>();
        foreach (var a in array)
        {
          dict[a]++;
        }
        return dict;
      }
      public class MyDict<T1, T2> : Dictionary<T1, T2>
      {
        public new T2 this[T1 key]
        {
          get { if (!base.ContainsKey(key)) { base.Add(key, default(T2)); } return base[key]; }
          set { base[key] = value; }
        }
      }

      public static bool IsPrime(long x)
      {
        var fact = Factorize(x);
        return fact.Count == 1 && fact.Values.ElementAt(0) == 1;
      }
      public static Dictionary<long, int> Factorize(long x)
      {
        var dict = new Dictionary<long, int>();
        long minp = 2;
        while (x > 1)
        {
          bool ok = false;
          for (long p = minp; p * p <= x; ++p)
          {
            if (x % p == 0)
            {
              if (!dict.ContainsKey(p))
              {
                dict.Add(p, 0);
              }
              dict[p]++;
              minp = p;
              x /= p;
              ok = true;
              break;
            }
          }
          if (!ok)
          {
            if (!dict.ContainsKey(x)) { dict.Add(x, 0); }
            dict[x]++;
            break;
          }
        }
        return dict;
      }

      public static long GCD(long a, long b)
      {
        while (b > 0)
        {
          var c = a % b;
          a = b;
          b = c;
        }
        return a;
      }


      public class BIT
      {
        int N; long[] array;
        public BIT(int m) { for (int n = 1; ; n *= 2) { if (n >= m) { N = n; array = new long[N + 1]; break; } } }
        public void Add(int idx, int v) { for (int x = idx; x <= N; x += x & -x) { array[x] += v; } }
        public long Sum(int idx) { long ret = 0; for (int x = idx; x > 0; x -= x & -x) { ret += array[x]; } return ret; }
      }

      public class UnionFindTree
      {
        int[] parent; int[] count;
        public UnionFindTree(int n) { parent = new int[n]; count = new int[n]; for (int i = 0; i < n; ++i) { parent[i] = i; count[i] = 1; } }
        public int Root(int i) { if (parent[i] == i) { return i; } else { return parent[i] = Root(parent[i]); } }
        public int Count(int i) { return count[Root(i)]; }
        public bool Same(int i, int j) { return Root(i) == Root(j); }
        public void Unite(int i, int j) { var ri = Root(i); var rj = Root(j); if (ri != rj) { parent[ri] = rj; count[rj] += count[ri]; } }
      }
      public class PriorityQueue<T> where T : IComparable
      {
        private IComparer<T> _comparer = null; private bool _isAsc = true; private T[] _heap; private int _sz = 0;
        public PriorityQueue(int maxSize, IComparer<T> comparer) { _heap = new T[maxSize]; _comparer = comparer; }
        public PriorityQueue(int maxSize, bool isAsc = true) { _heap = new T[maxSize]; _isAsc = isAsc; }
        private int Compare(T x, T y) { if (_comparer != null) { return _comparer.Compare(x, y); } return _isAsc ? x.CompareTo(y) : y.CompareTo(x); }
        public void Push(T x) { var i = _sz++; while (i > 0) { var p = (i - 1) / 2; if (Compare(_heap[p], x) <= 0) { break; } _heap[i] = _heap[p]; i = p; } _heap[i] = x; }
        public T Pop() { T ret = _heap[0]; T x = _heap[--_sz]; int i = 0; while (i * 2 + 1 < _sz) { int a = i * 2 + 1; int b = i * 2 + 2; if (b < _sz && Compare(_heap[b], _heap[a]) < 0) { a = b; } if (Compare(_heap[a], x) >= 0) { break; } _heap[i] = _heap[a]; i = a; } _heap[i] = x; return ret; }
        public int Count() { return _sz; }
        public T Peek() { return _heap[0]; }
        public bool Contains(T x) { for (int i = 0; i < _sz; i++) if (x.Equals(_heap[i])) return true; return false; }
      }
      public class MyTuple<T1, T2> : IComparable where T1 : IComparable<T1>
      {
        public readonly T1 Item1; public readonly T2 Item2;
        public MyTuple(T1 item1, T2 item2) { Item1 = item1; Item2 = item2; }
        public int CompareTo(object obj) { return Item1.CompareTo(((MyTuple<T1, T2>)obj).Item1); }
      }
      public static long[] Dijkstra(Dictionary<int, Dictionary<int, long>> adj, int N, int M, int start)
      {
        long INF = (long)1e18;
        var dist = Enumerable.Range(0, N + 1).Select(i => INF).ToArray();
        var queue = new PriorityQueue<MyTuple<long, int>>(N + M + 100);
        dist[start] = 0;
        queue.Push(new MyTuple<long, int>(0, start));
        while (queue.Count() > 0)
        {
          var kvp = queue.Pop();
          var d = kvp.Item1; var v = kvp.Item2;
          if (dist[v] < d) { continue; }
          foreach (var kvp2 in adj[v])
          {
            var newV = kvp2.Key;
            var newD = dist[v] + kvp2.Value;
            if (newD < dist[newV])
            {
              dist[newV] = newD;
              queue.Push(new MyTuple<long, int>(newD, newV));
            }
          }
        }
        return dist;
      }
    }
    struct MOD
    {
      public static long P = 1000000007;
      public readonly long V;

      public MOD(long a) { this.V = a % P; }
      public static implicit operator MOD(long a) { return new MOD(a); }
      public static MOD operator +(MOD a, MOD b) { return new MOD((a.V + b.V) % P); }
      public static MOD operator -(MOD a, MOD b) { return new MOD((a.V - b.V + P) % P); }
      public static MOD operator *(MOD a, MOD b) { return new MOD((a.V * b.V) % P); }
      public static MOD operator /(MOD a, MOD b) { return new MOD((a.V * b.Inverse().V) % P); }
      public MOD Inverse()
      {
        long a = V, p = P; long b = p, c = 1, d = 0, e = 0, f = 0;
        while (b != 0) { e = a / b; f = b; b = a - e * b; a = f; f = d; d = c - e * d; c = f; }
        c %= p;
        return c + (c < 0 ? p : 0);
      }
      public MOD Power(long n)
      {
        long a = V, p = P; long res = 1; long mult = a;
        for (int i = 0; i < 63; ++i) { if ((n & ((long)1 << i)) > 0) { res = (res * mult) % p; } mult = (mult * mult) % p; }
        return res;
      }
      public override string ToString() { return V.ToString(); }
    }


    static class Read
{
static Queue<string> queue = new Queue<string>();
static void Enqueue() { var ss = Console.ReadLine().Split(' '); foreach (var s in ss) { queue.Enqueue(s); } }
public static int Int() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt32(queue.Dequeue()); }
public static long Long() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt64(queue.Dequeue()); }
public static string Str() { if (queue.Count == 0) { Enqueue(); } return queue.Dequeue(); }
public static int[] IntN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt32(s)).ToArray(); }
public static long[] LongN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt64(s)).ToArray(); }
public static ulong[] ULongN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToUInt64(s)).ToArray(); }
public static string[] StrN() { return Console.ReadLine().Split(' '); }
public static Tuple<int, int>[] TupleInt(int n) { List<Tuple<int, int>> list = new List<Tuple<int, int>>(); for (int i = 0; i < n; ++i) { var ab = Read.IntN(); list.Add(new Tuple<int, int>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<long, long>[] TupleLong(int n) { List<Tuple<long, long>> list = new List<Tuple<long, long>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<long, long>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<string, string>[] TupleStr(int n) { List<Tuple<string, string>> list = new List<Tuple<string, string>>(); for (int i = 0; i < n; ++i) { var ab = Read.StrN(); list.Add(new Tuple<string, string>(ab[0], ab[1])); } return list.ToArray(); }
public static Tuple<double, double>[] TupleDouble(int n) { List<Tuple<double, double>> list = new List<Tuple<double, double>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<double, double>(ab[0], ab[1])); } return list.ToArray(); }
public static long[,] LongMatrix(int r, int c) { var mat = new long[r, c]; for (int i = 0; i < r; ++i) { var x = Read.LongN(); for (int j = 0; j < c; ++j) { mat[i, j] = x[j]; } } return mat; }
public static Dictionary<int, HashSet<int>> AdjacencyList(int N, int M, bool isDirectional = false)
{
Dictionary<int, HashSet<int>> dict = new Dictionary<int, HashSet<int>>();
for (int i = 0; i <= N; ++i) { dict.Add(i, new HashSet<int>()); }
for (int i = 0; i < M; ++i) { var ab = Read.IntN(); if (!dict[ab[0]].Contains(ab[1])) { dict[ab[0]].Add(ab[1]); } if (!isDirectional && !dict[ab[1]].Contains(ab[0])) { dict[ab[1]].Add(ab[0]); } }
return dict;
}
public static Dictionary<int, Dictionary<int, long>> AdjacencyListWithWeight(int N, int M, bool isDirectional = false)
{
Dictionary<int, Dictionary<int, long>> dict = new Dictionary<int, Dictionary<int, long>>(); for (int i = 0; i <= N; ++i) { dict.Add(i, new Dictionary<int, long>()); }
for (int i = 0; i < M; ++i) { var ab = Read.IntN(); dict[ab[0]].Add(ab[1], ab[2]); if (!isDirectional) { dict[ab[1]].Add(ab[0], ab[2]); } }
return dict;
}
}
    }
}


Measured memory_bytes: 106920