#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdint>

void beolvas(std::istream &be, std::vector<int64_t> &v, int &k, int &b) {
    int n;
    be >> n >> k >> b;

    v.resize(n);
    for (auto &x : v) {
        be >> x;
    }
}

void feldolgoz(std::vector<int64_t> &v, int k, int negativ) {
    using std::cout;
    
    static const int64_t M = 1000000007;
    const auto n = static_cast<int>(v.size());

    sort(v.begin(), v.end());

    // Megkeressuk az elso nemnegativ szam poziciojat
    auto p = static_cast<int>(lower_bound(v.begin(), v.end(), 0) - v.begin());

    // Ha a feltetel tobb negativ szamot kovetel meg, mint ahany
    // eredetileg a sorozatban talalhato, akkor nincs megoldas.
    if (p < negativ) {
        cout << "-1\n";
        return;
    }

    // A 0-hoz legkozelebb eso negativ szamtol kezdve megprobalunk annyit
    // 0-ig novelni, hogy hogy pontosan az eloirt darabszamu maradjon.
    for (; p > negativ && k >= 0; p--) {
        // Levonjuk 'k'-bol az aktualis negativ szam 0-ig novelesenek koltseget.
        k += static_cast<int>(v[p - 1]);
        v[p - 1] = 0;
    }

    // Ha nincs elegendo valasztasunk ahhoz, hogy "eltuntessuk" a megfelelo darabszamu
    // negativ szamot, akkor nincs megoldas.
    if (k < 0) {
        cout << "-1\n";
    }

    // Kiszamitjuk az elso nemnegativ szamtol kezdodoen egeszen a sorozat vegeig
    // az egyes elemek osszeget:
    // ps[i] = az elso 'i' db. elem osszege az elso nemnegativ szamtol kezdodoen
    std::vector<int64_t> ps(n - p + 1);
    for (int i = p; i < n; i++) {
        ps[i - p + 1] = ps[i - p] + v[i] - v[p];
    }

    // Binaris kereses segitsegevel megkeressuk az elso olyan elem poziciojat,
    // amennyire mar eppen nem potolhatok ki a sorozat elemei az elso nemnegativ
    // elemtol kezdodoen. Pl.:
    // 
    // Legyen v = { -2, -1, 1, 3, 4 }, k = 3
    // 
    // Az elso nemnegativ elem pozicioja (p = 2). 2 db. valasztassal a sorozat
    // kipotolhato egeszen a 3. pozicioig: v = { -2, -1, 1 + 2, 3, 4 },
    // azonban ahhoz, hogy a 4. pozicioig kipotoljuk a sorozatot 4 valasztasra
    // lenne szukseg: v = { -2, -1, 1 + 3, 3 + 1, 4 }, azaz a 4. az elso olyan
    // pozicio, ameddig mar eppen nem potolhato ki 'k' db. valasztasbol.
    int b = p, e = n;
    while (b < e) {
        const auto m = b + (e - b) / 2;
        // A 'p'-edik elemtol az 'm'-edik elemig 'v[m]'-re valo kipotlasanak
        // koltsege.
        const auto x = (v[m] - v[p]) * (m - p + 1) - ps[m - p + 1];

        if (k < x) {
            e = m;
        } else {
            b = m + 1;
        }
    }

    // Levonunk 'k'-bol annyit, amennyi elegendo az elemek kipotoloasahoz
    // a 'p'-ediktol, az 'e-1'-edikig 'v[e-1]'-re. 
    k -= static_cast<int>((v[e - 1] - v[p]) * (e - p) - ps[e - p]);

    // Az e = n esetben, azaz amikor a sorozat kipotolhato egeszen az utolso
    // 'n-1'-edik elemig, elofordulhat, hogy 'k' elegendoen nagy ahhoz, hogy
    // akar 1-nel tobbel is novelhetjuk meg az utolso elemet is. Az 'x' erteke
    // egyenlo lesz azzal az ertekkel, amelyre vegul kipotoljuk a sorozatot
    // 'p'-tol 'e-1'-ig.
    const auto x = v[e - 1] + k / (e - p);

    // Elkezdjuk kiszamitani a modositott vektor elemeinek a szorzatat, ugyelve
    // arra, hogy ne tortenjen tulcsordulas a szorzassoran.
    int64_t s = 1;

    // Osszeszorozzuk a megmaradt negativ elemeket.
    int i;
    for (i = 0; i < p; i++) {
        s = (s * -v[i]) % M;
    }

    // Osszesen 'k % (e - p)' db. olyan elem lesz, amely meg tovabb novelheto
    // eggyel, azaz amelyeknek az erteke igy 'x+1' lesz.
    for (auto j = k % (e - p); j > 0; j--) {
        s = s * (x + 1) % M;
        i++;
    }

    // A maradek elemek erteke 'x' lesz egeszen 'e-1'-ig. 
    for (; i < e; i++) {
        s = s * x % M;
    }

    // A vektor vegen pedig azok az elemek maradnak, amelyeket mar nem lehet
    // kipotolni, mert tolsagosan nagyok.
    for (; i < n; i++) {
        s = s * v[i] % M;
    }

    cout << s << '\n';
}

int main() {
    std::vector<int64_t> v;
    int k, b;
    beolvas(std::cin, v, k, b);

    feldolgoz(v, k, b);

    return 0;
}