//#include <bits/stdc++.h>

#include <iostream>
#include <algorithm>

#include <bitset>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <stack>
#include <queue>
#include <deque>
#include <cstring>
#include <string>
#include <utility>
#include <array>
#include <complex>
#include <valarray>

#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <chrono>
#include <random>
#include <numeric>

#include<memory>


using namespace std;
//#define int long long

typedef long long ll;
typedef unsigned long long ull;
//typedef unsigned __int128 HASH;
typedef pair<int,int> pii;
typedef pair<ll, ll> pll;
typedef pair<ull, ull> pullull;
typedef pair<ll,int> plli;
typedef pair<double,int> pdi;
typedef pair<long double, int> pdbi;
typedef pair<int,pii> pipii;
typedef pair<ll,pll> plpll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;
typedef vector<vector<int>> mat;

#define rep(i,n) for (int i=0;i<(n);i++)
#define rep2(i,a,b) for (int i=(a);i<(b);i++)
#define rrep(i,n) for (int i=(n);i>0;i--)
#define rrep2(i,a,b) for (int i=(a);i>b;i--)
#define pb push_back
#define fi first
#define se second
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()

const ll hmod1 = 999999937;
const ll hmod2 = 1000000000 + 9;
const int INF = 1<<29;
const ll INFLL = 1LL<<62;
const long double EPS = 1e-12;
const ll mod = 1000000000 + 7;
//const ll mod = 998244353;
const int dx4[4] = {1, 0, -1, 0};
const int dy4[4] = {0, 1, 0, -1};
const int dx8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
const int dy8[8] = {0, 1, -1, 1, -1, 0, 1, -1};
const long double pi = 3.141592653589793;

#define addm(X, Y) (X) = ((X) + ((Y) % mod) + mod) % mod
#define inside(y, x, h, w) (0 <= (y) && (y) < (h) && 0 <= (x) && (x) < (w)) ? true : false

//debug
#define DEBUG

#define DUMPOUT cerr

#ifdef DEBUG
#define dump(...) DUMPOUT<<#__VA_ARGS__<<" :["<<__FUNCTION__<<":"<<__LINE__<<"]"<<endl; DUMPOUT<<"    "; dump_func(__VA_ARGS__)
#else
#define dump(...)
#endif

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)...);
}

//ostream
template<typename T> ostream& operator << (ostream& os, vector<T>& vec) {
    os << "["; for (int i = 0; i<vec.size(); i++) os << vec[i] << (i + 1 == vec.size() ? "" : ", "); os << "]";
    return os;
}

template<typename T, typename U> ostream& operator << (ostream& os, pair<T, U>& pair_var) {
    os << "(" << pair_var.first << ", " << pair_var.second << ")";
    return os;
}

template<typename T, typename U> ostream& operator << (ostream& os, map<T, U>& map_var) {
    os << "[";
    for (auto itr = map_var.begin(); itr != map_var.end(); itr++) {
        os << "(" << itr->first << ", " << itr->second << ")"; itr++;  if(itr != map_var.end()) os << ", "; itr--;
    }
    os << "]";
    return os;
}

template<typename T> ostream& operator << (ostream& os, set<T>& set_var) {
    os << "[";
    for (auto itr = set_var.begin(); itr != set_var.end(); itr++) {
        os << *itr; ++itr; if(itr != set_var.end()) os << ", "; itr--;
    }
    os << "]";
    return os;
}

auto start = chrono::system_clock::now();
double timelimit = 29800;

inline bool check_time() {
    auto end = chrono::system_clock::now();
    auto dur = end - start;
    auto msec = chrono::duration_cast<chrono::milliseconds>(dur).count();
    if (msec >= timelimit) return false;
    return true;
}

inline double get_time() {
  auto end = chrono::system_clock::now();
  auto dur = end - start;
  auto msec = chrono::duration_cast<chrono::milliseconds>(dur).count();
  return msec;
}

inline void now_time() {
  auto end = chrono::system_clock::now();
  auto dur = end - start;
  auto msec = chrono::duration_cast<chrono::milliseconds>(dur).count();
  cout << "time : " << msec << " msec"<< endl;
}

unsigned long long seed128[4]; //x,y,z,wとして利用
inline void seed(unsigned long long s){
    for(int i=1; i<=4; i++){
        seed128[i-1] = s = 1812433253U * (s^(s>>30)) + i;
    }
}

