Problem: This is an interactive task.

Scientists are about to invent a new optimization for the Floyd-Warshall algorithm, which will allow it to work in linear time. There is only one part of the optimization still unfinished.

It is well known that the Floyd-Warshall algorithm takes a graph with n nodes and exactly one edge between each pair of nodes. The scientists have this graph, what is more, they have directed each edge in one of the two possible directions.

To optimize the algorithm, exactly m edges are colored in pink color and all the rest are colored in green. You know the direction of all m pink edges, but the direction of green edges is unknown to you. In one query you can ask the scientists about the direction of exactly one green edge, however, you can perform at most 2 ⋅ n such queries.

Your task is to find the node from which every other node can be reached by a path consisting of edges of same color. Be aware that the scientists may have lied that they had fixed the direction of all edges beforehand, so their answers may depend on your queries.

Input

The first line contains two integers n and m (1 ≤ n ≤ 100 000, 0 ≤ m ≤ 100 000) — the number of nodes and the number of pink edges.

The next m lines describe the pink edges, the i-th of these lines contains two integers u_i, v_i (1 ≤ u_i, v_i ≤ n, u_i ≠ v_i) — the start and the end of the i-th pink edge. It is guaranteed, that all unordered pairs (u_i, v_i) are distinct.

Output

When you found the answer, print "!" and the number of the node from which every other node can be reached by a single-colored path.

Interaction

To ask the direction of the green edge between nodes a and b, print "?", a and b in single line, separated by the space characters. 

In answer to this read a single integer, which will be 1 if the edge is directed from a to b and 0 if the edge is directed from b to a.

You can ask at most 2 ⋅ n queries, otherwise you will get Wrong Answer.

After printing a query do not forget to output end of line and flush the output. Otherwise you will get Idleness limit exceeded. To do this, use: 

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



Answer -1 instead of 0 or 1 means that you made an invalid query or exceeded the query limit. Exit immediately after receiving -1 and you will see Wrong answer verdict. Otherwise you can get an arbitrary verdict because your solution will continue to read from a closed stream.

Hacks

Hacks should be formatted as follows.

The first line should contain two integers n and m (1 ≤ n ≤ 300, 0 ≤ m ≤ n ⋅ (n - 1) / 2) — the number of nodes and number of pink edges.

The next m lines should describe the pink edges, the i-th line should contain 2 integers a_i, b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i), which means that there is a pink edge from a_i to b_i. All unordered pairs (a_i, b_i) should be distinct.

The next (n ⋅ (n - 1) / 2 - m) lines should describe the green edges, the i-th line should contain two integers a_i, b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i)), which means that there is a green edge from a_i to b_i. All unordered pairs of (a_i, b_i) should be distinct and should also be different from the pairs for the pink edges.

Example

Input


4 2
1 2
3 4
0
1
1

Output


? 1 3
? 4 2
? 3 2
! 3

Note

In the example above the answer for the query "? 1 3" is 0, so the edge is directed from 3 to 1. The answer for the query "? 4 2" is 1, so the edge is directed from 4 to 2. The answer for the query "? 3 2" is 1, so the edge is directed from 3 to 2. So there are green paths from node 3 to nodes 1 and 2 and there is a pink path from node 3 to node 4.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int _w;
int n, m;
namespace G {
int head[N], nxt[N], to[N], eid;
void init() {
  eid = 0;
  memset(head, -1, sizeof head);
}
void link(int u, int v) { to[eid] = v, nxt[eid] = head[u], head[u] = eid++; }
}  // namespace G
namespace SCC {
int dfn[N], clk, low[N], sccid[N], sccn, stk[N], top;
vector<int> scc[N], scc_backup[N];
int sccin[N];
deque<int> que;
void dfs(int u) {
  using namespace G;
  dfn[u] = low[u] = ++clk;
  stk[top++] = u;
  for (int i = head[u]; ~i; i = nxt[i]) {
    int v = to[i];
    if (!dfn[v]) {
      dfs(v);
      low[u] = min(low[u], low[v]);
    } else if (!sccid[v]) {
      low[u] = min(low[u], dfn[v]);
    }
  }
  if (low[u] == dfn[u]) {
    ++sccn;
    scc[sccn].clear();
    while (1) {
      int o = stk[--top];
      sccid[o] = sccn;
      scc[sccn].push_back(o);
      if (o == u) break;
    }
  }
}
void calc_in() {
  using namespace G;
  for (int u = 1; u <= n; ++u)
    for (int i = head[u]; ~i; i = nxt[i]) {
      int v = to[i];
      if (sccid[u] != sccid[v]) ++sccin[sccid[v]];
    }
}
void erase(int id) {
  using namespace G;
  for (auto u : scc_backup[id])
    for (int i = head[u]; ~i; i = nxt[i]) {
      int v = to[i];
      if (sccid[u] != sccid[v]) {
        --sccin[sccid[v]];
        if (sccin[sccid[v]] == 0) {
          que.push_front(sccid[v]);
        }
      }
    }
}
int merge(int scc1, int scc2) {
  using namespace G;
  while (scc[scc1].size() && scc[scc2].size()) {
    int u = scc[scc1].back();
    int v = scc[scc2].back();
    printf("? %d %d\n", u, v);
    fflush(stdout);
    int dir;
    _w = scanf("%d", &dir);
    if (dir == 1) {
      scc[scc2].pop_back();
    } else {
      scc[scc1].pop_back();
      swap(scc1, scc2);
    }
  }
  if (scc[scc1].empty()) {
    erase(scc1);
    return scc2;
  } else {
    erase(scc2);
    return scc1;
  }
}
void solve() {
  for (int i = 1; i <= n; ++i) dfn[i] = low[i] = sccid[i] = 0;
  sccn = top = clk = 0;
  for (int i = 1; i <= n; ++i)
    if (!dfn[i]) dfs(i);
  for (int i = 1; i <= sccn; ++i) scc_backup[i] = scc[i];
  calc_in();
  for (int i = 1; i <= sccn; ++i)
    if (!sccin[i]) que.push_back(i);
  while (que.size() >= 2) {
    int scc1 = que.back();
    que.pop_back();
    int scc2 = que.back();
    que.pop_back();
    que.push_back(merge(scc1, scc2));
  }
  printf("! %d\n", scc[que.back()].back());
  fflush(stdout);
}
}  // namespace SCC
int main() {
  _w = scanf("%d%d", &n, &m);
  G::init();
  for (int i = 0; i < m; ++i) {
    int u, v;
    _w = scanf("%d%d", &u, &v);
    G::link(u, v);
  }
  SCC::solve();
  return 0;
}