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.*;

public class Main {
    static ArrayList<edge>graph[]=new ArrayList[250000];
    public static void main(String[] args) throws IOException {
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new PrintStream(System.out));
        StringTokenizer st = new StringTokenizer(f.readLine());
        int n = Integer.parseInt(st.nextToken());
        int q = Integer.parseInt(st.nextToken());
        for (int i = 0; i < n; i++) {
            ss[i] = new subset(1,i);
            graph[i] = new ArrayList<>();
        }
        edge[]arr=new edge[n-1];
        for (int i = 0; i < n-1; i++) {
            st = new StringTokenizer(f.readLine());
            int a = Integer.parseInt(st.nextToken()) - 1;
            int b = Integer.parseInt(st.nextToken()) - 1;
            int c = Integer.parseInt(st.nextToken());
            graph[a].add(new edge(a,b, c));
            graph[b].add(new edge(b,a, c));
            arr[i]=new edge(a,b,c);
        }
        st=new StringTokenizer(f.readLine());
        edge[]query=new edge[q];
        for (int i = 0; i < q; i++) {
            query[i]=new edge(i,i,Integer.parseInt(st.nextToken()));
        }
        long[]ans=new long[250000];
        Arrays.sort(query);
        Arrays.sort(arr);
        int j=0;
        for(int i=0;i<q;i++){
            while(j<n-1 && arr[j].weight<=query[i].weight){
                //add edge
                int a=findParent(arr[j].x);
                int b=findParent(arr[j].y);
                union(a,b);
                j++;
            }
//            for(int k:hs.keySet()){
//                k=hs.get(k);
//                ans[query[i].x]+=(k*(k-1))/2;
//            }

            ans[query[i].x]=runningtotal;
        }
        for(int i=0;i<q;i++){
            out.print(ans[i]+" ");
        }
        f.close();
        out.close();
    }
    static long runningtotal=0;
    static HashMap<Integer,Integer>hs=new HashMap<>();
    static subset ss[] = new subset[250000];
    private static void union ( int px, int py){
        if(px==py){
            runningtotal-=(ss[px].rank*(ss[px].rank-1l))/2l;
            ss[px].rank++;
            runningtotal+=(ss[px].rank*(ss[px].rank-1l))/2l;
//            hs.put(px,ss[px].rank);
            return;
        }
        ss[py].parent = px;
        runningtotal-=(ss[py].rank*(ss[py].rank-1l))/2l;
        runningtotal-=(ss[px].rank*(ss[px].rank-1l))/2l;
        ss[px].rank+=ss[py].rank;
        runningtotal+=(ss[px].rank*(ss[px].rank-1l))/2l;
//        if(hs.containsKey(py))hs.remove(py);
//        hs.put(px,ss[px].rank);


    }

    private static int findParent ( int x){
        if (x == ss[x].parent) {
            return ss[x].parent;
        } else {
            ss[x].parent = findParent(ss[x].parent);
        }
        return ss[x].parent;
    }
}
class edge implements Comparable <edge>{
    int x;
    int y;
    int weight;
    public int compareTo(edge other){
        return weight- other.weight;
    }
    //constructor
    edge(int t,int p, int o)
    {
        x=t;
        y=p;
        weight=o;
    }
}
class subset{
    long rank;
    int parent;
    subset(long u, int o){
        rank=u;
        parent=o;
    }
}