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

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

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::queue<int> order;

	shortestPath(gra, 0, dist, prev);
	//for(int i =0;i<prev.size();i++){
	//	std::cout << prev[i]+1 << std::endl;
	//}
	// recieve info
	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(dst);
		}
		if (order.empty()) {
			std::cout <<  -1 << std::endl;
			t++;
			continue;
		}
		int next_order = order.front();

		//std::cout << next_order << "  " << std::endl; // 先頭要素を参照する
		order.pop(); // 先頭要素を削除
		std::vector<int> path = buildPath(prev, next_order-1);

		int pre_i = 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 < path.size(); i++) {
			if (i != 0) {
				int w = gra[pre_i][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 <<  path[i]  +1 << std::endl;
					t++;
					if (t >= Tmax) {
						goto end;
					}
				}
			}
//				std::cout << path[i] << " ";
			pre_i = 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