/*/ Author: kal013 /*/
// #pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
using namespace std;
using namespace __gnu_pbds;

template<class T> 
using ordered_set = tree<T, null_type,less<T>, rb_tree_tag,tree_order_statistics_node_update> ;

template<class key, class value, class cmp = std::less<key>>
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// find_by_order(k)  returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;

struct custom_hash { // Credits: https://codeforces.com/blog/entry/62393
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
    size_t operator()(pair<int64_t,int64_t> Y) const{
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(Y.first * 31 + Y.second + FIXED_RANDOM);
    }
};

template<class T> ostream& operator<<(ostream &os, vector<T> V) {
    os << "[ ";
    for(auto v : V) os << v << " ";
    return os << "]";
}
template<class T> ostream& operator<<(ostream &os, set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, unordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator << (ostream& os, multiset<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, ordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {
    return os << "(" << P.first << "," << P.second << ")";
}
template<class L, class R> ostream& operator<<(ostream &os, map<L,R> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R>> ostream& operator<<(ostream &os, unordered_map<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R> > ostream& operator<<(ostream &os, gp_hash_table<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}

#define TRACE
#ifdef TRACE
    #define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template <typename Arg1>
    void __f(const char* name, Arg1&& arg1){
        cerr << name << " : " << arg1 << endl;
    }
    template <typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names + 1, ',');
        cerr.write(names, comma - names) << " : " << arg1<<" | ";
        __f(comma+1, args...);
    }
#else
    #define trace(...) 1
#endif

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random_long(long long l,long long r){
    uniform_int_distribution<int64_t> generator(l,r);
    return generator(rng);
}
inline int64_t random_long(){
    uniform_int_distribution<int64_t> generator(LLONG_MIN,LLONG_MAX);
    return generator(rng);
}


/*/---------------------------Defines----------------------/*/
typedef vector<int> vi;
typedef pair<int,int> pii;

#define ll long long
#define F first
#define S second
#define pb push_back
#define endl "\n"
#define all(v) (v).begin(),(v).end()
/*/-----------------------Modular Arithmetic---------------/*/

const int mod=1e9+7;
inline int add(int x,int y){
    x+=y;
    if (x>=mod) return x-mod;
    return x;
}
inline int sub(int x,int y){
    x-=y;
    if (x<0) return x+mod;
    return x;
}
inline int mul(int x,int y){
    return (x*1ll*y)%mod;
}
inline int power(int x,int y){
    int ans=1;
    while(y){
        if (y&1) ans=mul(ans,x);
        x=mul(x,x);
        y>>=1;
    }
    return ans;
}
inline int inv(int x){
    return power(x,mod-2);
}
/*/-----------------------------Code begins----------------------------------/*/

void solve(){
    int n,k;
    cin >> n >> k;

    vector<pair<int,int> >  A(n);
    int cnt_neg = 0, cnt_zero = 0;
    for(int i = 0; i < n; ++i){
    	cin >> A[i].second;
    	A[i].first = abs(A[i].second);
    	if (A[i].second == 0){
    		++cnt_zero;
    	}
    	else if (A[i].second  < 0 ){
    		A[i].second = -1;
    		++cnt_neg;
    	}
    	else{
    		A[i].second = 1;
    	}
    }
    int ans = 1;
    if (k == n){
    	for(int z = 0; z < n; ++z){
    		ans = mul(ans,A[z].first);
    		if (A[z].second == -1) ans = sub(0,ans);
    	}
    	cout << ans << endl;
    	return;
    }

    sort(all(A));

    if (cnt_neg == n && (k&1)){
    	int ans = 1;
    	for(int i = 0; i < k; ++i){
    		ans = mul(ans,mod - A[i].first);
    	}

    	cout << ans << endl;
    	return;
    }
    else if (cnt_neg + cnt_zero == n && (k&1)){
    	cout << 0 << endl;
    	return;
    }


    int n_cnt = 0;
    int l_neg = n,l_pos = n;
    ans = 1;
    for(int i = n - 1; i >= n - k; --i){
    	if (A[i].second == -1){
    		l_neg = i;
    		++n_cnt;
    	} 
    	else if (A[i].second == 1){
    		l_pos = i;
    	}
    	ans = mul(ans,A[i].first);
    }

    if (n_cnt&1 && ans != 0){
    	assert(l_neg < n);
    	int mx_pos = 0, mx_neg = 0;


    	for(int i = 0; i < n-k; ++i){
    		if (A[i].second == 1){
    			mx_pos = A[i].first;
    		}
    		else if (A[i].second == -1){
    			mx_neg = A[i].first;
    		}
    	}
    	if (mx_neg == 0 && mx_pos == 0){
    		cout << 0 << endl;
    		return;
    	}
    	else if (mx_neg == 0 || l_pos == n){
    		ans = mul(ans,mx_pos);
    		ans = mul(ans,inv(A[l_neg].first));
    		cout << ans << endl;
    	}
    	else if (mx_pos == 0){
    		assert(l_pos < n);
    		ans = mul(ans,mx_neg);
    		ans = mul(ans,inv(A[l_pos].first));
    		cout << ans << endl;
    	}
    	else {
    		assert(l_pos < n);
    		long long p1 = A[l_neg].first * 1ll * mx_neg, p2 = A[l_pos].first * 1ll * mx_pos;
    		ans = mul(ans,inv(A[l_neg].first));
    		ans = mul(ans,inv(A[l_pos].first));
    		p1 = max(p1,p2);
    		p1 %= mod;
    		ans = mul(ans, p1);

    		cout << ans << endl;
    	}
    }
    else{
    	cout << ans << endl;
    }





}
int main(){
    // Use "set_name".max_load_factor(0.25);"set_name".reserve(512); with unordered set
    // Or use gp_hash_table<X,null_type>
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
    cout<<fixed<<setprecision(25);
    cerr<<fixed<<setprecision(10);
    auto start = std::chrono::high_resolution_clock::now();
    int t=1;
    // cin>>t;
    while(t--) {
        solve();
    }
    auto stop = std::chrono::high_resolution_clock::now(); 
    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start); 
    
    // cerr << "Time taken : " << ((long double)duration.count())/((long double) 1e9) <<"s "<< endl;     
}


Measured memory_bytes: 4804