Link to this code: `https://cses.fi/paste/1a1adab9babc8ef84a7c56/`
```#include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
typedef pair<int, int> pii;
#define endl "\n"
#define all(v) v.begin(),v.end()

#define trace1(x)       if(dm) cout<<(#x)<<" "<<(x)<<endl
#define trace2(x,y)     if(dm) cout<<(#x)<<" "<<(x)<<", "<<(#y)<<" "<<(y)<<endl
#define trace3(x,y,z)   if(dm) cout<<(#x)<<" "<<(x)<<", "<<(#y)<<" "<<(y)<<", "<<(#z)<<" "<<(z)<<endl
int dm = 0;
void fastio(){ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);}
void fileio() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
#endif
}

vector<int> suffix_array(const string& str){
// return sorted position of each suffix, 'pos'
// pos[k] = i => kth smallest suffix is suffix[i...n-1]

string s = str + '\$'; // '\$' is smaller than all character;

int n = s.size();
vector<int> clss(n, 0);
vector<int> pos(n,0);
// clss[i] = k => suffix s[i...n-1] is kth smallest suffix in sorted order.
// its like sort of inverse of pos[] array, and both arrays can be computed from each other

// ----------  Step 1
// build initial clss for only first character
vector<int> cnt(126,0);
vector<int> cntsum(127,0);
vector<vector<int>> idx_with_clss(n);
vector<int> newclss(n,-1);
for(int i=0; i<n; i++){
cnt[s[i]]++;
}
for(int i=1; i<=126; i++){
cntsum[i] = cntsum[i-1] + cnt[i-1];
}
for(int i=0; i<n; i++){
clss[i] = cntsum[ s[i] ] ;
pos[ cntsum[s[i]] + (cnt[s[i]]-1) ] = i;
cnt[s[i]]--;
}

// ----------- Step 2
int prevlen = 1;
int len = 2;
while(len<=n){
// we know the order for string of some prevlen >= len/2
// we want to order the shifts for length len [0...len-1]
// first order the shifts according to rank of their [prevlen...len-1]
// then we order then acc to rank of [0..prevlen-1]

// pos[k+x] = i, pos[k] = j
// implies i appears after j
// <=> for shift i, [prevlen...len-1] is having clss bigger than for shift j,[prevlen...len-1]
// order shift 'i' according to clss[(i+prevlen)%n]
// then order shift 'i' according to clss[i]

// Step A : order acc to clss[ (i+prevlen) % n]

for(int i=0; i<n; i++){
idx_with_clss[i].clear();
}
for(int i=0; i<n;i++){
idx_with_clss[ clss[(i+prevlen)%n] ].push_back(i);
}
int k=0;
for(int i=0; i<n; i++){
for(int idx : idx_with_clss[i]){
pos[k++] = idx;
}
}

// Step B : order acc to clss[i]
for(int i=0; i<n; i++){
idx_with_clss[i].clear();
}

for(int order=0; order<n;order++){
idx_with_clss[ clss[pos[order]] ].push_back(pos[order]);
}
k=0;
for(int i=0; i<n; i++){
for(int idx : idx_with_clss[i]){

pos[k++] = idx;
// can put the next loop here
}
}

assert(k==n);

// Step C : Find clss array using pos
newclss[pos[0]] = 0;
int curclss = 0;
for(int ord=1; ord<n; ord++){
// shift with pos[ord-1] <= shift with pos[ord] till length 'len'
// if greater then higher class otherwise same
int i=pos[ord-1];
int j=pos[ord];

if(clss[j]>clss[i] ||
(clss[i]==clss[j] && (clss[(j+prevlen)%n]>clss[(i+prevlen)%n]) ) )
{
curclss++;
}

newclss[j] = curclss;
}

for(int i=0; i<n; i++) clss[i] = newclss[i];

prevlen = len;
if(len==n) break;
len = len*2;
if(len>n) len = n;
}

// remove first element of pos
pos.erase(pos.begin());
return pos;

}

vector<int> lcp_array(const string&s, const vector<int>& sa){
int n = s.size();
vector<int> lcp(n-1,-1);
vector<int> rank(n);
for(int i=0; i<n; i++)rank[ sa[i] ] = i;

// there are n suffixes
// lcp[i] -> lcp of suffix[ sa[i] ] and suffix[ sa[i+1] ]

for(int idx=0; idx<n; idx++){
int i = rank[idx];
if(i == n-1){
continue;
}
if(lcp[i]==-1){
int idx1 = sa[i];
int idx2 = sa[i+1];
int curlcp = 0;
while(idx1<n && idx2<n && s[idx1]==s[idx2]){
idx1++,idx2++,curlcp++;
}
// maybe 0,1,2...
lcp[i] = curlcp;
curlcp--;
idx1 = sa[i]+1;
idx2 = sa[i+1]+1;
while(idx1<n && idx2<n && curlcp >= 0){
int rank1 = rank[idx1];
int rank2 = rank[idx2];
if(rank2 != rank1+1){
}
else{
lcp[rank1] = curlcp;
}

curlcp--, idx1++, idx2++;
}
}
}

return lcp;
}

class PrefixSumSALengths{
public:
vector<lli> psum;
int n;

PrefixSumSALengths(){

}

PrefixSumSALengths(const vector<int>& sa){
this->n = sa.size();
psum = vector<lli>(n+1, 0);
for(int i=1; i<=n; i++){
psum[i] = psum[i-1] + (n - sa[i-1]);
}
}

lli get_sum(int st, int end) const{
assert(end+1 <= n);
assert(st>=0);
return psum[end+1] - psum[st];
}

};

namespace spt{
const int MX = 27;
const int SZ = 200000;
int table[MX][SZ+1];
struct rmq{
int n;

rmq(){}
rmq(const vector<int>& arr){init(arr);}
void init(const vector<int>& arr)
{
n = arr.size();
assert(n <= SZ);
for(int idx=0; (1<<idx)<=n; idx++){
for(int i=0; i<n; i++){
if(idx==0){
table[idx][i] = arr[i];
}
else{
int sz = 1<<idx;
if(i+sz-1>=n) break;
table[idx][i] = min( table[idx-1][i], table[idx-1][i+sz/2]);
}
}
}
}
int getmin(int st, int end){

// sz = (end-st+1)
// start idx = st
// __lg(sz)
int idx = __lg(end-st+1) ;
int pow2 = 1 << idx;
int st2 = end - pow2 + 1;
return min( table[idx][st] , table[idx][st2]);
}
};
}

string s;
lli k;
int n;
vector<int> sa;
vector<int> lcp;
PrefixSumSALengths psum;

string ans;
spt::rmq rmq;

int get_lcp(int i, int j){
if(i==j){
return n - sa[i];
}
else{
return rmq.getmin(i, j-1);
}
}

int get_last(int i, int len){
// ith rank
// last guy j with lcp(i,j) >= len

assert(lcp[i] >= len);

int st = i;
int end = n-1;

int j = -1;
while(st <= end)
{
int mid = (st+end)/2;
if(get_lcp(i, mid)>=len && (mid==n-1 || get_lcp(i, mid+1)<len)){
j = mid;
break;
}
else if(get_lcp(i, mid) < len){
end = mid-1;
}
else{
st = mid+1;
}
}
assert(j!=-1);
return j;

}

void solve(){
cin>>s>>k;
n = s.size();

sa = suffix_array(s);
lcp = lcp_array(s, sa);
lcp.push_back(0);

rmq.init(lcp);
int prevlcp = 0;
for(int rank=0; rank<n; rank++){
int idx = sa[rank];

// Mistake 1 : did prevlcp instead of 'prevlcp + 1'

int stlen = prevlcp + 1;
int endlen = lcp[rank];

for(int len = stlen; len<=endlen; len++){
// string is s[idx...idx+len-1]
int lastrank = get_last(rank, len);
int cnt = lastrank - rank + 1;
if(cnt >= k){
ans = s.substr(idx, len);
// Mistake 2 : did this after the break
k = 0;
break;
}
else{
k -= cnt;
}
}

if(k==0) break;

// Mistake 3 : did not do this donelen
int donelen = max(lcp[rank], prevlcp);
int next_cnt = n - (idx + donelen) ;

assert(next_cnt >= 0);

if(next_cnt >= k){
// Mistake 4 : did not used donelen here
ans = s.substr(idx, donelen + k);
break;
}
else{
k -= next_cnt;
}

prevlcp = lcp[rank];
}

cout << ans << endl;
}

int main(){

#ifndef ONLINE_JUDGE
dm = 1;
#endif
if(!dm)fastio();
//fastio();
fileio();

lli tst=1;

//if(dm)cin>>tst ;
while(tst--){
// input
solve();
}
return 0 ;
}
```