Problem: Requirements

* All inputs are of non-negative integer value.
* T_{\text{max}} = 10000
* 200 \leq |V| \leq 400
* 1.5 |V| \leq |E| \leq 2 |V|
* 1 \leq u_{i}, v_{i} \leq |V| (1 \leq i \leq |E|)
* 1 \leq d_{u_i, v_i} \leq \lceil 4\sqrt{2|V|} \rceil (1 \leq i \leq |E|)
* The given graph has no self-loops / multiple edges and is guaranteed to be connected.
* 0 \leq N_{\text{new}} \leq 1
* 1 \leq \mathrm{new\\_id}_{i} \leq T_{\text{last}}+1 (1 \leq i \leq N_{\text{new}}). Note: If all orders are generated by the order generation rule as explained above, the total number of orders is at most T_{\text{last}}+1. Therefore, the possible range of \mathrm{new\\_id}_{i} should be from 1 to T_{\text{last}}+1.
* 2 \leq \mathrm{dst}_i \leq |V| (1 \leq i \leq N_{\text{new}})
* The order IDs \mathrm{new\\_{id}}_i are unique.

Input Format

Input is provided in the following form:


|V| |E|
u_{1} v_{1} d_{u_{1}, v_{1}}
u_{2} v_{2} d_{u_{2}, v_{2}}
:
u_{|E|} v_{|E|} d_{u_{|E|}, v_{|E|}}
T_{\text{max}}
\mathrm{info}_{0}
\mathrm{info}_{1}
:
\mathrm{info}_{T_{\text{max}}-1}


* In the first line |V| denotes the number of vertices, while |E| denotes the number of edges.
* The following |E| lines denote the edges of the graph. In particular, in the ith line u_{i} and v_{i} denote the edge connecting u_{i} and v_{i} and d_{u_{i}, v_{i}} the corresponding distance.
* The following line denotes the number of steps T_{\text{max}}.



In the following line, \mathrm{info}_t is information about the order from the customer that occurs at time t. \mathrm{info}_t is given in the form:


N_{\text{new}}
\mathrm{new\_id}_1 \mathrm{dst}_1
\mathrm{new\_id}_2 \mathrm{dst}_2
\vdots
\mathrm{new\_id}_{N_{\text{new}}} \mathrm{dst}_{N_{\text{new}}}


* N_{\text{new}} represents the number of new orders which appear at time t.
* The next N_{\text{new}} lines give the newly generated order information. The i-th order information indicates that the order ID \mathrm{new\\_{id}}_i of the new order, while \mathrm{dst}_i denotes the vertex to which the customer wishes the order to be delivered.
* Note: If N_{\text{new}}=0, there are no new lines.

Output Format

The Output expects T_{\text{max}} integers in the format specified below.


\mathrm{command}_{0}
\mathrm{command}_{1}
:
\mathrm{command}_{T_{\text{max}}-1}


In particular, \mathrm{command}_{i} shall specify the movement of the delivery car by using one of the following two options:

1) `stay`, if the car shall not move:


-1


2) `move w`, if the car shall be moved one step towards the neighboring vertex w


w


Note that in case of 2) w has to satisfy the following conditions:

* w \in V
* If the car is at vertex u: \left\\{ u, w \right\\} \in E .
* If the car is on the edge \left\\{ u, v \right\\}, w must either satisfy u = w or v = w.



* * *

Examples

Input




Output




Input

5 7
1 2 5
5 3 4
2 4 8
1 5 1
2 3 3
4 5 3
4 3 9
4
1
1 2
1
2 5
1
3 4
0


Output

2
-1
1
5

Solution (in CPP):

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

using namespace std;
#define FOR(i, N) for (int i = 0; i < (int)N; i++)
#define FORIN(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define INF (1 << 29)

using Pi = pair<int, int>;

string to_string(string s) {
  return s;
}

