This is an interactive problem.

You are given a sorted in increasing order singly linked list. You should find the minimum integer in the list which is greater than or equal to x.

More formally, there is a singly liked list built on an array of n elements. Element with index i contains two integers: valuei is the integer value in this element, and nexti that is the index of the next element of the singly linked list (or -1, if the current element is the last). The list is sorted, i.e. if nexti ≠ - 1, then valuenexti > valuei.

You are given the number of elements in the list n, the index of the first element start, and the integer x.

You can make up to 2000 queries of the following two types:

  * ? i (1 ≤ i ≤ n) — ask the values valuei and nexti, 
  * ! ans — give the answer for the problem: the minimum integer, greater than or equal to x, or ! -1, if there are no such integers. Your program should terminate after this query. 



Write a program that solves this problem.

Input

The first line contains three integers n, start, x (1 ≤ n ≤ 50000, 1 ≤ start ≤ n, 0 ≤ x ≤ 109) — the number of elements in the list, the index of the first element and the integer x.

Output

To print the answer for the problem, print ! ans, where ans is the minimum integer in the list greater than or equal to x, or -1, if there is no such integer.

Interaction

To make a query of the first type, print ? i (1 ≤ i ≤ n), where i is the index of element you want to know information about.

After each query of type ? read two integers valuei and nexti (0 ≤ valuei ≤ 109,  - 1 ≤ nexti ≤ n, nexti ≠ 0).

It is guaranteed that if nexti ≠ - 1, then valuenexti > valuei, and that the array values give a valid singly linked list with start being the first element.

Note that you can't ask more than 1999 queries of the type ?.

If nexti = - 1 and valuei = - 1, then it means that you asked more queries than allowed, or asked an invalid query. Your program should immediately terminate (for example, by calling exit(0)). You will receive "Wrong Answer", it means that you asked more queries than allowed, or asked an invalid query. If you ignore this, you can get other verdicts since your program will continue to read from a closed stream.

Your solution will get "Idleness Limit Exceeded", if you don't print anything or forget to flush the output, including the final answer.

To flush you can use (just after printing a query and line end):

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



Hacks format

For hacks, use the following format:

In the first line print three integers n, start, x (1 ≤ n ≤ 50000, 1 ≤ start ≤ n, 0 ≤ x ≤ 109).

In the next n lines print the description of the elements of the list: in the i-th line print two integers valuei and nexti (0 ≤ valuei ≤ 109,  - 1 ≤ nexti ≤ n, nexti ≠ 0).

The printed structure should be a valid singly linked list. In particular, it should be possible to reach all elements from start by following links nexti, and the last element end should have -1 in the nextend.

Example

Input

5 3 80
97 -1
58 5
16 2
81 1
79 4


Output

? 1
? 2
? 3
? 4
? 5
! 81

Note

You can read more about singly linked list by the following link: <https://en.wikipedia.org/wiki/Linked_list#Singly_linked_list>

The illustration for the first sample case. Start and finish elements are marked dark. <image>
import java.io.*;
import java.util.*;

public class D {

  private static final String REGEX = " ";
  private static final Boolean DEBUG = false;
  private static final String FILE_NAME = "input.txt";


  public static void main(String[] args) throws IOException {
    if (DEBUG) {
      generate();
    }
    Solver solver = new Solver();
    solver.readData();
    solver.solve();
    solver.print();
  }

  private static void generate() throws IOException {
//    FileWriter writer = new FileWriter("input.txt");
//    writer.close();
  }

  private static class Solver {
    private StringBuilder myStringBuilder = new StringBuilder();
    int n, start, x;
    private Scanner myScanner;

    void readData() throws IOException {
      myScanner = new Scanner();
      n = myScanner.nextInt();
      start = myScanner.nextInt();
      x = myScanner.nextInt();
    }

    void solve() throws IOException {
      PrintStream out = System.out;
      PrintWriter printWriter = new PrintWriter(out);
      int lowerBound = 0;
      int upperBound = 1000000000;
      int q = 2000;
      int nextLower = start;
      int nextIndex;
      List<Integer> nextArr = new ArrayList<>(n);
      for (int i = 1; i <= n; i++) {
        nextArr.add(i);
      }
      Collections.shuffle(nextArr);
      int index = 0;

      while (q > 1000 && (upperBound - lowerBound) > q && x - lowerBound > q && index < n) {
        nextIndex = nextArr.get(index++);
        printWriter.println("? " + nextIndex);
        printWriter.flush();
        q--;
        int value = myScanner.nextInt();
        int xxx = myScanner.nextInt();
        if (value == x) {
          printWriter.print("! " + value);
          printWriter.flush();
          return;
        }
        if (value > x && value < upperBound) {
          upperBound = value;
        } else if (value < x && value > lowerBound) {
          lowerBound = value;
          nextLower = xxx;
        }
      }
      nextIndex = nextLower;
      while (q > 0 && nextIndex > 0) {
        printWriter.println("? " + nextIndex);
        printWriter.flush();
        q--;
        int value = myScanner.nextInt();
        nextIndex = myScanner.nextInt();
        if (value >= x) {
          printWriter.print("! " + value);
          printWriter.flush();
          return;
        }
      }
      printWriter.print("! " + -1);
      printWriter.flush();
    }

