Problem:
Score : 500 points

Problem Statement

Given are N integers A_1,\ldots,A_N.

We will choose exactly K of these elements. Find the maximum possible product of the chosen elements.

Then, print the maximum product modulo (10^9+7), using an integer between 0 and 10^9+6 (inclusive).

Constraints

1 \leq K \leq N \leq 2\times 10^5

|A_i| \leq 10^9

Input

Input is given from Standard Input in the following format:

N K
A_1 \ldots A_N

Output

Print the maximum product modulo (10^9+7), using an integer between 0 and 10^9+6 (inclusive).

Sample Input 1

4 2
1 2 -3 -4

Sample Output 1

12

The possible products of the two chosen elements are 2, -3, -4, -6, -8, and 12, so the maximum product is 12.

Sample Input 2

4 3
-1 -2 -3 -4

Sample Output 2

1000000001

The possible products of the three chosen elements are -24, -12, -8, and -6, so the maximum product is -6.

We print this value modulo (10^9+7), that is, 1000000001.

Sample Input 3

2 1
-1 1000000000

Sample Output 3

1000000000

The possible products of the one chosen element are -1 and 1000000000, so the maximum product is 1000000000.

Sample Input 4

10 10
1000000000 100000000 10000000 1000000 100000 10000 1000 100 10 1

Sample Output 4

999983200

Be sure to print the product modulo (10^9+7).

Solution in Common Lisp (SBCL 2.0.3) (judge verdict: Wrong Answer)

(defun main ()
  (let* ((n (read))
         (k (read))
         (a (make-array (list n)))
         (mx 0)
         (my 0)
         (s 0)
         (z 0)
         (x 1)
         (pe nil)
         (y 1)
         (_ (+ (expt 10 9) 7)))
    ;
    (loop :for i :from 0 :to n
          :do (let ((w (read)))
                (setf (aref a i) w)
                (if (= w 0) (incf z))))
    ;
    (when (> k (- n z))
      (format t "0~%")
      (return-from main))
    
    (setf a (sort a (lambda (a b) (> (abs a) (abs b)))))
    (loop :with i := 0
          :with j := 0
          :while (< j k)
          :if (/= (aref a i) 0)
          :do (progn
                (when (< (aref a i) 0)
                  (incf mx))
                (setf x (mod (* x (abs (aref a i))) _))
                (incf j))
          :do (incf i))
    (loop :with i := 0
          :with j := 0
          :while (< j k)
          :if (/= (aref a (- (1- n) i)) 0)
          :do (progn
                (when (< (aref a (- (1- n) i)) 0)
                  (incf my))
                (setf y (mod (* y (abs (aref a (- (1- n) i)))) _))
                (setf s i)
                (incf j))
          :do (incf i))
    
    (loop :named foo
          :for i :from (1+ s) :to (1- n)
          :if (> (aref a i) 0)
          :do (progn
                (setf pe (aref a i))
                (return-from foo)))
    
    (cond ((evenp mx)
           (format t "~A~%" x))
          (pe
           (let ((mm))
             (loop :named foo
                   :for i :from s :downto 0
                   :if (< (aref a i) 0)
                   :do (progn
                         (setf mm (aref a i))
                         (return-from foo)))             
             (setf mm (mod (expt mm (- _ 2)) _))
             (format t "~A~%" (mod (* (mod (* x pe) _) mm) _))))
          (t
           (format t "~A~%" y)))))
(main)