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

typedef long long LL;
typedef pair<int, int> PII;
typedef vector<int> VI;
#define MP make_pair
#define PB push_back
#define X first
#define Y second

#define FOR(i, a, b) for(int i = (a); i < (b); ++i)
#define RFOR(i, b, a) for(int i = (b) - 1; i >= (a); --i)
#define ITER(it, a) for(__typeof(a.begin()) it = a.begin(); it != a.end(); ++it)
#define ALL(a) a.begin(), a.end()
#define SZ(a) (int)((a).size())
#define FILL(a, value) memset(a, value, sizeof(a))
#define debug(a) cerr << #a << " = " << a << endl;

const double PI = acos(-1.0);
const LL INF = 1e9;
const LL LINF = INF * INF;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

inline int random(int l, int r)
{
	return l + rng() % (r - l + 1);
}

const int T = 10000;
int Tmax;
const int N = 400 + 7;
const int M = 800 + 7;
int p[N];
int find(int u)
{
	return p[u] = u == p[u] ? u : find(p[u]);
}
bool unite(int u , int v)
{
	u = find(u) , v = find(v);
	if(u != v)
	{
		p[v] = u;
		return true;
	}
	return false;
}
int n, m;
vector<PII> g[N];
pair<int, PII> edges[M];
PII order[T];
VI needed[N];
int dist[N][N];
int parent[N][N];
int G[N][N];
int number_of_orders_on_suf[T + 1];

inline int waiting_orders(int l, int r)
{
	r = min(r , T - 1);
	if (l > r) return 0;
	return number_of_orders_on_suf[r] - (l ? number_of_orders_on_suf[l - 1] : 0);
}

void graph_input()
{
	cin >> n >> m;
	FOR(i, 1, n + 1) FOR(j, 1, n + 1) G[i][j] = INF;
	FOR(i, 1, n + 1) G[i][i] = 0;
	
	FOR(i, 0, m)
	{
		int u, v, w;
		cin >> u >> v >> w;
		G[u][v] = G[v][u] = w;
		g[u].PB({v, w});
		g[v].PB({u, w});
		edges[i] = {w, {u, v}};
	}
}

void order_input()
{
	cin >> Tmax;
	FILL(order, -1);
	int de;
	int suma = 0;
	double maxCof = 0;
	FOR(i, 0, Tmax)
	{
		int t;
		cin >> t;
		suma += t;
		if(suma / (i + 1.) > maxCof)
		{
			maxCof = suma / (i + 1.0);
			de = i;
		}
		if (i)
			number_of_orders_on_suf[i] = number_of_orders_on_suf[i - 1];
		if (t == 0) continue;
		number_of_orders_on_suf[i]++;
		int id, dst;
		cin >> id >> dst;
		order[i] = {id, dst};
		needed[dst].PB(i);		
	}
	cerr << de << endl;
}

void preprocess()
{
	FOR(i, 1, n + 1)
	{
		FOR(j, 1, n + 1) dist[i][j] = INF;
		dist[i][i] = 0;
		set<PII> S;
		FOR(j, 1, n + 1)
			S.insert({dist[i][j], j});
		
		while(SZ(S))
		{
			int v = S.begin()->Y;
			S.erase(S.begin());
			
			for(auto e: g[v])
			{
				int to = e.X, len = e.Y;
				if (dist[i][to] <= dist[i][v] + len) continue;
				parent[i][to] = v;
				S.erase({dist[i][to], to});
				dist[i][to] = dist[i][v] + len;
				S.insert({dist[i][to], to});
			}
		}
	}
}

vector<int> path(int from, int to)
{
	vector<int> res;
	while(from != to)
	{
		res.PB(to);
		to = parent[from][to];
	}
	
	res.PB(from);
	reverse(ALL(res));
	return res;
}
double cof[N];

vector<int> go(vector<int>& orders, int start_time)
{
	int curr_vertex = 1;
	vector<int> res;
	const int Magic = 47;
	vector<int> ostov;
	ostov.PB(1);
	while(SZ(orders))
	{
		memset(cof , 0 , sizeof cof);
		for(auto ord : orders)
			cof[order[ord].Y]++;
		int to = -1;
		for(auto i: orders)
			if (to == -1 || dist[curr_vertex][to] / cof[to] > dist[curr_vertex][order[i].Y] / cof[order[i].Y])
				to = order[i].Y;
		
		ostov.PB(to);
		
		int curr_time = start_time + SZ(res);
		int nxt_time = start_time + SZ(res) + dist[curr_vertex][to];
		//cerr << curr_time << " " << nxt_time << '\n';
		if(curr_time < 9500 && nxt_time >= 9500 && curr_vertex != 1)
			to = 1;
		if (curr_vertex != 1 && 2 * dist[curr_vertex][to] > dist[curr_vertex][1] && SZ(res) >= Magic && curr_time < 9500)
			to = 1;
		
		vector<int> way = path(curr_vertex, to);
		FOR(i, 0, SZ(way) - 1)
			FOR(j, 0, G[way[i]][way[i + 1]])
				res.PB(way[i + 1]);
		
		curr_vertex = to;
		sort(ALL(way));
		vector<int> nxt;
		for(auto i: orders)
		{
			auto it = lower_bound(ALL(way), order[i].Y);
			if (it != way.end() && *it == order[i].Y) continue;
			nxt.PB(i);
		}
		
		orders = nxt;
		
		if (to == 1) break;
	}	
	
	vector<int> way = path(curr_vertex, 1);
	FOR(i, 0, SZ(way) - 1)
		FOR(j, 0, G[way[i]][way[i + 1]])
			res.PB(way[i + 1]);
	//int hujna = 0;
	
	//cerr << SZ(res) << " " << hujna << endl;
	return res;
}

int main()
{
	ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	
	graph_input();
	order_input();
	preprocess();
	
	vector<int> res;
	vector<int> orders;
	
	int Magic = 1;
	int chas = 0;
	while(chas < Tmax)
	{
		
		if (order[chas].X != -1)
			orders.PB(chas);
			
		if (SZ(orders) >= Magic)
		{
			auto tut = go(orders, chas);
			for(auto i: tut) res.PB(i);
			if (SZ(res) >= Tmax)
			{
				res.resize(Tmax);
				break;
			}
			
			FOR(i, 0, SZ(tut))
			{
				chas++;
				if (order[chas].X != -1) orders.PB(chas);
			}
			
			continue;
		}
		
		chas++;	
		res.PB(-1);
	}
	
	for(auto i: res) cout << i << endl;
	
	//cerr << "Time elapsed: " << clock() / (double)CLOCKS_PER_SEC << endl;
	return 0;
}


Measured memory_bytes: 2560