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

//#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()

typedef std::unordered_map<int,vector<int> > Dist_memo;
typedef std::unordered_map<int,vector<int> > Prev_memo;

Dist_memo dist_memo = Dist_memo();
Prev_memo prev_memo = Prev_memo();

void shortestPath(const Graph &g, int s, std::vector<Weight> &dist,
		std::vector<int> &prev) {
	  Dist_memo::iterator itr = dist_memo.find(s);
	  if( itr != dist_memo.end() ) {
		  vector<int> memo_dist = itr->second;
		  vector<int> memo_prev = prev_memo[s];
		  dist.resize(memo_dist.size());
		  prev.resize(memo_prev.size());
		  copy(memo_dist.begin(),memo_dist.end(),dist.begin());
		  copy(memo_prev.begin(),memo_prev.end(),prev.begin());
		  return;
	  };
	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));
			}
		}
	}
	vector<int> lp = vector<int>(prev.size());
	//copy(prev.begin(),prev.end(),lp.begin());
	prev_memo[s] = prev;
	dist_memo[s] = dist;
}

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;
}

struct second_order {
  bool operator()(const std::pair<int, int> & x, const std::pair<int, int>& y) const {
    return x.second < y.second;
  }
};

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 = 5;
	int atimer = timer;
	int NN = 7;
	int N = NN;

	int status = 0;

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

	int order_count = 0;
	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
		std::unordered_map<int, int> mValues = std::unordered_map<int,int>();
		for (std::deque<int>::iterator it = order.begin(); it != order.end(); ++it)
		    ++mValues[*it];
		std::priority_queue<std::pair<int, int>, std::vector<std::pair<int, int> >, second_order> que;
		for( std::unordered_map<int,int>::iterator itr = mValues.begin(); itr != mValues.end(); ++itr) {
		    que.push(*itr);
		}
#ifdef DEBUG
	cout << que.size() << endl;
#endif
	if (N > que.size()){
		N = que.size();
	}
	int counter = N;
	vector<int> copy_order = vector<int>(N);

	 for(int i = 0; i < counter ;i++) {
		pair<int,int> item = que.top();
	    copy_order[i] = item.first;
#ifdef DEBUG
	   std::cout << item.first << "(" << item.second << ")" << std::endl;
#endif
	    que.pop();
	  }


//		int n = N;
//			while(1){
//				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::set<int> test_set = std::set<int>(copy_order.begin(),copy_order.end());
//				if(N != test_set.size()){
//					cout << "set:" <<test_set.size() <<endl;
//					n++;
//				}else{
//					break;
//					copy_order = std::vector<int>(test_set.begin(),test_set.end());
//				}
//			}

			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 << " ";
			}
			int before_order = order.size();
			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] << " ";
			}
			order_count += before_order - order.size();
			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;
			}
		}
	}
#ifdef DEBUG
	cout << "order_count : " << order_count;
#endif
	return 0;
}


Measured memory_bytes: 1408