Problem:
Score : 500 points

Problem Statement

We have N integers. The i-th number is A_i.

\{A_i\} is said to be pairwise coprime when GCD(A_i,A_j)=1 holds for every pair (i, j) such that 1\leq i < j \leq N.

\{A_i\} is said to be setwise coprime when \{A_i\} is not pairwise coprime but GCD(A_1,\ldots,A_N)=1.

Determine if \{A_i\} is pairwise coprime, setwise coprime, or neither.

Here, GCD(\ldots) denotes greatest common divisor.

Constraints

2 \leq N \leq 10^6

1 \leq A_i\leq 10^6

Input

Input is given from Standard Input in the following format:

N
A_1 \ldots A_N

Output

If \{A_i\} is pairwise coprime, print pairwise coprime; if \{A_i\} is setwise coprime, print setwise coprime; if neither, print not coprime.

Sample Input 1

3
3 4 5

Sample Output 1

pairwise coprime

GCD(3,4)=GCD(3,5)=GCD(4,5)=1, so they are pairwise coprime.

Sample Input 2

3
6 10 15

Sample Output 2

setwise coprime

Since GCD(6,10)=2, they are not pairwise coprime. However, since GCD(6,10,15)=1, they are setwise coprime.

Sample Input 3

3
6 10 16

Sample Output 3

not coprime

GCD(6,10,16)=2, so they are neither pairwise coprime nor setwise coprime.

Solution in Rust (1.42.0) (judge verdict: Wrong Answer)

use proconio::{input, fastout};
use proconio::marker::{Chars};
use proconio::marker::Usize1;
use std::cmp::*;

macro_rules! debug {
      ($($a:expr),*) => {
          eprintln!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}

fn gcd(mut a: usize, mut b: usize) -> usize {
    if a<b {
        let mut tmp = a;
        a = b;
        b = tmp;
    } 
    let mut r = a % b;
    while r!=0 {
        a = b;
        b = r;
        r = a % b;
    }
    b
}

#[fastout]
fn main() {
    input!{
        n: usize,
        a: [usize;n],
    }
    
    let mut primes: Vec<usize> = vec![0;1000_000];
    // let mut primes: Vec<usize> = vec![0;6];
    let mut ok = true;
    for i in 0..n {
        let s = (a[i] as f64).sqrt().ceil() as usize;
        for j in 2..s+1 {
            let mut ret = 0;
            let mut a_tmp = a[i];
            if a[i]%j==0 {
                while a_tmp%j==0 {
                    a_tmp /= j;
                }
                if primes[j]!=0 || primes[a_tmp]!=0 {
                    ok = false;
                    break;
                } else if primes[j]==0 {
                    primes[j] += 1;
                } else if primes[a_tmp]==0 {
                    primes[a_tmp] += 1;
                }
            }
        }
        if ok==false {
            break;
        }
    }
    // debug!(primes);

    if ok==true {
        println!("pairwise coprime");
        return;
    } else {
        let mut ret = a[0];
        for i in 1..n {
            ret = gcd(ret, a[i]);
        }
        if ret==1 {
            println!("setwise coprime");
        } else {
            println!("not coprime");
        }
    }

}