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 <iostream>
#include <vector>
#include <array>
#include <list>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <tuple>
#include <memory>
#include <cmath>
#include <algorithm>
#include <functional>
#include <iomanip>
#include <numeric>
#include <climits>
#include <cfloat>
#include <cassert>
#include <random>

void set_rank(std::vector<int>& rank, const std::vector<int>& sorted_indices, const std::vector<long long int>& compare_value) {
	rank[sorted_indices.front()] = 0;
	for (auto i = 1; i < sorted_indices.size(); ++i) {
		rank[sorted_indices[i]] = rank[sorted_indices[i - 1]] + (compare_value[sorted_indices[i]] == compare_value[sorted_indices[i - 1]] ? 0 : 1);
	}
}
std::vector<int> make_suffix_array(const std::string& str) {
	std::vector<int> rank(str.size()), indices(str.size());
	std::vector<long long int> compare_value(str.size());
	std::iota(indices.begin(), indices.end(), 0);
	std::copy(str.begin(), str.end(), compare_value.begin());
	const auto comparator = [&compare_value](int i, int j) {return compare_value[i] < compare_value[j]; };
	std::sort(indices.begin(), indices.end(), comparator);
	set_rank(rank, indices, compare_value);
	for (auto i = 0; (1 << i) < str.size(); ++i) {
		for (auto j = 0; j < str.size(); ++j) {
			compare_value[j] = rank[j] * (str.size() + 1LL) + (j + (1 << i) < str.size() ? rank[j + (1 << i)] : -1);
		}
		std::sort(indices.begin(), indices.end(), comparator);
		set_rank(rank, indices, compare_value);
	}
	return indices;
}
template<typename Idx, typename F>
int upper_bound(Idx from, Idx until, const F& predicate) {
	while (from < until) {
		const auto mid = (from + until) / 2;
		if (predicate(mid)) until = mid;
		else from = mid + 1;
	}
	return until;
}


int main() {
	int n; long long int h; std::cin >> n >> h;
	std::string str; std::cin >> str;
	std::vector<int> next_positive(n, 0);
	for (auto i = 0; i < str.size(); ++i) if (str[i] == '0') next_positive[i] = 1;
	for (auto i = 2; i <= str.size(); ++i) if (str[str.size() - i] == '0')  next_positive[str.size() - i] += next_positive[str.size() - i + 1];
	std::vector<long long int> substrings(n + 1, 0);
	long long int for_zero = 0;
	for (auto i = 0; i < next_positive.size(); ++i) {
		const auto head = next_positive[i] + i;
		if (head != n) substrings[n - head]++;
		if (i == 0 || str[i - 1] != '0') {
			for_zero += next_positive[i] * (next_positive[i] + 1LL) >> 1;
		}
	}
	for (int i = substrings.size() - 2; i > 0; --i) substrings[i] += substrings[i + 1];
	for (auto i = 1; i < substrings.size(); ++i) substrings[i] += substrings[i - 1];
	const auto length = std::distance(substrings.begin(), std::lower_bound(substrings.begin(), substrings.end(), h - for_zero));
	if (length == 0) {
		std::cout << "0\n";
	}else {
		const auto sa = make_suffix_array(str);
		const auto rank = h - substrings[length - 1] - for_zero;
		std::vector<int> substr, multipler(n, 0);
		for (const auto i : sa) {
			if (str[i] == '0') {
				const auto head = i + next_positive[i];
				if (head != n) multipler[head]++;
			}else if (0 <= i && i <= n - length) {
				while (multipler[i]-- >= 0) substr.push_back(i);
			}
		}
		std::cout << str.substr(substr[rank - 1], length) << std::endl;
	}
}

