#include<bits/stdc++.h>
using namespace std;
int mian(); int main() { return mian(); }
/*
$f(b)\sum_{t|b}\mu(t)sg(m)$
*/
#define ll long long
const int N = 2e5 + 25;
int n, d, a[N];

int f_edge[N], cnt_edge;
struct edge { int v, net; } eg[N << 1];
void add(const int u, const int v) { eg[++cnt_edge] = (edge) { v, f_edge[u] }; f_edge[u] = cnt_edge; }

int mu[N];
bool isp[N];
vector<int> pr;
void init_mu() {
	mu[1] = 1;
	for(int i = 2; i < N; ++i) {
		if( !isp[i] ) { pr.push_back(i); mu[i] = -1; }
		for(auto x : pr) {
			if( i * x >= N ) break;
			isp[i * x] = true;
			if( i % x == 0 ) { mu[i * x] = 0; break; }
			mu[i * x] = -mu[i];
		}
	}
}

ll td[N];//t^{d+1} 
const ll inf = 0x3f3f3f3f3f3f3f3f;
ll ppow(const ll x) { 
	ll ans = x, y = d;//d+1次方 
	while(y) {
		if( ans * x > (ll)n * n ) return inf;
		ans *= x; y--;
	}
	return ans;
}
void init_td() { for(int i = 1; i <= n; ++i) if( ( td[i] = ppow(i) ) == inf ) { td[i] = 0; break; } }

vector<int> sit[N];
vector<ll> gcd[N];//gcd(t^{d+1},b)
void factor(int x) {
	for(int i = 1; i * i <= x; ++i) if( x % i == 0 ) sit[x].push_back(i), gcd[x].push_back( td[i] / (ll)__gcd( td[i], (ll)x ) );
	const int siz = (int)sit[x].size();
	for(int i = 0; i < siz; ++i) if( sit[x][i] * sit[x][i] != x ) sit[x].push_back( x / sit[x][i] ), gcd[x].push_back( td[ x / sit[x][i] ] / (ll)__gcd( td[ x / sit[x][i] ], (ll)x ) );
//	cout<<x<<endl;
//	for(auto v:sit[x]) cout<<v<<" ";
//	puts("");
//	for(auto v:gcd[x]) cout<<v<<" ";
//	puts("\n\n");
}
void init_sit() { for(int x = 1; x <= n; ++x) factor(x); }


int f[N];
void factorization(int x) {
	const int xi = x;
	f[xi] = 1;
	for(auto i : pr) {
		if( i * i > x ) break;
		int cnt = 0;
		while( x % i == 0 ) x /= i, cnt++;
		if( cnt > d ) return (void)( f[xi] = 0 );
		f[xi] = ( cnt & 1 ? -f[xi] : f[xi] );
	}
	if( x > 1 ) f[xi] = -f[xi];
}
void init_f() { for(int x = 1; x <= n; ++x) factorization(x); }

int siz[N], son[N];
void dfs_init(const int u, const int dad) {
	siz[u] = 1;
	for(int i = f_edge[u]; i; i = eg[i].net) {
		const int v = eg[i].v;
		if( v == dad ) continue;
		dfs_init(v, u);
		siz[u] += siz[v];
		if( siz[v] > siz[ son[u] ] ) son[u] = v;
	}
}

