#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

struct SuffixArray {
    int n;
    string s;
    vector<int> sa, rank, lcp;
    vector<vector<int>> st;
    vector<int> lg;

    SuffixArray() {}

    void init(const string& str) {
        s = str;
        n = s.length();
        sa.resize(n);
        rank.resize(n);
        lcp.resize(n);

        for (int i = 0; i < n; i++) {
            sa[i] = i;
            rank[i] = s[i];
        }

        for (int k = 1; k < n; k <<= 1) {
            auto cmp = [&](int i, int j) {
                if (rank[i] != rank[j]) return rank[i] < rank[j];
                int ri = i + k < n ? rank[i + k] : -1;
                int rj = j + k < n ? rank[j + k] : -1;
                return ri < rj;
            };
            sort(sa.begin(), sa.end(), cmp);
            vector<int> tmp(n);
            tmp[sa[0]] = 0;
            for (int i = 1; i < n; i++) {
                tmp[sa[i]] = tmp[sa[i - 1]] + cmp(sa[i - 1], sa[i]);
            }
            rank = tmp;
            if (rank[sa[n - 1]] == n - 1) break;
        }

        int k = 0;
        for (int i = 0; i < n; i++) {
            if (rank[i] == 0) {
                lcp[0] = 0;
                continue;
            }
            int j = sa[rank[i] - 1];
            while (i + k < n && j + k < n && s[i + k] == s[j + k]) k++;
            lcp[rank[i]] = k;
            if (k > 0) k--;
        }

        lg.assign(n + 1, 0);
        for (int i = 2; i <= n; i++) lg[i] = lg[i >> 1] + 1;

        int K = lg[n] + 1;
        st.assign(K, vector<int>(n));
        for (int i = 0; i < n; i++) st[0][i] = lcp[i];

        for (int j = 1; j < K; j++) {
            for (int i = 0; i + (1 << j) <= n; i++) {
                st[j][i] = min(st[j - 1][i], st[j - 1][i + (1 << (j - 1))]);
            }
        }
    }

    int get_lcp(int i, int j) {
        if (i == j) return n - i;
        int r1 = rank[i];
        int r2 = rank[j];
        if (r1 > r2) swap(r1, r2);
        r1++;
        int k = lg[r2 - r1 + 1];
        return min(st[k][r1], st[k][r2 - (1 << k) + 1]);
    }
};

bool check(int pos, int len, int n, int l, int k, const string& s, SuffixArray& sa) {
    long long min_M_bad = 2e9;
    int bad_cnt = 0;

    for (int j = 0; j < k; j++) {
        int p = j * l;
        int L = min(len, sa.get_lcp(p, pos));
        long long M;
        if (L < len) {
            if (p + L < n && s[p + L] > s[pos + L]) {
                M = max(l, L + 1);
            } else {
                M = 2e9;
            }
        } else {
            M = max(l, len);
        }

        if (M == l) {
            
        } else {
            bad_cnt++;
            min_M_bad = min(min_M_bad, M);
        }
    }

    if (bad_cnt < k) return true;
    if (min_M_bad <= (long long)n - (long long)(k - 1) * l) return true;
    return false;
}

void solve() {
    int n, l, k;
    if (!(cin >> n >> l >> k)) return;
    string s;
    cin >> s;

    if ((long long)k * l > n) {
        cout << "NO\n";
        return;
    }

    if (n == 1) { cout << "YES\n" << s << "\n"; return; }

    SuffixArray sa;
    sa.init(s);

    vector<long long> cnt(n, 0);
    vector<int> start_len(n, 0);

    for (int r = 0; r < n; r++) {
        int lcp_prev = (r == 0) ? 0 : sa.lcp[r];
        int st_len = max(l, lcp_prev + 1);
        int en_len = n - sa.sa[r];
        if (st_len <= en_len) {
            cnt[r] = en_len - st_len + 1;
            start_len[r] = st_len;
        } else {
            cnt[r] = 0;
            start_len[r] = 0;
        }
    }

    vector<long long> pref(n, 0);
    pref[0] = cnt[0];
    for (int r = 1; r < n; r++) {
        pref[r] = pref[r - 1] + cnt[r];
    }

    long long N_total = pref[n - 1];
    if (N_total == 0) {
        cout << "NO\n";
        return;
    }

    auto get_substr = [&](long long idx) -> pair<int, int> {
        int r = lower_bound(pref.begin(), pref.end(), idx) - pref.begin();
        long long prev = (r == 0) ? 0 : pref[r - 1];
        int len = start_len[r] + (idx - prev - 1);
        return {sa.sa[r], len};
    };

    long long low = 1, high = N_total, ans_idx = 0;
    while (low <= high) {
        long long mid = low + (high - low) / 2;
        auto [pos, len] = get_substr(mid);
        if (check(pos, len, n, l, k, s, sa)) {
            ans_idx = mid;
            low = mid + 1;
        } else {
            high = mid - 1;
        }
    }

    if (ans_idx == 0) {
        cout << "NO\n";
    } else {
        cout << "YES\n";
        auto [pos, len] = get_substr(ans_idx);
        cout << s.substr(pos, len) << "\n";
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    int totalQueryNum;
    if (cin >> totalQueryNum) {
        while (totalQueryNum--) {
            solve();
        }
    }
    return 0;
}