Problem: Unfortunately, a mistake was found in the proof of the author's solution to this problem. Currently, we don't know the absolutely correct solution. However, you can solve this task, but if your solution passes all the tests, it is not guaranteed to be correct. If your solution has passed all the tests and you are sure that it is correct, you can write to one of the contest authors about it.

Surely you all read the book "Alice in Wonderland". In this task, Nastya got to the country of Three strange Bees. The bees are strange because their honeycombs are pentagonal. Nastya got there illegally, so she wants bees not to catch her. Help the bees punish the intruder! 

This is an interactive problem.

A beehive is a connected undirected graph where bees and Nastya can move along the edges. A graph satisfies two properties: 

  * The degree of any of its vertex is no more than 3. 
  * For each edge, there exists a cycle of length not greater than 5 passing through this edge. 

There are three bees and Nastya. You play for bees. Firstly, you choose the vertices where you put the bees. Then Nastya chooses another vertex in which she will initially appear. One move is first moving the bees, then Nastya, in turn: 
  1. For each of your bees, you can either move each one along some edge from the vertex they are currently staying or leave it in place. 
  2. Then Nastya will necessarily move along some edge of the graph from the vertex she is currently staying/. 



You win if at least one of the bees and Nastya are in the same vertex at any time of the game.

If this situation does not occur after n moves, then you lose.

Several bees can be in the same vertex.

Input

The first line contains two integers n (4 ≤ n ≤ 5000) and m (n ≤ m ≤ 3n) — the number of vertices and edges in the graph.

Each of the next m lines contains two integers v and u (1 ≤ v, u ≤ n), which mean that there is an edge between the vertices v and u. It is guaranteed that the graph is connected, does not contain loops that the degree of any vertex does not exceed 3 and a cycle of length no more than 5 passes through each edge. Note that the graph may contain multiple edges.

Interaction

At each turn, you must output exactly three vertices a, b, c (1 ≤ a, b, c ≤ n). For the first time, 3 vertices displayed will indicate which vertices you originally placed bees on. In response, you will receive the vertex where the jury placed Nastya. Each next 3 vertices will indicate where the 3 bees move at your turn. Each of the bees can, regardless of other bees, both remain at the current vertex and move along the edge. After the next output of 3 vertices, in response, you get the number of the new vertex to which Nastya went.

As soon as one of the bees is at the same vertex with Nastya or you have reached the limit on the number of moves, your program should stop working. That is if you made a move, and one of the bees ended up at the same vertex with Nastya, your program must stop working, or if Nastya made a move and ended up at the same vertex with one of the bees, you should not make your move and the program should stop working.

If the number of moves exceeds limit (n, where n is the number of vertices), you will get the Wrong Answer verdict.

Your solution may receive the verdict Idleness Limit Exceeded if you don't output anything or forget to flush the output buffer.

To flush the output buffer, you need to do the following immediately after printing the query and the line end:

  * fflush(stdout) or cout.flush() in C++; 
  * System.out.flush() in Java; 
  * flush(output) in Pascal; 
  * stdout.flush() in Python; 
  * for other languages see documentation. 



In this problem interactor is adaptive. This means that depending on all your previous moves, Nastya's behavior may change.

Hacks are not available for this problem.

Examples

Input


5 5
1 2
2 3
3 4
4 5
5 1
4
5

Output


1 1 2
1 5 3

Input


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

Output


7 3 3
6 2 2
5 3 1

Note

Let Nastya be a green chip, and three numbered red ones are three bees.

In the first test, the movement of the heroes looks like this.

<image> After selecting the starting vertices. <image> The first move after the bees move. <image> The first move after the Nastya's move. The first bee caught Nastya.

In the second test, the movement of the heroes looks like this.

