//Optional FAST

//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,fma,abm,mmx,avx,avx2,tune=native")

//Required Libraries

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>

//Required namespaces

using namespace std;
using namespace __gnu_pbds;

//Required defines

#define endl '\n'

#define READ(X) cin>>X;
#define READV(X) long long X; cin>>X;
#define READAR(A,N) long long A[N]; for(long long i=0;i<N;i++) {cin>>A[i];}
#define rz(A,N) A.resize(N);
#define sz(X) (long long)(X.size())
#define pb push_back
#define pf push_front
#define fi first
#define se second
#define FORI(a,b,c) for(long long a=b;a<c;a++)
#define FORD(a,b,c) for(long long a=b;a>c;a--)

//Required typedefs

typedef tree<long long,null_type,less<long long>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
typedef tree<long long,null_type,greater<long long>,rb_tree_tag,tree_order_statistics_node_update> ordered_set1;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<long long,long long> pll;

//Required Constants

const long long inf=(long long)1e18;
const long long MOD=(long long)(1e9+7);
const long long INIT=(long long)(1e6+1);
const long double PI=3.14159265358979;

// Required random number generators

// mt19937 gen_rand_int(chrono::steady_clock::now().time_since_epoch().count());
// mt19937_64 gen_rand_ll(chrono::steady_clock::now().time_since_epoch().count());

//Required Functions

ll power(ll x,ll y) 
{ 
    if (y == 0) 
        return 1; 
    ll p = power(x, y/2) % MOD; 
    p = (p * p) % MOD; 
  
    return (y%2 == 0)? p : (x * p) % MOD; 
}
ll modInverse(ll a) 
{ 
   return power(a,MOD-2); 
   
}

//Work

int main()
{
    #ifndef ONLINE_JUDGE
    if (fopen("INPUT.txt", "r"))
    {
        freopen ("INPUT.txt" , "r" , stdin);
        //freopen ("OUTPUT.txt" , "w" , stdout);
    }
    #endif
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    clock_t clk;
    clk = clock();
//-----------------------------------------------------------------------------------------------------------//

    READV(N);
    READV(K);
    ll neg=0,pos=0,zero=0;
    READAR(A,N);
    FORI(i,0,N)
    {
        neg+=(A[i]<0);
        pos+=(A[i]>0);
        zero+=(A[i]==0);
    }
    bool positive_pos=false;
    FORI(i,0,pos+1)
    {
        if(i<=K && (K-i)%2==0 && neg>=(K-i))
        {
            positive_pos=true;
        }
    }
    if(positive_pos)
    {
        vector<ll> positive_guys,negative_guys;
        pair<ll,pll> last={-1,{-1,-1}};
        FORI(i,0,N)
        {
            if(A[i]<0)
            {
                negative_guys.pb(abs(A[i]));
            }
            else if(A[i]>0)
            {
                positive_guys.pb(A[i]);
            }
        }
        sort(positive_guys.begin(),positive_guys.end(),greater<>());
        sort(negative_guys.begin(),negative_guys.end(),greater<>());
        multiset<pair<ll,pll>,greater<>> positive_dual,negative_dual;
        vector<bool> taken(sz(positive_guys),false);
        FORI(i,0,sz(positive_guys)-1)
        {
            positive_dual.insert({positive_guys[i]*positive_guys[i+1],{i,i+1}});
            i++;
        }
        FORI(i,0,sz(negative_guys)-1)
        {
            negative_dual.insert({negative_guys[i]*negative_guys[i+1],{i,i+1}});
            i++;
        }
        ll ans=1;
        ll t=K/2;
        while (t>0)
        {
            if(sz(positive_dual)>0 && sz(negative_dual)>0)
            {
                if((*positive_dual.begin()).fi>=(*negative_dual.begin()).fi)
                {
                    auto x=*positive_dual.begin();
                    ans=(ans*(x.fi%MOD))%MOD;
                    taken[x.se.fi]=true;
                    taken[x.se.se]=true;
                    last=x;
                    positive_dual.erase(positive_dual.begin());
                }
                else
                {
                    auto x=*negative_dual.begin();
                    ans=(ans*(x.fi%MOD))%MOD;
                    negative_dual.erase(negative_dual.begin());
                }
            }
            else if(sz(positive_dual)>0)
            {
                auto x=*positive_dual.begin();
                ans=(ans*(x.fi%MOD))%MOD;
                taken[x.se.fi]=true;
                taken[x.se.se]=true;
                last=x;
                positive_dual.erase(positive_dual.begin());
            }
            else if(sz(negative_dual)>0)
            {
                auto x=*negative_dual.begin();
                ans=(ans*(x.fi%MOD))%MOD;
                negative_dual.erase(negative_dual.begin());
            }
            t--;
        }
        if(K%2==1)
        {
            ll mn=-1;
            FORI(i,0,sz(taken))
            {
                if(!taken[i])
                {
                    mn=positive_guys[i];
                    break;
                }
            }
            if(mn==-1)
            {
                ans=(ans*modInverse(last.fi%MOD))%MOD;
                taken[last.se.fi]=false;
                taken[last.se.se]=false;
                if(sz(negative_dual)>0)
                {
                    auto x=*negative_dual.begin();
                    ans=(ans*(x.fi%MOD))%MOD;
                    negative_dual.erase(negative_dual.begin());
                }
            }
            FORI(i,0,sz(taken))
            {
                if(!taken[i])
                {
                    mn=positive_guys[i];
                    break;
                }
            }
            ans=(ans*mn)%MOD;
        }
        cout<<ans<<endl;
    }
    else
    {
        FORI(i,0,N)
        {
            A[i]=abs(A[i]);
        }
        sort(A,A+N);
        ll ans=1;
        FORI(i,0,K)
        {
            ans=(ans*A[i])%MOD;
        }
        ans=(MOD-ans)%MOD;
        cout<<ans<<endl;
    }
    

//-----------------------------------------------------------------------------------------------------------//


    clk = clock() - clk;
    cerr << fixed << setprecision(6) << "Time: " << ((double)clk)/CLOCKS_PER_SEC << endl;

    return 0;
}

Measured memory_bytes: 12692