using System;
using System.Collections;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Collections.Generic;
using System.Threading.Tasks;

/*
・概要
	：高速で素因数分解を行う為のライブラリ
		「複数の」クエリの素因数分解を高速に処理する必要がある場合に、有用。
		計算量は、O(Q * logN)（Qはクエリ数、Nは対象整数の最大値）

	：使用場面
		クエリ数Qが大きく、かつNもそこそこ大きい場合に使おう　
		逆に、クエリは少ないがNがでかい場合は、通常の試し割りの方がマシ。

		（cf. 計算量O(Q * logN)
			Q, Nがともに10^6以下とかなら余裕で間に合う。
			但し、N以下の全整数に配列のインデックスを割り当てるので、
			Nがintの範囲を超えたりするともう無理。）

	：cf. なお、通常の素因数分解メソッド（試し割り法）は、
		対象の整数をNとしたとき、計算量O(√N)かかる。
		この場合だと間に合わない問題もある。
		（e.g.
			例えばN = 10^6で、かつN個のクエリに答えなければならない場合、
			計算量がO(N * √N) = O(N^(3/2))となり、
			10^9回の計算が必要となってしまい、間に合わない。）

・使用法
	1. PrimeFactorizationクラスのオブジェクトを作成
		コンストラクタの引数は、（対象となる整数の）最大値max。
		（e.g. PrimeFactorization pf = new PrimeFactorization(max);）

	2. 整数xの素因数分解の結果を、ディクショナリとして取得
		戻り値のディクショナリは、keyが素数pで、valueが指数nにあたる。（p^n）
		（e.g. Dictionary<int,int> factors = pf.GetPrimeFactors(x);）

・アルゴリズム
	1. 事前計算（計算量O(MAX * log(logMAX))：エラトステネスの篩と同様）
		最大の整数MAX以下の各正整数Xiについて、（1 <= Xi <= MAX）
		iの最小の素因数MinFactorを事前に計算しておく。
		（※各iに対して配列のインデックスを割り当てるので、
			メモリの都合上、MAXはintの範囲に収まらないと厳しい）

	2. 任意のXiの素因数分解（計算量O(logXi)）
		1で求めた最小の素因数MinFactorを辿っていけば良い、
		つまり、MinFactor[Xi] = Xjとしたとき、
		次にMinFactor[Xi / Xj] = Xk...という風に順番に見ていく。
		素数にたどり着いたところで終了。

	3. よって、Q個のクエリに応答するとした場合、
		全体の計算量は、O(MAX * log(logMAX) + Q * logXi)
		最大値MAX = Nに置き換えると、
		O(N * log(logN) + Q * logN)なので、ボトルネックを考えて
		O(Q * logN)となる。
		（※Q, Nがともに10^6以下とかだと余裕で間に合う。）
*/


class Program
{
	//最大公約数を求める関数（Gratest Common Divisor）
	//計算量はO(logN)（より小さい方の整数をNとしたとき）
	//タイプはulongとする
	static ulong GCD(ulong a, ulong b)
	{
		//より大きい方をnとする
		ulong n = Math.Max(a, b);
		ulong m = Math.Min(a, b);

		//ループ処理（ユークリッドの互除法を利用）
		while(m != 0){
			ulong rem = n % m;
			n = m;
			m = rem;
		}

		return n;
	}

	//Main（高速出力準備）
	static void Main(string[] args)
	{
		//出力準備（AutoFlushを切る）
		var sw = new StreamWriter(Console.OpenStandardOutput()){AutoFlush = false};
		Console.SetOut(sw);
		//解答
		Solve();
		//出力終了
		Console.Out.Flush();
	}

