using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.IO;

namespace AtCoder
{
    public class State
    {
        public long time;

        public long tlast;

        public long tmax;
    }

    public class MainClass
    {
        public static void Main(string[] args)
        {
            checked
            {
                try
                {
                    var first = new FirstInput();
                    var graph = BuildGraph(first);
                    var state = new State()
                    {
                        tmax = first.Tmax,
                        tlast = (long)((double)first.Tmax * 0.95),
                    };

                    var orders = new List<Order>(); //注文
                    var carringOdrs = new List<Order>(); //配送中の注文

                    for (int t = 0; t < first.Tmax; t++)
                    {
                        var orderIn = new OrdersInput(t);
                        if (orderIn.order != null) orders.Add(orderIn.order);
                        carringOdrs.AddRange(orders.Where(o => orderIn.puts.Contains(o.id)));

                        state.time = t;

                        Console.WriteLine(Drive(graph, carringOdrs, state));

                        var verdict = new VerdictInput();
                        if (verdict.verdict != "OK") break;

                        carringOdrs.RemoveAll(o => verdict.archives.Contains(o.id));
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }
            }
        }

        ///<summary>ルート</summary>
        private static Queue<int> route = null;

        ///<summary>車</summary>
        private static readonly Car car = new Car();

        private static string Drive(List<Vertex> graph, List<Order> carringOdrs, State state)
        {
            if (car.Returned)
            {
                if (carringOdrs.Count == 0) return "-1";

                BuildRoute(graph, carringOdrs, state);

                car.SetDest(route.Dequeue());
            }
            else if (car.Arrived)
            {
                if (route.Count == 0)
                    car.Return();
                else
                    car.SetDest(route.Dequeue());
            }

            return car.Drive(graph);
        }

        private static void BuildRoute(List<Vertex> graph, List<Order> carringOdrs, State state)
        {
            var carring = carringOdrs.GroupBy(o => o.dst).ToList();
            var list = new List<IGrouping<int, Order>>();

            // Farthest Insertion 法
            var now = graph[0];
            while (carring.Count > 0)
            {
                var nearest = carring.MinBy(g => now.Distances[g.Key]);
                carring.Remove(nearest);
                list.Add(nearest);
                now = graph[nearest.Key];
            }

            // 2-opt 法
            var list2 = new List<IGrouping<int, Order>>(list);
            var score = CalcScore(graph, list, state);

            for (int ai = 0; ai < list2.Count - 1; ai++)
            {
                var a = list2[ai];
                for (int bi = ai + 1; bi < list2.Count; bi++)
                {
                    var b = list2[bi];

                    var xi = list.IndexOf(a);
                    var yi = list.IndexOf(b);
                    var count = Math.Abs(xi - yi + 1);
                    list.Reverse(Math.Min(xi, yi), count);

                    var revdScore = CalcScore(graph, list, state);

                    if (score < revdScore)
                    {
                        score = revdScore;
                    }
                    else
                    {
                        list.Reverse(Math.Min(xi, yi), count);
                    }
                }
            }

            route = new Queue<int>(list.Select(v => v.Key));
        }

        private static long CalcScore(List<Vertex> graph, List<IGrouping<int, Order>> list, State state)
        {
            if (state.time >= state.tlast)
                return CalcSalesScore(graph, list, state);
            else
                return -CalcTotalLength(graph, list);
        }

        private static long CalcSalesScore(List<Vertex> graph, List<IGrouping<int, Order>> list, State state)
        {
            var res = 0L;
            var time = state.time;

            var now = graph[0];
            foreach (var g in list)
            {
                time += now.Distances[g.Key];

                foreach (var o in g)
                {
                    var late = time - o.time;
                    res += state.tmax * state.tmax - late * late;
                }

                now = graph[g.Key];
            }

            return res;
        }

        private static long CalcTotalLength(List<Vertex> graph, List<IGrouping<int, Order>> list)
        {
            var res = 0L;
            var now = graph[0];
            foreach (var g in list)
            {
                res += now.Distances[g.Key];
                now = graph[g.Key];
            }

            res += now.Distances[graph[0].Id];

            return res;
        }

        private static List<Vertex> BuildGraph(FirstInput f)
        {
            var template = new int[f.sizeV];
            for (int i = 0; i < template.Length; i++) template[i] = 91200 + 91200;

            var vertices = Enumerable
                .Range(0, f.sizeV)
                .Select(n => new Vertex(n, (int[])template.Clone()))
                .ToList();

            foreach (var side in f.sides)
            {
                var u = vertices[side.u];
                var v = vertices[side.v];
                u.Adjacent.Add(v);
                v.Adjacent.Add(u);
                u.Distances[v.Id] = side.distance;
                v.Distances[u.Id] = side.distance;
            }

            // 全頂点に対しダイクストラ法を適用
            foreach (var start in vertices)
            {
                start.Distances[start.Id] = 0;
                var queue = new Queue<Vertex>(start.Adjacent);

                while (queue.Count > 0)
                {
                    var vertex = queue.Dequeue();

                    if (!vertex.Adjacent.Contains(start))
                    {
                        vertex.Distances[start.Id] =
                            vertex.Adjacent.Min(t => t.Distances[start.Id] + t.Distances[vertex.Id]);
                    }

                    foreach (var t in vertex.Adjacent)
                    {
                        if (t.Distances[start.Id] > vertex.Distances[start.Id] + vertex.Distances[t.Id])
                        {
                            queue.Enqueue(t);
                        }
                    }
                }
            }

            return vertices;
        }

    }

