#include <iostream>
#include <vector>
#include <utility>
#include <queue>
#include <algorithm>
#include <queue>
#include <unordered_map>

//#define DEBUG 1

typedef int Weight;
struct Edge {
	int src, dst;
	Weight weight;
	Edge() {
		this->src = -1;
		this->dst = -1;
		this->weight = -1;
		//	std::cout << "aaa" << std::endl;
	}
	;
	Edge(const Edge &obj) {
		//std::cout << "bbb" << std::endl;
		src = obj.src;
		dst = obj.dst;
		weight = obj.weight;
	}
	Edge(int src, int dst, Weight weight) :
			src(src), dst(dst), weight(weight) {
	}
};

bool operator <(const Edge &e, const Edge &f) {
	return e.weight != f.weight ? e.weight > f.weight : // !!INVERSE!!
			e.src != f.src ? e.src < f.src : e.dst < f.dst;
}

typedef std::unordered_map<int, Edge> Edges;
typedef std::vector<Edges> Graph;

typedef std::vector<Weight> Array;
typedef std::vector<Array> Matrix;
#define INF 10000

#define _GLIBCXX_DEBUG
#include <iostream>
#include <vector>

using namespace std;

#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()

void shortestPath(const Graph &g, int s, std::vector<Weight> &dist,
		std::vector<int> &prev) {
	int n = g.size();
	dist.assign(n, INF);
	dist[s] = 0;
	prev.assign(n, -1);
	std::priority_queue<Edge> Q; // "e < f" <=> "e.weight > f.weight"
	for (Q.push(Edge(-2, s, 0)); !Q.empty();) {
		Edge e = Q.top();
		Q.pop();
		if (prev[e.dst] != -1)
			continue;
		prev[e.dst] = e.src;
		//FOR(f, g[e. dst])
		for (__typeof((g[e.dst]).begin()) i = (g[e.dst]).begin();
				i != (g[e.dst]).end(); ++i) {
			Edge f = i->second;
			if (dist[f.dst] > e.weight + f.weight) {
				dist[f.dst] = e.weight + f.weight;
				Q.push(Edge(f.src, f.dst, e.weight + f.weight));
			}
		}
	}
}

std::vector<int> buildPath(const std::vector<int> &prev, int t) {
	std::vector<int> path;
	for (int u = t; u >= 0; u = prev[u])
		path.push_back(u);
	reverse(path.begin(), path.end());
	return path;
}

template<class BidirectionalIterator>
bool next_partial_permutation(BidirectionalIterator first,
		BidirectionalIterator middle, BidirectionalIterator last) {
	reverse(middle, last);
	return next_permutation(first, last);
}
template<class BidirectionalIterator>
bool prev_partial_permutation(BidirectionalIterator first,
		BidirectionalIterator middle, BidirectionalIterator last) {
	bool result = prev_permutation(first, last);
	reverse(middle, last);
	return result;
}