template <class S, class T>
string to_string(pair<S, T> p) {
  return "{" + to_string(p.first) + "," + to_string(p.second) + "}";
}

template <class S>
string to_string(unordered_set<S> s) {
  string ret = "{";
  for (S x : s)
    ret += to_string(x) + ",";
  return ret + "}";
}

template <class S, class T>
string to_string(map<S, T> m) {
  string ret = "{";
  for (pair<S, T> x : m)
    ret += to_string(x) + ",";
  return ret + "}";
}

template <class T>
string to_string(vector<T> v) {
  string ret = "{";
  for (int i = 0; i < (int)v.size() - 1; ++i) {
    ret += to_string(v[i]) + ",";
  }
  if (v.size() > 0) {
    ret += to_string(v.back());
  }
  ret += "}";
  return ret;
}

void debug() {
  cerr << endl;
}

template <class Head, class... Tail>
void debug(Head head, Tail... tail) {
  cerr << to_string(head) << " ";
  debug(tail...);
}
using Ppi = pair<int, pair<int, int>>;

int V, E, T;
vector<vector<Pi>> G;
vector<vector<int>> orders;
vector<vector<int>> dists;
vector<vector<vector<Ppi>>> pathes;

void find_pathes() {
  vector<vector<int>> prev(V, vector<int>(V));
  FOR(i, V) {
    dists[i][i] = 0;
    FOR(j, V) { prev[i][j] = i; }
  }
  FOR(k, V) {
    FOR(i, V) {
      FOR(j, V) {
        if (dists[i][k] + dists[k][j] < dists[i][j]) {
          dists[i][j] = dists[i][k] + dists[k][j];
          prev[i][j] = prev[k][j];
        }
      }
    }
  }
  FOR(s, V) {
    FOR(g, V) {
      int now = g;
      while (now != s) {
        int pr = prev[s][now];
        pathes[s][g].push_back(Ppi(dists[s][now] - dists[s][pr], Pi(pr, now)));
        now = pr;
      }
    }
  }
}

int main() {
  cin >> V >> E;
  G.resize(V);
  dists = vector<vector<int>>(V, vector<int>(V, INF));
  pathes.resize(V);
  FOR(i, V) { pathes[i].resize(V); }
  FOR(i, E) {
    int u, v, d;
    cin >> u >> v >> d;
    u--;
    v--;
    G[u].emplace_back(d, v);
    G[v].emplace_back(d, u);
    dists[u][v] = d;
    dists[v][u] = d;
  }
  find_pathes();
  cin >> T;
  orders.resize(T);
  int now = 0;
  int next = 0;
  vector<int> wait;
  unordered_set<int> can;
  vector<int> actions(T * 10, -1);
  FOR(i, T) {
    int Nnew;
    cin >> Nnew;
    FOR(j, Nnew) {
      int new_id, dst;
      cin >> new_id >> dst;
      wait.push_back(dst - 1);
    }
    if (now == i) {
      if (next == 0) {
        for (int v : wait) {
          can.insert(v);
        }
        wait.clear();
      }
      if (!can.empty()) {
        vector<Pi> candi;
        for (int v : can) {
          candi.push_back(Pi(dists[next][v], v));
        }
        int g = min_element(ALL(candi))->second;
        can.erase(g);
        vector<Ppi> path = pathes[next][g];
        for (int a = path.size() - 1; a >= 0; --a) {
          FOR(b, path[a].first) { actions[now++] = path[a].second.second + 1; }
        }
        next = g;
      } else {
        if (next == 0) {
          now++;
        } else {
          int g = 0;
          vector<Ppi> path = pathes[next][0];
          for (int a = path.size() - 1; a >= 0; --a) {
            FOR(b, path[a].first) {
              actions[now++] = path[a].second.second + 1;
            }
          }
          next = 0;
        }
      }
    }
  }
  FOR(i, T) { cout << actions[i] << endl; }
  return 0;
}