inline unsigned long long Xor128(){
  unsigned long long t;
  t=(seed128[0]^(seed128[0]<<11));
  seed128[0]=seed128[1];
  seed128[1]=seed128[2];
  seed128[2]=seed128[3];
  seed128[3]=(seed128[3]^(seed128[3]>>19))^(t^(t>>8));
  return seed128[3];
}

int n, m; //頂点数, 辺数
vector<vector<pair<int, int>>> g;
const int T = 10000;
vector<pii> order; //(id, v) ただし(-1, -1)は注文がないことを表す
int order_cnt = 0; //注文数
vector<int> start_o; //start_o[id]:= 注文idを開始した時刻
vector<vector<int>> order_info; //order_info[v]:= 頂点vの注文リスト

vector<vector<int>> d; //d[i][j]:= iからjへの最短経路距離
vector<vector<vector<int>>> path; //d[i][j]:= iからjへの最短経路path
int delivery_cnt = 0; //達成した注文数

int peak = 0;
vector<int> pri_v;
ll max_score = 0;
vector<vector<bool>> store_on_path;

void read() {
  //input graph
  cin >> n >> m;
  g.resize(n);
  rep(i, m) {
    int u, v, c;
    cin >> u >> v >> c;
    u--; v--;
    g[u].emplace_back(v, c);
    g[v].emplace_back(u, c);
  }

  //input order
  order_info.resize(n);
  int f;
  rep(i, n) cin >> f;
  int tmp_T;
  cin >> tmp_T;
  //order.emplace_back(-1, -1);
}

void analysis() {
  //cerr << order_cnt << endl;
  //各頂点の注文数
  int region[n] = {};
  rep(i, T) {
    if (order[i].fi == -1) continue;
    region[order[i].se]++;
  }
  vector<pii> freq;
  rep(i, n) freq.emplace_back(region[i], i);
  sort(rall(freq));
  pri_v.resize(n, INF);
  rep(i, n) {
    int num = freq[i].fi;
    int v = freq[i].se;
    pri_v[v] = num;
  }
  /*
  rep(i, n) {
    cerr << freq[i].se+1 << " " << freq[i].fi << endl;
  }
  exit(0);
  */
  //注文率([-range/2, range/2]の平均)
  int range = 1000;
  vector<double> rates;
  rep2(i, range/2, T-range/2) {
    double rate = 0;
    rep2(j, i-range/2, i+range/2+1) {
      if (order[j].fi == -1) continue;
      rate++;
    }
    rate /= (double)range;
    //cout << i << " " << rate << endl;
    rates.push_back(rate);
  }
  double mx_rate = 0;
  rep(i, (int)rates.size()) {
    if (mx_rate < rates[i]) {
      mx_rate = rates[i];
      peak = i + range/2;
    }
  }
}

vector<int> dijkstra(const int s, const int n, vector<int>& pv, const vector<vector<pii>>& g) {
  priority_queue<pii, vector<pii>, greater<pii>> que;
  vector<int> d(n, INF); d[s] = 0;
  que.emplace(0, s);
  while (!que.empty()) {
    pii p = que.top();que.pop();
    int fr = p.second;
    if (d[fr] < p.first) continue;
    for (pair<int, int> e: g[fr]) {
      int to = e.fi;
      int cost = e.se;
      if (d[to] > d[fr] + cost) {
        d[to] = d[fr] + cost;
        pv[to] = fr;
        que.emplace(d[to], to);
      }
    }
  }
  return d;

}

vector<int> get_path(int t, const vector<int>& pv) {
    vector<int> path;
    while (t != -1) {
      path.push_back(t);
      t = pv[t];
    }
    reverse(path.begin(),path.end());
    return path;
}

void calc_graph() {
  d.resize(n);
  path.resize(n);
  store_on_path.resize(n);
  rep(i, n) {
    path[i].resize(n);
    store_on_path[i].resize(n, false);
  }

  rep(i, n) {
    vector<int> pv(n, -1);
    d[i] = dijkstra(i, n, pv, g);
    rep(j, n) {
      if (i == j) continue;
      path[i][j] = get_path(j, pv);
    }
  }
  store_on_path[0][0] = true;
  rep(i, n) {
    rep(j, n) {
      if (i == j) continue;
      rep2(k, 1, (int)path[i][j].size()) {
        if (path[i][j][k] == 0) store_on_path[i][j] = true;
      }
    }
  }
}

