#include <atcoder/all>
#include <bits/stdc++.h>
#define rep(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
using namespace atcoder;
using namespace std;

typedef long long ll;

template <typename T> T ceil_div(T a, T b) {
    if (b < 0)
        a = -a, b = -b;
    return (a >= 0 ? (a + b - 1) / b : a / b);
}

struct RollingHash {
    int n;
    static const ll base1 = 1009;
    static const ll base2 = 2009;
    static const ll mod1 = 1000000007;
    static const ll mod2 = 1000000009;
    vector<ll> hash1, hash2, pow1, pow2;

    RollingHash() {}
    RollingHash(const string &S) {
        n = (int)S.size();
        hash1.assign(n + 1, 0);
        hash2.assign(n + 1, 0);
        pow1.assign(n + 1, 1);
        pow2.assign(n + 1, 1);
        for (int i = 0; i < n; ++i) {
            hash1[i + 1] = (hash1[i] * base1 + S[i]) % mod1;
            hash2[i + 1] = (hash2[i] * base2 + S[i]) % mod2;
            pow1[i + 1] = (pow1[i] * base1) % mod1;
            pow2[i + 1] = (pow2[i] * base2) % mod2;
        }
    }

    /**
     * S の [l, r) のハッシュ値を返す
     * O(1)
     */
    inline pair<ll, ll> get(int l, int r) const {
        ll res1 = hash1[r] - hash1[l] * pow1[r - l] % mod1;
        if (res1 < 0)
            res1 += mod1;
        ll res2 = hash2[r] - hash2[l] * pow2[r - l] % mod2;
        if (res2 < 0)
            res2 += mod2;
        return make_pair(res1, res2);
    }

    /**
     * S のハッシュ値を返す
     * O(1)
     */
    inline pair<ll, ll> hash() const { return get(0, (int)hash1.size() - 1); }

    /**
     * LCP (Longest Common Prefix)
     * O( log N )
     */
    inline int getLCP(int a, int b) const {
        int len = min((int)hash1.size() - a, (int)hash1.size() - b);
        int low = 0, high = len;
        while (high - low > 1) {
            int mid = (low + high) >> 1;
            if (get(a, a + mid) != get(b, b + mid))
                high = mid;
            else
                low = mid;
        }
        return low;
    }

    /**
     * hash h1 と 長さ h2_len の文字列の hash h2 を結合
     */
    pair<ll, ll> concat(pair<ll, ll> h1, pair<ll, ll> h2, ll h2_len) {
        if (h2_len < pow1.size())
            return make_pair((h1.first * pow1[h2_len] + h2.first) % mod1,
                             (h1.second * pow2[h2_len] + h2.second) % mod2);
        return make_pair(
            (h1.first * pow_mod(base1, h2_len + 1, mod1) + h2.first) % mod1,
            (h1.second * pow_mod(base2, h2_len + 1, mod2) + h2.second) % mod2);
    }

    /**
     * 文字列の最小周期を返す
     */
    int max_repeat(bool multiple_only = false) {
        for (int i = 1; i < n; i++) {
            if (multiple_only && n % i != 0)
                continue;
            if (n - i < i)
                break;
            if (get(0, n - i) == get(i, n)) {
                return i;
            }
        }
        return n;
    }

    /**
     * hash h を count 回結合 (WIP)
     */
    pair<ll, ll> times(pair<ll, ll> h, ll len, ll count) {
        pair<ll, ll> ret = {0, 0}, now = h;
        ll pw = 1;
        while (count) {
            if (count & 1)
                ret = concat(ret, now, len * pw);
            now = concat(now, now, len * pw);
            count >>= 1;
            pw <<= 1;
        }
        return ret;
    }
};

int max_pal_len(string s) {
    // 回文の最大半径を返す
    int ret = 0;

    // 奇数長
    vector<int> odd(s.size());
    for (int i = 0, l = 0, r = -1; i < s.size(); i++) {
        int k = (i > r) ? 1 : min(odd[l + r - i], r - i);
        while (0 <= i - k && i + k < s.size() && s[i - k] == s[i + k])
            k++;
        odd[i] = k--;
        ret = max(ret, k * 2 + 1);
        if (i + k > r)
            l = i - k, r = i + k;
    }
    ret = max(ret, *max_element(odd.begin(), odd.end()) * 2 - 1);

    // 偶数長
    vector<int> even(s.size());
    for (int i = 0, l = 0, r = -1; i < s.size(); i++) {
        int k = (i > r) ? 0 : min(even[l + r - i + 1], r - i + 1);
        while (0 <= i - k - 1 && i + k < s.size() && s[i - k - 1] == s[i + k])
            k++;
        even[i] = k--;
        ret = max(ret, k * 2);
        if (i + k > r)
            l = i - k - 1, r = i + k;
    }
    ret = max(ret, *max_element(even.begin(), even.end()) * 2);
    return ret;
}

void solve() {
    int n, m;
    string s;
    cin >> n >> m >> s;
    if (max_pal_len(s) >= m) {
        cout << 1 << '\n';
        return;
    }
    string t = s;
    reverse(t.begin(), t.end());
    if (s == t) {
        cout << ceil_div(m, n) << '\n';
        return;
    }
    RollingHash rhs(s), rht(t);
    auto isPal = [&](int li, int ri) {
        return rhs.get(li, ri) == rht.get(n - ri, n - li);
    };
    int ans = 2e9;
    rep(i, 0, n) {
        if (isPal(0, i) && isPal(i, n)) {
            int lenl = i + 1, lenr = n - i;
            int cd = ceil_div(m, n) * n;
            int pre = 0;
            if (cd - min(lenl, lenr) >= m) {
                ans = min(ans, ceil_div(m, n));
            } else {
                ans = min(ans, ceil_div(m, n) + 1);
            }
        }
    }
    if (ans == 2e9)
        ans = -1;
    cout << ans << '\n';
}

int main() {
    int t;
    cin >> t;
    while (t--)
        solve();
}