#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));
			}
		}
	}
}
class unionfind{ // 0-indexed
public:
	vector<int> parent;
	vector<size_t> size;
	size_t num_of_disjointsets;
	unionfind(size_t n){
		parent.resize(n, -1);
		size.resize(n, 1);
		num_of_disjointsets = n;
	}

	size_t find(size_t x){
		if(parent[x] == -1) return x;
		return parent[x] = find(parent[x]);
	}

	size_t unite(size_t x, size_t y){
		x = find(x);
		y = find(y);
		if(x == y) return -1;
		if(size[x] < size[y]){
			parent[x] = y;
			size[y] += size[x];
			size[x] = 0;
			--num_of_disjointsets;
			return y;
		}else{
			parent[y] = x;
			size[x] += size[y];
			size[y] = 0;
			return x;
			--num_of_disjointsets;
		}
	}

	bool united(size_t x, size_t y){
		return find(x) == find(y);
	}
};

int v, e, tmax, step, rest;
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);
			++rest;
		}
	}
}
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 || g[i][h[i][j]].cost + d[g[i][h[i][j]].to][j] > g[i][k].cost + d[g[i][k].to][j])
					h[i][j] = k;
}
void improve(vector<int> &ret, vector<vector<int>> &ord){
	if(ret.size() <= 1) return;
	vector<int> ta(ret.size());
	ta[0] = step + d[0][ret[0]];
	for(size_t i=1; i<ta.size(); ++i)
		ta[i] = ta[i-1] + d[ret[i-1]][ret[i]];
	long long score = 0;
	for(size_t i=0; i<ret.size(); ++i)
		for(size_t j=0; j<ord[ret[i]].size(); ++j)
			score += (long long)(ta[i] - ord[ret[i]][j]) * (ta[i] - ord[ret[i]][j]);
	score += (long long)(ta.back() + d[ret.back()][0] - step) * (tmax - step) * rest;
	for(int i=0; i<1300000; ++i){
		int x = rd() % ret.size();
		int y = x;
		while(y == x) y = rd() % ret.size();
		if(x > y) swap(x, y);
		swap(ret[x], ret[y]);
		vector<int> tb(ret.size());
		tb[0] = step + d[0][ret[0]];
		for(size_t j=1; j<ta.size(); ++j)
			tb[j] = tb[j-1] + d[ret[j-1]][ret[j]];
		long long nscore = 0;
		for(size_t j=0; j<ret.size(); ++j)
			for(size_t k=0; k<ord[ret[j]].size(); ++k)
				nscore += (long long)(tb[j] - ord[ret[j]][k]) * (tb[j] - ord[ret[j]][k]);
		nscore += (long long)(tb.back() + d[ret.back()][0] - step) * (tmax - step) * rest;
		if(score <= nscore) swap(ret[x], ret[y]);
		else{
			score = nscore;
			for(size_t j=0; j<ta.size(); ++j)
				ta[j] = tb[j];
		}
	}
}
void dfs(int p, graph &mst, vector<int> &ret, vector<int> &visited){
	if(visited[p] == 1) return;
	visited[p] = 1;
	for(auto e:mst[p])
		if(visited[e.to] == false){
			ret.push_back(e.to);
			dfs(e.to, mst, ret, visited);
		}
}
vector<int> solve_tsp(vector<vector<int>> &ord){
	ord[0].push_back(step);
	vector<int> ret;
	graph mst(v);
	priority_queue<edge> pq;
	for(int i=0; i<v-1; ++i)
		for(int j=i+1; j<v; ++j)
			if(!ord[i].empty() && !ord[j].empty())
				pq.push(edge(d[i][j], i, j));
	unionfind uf(v);
	while(!pq.empty()){
		edge e = pq.top(); pq.pop();
		if(!uf.united(e.from, e.to)){
			mst[e.from].push_back(e);
			swap(e.from, e.to);
			mst[e.from].push_back(e);
			uf.unite(e.from, e.to);
		}
	}
	vector<int> visited(v);
	dfs(0, mst, ret, visited);
	improve(ret, ord);
	ret.push_back(0);
	ord.clear();
	ord.resize(v);
	return ret;
}
void solve(){
	state s(0, 0, 0);
	vector<vector<int>> ord(v);
	for(; ord.empty() && step<tmax; ++step){
		if(info[step] != P(-1, -1)){
			ord[info[step].second].push_back(step);
			--rest;
		}
		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].push_back(step);
			--rest;
		}
	}
}

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

Measured memory_bytes: 9964