Problem: Drazil and Varda are the earthworm couple. They want to find a good place to bring up their children. They found a good ground containing nature hole. The hole contains many rooms, some pairs of rooms are connected by small tunnels such that earthworm can move between them.

Let's consider rooms and small tunnels as the vertices and edges in a graph. This graph is a tree. In the other words, any pair of vertices has an unique path between them.

Each room that is leaf in the graph is connected with a ground by a vertical tunnel. Here, leaf is a vertex that has only one outgoing edge in the graph.

Each room is large enough only to fit one earthworm living in it. Earthworm can't live in a tunnel.

Drazil and Varda have a plan to educate their children. They want all their children to do morning exercises immediately after getting up!

When the morning is coming, all earthworm children get up in the same time, then each of them chooses the farthest path to the ground for gathering with others (these children are lazy, so they all want to do exercises as late as possible).

Drazil and Varda want the difference between the time first earthworm child arrives outside and the time the last earthworm child arrives outside to be not larger than l (otherwise children will spread around the ground and it will be hard to keep them exercising together).

Also, The rooms that are occupied by their children should form a connected set. In the other words, for any two rooms that are occupied with earthworm children, all rooms that lie on the path between them should be occupied with earthworm children too.

How many children Drazil and Varda may have at most in order to satisfy all conditions above? Drazil and Varda want to know the answer for many different choices of l.

