#include <bits/stdc++.h>
using namespace std;

using ll = long long;
using ull = unsigned long long;
#define repi(n) for (int i = 0; i < (n); i++)
#define repj(n) for (int j = 0; j < (n); j++)
#define repk(n) for (int k = 0; k < (n); k++)
#define repl(n) for (int l = 0; l < (n); l++)
#define rep(i, n) for (int i = 0; (i) < (n); i++)
#define repr(i, a, b) for (auto i = (a); i < (b); i++)
#define repv(itr) for (auto&& v : (itr))
#define repv2(itr) for (auto&& v2 : (itr))
#define repv3(itr) for (auto&& v3 : (itr))
#define updatemax(t, v) (t = max((t), (v)))
#define updatemin(t, v) (t = min((t), (v)))
const double PI = atan(1.0) * 4;
const double E = exp(1);
ll modpow(ll a, ll b, ll m) {
  ll re = 1, k = 1;
  while (k <= b) {
    if (b & k) {
      re *= a;
      re %= m;
    }
    k = k << 1;
    a *= a;
    a %= m;
    a += m;
    a %= m;
  }
  return re;
}
ll modinv(ll a, ll m) {
  a %= m;
  if (a < 0) a += m;
  ll b = m, u = 1, v = 0;
  while (b) {
    ll t = a / b;
    a -= t * b;
    swap(a, b);
    u -= t * v;
    swap(u, v);
  }
  u %= m;
  if (u < 0) u += m;
  return u;
}
ll modbinomial(ll n, ll k, ll m) {
  k = min(k, n - k);
  if (k < 0) return 0;
  ll re = 1;
  for (ll i = 0; i < k; i++) {
    re *= n - i;
    re %= m;
    re *= modinv(i + 1, m);
    re %= m;
  }
  return re;
}
class uftree {
 private:
  int n, groups;
  vector<int> parent, size;

 public:
  uftree(int _n) {
    groups = n = _n;
    parent.resize(n);
    size.resize(n);
    for (int i = 0; i < n; i++) {
      parent[i] = i;
      size[i] = 1;
    }
  }
  int group(int x) {
    if (parent[x] == x) return x;
    return parent[x] = group(parent[x]);
  }
  bool inSameGroup(int x, int y) { return group(x) == group(y); }
  int groupSizeOf(int x) { return size[group(x)]; }
  void merge(int x, int y) {
    int gx = group(x), gy = group(y);
    if (gx != gy) {
      parent[gx] = gy;
      size[gy] += size[gx];
      size[gx] = 0;
      groups--;
    }
  }
  int countGroups() { return groups; }
};
template <typename T>
class segtree {
 private:
  int n;
  function<T(T, T)> f;
  T e;
  vector<T> data, lazy;
  void _updateP(int i) {
    data[i] = f(data[i * 2 + 1], data[i * 2 + 2]);
    if (i) _updateP((i - 1) / 2);
  }
  T _calc(int begin, int end, int node, int nodeBegin, int nodeEnd) {
    if (end <= nodeBegin || nodeEnd <= begin) {
      return e;
    } else if (begin <= nodeBegin && nodeEnd <= end) {
      return data[node];
    } else {
      int m = (nodeBegin + nodeEnd) / 2;
      T left = _calc(begin, end, node * 2 + 1, nodeBegin, m);
      T right = _calc(begin, end, node * 2 + 2, m, nodeEnd);
      return f(left, right);
    }
  }

 public:
  segtree(int n_, function<T(T, T)> f_, T e_, T fill) {
    n = pow(2, ceil(log2(n_)));
    f = f_;
    e = e_;
    data.resize(n * 2 - 1);
    for (int i = 0; i < n * 2 - 1; i++) data[i] = fill;
  }
  segtree(int n_, function<T(T, T)> f_, T e_) : segtree(n_, f_, e_, e_) {}
  T value(int i) { return data[n - 1 + i]; }
  void update(int i, T value) {
    data[n - 1 + i] = value;
    if (n) _updateP((n - 2 + i) / 2);
  }
  T calc(int begin, int end) { return _calc(begin, end, 0, 0, n); }
  static T max(T a, T b) { return std::max(a, b); }
  static T min(T a, T b) { return std::min(a, b); }
  static T sum(T a, T b) { return a + b; }
};

bool comp(const ll a, const ll b) {
  return abs(a) > abs(b) || (abs(a) == abs(b) && a > b);
}

const ll waru = 1e9 + 7;
ll a[200100];
int main() {
  int n, k;
  cin >> n >> k;
  bool allnegative = true;
  repi(n) {
    cin >> a[i];
    if (a[i] > 0) allnegative = false;
  }
  sort(a, a + n, comp);
  ll re = 1;
  if (k % 2 == 1 && allnegative) {
    repi(k) {
      re *= a[n - 1 - i];
      re %= waru;
    }
  } else {
    bool positive = true;
    repi(k) {
      re *= a[i];
      re %= waru;
      if (a[i] < 0) positive = !positive;
    }
    if (!positive && k < n) {
      ll outp, outn, inp, inn;
      bool outpexits = false, inpexists = false, innexists = false;
      repi(k) {
        if (a[k - 1 - i] > 0) {
          outp = a[k - 1 - i];
          outpexits = true;
          break;
        }
      }
      repi(k) {
        if (a[k - 1 - i] < 0) {
          outn = a[k - 1 - i];
          break;
        }
      }
      repi(n - k) {
        if (a[k + i] > 0) {
          inp = a[k + i];
          inpexists = true;
          break;
        }
      }
      repi(n - k) {
        if (a[k + i] < 0) {
          inn = a[k + i];
          innexists = true;
          break;
        }
      }
      bool choose_inn_outp;
      if (!inpexists) {
        choose_inn_outp = true;
      } else if (!innexists || !outpexits) {
        choose_inn_outp = false;
      } else {
        choose_inn_outp = abs(inn * outn) >= abs(inp * outp);
      }
      // cout << "outn:" << outn << endl;
      // cout << "outp:" << outp << endl;
      // cout << "inn:" << inn << endl;
      // cout << "inp:" << inp << endl;
      if (choose_inn_outp) {
        re *= inn;
        re %= waru;
        re *= modinv(outp, waru);
        re %= waru;
      } else {
        re *= inp;
        re %= waru;
        re *= modinv(outn, waru);
        re %= waru;
      }
    }
  }
  re %= waru;
  if (re < 0) re += waru;
  cout << re << endl;
}


Measured memory_bytes: 5180