#include <bits/stdc++.h>

using namespace std;

#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define RFOR(i, a, b) for(int i = (a) - 1; i >= (b); i--)
#define SZ(a) int(a.size())
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define F first
#define S second

typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef double db;

const int N = 1 << 10;

mt19937 rng;

struct Graph
{
	int szL, szR;
	vector<VI> g;
	VI mateForR, mateForL, usedL;
	vector<VI> dirGraph;
	VI usedDirGraph;
	
	void init(int L, int R)
	{
		szL = L, szR = R;
		g.resize(szL);
		mateForL.resize(szL);
		usedL.resize(szL);
		
		mateForR.resize(szR);
		dirGraph.resize(szL + szR);
		usedDirGraph.resize(szL + szR);
	}
	void addEdge(int from, int to)
	{
		assert(0 <= from && from < szL);
		assert(0 <= to && to < szR);
		
		g[from].PB(to);
	}
	
	int iter;
	bool kuhn(int v)
	{
		if(usedL[v] == iter) return false;
		usedL[v] = iter;
		shuffle(ALL(g[v]), rng);
		for(int to : g[v])
		{
			if(mateForR[to] == -1)
			{
				mateForR[to] = v;
				mateForL[v] = to;
				return true;
			}
		}
		for(int to : g[v])
		{
			if(kuhn(mateForR[to]))
			{
				mateForR[to] = v;
				mateForL[v] = to;
				return true;
			}
		}
		return false;
	}
	int doKuhn()
	{
		fill(ALL(mateForR), -1);
		fill(ALL(mateForL), -1);
		fill(ALL(usedL), -1);
		
		int res = 0;
		iter = 0;
		
		while(true)
		{
			iter++;
			
			bool ok = false;
			FOR(v, 0, szL)
			{
				if(mateForL[v] == -1)
				{
					if(kuhn(v))
					{
						ok = true;
						res++;
					}
				}
			}
			if(!ok) break;
		}
		return res;
	}
	void buildDirGraph()
	{
		FOR(i, 0, szL)
		{
			for (int to : g[i])
			{
				if (mateForL[i] == to)
				{
					dirGraph[szL + to].PB(i);
				}
				else
				{
					dirGraph[i].PB(szL + to);
				}
			}
		}
	}
	void dfsDirGraph(int v)
	{
		usedDirGraph[v] = true;
		for (int to : dirGraph[v])
		{
			if (!usedDirGraph[to])
				dfsDirGraph(to);
		}
	}
	pair<VI, VI> minVertexCover()
	{
		buildDirGraph();
		FOR(i, 0, szL)
			if (mateForL[i] == -1 && !usedDirGraph[i])
				dfsDirGraph(i);
		VI vecL, vecR;
		FOR(i, 0, szL)
			if (!usedDirGraph[i])
				vecL.PB(i);
		FOR(i, 0, szR)
			if (usedDirGraph[szL + i])
				vecR.PB(i);
		return {vecL, vecR};
	}
};

int n;
string s[2][N];
pair<string, int> sorted[2][N];
int lcp[2][N][N];

int calcLCP(const string& s1, const string& s2)
{
	int res = 0;
	while (res < SZ(s1) && res < SZ(s2) && s1[res] == s2[res])
		res++;
	return res;
}

void solve()
{
	int m;
	cin >> m;
	VI good(n);
	FOR(j, 0, m)
	{
		int i;
		cin >> i;
		i--;
		good[i] = 1;
	}
	vector<vector<string>> f(2, vector<string>(n));
	vector<string> fs[2];
	map<string, int> fIndex[2];
	FOR(t, 0, 2)
	{
		VI maxLCP(n, -1);
		int start = 0, end = n - 1, step = 1;
		FOR(tt, 0, 2)
		{
			int prvBad = -1;
			for (int i = start; ; i += step)
			{
				int j = sorted[t][i].S;
				if (good[j] && prvBad != -1)
					maxLCP[j] = max(maxLCP[j], lcp[t][prvBad][i]);
				else if (!good[j])
					prvBad = i;
				if (i == end)
					break;
			}
			start = n - 1;
			end = 0;
			step = -1;
		}
		FOR(i, 0, n)
		{
			if (good[i])
			{
				f[t][i] = maxLCP[i] == SZ(s[t][i]) ? s[t][i] : (s[t][i].substr(0, maxLCP[i] + 1) + "*");
				if (t)
					reverse(ALL(f[t][i]));
				if (!fIndex[t].count(f[t][i]))
				{
					fIndex[t][f[t][i]] = SZ(fIndex[t]);
					fs[t].PB(f[t][i]);
				}
			}
		}
	}
	Graph g;
	g.init(SZ(fIndex[0]), SZ(fIndex[1]));
	FOR(i, 0, n)
	{
		if (good[i])
		{
			g.addEdge(fIndex[0][f[0][i]], fIndex[1][f[1][i]]);
		}
	}
	int cnt = g.doKuhn();
	auto [vecL, vecR] = g.minVertexCover();
	assert(SZ(vecL) + SZ(vecR) == cnt);
	cout << 1000 * m + cnt << " " << cnt;
	for (int i : vecL)
		cout << " " << fs[0][i];
	for (int i : vecR)
		cout << " " << fs[1][i];
	cout << "\n";
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	int k;
	cin >> n >> k;
	FOR(i, 0, n)
	{
		cin >> s[0][i];
		s[1][i] = s[0][i];
		reverse(ALL(s[1][i]));
	}
	FOR(t, 0, 2)
	{
		FOR(i, 0, n)
		{
			sorted[t][i] = {s[t][i], i};
		}
		sort(sorted[t], sorted[t] + n);
		FOR(i, 0, n)
			FOR(j, 0, n)
				lcp[t][i][j] = calcLCP(sorted[t][i].F, sorted[t][j].F);
	}
	while (k--)
		solve();
	return 0;
}