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 Common Lisp (SBCL 2.0.3) (judge verdict: Wrong Answer)

;;; Utils

(defmacro read-numbers-to-list ()
  `(read-from-string
    (concatenate 'string "(" (read-line) ")")))


(defmacro read-line-to-array (dimension)
  (if (< dimension 0)
      (error "invalid arguments for dimension.")
      `(make-array ,dimension :initial-contents (read-numbers-to-list))))

(defmacro read-line-to--char-list ()
  `(concatenate 'list (read-line)))

(defmethod make-cumlative-sum ((sequence list))
  (labels ((inner (sequence &optional (acc '(0)))
             (if (null sequence)
                 (reverse acc)
                 (inner (rest sequence) (cons (+ (first sequence)
                                                 (first acc))
                                              acc)))))
    (inner sequence)))





(defmethod princ-for-each-line ((sequence list))
  (labels ((inner (sequence)
             (if (null sequence)
                 nil
                 (progn
                   (fresh-line)
                   (princ (first sequence))
                   (inner (rest sequence))))))
    (inner sequence)))

(defmethod princ-for-each-line ((sequence array))
  (dotimes (i (length sequence))
    (fresh-line)
    (princ (aref sequence i))))



;;; Write code here

(defun factorize-number-to-lst (x)
  (assert (and (numberp x)
               (plusp x)))
  (labels
      ((inner (x)
         (if (= x 1)
             1)
         (let ((res nil)
               (f 2))
           (loop while (<= (* f f) x) do
                (if (zerop (mod x f))
                    (progn
                      (setf x (truncate x f))
                      (push f res))
                    (incf f))
              finally
                (progn
                  (when (/= x 1)
                    (push x res))
                  (return (reverse res)))))))
    (inner x)))


(defun setwise-p (xs)
  (=
   (reduce #'gcd xs)
   1))


(defun step-sum (sequence start end step)
  (assert (arrayp sequence))
  (labels ((inner (start end step &optional (acc 0))
             (if (< start end)
                 (inner (+ start step) end step (+ acc
                                                   (aref sequence start)))
                 acc)))
    (inner start end step)))

(defun pairwise-p (n xs)
  (assert (and (plusp n)
               (every #'numberp xs)))
  (let ((memo (make-array (1+ (expt 10 6))::initial-element 0))
        (flag t))
    (dotimes (i n)
      (setf (aref memo (first xs)) 1)
      (pop xs))
    (let ((f 2))
      (loop while (<= f (expt 10 6)) do
           (when (> (step-sum memo f (expt 10 6) f) 1)
             (setf flag nil))
           (incf f)
         finally
           (return flag)))))



(defun solve (n a)
  (cond
    ((pairwise-p n a) "pairwise coprime")
    ((setwise-p a)  "setwise coprime")
    (t "not coprime")))


(defun main ()
  (let ((n (read))
        (a (sort (read-numbers-to-list) #'<)))
    (format t "~a~%" (solve n a))))

(main)