	static void Solve()
	{
		//読み込む
		int N = int.Parse(Console.ReadLine());
		ulong[] An = Console.ReadLine().Split(' ').Select(i => ulong.Parse(i)).ToArray();

		//全体の最大公約数（GCD(A0,A1,A2,...An)）
		ulong gcd = An[0];
		for(int i=1; i<N; i++){
			gcd = GCD(gcd,An[i]);
		}

		//A0からAnまでをそれぞれ素因数分解する
		//最大値
		int max = 1000000;

		//整数i-1を素因数に有する整数が既に見つかっているか
		bool[] found = new bool[max];

		//pairwiseであるフラグ
		bool pairwise = true;

		//1. PrimeFactorizationクラスのオブジェクトを作成
		//引数は、素因数分解の対象たる整数の最大値
		PrimeFactorization pf = new PrimeFactorization(max);

		//pairwiseかどうかを判定
		for(int i=0; i<N; i++){
			int x = (int)An[i];

			//2. 整数xの素因数分解の結果を、ディクショナリとして取得
			//戻り値のディクショナリは、keyが素数pで、valueが指数nにあたる。
			Dictionary<int,int> factors = pf.GetPrimeFactors(x);

			//素因数分解
			foreach(KeyValuePair<int,int> pair in factors){
				int p = pair.Key;

				//pを素因数に有するAn[j]が既に見つかっている場合、pairwiseたり得ない
				if(found[p-1]){
					pairwise = false;
					break;
				}
				//まだ見つかっていない場合、フラグに反映
				else{
					found[p-1] = true;
				}
			}

			//pairwiseでないことが判明している場合
			if(!pairwise){
				break;
			}
		}

		string ans = "";

		//条件判定
		if(pairwise){
			ans = "pairwise coprime";
		}
		else if(gcd == 1){
			ans = "setwise coprime";
		}
		else{
			ans = "not coprime";
		}

		Console.WriteLine(ans);
	}
}

//複数の素因数分解クエリに高速で答える為のクラス
class PrimeFactorization
{
	/*
	取り敢えずint型で実装
	（どの道、intを越えるようじゃメモリが足りない）
	*/

	/*
	1. メンバ変数
	*/
	//素因数分解の対象となる整数の最大値
	int MAX;
	//整数i（1 <= i <= MAX）の最小の素因数を格納する配列
	/*
	iの最小の素因数は、MinFactor[i]に保存されている
	（インデックス0は使用しない）
	*/
	int[] MinFactor;

	/*
	2. コンストラクタ
	*/
	//引数は、対象となる整数の最大値
	public PrimeFactorization(int max)
	{
		this.MAX = max;
		this.MinFactor = new int[this.MAX+1];

		//MAX以下の整数について、最小の素因数を取得
		this.SetMinFactor();
	}

	//事前準備として、最小の素因数を計算
	void SetMinFactor()
	{
		//先ず、配列を初期化
		for(int i=0; i<=this.MAX; i++){
			this.MinFactor[i] = i;
		}

		//√MAXまで探索を続ける
		for(int i=2; i*i<=this.MAX; i++){
			//自身が素数の場合（即ち、最小の素因数が自分自身の場合）
			if(this.MinFactor[i] == i){
				//iの倍数に該当する整数を探索
				for(int j=i*i; j<=this.MAX; j+=i){
					//最小の素因数がまだ決定していない場合、更新
					if(this.MinFactor[j] == j){
						this.MinFactor[j] = i;
					}
				}
			}
		}

		//終了
		return;
	}

	//素因数分解の結果を、ディクショナリとして出力
	/*
	ディクショナリのkeyが素数で、valueが指数にあたる。
	（e.g. 12 = 2^2 * 3の場合、
		factors[2] = 2, factors[3] = 1、となるようなディクショナリを出力。）
	*/
	public Dictionary<int,int> GetPrimeFactors(int X)
	{
		//素因数分解の結果を格納するディクショナリ
		Dictionary<int,int> factors = new Dictionary<int,int>();

		//素数に辿り着くまで、MinFactorを順に辿っていく
		int tempo = X;

		//素数に辿り着いた場合、tempo / p = 1となり、終了する。
		while(tempo != 1){
			//tempoの最小の素因数を取得
			int	p = this.MinFactor[tempo];
			//tempoの最小の素因数は、Xの素因数であるので、ディクショナリに反映
			//keyが存在しない場合、追加
			if(!factors.ContainsKey(p)){
				factors.Add(p,1);
			}
			//keyが存在する場合、指数を1つ増やす
			else{
				factors[p]++;
			}

			//次の数へ
			tempo /= p;
		}

		//ディクショナリを出力
		return factors;
	}
}



Measured memory_bytes: 100736