ll ans[N];
int sg[N];
ll sum;
void dfs_sg(const int u, const int dad) {//更新sg 
	for(auto m : sit[ a[u] ]) sg[m] += f[ a[u] ];
	
	for(int i = 0; i < (int)sit[ a[u] ].size(); ++i) {
		const int t = sit[ a[u] ][i], g = gcd[ a[u] ][i];
		if( td[t] and g <= n ) sum += mu[t] * sg[g]* f[ a[u] ]; //处理子树之间的贡献，这里的所有贡献都是u到子树外的贡献 
	}
	//放在前面是为了防止u统计v又有v统计u 
	for(int i = f_edge[u]; i; i = eg[i].net) {
		const int v = eg[i].v;
		if( v != dad ) dfs_sg(v, u);
	}
}
void dfs_reset(const int u, const int dad) {//清空sg，因为sg中只包含整颗子树内的，所以全部清空即可 
	for(auto m : sit[ a[u] ]) sg[m] = 0;
	for(int i = f_edge[u]; i; i = eg[i].net) {
		const int v = eg[i].v;
		if( v != dad ) dfs_reset(v, u);
	}
}
void dfs_solve(const int u, const int dad) {//更新ans 
	for(int i = f_edge[u]; i; i = eg[i].net) {
		const int v = eg[i].v;
		if( v == dad or v == son[u] ) continue;
		dfs_solve(v, u);
	}
	
	if(son[u]) dfs_solve(son[u], u);
	for(int i = f_edge[u]; i; i = eg[i].net) {
		const int v = eg[i].v;
		if( v == dad or v == son[u] ) continue;
		dfs_sg(v, u);
	}//先便利子树再加入 $u$ 防止自述中的点计算了 $u$ 的贡献，而 $u$ 下面也要计算 
	for(auto m : sit[ a[u] ]) sg[m] += f[ a[u] ];//把 $u$ 加入 $S$ 就得到了自己对自己的贡献 
	
	for(int i = 0; i < (int)sit[ a[u] ].size(); ++i) {
		const int t = sit[ a[u] ][i], g = gcd[ a[u] ][i];
		if( td[t] and g ){
			sum += mu[t] * sg[g]* f[ a[u] ];
//			cout<<u<<" "<<t<<" "<<g<<" "<<mu[t]<<" "<<sg[g]<<" "<<f[a[u]]<<endl;
		}
	}
	ans[u] = sum ;
	if( u != son[dad] ) dfs_reset(u, dad), sum = 0;
	//清空轻儿子贡献 
}

