Problem: // We decided to drop the legend about the power sockets but feel free to come up with your own :^)

Define a chain: 

  * a chain of length 1 is a single vertex; 
  * a chain of length x is a chain of length x-1 with a new vertex connected to the end of it with a single edge. 



You are given n chains of lengths l_1, l_2, ..., l_n. You plan to build a tree using some of them.

  * Each vertex of the tree is either white or black. 
  * The tree initially only has a white root vertex. 
  * All chains initially consist only of white vertices. 
  * You can take one of the chains and connect any of its vertices to any white vertex of the tree with an edge. The chain becomes part of the tree. Both endpoints of this edge become black. 
  * Each chain can be used no more than once. 
  * Some chains can be left unused. 



The distance between two vertices of the tree is the number of edges on the shortest path between them.

If there is at least k white vertices in the resulting tree, then the value of the tree is the distance between the root and the k-th closest white vertex.

What's the minimum value of the tree you can obtain? If there is no way to build a tree with at least k white vertices, then print -1.

Input

The first line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 2 ≤ k ≤ 10^9) — the number of chains and the minimum number of white vertices a tree should have to have a value.

The second line contains n integers l_1, l_2, ..., l_n (3 ≤ l_i ≤ 2 ⋅ 10^5) — the lengths of the chains.

Output

Print a single integer. If there is no way to build a tree with at least k white vertices, then print -1. Otherwise, print the minimum value the tree can have.

Examples

Input


1 2
3


Output


2


Input


3 3
4 3 3


Output


3


Input


3 5
4 3 4


Output


4


Input


2 10
5 7


Output


-1

Note

<image>

You are allowed to not use all the chains, so it's optimal to only use chain of length 4 in the second example.

Solution (in CPP):

Solution:
 #include <bits/stdc++.h>
// #include <atcoder/all>

//using namespace atcoder;
//tabaicho  see https://boostjp.github.io/tips/multiprec-int.html   
// #include <boost/multiprecision/cpp_int.hpp>

// using namespace boost::multiprecision;

// cpp_int
// int128_t
// int256_t
// int512_t
// int1024_t

// uint128_t
// uint256_t
// uint512_t
// uint1024_t



#define int long long
 #define inf  1000000007
// #define inf  998244353

 #define pa pair<int,int>
 #define ll long long
 #define PI 3.14159265358979323846
 #define  mp make_pair
 #define  pb push_back
 #define EPS (1e-8)
 
      using namespace std;
                                          
 int dx[8]={0,1,0,-1,1,1,-1,-1};
 int dy[8]={1,0,-1,0,-1,1,1,-1};
                                            
class pa3{
	public:
	int x;
	int y,z;
	pa3(int x=0,int y=0,int z=0):x(x),y(y),z(z) {}
	bool operator < (const pa3 &p) const{
		if(x!=p.x) return x<p.x;
		if(y!=p.y) return y<p.y;
		 return z<p.z;
		//return x != p.x ? x<p.x: y<p.y;
	}
	bool operator > (const pa3 &p) const{
		if(x!=p.x) return x>p.x;
		if(y!=p.y) return y>p.y;
		 return z>p.z;
		//return x != p.x ? x<p.x: y<p.y;
	}
	bool operator == (const pa3 &p) const{
		return x==p.x && y==p.y && z==p.z;
	}
		bool operator != (const pa3 &p) const{
			return !( x==p.x && y==p.y && z==p.z);
	}

};

class pa4{
	public:
	int x;
	int y,z,w;
	pa4(int x=0,int y=0,int z=0,int w=0):x(x),y(y),z(z),w(w) {}
	bool operator < (const pa4 &p) const{
		if(x!=p.x) return x<p.x;
		if(y!=p.y) return y<p.y;
		if(z!=p.z)return z<p.z;
		return w<p.w;
		//return x != p.x ? x<p.x: y<p.y;
	}
	bool operator > (const pa4 &p) const{
		if(x!=p.x) return x>p.x;
		if(y!=p.y) return y>p.y;
		if(z!=p.z)return z>p.z;
		return w>p.w;
		//return x != p.x ? x<p.x: y<p.y;
	}
	bool operator == (const pa4 &p) const{
		return x==p.x && y==p.y && z==p.z &&w==p.w;
	}
		

};
class pa2{
	public:
	int x,y;
	pa2(int x=0,int y=0):x(x),y(y) {}
	pa2 operator + (pa2 p) {return pa2(x+p.x,y+p.y);}
	pa2 operator - (pa2 p) {return pa2(x-p.x,y-p.y);}
	bool operator < (const pa2 &p) const{
		return y != p.y ? y<p.y: x<p.x;
	}
	bool operator > (const pa2 &p) const{
		return x != p.x ? x<p.x: y<p.y;
	}
	bool operator == (const pa2 &p) const{
		return abs(x-p.x)==0 && abs(y-p.y)==0;
	}
	bool operator != (const pa2 &p) const{
		return !(abs(x-p.x)==0 && abs(y-p.y)==0);
	}
		

};



