using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Threading;
using System.Text;
using System.Diagnostics;

namespace hokudai2019B {
    using static util;
    using P = pair<int, int>;
    class Program {
        static void Main(string[] args) {
            var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
            var solver = new Solver(sw);
            // var t = new Thread(solver.solve, 1 << 26); // 64 MB
            // t.Start();
            // t.Join();
            solver.solve();
            sw.Flush();
        }
    }

    class Solver {
        StreamWriter sw;
        Scan sc;
        void Prt(string a) => Console.WriteLine(a);
        void Prt<T>(IEnumerable<T> a) => Prt(string.Join(" ", a));
        void Prt(params object[] a) => Prt(string.Join(" ", a));
        public Solver(StreamWriter sw) {
            this.sw = sw;
            this.sc = new Scan();
        }

        Random rnd;
        int n;

        public void solve() {
            rnd = new Random(0);
            int m;
            sc.Multi(out n, out m);
            var dist = new int[n][];
            var next = new int[n][];
            for (int i = 0; i < n; i++)
            {
                dist[i] = new int[n];
                next[i] = new int[n];
                for (int j = 0; j < n; j++)
                {
                    dist[i][j] = M;
                    next[i][j] = -1;
                }
                dist[i][i] = 0;
            }

            for (int i = 0; i < m; i++)
            {
                int u, v, d;
                sc.Multi(out u, out v, out d);
                --u;
                --v;
                if (dist[u][v] > d) {
                    dist[u][v] = d;
                    next[u][v] = v;
                }
                if (dist[v][u] > d) {
                    dist[v][u] = d;
                    next[v][u] = u;
                }
            }
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < n; ++j) {
                    for (int k = 0; k < n; ++k) {
                        if (dist[j][k] > dist[j][i] + dist[i][k]) {
                            dist[j][k] = dist[j][i] + dist[i][k];
                            next[j][k] = next[j][i];
                        }
                    }
                }
            }
            var f = sc.IntArr;


            int T = sc.Int;

            var dst = new List<int>();
            int t = 0;
            int p = 0;

            Action read_verdict = () => {
                var v = sc.Str;
                Assert(v == "OK");
                int a = sc.Int;
                for (int i = 0; i < a; i++)
                {
                    int aa = sc.Int;
                }
            };
            Action read = () => {
                int a = sc.Int;
                Assert(0 <= a && a <= 1);
                if (a == 1) {
                    int id, ds;
                    sc.Multi(out id, out ds);
                    dst.Add(ds - 1);
                }
                a = sc.Int;
                for (int i = 0; i < a; i++)
                {
                    int aa = sc.Int;
                }
            };

            read();

            Func<int, bool> post = x => {
                Prt(x < 0 ? -1 : x + 1);
                read_verdict();
                ++t;
                if (t == T) return false;
                read();
                return true;
            };
            Func<int, bool> walk = to => {
                while (p != to) {
                    for (int i = 0; i < dist[p][next[p][to]]; i++)
                        if (!post(next[p][to])) return false;

                    p = next[p][to];
                }
                return true;
            };

