Ashish has an array a of size n.

A subsequence of a is defined as a sequence that can be obtained from a by deleting some elements (possibly none), without changing the order of the remaining elements.

Consider a subsequence s of a. He defines the cost of s as the minimum between: 

  * The maximum among all elements at odd indices of s. 
  * The maximum among all elements at even indices of s. 



Note that the index of an element is its index in s, rather than its index in a. The positions are numbered from 1. So, the cost of s is equal to min(max(s_1, s_3, s_5, …), max(s_2, s_4, s_6, …)).

For example, the cost of \{7, 5, 6\} is min( max(7, 6), max(5) ) = min(7, 5) = 5.

Help him find the minimum cost of a subsequence of size k.

Input

The first line contains two integers n and k (2 ≤ k ≤ n ≤ 2 ⋅ 10^5) — the size of the array a and the size of the subsequence.

The next line contains n integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^9) — the elements of the array a.

Output

Output a single integer — the minimum cost of a subsequence of size k.

Examples

Input


4 2
1 2 3 4


Output


1

Input


4 3
1 2 3 4


Output


2

Input


5 3
5 3 4 2 6


Output


2

Input


6 4
5 3 50 2 4 5


Output


3

Note

In the first test, consider the subsequence s = \{1, 3\}. Here the cost is equal to min(max(1), max(3)) = 1.

In the second test, consider the subsequence s = \{1, 2, 4\}. Here the cost is equal to min(max(1, 4), max(2)) = 2.

In the fourth test, consider the subsequence s = \{3, 50, 2, 4\}. Here the cost is equal to min(max(3, 2), max(50, 4)) = 3.
import java.io.*;
import java.util.*;

public class d {
	public static void main(String[] args) throws IOException {
		FastScanner stdin = new FastScanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		
		int n = stdin.nextInt();
		int k = stdin.nextInt();
		
		thing[] in = new thing[n];
		for (int i = 0; i < n; i++) in[i] = new thing(i, stdin.nextInt());
		
		Arrays.sort(in);
				
		TreeSet<clus> ind = new TreeSet<>();
		int len = 0, ans = Integer.MAX_VALUE;
		for (int i = 0; i < n; i++)
		{
			if (k%2==0 && in[i].indx == n-1) continue;
			
			clus curr = new clus(in[i].indx, in[i].indx);
			clus low = ind.lower(curr);
			clus hi = ind.higher(curr);
			
			if (low != null && hi != null && low.r == in[i].indx-1 && hi.l == in[i].indx+1)
			{
				len -= (low.r-low.l+2)/2;
				len -= (hi.r-hi.l+2)/2;
				low.r = hi.r;
				ind.remove(hi);
				len += (low.r-low.l+2)/2;
			}
			else if (low != null && low.r == in[i].indx-1)
			{
				len -= (low.r-low.l+2)/2;
				low.r = in[i].indx;
				len += (low.r-low.l+2)/2;
			}
			else if (hi != null && hi.l == in[i].indx+1)
			{
				len -= (hi.r-hi.l+2)/2;
				hi.l = in[i].indx;
				len += (hi.r-hi.l+2)/2;
			}
			else
			{
				ind.add(curr);
				len++;
			}
			
			if (len >= (k+1)/2)
			{
				ans = Math.min(ans, in[i].num);
				break;
			}			
		}
				
		ind.clear();
		len = 0;
		for (int i = 0; i < n; i++)
		{
			if (in[i].indx == 0) continue;
			if (k%2==1 && in[i].indx == n-1) continue;
			
			clus curr = new clus(in[i].indx, in[i].indx);
			clus low = ind.lower(curr);
			clus hi = ind.higher(curr);
			
			if (low != null && hi != null && low.r == in[i].indx-1 && hi.l == in[i].indx+1)
			{
				len -= (low.r-low.l+2)/2;
				len -= (hi.r-hi.l+2)/2;
				low.r = hi.r;
				ind.remove(hi);
				len += (low.r-low.l+2)/2;
			}
			else if (low != null && low.r == in[i].indx-1)
			{
				len -= (low.r-low.l+2)/2;
				low.r = in[i].indx;
				len += (low.r-low.l+2)/2;
			}
			else if (hi != null && hi.l == in[i].indx+1)
			{
				len -= (hi.r-hi.l+2)/2;
				hi.l = in[i].indx;
				len += (hi.r-hi.l+2)/2;
			}
			else
			{
				ind.add(curr);
				len++;
			}
						
			if (len >= k/2)
			{
				ans = Math.min(ans, in[i].num);
				break;
			}			
		} 
		
		out.println(ans);
		
		out.flush();
	}
	
	static class clus implements Comparable<clus>
	{
		int l, r;
		
		public clus(int ll, int rr) { l=ll; r=rr; }
		
		public int compareTo(clus o) { 
			return l - o.l; 
		}
		
		public String toString() { return l + " " + r; }
	}
	
	static class thing implements Comparable<thing>
	{
		int indx, num;
		
		public thing(int i, int n) { indx = i; num = n; }
		
		public int compareTo(thing o) { return num - o.num; };
		
		public String toString() { return indx + " " + num; }
	}
	
	static class FastScanner {
	    BufferedReader br;
	    StringTokenizer st;
		
	    public FastScanner(InputStream i) {
	        br = new BufferedReader(new InputStreamReader(i));
	        st = new StringTokenizer("");
	    }
				
	    public String next() throws IOException {
	        if(st.hasMoreTokens())
	            return st.nextToken();
	        else
	            st = new StringTokenizer(br.readLine());
	        return next();
	    }

	    public int nextInt() throws IOException {
	        return Integer.parseInt(next());
	    }
	   
	    public long nextLong() throws IOException {
	        return Long.parseLong(next());
	    }
	    
	    public double nextDouble() throws IOException {
	        return Double.parseDouble(next());
	    }
	 }
}
