#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
long long w[MAXN];
class LFS {
 public:
  LFS() {
    memset(head, -1, sizeof head);
    ecnt = 0;
    n = 0;
  }
  LFS(int N) {
    memset(head, -1, sizeof head);
    ecnt = 0;
    n = N;
  }
  void adde(int from, int to, int w) {
    e[ecnt].to = to;
    e[ecnt].w = w;
    e[ecnt].next = head[from];
    head[from] = ecnt++;
  }
  void addde(int a, int b, int w) {
    adde(a, b, w);
    adde(b, a, w);
  }
  long long solve() {
    memset(dp1, 0, sizeof dp1);
    memset(dp2, 0, sizeof dp2);
    memset(cc, 0, sizeof cc);
    ans = 0;
    dfs1(1, 0);
    dfs2(1, 0);
    return (ans + MOD) % MOD;
  }

 protected:
  struct Edge {
    int to, next, w;
  } e[MAXN * 2];
  int head[MAXN];
  int ecnt;
  int n;
  long long dp1[MAXN][2];
  long long dp2[MAXN][2];
  long long cc[MAXN];
  long long ans;

 private:
  void dfs1(int u, int fa) {
    cc[u] = 0;
    for (int i = head[u]; i != -1; i = e[i].next) {
      int v = e[i].to;
      if (v != fa) {
        dfs1(v, u);
        dp1[u][0] += dp1[v][1];
        dp1[u][1] += dp1[v][0];
        cc[u] += cc[v];
      }
    }
    for (int i = head[u]; i != -1; i = e[i].next) {
      int v = e[i].to;
      if (v != fa) {
        ans += (((cc[u] - cc[v]) * w[u]) % MOD) * (dp1[v][1] - dp1[v][0]) % MOD;
        ans %= MOD;
      }
    }
    ans += (long long)n * w[u] % MOD;
    ans %= MOD;
    ans += (((n - cc[u]) * w[u]) % MOD) * (dp1[u][0] - dp1[u][1]) % MOD;
    ans %= MOD;
    cc[u]++;
    dp1[u][0]++;
  }
  void dfs2(int u, int fa) {
    if (u != 1) {
      ans += (((dp2[u][0] - dp2[u][1]) * w[u]) % MOD) * cc[u] % MOD;
      ans %= MOD;
    }
    for (int i = head[u]; i != -1; i = e[i].next) {
      int v = e[i].to;
      if (v != fa) {
        dp2[v][0] = dp1[u][1] - dp1[v][0] + dp2[u][1];
        dp2[v][1] = dp1[u][0] - dp1[v][1] + dp2[u][0];
        dfs2(v, u);
      }
    }
  }
};
inline long long read() {
  long long X = 0, w = 0;
  char ch = 0;
  while (!isdigit(ch)) {
    w |= ch == '-';
    ch = getchar();
  }
  while (isdigit(ch)) {
    X = (X << 3) + (X << 1) + (ch ^ 48);
    ch = getchar();
  }
  return w ? -X : X;
}
int main() {
  int n = read();
  LFS* tree = new LFS(n);
  for (int i = 1; i <= n; i++) {
    w[i] = read();
  }
  for (int i = 1; i < n; i++) {
    int u = read();
    int v = read();
    tree->addde(u, v, 1);
  }
  cout << tree->solve() << endl;
  delete tree;
  return 0;
}
