Problem

There is a string $ S $ of length $ N $. All characters in $ S $ are numbers between 0 and 9.
When you make a sequence of $ \ frac {N \ times (N + 1)} {2} $, which is the number of terms created by enumerating all the numbers created from all the substrings of $ S $, Find the smallest value in $ H $.

Constraints

The input satisfies the following conditions.

* $ 1 \ leq N \ leq 10 ^ 5 $
* $ 1 \ leq H \ leq \ frac {N \ times (N + 1)} {2} $
* $ | S | = N $
* All characters in $ S $ are 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

Input

The input is given in the following format.


$ N $ $ H $
$ S $


All inputs are given as integers.
$ N $ and $ H $ are given on the first line, separated by blanks.
The second line is given the string $ S $ of length $ N $.

Output

Output the $ H $ th value on one line.
(Do not include extra 0s at the beginning of the output.)

Examples

Input

2 3
00


Output

0


Input

4 9
0012


Output

12


Input

5 13
10031


Output

100
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;



#define SIZE 100005

#define NUM1 1000000009
#define NUM2 99999883

struct Info{
	ull hash_1,hash_2;
};
ull HASH[SIZE][2],POW[SIZE][2];

ll T_length,H,digit;
ll table[SIZE],ruisekiwa[SIZE];
vector<int> V;
char T[SIZE];

bool IS_SAME(Info left,Info right){
	if(left.hash_1 == right.hash_1 && left.hash_2 == right.hash_2)return true;
	else{
		return false;
	}
}

Info calcHash(int left,int right){

	Info ret;

	int length = right-left+1;

	//indexのずれに注意:T[right]までのハッシュ値はHASH[right+1]に記録されている
	ret.hash_1 = HASH[right+1][0]-HASH[left][0]*POW[length][0];
	ret.hash_2 = HASH[right+1][1]-HASH[left][1]*POW[length][1];

	return ret;
}

//AとBの一致長さを返す
ll calc_match_len(int start_A,int start_B,int length){

	ll left = 0,right = length-1,mid = (left+right)/2;
	ll match_len = 0;
	Info tmp_A,tmp_B;

	while(left <= right){

		tmp_A = calcHash(start_A,start_A+mid);
		tmp_B = calcHash(start_B,start_B+mid);

		if(IS_SAME(tmp_A,tmp_B)){
			match_len = mid+1;
			left = mid+1;
		}else{
			right = mid-1;
		}
		mid = (left+right)/2;
	}

	return match_len;
}

bool compare(int a,int b){

	ll match_len = calc_match_len(a,b,digit);

	return T[a+match_len] < T[b+match_len];
}


int main(){

	scanf("%lld %lld",&T_length,&H);

	scanf("%s",T);

	ll num_zero = 0;
	for(int i = 0; i < T_length; ){
		if(T[i] != '0'){

			i += 1;
			continue;
		}
		ll count = 0;
		for(;i+count < T_length && T[i+count] == '0'; count++);

		num_zero += (count*(count+1))/2;
		i += count;
	}

	if(num_zero >= H){

		printf("0\n");
		return 0;
	}

	//2通りのハッシュ値を計算する
	HASH[0][0] = 0;
	HASH[0][1] = 0;
	POW[0][0] = 1;
	POW[0][1] = 1;

	//Tのハッシュ値を求める
	for(int i = 1; i <= T_length; i++){
		HASH[i][0] = T[i-1] + HASH[i-1][0]*NUM1;
		HASH[i][1] = T[i-1] + HASH[i-1][1]*NUM2;

		POW[i][0] = POW[i-1][0]*NUM1;
		POW[i][1] = POW[i-1][1]*NUM2;
	}

	for(int i = 0; i <= T_length; i++){

		ruisekiwa[i] = 0; //桁iの数がいくつあるか
	}

	table[T_length] = T_length;
	for(int i = T_length-1; i >= 0; i--){

		if(T[i] != '0'){

			table[i] = i;
		}else{

			table[i] = table[i+1];
		}

		ruisekiwa[T_length-table[i]]++;
		ruisekiwa[0]--;
	}

	for(int i = T_length-1; i >= 0; i--){

		ruisekiwa[i] += ruisekiwa[i+1];
	}

	digit = 0;
	ll sum = num_zero;

	for(int i = 1; i <= T_length; i++){

		if(sum+ruisekiwa[i] >= H){
			digit = i;
			break;
		}
		sum += ruisekiwa[i];
	}

	//printf("sum:%lld digit:%lld\n",sum,digit);

	for(int i = 0; i <= T_length; i++){

		if(table[i]+digit > T_length)break;

		V.push_back(table[i]);
	}

	sort(V.begin(),V.end(),compare);

	for(int i = 0; i < digit; i++){

		printf("%c",T[V[H-(sum+1)]+i]);
	}
	printf("\n");

	return 0;
}

