In the Isle of Guernsey there are n different types of coins. For each i (1 ≤ i ≤ n), coin of type i is worth ai cents. It is possible that ai = aj for some i and j (i ≠ j). 

Bessie has some set of these coins totaling t cents. She tells Jessie q pairs of integers. For each i (1 ≤ i ≤ q), the pair bi, ci tells Jessie that Bessie has a strictly greater number of coins of type bi than coins of type ci. It is known that all bi are distinct and all ci are distinct. 

Help Jessie find the number of possible combinations of coins Bessie could have. Two combinations are considered different if there is some i (1 ≤ i ≤ n), such that the number of coins Bessie has of type i is different in the two combinations. Since the answer can be very large, output it modulo 1000000007 (109 + 7). 

If there are no possible combinations of coins totaling t cents that satisfy Bessie's conditions, output 0.

Input

The first line contains three space-separated integers, n, q and t (1 ≤ n ≤ 300; 0 ≤ q ≤ n; 1 ≤ t ≤ 105). The second line contains n space separated integers, a1, a2, ..., an (1 ≤ ai ≤ 105). The next q lines each contain two distinct space-separated integers, bi and ci (1 ≤ bi, ci ≤ n; bi ≠ ci).

It's guaranteed that all bi are distinct and all ci are distinct.

Output

A single integer, the number of valid coin combinations that Bessie could have, modulo 1000000007 (109 + 7).

Examples

Input

4 2 17
3 1 2 5
4 2
3 4


Output

3


Input

3 2 6
3 1 1
1 2
2 3


Output

0


Input

3 2 10
1 2 3
1 2
2 1


Output

0

Note

For the first sample, the following 3 combinations give a total of 17 cents and satisfy the given conditions: {0 of type 1, 1 of type 2, 3 of type 3, 2 of type 4}, {0, 0, 6, 1}, {2, 0, 3, 1}.

No other combinations exist. Note that even though 4 occurs in both bi and ci,  the problem conditions are still satisfied because all bi are distinct and all ci are distinct.
#include <bits/stdc++.h>
using namespace std;
int arr[310], nex[310], T, N;
bool can, isRoot[310];
void dfs(int x, int val) {
  if (T < 0) return;
  arr[x] += val;
  if (nex[x] != -1) {
    T -= arr[x];
    dfs(nex[x], arr[x]);
  }
}
long long int memo[310][100000 + 100];
long long int solve(int pos, int val) {
  if (pos == 0) return val == 0;
  if (val <= 0) return val == 0;
  if (memo[pos][val] != -1) return memo[pos][val];
  long long int ret = solve(pos - 1, val);
  if (val - arr[pos] >= 0)
    ret = (ret + solve(pos, val - arr[pos])) % 1000000007;
  return memo[pos][val] = ret;
}
long long int t[100000 + 100];
int main() {
  int Q, x, y;
  while (cin >> N >> Q >> T) {
    for (int i = 1; i <= N; i++) scanf("%d", &arr[i]);
    memset(nex, -1, sizeof nex);
    memset(isRoot, true, sizeof isRoot);
    for (int i = 0; i < Q; i++) {
      scanf("%d %d", &x, &y);
      nex[x] = y;
      isRoot[y] = false;
    }
    bool in = false;
    for (int i = 1; i <= N; i++)
      if (isRoot[i] && nex[i] != -1) {
        in = true;
        dfs(i, 0);
      }
    if ((Q > 0 && in == false) || T < 0) {
      cout << 0 << endl;
      return 0;
    }
    memset(memo, -1, sizeof memo);
    t[0] = 1;
    for (int i = 1; i <= N; i++)
      for (int j = 0; j <= T; j++) {
        if (j - arr[i] >= 0) t[j] = (t[j] + t[j - arr[i]]) % 1000000007;
      }
    cout << t[T] << endl;
  }
  return 0;
}
