Problem: Farmer John is obsessed with making Bessie exercise more!

Bessie is out grazing on the farm, which consists of n fields connected by m directed roads. Each road takes some time w_i to cross. She is currently at field 1 and will return to her home at field n at the end of the day.

Farmer John has plans to increase the time it takes to cross certain roads. He can increase the time it takes to cross each road by a nonnegative amount, but the total increase cannot exceed x_i for the i-th plan. 

Determine the maximum he can make the shortest path from 1 to n for each of the q independent plans.

Input

The first line contains integers n and m (2 ≤ n ≤ 50, 1 ≤ m ≤ n ⋅ (n-1)) — the number of fields and number of roads, respectively.

Each of the following m lines contains 3 integers, u_i, v_i, and w_i (1 ≤ u_i, v_i ≤ n, 1 ≤ w_i ≤ 10^6), meaning there is an road from field u_i to field v_i that takes w_i time to cross.

It is guaranteed that there exists a way to get to field n from field 1. It is guaranteed that the graph does not contain self-loops or parallel edges. It is possible to have a road from u to v and a road from v to u.

The next line contains a single integer q (1 ≤ q ≤ 10^5), the number of plans.

Each of the following q lines contains a single integer x_i, the query (0 ≤ x_i ≤ 10^5).

Output

For each query, output the maximum Farmer John can make the shortest path if the total increase does not exceed x_i.

Your answer is considered correct if its absolute or relative error does not exceed 10^{-6}.

Formally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \frac{|a - b|}{max{(1, |b|)}} ≤ 10^{-6}.

Example

Input


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


Output


