#include <cstdio>
#include <algorithm>
#define K 12
#define N 500005
using std::min;
using std::max;
const int MOD = 1000000007, INF = 0x3f3f3f3f;
int n, k, w[K], c[N], d[N], dt[K], mn[K], mx[K], cmn[K], cmx[K], cs[K], pw[K], ans;
int tr[K][K], sum[K], tmp[K];
inline int mval(int x) {
    return x >= MOD ? x - MOD : x;
}
inline void inc(int &x, int a) {
    x = mval(x + a);
}
inline int qpow(int x, int p) {
    int ret = 1;

    while (p) {
        if (p & 1)
            ret = 1ll * ret * x % MOD;

        p >>= 1, x = 1ll * x * x % MOD;
    }

    return ret;
}
inline void lag(int *f, int *g, int n) {
    for (int i = 0; i <= n; ++i) {
        std::fill(tmp, tmp + n + 1, 0);
        tmp[0] = 1;
        int cur = 1;

        for (int j = 0; j <= n; ++j)
            if (i != j) {
                cur = 1ll * (MOD + i - j) * cur % MOD;

                for (int k = n; k; --k)
                    tmp[k] = mval(MOD + tmp[k - 1] - 1ll * j * tmp[k] % MOD);

                tmp[0] = mval(MOD - 1ll * tmp[0] * j % MOD);
            }

        cur = qpow(cur, MOD - 2);

        for (int j = 0; j <= n; ++j)
            inc(g[j], 1ll * f[i]*cur % MOD * tmp[j] % MOD);
    }
}
inline void proc(int n) {
    for (int i = 0; i <= n; ++i) {
        for (int j = 1; j <= i + 1; ++j)
            sum[j] = qpow(j, i);

        for (int j = 1; j <= i + 1; ++j)
            inc(sum[j], sum[j - 1]);

        lag(sum, tr[i], i + 1);
    }
}
inline void mul(int a, int b) {
    for (int i = k; i; --i)
        tmp[i] = mval(1ll * a * tmp[i - 1] % MOD + 1ll * b * tmp[i] % MOD);

    tmp[0] = 1ll * tmp[0] * b % MOD;
}
int main() { 
    scanf("%d%d", &n, &k);
    proc(10);
    pw[0] = 1;

    for (int i = 1; i <= k; ++i)
        scanf("%d", w + i);

    for (int i = 1; i <= n; ++i) {
        scanf("%d%d", c + i, d + i);
        int x = c[i];
        dt[x] += d[i], mn[x] = std::min(mn[x], dt[x]), mx[x] = std::max(mx[x], dt[x]);
    }

    for (int i = 1; i <= n; ++i)
        if (dt[c[i]] < 0)
            d[i] = -d[i];

    for (int i = 1; i <= k; ++i)
        if (dt[i] < 0)
            dt[i] = -dt[i], std::swap(mn[i], mx[i]), mn[i] = -mn[i], mx[i] = -mx[i];

    bool ok = 1;

    for (int i = 1; i <= k; ++i)
        if (dt[i] || w[i] <= mx[i] - mn[i]) {
            ok = 0;
            break;
        }

    if (ok)
        return puts("-1"), 0;

    for (int i = 1; i <= n; ++i) {
        int x = c[i];
        cs[x] += d[i];

        if (cmn[x] <= cs[x] && cs[x] <= cmx[x])
            continue;

        cmn[x] = min(cmn[x], cs[x]);
        cmx[x] = max(cmx[x], cs[x]);

        if (cmx[x] - cmn[x] > w[x])
            break;

        if (dt[x] != 0 && d[i] > 0 && cs[x] + dt[x] > mx[x]) {
            int lim = (w[x] - max(mx[x] - dt[x], cmx[x]) + mn[x]) / dt[x];
            std::fill(tmp, tmp + k + 2, 0);
            tmp[0] = i, tmp[1] = n;

            for (int t = 1; t <= k; ++t)
                if (t != x) {
                    if (dt[t])
                        lim = min(lim, (w[t] - max(mx[t] - dt[t], cmx[t]) + mn[t] - 1) / dt[t]);

                    mul(mval(MOD - dt[t]), w[t] - max(mx[t] - dt[t], cmx[t]) + mn[t]);
                }

            for (int j = 1; j <= k + 1; ++j)
                pw[j] = 1ll * pw[j - 1] * lim % MOD;

            for (int a = 0; a <= k; ++a)
                for (int b = 0; b <= a + 1; ++b)
                    inc(ans, 1ll * tmp[a]*tr[a][b] % MOD * pw[b] % MOD);
        }

        int cur = 1;

        for (int t = 1; t <= k; ++t)
            if (t != x)
                cur = 1ll * cur * (w[t] - cmx[t] + cmn[t]) % MOD;

        inc(ans, 1ll * i * cur % MOD);
    }

    printf("%d\n", ans);
    return 0;
}