//nowtでidの注文を完了した時に、それによって得られるスコア
inline double calc_value(const int nowt, const int id) {
  double wait = (nowt - start_o[id]);
  return max(0.0, (double)T*T - wait*wait);
}


int update_ans(double& score, int& nowt, const vector<int>& TSP_path, vector<int>& ans, vector<int>& next_TSP_path) {
  assert(TSP_path[0] == 0);
  if (nowt < 9500) assert(TSP_path[(int)TSP_path.size()-1] == 0);
  //rep2(i, 1, (int)TSP_path.size()-1) assert(TSP_path[i] != 0);
  vector<pii> new_order; //まだ商品を持っていないが注文は来ているid
  int order_num = -1;
  int order_id = -1;
  int order_v = -1;
  int n_achive = -1;
  int n_put = -1;

  rep(i, (int)TSP_path.size()-1) {
    int now = TSP_path[i];
    int nx = TSP_path[i+1];
    if (nowt + d[now][nx] > T) return 0;
    double rate = 1;
    if (nowt < peak) rate = (double)nowt/peak;
    else rate = (double)(10001-nowt) /(10001-peak);
    //int limd = 1+Xor128() % (int)(1+30*rate);
    //double limd =1+10*rate+Xor128() % 20;
    //int limd = 10+Xor128()%(1 + (int)(6000/(int)new_order.size()));
    int limd = 5 + Xor128() % 30;
    //limd = 1+20*rate;
    //cerr << limd << " " << rate << endl;
    int limo = 50 + Xor128() % 200;
    /*
    double mx_order = 0;
    double ave_order = 0;
    double order_cnt = 0;
    rep(i, n) {
      if (order_info[i].size() == 0) continue;
      order_cnt++;
      ave_order += order_info[i].size();
      mx_order = max(mx_order, (double)order_info[i].size());
    }
    if (peak-5000 > nowt || nowt > peak+5000) {
      mx_order = INF;
      ave_order = INF;
    }
    ave_order /= n;
    */
    //cerr << "ave_order : " << ave_order << endl;
    //cerr << mx_order << endl;
    //cerr << order_cnt << endl;
    if (now != 0 && (nowt < T && (int)new_order.size() >= limo && d[now][0] <= limd && d[now][0]+nowt <= T)) {
      //if (nowt <= 10000 && (int)new_order.size() >= limo && d[now][0] <= limd) {
      //if (nowt >= 9500) last_return = true;
      assert(now != 0);
      //cerr << "return !" << endl;
      rep(j, (int)path[now][0].size()-1) {
        int pnow = path[now][0][j];
        int pnx = path[now][0][j+1];
        rep(k, d[pnow][pnx]) {
          //ans[nowt++] = pnx;
          cout << pnx+1 << endl;
          nowt++;
          string s;
          cin >> s;
          assert(s == "OK");
          if (k == d[pnow][pnx]-1) break;
          cin >> n_achive;
          cin >> order_num;
          if (order_num == 1) {
            cin >> order_id >> order_v;
            new_order.push_back({--order_id, --order_v});
            start_o.push_back(nowt);
          }
          cin >> n_put;
        }
        cin >> n_achive;
        if ((int)order_info[pnx].size() != 0) {
          int tmp_achive;
          rep(_, n_achive) cin >> tmp_achive;
          assert(pnx != 0);
          next_TSP_path.push_back(pnx);
          assert(n_achive == (int)order_info[pnx].size());
          for (int id : order_info[pnx]) {
            delivery_cnt++;
            score += calc_value(nowt, id);
          }
          order_info[pnx].clear();
        }
        if (nowt == T) return -1;
        cin >> order_num;
        if (order_num == 1) {
          cin >> order_id >> order_v;
          new_order.push_back({--order_id, --order_v});
          start_o.push_back(nowt);
        }
        cin >> n_put;
      }
      for (auto p : new_order) {
        int tmp_id;
        cin >> tmp_id;
        int id = p.fi;
        int v = p.se;
        order_info[v].push_back(id);
      }
      next_TSP_path.push_back(0);
      new_order.clear();
      return -1;
    }
    rep(j, (int)path[now][nx].size()-1) {
      int pnow = path[now][nx][j];
      int pnx = path[now][nx][j+1];
      //cout << d[pnow][pnx] << endl;
      rep(k, d[pnow][pnx]) {
        //ans[nowt++] = pnx;
        cout << pnx+1 << endl;
        nowt++;
        string s;
        cin >> s;
        assert(s == "OK");
        if (k == d[pnow][pnx]-1) {
          //cout << pnow << " " << pnx << " " << k << endl;
          break;
        }
        cin >> n_achive;
        cin >> order_num;
        if (order_num == 1) {
          cin >> order_id >> order_v;
          new_order.push_back({--order_id, --order_v});
          start_o.push_back(nowt);
        }
        cin >> n_put;
      }
      cin >> n_achive;
      //if (n_achive == 4) cout << 100000 << endl;
      if ((int)order_info[pnx].size() != 0) {
        int tmp_achive;
        //if (tmp_achive == 588) cout << tmp_achive << endl;
        rep(_, n_achive) cin >> tmp_achive;
        assert(pnx != 0);
        for (int id : order_info[pnx]) {
          delivery_cnt++;
          score += calc_value(nowt, id);
          //next_idS.insert({id, pnx});
        }
        next_TSP_path.push_back(pnx);
        order_info[pnx].clear();
      }
      if (nowt == T) return -1;
      cin >> order_num;
      if (order_num == 1) {
        cin >> order_id >> order_v;
        new_order.push_back({--order_id, --order_v});
        start_o.push_back(nowt);
      }
      cin >> n_put;
      if (pnx == 0) {
        int tmp_id;
        for (auto p : new_order) {
          cin >> tmp_id;
          int id = p.fi;
          int v = p.se;
          order_info[v].push_back(id);
        }
        next_TSP_path.push_back(0);
        new_order.clear();
        return -1;
      }
    }
  }
  return -1;
}