    public class Car
    {
        private int destVId = 0;

        public int headingVId { get; private set; } = 0;

        private int headingVDist = 0;

        public bool Arrived => destVId == headingVId && headingVDist == 0;

        public bool Returned => Arrived && destVId == 0;

        public void Return()
        {
            destVId = 0;
        }

        public void SetDest(int dest)
        {
            destVId = dest;
        }

        public string Drive(List<Vertex> graph)
        {
            if (Arrived) return "-1";

            if (headingVDist == 0)
            {
                var next = graph[headingVId].Adjacent.MinBy(t => t.Distances[destVId]);

                headingVDist = next.Distances[headingVId] - 1;
                headingVId = next.Id;
            }
            else
                headingVDist--;

            return (headingVId + 1).ToString();
        }
    }

    public class Vertex
    {
        public readonly int Id;
        public readonly List<Vertex> Adjacent;

        // TODO ushort
        public readonly int[] Distances;

        public Vertex(int id, int[] d)
        {
            this.Id = id;
            this.Adjacent = new List<Vertex>();
            this.Distances = d;
        }
    }

    #region "入出力"

    ///<summary>辺の入力。</summary>
    public class Side
    {
        public readonly int u;
        public readonly int v;
        public readonly int distance;

        public Side()
        {
            var ary = Console.ReadLine().Split();
            u = int.Parse(ary[0]) - 1;
            v = int.Parse(ary[1]) - 1;
            distance = int.Parse(ary[2]);
        }
    }

    public class FirstInput
    {
        public readonly int sizeV;
        private readonly int sizeE;
        ///<summary>辺の集合。</summary>
        public readonly List<Side> sides;
        ///<summary>注文頻度。</summary>
        public readonly List<int> freqs;
        public readonly int Tmax;

        public FirstInput()
        {
            var ary = Console.ReadLine().Split();
            sizeV = int.Parse(ary[0]);
            sizeE = int.Parse(ary[1]);

            sides = EnumerablePlus.Repeat(sizeE, () => new Side()).ToList();
            freqs = Console.ReadLine().Split().Select(int.Parse).ToList();
            Tmax = int.Parse(Console.ReadLine());
        }
    }

    public class Order
    {
        ///<summary>注文ID。</summary>
        public readonly int id;
        ///<summary>届け先頂点。</summary>
        public readonly int dst;
        ///<summary>受注時間。</summary>
        public readonly int time;

        public Order(int time)
        {
            var ary = Console.ReadLine().Split();
            id = int.Parse(ary[0]);
            dst = int.Parse(ary[1]) - 1;
            this.time = time;
        }
    }

    public class OrdersInput
    {
        // TODO 0 or 1
        private readonly int sizeNew;
        ///<summary>新規注文。</summary>
        public readonly Order order;
        private readonly int sizePut;
        ///<summary>出荷開始注文。</summary>
        public readonly List<int> puts;

        public OrdersInput(int time)
        {
            sizeNew = int.Parse(Console.ReadLine());
            if (sizeNew == 1)
                order = new Order(time);
            else
                order = null;
            sizePut = int.Parse(Console.ReadLine());
            puts = EnumerablePlus.Repeat(sizePut, () => int.Parse(Console.ReadLine())).ToList();
        }
    }

    public class VerdictInput
    {
        public readonly string verdict;
        private readonly int sizeArchive = 0;
        public readonly List<int> archives = null;

        public VerdictInput()
        {
            verdict = Console.ReadLine();

            if (verdict != "OK") return;

            sizeArchive = int.Parse(Console.ReadLine());
            archives = EnumerablePlus.Repeat(sizeArchive, () => int.Parse(Console.ReadLine())).ToList();
        }
    }

    #endregion

    public static class EnumerablePlus
    {
        ///<summary>出力文字列に変換。</summary>
        public static string MkString<T>(this IEnumerable<T> list)
        {
            return list.Aggregate(
                new System.Text.StringBuilder(),
                (a, b) => ((a.Length > 0) ? a.Append(' ') : a).Append(b)
                ).ToString();
        }

        ///<summary>添字付きfor。</summary>
        public static void ForEach<T>(this IEnumerable<T> list, Action<T, int> a)
        {
            int i = 0;
            foreach (var item in list)
            {
                a(item, i);
            }
        }

        ///<summary>添字付きfor。</summary>
        public static void ForEach<T>(this IEnumerable<T> list, Action<T> a)
        {
            foreach (var item in list)
            {
                a(item);
            }
        }

        ///<summary>指定回数デリゲートを呼び出す。</summary>
        public static IEnumerable<T> Repeat<T>(int n, Func<T> f)
        {
            for (int i = 0; i < n; i++)
            {
                yield return f();
            }
        }

        public static T MinBy<T, U>(this IEnumerable<T> xs, Func<T, U> key) where U : IComparable<U>
        {
            return xs.Aggregate((a, b) => key(a).CompareTo(key(b)) <= 0 ? a : b);
        }

        public static T MaxBy<T, U>(this IEnumerable<T> xs, Func<T, U> key) where U : IComparable<U>
        {
            return xs.Aggregate((a, b) => key(a).CompareTo(key(b)) >= 0 ? a : b);
        }
    }
}


Measured memory_bytes: 39412