output_description: Print the maximum product modulo (10^9+7), using an integer between 0 and
  10^9+6 (inclusive).
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N K
      A_1 \ldots A_N
attempt: # でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
  import sys
  
  MOD = 10**9 + 7
  
  
  def main(N, K, A):
      negative = sorted([a for a in A if a < 0])
      neg = len(negative)
      zero = [a for a in A if a == 0]
      positive = sorted([a for a in A if a > 0])
      pos = len(positive)
  
      if N - K < len(zero):
          return 0
      N -= len(zero)
      A = sorted([a for a in A if a != 0], key=lambda x: abs(x))
  
      ans = Mint(1)
      if ((neg & (~1)) + pos < K) or (neg & 1 and K == N) or (pos == 0 and K & 1):
          # マイナスになっちゃう
          for i in range(K):
              ans *= abs(A[i])
          ans = -ans
      else:
          # プラスにできる
          A.reverse()
          neg_cnt = 0
          last_pos = 0
          last_cnt = 0
          for i in range(K):
              ans *= abs(A[i])
              if A[i] < 0:
                  neg_cnt += 1
              if neg_cnt & 1 == 0:
                  last_pos = ans.value
                  last_cnt = i + 1
          remain = K - last_cnt
          if remain == 1:
              for i in range(last_cnt, N):
                  if A[i] > 0:
                      ans = Mint(last_pos * A[i])
                      break
          elif remain != 0:
              pospos = 1
              negneg = 1
              pos_rem = remain
              neg_rem = remain
              for i in range(last_cnt, N):
                  if A[i] > 0 and pos_rem > 0:
                      pospos *= A[i]
                      pos_rem -= 1
                  if A[i] < 0 and neg_rem > 0:
                      negneg *= abs(A[i])
                      neg_rem -= 1
                  if pos_rem == neg_rem == 0:
                      break
              pospos = pospos if pos_rem == 0 else 1
              negneg = negneg if neg_rem == 0 else 1
              ans = Mint(last_pos * max(pospos, negneg))
  
      return ans
  
  
  class Mint:
      def __init__(self, value=0):
          self.value = value % MOD
          if self.value < 0:
              self.value += MOD
  
      @staticmethod
      def get_value(x):
          return x.value if isinstance(x, Mint) else x
  
      def inverse(self):
          a, b = self.value, MOD
          u, v = 1, 0
          while b:
              t = a // b
              b, a = a - t * b, b
              v, u = u - t * v, v
          if u < 0:
              u += MOD
          return u
  
      def __repr__(self):
          return str(self.value)
  
      def __eq__(self, other):
          return self.value == other.value
  
      def __neg__(self):
          return Mint(-self.value)
  
      def __hash__(self):
          return hash(self.value)
  
      def __bool__(self):
          return self.value != 0
  
      def __iadd__(self, other):
          self.value = (self.value + Mint.get_value(other)) % MOD
          return self
  
      def __add__(self, other):
          new_obj = Mint(self.value)
          new_obj += other
          return new_obj
  
      __radd__ = __add__
  
      def __isub__(self, other):
          self.value = (self.value - Mint.get_value(other)) % MOD
          if self.value < 0:
              self.value += MOD
          return self
  
      def __sub__(self, other):
          new_obj = Mint(self.value)
          new_obj -= other
          return new_obj
  
      def __rsub__(self, other):
          new_obj = Mint(Mint.get_value(other))
          new_obj -= self
          return new_obj
  
      def __imul__(self, other):
          self.value = self.value * Mint.get_value(other) % MOD
          return self
  
      def __mul__(self, other):
          new_obj = Mint(self.value)
          new_obj *= other
          return new_obj
  
      __rmul__ = __mul__
  
      def __ifloordiv__(self, other):
          other = other if isinstance(other, Mint) else Mint(other)
          self *= other.inverse()
          return self
  
      def __floordiv__(self, other):
          new_obj = Mint(self.value)
          new_obj //= other
          return new_obj
  
      def __rfloordiv__(self, other):
          new_obj = Mint(Mint.get_value(other))
          new_obj //= self
          return new_obj
  
  
  if __name__ == "__main__":
      input = sys.stdin.readline
      N, K = map(int, input().split())
      (*A,) = map(int, input().split())
      print(main(N, K, A))
  
problem_description: 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).
samples: [{"input": "4 2\n    1 2 -3 -4", "output": "12\n    \n\nThe possible products of the two chosen elements are 2, -3, -4, -6, -8, and\n12, so the maximum product is 12.\n\n* * *"}, {"input": "4 3\n    -1 -2 -3 -4", "output": "1000000001\n    \n\nThe possible products of the three chosen elements are -24, -12, -8, and -6,\nso the maximum product is -6.\n\nWe print this value modulo (10^9+7), that is, 1000000001.\n\n* * *"}, {"input": "2 1\n    -1 1000000000", "output": "1000000000\n    \n\nThe possible products of the one chosen element are -1 and 1000000000, so the\nmaximum product is 1000000000.\n\n* * *"}, {"input": "10 10\n    1000000000 100000000 10000000 1000000 100000 10000 1000 100 10 1", "output": "999983200\n    \n\nBe sure to print the product modulo (10^9+7)."}]