(Drazil and Varda don't live in the hole with their children)

Input

The first line contains one integer n denoting how many rooms there are in the hole (2 ≤ n ≤ 105).

Then there are n - 1 lines following. Each of these lines contains three integers x, y, v (1 ≤ x, y ≤ n, 1 ≤ v ≤ 106) denoting there is a small tunnel between room x and room y that takes time v to pass. 

Suppose that the time for an earthworm to get out to the ground from any leaf room is the same.

The next line contains an integer q (1 ≤ q ≤ 50), denoting the number of different value of l you need to process.

The last line contains q numbers, each number denoting a value of l (1 ≤ l ≤ 1011).

Output

You should print q lines. Each line should contain one integer denoting the answer for a corresponding value of l.

Examples

Input

5
1 2 3
2 3 4
4 5 3
3 4 2
5
1 2 3 4 5


Output

1
3
3
3
5


Input

12
5 9 3
2 1 7
11 7 2
6 5 5
2 5 3
6 7 2
1 4 4
8 5 7
1 3 8
11 12 3
10 8 2
10
13 14 14 13 13 4 6 7 2 1


Output

10
10
10
10
10
3
3
5
2
1

Note

For the first sample the hole looks like the following. Rooms 1 and 5 are leaves, so they contain a vertical tunnel connecting them to the ground. The lengths of farthest path from rooms 1 – 5 to the ground are 12, 9, 7, 9, 12 respectively. 

If l = 1, we may only choose any single room. 

If l = 2..4, we may choose rooms 2, 3, and 4 as the answer. 

If l = 5, we may choose all rooms.

<image>

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.Arrays;
import java.util.Iterator;
import java.io.IOException;
import java.util.ArrayList;
import java.io.UncheckedIOException;
import java.util.List;
import java.io.Closeable;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.Comparator;
import java.io.InputStream;
import java.util.function.IntFunction;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(null, new TaskAdapter(), "", 1 << 29);
        thread.start();
        thread.join();
    }

    static class TaskAdapter implements Runnable {
        @Override
        public void run() {
            InputStream inputStream = System.in;
            OutputStream outputStream = System.out;
            FastInput in = new FastInput(inputStream);
            FastOutput out = new FastOutput(outputStream);
            DDrazilAndMorningExercise solver = new DDrazilAndMorningExercise();
            solver.solve(1, in, out);
            out.close();
        }
    }

    static class DDrazilAndMorningExercise {
        Debug debug = new Debug(false);

        public void dfs(Node root, Edge p) {
            root.dist = 0;
            for (Edge e : root.adj) {
                if (e == p) {
                    continue;
                }
                Node node = e.other(root);
                dfs(node, e);
                root.dist = Math.max(root.dist, node.dist + e.w);
            }
        }

        public void dfs1(Node root, Edge p, long fromTop) {
            root.dist = Math.max(root.dist, fromTop);
            int m = root.adj.size();
            long[] preMax = new long[m];
            for (int i = 0; i < m; i++) {
                Edge e = root.adj.get(i);
                if (e == p) {
                    continue;
                }
                preMax[i] = e.w + e.other(root).dist;
            }
            long[] postMax = preMax.clone();
            for (int i = 1; i < m; i++) {
                preMax[i] = Math.max(preMax[i - 1], preMax[i]);
            }
            for (int i = m - 2; i >= 0; i--) {
                postMax[i] = Math.max(postMax[i + 1], postMax[i]);
            }
            for (int i = 0; i < m; i++) {
                Edge e = root.adj.get(i);
                if (e == p) {
                    continue;
                }
                long cand = fromTop;
                if (i > 0) {
                    cand = Math.max(cand, preMax[i - 1]);
                }
                if (i + 1 < m) {
                    cand = Math.max(cand, postMax[i + 1]);
                }
                dfs1(e.other(root), e, cand + e.w);
            }
        }

        public void solve(int testNumber, FastInput in, FastOutput out) {
            int n = in.ri();
            Node[] nodes = new Node[n];
            for (int i = 0; i < n; i++) {
                nodes[i] = new Node();
                nodes[i].id = i;
            }
            for (int i = 0; i < n - 1; i++) {
                Node a = nodes[in.ri() - 1];
                Node b = nodes[in.ri() - 1];
                Edge e = new Edge();
                e.a = a;
                e.b = b;
                e.w = in.ri();
                e.a.adj.add(e);
                e.b.adj.add(e);
            }
            dfs(nodes[0], null);
            dfs1(nodes[0], null, 0);

            for (int i = 0; i < n; i++) {
                debug.debug("i", i);
                debug.debug("dist", nodes[i].dist);
            }
            Node[] sorted = nodes.clone();
            Arrays.sort(sorted, Comparator.comparingLong(x -> -x.dist));
            for (int i = 0; i < n; i++) {
                sorted[i].invId = i;
            }

            int q = in.ri();
            DSUExt dsu = new DSUExt(n);
            for (int i = 0; i < q; i++) {
                dsu.init();
                long l = in.rl();
                Range2DequeAdapter<Node> dq = new Range2DequeAdapter<>(j -> sorted[j], 0, n - 1);
                int best = 1;
                for (Node node : sorted) {
                    while (!dq.isEmpty() && dq.peekFirst().dist - node.dist > l) {
                        Node head = dq.removeFirst();
                        //added
                        dsu.size[dsu.find(head.id)]--;
                    }
                    for (Edge x : node.adj) {
                        Node to = x.other(node);
                        if (to.invId < node.invId && to.dist - node.dist <= l) {
                            dsu.merge(to.id, node.id);
                            best = Math.max(best, dsu.size[dsu.find(node.id)]);
                        }
                    }
                }
                out.println(best);
            }
        }

    }

    static class Edge {
        Node a;
        Node b;
        int w;

        Node other(Node x) {
            return a == x ? b : a;
        }

    }

    static class Debug {
        private boolean offline;
        private PrintStream out = System.err;

        public Debug(boolean enable) {
            offline = enable && System.getSecurityManager() == null;
        }

        public Debug debug(String name, int x) {
            if (offline) {
                debug(name, "" + x);
            }
            return this;
        }

        public Debug debug(String name, long x) {
            if (offline) {
                debug(name, "" + x);
            }
            return this;
        }

        public Debug debug(String name, String x) {
            if (offline) {
                out.printf("%s=%s", name, x);
                out.println();
            }
            return this;
        }

    }

    static class FastInput {
        private final InputStream is;
        private byte[] buf = new byte[1 << 13];
        private int bufLen;
        private int bufOffset;
        private int next;

        public FastInput(InputStream is) {
            this.is = is;
        }

        private int read() {
            while (bufLen == bufOffset) {
                bufOffset = 0;
                try {
                    bufLen = is.read(buf);
                } catch (IOException e) {
                    bufLen = -1;
                }
                if (bufLen == -1) {
                    return -1;
                }
            }
            return buf[bufOffset++];
        }

        public void skipBlank() {
            while (next >= 0 && next <= 32) {
                next = read();
            }
        }

        public int ri() {
            return readInt();
        }

        public int readInt() {
            int sign = 1;

            skipBlank();
            if (next == '+' || next == '-') {
                sign = next == '+' ? 1 : -1;
                next = read();
            }

            int val = 0;
            if (sign == 1) {
                while (next >= '0' && next <= '9') {
                    val = val * 10 + next - '0';
                    next = read();
                }
            } else {
                while (next >= '0' && next <= '9') {
                    val = val * 10 - next + '0';
                    next = read();
                }
            }

            return val;
        }

        public long rl() {
            return readLong();
        }

        public long readLong() {
            int sign = 1;

            skipBlank();
            if (next == '+' || next == '-') {
                sign = next == '+' ? 1 : -1;
                next = read();
            }

            long val = 0;
            if (sign == 1) {
                while (next >= '0' && next <= '9') {
                    val = val * 10 + next - '0';
                    next = read();
                }
            } else {
                while (next >= '0' && next <= '9') {
                    val = val * 10 - next + '0';
                    next = read();
                }
            }

            return val;
        }

    }

    static class Node {
        int id;
        long dist;
        List<Edge> adj = new ArrayList<>();
        int invId;

    }

    static class DSUExt extends DSU {
        int[] size;

        public DSUExt(int n) {
            super(n);
            size = new int[n];
        }

        public void init(int n) {
            super.init(n);
            Arrays.fill(size, 1);
        }

        protected void preMerge(int a, int b) {
            super.preMerge(a, b);
            size[a] += size[b];
        }

    }

    static interface SimplifiedStack<T> extends Iterable<T> {
    }

    static class FastOutput implements AutoCloseable, Closeable, Appendable {
        private static final int THRESHOLD = 1 << 13;
        private final Writer os;
        private StringBuilder cache = new StringBuilder(THRESHOLD * 2);

        public FastOutput append(CharSequence csq) {
            cache.append(csq);
            return this;
        }

        public FastOutput append(CharSequence csq, int start, int end) {
            cache.append(csq, start, end);
            return this;
        }

        private void afterWrite() {
            if (cache.length() < THRESHOLD) {
                return;
            }
            flush();
        }

        public FastOutput(Writer os) {
            this.os = os;
        }

        public FastOutput(OutputStream os) {
            this(new OutputStreamWriter(os));
        }

        public FastOutput append(char c) {
            cache.append(c);
            afterWrite();
            return this;
        }

        public FastOutput append(int c) {
            cache.append(c);
            afterWrite();
            return this;
        }

        public FastOutput append(String c) {
            cache.append(c);
            afterWrite();
            return this;
        }

        public FastOutput println(int c) {
            return append(c).println();
        }

        public FastOutput println() {
            return append(System.lineSeparator());
        }

        public FastOutput flush() {
            try {
                os.append(cache);
                os.flush();
                cache.setLength(0);
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
            return this;
        }

        public void close() {
            flush();
            try {
                os.close();
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }

        public String toString() {
            return cache.toString();
        }

    }

    static class DSU {
        protected int[] p;
        protected int[] rank;
        protected int n;

        public DSU(int n) {
            p = new int[n];
            rank = new int[n];
        }

        public void init() {
            init(p.length);
        }

        public void init(int n) {
            this.n = n;
            for (int i = 0; i < n; i++) {
                p[i] = i;
                rank[i] = 0;
            }
        }

        public final int find(int a) {
            if (p[a] == p[p[a]]) {
                return p[a];
            }
            find(p[a]);
            preAccess(a);
            return p[a] = p[p[a]];
        }

        protected void preAccess(int a) {

        }

        protected void preMerge(int a, int b) {

        }

        public final void merge(int a, int b) {
            a = find(a);
            b = find(b);
            if (a == b) {
                return;
            }
            if (rank[a] == rank[b]) {
                rank[a]++;
            }

            if (rank[a] < rank[b]) {
                int tmp = a;
                a = b;
                b = tmp;
            }

            preMerge(a, b);
            p[b] = a;
        }

        public String toString() {
            return Arrays.toString(Arrays.copyOf(p, n));
        }

    }

    static class Range2DequeAdapter<T> implements SimplifiedDeque<T> {
        IntFunction<T> data;
        int l;
        int r;

        public Range2DequeAdapter(IntFunction<T> data, int l, int r) {
            this.data = data;
            this.l = l;
            this.r = r;
        }

        public boolean isEmpty() {
            return l > r;
        }

        public T peekFirst() {
            return data.apply(l);
        }

        public T removeFirst() {
            return data.apply(l++);
        }

        public Iterator<T> iterator() {
            return new Iterator<T>() {
                int iter = l;


                public boolean hasNext() {
                    return iter <= r;
                }


                public T next() {
                    return data.apply(iter++);
                }
            };
        }

    }

    static interface SimplifiedDeque<T> extends SimplifiedStack<T> {
    }
}