Problem: Some country consists of n cities, connected by a railroad network. The transport communication of the country is so advanced that the network consists of a minimum required number of (n - 1) bidirectional roads (in the other words, the graph of roads is a tree). The i-th road that directly connects cities ai and bi, has the length of li kilometers.

The transport network is served by a state transporting company FRR (Fabulous Rail Roads). In order to simplify the price policy, it offers a single ride fare on the train. In order to follow the route of length t kilometers, you need to pay <image> burles. Note that it is forbidden to split a long route into short segments and pay them separately (a special railroad police, or RRP, controls that the law doesn't get violated).

A Large Software Company decided to organize a programming tournament. Having conducted several online rounds, the company employees determined a list of finalists and sent it to the logistical department to find a place where to conduct finals. The Large Software Company can easily organize the tournament finals in any of the n cities of the country, so the the main factor in choosing the city for the last stage of the tournament is the total cost of buying tickets for all the finalists. We know that the i-th city of the country has wi cup finalists living there.

Help the company employees find the city such that the total cost of travel of all the participants to it is minimum.

Input

The first line of the input contains number n (1 ≤ n ≤ 200 000) — the number of cities in the country.

The next line contains n integers w1, w2, ..., wn (0 ≤ wi ≤ 108) — the number of finalists living in each city of the country.

Next (n - 1) lines contain the descriptions of the railroad, the i-th line contains three integers, ai, bi, li (1 ≤ ai, bi ≤ n, ai ≠ bi, 1 ≤ li ≤ 1000).

Output

Print two numbers — an integer f that is the number of the optimal city to conduct the competition, and the real number c, equal to the minimum total cost of transporting all the finalists to the competition. Your answer will be considered correct if two conditions are fulfilled at the same time: 

  1. The absolute or relative error of the printed number c in comparison with the cost of setting up a final in city f doesn't exceed 10 - 6; 
  2. Absolute or relative error of the printed number c in comparison to the answer of the jury doesn't exceed 10 - 6. 



If there are multiple answers, you are allowed to print any of them.

Examples

Input

5
3 1 2 6 5
1 2 3
2 3 1
4 3 9
5 3 1


Output

3 192.0

Input

2
5 5
1 2 2


Output

1 14.142135623730951000

Note

In the sample test an optimal variant of choosing a city to conduct the finals of the competition is 3. At such choice the cost of conducting is <image> burles.

In the second sample test, whatever city you would choose, you will need to pay for the transport for five participants, so you will need to pay <image> burles for each one of them.

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.util.LinkedList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author xwchen
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        LinkedList<Pair<Integer, Integer>>[] adj = null;
        boolean[] removed = null;
        int[] subTreeSize = null;
        int[] w;
        int subTreeCount = 0;
        int bestIndex;
        double best;
        double[] gradient = null;
        int centroid;
        LinkedList<Integer> lastTwo = new LinkedList<>();

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            w = in.nextIntArray(n);
            adj = new LinkedList[n];
            for (int i = 0; i < n; ++i) {
                adj[i] = new LinkedList<>();
            }
            removed = new boolean[n];
            subTreeSize = new int[n];
            gradient = new double[n];
            best = 1e308;
            for (int i = 0; i < n; ++i) {
                adj[i] = new LinkedList<>();
            }
            for (int i = 0; i < n - 1; ++i) {
                int a = in.nextInt();
                int b = in.nextInt();
                int len = in.nextInt();
                --a;
                --b;
                addEdge(a, b, len);
                addEdge(b, a, len);
            }
            decompose(0);
            for (int last : lastTwo) {
                double cost = getCost(last, last, 0);
                //Utils.pf("id = %d cost = %.6f", (last + 1), cost);
                if (cost < best) {
                    best = cost;
                    bestIndex = last;
                }
            }
            out.println((bestIndex + 1) + " " + String.format("%.6f", best));
        }

        double getCost(int u, int pre, long len) {
            double sum = w[u] * len * Math.sqrt(len);
            for (Pair<Integer, Integer> e : adj[u]) {
                int v = e.x;
                int lv = e.y;
                if (v != pre) {
                    sum += getCost(v, u, len + lv);
                }
            }
            return sum;
        }

        double getGradient(int u, int pre, long len) {
            double sum = w[u] * Math.sqrt(len);
            for (Pair<Integer, Integer> e : adj[u]) {
                int v = e.x;
                int lv = e.y;
                if (v != pre) {
                    sum += getGradient(v, u, len + lv);
                }
            }
            return sum;
        }

        void decompose(int root) {
            subTreeCount = getSubtreeSize(root, -1);
            centroid = findCentroid(root, -1);
            //Utils.pf("centroid = %d", centroid);
            lastTwo.addLast(centroid);
            if (lastTwo.size() > 2) {
                lastTwo.removeFirst();
            }
            removed[centroid] = true;
            double sumGradient = 0;
            for (Pair<Integer, Integer> e : adj[centroid]) {
                int len = e.y;
                gradient[e.x] = getGradient(e.x, centroid, len);
                sumGradient += gradient[e.x];
            }
            for (Pair<Integer, Integer> e : adj[centroid]) {
                int v = e.x;
                if (gradient[v] + gradient[v] >= sumGradient) {
                    if (!removed[v]) {
                        decompose(v);
                    } else {
                        lastTwo.addLast(v);
                        if (lastTwo.size() > 2) {
                            lastTwo.removeFirst();
                        }
                    }
                }
            }
        }

        int getSubtreeSize(int u, int pre) {
            subTreeSize[u] = 1;
            for (Pair<Integer, Integer> e : adj[u]) {
                int v = e.x;
                if (v != pre && !removed[v]) {
                    subTreeSize[u] += getSubtreeSize(v, u);
                }
            }
            return subTreeSize[u];
        }

        int findCentroid(int u, int pre) {
            for (Pair<Integer, Integer> e : adj[u]) {
                int v = e.x;
                if (v != pre && !removed[v] && subTreeSize[v] > subTreeCount / 2) {
                    return findCentroid(v, u);
                }
            }
            return u;
        }

        void addEdge(int u, int v, int len) {
            adj[u].add(new Pair<>(v, len));
        }

    }

    static class InputReader {
        private BufferedReader reader;
        private StringTokenizer tokenizer = new StringTokenizer("");

        public InputReader(InputStream inputStream) {
            this.reader = new BufferedReader(
                    new InputStreamReader(inputStream));
        }

        public String next() {
            while (!tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return tokenizer.nextToken();
        }

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

        public int[] nextIntArray(int n) {
            int[] a = new int[n];
            for (int i = 0; i < n; i++)
                a[i] = nextInt();
            return a;
        }

    }

    static class Pair<K, V> implements Comparable<Pair> {
        public K x;
        public V y;

        public Pair(K x, V y) {
            this.x = x;
            this.y = y;
        }

        public Pair() {

        }

        public int compareTo(Pair o) {
            if (compareNumber(x, o.x) != 0) {
                return compareNumber(x, o.x);
            } else {
                return compareNumber(y, o.y);
            }
        }

        private int compareNumber(Object o1, Object o2) {
            if (o1 instanceof Integer && o2 instanceof Integer) {
                return ((Integer) o1).compareTo((Integer) o2);
            } else if (o1 instanceof Long && o2 instanceof Long) {
                return ((Long) o1).compareTo((Long) o2);
            } else if (o1 instanceof Double && o2 instanceof Double) {
                return ((Double) o1).compareTo((Double) o2);
            } else {
                System.out.println("Unsupported Type");
                return 0;
            }
        }

    }
}