#include <bits/stdc++.h>

using namespace std;
#define int long long
constexpr int INF = 1e12+ 7;

struct node {
    map<char, node *> go;
    int val{INF};

    bool can(char c) {
        return go.count(c);
    }
};

void solve() {
    int n, k;
    cin >> n >> k;
    vector<string> a(n);
    vector<int> best(k, INF);
    best[0] = 0;
    for (auto &s: a) {
        cin >> s;
        int re = s.size() % k;
        best[re] = min(best[re], (int) s.size() / k + 1);
    }
    vector<pair<int, int>> e;
    int mx = 0;
    for (int re = 0; re < k; ++re) {
        if (best[re] < INF) {
            mx = max(mx, best[re]);
            e.push_back({re, best[re]});
        }
    }
    mx += 2;
    vector<int> d(k, INF);
    vector<char> used(k, 0);
    d[0] = 0;
    int pos = 0, have = 1;
    vector<queue<int>> q(mx);
    q[0].push(0);
    while (have) {
        while (q[pos % mx].empty())++pos;
        int v = q[pos % mx].front();
        q[pos % mx].pop();
        --have;
        if (used[v])continue;
        used[v] = 1;
        for (auto [re, w]: e) {
            w += (re + v) >= k;
            int to = (re + v) % k;
            if (d[to] > d[v] + w) {
                d[to] = d[v] + w;
                q[d[to] % mx].push(to);
                ++have;
            }
        }
    }

    node *root = new node;
    root->val = 0;
    for (const auto &s: a) {
        node *cur = root;
        for (int i = 0; i < s.size(); ++i) {
            if (!cur->can(s[i])) {
                cur->go[s[i]] = new node;
            }
            cur = cur->go[s[i]];
            int z = (ssize(s) - i - 1);
            int x = (-z % k + k) % k;
            int cost = d[x] + (z + x) / k;
            cur->val = min(cur->val, cost + 1);
        }
    }
    string s;
    cin >> s;
    int t = s.size();
    vector<int> dp(t + 1, INF);
    dp[t] = 0;
    for (int i = t - 1; ~i; --i) {
        node *cur = root;
        for (int j = i; j < t; ++j) {
            if (!cur->can(s[j]))break;
            cur = cur->go[s[j]];
            dp[i] = min(dp[i], cur->val + dp[j + 1]);
        }
    }
    cout << (dp[0] < INF ? dp[0] : -1) << "\n";
}

signed main() {
    cin.tie(0)->sync_with_stdio(false);
    int t;
    cin >> t;
    while (t--)solve();
}