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 MOD = 1e9 + 7;
const double eps = 1e-9;
const int maxn = 100010;
inline int read() {
  int ret = 0, sgn = 1;
  char ch = getchar();
  while (ch < '0' || ch > '9') {
    if (ch == '-') sgn = -1;
    ch = getchar();
  }
  while (ch >= '0' && ch <= '9') {
    ret = ret * 10 + ch - '0';
    ch = getchar();
  }
  return ret * sgn;
}
vector<int> E[100010];
vector<int> que[100010];
void add(int u, int v) {
  E[u].push_back(v);
  E[v].push_back(u);
}
void quee(int a, int b) {
  que[a].push_back(b);
  que[a].push_back(a);
  que[b].push_back(b);
  que[b].push_back(a);
}
struct node {
  int l, r;
  int cnt, lazy;
  int leng() { return r - l + 1; }
} T[maxn << 2];
int s[maxn], e[maxn];
int tot;
void dfs(int x, int fa) {
  s[x] = ++tot;
  for (int i = 0; i < E[x].size(); i++) {
    if (E[x][i] == fa) continue;
    dfs(E[x][i], x);
  }
  e[x] = tot;
}
void build(int k, int l, int r) {
  T[k].l = l;
  T[k].r = r;
  T[k].cnt = T[k].lazy = 0;
  if (l == r) return;
  int m = (l + r) >> 1;
  build(k << 1, l, m);
  build(k << 1 | 1, m + 1, r);
}
void push_up(int k) {
  if (T[k].lazy)
    T[k].cnt = T[k].leng();
  else {
    if (T[k].l == T[k].r)
      T[k].cnt = 0;
    else {
      T[k].cnt = T[k << 1].cnt + T[k << 1 | 1].cnt;
    }
  }
}
void updata(int k, int l, int r, int val) {
  if (T[k].l == l && T[k].r == r) {
    T[k].lazy += val;
    push_up(k);
    return;
  }
  int m = (T[k].l + T[k].r) >> 1;
  if (r <= m) {
    updata(k << 1, l, r, val);
  } else if (l > m) {
    updata(k << 1 | 1, l, r, val);
  } else {
    updata(k << 1, l, m, val);
    updata(k << 1 | 1, m + 1, r, val);
  }
  push_up(k);
  return;
}
int ans[maxn];
void solve(int u, int pre) {
  for (int i = 0; i < que[u].size(); i++) {
    int v = que[u][i];
    updata(1, s[v], e[v], 1);
  }
  ans[u] = T[1].cnt;
  if (ans[u]) ans[u]--;
  for (int i = 0; i < E[u].size(); i++) {
    int v = E[u][i];
    if (v == pre) continue;
    solve(v, u);
  }
  for (int i = 0; i < que[u].size(); i++) {
    int v = que[u][i];
    updata(1, s[v], e[v], -1);
  }
}
int main() {
  int n;
  int m;
  scanf("%d", &n);
  scanf("%d", &m);
  for (int i = 1; i < n; i++) {
    int v, u;
    scanf("%d%d", &u, &v);
    add(u, v);
  }
  for (int i = 1; i <= m; i++) {
    int a, b;
    scanf("%d%d", &a, &b);
    quee(a, b);
  }
  dfs(1, -1);
  build(1, 1, n);
  solve(1, -1);
  for (int i = 1; i < n; i++) {
    cout << ans[i] << ' ';
  }
  cout << ans[n] << endl;
  return 0;
}
