#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define pii pair<int, int>
#define ld long double
#define all(a) (a).begin(), (a).end()

const int MAXN = 1000100;
const long long INF = 1e18;
int go[MAXN][26];
long long cost[MAXN];
int nodes_cnt = 0;

int node() {
    fill(go[nodes_cnt], go[nodes_cnt] + 26, -1);
    cost[nodes_cnt] = INF;
    ++nodes_cnt;
    return nodes_cnt - 1;
}

void solve() {
    nodes_cnt = 0;
    node();

    int n, k;
    cin >> n >> k;
    vector<long long> dp(k, INF);
    vector<long long> min_len(k, INF);
    vector<string> lines(n);
    for (int i = 0; i < n; ++i) {
        cin >> lines[i];
        long long sz = lines[i].size();
        min_len[sz % k] = min(min_len[sz % k], sz);
        int cur = 0;
        for (char c : lines[i]) {
            if (go[cur][c - 'a'] == -1) {
                go[cur][c - 'a'] = node();
            }
            cur = go[cur][c - 'a'];
        }
    }

    // dp r

    vector<int> interesting;
    for (int i = 0; i < k; ++i) {
        if (min_len[i] != INF)
            interesting.emplace_back(i);
    }
    dp[0] = 0;
    set<pair<long long, int>> Q;
    Q.emplace(0ll, 0);
    while (!Q.empty()) {
        int mn = Q.begin()->second;
        Q.erase(Q.begin());
        for (int i : interesting) {
            long long extra_r = min_len[i] + mn;
            long long opt = dp[mn] + extra_r / k + 1;
            int nxt = mn + i;
            if (nxt >= k)
                nxt -= k;
            if (dp[nxt] > opt) {
                Q.erase(make_pair(dp[nxt], nxt));
                dp[nxt] = opt;
                Q.emplace(dp[nxt], nxt);
            }
        }
    }

    for (int i = 0; i < n; ++i) {
        int cur = 0;
        for (int j = 0; j < lines[i].size(); ++j) {
            cur = go[cur][lines[i][j] - 'a'];
            int rest = lines[i].size() - j - 1;
            int tmp = (k - rest % k) % k;
            cost[cur] = min(cost[cur], (rest + tmp) / k + dp[tmp] + 1);
        }
    }

    string t;
    cin >> t;
    vector<long long> final_dp(t.size() + 1, INF);
    final_dp[0] = 0;
    for (int i = 0; i < t.size(); ++i) {
        int cur = 0;
        for (int j = 0; i + j < t.size(); ++j) {
            cur = go[cur][t[i + j] - 'a'];
            if (cur == -1)
                break;
            final_dp[i + j + 1] = min(final_dp[i + j + 1], final_dp[i] + cost[cur]);
        }
    }
    if (final_dp.back() == INF)
        cout << -1 << '\n';
    else
        cout << final_dp.back() << '\n';

}

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

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