#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 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];

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);
	FOR(i, 0, Tmax)
	{
		int t;
		cin >> t;
		if (t == 0) continue;
		int id, dst;
		cin >> id >> dst;
		order[i] = {id, dst};
		needed[dst].PB(i);		
	}
}

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

vector<int> go(vector<int> orders)
{
	int curr_vertex = 1;
	vector<int> res;
	
	while(SZ(orders))
	{
		int to = -1;
		for(auto i: orders)
			if (to == -1 || dist[curr_vertex][to] > dist[curr_vertex][order[i].Y])
				to = order[i].Y;
				
		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;
	}	
	
	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]);
	
	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);
			for(auto i: tut) res.PB(i);
			if (SZ(res) >= Tmax)
			{
				res.resize(Tmax);
				break;
			}
			
			orders.clear();
			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