inline vector<int> heulistic_TSP(const int nowt, const vector<int>& DS) {
  priority_queue<pii> pq;
  for (int v : DS) {
    pq.push({order_info[v].size(), v});
  }
  vector<int> VS;
  int lm = 200;
  while ((int)VS.size() < lm && !pq.empty()) {
    pii x = pq.top(); pq.pop();
    VS.push_back(x.se);
  }

  vector<int> TSP_path;
  int now = 0;
  int tmp_nowt = nowt;
  TSP_path.push_back(0);
  vector<bool> visited(n, false);
  int cnt = 0;
  vector<pii> tmp_new_order(n);
  while (true) {
    double mn_score = INF;
    int nx = -1;
    for (auto v : VS) {
      if (visited[v]) continue;
      if (tmp_nowt + d[now][v] > T) continue;
      double ocnt = order_info[v].size();
      double tmp_score = d[now][v];
      double low = 20000;
      double up = 20000;
      if (peak-low <= nowt && nowt <= peak+up) {
        tmp_score = d[now][v]*d[now][v]*d[now][v] / (ocnt);
      }
      if (tmp_score < mn_score) {
        mn_score = tmp_score;
        nx = v;
        //cout << v << endl;
      }
    }
    //cout << nx << endl;
    if (nx == -1) break; //TSP完了
    visited[nx] = true;
    bool via_store = false;
    rep2(i, 1, (int)path[now][nx].size()) {
      if (path[now][nx][i] == 0) {
        via_store = true;
        break;
      }
    }
    if (via_store) {
      TSP_path.push_back(0);
      return TSP_path;
    }
    for (auto v : VS) {
      if (visited[v]) continue;
      if (d[now][nx] >= d[now][v] + d[v][nx]) {
        visited[v] = true;
        TSP_path.push_back(v);
        break;
      }
    }
    TSP_path.push_back(nx);
    tmp_nowt += d[now][nx];
    now = nx;
    cnt++;
    //if (cnt == 1000) break;
  }
  TSP_path.push_back(0);
  return TSP_path;
}

//最小単位で表現 (u->vをu->w->v)
vector<int> trans_minimum(const vector<int> TSP) {
  vector<int> ret;
  rep(i, (int)TSP.size()-1) {
    int now = TSP[i];
    int nx = TSP[i+1];
    rep(j, (int)path[now][nx].size()-1) {
      ret.push_back(path[now][nx][j]);
    }
    if (i == (int)TSP.size() - 2) {
      ret.push_back(0);
    }
  }
  return ret;
}


