#貪欲法，フロイド・ワーシャルのとこだけかえたい
import time
import numpy as np
from scipy.sparse.csgraph import shortest_path, floyd_warshall, dijkstra, bellman_ford, johnson
from scipy.sparse import csr_matrix
#頂点数と辺数を取得
vertex_number, edge_number = map(int, input().split())
 
#隣接行列を作成 (辺がないところは 0，便宜上，(n+1)×(n+1)行列をつくっている)
 
A = [[0 for i in range(vertex_number+1)] for j in range(vertex_number+1)] #内包表記にしないと，一個の変更で複数のリストが変更されてしまうので注意
for i in range(edge_number):
    j,k,d = map(int, input().split())
    A[j][k] = d
    A[k][j] = d
    
 
#T_max と info を取得
T_max = int(input())
info = []
 
for i in range(T_max):
    x = int(input())
    if x == 0:
        info.append([x])
    else:
        y,z = map(int, input().split())
        info.append([x,y,z])
 
 
#最短距離行列Dを作成する
D = [[0 for i in range(vertex_number+1)] for j in range(vertex_number+1)] #最短距離行列

#最短距離行列の初期化
for i in range(vertex_number+1):
    for j in range(vertex_number+1):
        if (i != 0) and (j != 0): #iが0 または j が0のときは何もしない
            if i == j:             # i=j のときは 0
                D[i][j] = 0
            elif A[i][j] == 0:      #辺がないところは距離無限大
                D[i][j] = float("inf")
            else: D[i][j] = A[i][j] #辺があるところはその辺の長さ

D1,Prev = floyd_warshall(D,directed=False,return_predecessors=True)   #最短距離を求める(追記を参照)
for i in range(vertex_number+1):
    for j in range(vertex_number+1):
        if D1[i][j] != float("inf"):
            D[i][j] = int(D1[i][j])



def Shortest_path(i,j): #iからj への最短経路をリストとして出力
    SP = [j]
    x = Prev[i][j]
    while (x != i) and (x > 0):
        SP.insert(0,x)
        x = Prev[i][x]
    SP.insert(0,i)
    return SP
 

def Request(a,b): #時刻 a< t<=b の間に発生したリクエストの頂点をかぶりをなくして出力
    R = []
    if a == b: #a=b ならば [] を出力
        return R
    else:
        for i in range(b-a):
            if info[i+a+1] != [0]:
                if info[i+a+1][2] not in R:
                    R.append(info[i+a+1][2])
        return R
 
def Wt(a,b): #時刻 a< t<=b の間に発生したリクエストの時刻ti に対して，t-t_iを出力
    R = []
    WT = []
    if a == b: #a=b ならば [] を出力
        return WT
    else:
        for i in range(b-a):
            if info[i+a+1] != [0]:
                if info[i+a+1][2] not in R:
                    WT.append(b-(i+a+1))
                    R.append(info[i+a+1][2])
        return WT
#Algorithm (貪欲法)
 
t = 0
t_start = 0
Root = []
counter = 0
while t < T_max-1:
    Req = [] #おとづれたいactive vertex set
    if Request(t_start,t) == []: # いまもっているおとづれるべき頂点集合が空ならばリクエストが来るまで待つ
        while (info[t] == [0]) and (t != T_max - 1):
            t += 1
            Root.append(-1)
        if t != T_max - 1:
            Req.append(info[t][2])
 
    else:
        Req = Request(t_start,t)

    W = Wt(t_start,t)
    '''
    print("現在時刻",t)
    print("はじめのリクエスト数",len(Req))
    '''
    rp = []
    Reqq = Req.copy()
    WW = W.copy()
    if counter == 1:
        #real-path の途中に1があったらそのあとあらわれた頂点が，Req の中にあるなら, Req と W の対応する頂点を除去する
        for i in range(len(Req)):
            t_i = t - W[i]-t_start #1からReq[i] のリクエストがくるまでの時間
            for j in range(len(time_path)):
                if time_path[j] >= t_i:
                    rp = real_path[j:] #Req[i] のリクエストがあった時刻またはその直後におとずれた頂点からはじまるreal-path
                    break
            if (1 in rp) and (Req[i] in rp) and (rp.index(1) < rp.index(Req[i])):
                Reqq.remove(Req[i])
                WW.remove(W[i])
        Req = Reqq
        W = WW
    '''
    print("厳選後のリクエスト数",len(Req))
    '''
    t_start = t
    counter = 1
    if t != T_max - 1:
        
        t_path = 0       
        active_path = [1]
        real_path = []
        while Req != []:
            x = 0
            u = 0
            for i in range(len(Req)):
                if i == 0:
                    x = D[active_path[-1]][Req[0]]
                    u = Req[0]
                elif x > D[active_path[-1]][Req[i]]:
                    x = D[active_path[-1]][Req[i]]
                    u = Req[i]
            Req.remove(u)
            active_path.append(u)
            t_path += x
        t_path += D[active_path[-1]][1]
        active_path.append(1)
        t += t_path
 

        #active_pathからRootを作成
        for i in range(len(active_path)):
            if i == 0:
                real_path =real_path + Shortest_path(active_path[i],active_path[i+1])
            elif i != len(active_path)-1:
                real_path.pop(-1)
                real_path =real_path + Shortest_path(active_path[i],active_path[i+1])
        for j in range(len(real_path)):
            if j < len(real_path)-1:
                for k in range(A[real_path[j]][real_path[j+1]]):
                    Root.append(real_path[j+1])
         #real_pathからtime_path を構成
        time_path = []
        for i in range(len(real_path)):
            tt = 0
            if i == 0:
                time_path.append(0)
            else:
                tt += A[real_path[i-1]][real_path[i]]
                time_path.append(tt)
#Root から最終出力を生成

for i in range(T_max):
    if i < len(Root):
        print(Root[i])
    else:
        print(-1)


Measured memory_bytes: 33988