#include <iostream>
#include <vector>
#include <queue>

#define FOR(a,b,n) for(int a=(b);a<(n);a++)
#define REP(i,n) FOR(i,0,(n))

using namespace std;

typedef long long lint;
lint inf=1e9;

struct edge{
  int u,v,l;
  edge(int _u,int _v, int _l):u(_u),v(_v),l(_l){}
  edge reverse(){
    swap(u,v);
    return *this;
  }
  bool operator == (const edge& a)const{return u==a.u and v==a.v;}
};

//「edgeの始点からlの位置にいる」の意味
struct pos{
  pos(int _p):e(_p,_p,0),l(0){}
  pos(edge _e,int _l):e(_e),l(_l){}
  pos& reverse(){
    e=e.reverse();
    l=e.l-l;
    return *this;
  }
  bool operator == (const pos& a)const{
    auto a_copy=a;
    return (e==a_copy.e and l==a_copy.l)
    or(e==a_copy.reverse().e and l==a_copy.reverse().l);
  }
  pos& move(int dir,int d){
    if(dir==e.u){
      l-=d;
    }else if(dir==e.v){
      l+=d;
    }
    if(l==e.l)reverse();
    if(l==0){
      // posが頂点にある状態
      e.v=e.u;
    }
    return *this;
  }
  edge e;
  int l;
};

//「 p.firstに向かってp.second進む」の配列
using route=queue<pair<int,int> >;

vector<vector<pair<int,int> > > c;
vector<vector<int> > d;

// ワーシャルフロイドのマップからどのノードを経由するのが最適か計算
auto calc_neighbirhood_nood(const pos& start, const pos& goal){
  struct result{
    pos sn;
    pos gn;
  };
  auto s=start;
  auto g=goal;
  auto smin=s;
  auto gmin=g;
  int min_score=inf;
  // 辺の遡り方４パターン比較
  REP(i,2){
    REP(j,2){
      int score=d[s.e.u][g.e.u]+s.l+g.l;
      if(score<min_score){
          smin=s;
          gmin=g;
        min_score=score;
      }
      s.reverse();
    }
    g.reverse();
  }
  return result{smin,gmin};
}

// pos間の距離を計算(O(1))
int calc_distance(const pos& start, const pos& goal, route& r){
  auto s=start;
  auto g=goal;
  // 比較のために始点<=終点になるようにしておく
  if(s.e.u>s.e.v)s.reverse();
  if(g.e.u>g.e.v)g.reverse();
  if(s==g)return 0;
  else if(s.e == g.e)return abs(s.l-g.l);
  else{
    auto res=calc_neighbirhood_nood(s,g);
    auto smin=res.sn;
    auto gmin=res.gn;
    return s.l+g.l+d[s.e.u][g.e.u];
  }
}


// pos間のルートを算出(O(N))
void calc_route(const pos& start, const pos& goal, route& r){
  auto s=start;
  auto g=goal;
  // 比較のために始点<=終点になるようにしておく
  if(s.e.u>s.e.v)s.reverse();
  if(g.e.u>g.e.v)g.reverse();
  // ワーシャルフロイドのマップからどのノードを経由するのが最適か計算
  if(s==g){//同一地点ならルート生成しない
    ;
  }else if(s.e == g.e){// 同一辺内なら
    if(s.l<=g.l)r.push(make_pair(s.e.v,g.l-s.l));
    else r.push(make_pair(s.e.u,s.l-g.l));
  }else{
    auto res=calc_neighbirhood_nood(s,g);
    auto smin=res.sn;
    auto gmin=res.gn;
    // 始点ノードまで移動
    if(smin.l)r.push(make_pair(smin.e.u,smin.l));
    // 始点ノードから終点ノードまで移動
    int cn=smin.e.u;
    int gn=gmin.e.u;
    while(cn!=gn){
      for(auto e:c[cn]){
        if(d[e.first][gn]+e.second==d[cn][gn]){
          r.push(e);
          cn=e.first;
          break;
        }
      }
    }
    // 終点ノードから終点まで移動
    if(gmin.l)r.push(make_pair(gmin.e.v,gmin.l));
  }
}

pos compute_dist(int t){
  if(t>5000)return 100;
  return 0;
}

int main(){
  int N,M;
  cin>>N>>M;
  c.assign(N,vector<pair<int,int> >());
  d.assign(N,vector<int>(N,inf));
  REP(i,N)d[i][i]=0;
  REP(i,M){
    int u,v,l;
    cin>>u>>v>>l;
    u--;v--;
    c[u].push_back(make_pair(v,l));
    c[v].push_back(make_pair(u,l));
    d[u][v]=l;
    d[v][u]=l;
  }

  int T;
  cin>>T;
  vector<pair<int,int> > v;
  REP(t,T){
    int K;
    cin>>K;
    REP(j,K){
      int id,dst;
      cin>>id>>dst;
      dst--;
      // とりあえず注文時間と目的地だけ保存
      v.push_back(make_pair(t,dst));
    }
  }
  // ワーシャルフロイド
  REP(k,N)REP(i,N)REP(j,N)d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
  pos pnow(0),dist(0),dist_pre(0);
  int step=0;
  route r;
  REP(t,T){
    dist = compute_dist(t);
    if(!(dist==dist_pre)){
      // 前のルートを破棄して再計算
      r=route();
      calc_route(pnow,dist,r);
      step=0;
    }
    // routeに沿ってpnowを進める and 出力
    if(r.empty()){
      cout<<-1<<endl;
    }else{
      int dir = r.front().first;
      int l = r.front().second;
      cout<<dir+1<<endl;
      pnow.move(dir,1);
      step++;
      if(step>=l){
        r.pop();
        step=0;
      }
    }

    dist_pre=dist;
  }
  return 0;
}

Measured memory_bytes: 1024