#include<cstdio>

#include<cstring>

#include<cmath>

#include<vector>

#include<queue>

#include<algorithm>

using namespace std;

const int maxn=+;

int n;

int belong[maxn];

int cost[maxn];

int g[maxn][maxn];

char str[maxn];

const int INF=0x7FFFFFFF;

struct Edge

{

    int from,to,cap,flow,cost;

};

int N,M,K,len,s,t;

vector<Edge> edges;

vector<int> G[maxn];

int inq[maxn];

int d[maxn];

int p[maxn];

int a[maxn];

int use[maxn];

int dis[maxn][maxn];

void init()

{

    for(int i=; i<maxn; i++) G[i].clear();

    edges.clear();

}

void Addedge(int from,int to,int cap,int cost)

{

    edges.push_back((Edge)

    {

        from,to,cap,,cost

    });

    edges.push_back((Edge)

    {

        to,from,,,-cost

    });

    len=edges.size();

    G[from].push_back(len-);

    G[to].push_back(len-);

}

bool BellmanFord(int s,int t,int &flow,int &cost)

{

    for(int i=; i<maxn; i++) d[i]=INF;

    memset(inq,,sizeof(inq));

    memset(p,-,sizeof(p));

    d[s]=;

    inq[s]=;

    p[s]=;

    a[s]=INF;

    queue<int>Q;

    Q.push(s);

    while(!Q.empty())

    {

        int u=Q.front();

        Q.pop();

        inq[u]=;

        for(int i=; i<G[u].size(); i++)

        {

            Edge& e=edges[G[u][i]];

            if(e.cap>e.flow&&d[e.to]>d[u]+e.cost)

            {

                d[e.to]=d[u]+e.cost;

                p[e.to]=G[u][i];

                a[e.to]=min(a[u],e.cap-e.flow);

                if(!inq[e.to])

                {

                    Q.push(e.to);

                    inq[e.to]=;

                }

            }

        }

    }

    if(d[t]==INF) return false;

    flow+=a[t];

    cost+=d[t]*a[t];

    int u=t;

    while(u!=s)

    {

        edges[p[u]].flow+=a[t];

        edges[p[u]^].flow-=a[t];

        u=edges[p[u]].from;

    }

    return true;

}

void Mincost (int s,int t)

{

    int flow=,cost=;

    while(BellmanFord(s,t,flow,cost));

    printf("%d ",flow);

    printf("%d\n",*flow-cost);

}

void read()

{

    scanf("%s",str);

    for(int i=;str[i];i++) belong[i+]=str[i]-'';

    scanf("%s",str);

    for(int i=;str[i];i++) cost[i+]=str[i]-'';

    memset(g,,sizeof g);

    for(int i=;i<=n;i++)

    {

        int num; scanf("%d",&num);

        while(num--)

        {

            int id; scanf("%d",&id);

            g[i][id]=g[id][i]=;

        }

    }

}

int main()

{

    int T; scanf("%d",&T);

    while(T--)

    {

        scanf("%d",&n); s=,t=n+;

        init();

        read();

        for(int i=;i<=n;i++)

        {

            if(belong[i]==) Addedge(,i,,);

            else Addedge(i,n+,,);

        }

        for(int i=;i<=n;i++)

        {

            if(belong[i]==) continue;

            for(int j=;j<=n;j++)

            {

                if(i==j) continue;

                if(g[i][j]==) continue;

                if(belong[j]==) continue;

                Addedge(i,j,,cost[i]+cost[j]);

            }

        }

        Mincost(s,t);

        for(int i=;i<edges.size();i=i+)

        {

            if(edges[i].from==) continue;

            if(edges[i].to==n+) continue;

            if(edges[i].flow==) continue;

            printf("%d %d\n",edges[i].from,edges[i].to);

        }

    }

    return ;

}