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: Accepted)

#![allow(unused_imports)]
#![allow(dead_code)]

use proconio::input;
use proconio::marker::{Bytes, Chars};
use std::collections::*;

fn main() {
    input! {
        n:usize,
        a:[i64;n],
    }
    let ans = if is_pairwise_coprime(&a) {
        "pairwise coprime"
    } else if is_setwise_coprime(&a) {
        "setwise coprime"
    } else {
        "not coprime"
    };
    println!("{}", ans);
}

fn sheave(n: usize) -> Vec<i64> {
    let mut res = vec![0; n + 1];
    for i in 2..=n {
        if res[i] == 0 {
            for j in (1..).take_while(|&j| i * j <= n).map(|j| j * i) {
                if res[j] == 0 {
                    res[j] = i as i64;
                }
            }
        }
    }
    return res;
}

fn pf(mut x: i64, sheave: &Vec<i64>) -> BTreeSet<i64> {
    let mut res = BTreeSet::new();
    while x != 1 {
        let p = sheave[x as usize];
        res.insert(p);
        x /= p;
    }
    return res;
}

fn is_pairwise_coprime(a: &Vec<i64>) -> bool {
    let m = 1000000;
    let sheave = sheave(m);
    let mut used = vec![false; m];
    for &x in a.iter() {
        let pf = pf(x, &sheave);
        for p in pf {
            let p = p as usize;
            if used[p] {
                return false;
            } else {
                used[p] = true;
            }
        }
    }
    true
}

fn gcd(a: i64, b: i64) -> i64 {
    if b == 0 {
        a
    } else {
        gcd(b, a % b)
    }
}

fn is_setwise_coprime(a: &Vec<i64>) -> bool {
    a.iter().fold(0, |acc, &x| gcd(acc, x)) == 1
}