string itos( int i ) {
	ostringstream s ;
	s << i ;
	return s.str() ;
}
 
int Gcd(int v,int b){
	if(v==0) return b;
	if(b==0) return v;
	if(v>b) return Gcd(b,v);
	if(v==b) return b;
	if(b%v==0) return v;
	return Gcd(v,b%v);
}


 int mod;
int extgcd(int a, int b, int &x, int &y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    int d = extgcd(b, a%b, y, x);
    y -= a/b * x;
    return d;
}
pa operator+(const pa & l,const pa & r) {   
    return {l.first+r.first,l.second+r.second};                                    
}    
pa operator-(const pa & l,const pa & r) {   
    return {l.first-r.first,l.second-r.second};                                    
}  

ostream& operator<<(ostream& os, const vector<int>& VEC){
	for(auto v:VEC)os<<v<<" ";
    return os;
}

ostream& operator<<(ostream& os, const pa& PAI){
	os<<PAI.first<<" : "<<PAI.second;
    return os;
}

ostream& operator<<(ostream& os, const pa3& PAI){
	os<<PAI.x<<" : "<<PAI.y<<" : "<<PAI.z;
    return os;
}

ostream& operator<<(ostream& os, const pa4& PAI){
	os<<PAI.x<<" : "<<PAI.y<<" : "<<PAI.z<<" : "<<PAI.w;
    return os;
}

ostream& operator<<(ostream& os, const vector<pa>& VEC){
	for(auto v:VEC)os<<v<<" ";
    return os;
}


int beki(int wa,int rr,int warukazu){
	if(rr==0) return 1%warukazu;
	if(rr==1) return wa%warukazu;
	wa%=warukazu;
	if(rr%2==1) return ((ll)beki(wa,rr-1,warukazu)*(ll)wa)%warukazu;
	ll zx=beki(wa,rr/2,warukazu);
	return (zx*zx)%warukazu;
}

              
int pr[2100000];
int inv[2100000];



int comb(int nn,int rr){
	if(rr<0 || rr>nn || nn<0) return 0;
	int r=pr[nn]*inv[rr];
	r%=mod;
	r*=inv[nn-rr];
	r%=mod;
	return r;
}

void gya(int ert){
	pr[0]=1;
	for(int i=1;i<=ert;i++){
		pr[i]=((ll)pr[i-1]*i)%mod;
	}
		inv[ert]=beki(pr[ert],mod-2,mod);
	for(int i=ert-1;i>=0;i--){
		inv[i]=(ll)inv[i+1]*(i+1)%mod;
	}
}


                


                
              //   cin.tie(0);
    		//	ios::sync_with_stdio(false);
    			//priority_queue<pa3,vector<pa3>,greater<pa3>> pq;            
                 //sort(ve.begin(),ve.end(),greater<int>());
 //   mt19937(clock_per_sec);
  //  mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count()) ;


struct seg_chusho{
	//       1
	//   2        3
	// 4   5   6    7
	using Node =int;
	using Sayo =int;	
	
	private:
	public:
	
	// 1<<15 = 32768
	// 1<<16 = 65536
	// 1<<17 = 131072
	// 1<<18 = 262144
	
	int cor=(1<<18);
	// node k : [ (cor/msb)*(k&(msb-1)) , (cor/msb)*((k&(msb-1))+1))
	// where msb=(1<<(31-__builtin_clz(k)));
	
	


	// 遅延が貯まっていないときに保持する値
	Sayo S_id=0;
	
	Node N_id=0;
	
	Node node_merge(Node x,Node y){
		// x と yをマージする 区間和なら和
		
		// ここに実装する
		return x+y;
		if(x==N_id)return y;
		if(y==N_id)return x;
	//	return x+y;
	}
	Sayo merge_sayo(Sayo x,Sayo y){
		// 作用xの上から作用yを更にのっける
		return x+y;
		// ここに実装する
		if(x==S_id)return y;
		if(y==S_id)return x;
		
		
	}
	
	Node node_sayo(Node x,Sayo y,int k){
		// 区間[l,r)のNode k に作用yを載せる
	// node k : [ (cor/msb)*(k&(msb-1)) , (cor/msb)*((k&(msb-1))+1))
	// where msb=(1<<(31-__builtin_clz(k)));
	// len = cor>>(31-__builtin_clz(k));
		int len=cor>>(31-__builtin_clz(k));
		return x+y*len;
		
		// ここに実装する
		
		
	}
	
	
	vector<Node> vec;
	vector<Sayo> lazy;
	
