#include <bits/stdc++.h>
using namespace std;

#define rep(i,n) for(int i=0;i<n;i++)
#define REP(i,a,n) for(int i=a;i<n;i++)

typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef tuple<int,int,int> tiii;

const int INF=1<<25;
const ll LINF = 1e18+5;

const int MAX_V = 625;
int uf_par[MAX_V]; // parents
int uf_rank[MAX_V]; // depth of tree

void uf_init(int n) {
    rep(i,n) {
        uf_par[i] = i;
        uf_rank[i] = 0;
    }
}

int uf_find(int x) {
    if (uf_par[x] == x) {
        return x;
    } else {
        return uf_par[x] = uf_find(uf_par[x]);
    }
}

void uf_unite(int x, int y) {
    x = uf_find(x);
    y = uf_find(y);
    if (x==y) return;
    if (uf_rank[x] < uf_rank[y]) {
        uf_par[x] = y;
    } else {
        uf_par[y] = x;
        if (uf_rank[x] == uf_rank[y]) uf_rank[x]++;
    }
}

bool uf_same(int x, int y) {
    return uf_find(x) == uf_find(y);
}

bool pairCompare(const tiii& Fir, const tiii& Sec)
{
    return get<0>(Fir) < get<0>(Sec); // 1番目について昇順
}

vector<vector<int>> fl_G(MAX_V);
bool fl_visited[MAX_V];
int fl_V, fl_E; 

void fl_initBridge() {
    rep(i, fl_V) {
		fl_visited[i] = false;
		// もし孤立点ならvisitedにtrue
		if (fl_G[i].size() == 0) fl_visited[i] = true;
	}
}

void fl_dfs(int v, int s, int t) {
    bool used_path = false;
    fl_visited[v] = true;
    if (v == t) swap(s, t);
    rep(i, fl_G[v].size()) {
        if (v==s && fl_G[v][i] == t && !used_path) {
            used_path = true;
            continue;
        }
        if (!fl_visited[fl_G[v][i]]) {
            fl_dfs(fl_G[v][i], s, t);
        }
    }
}

// uからvへのpathが橋かどうか
bool fl_isBridge(int u, int v) {
    fl_initBridge();
    fl_dfs(u, u, v);
    rep(i, fl_V) {
        if (!fl_visited[i]) return true;
    }
    return false;
}

