#include <bits/stdc++.h>

using namespace std;

using ll = long long;
#define int long long


const int maxN = 100005;

int pt;

struct node_t {
    node_t();
    void update();
    int dir() {
        return this == (p->ch[1]);
    }
    void setc(node_t *c, int d) {
        ch[d] = c;
        c->p = this;
    }
    node_t *p, *ch[2];
    int size;
    int sum_depth;
} s[maxN], *nil = s, *root;

node_t::node_t() {
    p = ch[0] = ch[1] = nil;
}

void node_t::update() {
    if (this == nil) return;
    size = ch[0]->size + ch[1]->size + 1;
    sum_depth = ch[0]->sum_depth + ch[0]->size + ch[1]->sum_depth + ch[1]->size;
}

node_t *newNode() {
    ++pt;
    s[pt].size = 1;
    s[pt].sum_depth = 0;
    s[pt].p = s[pt].ch[0] = s[pt].ch[1] = nil;
    s[pt].update();
    return s + pt;
}

void rotate(node_t *t) {
    node_t *p = t->p;
    p->p->update();
    p->update();
    t->update();
    int d = t->dir();
    p->p->setc(t, p->dir());
    p->setc(t->ch[!d], d);
    t->setc(p, !d);
    if (p == root) {
        root = t;
    }
    p->update();
    t->update();
}
node_t *splay(node_t *t, node_t *dst = nil) {
    while(t->p != dst) {
        if (t->p->p == dst) {
            rotate(t);
        } else if (t->dir() == t->p->dir()) {
            rotate(t->p);
            rotate(t);
        } else {
            rotate(t);
            rotate(t);
        }
    }
    t->update();
    return t;
}

node_t *prev(node_t *p) {
    splay(p);
    p = p->ch[0];
    p->update();
    while(p->ch[1] != nil) {
        p = p->ch[1];
        p->update();
    }
    return p;
}
node_t *succ(node_t *p) {
    splay(p);
    p = p->ch[1];
    p->update();
    while(p->ch[0] != nil) {
        p = p->ch[0];
        p->update();
    }
    return p;
}
void insert(node_t *y, node_t *x) {
    splay(y);
    if (y->ch[1] == nil) {
        y->ch[1] = x;
        x->p = y;
        y->update();
    } else {
        y = y->ch[1];
        y->update();
        while(y->ch[0] != nil) {
            y = y->ch[0];
            y->update();
        }
        y->ch[0] = x;
        x->p = y;
        y->update();
    }
    splay(x);
}

void init() {
    pt = 0;
    nil->p = nil->ch[0] = nil->ch[1] = nil;
}

vector<int> G[maxN];

const int MOD = 1e9+7;

void solve(){
    int n;
    cin >> n;
    vector<int> b(n);
    for (int i = 0; i < n; ++i) {
        cin >> b[i];
    }
    for (int i = 0; i < n - 1; ++i) {
        int u, v;
        cin >> u >> v;
        --u;
        --v;
        G[u].push_back(v);
        G[v].push_back(u);
    }
    vector<int> p(n);
    iota(p.begin(), p.end(), 0);
    sort(p.begin(), p.end(), [&](int i, int j) {
        return b[i] < b[j];
    });
    init();
    vector<node_t *> nodes;
    for (int i = 0; i < n; ++i) {
        nodes.push_back(newNode());
    }
    int res=0;
    for (auto i : p) {
        int cur = b[i];
        vector<pair<int,int>>a;
        // if(cur==5)continue;
        for (auto to : G[i]) {
            if (b[to] > b[i]) {
                continue;
            }
            splay(nodes[to]);
            a.push_back({nodes[to]->size, nodes[to]->sum_depth});
            // cout<<"@@ "<<to<<" "<<a.back().first<<" "<<a.back().second<<endl;
            insert(nodes[to], nodes[i]);
        }
        for (auto to : G[i]) {
            if (b[to] > b[i]) {
                continue;
            }
        }
        // cout << "!@ " << i << " " << b[i] << endl;
        for(auto&[sz, sm]:a){
            // cout << "!!! " << sz << " " << sm << " " << nodes[i]->size << endl;
            res += b[i] * (sm+sz) % MOD *(nodes[i]->size-sz) % MOD;
            res %= MOD;
        }
    }
    cout << res << endl;
}

int32_t main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    int t=1;
    // cin>>t;
    for(int _=1;_<=t;_++){
        solve();
    }
}