	void shoki1(){
		//S_id,N_idが未定義ならここでやる
		vec.resize(2*cor+3, N_id);
		lazy.resize(2*cor+3,S_id);
	}
	void shoki2(){
		for(int i=cor-1;i>0;i--) vec[i]=node_merge(vec[2*i],vec[2*i+1]);
	}
	

	Node chien(int k){
		if(lazy[k]==S_id) return vec[k];
		if(k<cor){
			lazy[k*2]=merge_sayo(lazy[k*2],lazy[k]);
			lazy[k*2+1]=merge_sayo(lazy[k*2+1],lazy[k]);
		}
		vec[k]=node_sayo(vec[k],lazy[k],k);
		lazy[k]=S_id;
		return vec[k];
	}
	
	void  clear_chien(int r){
		// 1 ~ r までの遅延を開放する
		if(r==0)return;
		int f=31-__builtin_clz(r);
		int pos=0;
		int len=cor;
		for(int i=f;i>=0;i--){
			pos*=2;
			pos+=!!(r&(1<<i));
			chien(pos);
			len/=2;
		}
		
	}


	void rangeshori(int a,int b,Sayo w){
		a+=cor,b+=cor;
		int aa=a/(a&(-a))/2;
		int bb=b/(b&(-b))/2;
		clear_chien(aa);
		clear_chien(bb);
		while(a<b){
			if(a&1){
				lazy[a]=merge_sayo(lazy[a],w);
				a++;
			}
			if(b&1){
				b--;
				lazy[b]=merge_sayo(lazy[b],w);
			}
			a/=2,b/=2;
		}

		while(aa>0 || bb>0){
			if(aa>bb){
				vec[aa]=node_merge(chien(2*aa),chien(2*aa+1));
				aa/=2;		
			}
			else if(aa<bb){
				vec[bb]=node_merge(chien(2*bb),chien(2*bb+1));
				bb/=2;	
			}
			else{
				vec[aa]=node_merge(chien(2*aa),chien(2*aa+1));
				aa/=2;		
				bb/=2;
			}
		}

	}


	Node getrange(int a,int b){
		a+=cor,b+=cor;
		int aa=a/(a&(-a))/2;
		int bb=b/(b&(-b))/2;
		clear_chien(aa);
		clear_chien(bb);
		Node hi=N_id;
		Node mi=N_id;
			
		while(a<b){
			if(a&1){
				hi=node_merge(hi,chien(a));
				a++;
			}
			if(b&1){
				b--;
				mi=node_merge(chien(b),mi);
			}
			a/=2,b/=2;
		}
		return node_merge(hi,mi);
	}
	
	// 位置pから広げていき初めてboundary_check()がtrueになる場所を返す．ない場合はcorが返る
	
	bool boundary_check(int k,Node x){
	//	return x>=100;
		return x>=k;
	}
	
	int lower_bound(int p,int x){
		p+=cor;
		Node ima=N_id;
		bool fst=1;
		while(1){
			while(!(p&1))p/=2;
			if(fst)fst=0,clear_chien(p/2);
			if(boundary_check(x,node_merge(ima,chien(p))))break;//条件を超える
			ima=node_merge(ima,vec[p]);
			p++;
			if(p==(p&(-p))) return cor;
		}
		while(1){
			if(p>=cor) return p-cor;
			p*=2;
			if(!boundary_check(x,node_merge(ima,chien(p)))){//条件を超えない
				ima=node_merge(ima,vec[p]);
				p++;
				chien(p);
			}
		}
	}
	


	

};


void solve(){
int n,k;
//	n=200000;
//	k=1000000000;
	cin>>n>>k;
	vector<int>ve(n);
	for(int i=0;i<n;i++)cin>>ve[i];
	sort(ve.begin(),ve.end(),greater<int>());
	seg_chusho ss;
	ss.shoki1();
	ss.rangeshori(0,1,1);
	int ima=0;
	int wa=1;
	int ans=inf;
	for(auto v:ve){
		wa+=v-2;
		while(ss.getrange(ima,ima+1)==0)ima++;
		ss.rangeshori(ima,ima+1,-1);
		if(v%2){
			ss.rangeshori(ima+2,ima+2+v/2,2);
		}
		else{
			ss.rangeshori(ima+2,ima+2+v/2-1,2);
			ss.rangeshori(ima+2+v/2-1,ima+2+v/2,1);
		}
		assert(wa==ss.getrange(0,ss.cor));
		if(wa>=k){
 
			
			int g=ss.lower_bound(0,k);
		//	cout<<g<<endl;
			ans=min(ans,g);
		}
	}
	
	if(ans==inf)cout<<-1<<endl;
	else cout<<ans<<endl;
	
	
}
 


signed main(){
	mod=inf;

	cin.tie(0);
	ios::sync_with_stdio(false);

int n=1;
//	cin>>n;
for(int i=0;i<n;i++)solve();
	return 0;

	
}