#include <algorithm>
#include <iostream>
#include <fstream>
#include <vector>
#include <utility>
#include <random>
#include <string.h>
#define inf 100000000
//#define DEBUG
using namespace std;
typedef long long int ll;

const unsigned long long int cycle_per_sec = 2800000000;

unsigned long long int getCycle() {
    unsigned int low, high;
    __asm__ volatile ("rdtsc" : "=a" (low), "=d" (high));
    return ((unsigned long long int)low) | ((unsigned long long int)high << 32);
}

double getTime (unsigned long long int begin_cycle) {
    return (double)(getCycle() - begin_cycle) / cycle_per_sec;
}

class XorShift {
public:
    unsigned int x;
    unsigned int y;
    unsigned int z;
    unsigned int w;
    unsigned int t;
    
    XorShift(int tmp) {
        mt19937 rnd(tmp);
        x = rnd();
        y = rnd();
        z = rnd();
        w = rnd();
        t = 1;
    }
    
    int rand() {
        t = x ^ (x << 11);
        x = y;
        y = z;
        z = w;
        w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
        return w & 0x7fffffff;
    }
} engine(rand());

const int PEAK_UPDATE_SPAN = 100;

int V, E;
vector<pair<int,int>> EDGE[400];
int DIST[400][400];
const int Tmax = 10000;
int F[400];
int ORDER[Tmax];
int PEAK;
int ORDER_FREQ[PEAK_UPDATE_SPAN];
double order_acc[Tmax];

struct STATE {
    ll score;
    int tour_size;
    pair<int,int> tours[Tmax];
    int orders_sum;
    int orders_si[400];
    int orders[400][200];
    int havings_si[400];
    int havings[400][200];
    int pos; // -1 if on edge

    STATE() {
        score = 0;
        tour_size = 0;
        pos = 0;
        orders_sum = 0;
        memset(orders_si, 0, sizeof(orders_si));
        memset(havings_si, 0, sizeof(havings_si));
    }

    void copy (STATE& st) {
        score = st.score;
        tour_size = st.tour_size;
        pos = st.pos;
        orders_sum = st.orders_sum;
        for (int i = 0; i < V; i++) {
            orders_si[i] = st.orders_si[i];
            for (int j = 0; j < orders_si[i]; j++) {
                orders[i][j] = st.orders[i][j];
            }
            havings_si[i] = st.havings_si[i];
            for (int j = 0; j < havings_si[i]; j++) {
                havings[i][j] = st.havings[i][j];
            }
        }
    }
};

void init() {
    PEAK = 4750;
    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
            DIST[i][j] = inf;
        }
        DIST[i][i] = 0;
    }
    for (int i = 0; i < V; i++) {
        for (pair<int, int>& e: EDGE[i]) {
            DIST[i][e.first] = min(DIST[i][e.first], e.second);
        }
    }
    for (int u = 0; u < V; u++) {
        for (int i = 0; i < V; i++) {
            for (int j = 0; j < V; j++) {
                DIST[i][j] = min(DIST[i][j], DIST[i][u] + DIST[u][j]);
            }
        }
    }
}

void update_peak(int si) {
    int bestp = PEAK;
    double bestval = (double)inf;
    for (int p = 0; p < 9500; p += 100) {
        double val = 0.0;
        for (int i = 0; i < si; i++) {
            double ratio = ORDER_FREQ[i]/(double)PEAK_UPDATE_SPAN;
            int mid = i*PEAK_UPDATE_SPAN + PEAK_UPDATE_SPAN/2;
            double ex = (p>=mid)?(mid/(double)p):((9500-mid)/(double)(9500-p));
            val += (ratio-ex)*(ratio-ex);
        }
        if (val < bestval) {
            bestval = val;
            bestp = p;
        }
    }
    PEAK = bestp;
}

void update_order_acc() {
    for (int i = 0; i < Tmax; i++) {
        if (i > 0) order_acc[i] = order_acc[i-1];
        if (i < PEAK) {
            order_acc[i] += i / (double)PEAK;
        } else if (i <= 9500) {
            order_acc[i] += (9500-i) / (double)(9500-PEAK);
        }
    }
}

