//#define NDEBUG
#include "bits/stdc++.h"
#include <iostream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <array>
#ifdef _MSC_VER
#include <ppl.h>
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
#endif

using namespace std;

#define DUMPOUT cerr
#define dump(...) DUMPOUT<<"  ";DUMPOUT<<#__VA_ARGS__<<" :["<<__LINE__<<":"<<__FUNCTION__<<"]"<<endl;DUMPOUT<<"    ";dump_func(__VA_ARGS__)

typedef unsigned uint; typedef long long ll; typedef unsigned long long ull; typedef pair<int, int> pii; typedef pair<ll, ll> pll; typedef pair<double, double> pdd; typedef pair<string, string> pss;
template <typename _KTy, typename _Ty> ostream& operator << (ostream& o, const pair<_KTy, _Ty>& m) { o << "{" << m.first << ", " << m.second << "}"; return o; }
template <typename _KTy, typename _Ty> ostream& operator << (ostream& o, const map<_KTy, _Ty>& m) { if (m.empty()) { o << "{ }"; return o; } o << "{" << *m.begin(); for (auto itr = ++m.begin(); itr != m.end(); itr++) { o << ", " << *itr; } o << "}"; return o; }
template <typename _KTy, typename _Ty> ostream& operator << (ostream& o, const unordered_map<_KTy, _Ty>& m) { if (m.empty()) { o << "{ }"; return o; } o << "{" << *m.begin(); for (auto itr = ++m.begin(); itr != m.end(); itr++) { o << ", " << *itr; } o << "}"; return o; }
template <typename _Ty> ostream& operator << (ostream& o, const vector<_Ty>& v) { if (v.empty()) { o << "{ }"; return o; } o << "{" << v.front(); for (auto itr = ++v.begin(); itr != v.end(); itr++) { o << ", " << *itr; } o << "}"; return o; }
template <typename _Ty> ostream& operator << (ostream& o, const set<_Ty>& s) { if (s.empty()) { o << "{ }"; return o; } o << "{" << *(s.begin()); for (auto itr = ++s.begin(); itr != s.end(); itr++) { o << ", " << *itr; } o << "}"; return o; }
template <typename _Ty> ostream& operator << (ostream& o, const unordered_set<_Ty>& s) { if (s.empty()) { o << "{ }"; return o; } o << "{" << *(s.begin()); for (auto itr = ++s.begin(); itr != s.end(); itr++) { o << ", " << *itr; }	o << "}"; return o; }
template <typename _Ty> ostream& operator << (ostream& o, const stack<_Ty>& s) { if (s.empty()) { o << "{ }"; return o; } stack<_Ty> t(s); o << "{" << t.top(); t.pop(); while (!t.empty()) { o << ", " << t.top(); t.pop(); } o << "}";	return o; }
template <typename _Ty> ostream& operator << (ostream& o, const list<_Ty>& l) { if (l.empty()) { o << "{ }"; return o; } o << "{" << l.front(); for (auto itr = ++l.begin(); itr != l.end(); ++itr) { o << ", " << *itr; } o << "}"; return o; }
template <typename _KTy, typename _Ty> istream& operator >> (istream& is, pair<_KTy, _Ty>& m) { is >> m.first >> m.second; return is; }
template <typename _Ty> istream& operator >> (istream& is, vector<_Ty>& v) { for (size_t t = 0; t < v.size(); t++) is >> v[t]; return is; }
namespace aux { // print tuple
  template<typename Ty, unsigned N, unsigned L> struct tp { static void print(ostream& os, const Ty& v) { os << get<N>(v) << ", "; tp<Ty, N + 1, L>::print(os, v); } };
  template<typename Ty, unsigned N> struct tp<Ty, N, N> { static void print(ostream& os, const Ty& v) { os << get<N>(v); } };
}

template<typename... Tys> ostream& operator<<(ostream& os, const tuple<Tys...>& t) { os << "{"; aux::tp<tuple<Tys...>, 0, sizeof...(Tys) - 1>::print(os, t); os << "}"; return os; }

template<typename A, size_t N, typename T> inline void Fill(A(&array)[N], const T &val) { std::fill((T*)array, (T*)(array + N), val); }

void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail> void dump_func(Head&& head, Tail&&... tail) { DUMPOUT << head; if (sizeof...(Tail) == 0) { DUMPOUT << " "; } else { DUMPOUT << ", "; } dump_func(std::move(tail)...); }

#define PI 3.14159265358979323846
#define EPS 1e-8
#define FOR(t,a,n) for(int t=(a);t<(n);++t)
#define REP(t,n)  FOR(t,0,n)
#define all(j) (j).begin(), (j).end()
#define SZ(j) ((int)(j).size())
#define fake false