            while (true) {
                while (!dst.Any()) {
                    if (!post(-1)) return;
                }
                dst = distinct(dst);
                var tos = dst.copy().ToList();
                tos.Sort((x, y) => dist[dst[0]][x].CompareTo(dist[dst[0]][y]));
                if (tos.Count > 120)
                    tos = tos.Take(120).ToList();

                var vis = new bool[n];
                foreach (var item in tos)
                {
                    vis[item] = true;
                }
                var nex = new List<int>();
                foreach (var item in dst)
                {
                    if (!vis[item]) nex.Add(item);
                }

                tos = reorder(tos, dist);
                dst = nex;
                foreach (var to in tos)
                    if (!walk(to)) return;
                if (!walk(0)) return;
                // DBG("turn", t);
            }
        }
        int delta_2opt(List<int> dst, int i, int j, int[][] dist) {
            if (i == j) return M;
            return - dist[dst[i]][dst[(i + 1) % dst.Count]]
                   - dist[dst[j]][dst[(j + 1) % dst.Count]]
                   + dist[dst[i]][dst[j]]
                   + dist[dst[(i + 1) % dst.Count]][dst[(j + 1) % dst.Count]];
        }
        void swap_2opt(List<int> dst, int i, int j) {
            if (i > j) swap(ref i, ref j);
            while (i + 1 < j) {
                dst.swap(i + 1, j);
                ++i;
                --j;
            }
        }
        int delta_1_5opt(List<int> dst, int i, int j, int[][] dist) {
            if (i == j || i + 1 == dst.Count || i + 1 == j) return M;
            return - dist[dst[i]][dst[i + 1]]
                   - dist[dst[i + 1]][dst[(i + 2) % dst.Count]]
                   - dist[dst[j]][dst[(j + 1) % dst.Count]]
                   + dist[dst[i]][dst[(i + 2) % dst.Count]]
                   + dist[dst[j]][dst[i + 1]]
                   + dist[dst[i + 1]][dst[(j + 1) % dst.Count]];
        }
        void swap_1_5opt(List<int> dst, int i, int j) {
            int p = dst[i + 1];
            if (i < j) {
                for (int k = i + 1; k < j; k++)
                {
                    dst[k] = dst[k + 1];
                }
                dst[j] = p;
            }
            else {
                for (int k = i; k > j ; k--)
                {
                    dst[k + 1] = dst[k];
                }
                dst[j + 1] = p;
            }
        }

        List<int> annealing(List<int> dst, int[][] dist) {
            dst.Insert(0, 0);
            int m = dst.Count;
            double st = 1e-1, et = 1e-4;
            int lim = 1000000;
            for (int k = 0; k < lim; k++)
            {
                int i = rnd.Next(m);
                int j = rnd.Next(m);
                if (k % 2 == 0) {
                    int d = delta_2opt(dst, i, j, dist);
                    if (d < 0) {
                        swap_2opt(dst, i, j);
                    }
                    else if (d < M) {
                        double temp = st + (et - st) * k / lim;
                        double prb = Math.Exp(-d / temp) * M;
                        if (prb > rnd.Next(M)) {
                            swap_2opt(dst, i, j);
                        }
                    }
                }
                {
                    int d = delta_1_5opt(dst, i, j, dist);
                    if (d < 0) {
                        swap_1_5opt(dst, i, j);
                    }
                    else if (d < M) {
                        double temp = st + (et - st) * k / lim;
                        double prb = Math.Exp(-d / temp) * M;
                        if (prb > rnd.Next(M)) {
                            swap_1_5opt(dst, i, j);
                        }
                    }
                }
            }
            Assert(dst[0] == 0);
            dst.RemoveAt(0);
            return dst;
        }

        List<int> distinct(List<int> dst) {
            var exi = new bool[n];
            var res = new List<int>();
            foreach (var item in dst) {
                if (!exi[item]) {
                    res.Add(item);
                    exi[item] = true;
                }
            }
            return res;
        }

        List<int> nearest_neighbor(List<int> dst, int[][] dist) {
            int m = dst.Count;
            var vis = new bool[m];
            var res = new List<int>();
            int p = 0;
            for (int j = 0; ; j++)
            {
                int min = M;
                int mii = -1;
                for (int i = 0; i < m; i++)
                {
                    if (!vis[i] && min > dist[p][dst[i]]) {
                        min = dist[p][dst[i]];
                        mii = i;
                    }
                }
                if (mii == -1) break;
                vis[mii] = true;
                p = dst[mii];
                res.Add(p);
            }
            return res;
        }
        List<int> greedy_prim(List<int> dst, int[][] dist) {
            int m = dst.Count;
            var vis = new bool[m];
            var l1 = new List<int>();
            var l2 = new List<int>();
            int p1 = 0, p2 = 0;
            for (int j = 0; ; j++)
            {
                int min = M;
                int mii = -1;
                for (int i = 0; i < m; i++)
                {
                    if (!vis[i] && min > Math.Min(dist[p1][dst[i]], dist[p2][dst[i]])) {
                        min = Math.Min(dist[p1][dst[i]], dist[p2][dst[i]]);
                        mii = i;
                    }
                }
                if (mii == -1) break;
                vis[mii] = true;
                if (dist[p1][dst[mii]] <= dist[p2][dst[mii]]) {
                    p1 = dst[mii];
                    l1.Add(p1);
                }
                else {
                    p2 = dst[mii];
                    l2.Add(p2);
                }
            }
            l2.Reverse();
            l1.AddRange(l2);
            return l1;
        }

        List<int> reorder(List<int> dst, int[][] dist) {
            dst = distinct(dst);
            int m = dst.Count;

            dst = greedy_prim(dst, dist);
            // dst = nearest_neighbor(dst, dist);

            dst = annealing(dst, dist);

            Assert(dst.Count == m);
            return dst;
        }
    }

    class pair<T, U> : IComparable<pair<T, U>> {
        public T v1;
        public U v2;
        public pair() : this(default(T), default(U)) {}
        public pair(T v1, U v2) { this.v1 = v1; this.v2 = v2; }
        public int CompareTo(pair<T, U> a) {
            int c = Comparer<T>.Default.Compare(v1, a.v1);
            return c != 0 ? c : Comparer<U>.Default.Compare(v2, a.v2);
        }
        public override string ToString() => v1 + " " + v2;
        public void Deconstruct(out T a, out U b) { a = v1; b = v2; }
    }
    static class util {
        public static readonly int M = 1000000007;
        // public static readonly int M = 998244353;
        public static readonly long LM = 1L << 60;
        public static readonly double eps = 1e-11;
        public static void DBG(string a) => Console.Error.WriteLine(a);
        public static void DBG<T>(IEnumerable<T> a) => DBG(string.Join(" ", a));
        public static void DBG(params object[] a) => DBG(string.Join(" ", a));
        public static void Assert(bool cond) { if (!cond) throw new Exception(); }
        public static pair<T, U> make_pair<T, U>(T v1, U v2) => new pair<T, U>(v1, v2);
        public static int CompareList<T>(IList<T> a, IList<T> b) where T : IComparable<T> {
            for (int i = 0; i < a.Count && i < b.Count; i++)
                if (a[i].CompareTo(b[i]) != 0) return a[i].CompareTo(b[i]);
            return a.Count.CompareTo(b.Count);
        }
        public static bool inside(int i, int j, int h, int w) => i >= 0 && i < h && j >= 0 && j < w;
        static readonly int[] dd = { 0, 1, 0, -1 };
        // static readonly string dstring = "RDLU";
        public static P[] adjacents(int i, int j)
            => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1])).ToArray();
        public static P[] adjacents(int i, int j, int h, int w)
            => Enumerable.Range(0, dd.Length).Select(k => new P(i + dd[k], j + dd[k ^ 1]))
                                            .Where(p => inside(p.v1, p.v2, h, w)).ToArray();
        public static P[] adjacents(this P p) => adjacents(p.v1, p.v2);
        public static P[] adjacents(this P p, int h, int w) => adjacents(p.v1, p.v2, h, w);
        public static Dictionary<T, int> compress<T>(this IEnumerable<T> a)
            => a.Distinct().OrderBy(v => v).Select((v, i) => new { v, i }).ToDictionary(p => p.v, p => p.i);
        public static Dictionary<T, int> compress<T>(params IEnumerable<T>[] a) => compress(a.Aggregate(Enumerable.Union));
        public static T[] inv<T>(this Dictionary<T, int> dic) {
            var res = new T[dic.Count];
            foreach (var item in dic) res[item.Value] = item.Key;
            return res;
        }
        public static void swap<T>(ref T a, ref T b) where T : struct { var t = a; a = b; b = t; }
        public static void swap<T>(this IList<T> a, int i, int j) where T : struct { var t = a[i]; a[i] = a[j]; a[j] = t; }
        public static T[] copy<T>(this IList<T> a) {
            var ret = new T[a.Count];
            for (int i = 0; i < a.Count; i++) ret[i] = a[i];
            return ret;
        }
    }

    class Scan {
        StreamReader sr;
        public Scan() { sr = new StreamReader(Console.OpenStandardInput()); }
        public Scan(string path) { sr = new StreamReader(path); }
        public int Int => int.Parse(Str);
        public long Long => long.Parse(Str);
        public double Double => double.Parse(Str);
        public string Str => sr.ReadLine().Trim();
        public pair<T, U> Pair<T, U>() {
            T a; U b;
            Multi(out a, out b);
            return new pair<T, U>(a, b);
        }
        public P P => Pair<int, int>();
        public int[] IntArr => StrArr.Select(int.Parse).ToArray();
        public long[] LongArr => StrArr.Select(long.Parse).ToArray();
        public double[] DoubleArr => StrArr.Select(double.Parse).ToArray();
        public string[] StrArr => Str.Split(new[]{' '}, StringSplitOptions.RemoveEmptyEntries);
        bool eq<T, U>() => typeof(T).Equals(typeof(U));
        T ct<T, U>(U a) => (T)Convert.ChangeType(a, typeof(T));
        T cv<T>(string s) => eq<T, int>()    ? ct<T, int>(int.Parse(s))
                        : eq<T, long>()   ? ct<T, long>(long.Parse(s))
                        : eq<T, double>() ? ct<T, double>(double.Parse(s))
                        : eq<T, char>()   ? ct<T, char>(s[0])
                                            : ct<T, string>(s);
        public void Multi<T>(out T a) => a = cv<T>(Str);
        public void Multi<T, U>(out T a, out U b)
        { var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); }
        public void Multi<T, U, V>(out T a, out U b, out V c)
        { var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); }
        public void Multi<T, U, V, W>(out T a, out U b, out V c, out W d)
        { var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); }
        public void Multi<T, U, V, W, X>(out T a, out U b, out V c, out W d, out X e)
        { var ar = StrArr; a = cv<T>(ar[0]); b = cv<U>(ar[1]); c = cv<V>(ar[2]); d = cv<W>(ar[3]); e = cv<X>(ar[4]); }
    }
}


Measured memory_bytes: 19584