void input() {
    cin >> V >> E;
    for(int i = 0; i < E; i++) {
        // recieve edges
        int u, v, d; std::cin >> u >> v >> d;
        u--; v--;
        EDGE[u].push_back({v, d});
        EDGE[v].push_back({u, d});
    }
    for (int i = 0; i < V; i++) {
        cin >> F[i];
    }
    int _;
    cin >> _;
}

void optimize_path(vector<int>& path) {
    if (path.size() <= 3) return;
    int n = path.size();

    vector<int> best_path = path;
    int best_score = inf;

    for (int z = 0; z < 5; z++) {
        unsigned long long int start_cycle = getCycle();
        double TIME_LIMIT = 0.1;

        double now_t = 0.0;

        for (int loop = 0;; loop++) {
            if (loop%1000 == 0) {
                now_t = getTime(start_cycle);
                if (now_t > TIME_LIMIT) break;
            }

            if (engine.rand()%2) {
                int i = engine.rand()%n;
                int j = engine.rand()%n;
                if (i >= j) swap(i,j);
                if (j-i <= 1 || j-i == n-1) continue;

                int j2 = (j+1)%n;
                int ori_dist = DIST[path[i]][path[i+1]] + DIST[path[j]][path[j2]];
                int new_dist = DIST[path[i]][path[j]] + DIST[path[i+1]][path[j2]];

                if (new_dist <= ori_dist) {
                    int swap_st = i+1, swap_en = j;
                    while (swap_st < swap_en) {
                        swap(path[swap_st], path[swap_en]);
                        swap_st++;
                        swap_en--;
                    }
                }
            } else {
                int i = engine.rand()%(n-1)+1;
                int j = engine.rand()%n;
                if (i == j || i-1 == j) continue;

                int i2 = (i+1)%n;
                int j2 = (j+1)%n;
                int ori_dist = DIST[path[i-1]][path[i]] + DIST[path[i]][path[i2]] + DIST[path[j]][path[j2]];
                int new_dist = DIST[path[i-1]][path[i2]] + DIST[path[j]][path[i]] + DIST[path[i]][path[j2]];

                if (new_dist <= ori_dist) {
                    if (i > j) {
                        int tmp = path[i];
                        for (int k = i-1; k > j; k--) path[k+1] = path[k];
                        path[j+1] = tmp;
                    } else {
                        int tmp = path[i];
                        for (int k = i+1; k <= j; k++) path[k-1] = path[k];
                        path[j] = tmp;
                    }
                }
            }
        }
        int now_pos = 0;
        int score = 0;
        for (int i = 0; i < n; i++) {
            score += DIST[now_pos][path[i]];
            now_pos = path[i];
        }
        // cerr << score << " ";
        if (score < best_score) {
            best_path = path;
            score = best_score;
        }
        random_shuffle(path.begin()+1, path.end());
    }
    path = best_path;
}

void tsp(STATE& state, int now_t) {
    vector<int> points;
    for (int i = 0; i < V; i++) {
        if (state.havings_si[i]) {
            points.push_back(i);
        }
    }
    if (points.size() == 0) return;
    points.push_back(0);
    sort(points.begin(), points.end());

    vector<bool> saw((int)points.size(), false);
    vector<int> path((int)points.size());
    int pre = 0;
    path[0] = points[0];
    saw[pre] = true;
    for (int i = 0; i < (int)points.size()-1; i++) {
        int dis = inf;
        int to = -1;
        for (int j = 0; j < (int)points.size(); j++) {
            if (saw[j]) continue;
            if (dis > DIST[points[pre]][points[j]]) {
                dis = DIST[points[pre]][points[j]];
                to = j;
            }
        }
        pre = to;
        saw[to] = true;
        path[i+1] = points[to];
    }
    optimize_path(path);
    for (int i = 0; i < (int)path.size()-1; i++) {
        path[i] = path[i+1];
    }
    path[(int)path.size()-1] = points[0];

    int path_time = 0;
    {
        int now_pos = 0;
        for (int i = 0; i < (int)path.size()-1; i++) {
            path_time += DIST[now_pos][path[i]];
            now_pos = path[i];
        }
    }

    // do reverse
    while (true) {
        bool end = true;
        for (int i = 0; i < (int)path.size()-2; i++) {
            for (int z = i+2; z < (int)path.size()-1; z++) {
                if (DIST[path[i]][path[i+1]] == DIST[path[i]][path[z]]+DIST[path[i+1]][path[z]]) {
                    int tmp = path[z];
                    for (int j = z-1; j >= i+1; j--) path[j+1] = path[j];
                    path[i+1] = tmp;
                    end = false;
                    break;
                }
            }
            if (!end) break;
        }
        if (end) break;
    }
    {
        int tmp_acc = now_t;
        int pre_pos = 0;
        for (int i = 0; i < (int)path.size()-2; i++) {
            tmp_acc += DIST[pre_pos][path[i]];
            pre_pos = path[i];
            if (tmp_acc+DIST[path[i]][0] >= Tmax) break;
            double ord_cnt = order_acc[tmp_acc+DIST[path[i]][0]]-order_acc[now_t];
            if (DIST[path[i]][0]+DIST[0][path[i+1]]-DIST[path[i]][path[i+1]] < ord_cnt/10) {
                if (DIST[path[i]][0] == DIST[path[i]][path[i+1]]+DIST[path[i+1]][0]) continue;
                path[i+1] = 0;
                path.erase(path.begin()+i+2, path.end());
                break;
            }
        }
    }

    int now_pos = points[0];
    for (int i = 0; i < (int)path.size(); i++) {
        while (now_pos != path[i]) {
            for (pair<int,int> e : EDGE[now_pos]) {
                if (DIST[now_pos][path[i]] == e.second + DIST[e.first][path[i]]) {
                    state.tours[state.tour_size++] = pair<int,int>(e.first, e.second);
                    now_pos = e.first;
                    break;
                }
            }
        }
    }
    reverse(state.tours, state.tours+state.tour_size);

}

