#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 = 20;
	int atimer = timer;
	int NN = 3;
	int N = NN;

	for (int t = 0; t < Tmax;) {
		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 (order.empty()) {
			std::cout <<  -1 << std::endl;
			t++;
			continue;
		}
		int next_order = order.front();

		if(order.size() < NN && atimer > 0){
			atimer--;
			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>(order.size());
		std::copy(order.begin(),order.end(),copy_order.begin());
		std::sort(copy_order.begin(), copy_order.end());
		vector<int> shortest_order = vector<int>(order.size());

		vector<int> shortest_total_path = vector<int>();

		int shortest_dist = 999999999;
		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];
#ifdef DEBUG
					cout <<"dist:" << dist[to] << endl;
					for(int p =0;p<path.size();p++){
						cout << path[p] << " ";
					}
					cout << endl;
#endif
					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];
#ifdef DEBUG
					cout <<"dist:" << ldist[to] << endl;

					for(int p =0;p<path.size();p++){
						cout << path[p] << " ";
					}
					cout << endl;
#endif
					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];
#ifdef DEBUG
					cout <<"dist:" << dist[to] << endl;

					for(int p =0;p<path.size();p++){
						cout << path[p] << " ";
					}
					cout << endl;
#endif
					std::copy(path.begin() + 1,path.end(),std::back_inserter(total_path));
				}
			}
#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
		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] << " ";
														}
								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:";
		for(int i = 0;i < order.size();i++){
			cout << order[i] << " ";
		}
		cout << endl;
#endif

		//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);

		int pre_i = shortest_total_path[0];
//		if(next_order == 352){
//			for(int i =0;i<path.size();i++){
//				std::cout<<path[i] << " ";
//			}
//			std::cout << std::endl;
//		}
		for (int i = 0; i < shortest_total_path.size(); i++) {
			if (i != 0) {
				int w = gra[pre_i][shortest_total_path[i]].weight;
				//std::cout << "("<< gra[pre_i][path[i]].weight << ")";
				//std::cout << path[i] +1 ;
				for (int j = 0; j < w; j++) {
					std::cout <<  shortest_total_path[i]  +1 << std::endl;
					t++;
					if (t >= Tmax) {
						goto end;
					}
				}
			}
//		std::cout << path[i] << " ";
			pre_i = shortest_total_path[i];
		}
		//std::cout << std::endl;
//		std::reverse(path.begin(), path.end());
//		pre_i = path[0];
//		for (int i = 0; i < path.size(); i++) {
//			if (i != 0) {
//				//	std::cout << "("<< gra[pre_i][path[i]].weight << ")";
////					std::cout << path[i] << " ";
//				int w = gra[pre_i][path[i]].weight;
//				for (int j = 0; j < w; j++) {
//					std::cout << path[i] +1 << std::endl;
//					t++;
//					if (t >= Tmax) {
//						goto end;
//					}
//				}
//			}
//			pre_i = path[i];
//		}
//		std::cout << std::endl;
	}
	end:
//	std::cout << "end" << std::endl;

// insert your code here to get more meaningful output
// all stay
// for(int i = 0; i < Tmax; i++) std::cout << -1 << std::endl;

	return 0;
}


Measured memory_bytes: 384