class Timer {
public:
  double t = 0;
  Timer() {}
  static double time() {
#ifdef _MSC_VER
    return __rdtsc() / 2.8e9;
#else
    unsigned long long a, d;
    __asm__ volatile("rdtsc"
      : "=a"(a), "=d"(d));
    return (d << 32 | a) / 2.8e9;
#endif
  }
  void measure() { t = time() - t; }
  double elapsedMs() { return (time() - t) * 1000.0; }
} timer;

struct Xorshift {
  uint64_t x = 88172645463325252LL;
  unsigned nextUInt() {
    x = x ^ (x << 7);
    return x = x ^ (x >> 9);
  }
  unsigned nextUInt(unsigned mod) {
    x = x ^ (x << 7);
    x = x ^ (x >> 9);
    return x % mod;
  }
  unsigned nextUInt(unsigned l, unsigned r) {
    x = x ^ (x << 7);
    x = x ^ (x >> 9);
    return x % (r - l + 1) + l;
  }
  double nextDouble() {
    return double(nextUInt()) / UINT_MAX;
  }
} rnd;

template<typename T>
void shuffleVector(vector<T>& v, Xorshift& rnd) {
  int n = v.size();
  for (int t = n - 1; t >= 1; t--) {
    int r = rnd.nextUInt(t);
    swap(v[t], v[r]);
  }
}



int TMAX;
constexpr int inf = INT_MAX / 4;

struct Edge {
  int u, v, d;
  Edge() {}
  Edge(int u, int v, int d) : u(u), v(v), d(d) {}
};
using EdgePtr = Edge * ;

struct Order {
  int id, t, dst;
  Order() {}
  Order(int id, int t, int dst) : id(id), t(t), dst(dst) {}
};
using OrderPtr = Order * ;

struct TestCase {
  int V, E;
  vector<EdgePtr> edges;
  vector<OrderPtr> orders;

  TestCase() {}
  TestCase(istream& is) {
    is >> V >> E;
    for (int t = 0; t < E; t++) {
      int u, v, d;
      is >> u >> v >> d;
      u--; v--;
      edges.emplace_back(new Edge(u, v, d));
    }
    is >> TMAX;
    for (int t = 1; t <= TMAX; t++) {
      int Nnew;
      is >> Nnew;
      if (!Nnew) {
        orders.emplace_back(new Order(-1, t, -1));
      }
      else {
        int newId, dst;
        is >> newId >> dst;
        newId--; dst--;
        orders.emplace_back(new Order(newId, t, dst));
      }
    }
  }
};

struct WarshallFloyd {
  int V;
  vector<vector<int>> d;
  vector<vector<int>> next;
  WarshallFloyd() {}
  WarshallFloyd(const TestCase& tc) {
    V = tc.V;
    d.resize(V, vector<int>(V, inf));
    next.resize(V, vector<int>(V));
    for (int i = 0; i < V; i++) {
      d[i][i] = 0;
    }
    for (const EdgePtr& e : tc.edges) {
      d[e->u][e->v] = d[e->v][e->u] = e->d;
    }
    for (int i = 0; i < V; i++) {
      for (int j = 0; j < V; j++) {
        next[i][j] = j;
      }
    }
    for (int k = 0; k < V; k++) {
      for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
          if (d[i][k] + d[k][j] < d[i][j]) {
            d[i][j] = d[i][k] + d[k][j];
            next[i][j] = next[i][k];
          }
        }
      }
    }
  }
  vector<int> getPath(int u, int v) {
    vector<int> ret;
    for (int cur = u; cur != v; cur = next[cur][v]) {
      ret.push_back(cur);
    }
    ret.push_back(v);
    return ret;
  }
  vector<int> getPath(const vector<int>& r) {
    int n = (int)r.size();
    vector<int> path;
    for (int i = 0; i < n - 1; i++) {
      for (int u : getPath(r[i], r[i + 1])) {
        path.push_back(u);
      }
      path.pop_back();
    }
    path.push_back(r[0]);
    return path;
  }
  vector<int> getCommands(const vector<int>& p) {
    vector<int> cmds;
    int n = (int)p.size();
    for (int i = 0; i < n - 1; i++) {
      int u = p[i], v = p[i + 1];
      for (int k = 0; k < d[u][v]; k++) {
        cmds.push_back(v);
      }
    }
    return cmds;
  }
};

struct TSP {
  int V;
  vector<int> iToU;
  vector<vector<int>> d;

  int score;
  vector<int> p;

  TSP(const vector<vector<int>>& G, const vector<int>& us) : iToU(us) {
    V = (int)us.size();
    d.resize(V, vector<int>(V));
    for (int i = 0; i < V; i++) {
      for (int j = i; j < V; j++) {
        d[i][j] = d[j][i] = G[us[i]][us[j]];
      }
    }
    score = 0;
    p.resize(V);
    for (int i = 0; i < V; i++) {
      score += d[i][(i + 1) % V];
      p[i] = i;
    }
  }

  inline int dist(int i1, int i2) {
    return d[i1][i2];
  }

