Recently, on the course of algorithms and data structures, Valeriy learned how to use a deque. He built a deque filled with n elements. The i-th element is a_i (i = 1, 2, …, n). He gradually takes the first two leftmost elements from the deque (let's call them A and B, respectively), and then does the following: if A > B, he writes A to the beginning and writes B to the end of the deque, otherwise, he writes to the beginning B, and A writes to the end of the deque. We call this sequence of actions an operation.

For example, if deque was [2, 3, 4, 5, 1], on the operation he will write B=3 to the beginning and A=2 to the end, so he will get [3, 4, 5, 1, 2].

The teacher of the course, seeing Valeriy, who was passionate about his work, approached him and gave him q queries. Each query consists of the singular number m_j (j = 1, 2, …, q). It is required for each query to answer which two elements he will pull out on the m_j-th operation.

Note that the queries are independent and for each query the numbers A and B should be printed in the order in which they will be pulled out of the deque.

Deque is a data structure representing a list of elements where insertion of new elements or deletion of existing elements can be made from both sides.

Input

The first line contains two integers n and q (2 ≤ n ≤ 10^5, 0 ≤ q ≤ 3 ⋅ 10^5) — the number of elements in the deque and the number of queries. The second line contains n integers a_1, a_2, ..., a_n, where a_i (0 ≤ a_i ≤ 10^9) — the deque element in i-th position. The next q lines contain one number each, meaning m_j (1 ≤ m_j ≤ 10^{18}).

Output

For each teacher's query, output two numbers A and B — the numbers that Valeriy pulls out of the deque for the m_j-th operation.

Examples

Input


5 3
1 2 3 4 5
1
2
10


Output


1 2
2 3
5 2


Input


2 0
0 0


Output

Note

Consider all 10 steps for the first test in detail:
  1. [1, 2, 3, 4, 5] — on the first operation, A and B are 1 and 2, respectively.

So, 2 we write to the beginning of the deque, and 1 — to the end.

We get the following status of the deque: [2, 3, 4, 5, 1].

  2. [2, 3, 4, 5, 1] ⇒ A = 2, B = 3.
  3. [3, 4, 5, 1, 2]
  4. [4, 5, 1, 2, 3]
  5. [5, 1, 2, 3, 4]
  6. [5, 2, 3, 4, 1]
  7. [5, 3, 4, 1, 2]
  8. [5, 4, 1, 2, 3]
  9. [5, 1, 2, 3, 4]
  10. [5, 2, 3, 4, 1] ⇒ A = 5, B = 2. 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.InputMismatchException;
import java.util.TreeMap;
import java.util.TreeSet;

public class Solution1 implements Runnable {
	static final long MAX = 464897L;

	static class InputReader {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;
		private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();

			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}

				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}

		public int nextInt() {
			int c = read();

			while (isSpaceChar(c))
				c = read();

			int sgn = 1;

			if (c == '-') {
				sgn = -1;
				c = read();
			}

			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));

			return res * sgn;
		}

		public long nextLong() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;

			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public double nextDouble() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.') {
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.') {
				c = read();
				double m = 1;
				while (!isSpaceChar(c)) {
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public String readString() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));

			return res.toString();
		}

		public boolean isSpaceChar(int c) {
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public String next() {
			return readString();
		}

		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}
	}

	public static void main(String args[]) throws Exception {
		new Thread(null, new Solution1(), "Solution1", 1 << 26).start();
	}

	static long gcd(long a, long b) {
		if (b == 0)
			return a;
		return gcd(b, a % b);
	}

	static long lcm(long a, long b) {
		return (a * b) / gcd(a, b);
	}

	int maxn = 1000005;
	long MOD = 998244353;
	long prime = 29;
	ArrayList<Pair> adj[];
	TreeMap<Long, Long> tmap = new TreeMap();
	int[] val;
	int[] ans;
	long[] arr;
	ArrayList<Long> segTree[];
	public void run() {
		InputReader sc = new InputReader(System.in);
		PrintWriter w = new PrintWriter(System.out);
		int n = sc.nextInt();
		int quer = sc.nextInt();
	
		ArrayDeque<Integer> q = new ArrayDeque<Integer>();
		int[] arr = new int[n];
		ArrayList<Pair> ar  = new ArrayList();
		long max = Long.MIN_VALUE;
		for(int i = 0;i < n;i++) {
			arr[i] = sc.nextInt();
			q.addLast(arr[i]);
			max = Math.max(max,arr[i]);
		}
		for(int i = 0;i < n;i++) {
			int one = q.pollFirst();
			int two = q.pollFirst();
			ar.add(new Pair(one,two,1));
			if(one > two) {
				q.addFirst(one);
				q.addLast(two);
			}else {
				q.addFirst(two);
				q.addLast(one);
			}
			if(one == max || two == max) {
				break;
			}
		}
		ArrayList<Integer> another = new ArrayList();
		boolean first = true;
		while(!q.isEmpty()) {
			int x = q.pollFirst();
			if(!first) {
				another.add(x);
			}
			first = false;
		}
		for(int i = 0;i < quer;i++) {
			long x = sc.nextLong();
			if(ar.size() >= x) {
				w.println(ar.get((int)x-1).a + " " + ar.get((int)x-1).b);
			}else {
				long temp = x - ar.size() - 1;
				int sec = another.get((int)((temp) % (n-1)));
				w.println(max + " " + sec);
			}
		}
		w.close();
	}
	
	static long power(long a, long b, long mod) {
		long ans = 1;
		a = a % mod;
		while (b != 0) {
			if (b % 2 == 1) {
				ans = (ans * a) % mod;
			}
			a = (a * a) % mod;
			b = b / 2;
		}
		return ans;
	}

	class Pair implements Comparable<Pair> {
		int a;
		int b;
		int c;

		Pair(int a, int b, int c) {
			this.b = b;
			this.a = a;
			this.c = c;
		}

		public boolean equals(Object o) {
			Pair p = (Pair) o;
			return this.a == p.a && this.b == this.b;
		}

		public int hashCode() {
			return Long.hashCode(a) * 27 + Long.hashCode(b) * 31;
		}
		public int compareTo(Pair p) {
			return Long.compare(p.a, this.a);
		}
	}

	class Pair2 implements Comparable<Pair2> {
		int a;
		int b;
		int c;

		Pair2(int a, int b, int c) {
			this.b = b;
			this.a = a;
			this.c = c;
		}

		public boolean equals(Object o) {
			Pair p = (Pair) o;
			return this.a == p.a && this.b == this.b;
		}

		public int hashCode() {
			return Long.hashCode(a) * 27 + Long.hashCode(b) * 31;
		}

		public int compareTo(Pair2 p) {
			return Long.compare(this.b, p.b);
		}
	}
}