#define maxn 100005

struct node

{

    int v,next;

};

node e[maxn *  ];

int cnt ;

int head[maxn *  ];

int num ;

int E[maxn *  + ],L[maxn *  + ],R[maxn *  +  ];

int f[maxn *  +  ][];

int dp[maxn];

void init()

{

    cnt =  ;

    memset(head,-,sizeof(head));

}

void add(int u ,int v)

{

    e[cnt].v = v ;

    e[cnt].next = head[u];

    head[u] = cnt ++ ;

    e[cnt].v = u;

    e[cnt].next = head[v] ;

    head[v] = cnt ++ ;

    return ;

}

void dfs(int u ,int fa,int dep)

{

    E[++num] = u , L[num] = dep , R[u] = num;

    for(int i = head[u] ;i != -; i = e[i].next)

    if(e[i].v != fa)

    {

        int v = e[i].v;

        dfs(v, u, dep +  );

        E[++num] = u , L[num] = dep;

    }

    return;

}

void initRMQ()

{

    for(int i =  ; i <= num ;i ++ ) f[i][] = i;

    for(int j =  ; (<<j) <= num ; j++ )

        for(int i = ; i + (<<j) - <= num; i ++ )

            if(L[f[i][j-]] < L[f[i+(<<(j-))][j-]])      //ps:注意下标

                f[i][j] = f[i][j-];

            else f[i][j] = f[i+(<<(j-))][j-];

}

int lca(int a ,int b)

{

    a = R[a] , b = R[b];

    if(a>b) swap(a,b);

    int k = (log(1.0 + b - a )/log(2.0));

    if(L[f[a][k]] < L[f[b-(<<k)+][k]] )

        return E[f[a][k]];

    else return E[f[b-(<<k)+][k]];

}

void dfs(int u,int fa)

{

    for(int i = head[u] ; i != - ; i =e[i].next)

    if(e[i].v != fa)

    {

        int v = e[i].v;

        dfs(v,u);

        dp[u] += dp[v];

    }

    return ;

}

int main()

{

    int n,m;

    int u,v;

    while(scanf("%d%d",&n,&m)!=EOF)

    {

        init();

        for(int i =  ; i < n - ; i ++ )

        {

            scanf("%d%d",&u,&v);

            add(u,v);

        }

        num =  ;

        memset(R,,sizeof(R));

        dfs(,,);

        initRMQ();

        memset(dp,,sizeof(dp));

        for(int i = ; i < m ; i ++ )

        {

            scanf("%d%d",&u,&v);

            dp[u] ++ ;

            dp[v] ++ ;

            dp[lca(u,v)] -= ;

        }

        dfs(,);

        int sum ;

        sum =  ;

        for(int i =  ;i <= n ; i++ ) //   ps:1为根不要选。

        {

            if(dp[i] == )

                sum ++;

            else if(dp[i] ==  )

                sum += m;

        }

        printf("%d\n",sum);

    }

    return ;

}

/*

好题：

离线LCA + 树形DP

分析：加进来一条边(a,b)，会形成一条环 a - lca(a,b) - b

如果去掉(a,b)和没有被其他环覆盖的边，那么就能把树分成两部分。

只要记录dp[u]表示u的负边被环覆盖了几次

对于新加进来的一条边(a,b) dp[a] ++ , dp[b] ++  , dp[lca(a,b)] -= 2;///

这样处理为完所有新加进来的边之后，在dfs一边，跑完状态转移：dp[u] += dp[v];

这里就可以把每条环上的边都依次加1，并且因为lca(a,b)的父边不再环上，且已经提前减去了2

这样转移正好可以把减掉的2消去。

注意：这里把lca离线处理成rmq，只需要O(n)的遍历和O(nlogn)的预处理即可。  ST表

并且这里以1为根，后面的状态转移也要以1为根，否则lca就白算了。

*/