int mian() {
	scanf("%d%d", &n, &d);
	for(int i = 1, u, v; i < n; ++i) scanf("%d%d", &u, &v), add(u, v), add(v, u);
	for(int i = 1; i <= n; ++i) scanf("%d", &a[i]);
	init_mu();
	init_td();
	init_sit();
	init_f();
	dfs_init(1, 0);
	dfs_solve(1, 0);
//	dfs_solve(3,8);
	for(int i = 1; i <= n; ++i) printf("%lld\n", ans[i]);
	return 0;
} /*
20 1
15 2
4 15
9 13
16 19
2 5
13 2
19 2
8 14
1 12
18 7
10 5
3 8
20 19
14 2
7 19
18 6
8 11
17 8
19 1
14 3 5 2 9 4 18 16 1 20 13 7 6 12 19 17 10 15 8 11
*/
/*
给定一棵树，树上有点权。给定常数 $d$ 
设权值 $x$ 的函数 $f(x)=\prod_i(-1)^{k_i}\times [k_i\le d]$，其中 $k_i$ 表示 $x=\prod_i p_i^{k_i}$（唯一分解定理的次数） 
对每个点求子树中的 $i,j$ 的 $\sum_{i,j}f(a_ia_j)$ ， $i$ 可以等于 $j$ 
$n\le 2\times 10^5, d\le 20$，$a_i$ 组成一个排列 
$time:1s$，$memory:265MB$ 

发现 $f$ 存在一的一个大问题就是限制了次数，一旦超过就是 $0$ 
但是如果两个数没有相同的因子，那么就一定有 $f(ij)=f(i)f(j)$ ，也就是普通积性函数 
于是尝试构造一个完全积性函数 $g=\prod_i(-1)^{k_i}$，那么就没有了 $d$ 的限制 
会发现两者之间的关系是：$g=1\space or\space -1$ 但 $f=g=1\space or\space -1\space or\space 0$ 
直接将 $f$ 平方，那么就只有 $0$ 和 $1$ 两种情况了，于是就类似于一个 $bool$ 判断是否有 $k>d$ 
于是 $f^2(i)=[k_j\le d]$，与 $g$ 建立联系，就有 $f(i)=g(i)\times f^2(i)$  
（类似$\mu(ij)=\mu(i)\mu(j)\mu^2(ij)$） 

但是还是不好处理。发现 $f^2(i)$ 是一个 $bool$  类的判断，可以考虑变为 $[?=1]$ 后进行莫比乌斯变换 
设有 $h(x)$ 为最大的一个数字满足 $h(x)^{d+1} | x$ ，那么只要 $h(x)>1$ 则说明 $f(x)=0$ 
于是就有了 $f^2(i)=[h(i)=1]=\sum_{t|h(i)}\mu(t)=\sum_{t^{d+1}|i}\mu(t)$ ，原因是 $h(i)$ 是最大的一个，那么更小的一定是其因子 
会带到之前的式子中。 

因为要统计的是两个数的乘积，那么假设已经统计好了集合 $S$ 中的数 $a$ 互相的贡献，考虑 $b$ 与他们产生的贡献，可以得到：
$$
\sum_{a\in S}f(ab)=\sum_{a\in S}g(ab)f^2(ab)=\sum_{a\in S}g(a)g(b)f^2(ab)=\sum_{a\in S}g(a)g(b)\sum_{t^{d+1}|ab}\mu(t)
$$
首先转化视角为：
$$
g(b)\sum_{t}\mu(t)\sum_{a\in S}g(a)[t^{d+1}|ab]
$$
如果 $t$ 不是 $b$ 的因子，则一定有 $t^{d+1}|a$，于是就有了 $f(a)=0$，于是就有 $f(ab)=0$（选择 $t|b$ 的原因是 $b$ 在局部是固定的不用枚举 ）
注意到此时：
$$
[t^{d+1}|ab]=[t^{d+1}|ab][t|b]=[\dfrac{t^{d+1}}{\gcd{(t^{d+1}, b)}}|a]
$$
原因是除去 $b$ 部分的影响就只剩下了 $a$。于是就实现了将 $t,b$ 与 $a$ 分裂出来

此时原先的式子变为：
$$
f(b)\sum_{t|b}\mu(t)\sum_{a\in S}f(a)[\dfrac{t^{d+1}}{\gcd{(t^{d+1}, b)}}|a]
$$
>为什么从 $g$ 变成了 $f$ ?

>考虑若存在 $f(a)$ 或 $f(b)$ 中的任意一个是 $0$，那么就说明原先的 $f(ab)$ 也一定等于 $0$，因此直接等价了；如果都不是 $0$，那么就肯定有 $f(a)=g(a),f(b)=g(b)$，于是就转化为之前的式子，那么还是等价。此时的 $t|b$ 就是排除 $f(a)$ 等于 $0$ 的情况
因为所有权值是一个排列，因此直接枚举 $t$ 的总复杂度是 $n\ln n$
在枚举了 $b,t$ 的情况下 $\dfrac{t^{d+1}}{\gcd{(t^{d+1}, b)}}$ 是一个定值。记这个为 $m$。
那么设一个 $sg(m)=\sum_{a\in S}f(a)[m|a]$，于是式子变为 **$f(b)\sum_{t|b}\mu(t)sg(m)$**
那么只需要在 $S$ 不同时维护好对应的 $sg$ 就可以对于单个 $b$ 算出他的贡献 

会发现对于树上任意两个点的问题可以转化为子树问题（在子树中任选两个 $lca=u$ 的点）
对于集合 $S$ ，本质上也就是子树中的所有点
于是考虑使用树上启发式合并
每一次先得到所有轻儿子的答案，然后清空他们对于 $S$ 的影响（其实也就是 $sg$ 的影响）
然后统计重儿子的影响之后不清空，再把 $u$ 和其他的轻儿子加入 $S$ 中算出 $u$ 的答案
注意要加上自己到自己的贡献
对于总时间，单次统计答案是 $O(\ln n\log n)$ 的（因为有 $\gcd$），每个点总只会统计一次。然后至多有 $\log n$ 条轻链，因此总复杂度就是 $O(n\ln n\log n)$ 的
*/