#include <iostream>
#include <vector>
#include <utility>
#include <queue>
#include <string>
#include <chrono>

auto start = std::chrono::system_clock::now();
auto msec() {
	auto end = std::chrono::system_clock::now();
	auto dur = end - start;
	auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(dur).count();
	return ms;
}

typedef std::pair<int, int> PII;
const int INF = 999999999;

std::vector<std::vector<int>> D;

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

	// adjacency list
	std::vector<std::vector<PII>> G(V);

	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[v].push_back({u, d});
	}

  	D.assign(V,std::vector<int>(V,INF));
	for(int i = 0; i < V; i++){
		std::vector<bool> flag(V);
		D[i][i] = 0;
		std::priority_queue<PII, std::vector<PII>, std::greater<PII> > que;
		que.push(PII(0,i));
		while(!que.empty()){
			PII p = que.top();
			que.pop();
			int v = p.second;
			if(D[i][v] < p.first){
				continue;
			}
			for(int j=0;j<G[v].size();j++){
				int e = G[v][j].first;
				if(D[i][e] > D[i][v] + G[v][j].second){
					D[i][e] = D[i][v] + G[v][j].second;
					que.push(PII(D[i][e],e));
				}
			}
		}
	}
	
	// recieve freqencies
	std::vector<int> freq(V);
	for(int i = 0; i < V; i++) std::cin >> freq[i];
	
	int Tmax; std::cin >> Tmax;
	long long score = 0;
	std::vector<int> orderFlag;
	std::vector<PII> ORDER;
  
	int nowNode = 0;
	int targetNode = 0;
	int remainDist = 0;
	int unloadedBaggageSum = 0;
	std::vector<int> unloadedBaggageCount(V,0);
	std::vector<int> loadedBaggageCount(V,0);
	std::vector<std::vector<int>> nodeToOrder(V);
	int loadMinOrder = 0;

	for(int t = 0; t < Tmax; t++) {

		// the number of new order
		int Nnew; std::cin >> Nnew;
		for(int j = 0; j < Nnew; j++) {
			int new_id, dst; std::cin >> new_id >> dst;
			dst--;
			orderFlag.push_back(0);
			ORDER.push_back({t, dst});
			unloadedBaggageSum++;
			unloadedBaggageCount[dst]++;
			nodeToOrder[dst].push_back(orderFlag.size()-1);
		}
	
		// the number of items transfered into the car at time t.
		int Nput; std::cin >> Nput;
		for(int j = 0; j < Nput; j++) {
			int put_id; std::cin >> put_id;
		}

		// insert your code here to get more meaningful output
		int ans = -1;
		if(remainDist == 0){
			nowNode = targetNode;
			if(nowNode == 0){
				for(int j = loadMinOrder; j < ORDER.size(); j++){
					if(orderFlag[j] == 0){
						orderFlag[j] = 1;
						unloadedBaggageCount[ORDER[j].second]--;
						loadedBaggageCount[ORDER[j].second]++;
					}
					unloadedBaggageSum = 0;
					loadMinOrder = ORDER.size();
				}
			} else {
				for(int j = 0; j < nodeToOrder[nowNode].size(); j++){
					int id = nodeToOrder[nowNode][j];
					if(orderFlag[id] == 1){
						score += Tmax * Tmax - (t - ORDER[id].first) * (t - ORDER[id].first);
						orderFlag[id] = 2;
						loadedBaggageCount[ORDER[id].second]--;
					} else if(orderFlag[id] == 0){
						break;
					}
				}
			}
			int mintarget = -1;
			int mincost = INF;
			for(int j = 1; j < V; j++){
				if(unloadedBaggageCount[j] > 0){
					int coe = 100;
					int cost = 10 * (D[nowNode][0]+D[0][j]) * coe / (coe + unloadedBaggageSum) / (unloadedBaggageCount[j] + loadedBaggageCount[j]);
					if(cost <= mincost){
						mintarget = 0;
						mincost = cost;
					}
				}
				if(loadedBaggageCount[j] > 0){
					int coe = 9;
					int cost = 10 * D[nowNode][j] * (coe + 2 * unloadedBaggageCount[j]) * (coe + 2 * unloadedBaggageCount[j]) / coe / coe / loadedBaggageCount[j];
					int cost2min = 999999999;
					int min2 = -1;
					for(int k = 1; k < V; k++){
  						if(j != k && loadedBaggageCount[k] > 0){
							int cost2 = 10 * D[j][k] * (coe + 2 * unloadedBaggageCount[k]) * (coe + 2 * unloadedBaggageCount[k]) / coe / coe / loadedBaggageCount[k];
							if(cost2 < cost2min){
								cost2min = cost2;
								min2 = k;
							}
						}
					}
					int cost3min = 999999999;
					int min3 = -1;
					for(int k = 1; k < V; k++){
  						if(j != min2 && j != k && min2 != k && loadedBaggageCount[k] > 0){
							int cost3 = 10 * D[min2][k] * (coe + 2 * unloadedBaggageCount[k]) * (coe + 2 * unloadedBaggageCount[k]) / coe / coe / loadedBaggageCount[k];
							if(cost3 < cost3min){
								cost3min = cost3;
								min3 = k;
							}
						}
					}
					cost += cost2min / 2 + cost3min / 8;
					if(cost < mincost){
						mintarget = j;
						mincost = cost;
					}
				}
			}
			if(mintarget == -1 && nowNode > 0){
				mintarget = 0;
			}
			int minNextCost = INF;
			if(mintarget >= 0){
				for(int j = 0; j < G[nowNode].size(); j++){
					if(D[G[nowNode][j].first][mintarget] < minNextCost){
						ans = G[nowNode][j].first + 1;
						targetNode = ans - 1;
						remainDist = G[nowNode][j].second - 1;
						minNextCost = D[G[nowNode][j].first][mintarget];
					}
				}
			}
		} else {
			ans = targetNode + 1;
			remainDist--;
		}
		// you have to output a command here
		std::cout << ans << std::endl;

		std::string verdict; std::cin >> verdict;
		if(verdict == "NG") {
			return 1;
		}

		// the number of orders that have been delivered at time t.
		int Nachive; std::cin >> Nachive;
		for(int j = 0; j < Nachive; j++) {
			int achive_id; std::cin >> achive_id;
		}
		
	}
	std::cerr << score << std::endl;
	std::cerr << score * 30 << std::endl;
	return 0;
}


Measured memory_bytes: 1876