int main() {
	// recieve |V| and |E|
	int V, E;
	std::cin >> V >> E;
	std::vector<std::vector<std::pair<int, int> > > G(V);

	Graph gra = Graph(V);
	Edges edges = Edges();
	for (int i = 0; i < E; i++) {
		// recieve edges
		int u, v, d;
		std::cin >> u >> v >> d;
		u--;
		v--;
		//G[u].push_back({v,d});
		G[u].push_back(std::pair<int, int>(v, d));
		G[v].push_back(std::pair<int, int>(v, d));
		gra[u][v] = Edge(u, v, d);
		gra[v][u] = Edge(v, u, d);
	}

	//gra.push_back(edges);
	std::vector<Weight> dist = std::vector<Weight>();
	std::vector<int> prev = std::vector<int>();

//	std::cout << "start" << std::endl;
	//for(int i = 0 ; i < dist.size();i++){
	//		std::cout << "oh"<< dist[i];
	//}

	int Tmax;
	std::cin >> Tmax;
	std::deque<int> order;

	shortestPath(gra, 0, dist, prev);
	//for(int i =0;i<prev.size();i++){
	//	std::cout << prev[i]+1 << std::endl;
	//}
	// recieve info
	int timer = 100;
	int atimer = timer;
	int NN = 5;
	int N = NN;

	int status = 0;

	vector<int> shortest_order = vector<int>(order.size());
	vector<int> shortest_total_path = vector<int>();

	int remain_w = -1;
	int next_index = -1;
	int pre_node = -1;
	int shortest_dist = 999999999;
	for (int t = 0; t < Tmax; t++) {
		int Nnew;
		std::cin >> Nnew;
		for (int j = 0; j < Nnew; j++) {
			int new_id, dst;
			std::cin >> new_id >> dst;
			//std::cout << new_id << " "<<dst<< std::endl;
			order.push_back(dst);
		}

		if (status == 0) {
			if (order.empty()) {
				std::cout << -1 << std::endl;
				continue;
			}

			if (order.size() < NN && atimer > 0) {
				atimer--;
				std::cout << -1 << std::endl;
				continue;
			} else if (order.size() < NN && atimer <= 0) {
				atimer = timer;
				N = order.size();
			} else if (order.size() >= NN && atimer > 0) {
				N = NN;
				atimer = timer;
			}

#ifdef DEBUG
		cout << "N : " << N << endl;
		cout << "order:" << order.size() << endl;
#endif

			vector<int> copy_order = vector<int>(N);
			//std::copy(order.begin(), order.end(), copy_order.begin());
			std::copy(order.begin(), order.begin() + N, copy_order.begin());
			std::sort(copy_order.begin(), copy_order.end());

			do {
				vector<int> total_path = vector<int>();
				std::vector<Weight> ldist = std::vector<Weight>();
				std::vector<int> lprev = std::vector<int>();
				int total_dist = 0;
				for (int i = 0; i < N + 1; i++) {
					if (i == 0) {
						int to = copy_order[i] - 1;
						std::vector<int> path = buildPath(prev, to);
						total_dist += dist[to];
						std::copy(path.begin(), path.end(),
								std::back_inserter(total_path));
					} else if (i == N) {
						shortestPath(gra, copy_order[i - 1] - 1, ldist, lprev);
						int to = 0;
						std::vector<int> path = buildPath(lprev, to);
						total_dist += ldist[to];
						std::copy(path.begin() + 1, path.end(),
								std::back_inserter(total_path));
					} else {
						shortestPath(gra, copy_order[i - 1] - 1, ldist, lprev);
						int to = copy_order[i] - 1;
						std::vector<int> path = buildPath(lprev, to);
						total_dist += ldist[to];
						std::copy(path.begin() + 1, path.end(),
								std::back_inserter(total_path));
					}
//					if (total_dist > shortest_dist) {
//						cout << "break" << endl;
//						break;
//					}
				}
//#ifdef DEBUG
//			cout << "total_path:" ;
//						for(int i =0; i<total_path.size();i++){
//										cout << total_path[i] << " ";
//									}
//			cout << endl;
//#endif
//#ifdef DEBUG
//			cout<<endl;
//			cout << "total_dist:" <<total_dist << endl;
//#endif

				if (shortest_dist > total_dist) {
					shortest_dist = total_dist;
					shortest_total_path.clear();
					shortest_total_path.resize(total_path.size());
					std::copy(total_path.begin(), total_path.end(),
							shortest_total_path.begin());
				}
			} while (next_partial_permutation(copy_order.begin(),
					copy_order.begin() + N, copy_order.end()));

#ifdef DEBUG
			for (int i=0; i< copy_order.size();i++){
				cout << copy_order[i] << " ";
			}
			cout << endl;
			cout << "shortest_dist:" << shortest_dist << endl;
			cout << "shortest_total_path:";
			for (int i = 0; i < shortest_total_path.size(); i++) {
				cout << shortest_total_path[i] + 1 << " ";
			}
			cout << endl;
#endif
			for (int i = 0; i < shortest_total_path.size(); i++) {
				order.erase(
						remove(order.begin(), order.end(),
								shortest_total_path[i] + 1), order.end());
			}
#ifdef DEBUG
			cout <<"remain order size:" << order.size() << endl;
			cout << "remain order:";
			for (int i = 0; i < order.size(); i++) {
				cout << order[i] << " ";
			}
			cout << endl;
#endif
			status = 1;
			next_index = 0;
			pre_node = shortest_total_path[0];
			remain_w = -1;
		}
		if (status == 1) {
			//std::cout << next_order << "  " << std::endl; // 先頭要素を参照する
			//for(int i  =0;i<N;i++){
//			order.pop_front(); // 先頭要素を削除
			//	}

//		std::vector<int> path = buildPath(prev, next_order-1);

			if (remain_w <= 0) {
				pre_node = shortest_total_path[next_index];
				next_index++;
				remain_w =
						gra[pre_node][shortest_total_path[next_index]].weight;
			}
			std::cout << shortest_total_path[next_index] + 1 << std::endl;
			remain_w--;
			if (next_index == shortest_total_path.size() - 1 && remain_w <= 0) {
				status = 0;
				shortest_total_path.clear();
				shortest_dist = 999999999;
				remain_w = -1;
			}
		}
	}
	return 0;
}


Measured memory_bytes: 384