//                              -    주의 만세!

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<tuple>

/*
0
15 6 6
1 7
2 7
13 1
14 2
12 14
3 14
12 8
3 11
8 4
5 4
10 7
6 10
3 9
15 14
2 9
3 2
2 5
8 2
2 15
1 14
4 3 5 2 15 14

*/

#define fi first
#define se second
#define mkp std::make_pair
using ll=long long;
using std::max;
using std::min;
template<class T> void cmax(T&a,T b){a=max(a,b);}
template<class T> void cmin(T&a,T b){a=min(a,b);}

const int NV=5e5;
const ll mod=1e9+7;
int p2[NV+5],ip2[NV+5];
ll ksm(ll a,ll p){
    ll ans=1;
    while(p){
        if(p&1) ans=ans*a%mod;
        a=a*a%mod;
        p>>=1;
    }return ans;
}

int N;

namespace seg{
    struct SEGN{
        ll s,tml;
    } tr[NV*4+5];
    void domul(int x,ll z){
        tr[x].s=tr[x].s*z%mod;
        tr[x].tml=tr[x].tml*z%mod;
    }void dn(int x){
        if(tr[x].tml!=1){
            domul(x*2,tr[x].tml);
            domul(x*2+1,tr[x].tml);
            tr[x].tml=1;
        }
    }void up(int x){
        tr[x].s=(tr[x*2].s+tr[x*2+1].s)%mod;
    }void mul(int x,int l,int r,int ql,int qr,ll z){
        if(ql<=l&&r<=qr) return domul(x,z);
        int mid=l+r>>1;
        dn(x);
        if(ql<=mid) mul(x*2,l,mid,ql,qr,z);
        if(mid<qr) mul(x*2+1,mid+1,r,ql,qr,z);
        up(x);
    }void upd(int x,int l,int r,int p,ll z){
        if(l==r){
            tr[x].s=z;
            return;
        }
        int mid=l+r>>1;
        dn(x);
        if(p<=mid) upd(x*2,l,mid,p,z);
        else upd(x*2+1,mid+1,r,p,z);
        up(x);
    }ll que(int x,int l,int r,int ql,int qr){
        ll ans=0;
        int mid=l+r>>1;
        if(ql<=l&&r<=qr) return tr[x].s;
        dn(x);
        if(ql<=mid) ans=que(x*2,l,mid,ql,qr);
        if(mid<qr) ans=(ans+que(x*2+1,mid+1,r,ql,qr))%mod;
        return ans;
    }void dfs(int x,int l,int r){
        printf("%d[%d,%d]%lld\n",x,l,r,tr[x].s);
        if(l!=r){
            dn(x);
            int mid=l+r>>1;
            dfs(x*2,l,mid);
            dfs(x*2+1,mid+1,r);
        }
    }
}

