output_description: 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. 
  
  * * *
input_description: 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.
attempt: import random
  
  
  class maps(object):
      def __init__(self):
          with open("test.in") as f:
              self.readinputs(f)
  
      # recieve |V| and |E|
      def readinputs(self, file):
          self.V, self.E = map(int, file.readline().split())
          self.es = [[] for i in range(self.V)]
          self.Mes = [[0] * self.V for i in range(self.V)]
  
          for _ in range(self.E):
              # recieve edges
              a, b, c = map(int, file.readline().split())
              a, b = a - 1, b - 1
              self.es[a].append((b, c))
              self.es[b].append((a, c))
              self.Mes[a][b] = c
              self.Mes[b][a] = c
  
          self.T = int(file.readline())
  
          # recieve info
          self.info = [[] for i in range(self.T)]
          for t in range(self.T):
              Nnew = int(file.readline())
              for _ in range(Nnew):
                  new_id, dst = map(int, file.readline().split())
                  self.info[t].append((new_id, dst))
  
      def random_walk(self):
          where = [("v", 0)]  # ('e',from,to,dist)
  
          self.path = [0] * self.T
          for t in range(self.T):
              now_where = where[-1]
              if now_where[0] == "v":
                  to, dist = random.choice(self.es[now_where[1]])
                  # to, dist = self.es[now_where[1]][n]
                  self.path[t] = to
                  if dist == 1:
                      where.append(("v", to))
                  else:
                      where.append(("e", now_where[1], to, 1))
              elif now_where[0] == "e":
                  now_where = where[-1]
                  num = random.randint(0, 1)
  
                  if num == 0:
                      self.path[t] = now_where[2]
                      if now_where[3] + 1 < self.Mes[now_where[1]][now_where[2]]:
                          where.append(
                              ("e", now_where[1], now_where[2], now_where[3] + 1)
                          )
                      elif now_where[3] + 1 == self.Mes[now_where[1]][now_where[2]]:
                          where.append(("v", now_where[2]))
                      else:
                          # ココの分岐に来ることはありえない。
                          pass
  
                  else:
                      self.path[t] = now_where[1]
                      if now_where[3] - 1 > 0:
                          where.append(
                              ("e", now_where[1], now_where[2], now_where[3] - 1)
                          )
                      elif now_where[3] - 1 == 0:
                          where.append(("v", now_where[1]))
                      else:
                          # ココの分岐に来ることはありえない。
                          pass
              else:
                  # ココの分岐に来ることはありえない。
                  pass
  
      def all_stay(self):
          self.path = [0] * self.T
          for t in range(self.T):
              self.path[t] = -1
  
      def output(self):
          for t in range(self.T):
              print(self.path[t] + 1)
  
  
  if __name__ == "__main__":
      M = maps()
      M.random_walk()
      M.output()
  
problem_description: Setting
samples: []