#include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for (int i=0;i<(n);i++)
#define REP2(i,m,n) for (int i=m;i<(n);i++)
typedef long long ll;

const int INF = 1 << 29;

int N, M, Tmax;
int G[400][400];
int order_dest[10000];
int dist[400][400];

int current_dest = 0, remaining_dist = 0, latest_order = -1;
int command[10000];

bool is_at_store() {
    return current_dest == 0 && remaining_dist == 0;
}

void search() {
    vector<int> dests;
    REP(t, Tmax) {

        if (remaining_dist > 0) {
            command[t] = current_dest;
            remaining_dist -= 1;
        }

        if (remaining_dist > 0) {
            continue;
        }

        if (is_at_store()) {
            for (int i = 0; i < dests.size(); ) {
                if (dests[i] == 0) {
                    swap(dests[i], dests[(int)dests.size()-1]);
                    dests.pop_back();
                } else {
                    i += 1;
                }
            }
            while (latest_order < t) {
                latest_order += 1;
                if (order_dest[latest_order] != 0) {
                    dests.push_back(order_dest[latest_order]);
                }
            }
        }

        if (is_at_store() && dests.empty())  {
            command[t] = -1;
            continue;
        }

        for (int i = 0; i < dests.size(); ) {
            if (dests[i] == current_dest) {
                swap(dests[i], dests[(int)dests.size()-1]);
                dests.pop_back();
            } else {
                i += 1;
            }
        }

        if (dests.empty()) {
            dests.push_back(0);
        }

        int mdest = -1;
        int mdist = INF;

        for (auto dest: dests) {
            int d = dist[current_dest][dest];
            if (d < mdist) {
                mdist = d;
                mdest = dest;
            }
        }

        int mdest2 = -1;
        int mdist2 = INF;

        REP(i, N) if (i != current_dest && G[current_dest][i] != INF) {
            int d = G[current_dest][i] + dist[i][mdest];
            if (d < mdist2) {
                mdist2 = d;
                mdest2 = i;
            }
        }

        command[t] = mdest2;
        remaining_dist = G[current_dest][mdest2];
        current_dest = mdest2;
    }
}

void warshall_floyd() {
    REP(i, N) REP(j, N) {
        dist[i][j] = G[i][j];
    }
    REP(i, N) REP(j, N) REP(k, N) {
        dist[j][k] = min(dist[j][k], dist[j][i] + dist[i][k]);
    }
}

void input() {
    cin >> N >> M;
    REP(i, N) REP(j, N) {
        G[i][j] = i == j ? 0 : INF;
    }
    REP(i, M) {
        int u, v, d;
        cin >> u >> v >> d;
        --u, --v;
        G[u][v] = d;
        G[v][u] = d;
    }
    cin >> Tmax;
    REP(i, Tmax) {
        int n; cin >> n;
        if (n == 1) {
            cin >> n >> order_dest[i];
            order_dest[i] -= 1;
            //cerr << order_dest[i] << endl;
        }
    }
}

void output() {
    REP(t, Tmax) {
        cout << (command[t] == -1 ? command[t] : command[t] + 1) << "\n";
    }
}

int main() {
    input();
    warshall_floyd();
    search();
    output();
}