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

using namespace std;

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

struct {
  int nx[A];
  int cost;
} tr[V];

int used, 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(tr, used, tr[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;
    {
      vector<int> big;
      uint64_t mask{};
      for (auto& s: v) if (s.size() >= 64 || !(mask & 1ull << s.size())) mask |= 1ull << s.size(), big.push_back(s.size());
      sort(big.begin(), big.end());
      big.erase(unique(big.begin(), big.end()), big.end());
      vector<int> q{0}, nq;
      int dist = 1;
      while (q.size()) {
        ++dist;
        for (auto& t: q) {
          if (t >= k) {
            if (t - k >= k) nq.push_back(t - k);
            else if (ks[t - k] == 1e9) nq.push_back(t - k), ks[t - k] = dist;
          } else
          for (auto x: big) {
            if (t + x >= k) nq.push_back(t + x);
            else if (ks[t + x] == 1e9) nq.push_back(t + x), ks[t + x] = dist;
          }
        }
        swap(q = {}, nq);
      }
      reverse(ks + 1, ks + k);
    }
    for (auto& s: v) {
      int v = 0;
      for (int rem = s.size(); auto& c: s) {
        if (!tr[v].nx[c -= 'a']) tr[v].nx[c] = used++;
        v = tr[v].nx[c];
        --rem;
        if (ks[rem % k] != 1e9) tr[v].cost = min(tr[v].cost ?: 1 << 30, ks[rem % k] + rem / k + 1);
      }
    }
    string s; cin >> s;
    for (int i = 0; i < s.size(); ++i) {
      int v = 0;
      for (int j = i; j < s.size(); ++j) {
        if (!tr[v].nx[s[j] - 'a']) break;
        v = tr[v].nx[s[j] - 'a'];
        if (!tr[v].cost) break;
        ans[j + 1] = min(ans[j + 1], ans[i] + tr[v].cost);
      }
    }
    cout << (ans[s.size()] < 1e18? ans[s.size()]: -1) << '\n';
  }
}