#pragma GCC optimize("O3") //コンパイラ最適化用

#define _GLIBCXX_DEBUG //配列に[]でアクセス時のエラー表示
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
// forループ関係
//引数は、(ループ内変数,動く範囲)か(ループ内変数,始めの数,終わりの数)、のどちらか
// Dがついてないものはループ変数は1ずつインクリメントされ、Dがついてるものはメントされる
#define REP(i, n) for (ll i = 0; i < ll(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--) //ループ変数は1ずつデクリ
#define FOR(i, a, b) for (ll i = a; i < ll(b); i++)
#define FORD(i, a, b) for (ll i = a; i > ll(b); i--) //ループ変数は1ずつデクリ
// xにはvectorなどのコンテナ
#define ALL(x) x.begin(), x.end() // sortなどの引数を省略したい

const ll MOD = 1000000007;

// modint: mod 計算を int を扱うように扱える構造体
template <int MOD> struct Fp {
    long long val;
    constexpr Fp(long long v = 0) noexcept : val(v % MOD) {
        if (val < 0)
            val += MOD;
    }
    constexpr int getmod() { return MOD; }
    constexpr Fp operator-() const noexcept { return val ? MOD - val : 0; }
    constexpr Fp operator+(const Fp &r) const noexcept {
        return Fp(*this) += r;
    }
    constexpr Fp operator-(const Fp &r) const noexcept {
        return Fp(*this) -= r;
    }
    constexpr Fp operator*(const Fp &r) const noexcept {
        return Fp(*this) *= r;
    }
    constexpr Fp operator/(const Fp &r) const noexcept {
        return Fp(*this) /= r;
    }
    constexpr Fp &operator+=(const Fp &r) noexcept {
        val += r.val;
        if (val >= MOD)
            val -= MOD;
        return *this;
    }
    constexpr Fp &operator-=(const Fp &r) noexcept {
        val -= r.val;
        if (val < 0)
            val += MOD;
        return *this;
    }
    constexpr Fp &operator*=(const Fp &r) noexcept {
        val = val * r.val % MOD;
        return *this;
    }
    constexpr Fp &operator/=(const Fp &r) noexcept {
        long long a = r.val, b = MOD, u = 1, v = 0;
        while (b) {
            long long t = a / b;
            a -= t * b;
            swap(a, b);
            u -= t * v;
            swap(u, v);
        }
        val = val * u % MOD;
        if (val < 0)
            val += MOD;
        return *this;
    }
    constexpr bool operator==(const Fp &r) const noexcept {
        return this->val == r.val;
    }
    constexpr bool operator!=(const Fp &r) const noexcept {
        return this->val != r.val;
    }
    friend constexpr ostream &operator<<(ostream &os,
                                         const Fp<MOD> &x) noexcept {
        return os << x.val;
    }
    friend constexpr Fp<MOD> modpow(const Fp<MOD> &a, long long n) noexcept {
        if (n == 0)
            return 1;
        auto t = modpow(a, n / 2);
        t = t * t;
        if (n & 1)
            t = t * a;
        return t;
    }
};
using mint = Fp<MOD>;
int main() {
    ll n, k;
    cin >> n >> k;
    vector<ll> a(n);
    vector<ll> nng, ng;
    REP(i, n) {
        cin >> a[i];
        if (a[i] < 0) {
            ng.push_back(a[i]);

        } else {
            nng.push_back(a[i]);
        }
    }

    ll Snng = nng.size();
    ll Sng = ng.size();

    bool can_nng = false;
    if (Snng > 0) {
        if (n == k) {
            can_nng = (Sng % 2 == 0);
        } else {
            can_nng = true;
        }

    } else {
        can_nng = (k % 2 == 0);
    }

    mint ans = 1;
    if (!can_nng) {
        sort(a.begin(), a.end(), [](ll x, ll y) { return abs(x) < abs(y); });
        REP(ki, k) { ans *= a[ki]; }

    } else {
        sort(ALL(nng));
        sort(ALL(ng));
        reverse(ALL(ng));
        if (k % 2 == 1) {
            if (nng.size() >= 1) {
                ans *= nng.back();
                nng.pop_back();
            }
        }
        vector<ll> pairs;
        while (nng.size() >= 2) {
            ll x = nng.back();
            nng.pop_back();
            x = x * nng.back();
            nng.pop_back();
            pairs.push_back(x);
        }
        while (ng.size() >= 2) {
            ll x = ng.back();
            ng.pop_back();
            x = x * ng.back();
            ng.pop_back();
            pairs.push_back(x);
        }
        sort(ALL(pairs));
        reverse(ALL(pairs));

        REP(i, k / 2) { ans = ans * pairs[i]; }
    }
    cout << ans << endl;
}


Measured memory_bytes: 8272