The Little Elephant loves trees very much, he especially loves root trees.

He's got a tree consisting of n nodes (the nodes are numbered from 1 to n), with root at node number 1. Each node of the tree contains some list of numbers which initially is empty. 

The Little Elephant wants to apply m operations. On the i-th operation (1 ≤ i ≤ m) he first adds number i to lists of all nodes of a subtree with the root in node number ai, and then he adds number i to lists of all nodes of the subtree with root in node bi.

After applying all operations the Little Elephant wants to count for each node i number ci — the number of integers j (1 ≤ j ≤ n; j ≠ i), such that the lists of the i-th and the j-th nodes contain at least one common number.

Help the Little Elephant, count numbers ci for him.

Input

The first line contains two integers n and m (1 ≤ n, m ≤ 105) — the number of the tree nodes and the number of operations. 

Each of the following n - 1 lines contains two space-separated integers, ui and vi (1 ≤ ui, vi ≤ n, ui ≠ vi), that mean that there is an edge between nodes number ui and vi. 

Each of the following m lines contains two space-separated integers, ai and bi (1 ≤ ai, bi ≤ n, ai ≠ bi), that stand for the indexes of the nodes in the i-th operation.

It is guaranteed that the given graph is an undirected tree.

Output

In a single line print n space-separated integers — c1, c2, ..., cn.

Examples

Input

5 1
1 2
1 3
3 5
3 4
2 3


Output

0 3 3 3 3 

Input

11 3
1 2
2 3
2 4
1 5
5 6
5 7
5 8
6 9
8 10
8 11
2 9
3 6
2 8


Output

0 6 7 6 0 2 0 5 4 5 5 
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
long long add(long long a, long long b) {
  long long x = a + b;
  if (x >= 998244353) x -= 998244353;
  return x;
}
long long mul(long long a, long long b) { return (a * b) % 998244353; }
int n, m;
vector<int> qu[100002], v[100002];
pair<int, int> p[100002];
int ans[100002];
int st[100002], dr[100002], pz, sz[100002];
set<int> s;
int nnd[100002];
void dfs(int dad, int nod) {
  ++pz;
  st[nod] = pz;
  nnd[st[nod]] = nod;
  sz[nod] = 1;
  for (int i = 0; i < v[nod].size(); ++i) {
    int vecin = v[nod][i];
    if (vecin == dad) continue;
    dfs(nod, vecin);
    sz[nod] += sz[vecin];
  }
  dr[nod] = pz;
}
int aint[400002], aint2[800002];
void upd(int nod, int st, int dr, int L, int R, int val) {
  if (L <= st && dr <= R)
    aint[nod] += val;
  else {
    int mid = (st + dr) / 2;
    if (L <= mid) upd(nod << 1, st, mid, L, R, val);
    if (mid < R) upd(nod << 1 | 1, mid + 1, dr, L, R, val);
  }
  if (aint[nod])
    aint2[nod] = dr - st + 1;
  else
    aint2[nod] = aint2[nod << 1] + aint2[nod << 1 | 1];
}
void dfs2(int dad, int nod) {
  if (!qu[nod].empty()) upd(1, 1, n, st[nod], dr[nod], 1);
  for (int i = 0; i < qu[nod].size(); ++i)
    upd(1, 1, n, st[qu[nod][i]], dr[qu[nod][i]], 1);
  ans[nod] = max(0, aint2[1] - 1);
  for (int i = 0; i < v[nod].size(); ++i) {
    int vecin = v[nod][i];
    if (vecin == dad) continue;
    dfs2(nod, vecin);
  }
  for (int i = 0; i < qu[nod].size(); ++i)
    upd(1, 1, n, st[qu[nod][i]], dr[qu[nod][i]], -1);
  if (!qu[nod].empty()) upd(1, 1, n, st[nod], dr[nod], -1);
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cin >> n >> m;
  for (int i = 1; i < n; ++i) {
    int a, b;
    cin >> a >> b;
    v[a].push_back(b);
    v[b].push_back(a);
  }
  dfs(0, 1);
  for (int i = 1; i <= m; ++i) {
    cin >> p[i].first >> p[i].second;
    qu[p[i].first].push_back(p[i].second);
    qu[p[i].second].push_back(p[i].first);
  }
  dfs2(0, 1);
  for (int i = 1; i <= n; ++i) cout << ans[i] << " ";
  return 0;
}
