// #define DEBUGGING
#include <bits/stdc++.h>
#define endl '\n'
#define ALL(V) begin(V), end(V)
#define ALLR(V) rbegin(V), rend(V)
using ll = std::int64_t;
using ull = std::uint64_t;
using PLL = std::pair<ll, ll>;
using TLL = std::tuple<ll, ll, ll>;
template <typename T> using V = std::vector<T>;
template <typename T> using VV = V<V<T>>;
template <typename T> const T& var_min(const T &t) { return t; }
template <typename T> const T& var_max(const T &t) { return t; }
template <typename T, typename... Tail> const T& var_min(const T &t, const Tail&... tail) { return std::min(t, var_min(tail...)); }
template <typename T, typename... Tail> const T& var_max(const T &t, const Tail&... tail) { return std::max(t, var_max(tail...)); }
template <typename T, typename... Tail> void chmin(T &t, const Tail&... tail) { t = var_min(t, tail...); }
template <typename T, typename... Tail> void chmax(T &t, const Tail&... tail) { t = var_max(t, tail...); }
template <typename T> const T& clamp(const T &t, const T &low, const T &high) { return std::max(low, std::min(high, t)); }
template <typename T> void chclamp(T &t, const T &low, const T &high) { return t = clamp(t, low, high); }
namespace init__ { struct InitIO { InitIO() { std::cin.tie(nullptr); std::ios_base::sync_with_stdio(false); std::cout << std::fixed << std::setprecision(30); } } init_io; }
#define mv_rec make_v(init, tail...)
template <typename T> T make_v(T init) { return init; }
template <typename T, typename... Tail> auto make_v(T init, size_t s, Tail... tail) { return V<decltype(mv_rec)>(s, mv_rec); }
#undef mv_rec
using namespace std;

#ifdef DEBUGGING
#include "../../debug/debug.cpp"
#else
#define DEBUG(...) 0
#define DEBUG_SEPARATOR_LINE 0
#endif

string concat_s(string s) {
    string u = s;
    reverse(ALL(s));
    return u + s;
}

string sim(string s, ll idx, ll K) {
    ll len = 0;
    DEBUG(idx);
    {
        string u = concat_s(s);
        ll r = s.size() + (s.size() - idx) - 1;
        const char c = u[r];
        while (r < u.size()) {
            if (u[r] == c) len++;
            else break;
            r++;
        }
        s = u.substr(r - s.size(), s.size());
        len = 0;
        ll idx = s.size() - 1;
        while (0 <= idx) {
            if (s.back() == s[idx]) len++;
            else break;
            idx--;
        }
        // DEBUG(make_tuple(idx, r, u, s));
    }
    K -= 2;
    while (0 < K) {
        string u = concat_s(s);
        s = move(u.substr(len, s.size()));
        len *= 2;
        if (s.size() <= len) break;
        K--;
    }
    string u = concat_s(s);
    string ret = s;
    for (ll i = 0; i <= s.size(); i++) chmin(ret, u.substr(i, s.size()));
    DEBUG(ret);
    return ret;
}

bool judge(string s, ll K) {
    K--;
    ll len = 1;
    while (K--) {
        len *= 2;
        if (s.size() <= len) return true;
    }
    return false;
}

string solve() {
    ll N, K;
    string S;
    cin >> N >> K >> S;
    const char c = *min_element(ALL(S));
    if (judge(S, K)) return string(S.size(), c);
    string ret = S;
    if (K == 1) {
        string u = concat_s(S);
        for (ll i = 0; i <= S.size(); i++) chmin(ret, u.substr(i, S.size()));
    } else {
        char pre = 0;
        for (ll i = S.size() - 1; 0 <= i; i--) {
            if (pre != S[i] && S[i] == c) chmin(ret, sim(S, i, K));
            pre = S[i];
        }
    }
    return ret;
}

int main() {
    cout << solve() << endl;
    return 0;
}


Measured memory_bytes: 512