// https://szkopul.edu.pl/problemset/problem/R-s87nyFFh8WR12UGiJz_5Ii/site/?key=statement

#include <bits/stdc++.h>

using namespace std;

#define int long long

constexpr int sizik = 1000 * 1001;

#define ar std::array
#define pr std::pair
#define vec std::vector

typedef vec<vec<int>> _kra;

constexpr int K = 2;

typedef ar<int, K> H;

int mod = 1000 * 1000 * 1000 + 7;

// #define GARY_DBG

int _pow(int a, int b) {
    if (b == 0) return 1;
    if (b % 2 == 0) {
        int c = _pow(a, b / 2);
        return (c * c) % mod;
    } else {
        return (a * _pow(a, b - 1)) % mod;
    }
}

int p[K] = {199, 211}, pw[K];
int pot[sizik][K];

H calc_hash(const std::string& s) {
    int nk = (int)s.size();
    H local_hash{};
    for (int i = 0; i < K; i++) {
        for (int j = 0; j < nk; j++) {
            local_hash[i] = (local_hash[i] + s[j] * pot[j + 1][i]) % mod;
        }
    }
    return local_hash;
}

void replace_new_first(H& a, int k, char c, char c1) {
    for (int i = 0; i < K; i++) {
        a[i] = (a[i] + pot[k + 1][i] * c) % mod;
        a[i] = (((a[i] * pw[i] - c1) % mod) + mod) % mod;
    }
}

std::map<H, std::map<int, int>> q;
std::map<H, H> q1;
std::map<H, int> d;
std::map<H, std::string> mmp1;
std::map<H, char> mmp2, mmp3;

std::pair<int, char> kra[2 * sizik];
std::string ansix;
void get_ans(int start_v, int xx) {
    for (; xx > 0; xx--) {
        ansix += kra[start_v].second;
        start_v = kra[start_v].first;
    }
}

// może zwykly vector?

void print_H(const H& a) {
    std::cout << a[0] << " " << a[1];
}

void solve() {
    int n, k, a_ans, b_ans;
    std::cin >> n >> k >> a_ans >> b_ans;

    std::string s, s1;
    std::cin >> s;

    for (int i = 0; i < k; i++) {
        s1 += s[i];
    }

    H h1 = calc_hash(s1);

    q[h1][s[k]]++;

    for (int i = 0; i <= k + 1; i++) {
        s += 'a';
    }

    int nk = s.size();

    for (int i = k; i < nk; i++) {
        replace_new_first(h1, k, s[i], s[i - k]);

        mmp2[h1] = s[i - k + 1];
        mmp3[h1] = s[i];

        if ((i + 1 < n)) {
            q[h1][s[i + 1]]++;
        } else {
            q[h1][0] += 0;
        }
    }

    for (const auto& [a, b] : q) {
        int maxi = 0;
        char maxi_char = 'a';
        for (const auto& [c, cnt] : b) {
            if (cnt > maxi) {
                maxi = cnt;
                maxi_char = c;
            }
        }

        H a1 = a;
        replace_new_first(a1, k, maxi_char, mmp2[a]);

        q1[a] = a1;
    }

    H curr_v = calc_hash(s.substr(n - k, k));

    H empty_h{};

    int pth = 0, cle = 0, ppv = 0;
    while (true) {
        ++ppv;

        if (d[curr_v] != 0) {
            cle = ppv - d[curr_v];
            pth = d[curr_v] - 1;

            kra[ppv - 1] = std::make_pair(d[curr_v], mmp3[curr_v]);

            break;
        }

        d[curr_v] = ppv;
        if (d[curr_v] > 1) kra[d[curr_v] - 1] = std::make_pair(d[curr_v], mmp3[curr_v]);

        if (q1[curr_v] == empty_h) {
        } else {
            curr_v = q1[curr_v];
        }
    }

    int z = a_ans - n;

    int xxx = b_ans - a_ans + 1;
    if (z <= pth) {
        get_ans(z, xxx);
    } else {
        get_ans(pth + 1 + ((z - pth - 1) % cle), xxx);
    }

    std::cout << ansix << '\n';
}

int32_t main() {
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);

    for (int j = 0; j < K; j++) {
        pot[0][j] = 1;
        for (int i = 1; i < sizik; i++) {
            pot[i][j] = (p[j] * pot[i - 1][j]) % mod;
        }

        pw[j] = _pow(p[j], mod - 2);
    }

    int t = 1;
    // std::cin >> t;

    for (; t > 0; t--) {
        solve();
    }

    return 0;
}