#include <vector>
#include <iostream>
#include <algorithm>
#include <functional>
#include <string>
#include <limits.h>
#include <cmath>
#include <queue>
#include <map>
#include <iomanip>
#include <random>
#include <fstream>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;

ll gcd(ll a, ll b)
{
  ll r;
  while ((r = a % b))
  {
    a = b;
    b = r;
  }
  return b;
}

struct edge
{
  int u, v, d;
  bool operator<(const edge &right) const
  {
    if (u == right.u)
    {
      return d < right.d;
    }
    else
    {
      return u < right.u;
    }
  }
};

struct order
{
  int t, id, dst;
};

struct road
{
  int v,d;

};

int main()
{

  int vSize, eSize;
  cin >> vSize >> eSize;
  vector<edge> e(eSize * 2);
  rep(i, eSize) { cin >> e[i].u >> e[i].v >> e[i].d; }
  int Tmax;
  cin >> Tmax;
  vector<order> ord;
  rep(i, Tmax)
  {
    int n;
    cin >> n;
    rep(i, n)
    {
      order o;
      o.t = i;
      cin >> o.id >> o.dst;
      ord.push_back(o);
    }
  }

  rep(i, eSize)
  {
    e[i + eSize].u = e[i].v;
    e[i + eSize].v = e[i].u;
    e[i + eSize].d = e[i].d;
  }

  sort(e.begin(), e.end());

  /*
  ofstream outputfile("output.txt");

  rep(i, Tmax)
  {
    outputfile << "-1" << endl;
  }

  outputfile.close();
  */

  /*
  // 辺の情報を表示
  cout << "u"
       << " "
       << "v"
       << " "
       << "d" << endl;
  rep(i, eSize * 2)
  {
    cout << e[i].u << " " << e[i].v << " " << e[i].d << endl;
  }
  */

  vector<vector<road> > v(vSize + 1);

  rep(i, eSize * 2)
  {
    road r={e[i].v,e[i].d};
    v[e[i].u].push_back(r);
    //v[e[i].v].push_back(e[i].u);
  }

  /*
  for (int i = 1; i <= vSize; i++)
  {
    cout << i << ":";
    for (int j = 0; j < v[i].size(); j++)
    {
      cout << "{" << v[i][j].v << ", " << v[i][j].d << "} ";
    }
    cout << endl;
  }
  */

  /*
  // 1から一番近いところを往復する

  int dMin = e[0].d;
  int dMinV = e[0].v;

  rep(i, eSize)
  {
    if (e[i].u == 1)
    {
      if (e[i].d < dMin)
      {
        dMin = e[i].d;
        dMinV = e[i].v;
      }
    }
    else
    {
      break;
    }
  }

  // 0が配達、1が集荷
  int state = 0;
  rep(t, Tmax)
  {
    if (t / dMin % 2 == 0)
    {
      state = 0;
    }
    else
    {
      state = 1;
    }
    if (state == 0)
    {
      cout << dMinV << endl;
    }
    else
    {
      cout << 1 << endl;
    }
  }
  */

  // 1から近いとこかつ行ってないところに行き、行き詰まったらその道を戻る、を繰り返す
  // まずルートを決定する
  vector<int> visited;
  vector<int> route;
  vector<int> routeT;
  visited.push_back(1);
  int current = 1;
  while (1)
  {
    int flag = 0;
    for (int i = 0; i < v[current].size(); i++)
    {
      if (!binary_search(visited.begin(), visited.end(), v[current][i].v))
      {
        routeT.push_back(v[current][i].d);
        current = v[current][i].v;
        auto it = visited.insert(lower_bound(visited.begin(), visited.end(), current), current);
        route.push_back(current);
        flag = 1;
        break;
      }
    }
    if (flag == 0)
    {
      break;
    }
  }

  /*
  cout << "route:{";
  rep(i, route.size())
  {
    cout << route[i];
    if (i < route.size() - 1)
    {
      cout << ", ";
    }
  }
  cout << "}" << endl;

  cout << "routeT:{";
  rep(i, routeT.size())
  {
    cout << routeT[i];
    if (i < routeT.size() - 1)
    {
      cout << ", ";
    }
  }
  cout << "}" << endl;
  */

  //ルートを往復する
  int t=0;
  while (t<Tmax){
  //行き
    rep(i,routeT.size()){
      rep(j,routeT[i]){
        cout << route[i] << endl;
        t++; if(t==Tmax){return 0;}
      }
    } 

  //帰り
    for (int i=routeT.size()-2; i>=0; i--){
      rep(j,routeT[i+1]){
        cout << route[i] << endl;
        t++; if(t==Tmax){return 0;}
      }
    }
    rep(i, routeT[0]){
      cout << 1 << endl;
      t++; if(t==Tmax){return 0;}
    }
  }

  return 0;
}


Measured memory_bytes: 512