type yjs=record

           a:longint;

           s:int64;

          end;

 var f,q,g:array[..,..]of longint;

     head,vet,next,len,num,a,b,c,x,y,dep,fa,inq,ya,yb:array[..]of longint;

     hth,mst,s:int64;

     tot,n,m,i,del,k,tx,ty:longint;

     t:yjs;

 procedure swap(var x,y:longint);

 var t:longint;

 begin

  t:=x; x:=y; y:=t;

 end;

 procedure qsort(l,r:longint);

 var i,j,mid:longint;

 begin

  i:=l; j:=r; mid:=a[(l+r)>>];

  repeat

   while mid>a[i] do inc(i);

   while mid<a[j] do dec(j);

   if i<=j then

   begin

    swap(a[i],a[j]); swap(b[i],b[j]); swap(c[i],c[j]);

    swap(x[i],x[j]); swap(y[i],y[j]);

    inc(i); dec(j);

   end;

  until i>j;

  if l<j then qsort(l,j);

  if i<r then qsort(i,r);

 end;

 procedure add(a,b,c,d:longint);

 begin

  inc(tot);

  next[tot]:=head[a];

  vet[tot]:=b;

  len[tot]:=c;

  num[tot]:=d;

  head[a]:=tot;

 end;

 function lca(x,y:longint):longint;

 var i,d:longint;

 begin

  if dep[x]<dep[y] then swap(x,y);

  d:=dep[x]-dep[y];

  for i:= to  do

   if d and (<<i)> then x:=q[x,i];

  for i:= downto  do

   if q[x,i]<>q[y,i] then

   begin

    x:=q[x,i]; y:=q[y,i];

   end;

  if x=y then exit(x);

  exit(q[x,]);

 end;

 function clac(x,y:longint):yjs;

 var i,d:longint;

     cc:yjs;

 begin

  if dep[x]<dep[y] then swap(x,y);

  d:=dep[x]-dep[y];

  cc.a:=; cc.s:=-maxlongint;

  for i:= downto  do

   if d and (<<i)> then

   begin

    if f[x,i]>cc.s then

    begin

     cc.a:=g[x,i];

     cc.s:=f[x,i];

    end;

    x:=q[x,i];

   end;

  exit(cc);

 end;

 function ask(x,y:longint):yjs;

 var t:longint;

     t1,t2:yjs;

 begin

  t:=lca(x,y);

  t1:=clac(x,t);

  t2:=clac(y,t);

  if t1.s>t2.s then exit(t1);

  exit(t2);

 end;

 function find(k:longint):longint;

 begin

  if fa[k]<>k then fa[k]:=find(fa[k]);

  find:=fa[k];

 end;

 procedure dfs(u,pre:longint);

 var e,v,i:longint;

 begin

  for i:= to  do

  begin

   if dep[u]<(<<i) then break;

   q[u,i]:=q[q[u,i-],i-];

   if f[u,i-]<f[q[u,i-],i-] then

   begin

    f[u,i]:=f[q[u,i-],i-];

    g[u,i]:=g[q[u,i-],i-];

   end

    else

    begin

     f[u,i]:=f[u,i-];

     g[u,i]:=g[u,i-];

    end;

  end;

  e:=head[u];

  while e<> do

  begin

   v:=vet[e];

   if v<>pre then

   begin

    dep[v]:=dep[u]+;

    f[v,]:=len[e];

    q[v,]:=u;

    g[v,]:=num[e];

    dfs(v,u);

   end;

   e:=next[e];

  end;

 end;

 begin

  readln(n,m);

  for i:= to m do read(a[i]);

  for i:= to m do read(b[i]);

  for i:= to m do c[i]:=i;

  for i:= to m do readln(x[i],y[i]);

  readln(s);

  ya:=a; yb:=b;

  qsort(,m);

  for i:= to n do fa[i]:=i;

  for i:= to m do

  begin

   tx:=find(x[i]); ty:=find(y[i]);

   if tx<>ty then

   begin

    fa[ty]:=tx;

    hth:=hth+a[i];

    inq[c[i]]:=;

    add(x[i],y[i],a[i],c[i]);

    add(y[i],x[i],a[i],c[i]);

   end;

  end;

  dfs(,-);

  mst:=hth;

  for i:= to m do

   if inq[c[i]]= then

   begin

    if mst-s div b[i]<hth then

    begin

     hth:=mst-s div b[i];

     k:=c[i];

    end;

   end

    else

    begin

     t:=ask(x[i],y[i]);

     if mst-ya[t.a]+a[i]-s div b[i]<hth then

     begin

      hth:=mst-ya[t.a]+a[i]-s div b[i];

      k:=c[i];

      del:=t.a;

     end;

    end;

  writeln(hth);

  for i:= to m do

  begin

   if i=del then continue;

   if i=k then begin writeln(i,' ',ya[i]-s div yb[i]); continue; end;

   if inq[i]= then writeln(i,' ',ya[i]);

  end;

 end.