    void print() {
      System.out.println(myStringBuilder);
    }


    void out(Object object) {
      myStringBuilder.append(object);
    }

    void out(String string) {
      myStringBuilder.append(string);
    }

    public void out(boolean b) {
      myStringBuilder.append(b);
    }

    public void out(char c) {
      myStringBuilder.append(c);
    }

    public void out(int i) {
      myStringBuilder.append(i);
    }

    public void out(long lng) {
      myStringBuilder.append(lng);
    }

    public void out(float f) {
      myStringBuilder.append(f);
    }

    public void out(double d) {
      myStringBuilder.append(d);
    }

    public void newLine() {
      myStringBuilder.append("\n");
    }

    @SuppressWarnings("SameParameterValue")
    int[] splitInteger(String string, int n) {
      final String[] split = string.split(REGEX, n);
      int[] result = new int[split.length];
      for (int i = 0; i < n; ++i) {
        result[i] = Integer.parseInt(split[i]);
      }
      return result;
    }

    public int[] splitInteger(String string) {
      return splitInteger(string, 0);
    }


    @SuppressWarnings("SameParameterValue")
    long[] splitLong(String string, int n) {
      final String[] split = string.split(REGEX, n);
      long[] result = new long[split.length];
      for (int i = 0; i < n; ++i) {
        result[i] = Long.parseLong(split[i]);
      }
      return result;
    }

    public long[] splitLong(String string) {
      return splitLong(string, 0);
    }

    @SuppressWarnings("SameParameterValue")
    double[] splitDouble(String string, int n) {
      final String[] split = string.split(REGEX, n);
      double[] result = new double[split.length];
      for (int i = 0; i < n; ++i) {
        result[i] = Double.parseDouble(split[i]);
      }
      return result;
    }

    public double[] splitDouble(String string) {
      return splitDouble(string, 0);
    }

    @SuppressWarnings("SameParameterValue")
    String[] splitString(String string, int n) {
      return string.split(REGEX, n);
    }

    public String[] splitString(String string) {
      return splitString(string, 0);
    }

    public int max(int a, int b) {
      return Math.max(a, b);
    }

    public int max(int[] arr) {
      int max = Integer.MIN_VALUE;
      for (int x : arr) {
        max = max(max, x);
      }
      return max;
    }

    public long max(long a, long b) {
      return Math.max(a, b);
    }

    public int min(int a, int b) {
      return Math.min(a, b);
    }

    public long min(long a, long b) {
      return Math.min(a, b);
    }

    public double max(double a, double b) {
      return Math.max(a, b);
    }

    public double min(double a, double b) {
      return Math.min(a, b);
    }

    private final static int MOD = 1000000009;

    int multMod(int a, int b) {
      return ((a % MOD) * (b % MOD)) % MOD;
    }

    int sumMod(int a, int b) {
      return ((a % MOD) + (b % MOD)) % MOD;
    }

    long multMod(long a, long b) {
      return ((a % MOD) * (b % MOD)) % MOD;
    }

    long sumMod(long a, long b) {
      return ((a % MOD) + (b % MOD)) % MOD;
    }

    int sum(int[] arr) {
      int sum = 0;
      for (int i = 0; i < arr.length; i++) {
        sum += arr[i];
      }
      return sum;
    }

    long sum(long[] arr) {
      long sum = 0;
      for (int i = 0; i < arr.length; i++) {
        sum += arr[i];
      }
      return sum;
    }

  }

  private static class Scanner {
    private int currentIndex = 0;
    private String[] objects;
    private final BufferedReader myReader;
    private Computable<Character> charComputer;
    private Computable<Double> doubleComputer;
    private Computable<Integer> intComputer;
    private Computable<Long> longComputer;

    Scanner() throws FileNotFoundException {
      InputStream in = DEBUG ? new FileInputStream(FILE_NAME) : System.in;
      myReader = new BufferedReader(new InputStreamReader(in));
      charComputer = () -> objects[currentIndex].charAt(0);
      doubleComputer = () -> Double.parseDouble(objects[currentIndex]);
      intComputer = () -> Integer.parseInt(objects[currentIndex]);
      longComputer = () -> Long.parseLong(objects[currentIndex]);
    }

    String nextLine() throws IOException {
      objects = null;
      currentIndex = 0;
      return myReader.readLine();
    }

    int nextInt() throws IOException {
      return next(intComputer);

    }

    long nextLong() throws IOException {
      return next(longComputer);

    }

    double nextDouble() throws IOException {
      return next(doubleComputer);

    }

    char nextChar() throws IOException {
      return next(charComputer);
    }

    <T> T next(Computable<T> computer) throws IOException {
      T result;
      if (objects == null || currentIndex >= objects.length) {
        String s = myReader.readLine();
        objects = s.split(" ");
        currentIndex = 0;
      }
      result = computer.compute();
      currentIndex++;
      return result;
    }

    interface Computable<T> {
      T compute();
    }

    public void close() throws IOException {
      myReader.close();
    }
  }

}
