#include <bits/stdc++.h>

constexpr int N = 100005;
int n, m;
std::vector<int> t[N];
int dep[N], dfn[N], rnk[N], fa[N], tot;

void dfs(int u) {
    dfn[u] = ++tot;
    rnk[tot] = u;
    for (const auto &v : t[u]) {
        if (v == fa[u])
            continue;
        fa[v] = u;
        dep[v] = dep[u] + 1;
        dfs(v);
    }
}

inline int maxv(int a, int b) {
    if (!a || !b) 
        return a | b;
    return dep[a] < dep[b] ? a : b;
}

int st[23][N];

inline void init() {
    for (int i = 1; i <= n; i++)
        st[0][i] = rnk[i];
    for (int k = 1; k <= 19; k++) 
        for (int j = 1; j + (1 << k) - 1 <= n; j++)
            st[k][j] = maxv(st[k - 1][j], st[k - 1][j + (1 << (k - 1))]);
}

inline int lca(int u, int v) {
    if (!u || !v)
        return u | v;
    if (u == v)
        return u;
    int l = std::min(dfn[u], dfn[v]) + 1, r = std::max(dfn[u], dfn[v]), k = std::__lg(r - l + 1);
    return fa[maxv(st[k][l], st[k][r - (1 << k) + 1])];
}

struct node {
    int ls, rs, lv, rv, lc, sz, cc;
}tree[N << 7];

#define ls(p)  tree[p].ls
#define rs(p)  tree[p].rs
#define lv(p)  tree[p].lv
#define rv(p)  tree[p].rv
#define lc(p)  tree[p].lc
#define sz(p)  tree[p].sz
#define cc(p)  tree[p].cc

int cnt;

inline void pushup(int p) {
    if (!ls(p) || !rs(p) || !lc(ls(p)) || !lc(rs(p))) {
        int son = (lc(ls(p)) ? ls(p) : rs(p));
        sz(p) = sz(son);
        lv(p) = lv(son);
        rv(p) = rv(son);
        lc(p) = lc(son);
        return;
    }
    sz(p) = sz(ls(p)) + sz(rs(p)) + dep[lc(ls(p))] + dep[lc(rs(p))] - dep[lca(rv(ls(p)), lv(rs(p)))] - dep[lca(lc(ls(p)), lc(rs(p)))] - 1;
    lv(p) = lv(ls(p)) ? lv(ls(p)) : lv(rs(p));
    rv(p) = rv(rs(p)) ? rv(rs(p)) : rv(ls(p));
    lc(p) = lca(lc(ls(p)), lc(rs(p)));
    // std::cout << "pushup:" << p << ' ' << sz(p) << ' ' << sz(ls(p)) << ' ' << sz(rs(p)) << ' ' << lc(ls(p)) << ' ' << lc(rs(p)) << '\n';
}

void mdf(int p, int l, int r, int x, int v) {
    if (l == r) {
        cc(p) += v;
        if (cc(p)) 
            lv(p) = rv(p) = lc(p) = rnk[x], sz(p) = 1;
        else 
            lv(p) = rv(p) = lc(p) = sz(p) = 0;
        return;
    }    
    int mid = (l + r) >> 1;
    if (x <= mid) {
        if (!ls(p))
            ls(p) = ++cnt;
        mdf(ls(p), l, mid, x, v);
    } else {
        if (!rs(p))
            rs(p) = ++cnt;
        mdf(rs(p), mid + 1, r, x, v);
    }
    pushup(p);
}

int merge(int r1, int r2, int l, int r) {
    if (!r1 || !r2) 
        return r1 | r2;
    if (l == r) {
        cc(r1) += cc(r2);
        if (cc(r1)) 
            lv(r1) = rv(r1) = lc(r1) = rnk[l], sz(r1) = 1;
        else 
            lv(r1) = rv(r1) = lc(r1) = sz(r1) = 0;
        return r1;
    }
    int mid = (l + r) >> 1;
    ls(r1) = merge(ls(r1), ls(r2), l, mid);
    rs(r1) = merge(rs(r1), rs(r2), mid + 1, r);
    pushup(r1);
    return r1;
}

std::vector<std::pair<int, int> > op[N];

int rt[N];
long long ans = 0;
void solve(int u) {
    rt[u] = ++cnt;
    for (const int &v : t[u]) {
        if (v == fa[u])
            continue;
        solve(v);
        rt[u] = merge(rt[u], rt[v], 1, n);
    }
    for (const auto &[x, v] : op[u]) 
        mdf(rt[u], 1, n, x, v);
    ans += sz(rt[u]);
    // std::cout << u << ' ' << sz(rt[u]) << '\n';
    // if (u == 1) {
    //     std::cout << lc(ls(rt[u])) << ' ' << lc(rs(rt[u])) << '\n';
    //     std::cout << sz(ls(rt[u])) << ' ' << sz(rs(rt[u])) << '\n';
    //     // exit(0);
    // }
}

int main() {
    std::cin >> n >> m;
    for (int i = 1, u, v; i <= n - 1; i++) {
        std::cin >> u >> v;
        t[u].push_back(v);
        t[v].push_back(u);
    }
    dfs(1);
    init();
    while (m--) {
        int x, y;
        std::cin >> x >> y;
        int l = lca(x, y);
        // std::cout << x << ' ' << y << ' ' << l << '\n';
        op[x].emplace_back(dfn[x], 1);
        op[y].emplace_back(dfn[x], 1);
        op[l].emplace_back(dfn[x], -1);
        op[fa[l]].emplace_back(dfn[x], -1);

        op[x].emplace_back(dfn[y], 1);
        op[y].emplace_back(dfn[y], 1);
        op[l].emplace_back(dfn[y], -1);
        op[fa[l]].emplace_back(dfn[y], -1);
    }
    solve(1);
    std::cout << (ans - n) / 2 << '\n';
}