#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 1e6 + 5;
const int MAXM = 5e3 + 5;
const ll linf = 0x3f3f3f3f3f3f3f3f;

int pcnt = 0;
int son[MAXN][26];
ll val[MAXN];
int new_Node(void)
{
	int u = ++pcnt;
	memset(son[u], 0, sizeof(son[u]));
	val[u] = linf;
	return u;
}

char s[MAXN];
int sl[MAXN], sr[MAXN];
char a[MAXM];

void solve(void)
{
	int n,d;
	scanf("%d%d",&n,&d);
	for(int i=1,j=0; i<=n; ++i)
	{
		scanf("%s",s+j+1);
		sl[i] = j + 1;
		sr[i] = j + strlen(s+j+1);
		j = sr[i];
	}
	scanf("%s",a+1);
	int m = strlen(a+1);
	
	static ll f[MAXN];
	fill(f, f+d+1, linf);
	for(int i=1; i<=n; ++i)
	{
		int j = (sr[i] - sl[i] + 1) % d;
		f[j] = min(f[j], ll(sr[i] - sl[i] + 1) + d);
	}
	
	for(int i=0; i<d; ++i)
	{
		if(f[i] == linf) continue;
		if(i == 0) continue;
		
		for(int j=2; j<=10; ++j)
		{
			int t = i * j % d;
			if(f[t] >= f[i] * j) f[t] = linf;
		}
		for(int j=2; i*j<d; ++j)
		{
			int t = i * j;
			if(f[t] >= f[i] * j) f[t] = linf;
		}
	}
	
	vector<int> has;
	for(int i=1; i<d; ++i)
		if(f[i] != linf)
			has.emplace_back(i);
	
	static ll dis[MAXN];
	fill(dis, dis+d+1, linf);
	dis[0] = 0;
	
	static bool vis[MAXN];
	fill(vis, vis+d+1, 0);
	
	priority_queue< pair<ll,int> > q;
	q.emplace(0, 0);
	
	while(q.size())
	{
		int u = q.top().second; q.pop();
		if(vis[u]) continue;
		vis[u] = 1;
		
		for(int i: has)
		{
			int v = u + i;
			if(v >= d) v -= d;
			if(dis[v] > dis[u] + f[i])
			{
				dis[v] = dis[u] + f[i];
				q.emplace(-dis[v], v);
			}
		}
	}
	
	pcnt = 0;
	new_Node();
	
	for(int k=1; k<=n; ++k)
	{
		int u = 1;
		for(int i=sl[k]; i<=sr[k]; ++i)
		{
			int c = s[i] - 'a';
			int &v = son[u][c];
			if(!v) v = new_Node();
			u = v;
			
			int rem = sr[k] - i;
			ll cur = rem + d;
			
			int t = d - rem % d;
			if(t == d) t = 0;
			cur += dis[t];
			
			if(cur < linf)
				val[u] = min(val[u], cur / d);
			
			if(i - sl[k] + 1 > m) break; 
		}
	}
	
	static ll dp[MAXM];
	fill(dp, dp+m+1, linf);
	dp[0] = 0;
	for(int i=0; i<m; ++i)
	{
		int u = 1;
		for(int j=i+1; j<=m; ++j)
		{
			u = son[u][a[j] - 'a'];
			if(u == 0) break;
			dp[j] = min(dp[j], dp[i] + val[u]);
		}
	}
	
	if(dp[m] == linf)
		printf("-1\n");
	else
		printf("%lld\n",dp[m]);
}

int main(void)
{
	int T;
	scanf("%d",&T);
	while(T--) solve();
	return 0;
}