namespace gph{
    std::vector<int> G[NV+5],vec[NV+5];
    int pr[20][NV+5],dfc,dfn[NV+5],dfr[NV+5],dep[NV+5],in[NV+5],out[NV+5];
    void dfs(int x,int p){
        pr[0][x]=p;
        for(int i=1;i<20;++i) pr[i][x]=pr[i-1][pr[i-1][x]];
        dfn[x]=++dfc;
        for(int t:G[x]) if(t!=p){
            dep[t]=dep[x]+1;
            dfs(t,x);
        }
        dfr[x]=dfc;
    }void dfssum(int x,int p){
        for(int t:G[x]) if(t!=p){
            dfssum(t,x);
            in[x]+=in[t];
            out[x]+=out[t];
        }
    }int kanc(int x,int k){
        for(int i=19;~i;--i) if(k>>i&1) x=pr[i][x];
        return x;
    }int lca(int x,int y){
        if(dep[x]<dep[y]) std::swap(x,y);
        for(int i=19;~i;--i) if(dep[pr[i][x]]>=dep[y]) x=pr[i][x];
        if(x==y) return x;
        for(int i=19;~i;--i) if(pr[i][x]!=pr[i][y]){
            x=pr[i][x];
            y=pr[i][y];
        }
        return pr[0][x];
    }
    std::vector<std::pair<int,int> > pat[NV+5];
    ll ans;
    bool key[NV+5];
    void dfs2(int x,int p){
        for(int t:G[x]) if(t!=p) dfs2(t,x);
        for(int t:vec[x]){
            seg::mul(1,1,N,dfn[t],dfr[t],2);
            ++gph::in[gph::kanc(t,
                    gph::dep[t]-gph::dep[x]-1)];
        }
        //seg::dfs(1,1,N);
        ll f0=1,f1=0,f2=0,f3=0;
        for(int t:G[x]) if(t!=p){
            ll g0=f0*p2[in[t]]%mod,g1=f1*p2[in[t]]%mod;
            ll g2=f2*p2[in[t]]%mod,g3=f3*p2[in[t]]%mod;
            ll f=seg::que(1,1,N,dfn[t],dfr[t]);
            //printf("%lld %lld %lld %lld %lld\n",g0,g1,g2,g3,f);
            g1=(g1+f0*f)%mod;
            g2=(g2+f1*f)%mod;
            g3=(g3+(f2+f3)*f)%mod;
            f0=g0;
            f1=g1;
            f2=g2;
            f3=g3;
        }
        //printf("%d: %lld %lld %lld %lld\n",x,f0,f1,f2,f3);
        //for(int i=1;i<=N;++i) printf("%d %d\n",in[i],out[i]);
        for(int t:G[x]) if(t!=p){
            seg::mul(1,1,N,dfn[t],dfr[t],ip2[in[t]]);
        }
        if(G[x].size()>1){
            std::vector<std::tuple<int,int,int,int> > arr;
            for(int t:G[x]) if(t!=p) arr.emplace_back(dfn[t],0,0,1);
            for(auto p:pat[x]){
                int u=p.fi,v=p.se;
                if(dfn[u]>dfn[v]) std::swap(u,v);
                arr.emplace_back(dfn[u],dfn[v],dfr[v],2);
                arr.emplace_back(dfr[u]+1,dfn[v],dfr[v],mod+1>>1);
            }
            std::sort(arr.begin(),arr.end());

            auto find=[&](int v){
                int l=0,r=G[x].size();
                while(l+1<r){
                    int m=l+r>>1;
                    if(dfn[G[x][m]]>v) r=m;
                    else l=m;
                }
                return dfn[G[x][r]];
            };

            int lst=dfn[x]+1;
            for(auto eve:arr){
                int X,ql,qr,C;
                std::tie(X,ql,qr,C)=eve;
                if(lst<X){
                    ll c=seg::que(1,1,N,lst,X-1);
                    c=c*seg::que(1,1,N,find(lst),dfr[x])%mod;
                    ans=(ans+(ll)c*p2[out[x]+in[x]])%mod;
                    lst=X;
                }
                if(C!=1){
                    seg::mul(1,1,N,ql,qr,C);
                }
            }
        }
        seg::mul(1,1,N,dfn[x]+1,dfr[x],p2[in[x]]);

        int f=key[x]?(mod*2-f0-f1)%mod:(f2+f3)%mod;
        seg::upd(1,1,N,dfn[x],f);
        ans=(ans+(f+mod-f2)*p2[out[x]])%mod;
    }
}

namespace xm{
    std::pair<int,int> E[NV+5];
    int c[NV+5];
    void _(){
        int M,K;

        p2[0]=ip2[0]=1;
        for(int i=1;i<NV+5;++i){
            p2[i]=p2[i-1]*2%mod;
            ip2[i]=ip2[i-1]*(mod+1>>1)%mod;
        }

        scanf("%*d%d%d%d",&N,&M,&K);
        for(int i=1,u,v;i<N;++i){
            scanf("%d%d",&u,&v);
            gph::G[u].push_back(v);
            gph::G[v].push_back(u);
        }
        gph::dfs(1,0);
        for(int i=1;i<=M;++i){
            int u,v;
            scanf("%d%d",&u,&v);
            if(gph::dep[u]>gph::dep[v]) std::swap(u,v);
            E[i]={u,v};
            if(gph::dfn[u]<=gph::dfn[v]&&gph::dfn[v]<=gph::dfr[u]){
                int p=gph::kanc(v,gph::dep[v]-gph::dep[u]-1);
                ++gph::in[u];
                ++gph::out[u];
                ++c[gph::dfn[v]];
                --c[gph::dfr[v]+1];
                ++c[1];
                --c[gph::dfn[p]];
                ++c[gph::dfr[p]+1];
                gph::vec[u].push_back(v);
            }else{
                int p=gph::lca(u,v);
                if(gph::dfn[u]>gph::dfn[v]) std::swap(u,v);
                gph::pat[p].emplace_back(u,v);
                ++c[gph::dfn[u]];
                --c[gph::dfr[u]+1];
                ++c[gph::dfn[v]];
                --c[gph::dfr[v]+1];
            }
        }
        for(int i=1;i<=N;++i) c[i]+=c[i-1];
        gph::dfssum(1,0);
        //for(int i=1;i<=M;++i)
        //    if(gph::dfn[E[i].fi]<=gph::dfn[E[i].se]
        //            &&gph::dfn[E[i].se]<=gph::dfr[E[i].fi])
        //        ++gph::in[gph::kanc(E[i].se,
        //                gph::dep[E[i].se]-gph::dep[E[i].fi]-1)];
        for(int i=1;i<=N;++i) gph::out[i]=c[gph::dfn[i]]-gph::out[i];
        while(K--){
            int x;
            scanf("%d",&x);
            gph::key[x]=1;
        }
        //for(int i=1;i<=N;++i) printf("%d %d\n",gph::in[i],gph::out[i]);
        gph::dfs2(1,0);
        printf("%lld\n",(mod-gph::ans)%mod);
    }
}

int main(){
    xm::_();
    return 0;
}