#include <algorithm>
#include <array>
#include <cstdint>
#include <iostream>
#include <queue>
#include <vector>

using namespace std;

constexpr int A = 26, V = 26e6 + 1, K = 5e3;

int nx[V], cost[V], used = V, ks[K];
int64_t ans[K + 1];

int main() {
  cin.tie(0)->sync_with_stdio(0);
  for (int tc = (cin >> tc, tc); tc--; ) {
    fill_n(cost, used, 1e9);
    fill_n(nx, used, 0);
    used = 1;
    fill(ks + 1, end(ks), 1e9);
    fill(ans + 1, end(ans), 1e18);
    int n, k; cin >> n >> k;
    vector<string> v(n);
    for (auto& s: v) cin >> s;
    {
      priority_queue pq{greater{}, vector<array<int, 2>>{{1}}};
      vector<uint32_t> cost(k, -1);
      for (auto& s: v) cost[s.size() % k] = min(cost[s.size() % k], {s.size() / k + 1});
      while (pq.size()) {
        auto [c, l] = pq.top(); pq.pop();
        if (!l || c == ks[l])
        for (int s = 0; s < k; ++s) if (~cost[k] && ks[(l + s) % k] > c + cost[k] + (l + s) / k) {
          pq.push({ks[(l + s) % k] = c + cost[k] + (l + s) / k, (l + s) % k});
        }
      }
      reverse(ks + 1, ks + k);
    }
    for (auto& s: v) {
      int v = 0;
      for (int rem = s.size(); auto& c: s) {
        if (!nx[v]) nx[v] = used, used += A;
        v = nx[v] + c - 'a';
        --rem;
        cost[v] = min(cost[v], ks[rem % k] + rem / k);
      }
    }
    string s; cin >> s;
    for (int i = 0; i < s.size(); ++i) {
      int v = 0;
      for (int j = i; j < s.size(); ++j) {
        v = nx[v] + s[j] - 'a';
        if (cost[v] == 1e9) break;
        ans[j + 1] = min(ans[j + 1], ans[i] + cost[v] + 1);
      }
    }
    cout << (ans[s.size()] < 1e18? ans[s.size()]: -1) << '\n';
  }
}