#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200500;
const int LOG = 21;
struct Edge {
  long long a, b;
  long long index, w, c;
};
Edge edge[MAXN];
bool used[MAXN];
int p[MAXN], rk[MAXN], tin[MAXN], inv[MAXN], tout[MAXN], par[MAXN];
int jump[MAXN][LOG];
pair<int, int> dp[MAXN][LOG];
int n, m, timer;
long long S;
vector<vector<Edge> > g;
void dfs(int v, int parent, int waist, int index) {
  tin[v] = timer++;
  par[v] = parent == -1 ? v : parent;
  jump[v][0] = par[v];
  dp[v][0] = make_pair(waist, index);
  for (int i = 0; i < (int)(LOG - 1); ++i) {
    jump[v][i + 1] = jump[jump[v][i]][i];
    dp[v][i + 1] = max(dp[v][i], dp[jump[v][i]][i]);
  }
  for (int i = 0; i < (int)(g[v].size()); ++i) {
    int u = g[v][i].a ^ g[v][i].b ^ v;
    if (u != parent) dfs(u, v, g[v][i].w, g[v][i].index);
  }
  tout[v] = timer++;
}
int leader(int v) { return p[v] == v ? v : p[v] = leader(p[v]); }
void Union(int a, int b) {
  a = leader(a);
  b = leader(b);
  if (rk[a] > rk[b]) swap(a, b);
  if (rk[a] == rk[b]) rk[b]++;
  p[a] = b;
}
bool cmp(Edge a, Edge b) { return a.w < b.w; }
bool is_ancestor(int a, int b) {
  return tin[a] <= tin[b] && tout[b] <= tout[a];
}
int check(Edge e) {
  int u = e.a;
  int v = e.b;
  pair<int, int> res = make_pair(-1, -1);
  for (int len = LOG - 1; len >= 0; len--) {
    if (!is_ancestor(jump[v][len], u)) {
      res = max(dp[v][len], res);
      v = jump[v][len];
    }
  }
  if (!is_ancestor(v, u)) {
    res = max(dp[v][0], res);
    v = jump[v][0];
  }
  for (int len = LOG - 1; len >= 0; len--) {
    if (is_ancestor(v, jump[u][len])) {
      res = max(dp[u][len], res);
      u = jump[u][len];
    }
  }
  if (v != u) {
    res = max(dp[u][0], res);
    u = jump[u][0];
  }
  assert(v == u);
  return res.second;
}
int main() {
  cin >> n >> m;
  g.resize(n);
  for (int i = 0; i < (int)(m); ++i) cin >> edge[i].w;
  for (int i = 0; i < (int)(m); ++i) cin >> edge[i].c;
  for (int i = 0; i < (int)(m); ++i) cin >> edge[i].a >> edge[i].b;
  for (int i = 0; i < (int)(m); ++i)
    edge[i].index = i + 1, edge[i].a--, edge[i].b--;
  cin >> S;
  sort(edge, edge + m, cmp);
  for (int i = 0; i < (int)(m); ++i) inv[edge[i].index] = i;
  for (int i = 0; i < (int)(n); ++i) p[i] = i, rk[i] = 0;
  long long min_ind = -1;
  long long glob_res = 0;
  for (int i = 0; i < (int)(m); ++i) {
    if (leader(edge[i].a) != leader(edge[i].b)) {
      Union(edge[i].a, edge[i].b);
      used[i] = true;
      g[edge[i].a].push_back(edge[i]);
      g[edge[i].b].push_back(edge[i]);
      glob_res += edge[i].w;
      if (min_ind == -1 || edge[i].c < edge[min_ind].c) min_ind = i;
    }
  }
  long long res = glob_res - S / edge[min_ind].c;
  dfs(0, -1, -1, -1);
  int del_ind;
  bool upd = false;
  for (int i = 0; i < (int)(m); ++i) {
    if (!used[i]) {
      int cur_del_ind = inv[check(edge[i])];
      long long cur_res =
          glob_res + edge[i].w - S / edge[i].c - edge[cur_del_ind].w;
      if (cur_res < res) {
        upd = true;
        res = cur_res;
        del_ind = cur_del_ind;
        min_ind = i;
      }
    }
  }
  cout << res << '\n';
  if (!upd) {
    for (int i = 0; i < (int)(m); ++i) {
      if (used[i]) {
        cout << edge[i].index << ' ';
        if (i != min_ind)
          cout << edge[i].w;
        else
          cout << edge[i].w - S / edge[i].c;
        cout << '\n';
      }
    }
  } else {
    for (int i = 0; i < (int)(m); ++i) {
      if ((used[i] && del_ind != i) || min_ind == i) {
        cout << edge[i].index << ' ';
        if (i != min_ind)
          cout << edge[i].w;
        else
          cout << edge[i].w - S / edge[i].c;
        cout << '\n';
      }
    }
  }
  return 0;
}