// オイラー小道を探す
vector<int> fl_eulerCircuit() {
    vector<int> fl_ans;
    fl_ans.push_back(0);
    int e = fl_E, v = 0;
    while (e > 0) {
        bool flag = false;
		
        rep(i, fl_G[v].size()) {
            if (!fl_isBridge(v, fl_G[v][i])) {
                flag = true;
                int u = fl_G[v][i];
                fl_G[v].erase(fl_G[v].begin() + i);
                for (int j = 0; j < fl_G[u].size(); j++) {
                    if (fl_G[u][j] == v) {
                        // 消すのは一個だけ！(反対側)
                        fl_G[u].erase(fl_G[u].begin() + j);
                        break;
                    }
                } 
                v = u;
                e--;
                break;
            }
        }
        if (!flag) {
            // 橋しか見つからなかった
            int u = fl_G[v][0];
            fl_G[v].erase(fl_G[v].begin());
            for (int i = 0; i < fl_G[u].size(); i++) {
                if (fl_G[u][i] == v) {
                    // 消すのは1個(反対側)
                    fl_G[u].erase(fl_G[u].begin() + i);
                    break;
                }
            }
            v = u;
            e--;
        }
        fl_ans.push_back(v);
		
    }
    return fl_ans;
}

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

	// distance between V
	int dist[400][400];
	// next[i][j] : next point from i
	int next[400][400];

	// adjacency list
	vector<vector<pii>> G(V);

	rep(i, E) {
		// recieve edges
		int u, v, d; 
		cin >> u >> v >> d;
		u--; v--;
		G[u].push_back({v, d});
		G[v].push_back({u, d});
	}
	
	// recieve freqencies
	vector<int> freq(V);
	rep(i, V) cin >> freq[i];
	
	int Tmax;
	cin >> Tmax;

	rep(i,V) {
		rep(j,V) {
			dist[i][j] = INF;
			next[i][j] = j;
			if (i==j) dist[i][j] = 0;
		}
	}
	rep(i,V) {
		for(const auto& g: G[i]) {
			dist[i][g.first] = g.second;
		}
	}

	rep(k,V) {
		rep(i,V) {
			rep(j,V) {
				if (dist[i][j] > dist[i][k] + dist[k][j]) {
					dist[i][j] = dist[i][k] + dist[k][j];
					next[i][j] = next[i][k];
				}
			}
		}
	}

	// 配達を出かけるまでにあるIDたち
	vector<pii> IDs;

	// 配達に出かけているときの順番
	// 先頭から取り出す(一応list使ってる)
	list<int> TSP_2_opt;

	// 次行く道
	list<int> routes;

	// 次の頂点までにかかる時間
	int res_route = 0;

	// 今配達中かどうか
	bool is_deliverying = false;

	int pos = 0; // はじめ1に居る

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

		// the number of new order
		int Nnew;
		cin >> Nnew;
		for(int j = 0; j < Nnew; j++) {
			int new_id, dst; 
			cin >> new_id >> dst;
			IDs.push_back({new_id, dst-1});
		}
	
		// the number of items transfered into the car at time t.
		int Nput; 
		cin >> Nput;
		for(int j = 0; j < Nput; j++) {
			int put_id; 
			cin >> put_id;
			// doudemoii (tabun)
		}

		if (pos == 0 && IDs.size() != 0 && !is_deliverying) {
			// 配達に出かける
			// （今のところ)溜まってる注文を全部お届けに参る
			// IDsのサイズが0なら待機
			// 使う辺は店＋届ける頂点の全結合
			int destinations[MAX_V];
			destinations[0] = 1;
			for(const auto& id : IDs) {
				destinations[id.second] = 1;
			}
			IDs.clear();
			// iとjの距離, i, j
			vector<tiii> edges;
			rep(i, MAX_V) {
				if (destinations[i] == 0) continue;
				REP(j, i+1, MAX_V) {
					if (destinations[j]) {
						edges.push_back(tiii(dist[i][j], i, j));
					}
				}
			}
			
			// クラスカル法で最小全域木を作る
			// iとjの距離, i, j
			vector<tiii> MSP; // minimum spanning tree
			sort(edges.begin(), edges.end(), pairCompare);
			uf_init(MAX_V);
			rep(i, edges.size()) {
				tiii e = edges[i];
				if (!uf_same(get<1>(e), get<2>(e))) {
					uf_unite(get<1>(e), get<2>(e));
					MSP.push_back(e);
					MSP.push_back(tiii(get<0>(e), get<2>(e), get<1>(e)));
				}
			}

			for(auto& g : fl_G) g.clear();
			// オイラー小道を見つける
			fl_E = 0;
			fl_V = V;
			for(auto& m : MSP) {
				// 二重に入力
				fl_G[get<1>(m)].push_back(get<2>(m));
				fl_G[get<1>(m)].push_back(get<2>(m));
				fl_E++;
			}
			vector<int> MSP_euler_circuit = fl_eulerCircuit();

			// オイラー小道をショートカット（2近似)
			bool MSP_isvisited[MAX_V] = {};
			TSP_2_opt.clear();
			for(auto& m : MSP_euler_circuit) {
				if (!MSP_isvisited[m]){
					TSP_2_opt.push_back(m);
					MSP_isvisited[m] = true;
				}
			}
			// 最後店に戻る
			TSP_2_opt.push_back(0);
			is_deliverying = true;
		}

		// 配達中なら動く
		if (is_deliverying) {
			if (res_route == 0) {
				if (pos == TSP_2_opt.front()){
					// 目的地の頂点に到着
					// ワーシャルフロイドの経路復元を行い，routeに格納
					routes.clear();
					int start = TSP_2_opt.front();
					TSP_2_opt.pop_front();
					
					int end = TSP_2_opt.front();
					for(int cur = start; cur != end; cur = next[cur][end]){
						routes.push_back(cur);
					}
					routes.push_back(end);
				}
				routes.pop_front();
				res_route = dist[pos][routes.front()];
			}
			cout << routes.front() + 1 << endl;
			res_route--;
			// いまいる座標を更新
			if (res_route == 0) {
				pos = routes.front();
			}
		} else {
			cout << -1 << endl; // stay
		}
		// 最後までたどり着いた
		if (is_deliverying && pos ==0 && res_route == 0 && TSP_2_opt.size() == 1) {
			is_deliverying = false;
		}


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

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


Measured memory_bytes: 4976