void solve() {
    STATE now_state;
    for (int i = 0; i < Tmax; i++) {
        ORDER[i] = -1;
        int Nnew, trash;
        cin >> Nnew;
        if (Nnew == 1) {
            cin >> trash >> ORDER[i];
            ORDER[i]--;
        }
        int Nput;
        cin >> Nput;
        for (int j = 0; j < Nput; j++) cin >> trash;
        if (ORDER[i] != -1) {
            ORDER_FREQ[i*PEAK_UPDATE_SPAN/Tmax]++;
            now_state.orders_sum++;
            now_state.orders[ORDER[i]][now_state.orders_si[ORDER[i]]++] = i;
        }
        if (i%PEAK_UPDATE_SPAN == PEAK_UPDATE_SPAN-1) {
            update_peak(i*PEAK_UPDATE_SPAN/Tmax+1);
        }

        if (now_state.pos == 0) {
            now_state.orders_sum = 0;
            for (int v = 0; v < V; v++) {
                for (int j = 0; j < now_state.orders_si[v]; j++) {
                    now_state.havings[v][now_state.havings_si[v]++] = now_state.orders[v][j];
                }
                now_state.orders_si[v] = 0;
            }
            now_state.tour_size = 0;
        }
        if (!now_state.tour_size) {
            tsp(now_state, i);
        }

        if (now_state.tour_size) {
            int to = now_state.tours[now_state.tour_size-1].first;
            cout << to+1 << endl;
            now_state.tours[now_state.tour_size-1].second--;
            if (!now_state.tours[now_state.tour_size-1].second) {
                now_state.havings_si[to] = 0;
                now_state.tour_size--;
                now_state.pos = to;
                /*
                if (to != 0 && DIST[to][0] < now_state.orders_sum/200) {
                    int now_pos = to;
                    now_state.tour_size = 0;
                    while (now_pos != 0) {
                        for (pair<int,int> e : EDGE[now_pos]) {
                            if (DIST[now_pos][0] == e.second + DIST[e.first][0]) {
                                now_state.tours[now_state.tour_size++] = pair<int,int>(e.first, e.second);
                                now_pos = e.first;
                                break;
                            }
                        }
                    }
                    reverse(now_state.tours, now_state.tours+now_state.tour_size);
                }
                */
            } else {
                now_state.pos = -1;
            }
        } else {
            cout << -1 << endl;
        }
        string verdict; cin >> verdict;
        if (verdict == "NG") {
            exit(1);
        }

        // the number of orders that have been delivered at time t.
        int Nachive; cin >> Nachive;
        for(int j = 0; j < Nachive; j++) {
            int achive_id; cin >> achive_id;
        }
    }
}

int main() {
    input();

    init();

    solve();

    return 0;
}

Measured memory_bytes: 2644