You are given a weighted tree consisting of n vertices. Recall that a tree is a connected graph without cycles. Vertices u_i and v_i are connected by an edge with weight w_i.

You are given m queries. The i-th query is given as an integer q_i. In this query you need to calculate the number of pairs of vertices (u, v) (u < v) such that the maximum weight of an edge on a simple path between u and v doesn't exceed q_i.

Input

The first line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^5) — the number of vertices in the tree and the number of queries.

Each of the next n - 1 lines describes an edge of the tree. Edge i is denoted by three integers u_i, v_i and w_i — the labels of vertices it connects (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i) and the weight of the edge (1 ≤ w_i ≤ 2 ⋅ 10^5). It is guaranteed that the given edges form a tree.

The last line of the input contains m integers q_1, q_2, ..., q_m (1 ≤ q_i ≤ 2 ⋅ 10^5), where q_i is the maximum weight of an edge in the i-th query.

Output

Print m integers — the answers to the queries. The i-th value should be equal to the number of pairs of vertices (u, v) (u < v) such that the maximum weight of an edge on a simple path between u and v doesn't exceed q_i.

Queries are numbered from 1 to m in the order of the input.

Examples

Input


7 5
1 2 1
3 2 3
2 4 1
4 5 2
5 7 4
3 6 2
5 2 3 4 1


Output


21 7 15 21 3 


Input


1 2
1 2


Output


0 0 


Input


3 3
1 2 1
2 3 2
1 3 2


Output


1 3 3 

Note

The picture shows the tree from the first example: <image>
import java.util.*;
import java.io.*;
import java.math.BigInteger;

public class Main
{
	static final int mod=(int)1e9+7;
	static long[] size;
	static int[] p;
	static long pairs;
	public static void main(String[] args) throws Exception
	{
		FastReader in=new FastReader();
		PrintWriter pw=new PrintWriter(System.out);
		int n=in.nextInt();
		int q=in.nextInt();
		size=new long[n+1];
		p=new int[n+1];
		ArrayList<Integer[]>[] E=new ArrayList[200001];
		ArrayList<Integer>[] queries=new ArrayList[200001];
		for(int i=1;i<=200000;i++)
		{
			E[i]=new ArrayList();
			queries[i]=new ArrayList();
		}
		for(int i=1;i<=n;i++)
		{
			size[i]=1;
			p[i]=i;
		}
		for(int i=1;i<n;i++)
		{
			int u=in.nextInt();
			int v=in.nextInt();
			int w=in.nextInt();
			E[w].add(new Integer[]{u,v});
		}
		for(int i=0;i<q;i++)
			queries[in.nextInt()].add(i);
		pairs=0;
		long[] ans=new long[q];
		for(int i=1;i<=200000;i++)
		{
			for(Integer[] a:E[i])
				union(a[0],a[1]);

			for(int j:queries[i])
				ans[j]=pairs;
		}
		for(int i=0;i<q;i++)
			pw.print(ans[i]+" ");
		pw.flush();
	}

	static int find(int a)
	{
		if(a==p[a])
			return a;

		p[a]=find(p[a]);

		return p[a];
	}

	static void union(int a,int b)
	{
		int c=find(a);
		int d=find(b);

		if(c==d)
			return;
		pairs+=size[c]*size[d];
		if(size[c]>=size[d])
		{
			size[c]+=size[d];
			p[d]=c;
		}
		else
		{
			size[d]+=size[c];
			p[c]=d;
		}
	}
}

class FastReader
{
	BufferedReader br;
	StringTokenizer st;

	public FastReader()
	{
	    br=new BufferedReader(new InputStreamReader(System.in));
	}

	public String next() throws IOException
	{
	    if(st==null || !st.hasMoreElements())
	    {
	        st=new StringTokenizer(br.readLine());
	    }
	    return st.nextToken();
	}

	public int nextInt() throws IOException
	{
	    return Integer.parseInt(next());
	}

	public long nextLong() throws IOException
	{
	    return Long.parseLong(next());
	}
}