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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.StringTokenizer;

public class TaskG {
	public static void main(String[] arg) {
		final FastScanner in = new FastScanner(System.in);
		final PrintWriter out = new PrintWriter(System.out);
		final int N = in.nextInt();
		final int M = in.nextInt();
		final int[][] edges = new int[N - 1][3];
		for (int i = 0; i < edges.length; i++) {
			edges[i][0] = in.nextInt() - 1;
			edges[i][1] = in.nextInt() - 1;
			edges[i][2] = in.nextInt();
		}
		final int[] q = in.readIntArr(M);
		Integer[] qq = new Integer[M];
		for (int i = 0; i < M; i++) {
			qq[i] = q[i];
		}
		// Sort edges
		Arrays.sort(edges, (e1, e2) -> e1[2] - e2[2]);
		Arrays.sort(qq, (q1, q2) -> q1 - q2);

		wUF wUf = new wUF(N);
		int qi = 0;
		Map<Integer, Long> result = new HashMap<>();
		for (int i = 0; i < edges.length; i++) {
			while (qi < qq.length && qq[qi] < edges[i][2]) {
				result.put(qq[qi], wUf.count);
				qi++;
			}
			wUf.union(edges[i][0], edges[i][1]);
		}
		while (qi < qq.length) {
			result.put(qq[qi], wUf.count);
			qi++;
		}

		for (int i = 0; i < q.length; i++) {
			out.print(result.getOrDefault(q[i], 0L)+" ");
		}

		out.close();
		in.close();
	}

	private static class wUF {
		private int[] iDs;
		private long[] sz;
		private long count;

		public wUF(int N) {
			iDs = new int[N];
			sz = new long[N];
			for (int i = 0; i < N; i++) {
				iDs[i] = i;
				sz[i] = 1;
			}
			count = 0;
		}

		public int find(int p) {
			while (iDs[p] != p) {
				p = iDs[p];
			}
			return p;
		}

		public void union(int p, int q) {
			int pp = find(p);
			int qp = find(q);
			if (pp == qp) {
				return;
			}

			count -= (sz[pp] * (sz[pp] - 1)) / 2;
			count -= (sz[qp] * (sz[qp] - 1)) / 2;
			count += (sz[pp] + sz[qp]) * (sz[pp] + sz[qp] - 1) / 2;
			if (sz[pp] > sz[qp]) {
				iDs[qp] = pp;
				sz[pp] += sz[qp];
			} else {
				iDs[pp] = qp;
				sz[qp] += sz[pp];
			}
		}

		@Override
		public String toString() {
			return "iDs=" + Arrays.toString(iDs) + "\nsz=" + Arrays.toString(sz);
		}

	}

	private static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		FastScanner(InputStream stream) {
			try {
				br = new BufferedReader(new InputStreamReader(stream));
			} catch (Exception e) {
				e.printStackTrace();
			}
		}

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

		int[] readIntArr(int n) {
			int[] result = new int[n];
			for (int i = 0; i < n; i++) {
				result[i] = Integer.parseInt(next());
			}
			return result;
		}

		void close() {
			try {
				br.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

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

	}

}
