// #pragma GCC optimize ("Ofast")
// #pragma GCC optimize ("unroll-loops")
// #pragma GCC target ("avx,avx2,fma")
#include <bits/stdc++.h>

#define rep(i, a, b) for(int i = (a); i <= (b); i ++)
using std::cin, std::cout, std::cerr;
using ll = long long;

const ll P = 1e9 + 7;
ll Pow(ll a, ll b) {
    ll r = 1;
    for(; b; b /= 2) {
        if(b & 1)
            r = r * a % P;
        a = a * a % P;
    }
    return r;
}
ll Inv(ll x) { return Pow(x, P - 2); }
struct Comb {
    std::vector<ll> inv, fac, ifac;
    Comb(int n) { Init(n); }
    void Init(int n) {
        inv.assign(n + 1, 0);
        fac.assign(n + 1, 0);
        ifac.assign(n + 1, 0);
        fac[0] = ifac[0] = 1;
        for(int i = 1; i <= n; i ++) {
            inv[i] = i == 1 ? 1 : (P - P / i) * inv[P % i] % P;
            fac[i] = fac[i - 1] * i % P;
            ifac[i] = ifac[i - 1] * inv[i] % P;
        }
    }

    ll Binom(int n, int m) {
        if(m < 0 || n < m) return 0;
        return fac[n] * ifac[m] % P * ifac[n - m] % P;
    }

    ll StirlingPartition(int n, int m) {
        ll ret = 0;
        for(int k = m; k >= 0; k --) {
            int sgn = (m - k) % 2 == 0 ? 1 : P - 1;
            ret += sgn * Binom(m, k) % P * Pow(k, n);
            ret %= P;
        }
        return ret;
    }
}comb(1e3 + 1);

int main() {
    std::ios::sync_with_stdio(false);
    int n, m; cin >> n >> m;
    std::vector<std::vector<int>> e(n + 1);
    std::vector<int> w(n + 1);
    rep(i, 1, n) cin >> w[i];
    rep(i, 1, m) {
        int u, v; cin >> u >> v;
        e[u].push_back(v);
    }

    ll ans = 0;
    rep(s, 1, n) {
        std::vector<int> d(n + 1, 0);
        d[s] = w[s];
        std::set<std::pair<int, int>> set;
        rep(i, 1, n)
            set.insert({d[i], i});
        while(!set.empty()) {
            int x = prev(set.end())->second;
            set.erase(prev(set.end()));
            for(int i : e[x]) if(std::min(d[x], w[i]) > d[i]) {
                set.erase({d[i], i});
                d[i] = std::min(d[x], w[i]);
                set.insert({d[i], i});
            }
        }

        rep(t, 1, n) if(d[t] >= w[t]) {
            // cout << s << ' ' << t << ' ' << w[s] << ' ' << w[t] << '\n';
            ans += comb.StirlingPartition(w[s], w[t]);
            ans %= P;
        }
    }
    cout << ans << '\n';
}