class PersistentPartUnionFind:
    def __init__(self,N):
        INF = float('INF')
        self.now = 0
        self.N = 0
        self.parent = [-1 for i in range(N)]
        self.time = [INF for i in range(N)]
        self.num = [[] for i in range(N)]
        for i in range(N):
            self.num[i].append((0,1))
    
    def find(self,t,x):
        '''
        version:tにおけるxの根を見つける
        t (any) : version
        x (int) : 要素
        return : int : 根
        '''
        while self.time[x] <= t:
            x = self.parent[x]
        return x
    
    def union(self,x,y):
        '''
        x,yをつなげる
        x (int) : 要素
        y (int) : 要素
        '''
        self.now += 1
        x = self.find(self.now,x)
        y = self.find(self.now,y)

        if x == y:
            return
        
        if self.parent[x] > self.parent[y]:
            x,y = y,x
        
        
        self.parent[x] += self.parent[y]
        self.parent[y] = x
        self.time[y] = self.now
        self.num[x].append((self.now,-self.parent[x]))

    def same(self,t,x,y):
        '''
        version:tにおけるx,yが同じかどうかO(logN)
        t (any) : version
        x (int) : 要素
        y (int) : 要素
        return : bool : 同じかどうか
        '''
        return self.find(t,x) == self.find(t,y)

    def size(self,t,x):
        '''
        version:tにおける要素xが含まれる集合の大きさ
        t (any) : version
        x (int) : 要素
        return : int :集合の大きさ  
        '''
        x = self.find(t,x)

        ok = 0
        ng = len(self.num[x])
        while (ng-ok > 1):
            mid = (ok+ng)>>1
            if self.num[x][mid][0] <= t:
                ok = mid
            else:
                ng = mid
        
        return self.num[x][ok][1]

def binary_search(f):
    left,right=0,N
    while right-left>1:
        mid=(right+left)//2
        if not f(mid):
            left=mid
        else:
            right=mid
    return left

def f(x):
    return uf.same(x,s-1,t-1)


N,M=map(int,input().split())
uf = PersistentPartUnionFind(N)
c = []
for i in range(N-1):
    u,v=map(int,input().split())
    c.append((u,v))
for u, v in c[::-1]:
    uf.union(u-1,v-1)
q = []
ans = [0]*(N)
ans[0] = M
for _ in range(M):
    s,t = map(int,input().split())
    l = binary_search(f)
    ans[-1-l] -= 1
for i in range(1,len(ans)):
    ans[i] += ans[i-1]
for a in ans[1:]:
    print(a)