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

class state{
public:
	int vi, eij, d;
	state(int _vi, int _eij, int _d) : vi(_vi), eij(_eij), d(_d) {};
};
class edge{
public:
	int cost;
	size_t from, to;
	edge(int c, size_t f, size_t t){
		cost = c;
		from = f;
		to = t;
	}
};
using edges = vector<edge>;
using graph = vector<edges>;
void readgraph(graph &g, size_t E, bool D, bool C, bool Z){ // E:num_of_edges, D:directed, C:costed, Z:already 0-indexed
	for(size_t i=0; i<E; ++i){
		edge e(1, 0, 0);
		if(!C) cin >> e.from >> e.to;
		else cin >> e.from >> e.to >> e.cost;
		if(!Z){
			--e.from;
			--e.to;
		}
		g[e.from].push_back(e);
		if(!D){
			swap(e.from, e.to);
			g[e.from].push_back(e);
		}
	}
}
bool operator<(const edge &e, const edge &f){
	return e.cost != f.cost ? e.cost > f.cost : e.from != f.from ? e.from < f.from : e.to < f.to;
}
void dijkstra(const graph &g, size_t s, vector<int> &dist){
	size_t V = g.size();
	dist = vector<int>(V, 1e8);
	dist[s] = 0;
	priority_queue<edge> q;
	q.push(edge(0, s, s));
	while(!q.empty()){
		edge e = q.top(); q.pop();
		if(dist[e.to] < e.cost) continue;
		for(const edge f:g[e.to]){
			if(dist[f.to] > dist[e.to] + f.cost){
				dist[f.to] = dist[e.to] + f.cost;
				q.push(edge(dist[f.to], s, f.to));
			}
		}
	}
}

int v, e, tmax;
graph g;
vector<vector<int>> d, h;
using P = pair<int, int>;
vector<P> info;
random_device rd;

void input(){
	cin >> v >> e;
	g.resize(v);
	readgraph(g, e, false, true, false);
	cin >> tmax;
	info.resize(tmax, P(-1, -1));
	for(int i=0; i<tmax; ++i){
		int nnew; cin >> nnew;
		if(nnew == 1){
			int id, dst; cin >> id >> dst; --dst;
			info[i] = P(id, dst);
		}
	}
}
void calc_h(){
	d.resize(v);
	for(int i=0; i<v; ++i) dijkstra(g, i, d[i]);
	h.resize(v, vector<int>(v, -1));
	for(int i=0; i<v; ++i)
		for(int j=0; j<v; ++j)
			for(size_t k=0; k<g[i].size(); ++k)
				if(h[i][j] == -1 || d[g[i][h[i][j]].to][j] > d[g[i][k].to][j])
					h[i][j] = k;
}
vector<int> solve_tsp(vector<int> &ord){
	vector<int> ret;
	for(int i=0; i<v; ++i)
		if(ord[i] == 1)
			ret.push_back(i);
	int ev = 0;
	ev = d[0][ret[0]];
	for(size_t i=0; i+1<ret.size(); ++i)
		ev += d[ret[i]][ret[i+1]];
	ev += d[ret.back()][0];
	for(int i=0; i<5000000; ++i){
		int x = rd() % ret.size();
		int y = x;
		while(y == x) y = rd() % ret.size();
		if(x > y) swap(x, y);
		int dev = 0;
		if(x == 0){
			dev += d[0][ret[y]] - d[0][ret[x]];
		}else{
			dev += d[ret[x-1]][ret[y]] - d[ret[x-1]][ret[x]];
		}
		if(y+1 == (int)ret.size()){
			dev += d[ret[y]][0] - d[ret[x]][0];
		}else{
			dev += d[ret[x]][ret[y+1]] - d[ret[y]][ret[y+1]];
		}
		if(x + 1 != y){
			dev += d[ret[y]][ret[x+1]] - d[ret[x]][ret[x+1]];
			dev += d[ret[x]][ret[y-1]] - d[ret[y]][ret[y-1]];
		}
		if(dev < 0) swap(ret[x], ret[y]);
	}
	ret.push_back(0);
	ord.clear();
	ord.resize(v);
	return ret;
}
void solve(){
	state s(0, 0, 0);
	int step = 0;
	vector<int> ord(v);
	for(; accumulate(ord.begin(), ord.end(), 0)<5 && step<tmax; ++step){
		if(info[step] != P(-1, -1)) ord[info[step].second] = 1;
		cout << -1 << "\n";
	}
	vector<int> route;
	int index = 0;
	for(; step<tmax; ++step){
		if(s.vi == 0 && s.d == 0 && index == (int)route.size()){
			route = solve_tsp(ord);
			index = 0;
		}
		if(s.d == 0) s.eij = h[s.vi][route[index]];
		cout << g[s.vi][s.eij].to + 1 << "\n";
		++s.d;
		if(s.d == g[s.vi][s.eij].cost){
			s.vi = g[s.vi][s.eij].to;
			s.eij = 0;
			s.d = 0;
			if(s.vi == route[index]) ++index;
		}
		if(info[step] != P(-1, -1)) ord[info[step].second] = 1;
	}
}

int main(){
	cin.tie(0);
	ios::sync_with_stdio(false);
	input();
	calc_h();
	solve();
}

Measured memory_bytes: 1792