#include <bits/stdc++.h>
using namespace std;

constexpr int INF = INT_MAX;

struct edge{
    int from, to, d;
    edge(){}
    edge(int from, int to, int d):from(from),to(to),d(d){}
};

struct Graph{
    int V;
    vector<vector<edge> > g;
    vector<vector<int> > dist;
    void init(int _V){
        V = _V;
        g.resize(V);
    }
    void add_edge(int u, int v, int d){
        g[u].push_back(edge(u,v,d));
        g[v].push_back(edge(v,u,d));
    }
    void wf(){
        dist.resize(V, vector<int>(V, INF/3));
        for(auto &v : g){
            for(auto &e : v){
                int u = e.from, v = e.to, d = e.d;
                dist[u][v] = d;
                dist[v][u] = d;
            }
        }
        for(int i=0;i<V;i++){
            dist[i][i] = 0;
        }
        for(int k=0;k<V;k++){
            for(int i=0;i<V;i++){
                for(int j=0;j<V;j++){
                    dist[i][j] = min(dist[i][j], dist[i][k]+dist[k][j]);
                }
            }
        }
    }
    vector<edge> operator [](int i) {
        return g[i];
    }
};

double randFloat(double r){
    return double(rand())/RAND_MAX*r;
}

vector<int> build_path(vector<int> ls, const Graph &graph){
    vector<int> nn;
    
    // nn.push_back(0);
    // vector<bool> used(ls.size(),false);
    // for(int i=0;i<ls.size();i++){
    //     int dmin = INF, k = -1;
    //     for(int j=0;j<ls.size();j++){
    //         if(used[j]) continue;
    //         if(dmin > graph.dist[nn.back()][ls[j]]){
    //             dmin = graph.dist[nn.back()][ls[j]];
    //             k = j;
    //         }
    //     }
    //     nn.emplace_back(ls[k]);
    //     used[k] = true;
    // }
    // nn.emplace_back(0);

    nn = {0,0};
    for(auto x : ls){
        int dmin = INF, j = 1;
        for(int i=1;i<int(nn.size());i++){
            int tmp = graph.dist[nn[i-1]][x] + graph.dist[x][nn[i]] - graph.dist[nn[i-1]][nn[i]];
            if(tmp < dmin){
                j = i;
                dmin = tmp;
            }
        }
        nn.insert(nn.begin()+j,x);
    }
    
    vector<int> bestls = nn;
    int dif = 0, dmin = 0;

    for(int loopCount = 0; loopCount < 2000; loopCount++){
        for(int i=0;i<int(nn.size())-2;i++){
            for(int j=i+1;j<int(nn.size())-1;j++){
                int lhs = graph.dist[nn[i]][nn[i+1]] + graph.dist[nn[j]][nn[j+1]];
                int rhs = graph.dist[nn[i]][nn[j]] + graph.dist[nn[i+1]][nn[j+1]];
                if(lhs > rhs || exp(double(lhs-rhs)*2) > randFloat(1.0)){
                    dif += rhs-lhs; 
                    reverse(nn.begin()+i+1, nn.begin()+j+1);
                    if(dif < dmin){
                        dmin = dif;
                        bestls = nn;
                    }
                }
            }
        }
    }

    bestls.erase(bestls.begin());
    return bestls;
}

int main(void){
    int V, E, Tmax;
    // input
    cin >> V >> E;
    Graph graph;
    graph.init(V);
    for(int i=0;i<E;i++){
        int u, v, d;
        cin >> u >> v >> d;
        u--; v--;
        graph.add_edge(u,v,d);
    }
    cin >> Tmax;

    graph.wf();
    set<int> req;
    queue<int> reqque;
    vector<int> ls;
    vector<bool> remain(V);
    int now = 0, cnt = 0, nxt = 0;
    for(int t=0;t<Tmax;t++){
        int n;
        cin >> n;
        for(int i=0;i<n;i++){
            int id, dst;
            cin >> id >> dst;
            if(req.count(dst-1)==0){
                req.insert(dst-1);
                reqque.push(dst-1);
            }
        }
        if(now == 0){
            if(!reqque.empty()){
                vector<int> tmp;
                while(!reqque.empty()){
                    int dst = reqque.front();
                    if(!remain[dst]){
                        tmp.push_back(dst);
                        remain[dst] = true;
                    }
                    reqque.pop();
                }
                // ls.push_back(0);
                if(!tmp.empty()){
                    tmp = build_path(tmp, graph);
                    ls.insert(ls.end(), tmp.begin(), tmp.end());
                }
                remain[0] = true;
                req.clear();
            }
        }
        if(!ls.empty()){
            if(cnt == 0){
                int dst;
                while(!ls.empty()){
                    dst = ls.front();
                    if(remain[dst] && (now != dst)) break;
                    ls.erase(ls.begin());
                }
                for(auto &e : graph[now]){
                    if(now == e.to) continue;
                    if(graph.dist[now][e.to] + graph.dist[e.to][dst] == graph.dist[now][dst] && graph.dist[now][e.to] == e.d){
                        nxt = e.to;
                        cnt = e.d;
                        break;
                    }
                }
            }
            cout << nxt+1 << endl;
            now = -1;
            cnt--;
            if(cnt <= 0){
                now = nxt;
                remain[now] = false;
                while(!ls.empty() && now == ls.front()) ls.erase(ls.begin());
                // if(now == ls.front()) ls.erase(ls.begin());
            }
        }
        else{
            cout << -1 << endl;
        }
        // cout << now << " " << nxt << " " << cnt << " " << (ls.empty() ? -1 : ls.front()) << endl;
    }
    return 0;
}


Measured memory_bytes: 1152