Problem: 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>

Solution (in JAVA):

Solution:
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 ArrayList<edge> E;
	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];
		E=new ArrayList();
		for(int i=1;i<=n;i++)
		{
			size[i]=1;
			p[i]=i;
		}
		for(int i=1;i<n;i++)
			E.add(new edge(in.nextInt(),in.nextInt(),in.nextInt()));
		Collections.sort(E);
		Integer[][] queries=new Integer[q][2];
		for(int i=0;i<q;i++)
		{
			queries[i][0]=in.nextInt();
			queries[i][1]=i;
		}
		Arrays.sort(queries,(Integer[] a,Integer[] b)-> Integer.compare(a[0],b[0]));
		int i=0,j=0;
		pairs=0;
		long[] ans=new long[q];
		while(i<q)
		{
			while(j<E.size() && E.get(j).w<=queries[i][0])
			{
				union(E.get(j).u,E.get(j).v);
				j++;
			}
			ans[queries[i][1]]=pairs;
			i++;
		}
		for(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;
		}
	}

	static class edge implements Comparable<edge>
	{
		int u,v,w;

		public edge(int a,int b,int c)
		{
			u=a;
			v=b;
			w=c;
		}

		public int compareTo(edge e)
		{
			return Integer.compare(w,e.w);
		}
	}
}

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());
	}
}