  int twoOptDiff(int idx1, int idx2) {
    int p1 = p[idx1], p2 = p[(idx1 + 1) % V], p3 = p[idx2], p4 = p[(idx2 + 1) % V];
    return dist(p1, p3) + dist(p2, p4) - dist(p1, p2) - dist(p3, p4);
  }

  void solve2optClimbing() {
    while (true) {
      bool update = false;
      for (int i1 = 0; i1 < V - 1; i1++) {
        for (int i2 = i1 + 1; i2 < V; i2++) {
          int diff = twoOptDiff(i1, i2);
          if (diff < 0) {
            reverse(p.begin() + i1 + 1, p.begin() + i2 + 1);
            score += diff;
            //cerr << score << endl;
            update = true;
          }
        }
      }
      if (!update) break;
    }
  }

  double getTemp(double startTemp, double endTemp, int t, int T) {
    return endTemp + (startTemp - endTemp) * (T - t) / T;
  }

  void solve2optSA(int numLoop) {
    int bestScore = INT_MAX;
    vector<int> bp;
    const unsigned R = (1 << 30), mask = (1 << 30) - 1;
    for (int i = 0; i < numLoop; i++) {
      int i1 = rnd.nextUInt() % V;
      int i2 = rnd.nextUInt() % (V - 1);
      if (i2 >= i1) i2++;
      if (i1 > i2) swap(i1, i2);

      int diff = twoOptDiff(i1, i2);

      double temp = getTemp(3.0, 0.01, i, numLoop);
      double x = -diff / temp;
      double prob = exp(-diff / temp);

      if (R * prob > (rnd.nextUInt() & mask)) {
        reverse(p.begin() + i1 + 1, p.begin() + i2 + 1);
        score += diff;
        if (score < bestScore) {
          bestScore = score;
          bp = p;
        }
      }
    }
    score = bestScore;
    p = bp;
    //cerr << bestScore << endl;
  }

  pair<int, vector<int>> getDistanceAndRoute() {
    vector<int> route;
    for (int i : p) route.push_back(iToU[i]);
    route.push_back(iToU[0]);
    return pair<int, vector<int>>(score, route);
  }
};

struct State {
  TestCase tc;
  WarshallFloyd wf;
  State(const TestCase& tc, const WarshallFloyd& wf) : tc(tc), wf(wf) {}
  vector<int> gather(int t0, int t1) {
    t1 = min(t1, TMAX);
    // {0} + [t0, t1) にやってくる注文の位置集合
    set<int> st({ 0 });
    map<int, int> mp;
    for (int t = t0; t < t1; t++) {
      const auto& order = tc.orders[t];
      if (order->id == -1) continue;
      st.insert(order->dst);
    }
    //cerr << mp.size() << ": " << mp << endl;
    return vector<int>(st.begin(), st.end());
  }
  vector<int> getAns() {
    vector<int> ans;
    int interval = 10;
    int finish = 0, t0 = 0, t1 = interval;
    while (ans.size() < TMAX) {
      while (ans.size() < t1) ans.push_back(-2);
      auto v1 = gather(t0, t1);
      if (v1.size() > 1) {
        TSP tsp(wf.d, v1);
        tsp.solve2optSA(v1.size() * 100000);
        auto route = tsp.getDistanceAndRoute();
        auto path = wf.getPath(route.second);
        auto cmds = wf.getCommands(path);
        for (int cmd : cmds) ans.push_back(cmd);
        finish = t1 + route.first;
      }
      else {
        finish = t1;
      }
      t0 = t1;
      t1 = max(t1 + interval, finish);
    }
    while (ans.size() > TMAX) ans.pop_back();
    return ans;
  }
};

//#define DEBUG_MODE
#ifdef DEBUG_MODE
int main() {
  timer.measure();

  cin.tie(0);
  ios::sync_with_stdio(false);
  //int i = 1;
  concurrency::parallel_for(1, 101, [&](int i) {
    string input_name = "input/" + to_string(i) + ".txt";
    string output_name = "output/" + to_string(i) + ".txt";
    ifstream in(input_name);
    ofstream out(output_name);
    TestCase tc(in);
    WarshallFloyd wf(tc);
    State state(tc, wf);
    auto ans = state.getAns();
    for (int i : ans) out << i + 1 << endl;
    in.close();
    out.close();
    cerr << i << ": " << timer.elapsedMs() << endl;
  });

  return 0;
}
#else
int main() {
  timer.measure();

  cin.tie(0);
  ios::sync_with_stdio(false);

  TestCase tc(cin);

  WarshallFloyd wf(tc);

  vector<int> us;
  for (int i = 0; i < wf.V; i++)
    us.push_back(i);

  State state(tc, wf);
  auto ans = state.getAns();

  for (int i : ans) cout << i + 1 << endl;

  dump(timer.elapsedMs());

  return 0;
}
#endif

Measured memory_bytes: 5504