#include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <cmath>
using namespace std;

const int N = 1e5, E = N << 1;
const int Lg = 17;
const int SZ = N * 2 * 2 * Lg;

int n, m;

int head[N + 5], to[E + 5], nxt[E + 5], edge = 1;
void add_edge(int u, int v)
{
	edge++;
	to[edge] = v;
	nxt[edge] = head[u];
	head[u] = edge;
	return ;
}
void add(int u, int v)
{
	add_edge(u, v);
	add_edge(v, u);
	return ;
}

int dfn[N + 5], rk[N + 5], tim;
int fa[N + 5], dep[N + 5];
int st[N + 5][Lg + 5];

void dfs(int u, int father, int depth)
{
	dfn[u] = ++tim, rk[tim] = u;
	fa[u] = father, dep[u] = depth;
	st[tim][0] = u;

	for (int i = head[u]; i; i = nxt[i])
	{
		int v = to[i];
		if (v == father)
			continue;
		dfs(v, u, depth + 1);
	}
	return ;
}
int Min(int x, int y)
{
	if (dep[x] < dep[y])
		return x;
	return y;
}
int query(int l, int r)
{
	int k = __lg(r - l + 1);
	return Min(st[l][k], st[r - (1 << k) + 1][k]);
}
int LCA(int u, int v)
{
	if (u == v)
		return u;
	u = dfn[u], v = dfn[v];
	if (u > v)
		swap(u, v);
	return fa[query(u + 1, v)];
}
int Dis(int u, int v)
{
	return dep[u] + dep[v] - 2 * dep[LCA(u, v)];
}
void build()
{
	for (int k = 1; (1 << k) <= n; k++)
		for (int i = 1; i + (1 << k) - 1 <= n; i++)
			st[i][k] = Min(st[i][k - 1], st[i + (1 << (k - 1))][k - 1]);
	return ;
}

typedef pair<int, int> pir;
vector<pir> vec[N + 5];
void push(int p, int s, int t, int val)
{
	vec[p].emplace_back(dfn[s], val);
	vec[p].emplace_back(dfn[t], val);
	return ;
}

struct Node
{
	int ls, rs;
	int left, right;//node
	int sum, cnt;
} node[SZ + 5];
int tot, root[N + 5];

#define ls(p) node[p].ls
#define rs(p) node[p].rs
#define left(p) node[p].left
#define right(p) node[p].right
#define sum(p) node[p].sum
#define cnt(p) node[p].cnt

void pushup(int p)
{
	sum(p) = sum(ls(p)) + sum(rs(p));
	if (right(ls(p)) && left(rs(p)))
		sum(p) += Dis(right(ls(p)), left(rs(p)));

	if (left(ls(p)))
		left(p) = left(ls(p));
	else
		left(p) = left(rs(p));

	if (right(rs(p)))
		right(p) = right(rs(p));
	else
		right(p) = right(ls(p));
	return ;
}
int merge(int x, int y, int l, int r)
{
	if (!x || !y)
		return x + y;
	if (l == r)
	{
		cnt(x) += cnt(y);//sum of leaf is always 0
		if (cnt(x))
			left(x) = right(x) = rk[l];
		else
			left(x) = right(x) = 0;
		return x;
	}

	int mid = (l + r) >> 1;
	ls(x) = merge(ls(x), ls(y), l, mid);
	rs(x) = merge(rs(x), rs(y), mid + 1, r);
	pushup(x);
	return x;
}
void modify(int p, int l, int r, int pos, int v)
{
	if (l == r)
	{
		cnt(p) += v;
		if (cnt(p))
			left(p) = right(p) = rk[l];
		else
			left(p) = right(p) = 0;
		return ;
	}

	int mid = (l + r) >> 1;
	if (pos <= mid)
	{
		if (!ls(p))
			ls(p) = ++tot;
		modify(ls(p), l, mid, pos, v);
	}
	else
	{
		if (!rs(p))
			rs(p) = ++tot;
		modify(rs(p), mid + 1, r, pos, v);
	}
	pushup(p);
	return ;
}
int query(int p)
{
	int res = sum(p);
	if (left(p) && right(p))
		res += Dis(left(p), right(p));
	return res;
}

long long ans;
void solve(int u)
{
	root[u] = ++tot;
	for (int i = head[u]; i; i = nxt[i])
	{
		int v = to[i];
		if (v == fa[u])
			continue;
		solve(v);
		root[u] = merge(root[u], root[v], 1, n);
	}

	for (auto info : vec[u])
		modify(root[u], 1, n, info.first, info.second);
	ans += query(root[u]) / 2;//each edge is counted twice
	return ;
}

int main()
{
	// freopen("language.in", "r", stdin);
	// freopen("language.out", "w", stdout);

	scanf("%d%d", &n, &m);
	for (int i = 1, u, v; i < n; i++)
	{
		scanf("%d%d", &u, &v);
		add(u, v);
	}

	dfs(1, 0, 1);
	build();

	for (int i = 1, s, t; i <= m; i++)
	{
		scanf("%d%d", &s, &t);
		int lca = LCA(s, t);
		push(s, s, t, 1);
		push(t, s, t, 1);
		push(lca, s, t, -1);
		if (fa[lca])
			push(fa[lca], s, t, -1);
	}

	solve(1);
	ans >>= 1;//(u, v) & (v, u)
	printf("%lld\n", ans);
	return 0;
}