#pragma GCC diagnostic ignored "-Wwrite-strings"
//#pragma GCC diagnostic ignored "-Wc++11-extensions"

#include <vector>
#include <map>
#include <set>
#include <stack>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cctype>
#include <cstring>
#include <queue>
#include <cassert>
#include <ctime>
#include <cassert>
#include <climits>
#include "stdarg.h"
#include <bitset> //http://stackoverflow.com/questions/4048749/bitwise-operations-on-vectorbool //http://www.drdobbs.com/the-standard-librarian-bitsets-and-bit-v/184401382

using namespace std;

typedef long long LL;
typedef long double LD;
typedef vector<int> VI;
typedef vector<LL> VLL;
typedef pair<int,int> PII;
typedef vector<PII> VPII;
typedef vector <VI> VVI;
typedef vector <vector <double> > VVD;
typedef vector <double> VD;
typedef vector <string> VS;

#define MP make_pair
#define ST first
#define ND second
#define PB push_back
#define FOR(i,a,b) for( int i=(a); i<=(b); ++i)
#define FORD(i,a,b) for( int i=(a); i>=(b); --i)
#define REP(i,n) for(int i=0; i<(n); ++i)
#define ALL(X) (X).begin(),(X).end()
#define SZ(X) (int)(X).size()
#define FORE(it,X) for(__typeof((X).begin()) it=(X).begin(); it!=(X).end();++it)

#define CE cout << endl;
#define CL cout << "--------------------------------------" << endl;
#define ASF assert(false);
#define V vector

template<template<typename, typename> class ContainerT, typename ValueT> //http://cboard.cprogramming.com/cplusplus-programming/145441-stl-container-template-argument.html
ostream & operator << (ostream &out, const ContainerT<ValueT, std::allocator<ValueT> > &A) {
  FORE(i, A) out << *i << " "; return out;
}

template <class T, class U>
ostream & operator << (ostream &out, const pair<T,U> &A) {
  out << A.ST << "-" << A.ND; return out;
}


#define VA_NARGS_IMPL(_1,_2,_3,_4,_5,_6,_7,_8,N,...) N
#define VA_NARGS(...) VA_NARGS_IMPL(__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1)

#define P_(a)                       #a << ": " << a
#define P__(a)                      " | " << P_(a)
#define P1(a)                       cout << P_(a) << endl;
#define P2(a, b)                    cout << P_(a) << P__(b) << endl;
#define P3(a, b, c)                 cout << P_(a) << P__(b) << P__(c) << endl;
#define P4(a, b, c, d)              cout << P_(a) << P__(b) << P__(c) << P__(d) << endl;
#define P5(a, b, c, d, e)           cout << P_(a) << P__(b) << P__(c) << P__(d) << P__(e) << endl;
#define P6(a, b, c, d, e, f)        cout << P_(a) << P__(b) << P__(c) << P__(d) << P__(e) << P__(f) << endl;
#define P7(a, b, c, d, e, f, g)     cout << P_(a) << P__(b) << P__(c) << P__(d) << P__(e) << P__(f) << P__(g) << endl;
#define P8(a, b, c, d, e, f, g, h)  cout << P_(a) << P__(b) << P__(c) << P__(d) << P__(e) << P__(f) << P__(g) << P__(h) << endl;

#define P_IMPL2(count, ...) P ## count (__VA_ARGS__)
#define P_IMPL(count, ...) P_IMPL2(count, __VA_ARGS__) 
#define P(...) P_IMPL(VA_NARGS(__VA_ARGS__), __VA_ARGS__)

template<class T> void mini(T &a, const T &b) {if(b<a)a=b;}
template<class T> void maxi(T &a, const T &b) {if(b>a)a=b;}

int M, Q, N;
VS corpus; //0+[1,M], 0 is imaginary word.
VI R; //[0,N) -> [1,M], corpus index 
VVD T; //0+[1,M] * [1,M], transition prob, 0 is imaginary word.
VVD A; //[1,M] * [1,M], successing prob

VVD cache; //cache
VVI choice; //tracking
#define NEG_INF -1e200

template<class T>
void init(V<V<T> > &A, int N, int M) {
  A.clear(); A.resize(N); REP(i, N) A[i].resize(M);
}
template<class T>
void init(V<V<T> > &A, int N, int M, T val) {
  A.clear(); A.resize(N); REP(i, N) REP(j, M) A[i].PB(val);
}

double recognize(int segment, int previousMatch) {
  if(segment == N) return 0; //not log -> 1. identity of the operation
  assert(segment >= 0 and segment < N); //segment : [0,N)
  double &ret = cache[segment][previousMatch];
  if(ret != 1.0) return ret;
  ret = NEG_INF;
  int &choose = choice[segment][previousMatch];
  FOR(thisMatch, 1, M) {
    double cand = T[previousMatch][thisMatch]
                + A[thisMatch][R[segment]]
                + recognize(segment+1, thisMatch); //not log -> *
    if(ret < cand) {
      ret = cand;
      choose = thisMatch;
    }
  }
  assert(ret <= 0);
  assert(choose != 0); //means imaginary
  return ret;
}

string reconstruct(int segment, int previousMatch) {
  int choose = choice[segment][previousMatch];
  assert(choose >= 0 and choose <= M);
  string ret = corpus[choose];
  if(segment < N-1) ret = ret + " " + reconstruct(segment+1, choose);
  return ret;
}

double mylog(double a) {
  if(a == 0) return NEG_INF;
  else return log(a);
}

int main()
{
  cin >> M >> Q;
  init(T, M+1, M+1);
  init(A, M+1, M+1);
  corpus.resize(M+1); REP(i, M) cin >> corpus[i+1];
  corpus[0] = "IMAGINARY";
  REP(i, M+1) REP(j, M) scanf("%lf", &T[i][j+1]);
  REP(i, M) REP(j, M) scanf("%lf", &A[i+1][j+1]);

  REP(i, M+1) REP(j, M) T[i][j+1] = mylog(T[i][j+1]);
  REP(i, M) REP(j, M) A[i+1][j+1] = mylog(A[i+1][j+1]);

  //solves for each query
  REP(i, Q) {
    R.clear();
    cin >> N;
    REP(j, N) {
      string temp;
      cin >> temp;
//      FORE(k, corpus) if(*k == temp) R.PB(k-corpus.begin()); //there may exist corpus[0]
      FOR(k, 1, M) if(corpus[k] == temp) R.PB(k);
    }
    assert(R.size() == N);
    init(cache, M, M, 1.0);
    init(choice, M, M);
    recognize(0, 0);
    cout << reconstruct(0, 0) << endl;
  }

  return 0;
}