<image> After selecting the starting vertices. <image> The first move after the bees move. <image> The first move after the Nastya's move. <image> The second move after the bees move. The first bee caught Nastya.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
struct Candidate {
  std::vector<int> d;
  Candidate(std::vector<int> d_) {
    d = d_;
    std::sort(d.begin(), d.end());
    std::reverse(d.begin(), d.end());
  }
  inline bool operator<(const Candidate &rhs) {
    if (d[0] < 0 || rhs.d[0] < 0) return d[0] < rhs.d[0];
    for (int i = 0; i < static_cast<int>(d.size()); ++i)
      if (d[i] != rhs.d[i]) return d[i] < rhs.d[i];
    return false;
  }
};
int get_enemy_pos(std::vector<int> locations, bool mate) {
  std::cout << locations[0] + 1 << " " << locations[1] + 1 << " "
            << locations[2] + 1 << std::endl;
  if (!mate) {
    int pos;
    std::cin >> pos;
    return pos - 1;
  } else {
    return -1;
  }
}
std::vector<int> get_dist(std::vector<std::vector<int> > &adj, int src) {
  auto d = std::vector<int>(adj.size(), -1);
  auto q = std::queue<int>();
  q.push(src);
  d[src] = 0;
  while (!q.empty()) {
    int at = q.front();
    q.pop();
    for (auto &next : adj[at]) {
      if (d[next] < 0) {
        d[next] = d[at] + 1;
        q.push(next);
      }
    }
  }
  return d;
}
int main() {
  int nodes, edges;
  std::cin >> nodes >> edges;
  auto adj = std::vector<std::vector<int> >(nodes, std::vector<int>());
  for (int edge = 0; edge < edges; ++edge) {
    int src, dst;
    std::cin >> src >> dst;
    adj[src - 1].push_back(dst - 1);
    adj[dst - 1].push_back(src - 1);
  }
  srand(time(NULL));
  auto dists = std::vector<std::vector<int> >(static_cast<int>(adj.size()),
                                              std::vector<int>());
  int best_dist = nodes + 1;
  auto best_locs = std::vector<int>(3, -1);
  for (int iter = 0; iter < 5000; ++iter) {
    auto locs = std::vector<int>(3);
    for (int i = 0; i < static_cast<int>(locs.size()); ++i) {
      locs[i] = -1;
      bool ok = true;
      do {
        ok = true;
        locs[i] = rand() % nodes;
        for (int j = 0; j < i; ++j) {
          if (locs[i] == locs[j]) ok = false;
        }
      } while (!ok);
      if (dists[locs[i]].size() == 0) {
        dists[locs[i]] = get_dist(adj, locs[i]);
      }
    }
    int cand_dist = 1;
    for (int i = 0; i < nodes; ++i) {
      cand_dist = std::max(
          cand_dist, std::min(dists[locs[0]][i],
                              std::min(dists[locs[1]][i], dists[locs[2]][i])));
    }
    if (cand_dist < best_dist) {
      best_dist = cand_dist;
      best_locs = locs;
    }
  }
  auto locs = best_locs;
  auto enemy_pos = get_enemy_pos(locs, false);
  while (enemy_pos >= 0) {
    if (enemy_pos == locs[0] || enemy_pos == locs[1] || enemy_pos == locs[2]) {
      break;
    }
    auto targets = std::vector<int>();
    targets.push_back(enemy_pos);
    for (int repeats = 0; repeats < 0; ++repeats) {
      auto ntargets = std::vector<int>();
      for (auto &t : targets)
        for (auto &x : adj[t]) {
          ntargets.push_back(x);
        }
      for (auto &nt : ntargets) targets.push_back(nt);
      std::sort(targets.begin(), targets.end());
      targets.resize(std::unique(targets.begin(), targets.end()) -
                     targets.begin());
    }
    for (auto &x : targets) {
      if (dists[x].size() == 0) {
        dists[x] = get_dist(adj, x);
      }
    }
    auto d = std::vector<int>(static_cast<int>(locs.size()));
    auto best =
        Candidate(std::vector<int>(static_cast<int>(locs.size()), nodes + 1));
    auto cand_locs = std::vector<int>(3);
    auto best_locs = std::vector<int>(3, -1);
    for (int i = 0; i < 3; ++i) {
      std::random_shuffle(adj[locs[i]].begin(), adj[locs[i]].end());
    }
    static int choice[3];
    for (choice[0] = 0; choice[0] <= adj[locs[0]].size(); ++choice[0])
      for (choice[1] = 0; choice[1] <= adj[locs[1]].size(); ++choice[1])
        for (choice[2] = 0; choice[2] <= adj[locs[2]].size(); ++choice[2]) {
          bool mate = false;
          for (int i = 0; i < 3; ++i) {
            cand_locs[i] =
                (choice[i] == 0 ? locs[i] : adj[locs[i]][choice[i] - 1]);
            if (cand_locs[i] == enemy_pos) mate = true;
          }
          if (cand_locs[0] == cand_locs[1] || cand_locs[1] == cand_locs[2] ||
              cand_locs[0] == cand_locs[2]) {
            continue;
          }
          for (int j = 0; j < 3; ++j) d[j] = dists[targets[0]][cand_locs[j]];
          auto cand = Candidate(d);
          if (mate) {
            cand.d[0] = -1;
          }
          if (cand < best) {
            best = cand;
            best_locs = cand_locs;
          }
        }
    locs = best_locs;
    enemy_pos = get_enemy_pos(locs, best.d[0] < 0);
  }
  return 0;
}