#include <bits/stdc++.h>
using namespace std;
const int MAXN = 220000;
const int MAXM = 1100000;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int INF2 = 0x3f3f3f3f;
int f[MAXN], pre[MAXN][32], dep[MAXN], siz[MAXN], son[MAXN], tid[MAXN],
    top[MAXN], val[MAXN], fid[MAXN];
int rnk[MAXN * 4];
int ql, qr, cntn, S, n, m;
long long totv;
struct Edge {
  int u, v, w, c, f, nxt, flag;
  bool operator<(const Edge &b) const { return w < b.w; }
} e[MAXM << 1];
int e_cnt;
int head[MAXN];
void Add(int u, int v, int f, int w, int c) {
  int id = ++e_cnt;
  e[id].u = u;
  e[id].v = v;
  e[id].w = w;
  e[id].c = c;
  e[id].f = f;
  e[id].nxt = head[u];
  head[u] = id;
}
int Find(int x) { return x == f[x] ? x : f[x] = Find(f[x]); }
void Kruskal() {
  for (int i = 1; i <= m; ++i) e[i].f = i;
  sort(e + 1, e + m + 1);
  for (int i = 1; i <= n; ++i) f[i] = i;
  for (int i = 1; i <= m; ++i) {
    int a = e[i].u, b = e[i].v;
    if (Find(a) != Find(b)) {
      f[Find(a)] = Find(b);
      e[i].flag = true;
      totv += e[i].w;
      Add(a, b, i, e[i].w, e[i].c);
      Add(b, a, i, e[i].w, e[i].c);
    }
  }
}
void Maintain(int o, int l, int r) {
  if (e[rnk[o * 2]].w > e[rnk[o * 2 + 1]].w)
    rnk[o] = rnk[o * 2];
  else
    rnk[o] = rnk[o * 2 + 1];
}
void Update(int o, int l, int r, int id) {
  if (ql <= l && r <= qr)
    rnk[o] = id;
  else {
    int mid = l + r >> 1;
    if (ql < mid) Update(o * 2, l, mid, id);
    if (qr > mid) Update(o * 2 + 1, mid, r, id);
  }
  if (r - l > 1) Maintain(o, l, r);
}
int Query(int o, int l, int r) {
  if (ql <= l && r <= qr)
    return rnk[o];
  else {
    int mid = l + r >> 1;
    int rnt1 = -1, rnt2 = -1;
    if (ql < mid) rnt1 = Query(o * 2, l, mid);
    if (qr > mid) rnt2 = Query(o * 2 + 1, mid, r);
    if (rnt1 == -1) return rnt2;
    if (rnt2 == -1) return rnt1;
    return e[rnt1].w > e[rnt2].w ? rnt1 : rnt2;
  }
}
void DFS1(int u, int fa) {
  pre[u][0] = fa;
  dep[u] = dep[fa] + 1;
  siz[u] = 1;
  for (int i = 1; i <= 30; i++) pre[u][i] = pre[pre[u][i - 1]][i - 1];
  for (int id = head[u]; ~id; id = e[id].nxt) {
    int v = e[id].v;
    if (v == fa) continue;
    DFS1(v, u);
    siz[u] += siz[v];
    val[v] = e[id].w;
    fid[v] = e[id].f;
    if (son[u] == -1 || siz[v] > siz[son[u]]) son[u] = v;
  }
}
void DFS2(int u, int fa) {
  top[u] = fa;
  tid[u] = ++cntn;
  ql = tid[u];
  qr = tid[u] + 1;
  Update(1, 1, n + 1, fid[u]);
  if (son[u] == -1) return;
  DFS2(son[u], fa);
  for (int id = head[u]; ~id; id = e[id].nxt) {
    int v = e[id].v;
    if (v != pre[u][0] && v != son[u]) DFS2(v, v);
  }
}
void LCA(int &a, int &b) {
  for (int i = 30; i >= 0; --i)
    if (dep[a] < dep[b] - (1 << i)) b = pre[b][i];
  if (pre[b][0] == a) {
    a = -1;
    return;
  }
  if (dep[a] != dep[b]) b = pre[b][0];
  for (int i = 30; i >= 0; --i) {
    if (pre[a][i] == pre[b][i]) continue;
    a = pre[a][i];
    b = pre[b][i];
  }
}
int FindM(int a, int b) {
  int fa = top[a];
  int rnt = -1;
  while (dep[fa] > dep[b]) {
    ql = tid[fa];
    qr = tid[a] + 1;
    int t = Query(1, 1, n + 1);
    if (rnt == -1)
      rnt = t;
    else
      rnt = e[rnt].w > e[t].w ? rnt : t;
    a = pre[fa][0];
    fa = top[a];
  }
  ql = tid[b];
  qr = tid[a] + 1;
  int t = Query(1, 1, n + 1);
  if (rnt == -1)
    rnt = t;
  else
    rnt = e[rnt].w > e[t].w ? rnt : t;
  return rnt;
}
void Solve() {
  long long ans = INF;
  int del = -1, pos = -1;
  for (int i = 1; i <= m; ++i) {
    if (e[i].flag) {
      long long k = totv - S / e[i].c;
      if (ans > k) ans = k, del = -1, pos = i;
    } else {
      int a = e[i].u, b = e[i].v;
      if (dep[a] > dep[b]) swap(a, b);
      int lca1 = a, lca2 = b;
      LCA(lca1, lca2);
      int t1, t2, t;
      if (lca1 != -1) t1 = FindM(a, lca1);
      t2 = FindM(b, lca2);
      if (lca1 == -1)
        t = t2;
      else
        t = e[t1].w > e[t2].w ? t1 : t2;
      long long k = totv - e[t].w + e[i].w - S / e[i].c;
      if (ans > k) ans = k, del = t, pos = i;
    }
  }
  printf("%lld\n", ans);
  for (int i = 1; i <= m; ++i) {
    if (del == i) continue;
    if (pos == i)
      printf("%d %d\n", e[i].f, e[i].w - S / e[i].c);
    else if (e[i].flag)
      printf("%d %d\n", e[i].f, e[i].w);
  }
}
int main() {
  memset(head, -1, sizeof(head));
  memset(son, -1, sizeof(son));
  scanf("%d%d", &n, &m);
  e_cnt = m;
  for (int i = 1; i <= m; ++i) scanf("%d", &e[i].w);
  for (int i = 1; i <= m; ++i) scanf("%d", &e[i].c);
  for (int i = 1; i <= m; ++i) scanf("%d%d", &e[i].u, &e[i].v);
  scanf("%d", &S);
  Kruskal();
  DFS1(1, 0);
  DFS2(1, 1);
  Solve();
  return 0;
}
