//#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]);
  }
}



//constexpr int TMAX = 10000;
//constexpr int TLAST = 9500;
int TMAX;
int TLAST;
constexpr int inf = INT_MAX / 4;

template<typename T>
struct PrimeEdge {
  int u, v;
  T d;
  PrimeEdge() {}
  PrimeEdge(int u, int v, T d) : u(u), v(v), d(d) {}
};

struct TestCase {
  int V, E;
  vector<PrimeEdge<int>> edges;
  vector<int> freqs;
  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(u, v, d);
    }
    freqs.resize(V);
    for (int u = 0; u < V; u++) {
      is >> freqs[u];
    }
    is >> TMAX;
    TLAST = TMAX * 95 / 100;
  }
};

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 PrimeEdge<int>& 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 = 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 = 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 = 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];
  }

  double 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) {
    double bestScore = DBL_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);

      double 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;

  int turn;
  set<int> target;
  
  State(const TestCase& tc, const WarshallFloyd& wf) : tc(tc), wf(wf), turn(0) {}

  void order(istream& is) {
    int Nnew;
    is >> Nnew;
    for (int i = 0; i < Nnew; i++) {
      int id, dst;
      is >> id >> dst;
      id--; dst--;
      target.insert(dst);
    }
    int Nput;
    is >> Nput;
    for (int i = 0; i < Nput; i++) {
      int buf;
      is >> buf;
    }
  }

  void deliver(istream& is) {
    string verdict;
    is >> verdict;
    if (verdict == "NG") {
      exit(1);
    }
    int Nachieve;
    is >> Nachieve;
    for (int i = 0; i < Nachieve; i++) {
      int buf;
      is >> buf;
    }
  }

  void solve(istream& is, ostream& os) {
    int interval = 10;
    int finish = 0, t0 = 0, t1 = interval;

    while (turn < TMAX) {
      if (turn < t1) {
        order(is);
        os << -1 << endl;
        turn++;
        deliver(is);
      }
      else {
        vector<int> cmds;
        if (target.empty()) {
          finish = t1;
        }
        else {
          vector<int> vs({ 0 });
          for (int v : target) vs.push_back(v);
          target.clear();
          TSP tsp(wf.d, vs);
          tsp.solve2optSA(10000000);
          auto route = tsp.getDistanceAndRoute();
          auto path = wf.getPath(route.second);
          cmds = wf.getCommands(path);
          finish = t1 + route.first;
        }
        t0 = t1;
        t1 = max(t1 + interval, finish);
        for (int i = 0; i < cmds.size() && turn < TMAX; i++) {
          order(is);
          os << cmds[i] + 1 << endl;
          turn++;
          deliver(is);
        }
      }
    }
  }
};

int main() {
  timer.measure();

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

  TestCase tc(cin);

  WarshallFloyd wf(tc);

  State state(tc, wf);
  state.solve(cin, cout);

  dump(timer.elapsedMs());

  return 0;
}


Measured memory_bytes: 6200