#if not LOCAL
#define NDEBUG 1
#endif // LOCAL
#include<bits/stdc++.h>

const int maxV=200000;
const int logV=18;
const int maxE=200000;
const int inf=1000000009;

struct DSU {
private:
        std::vector<int> parent, rnk;
public:
        DSU(int n_vertex) {
                rnk.assign(n_vertex, 1);
                
                parent.resize(n_vertex);
                for (int i=0; i<n_vertex; ++i) parent[i]=i;
        }

        int findparent(int vertex) {
                return (parent[vertex]^vertex ? parent[vertex]=findparent(parent[vertex]): vertex);
        }

        bool unite_set(int v1, int v2) {
                v1=findparent(v1), v2=findparent(v2);
                
                if (v1==v2) return false;
                if (rnk[v1]<rnk[v2]) std::swap(v1, v2);
                parent[v2]=v1;
                if (rnk[v1]==rnk[v2]) ++rnk[v1];

                return true;
        }
};

struct Edge {
        int v1, v2, idx;
        int weight, cost;

        bool operator < (Edge const& other) const {
                return std::make_pair(weight, cost)<std::make_pair(other.weight, other.cost);
        }
};

std::vector< std::vector< std::pair<int, int> > > adjList;
std::vector<int> depth;
std::vector< std::vector<int> > up, max_weight;
std::vector<Edge> edges;

template<class X, class Y> void maximizeEW(X& a, Y b) {
        if (b==-1) return ;
        if (a==-1 or edges[a].weight<edges[b].weight) a=b;
}

/*int maxEW(int a, int b) {
        if (edges[a].weight>edges[b].weight) return a;
        return b;
}*/

void travel(int vertex) {
        for (auto& v: adjList[vertex]) {
                if (v.first!=up[vertex][0]) {
                        depth[v.first]=depth[vertex]+1;
                        up[v.first][0]=vertex;
                        max_weight[v.first][0]=v.second;

                        for (int i=1; i<logV; ++i) {
                                max_weight[v.first][i]=max_weight[v.first][i-1];

                                int up_v=up[v.first][i-1];
                                if (up_v!=-1) {
                                        up[v.first][i]=up[up_v][i-1];
                                        maximizeEW(max_weight[v.first][i], max_weight[up_v][i-1]);
                                }
                        }

                        travel(v.first);
                }
        }
}

int get_weight(int v1, int v2) {
        if (depth[v1]>depth[v2]) std::swap(v1, v2);

        int ret=0;
        for (int i=logV-1; i>=0; --i) {
                if (depth[v2]-depth[v1]>=(1<<i)) {
                        maximizeEW(ret, max_weight[v2][i]);
                        v2=up[v2][i];
                }
        }

        if (v1==v2) return ret;

        for (int i=logV-1; i>=0; --i) {
                if (up[v1][i]!=up[v2][i]) {
                        maximizeEW(ret, max_weight[v1][i]), maximizeEW(ret, max_weight[v2][i]);
                        v1=up[v1][i], v2=up[v2][i];
                }
        }

        maximizeEW(ret, max_weight[v1][0]), maximizeEW(ret, max_weight[v2][0]);

        return ret;
}

template<class X, class Y, class Z, class T, class M, class N> void minimize(X& a, Y b, Z& c, T d, M& e, N f) {
        if (a>b) a=b, c=d, e=f;
}


int main() {
        std::ios_base::sync_with_stdio(0); std::cin.tie(0);

        int n_vertex, n_edge; std::cin>>n_vertex>>n_edge;

        edges.resize(n_edge);
        for (int i=0; i<n_edge; ++i) edges[i].idx=i;
        for (auto& e: edges) std::cin>>e.weight;
        for (auto& e: edges) std::cin>>e.cost;
        for (auto& e: edges) {
                std::cin>>e.v1>>e.v2;
                --e.v1, --e.v2;
        }

        int total_cost; std::cin>>total_cost;

        std::sort(edges.begin(), edges.end());

        DSU dsu(n_vertex);
        adjList.resize(n_vertex);
        std::vector<bool> selected(n_edge, false);

        int64_t total_weight=0;
        for (int i=0; i<n_edge; ++i) {
                auto& e=edges[i];
                if (dsu.unite_set(e.v1, e.v2)) {
                        //std::cout<<1+e.idx<<"  "<<1+e.v1<<" "<<1+e.v2<<" "<<e.weight<<"\n";
                        total_weight+=e.weight;
                        selected[e.idx]=true;

                        adjList[e.v1].emplace_back(e.v2, i);
                        adjList[e.v2].emplace_back(e.v1, i);
                } 
        }

        up.assign(n_vertex, std::vector<int>(logV, -1));
        max_weight.assign(n_vertex, std::vector<int>(logV, -1));
        depth.resize(n_vertex); depth[0]=0;
        travel(0);

        int64_t result=total_weight;
        int chosen_edge=-1, removed_edge=-1;
        for (auto& e: edges) {
                if (selected[e.idx]) {
                        minimize(result, total_weight-total_cost/e.cost, chosen_edge, e.idx, removed_edge, -1);
                }
                else {
                        int max_edge=get_weight(e.v1, e.v2);
                        if (max_edge!=-1) minimize(result, total_weight-edges[max_edge].weight+e.weight-total_cost/e.cost, chosen_edge, e.idx, removed_edge, edges[max_edge].idx);
                }
        }

        if (removed_edge!=-1) {
                selected[removed_edge]=false;
                selected[chosen_edge]=true;
        }
        std::cout<<result<<"\n";
        for (auto& e: edges) {
                if (selected[e.idx]) {
                        if (e.idx==chosen_edge) e.weight-=total_cost/e.cost;
                        std::cout<<1+e.idx<<" "<<e.weight<<"\n";
                }
        }

        return 0;
}
