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>
using namespace std;
const int maxn = 100007;
int n, m, start[maxn], finish[maxn], num, ans[maxn];
vector<int> a[maxn], query[maxn];
bool free1[maxn];
void dfs(int u) {
  start[u] = ++num;
  int v;
  for (int i = 0, _a = (int(a[u].size())); i < _a; ++i) {
    v = a[u][i];
    if (start[v]) continue;
    dfs(v);
  }
  finish[u] = num;
}
struct {
  int minv, c, t;
} IT[maxn * 4];
void init(int i, int l, int r) {
  IT[i].minv = 0;
  IT[i].c = r - l + 1;
  if (l == r) return;
  int mid = (l + r) / 2;
  init(i * 2, l, mid);
  init(i * 2 + 1, mid + 1, r);
}
void lazy_update(int &i, int &l, int &r) {
  if (!IT[i].t) return;
  IT[i].minv += IT[i].t;
  if (l < r) {
    IT[i * 2].t += IT[i].t;
    IT[i * 2 + 1].t += IT[i].t;
  }
  IT[i].t = 0;
}
void update(int i, int l, int r, int &s, int &f, int v) {
  lazy_update(i, l, r);
  if (f < l || s > r) return;
  if (s <= l && r <= f) {
    IT[i].t += v;
    lazy_update(i, l, r);
    return;
  }
  int mid = (l + r) / 2;
  update(i * 2, l, mid, s, f, v);
  update(i * 2 + 1, mid + 1, r, s, f, v);
  IT[i].minv = min(IT[i * 2].minv, IT[i * 2 + 1].minv);
  IT[i].c = 0;
  if (IT[i * 2].minv == IT[i].minv) IT[i].c += IT[i * 2].c;
  if (IT[i * 2 + 1].minv == IT[i].minv) IT[i].c += IT[i * 2 + 1].c;
}
void dfs2(int u) {
  int l, r, v;
  free1[u] = 0;
  if (!query[u].empty()) update(1, 1, n, start[u], finish[u], 1);
  for (int i = 0, _a = (int(query[u].size())); i < _a; ++i) {
    l = start[query[u][i]];
    r = finish[query[u][i]];
    update(1, 1, n, l, r, 1);
  }
  ans[u] = n - IT[1].c * (IT[1].minv == 0);
  if (ans[u]) ans[u]--;
  for (int i = 0, _a = (int(a[u].size())); i < _a; ++i) {
    v = a[u][i];
    if (free1[v]) dfs2(v);
  }
  for (int i = 0, _a = (int(query[u].size())); i < _a; ++i) {
    l = start[query[u][i]];
    r = finish[query[u][i]];
    update(1, 1, n, l, r, -1);
  }
  if (!query[u].empty()) update(1, 1, n, start[u], finish[u], -1);
}
int main() {
  scanf("%d%d", &n, &m);
  int u, v;
  for (int i = 1, _c = n - 1; i <= _c; i++) {
    scanf("%d%d", &u, &v);
    a[u].push_back(v);
    a[v].push_back(u);
  }
  num = 0;
  dfs(1);
  for (int i = 1, _c = m; i <= _c; i++) {
    scanf("%d%d", &u, &v);
    query[u].push_back(v);
    query[v].push_back(u);
  }
  memset(free1, 1, sizeof(free1));
  init(1, 1, n);
  dfs2(1);
  for (int i = 1, _c = n; i <= _c; i++) printf("%d ", ans[i]);
  puts("");
  return 0;
}
