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 CPP):

Solution:
#include <bits/stdc++.h>
const int N = 2e5 + 10;
int n;
std::vector<std::pair<int, double> > edge[N];
bool vis[N];
double weight[N];
std::pair<int, double> ans;
int size[N], best[N];
double cost[N], der[N];
void init() {
  std::cin >> n;
  for (int i = 1; i <= n; i++) {
    scanf("%lf", &weight[i]);
  }
  for (int i = 1; i <= n - 1; i++) {
    int u, v;
    double w;
    scanf("%d%d%lf", &u, &v, &w);
    edge[u].push_back(std::make_pair(v, w));
    edge[v].push_back(std::make_pair(u, w));
  }
}
void dfs(int u, int father, double deep, std::vector<int> &queue) {
  queue.push_back(u);
  size[u] = 1;
  best[u] = 0;
  for (int i = 0; i < (int)edge[u].size(); i++) {
    int v = edge[u][i].first;
    if (vis[v] || v == father) {
      continue;
    }
    dfs(v, u, deep + edge[u][i].second, queue);
    size[u] += size[v];
    best[u] = std::max(best[u], size[v]);
    der[u] += der[v];
  }
}
int get_center(int root, const std::vector<int> &queue) {
  int total = size[root];
  int ret = 0;
  int tmp = n + 5;
  for (int i = 0; i < (int)queue.size(); i++) {
    int u = queue[i];
    best[u] = std::max(best[u], total - size[u]);
    if (best[u] < tmp) {
      tmp = best[u];
      ret = u;
    }
  }
  return ret;
}
void dfs_all(int u, int father, double deep) {
  cost[u] = deep * std::sqrt(deep) * weight[u];
  der[u] = sqrt(deep) * weight[u];
  for (int i = 0; i < (int)edge[u].size(); i++) {
    int v = edge[u][i].first;
    if (v == father) {
      continue;
    }
    dfs_all(v, u, deep + edge[u][i].second);
    der[u] += der[v];
  }
}
void update(int u) {
  double total_cost = 0.0;
  for (int i = 1; i <= n; i++) {
    total_cost += cost[i];
  }
  if (ans.first == 0 || total_cost < ans.second) {
    ans = std::make_pair(u, total_cost);
  }
}
int get_direction(int u, const std::vector<int> &queue) {
  double max = -1.0;
  int ret = -1;
  for (int i = 0; i < (int)edge[u].size(); i++) {
    if (vis[edge[u][i].first]) {
      continue;
    }
    int v = edge[u][i].first;
    if (der[v] > max) {
      max = der[v];
      ret = v;
    }
  }
  return ret;
}
void work() {
  int root = 1;
  while (true) {
    static std::vector<int> queue;
    queue.clear();
    dfs(root, 0, 0.0, queue);
    int center = get_center(root, queue);
    queue.clear();
    dfs_all(center, 0, 0.0);
    root = get_direction(center, queue);
    update(center);
    vis[center] = true;
    if (root == -1) {
      break;
    }
  }
  if (ans.first == 0) {
    ans.first = 1;
  }
  printf("%d %.8f\n", ans.first, ans.second);
}
int main() {
  init();
  work();
  return 0;
}