#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <map>
#include <unordered_map>
#include <set>
#include <deque>

long long mod = 1e9+7;
class Mint {
public:
  long long x;
  Mint(){}; // 引数なしでも定義できるように引数なしコンストラクタも用意しておく
  Mint(long long a){
    x = a%mod;
    while(x<0){
      x += mod;
    }
  };
  Mint& operator += (const Mint &a){
    x+=a.x;
    x%=mod;
    return *this;
  }
  Mint& operator -= (const Mint &a){
    x += (mod - a.x);
    x%=mod;
    return *this;
  }
  Mint& operator *= (const Mint &a){
    x*=a.x;
    x%=mod;
    return *this;
  }

  // a^n mod を計算する
  // Useaeg: Mint z = y.pow(y, n);
  Mint pow(Mint a, long long n) const {
    Mint y(1);
    Mint b(a);
    while (n > 0) {
      if (n & 1) y *= b;
      b *= b;
      n >>= 1;
    }
    return y;
  }

  // a^{-1} mod を計算する
  Mint modinv(const Mint &a) const {
    return pow(a, mod-2);
  }

  Mint& operator /= (const Mint &a) {
    x *= modinv(a).x;
    x %= mod;
    return *this;
  }

  Mint operator + (Mint &a) const {
    Mint y(*this);
    y += a;
    return y;
  }

  Mint operator - (Mint &a) const {
    Mint y(*this);
    y -= a;
    return y;
  }

  Mint operator * (Mint &a) const {
    Mint y(*this);
    y *= a;
    return y;
  }

  Mint operator / (Mint &a) const {
    Mint y(*this);
    y/=a;
    return y.x;
  }

  // nCk @mod を計算する
  Mint nCk(Mint &n, const long long k) const {
    Mint y = Mint(1);
    for (Mint i(0); (i.x)<k; i.x++){
      y *= (n-i);
      y /= i;
    }
    return y;
  }

  // nPk @mod を計算する
  Mint nPk(Mint &n, long long k) const {
    Mint y(1);
    for (Mint i(0); (i.x)<k; i.x++){
      y *= (n-i);
    }
    return y;
  }
};

int main(){
  int N;
  int K;
  scanf("%d", &N);
  scanf("%d", &K);
  std::vector<long long> plus, minus, plus2, minus2;
  int A;
  int pluscount = 0;
  int minuscount = 0;
  for (int i=0; i<N; i++){
    scanf("%d", &A);
    if (A>0) {
      plus.push_back(A);
      plus2.push_back(A);
      pluscount++;
    }
    else if (A<0) {
      minus.push_back(abs(A));
      minus2.push_back(abs(A));
      minuscount++;
    }
  }
  int zerocount = N-pluscount-minuscount;
  bool canpositive = false;
  for (int pc=K; pc>=0; pc-=2){
    int mc = K-pc;
    if (pluscount>=pc && minuscount>=mc){
      canpositive = true;
    }
  }
  std::sort(plus.rbegin(), plus.rend());
  std::sort(minus.rbegin(), minus.rend());
  std::sort(plus2.begin(), plus2.end());
  std::sort(minus2.begin(), minus2.end());

  if (canpositive){
    //printf("canpositive\n");
    Mint ans(1);
    int ixp=0;
    int ixm=0;
    if (K%2==1){
      Mint y(plus[0]);
      ans *= y;
      ixp++;
    }
    while(ixp+ixm<K){
      if (ixp+2>plus.size()){
        Mint y(minus[ixm]);
        Mint z(minus[ixm+1]);
        ans *= y;
        ans *= z;
        ixm+=2;
      } else if (ixm+2>minus.size()){
        Mint y(plus[ixp]);
        Mint z(plus[ixp+1]);
        ans *= y;
        ans *= z;
        ixp+=2;
      } else {
        if (plus[ixp]*plus[ixp+1]>=minus[ixm]*minus[ixm+1]){
          Mint y(plus[ixp]);
          Mint z(plus[ixp+1]);
          ans *= y;
          ans *= z;
          ixp+=2;
        } else {
          Mint y(minus[ixm]);
          Mint z(minus[ixm+1]);
          ans *= y;
          ans *= z;
          ixm+=2;          
        }
      }
    }
    std::cout << ans.x << std::endl;
  } else if (zerocount>0){
    printf("0\n");
  } else {
    //printf("cannegative\n");
    Mint ans(1);
    int ixp=0;
    int ixm=0;
    if (K%2==1){
      Mint y(minus2[0]);
      ans *= y;
      ans *= -1;
      ixm++;
    } else {
      Mint y(minus2[0]);
      Mint z(plus2[0]);
      ans *= y;
      ans *= z;
      ans *= -1;
      ixp++;      
      ixm++;
    }
    while(ixp+ixm<K){
      if (ixp+2>plus.size()){
        Mint y(minus2[ixm]);
        Mint z(minus2[ixm+1]);
        ans *= y;
        ans *= z;
        ixm+=2;
      } else if (ixm+2>minus.size()){
        Mint y(plus2[ixp]);
        Mint z(plus2[ixp+1]);
        ans *= y;
        ans *= z;
        ixp+=2;
      } else {
        if (plus2[ixp]*plus2[ixp+1]>=minus2[ixm]*minus2[ixm+1]){
          Mint y(plus2[ixp]);
          Mint z(plus2[ixp+1]);
          ans *= y;
          ans *= z;
          ixp+=2;
        } else {
          Mint y(minus2[ixm]);
          Mint z(minus2[ixm+1]);
          ans *= y;
          ans *= z;
          ixm+=2;          
        }
      }
      //printf("ixp=%d, ixm=%d\n", ixp, ixm);
    }
    std::cout << ans.x << std::endl;
  }

  return 0;
}

Measured memory_bytes: 6324