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

namespace hokudai {
    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) => sw.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();
        }

        public void solve() {
            int n, 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];
                        }
                    }
                }
            }

            int T = sc.Int;
            var queries = new int[T];
            for (int _ = 0; _ < T; _++)
            {
                int a = sc.Int;
                Assert(0 <= a && a <= 1);
                if (a == 1) {
                    int id, ds;
                    sc.Multi(out id, out ds);
                    queries[_] = ds - 1;
                }
                else
                    queries[_] = -1;
            }


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

            if (queries[t] != -1) dst.Add(queries[t]);

            Func<int, bool> post = x => {
                Prt(x < 0 ? -1 : x + 1);
                ++t;
                if (t == T) return false;
                if (queries[t] != -1) dst.Add(queries[t]);
                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 = reorder(dst, dist);

                var tos = dst.copy().ToList();
                dst = new List<int>();
                foreach (var to in tos)
                    if (!walk(to)) return;
                if (!walk(0)) return;
                // DBG("turn", t);
            }
        }
        List<int> reorder(List<int> dst, int[][] dist) {
            int m = dst.Count;
            // DBG(m);
            if (m < 20) {
                var dp = new int[1 << m][];
                var prev = new int[1 << m][];
                for (int i = 0; i < (1 << m); i++)
                {
                    dp[i] = new int[m];
                    prev[i] = new int[m];
                    for (int j = 0; j < m; j++)
                    {
                        dp[i][j] = M;
                        prev[i][j] = -1;
                    }
                }
                for (int i = 0; i < m; i++)
                {
                    dp[1 << i][i] = dist[0][dst[i]];
                }
                for (int i = 0; i < (1 << m); i++)
                {
                    for (int j = 0; j < m; j++)
                    {
                        if (dp[i][j] == M) continue;
                        for (int k = 0; k < m; k++)
                        {
                            if (((i >> k) & 1) == 0 && dp[i ^ (1 << k)][k] > dp[i][j] + dist[dst[j]][dst[k]]) {
                                dp[i ^ (1 << k)][k] = dp[i][j] + dist[dst[j]][dst[k]];
                                prev[i ^ (1 << k)][k] = j;
                            }
                        }
                    }
                }
                int min = M, p = -1;
                for (int i = 0; i < m; i++)
                {
                    if (min > dp[(1 << m) - 1][i] + dist[dst[i]][0]) {
                        min = dp[(1 << m) - 1][i] + dist[dst[i]][0];
                        p = i;
                    }
                }
                var res = new List<int>();
                int st = (1 << m) - 1;
                while (p != -1) {
                    res.Add(dst[p]);
                    int prv = prev[st][p];
                    st ^= 1 << p;
                    p = prv;
                }
                res.Reverse();
                return res;
            }
            else {
                var vis = new bool[m];
                var res = new List<int>();
                int p = 0;
                while (true) {
                    int min = M, 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;
            }
        }
    }

    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: 159892