int delivery(double& score, int& nowt, vector<int>& ans, vector<vector<int>>& TSPS) {
  vector<int> DS;
  rep(i, n) {
    if ((int)order_info[i].size() == 0) continue;
    DS.push_back(i);
  }
  vector<pii> TSP_ans;
  vector<int> TSP_path;
  vector<int> best_TSP_path;
  //cerr << "heulistic_TSP" << endl;
  TSP_path = heulistic_TSP(nowt, DS);
  if ((int)TSP_path.size() == 2) return -2;
  best_TSP_path = TSP_path;
  //best_TSP_path = SA(nowt, TSP_path);
  //optimize_tsp(best_TSP_path);
  //best_TSP_path = trans_minimum(best_TSP_path);
  if ((int)best_TSP_path.size() <= 2) return -2;
  vector<int> next_TSP_path = {0};
  //set<pii> next_idS;
  //cerr << nowt << " " << best_TSP_path.size() << endl;
  int val = update_ans(score, nowt, best_TSP_path, ans, next_TSP_path);
  //cerr << nowt << endl;
  TSPS.push_back(next_TSP_path);
  //idS.push_back(next_idS);
  return val;
}


vector<int> solve() {
  double best_score = 0;
  vector<int> best_ans;
  vector<vector<int>> best_TSPS;
  //vector<set<pii>> best_idS;
  vector<int> best_TSP_start;
  vector<vector<vector<int>>> best_rec_order_info;
  vector<double> best_rec_score;
  int best_nowt =  0;
  double score = 0;
  int nowt = 0;
  vector<int> ans(T+1, -1);
  vector<vector<int>> TSPS;
  vector<int> TSP_start;
  //vector<set<pii>> idS;
  vector<vector<vector<int>>> rec_order_info;
  vector<double> rec_score;

  delivery_cnt = 0;
  rep(i, n) order_info[i].clear();
  int order_num = -1;
  int order_id = -1;
  int order_v = -1;
  int n_put = -1;
  int n_achive = -1;
  while (nowt < T) {
    cin >> order_num;
    if (order_num == 1) cin >> order_id >> order_v;
    cin >> n_put;
    if (n_put == 1) {
      int tmp_id;
      cin >> tmp_id;
      order_info[--order_v].push_back(--order_id);
      start_o.push_back(nowt);
      break;
    }
    cout << -1 << endl;
    nowt++;
    string s;
    cin >> s;
    assert(s == "OK");
    cin >> n_achive;
  }
  while (nowt < T) {
    //cerr << "will deliver " << nowt << endl;
    TSP_start.push_back(nowt);
    rec_order_info.push_back(order_info);
    rec_score.push_back(score);
    int update = delivery(score, nowt, ans, TSPS);
    if (update == 0) {
      while (nowt < T) {
        cout << -1 << endl;
        nowt++;
        string s;
        cin >> s;
        assert(s == "OK");
        cin >> n_achive;
        if (nowt == T) return best_ans;
        cin >> order_num;
        if (order_num == 1) cin >> order_id >> order_v;
        cin >> n_put;
        int tmp_id;
        rep(_, n_put) cin >> tmp_id;
      }
      break;
    }
    if (update == -2) {
      TSP_start.pop_back();
      rec_order_info.pop_back();
      rec_score.pop_back();
      cout << -1 << endl;
      string s;
      cin >> s;
      assert(s == "OK");
      nowt++;
      cin >> n_achive;
      while (nowt < T) {
        cin >> order_num;
        if (order_num == 1) cin >> order_id >> order_v;
        cin >> n_put;
        if (order_num == 1) {
          int tmp_id;
          cin >> tmp_id;
          order_info[--order_v].push_back(--order_id);
          start_o.push_back(nowt);
          break;
        }
        cout << -1 << endl;
        nowt++;
        cin >> s;
        assert(s == "OK");
        cin >> n_achive;
      }
    }
  }
  if (best_score < score) {
    //cout << " score : " << (ll)score <<  " best_score : " << (ll)best_score << " order_cnt : " << order_cnt << " delivery_cnt : " << delivery_cnt << " delivery_rate : " << (double)delivery_cnt / order_cnt << endl;
    best_score = score;
    best_ans = ans;
    max_score = score;
    best_TSPS = TSPS;
    //best_idS = idS;
    best_TSP_start = TSP_start;
    best_rec_order_info = rec_order_info;
    best_nowt = nowt;
    best_rec_score = rec_score;
  }
  return best_ans;
}

signed main() {
  cin.tie(0);
  ios::sync_with_stdio(false);
  seed(37);
  read();
  //cerr << "peak : " << peak << endl;
  //cerr << "read passed" << endl;
  calc_graph();
  //cerr << "calc_graph passed" << endl;
  //analysis();
  vector<int> ans = solve();
}


Measured memory_bytes: 22860