#include <bits/stdc++.h>

using namespace std;

int V, E, Q, C, capmx;
int sz[10005];
int lat[1005];
int exist[1005][10005];
vector < pair<int, int> > parent[1005];
vector < pair<int, int> > child[1005];
int h[10000005];
int inheap[10000005];
int heapsz;

int reqE[1005][10005];

struct request{
    int tot, pos;
}reqS[1005][10005];
int cap[1005];
vector <int> cache[1005];

int ALL;
struct thing{
    int save, server, video;
    bool rem;
}everyone[10000005];

void ascend(int pos){
    while(everyone[h[pos]].save > everyone[h[pos / 2]].save && pos != 1){
        swap(inheap[h[pos]], inheap[h[pos / 2]]);
        swap(h[pos], h[pos / 2]);
    }
}

void descend(int pos){
    while(pos <= heapsz){
        if(everyone[h[pos]].save < everyone[h[2 * pos]].save){
            swap(inheap[h[pos]], inheap[h[2 * pos]]);
            swap(h[pos], h[2 * pos]);
            pos *= 2;
        }else if(everyone[h[pos]].save < everyone[h[2 * pos + 1]].save){
            swap(inheap[h[pos]], inheap[h[2 * pos + 1]]);
            swap(h[pos], h[2 * pos + 1]);
            pos *= 2;
            pos++;
        }else{
            break;
        }
    }
}

void add(int pos){
    heapsz++;
    inheap[pos] = heapsz;
    h[heapsz] = pos;
    ascend(heapsz);
}

void rem(int pos){
    pos = inheap[pos];
    swap(inheap[h[pos]], inheap[h[heapsz]]);
    swap(h[pos], h[heapsz]);
    heapsz--;
    if(everyone[h[pos]].save > everyone[h[pos / 2]].save && pos != 1){
        ascend(pos);
    }else{
        descend(pos);
    }
}

bool comp(const thing &a, const thing &b){
    return a.save > b.save;
}

void solve(const int &node, const int &video){
    for(auto it : parent[node]){
        everyone[reqS[it.first][video].pos].save -= reqE[node][video] * (lat[node] - it.second);
        if(everyone[reqS[it.first][video].pos].save == 0 && everyone[reqS[it.first][video].pos].rem == 0){
            rem(reqS[it.first][video].pos);
            everyone[reqS[it.first][video].pos].rem = 1;
        }else{
            descend(inheap[reqS[it.first][video].pos]);
        }
    }
}

int main()
{
    ifstream fin("1.in");
    ofstream fout("home.out");
    fin>>V>>E>>Q>>C>>capmx;
    int i,j;
    for(i = 1;i <= V;i++){
        fin>>sz[i];
    }
    for(i = 1;i <= E;i++){
        fin>>lat[i];
        int c;
        fin>>c;
        for(j = 1;j <= c;j++){
            int t,l;
            fin>>t>>l;
            t++;
            parent[i].push_back({t, l});
            child[t].push_back({i, l});
        }
    }
    for(i = 1;i <= Q;i++){
        int rv,re,rn;
        fin>>rv>>re>>rn;
        re++;
        rv++;
        reqE[re][rv] += rn;
        for(auto it : parent[re]){
            reqS[it.first][rv].tot += rn * (lat[re] - it.second);
        }
    }
    for(i = 1;i <= C;i++){
        for(j = 1;j <= V;j++){
            if(reqS[i][j].tot){
                ++ALL;
                everyone[ALL].save = reqS[i][j].tot;
                everyone[ALL].server = i;
                everyone[ALL].video = j;
            }
        }
    }
    sort(everyone + 1, everyone + ALL + 1, comp);
    for(i = 1;i <= ALL;i++){
        reqS[everyone[i].server][everyone[i].video].pos = i;
        add(i);
    }
    for(i = 1;i <= ALL;i++){
        thing t;
        t = everyone[i];
        if(cap[t.server] + sz[t.video] <= capmx && exist[t.server][t.video] == 0 && t.save){
            exist[t.server][t.video] = 1;
            cap[t.server] += sz[t.video];
            cache[t.server].push_back(t.video);
            for(auto it : child[t.server]){
                solve(it.first, t.video);
            }
        }
    }
    int n = 0;
    for(i = 1;i <= C;i++){
        if(cache[i].size()){
            n++;
        }
    }
    fout<<n<<'\n';
    for(i = 1;i <= C;i++){
        if(cache[i].size()){
            fout<<i - 1<<' ';
            for(auto it : cache[i]){
                fout<<it - 1<<' ';
            }
            fout<<'\n';
        }
    }
    return 0;
}