3.0000000000
4.0000000000
4.5000000000
5.0000000000
5.5000000000

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t, class u>
void chmax(t& first, u second) {
  if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
  if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<ll, ll>;
using vi = vc<ll>;
template <class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
  return os << "{" << p.first << "," << p.second << "}";
}
template <class t>
ostream& operator<<(ostream& os, const vc<t>& v) {
  os << "{";
  for (auto e : v) os << e << ",";
  return os << "}";
}
using uint = unsigned;
using ull = unsigned long long;
template <class t, size_t n>
ostream& operator<<(ostream& os, const array<t, n>& first) {
  return os << vc<t>(first.begin(), first.end());
}
template <ll i, class T>
void print_tuple(ostream&, const T&) {}
template <ll i, class T, class H, class... Args>
void print_tuple(ostream& os, const T& t) {
  if (i) os << ",";
  os << get<i>(t);
  print_tuple<i + 1, T, Args...>(os, t);
}
template <class... Args>
ostream& operator<<(ostream& os, const tuple<Args...>& t) {
  os << "{";
  print_tuple<0, tuple<Args...>, Args...>(os, t);
  return os << "}";
}
template <class t>
void print(t x, ll suc = 1) {
  cout << x;
  if (suc == 1) cout << "\n";
  if (suc == 2) cout << " ";
}
ll read() {
  ll i;
  cin >> i;
  return i;
}
vi readvi(ll n, ll off = 0) {
  vi v(n);
  for (ll i = ll(0); i < ll(n); i++) v[i] = read() + off;
  return v;
}
template <class T>
void print(const vector<T>& v, ll suc = 1) {
  for (ll i = ll(0); i < ll(v.size()); i++)
    print(v[i], i == ll(v.size()) - 1 ? suc : 2);
}
string readString() {
  string s;
  cin >> s;
  return s;
}
template <class T>
T sq(const T& t) {
  return t * t;
}
void yes(bool ex = true) {
  cout << "Yes"
       << "\n";
  if (ex) exit(0);
}
void no(bool ex = true) {
  cout << "No"
       << "\n";
  if (ex) exit(0);
}
void possible(bool ex = true) {
  cout << "Possible"
       << "\n";
  if (ex) exit(0);
}
void impossible(bool ex = true) {
  cout << "Impossible"
       << "\n";
  if (ex) exit(0);
}
constexpr ll ten(ll n) { return n == 0 ? 1 : ten(n - 1) * 10; }
const ll infLL = LLONG_MAX / 3;
const ll inf = infLL;
ll topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
ll topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
ll botbit(signed first) { return first == 0 ? 32 : __builtin_ctz(first); }
ll botbit(ll first) { return first == 0 ? 64 : __builtin_ctzll(first); }
ll popcount(signed t) { return __builtin_popcount(t); }
ll popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(ll i) { return i && (i & -i) == i; }
ll mask(ll i) { return (ll(1) << i) - 1; }
template <class t>
bool inc(t first, t second, t c) {
  return first <= second && second <= c;
}
template <class t>
void mkuni(vc<t>& v) {
  sort(v.begin(), v.end());
  v.erase(unique(v.begin(), v.end()), v.end());
}
ll rand_int(ll l, ll r) {
  static random_device rd;
  static mt19937_64 gen(rd());
  return uniform_int_distribution<ll>(l, r)(gen);
}
template <class t>
ll lwb(const vc<t>& v, const t& first) {
  return lower_bound(v.begin(), v.end(), first) - v.begin();
}
template <class D>
struct mincf {
  using P = pair<D, ll>;
  struct E {
    ll to, rev, cap;
    D cost;
  };
  ll n;
  vvc<E> g;
  vc<D> h, d;
  vi pv, pe;
  mincf(ll nn) : n(nn), g(n), h(n), d(n), pv(n), pe(n) {}
  pi ae(ll first, ll second, ll cap, D cost) {
    pi res(first, g[first].size());
    g[first].push_back({second, (ll)g[second].size(), cap, cost});
    g[second].push_back({first, (ll)g[first].size() - 1, 0, -cost});
    return res;
  }
  P go(ll s, ll t, ll f) {
    priority_queue<P, vc<P>, greater<P>> q;
    fill(d.begin(), d.end(), inf);
    d[s] = 0;
    q.push(P(0, s));
    while (q.size()) {
      D first;
      ll v;
      tie(first, v) = q.top();
      q.pop();
      if (d[v] < first) continue;
      if (v == t) break;
      for (ll i = ll(0); i < ll((ll)g[v].size()); i++) {
        E e = g[v][i];
        if (e.cap > 0) {
          D w = d[v] + e.cost + h[v] - h[e.to];
          if (w < d[e.to]) {
            d[e.to] = w;
            q.push(P(w, e.to));
            pv[e.to] = v;
            pe[e.to] = i;
          }
        }
      }
    }
    if (d[t] == inf) return P(0, 0);
    for (ll i = ll(0); i < ll(n); i++) h[i] = min(h[i] + min(d[i], d[t]), inf);
    ll first = f;
    for (ll v = t; v != s; v = pv[v]) chmin(first, g[pv[v]][pe[v]].cap);
    for (ll v = t; v != s; v = pv[v]) {
      E& e = g[pv[v]][pe[v]];
      e.cap -= first;
      g[e.to][e.rev].cap += first;
    }
    return P(first * h[t], first);
  }
  D calc(ll s, ll t, ll f) {
    D res = 0;
    while (f > 0) {
      P w = go(s, t, f);
      if (w.second == 0) return inf;
      f -= w.second;
      res += w.first;
    }
    return res;
  }
};
signed main() {
  cin.tie(0);
  ios::sync_with_stdio(0);
  cout << fixed << setprecision(20);
  ll n, m;
  cin >> n >> m;
  mincf<ll> mcf(n);
  for (ll i = ll(0); i < ll(m); i++) {
    ll first, second;
    cin >> first >> second;
    first--;
    second--;
    ll c;
    cin >> c;
    mcf.ae(first, second, 1, c);
  }
  vi x{0}, y{0};
  while (1) {
    ll first, second;
    tie(first, second) = mcf.go(0, n - 1, inf);
    if (second == 0) break;
    x.push_back(x.back() + second);
    y.push_back(y.back() + first);
  }
  using ld = long double;
  ll q;
  cin >> q;
  for (ll _ = ll(0); _ < ll(q); _++) {
    ll p;
    cin >> p;
    ll lw = 1, up = ll(x.size()) - 1;
    ld ans = inf;
    auto waf = [&](ll i) {
      ld w = ld(y[i] + p) / x[i];
      chmin(ans, w);
      return w;
    };
    while (up - lw > 3) {
      ll m1 = (lw + lw + up) / 3;
      ll m2 = (lw + up + up) / 3;
      if (waf(m1) < waf(m2))
        up = m2;
      else
        lw = m1;
    }
    for (ll i = ll(lw); i < ll(up + 1); i++) waf(i);
    cout << ans << endl;
  }
}