#include<iostream>
#include<vector>
#include<array>
#include<algorithm>
#include<string.h>
#include<cstring>
#include <string>
#include<unordered_map>
#include <set>
#include<numeric>
#include<queue>
#include<stack>
#include<cmath>
#include<iomanip>
#include <functional>
#include<assert.h>
#include<climits>
#include <map>
#include <random>
#include <bitset>
#include <chrono>
#include <limits>
#include<fstream>

using ll = long long;
using i64 = long long;

/**   最大流（MaxFlow 新版）
 *    2023-07-21: https://ac.nowcoder.com/acm/contest/view-submission?submissionId=62915815
**/

constexpr int inf = 1E9;
template<class T>
struct MaxFlow {
    //边结构体
    struct _Edge {
        int to;//
        T cap;
        _Edge(int to, T cap) : to(to), cap(cap) {}
    };

    int n;
    std::vector<_Edge> e;
    std::vector<std::vector<int>> g;
    std::vector<int> cur, h;

    MaxFlow() {}
    MaxFlow(int n) {
        init(n);
    }
    //初始化
    void init(int n) {
        this->n = n;
        e.clear();
        g.assign(n, {});
        cur.resize(n);
        h.resize(n);
    }
    //对点分层,找增广路,找一条增广路
    bool bfs(int s, int t) {//给定起点和终点
        h.assign(n, -1);//分配n个空间,每个空间初始化为-1
        std::queue<int> que;
        h[s] = 0;//起点为0
        que.push(s);//放入起点
        while (!que.empty()) {
            const int u = que.front();//拿到点
            que.pop();
            for (int i : g[u]) {//遍历它的下一层
                int v = e[i].to;//拿到下一个点和该边的容量
                auto c = e[i].cap;
                if (c > 0 && h[v] == -1) {//如果容量大于0且该点没有被重复走过
                    h[v] = h[u] + 1;//走过的第几个点
                    if (v == t) {//如果走到了终点就返回true
                        return true;
                    }
                    que.push(v);//否则将这个点放到队列中继续往下找
                }
            }
        }
        //如果最终都没有找到终点,这说明没有合法的增广路,则返回false
        return false;
    }
    //多路增广
    T dfs(int u, int t, T f) {
        if (u == t) {
            return f;
        }
        auto r = f;//
        for (int& i = cur[u]; i < int(g[u].size()); ++i) {
            const int j = g[u][i];
            int v = e[j].to;//拿到下一个点和该边的容量
            auto c = e[j].cap;
            //
            if (c > 0 && h[v] == h[u] + 1) {
                auto a = dfs(v, t, std::min(r, c));
                e[j].cap -= a;
                e[j ^ 1].cap += a;
                r -= a;
                if (r == 0) {
                    return f;
                }
            }
        }
        return f - r;
    }
    //添边
    //起点,终点,容量
    void addEdge(int u, int v, T c) {
        g[u].push_back(e.size());//点u的下一条边在e的哪个位置记录着
        e.emplace_back(v, c);//往后放
        g[v].push_back(e.size());//
        e.emplace_back(u, 0);//往回连一条边,容量为0,用来构建残留网
    }
    //dinic算法.累加可行流
    T flow(int s, int t) {
        T ans = 0;
        while (bfs(s, t)) {//首先看有没有合法的增广路
            cur.assign(n, 0);
            //传入起点和终点和数据t的最大值
            ans += dfs(s, t, std::numeric_limits<T>::max());//
        }
        return ans;
    }

    std::vector<bool> minCut() {
        std::vector<bool> c(n);
        for (int i = 0; i < n; i++) {
            c[i] = (h[i] != -1);
        }
        return c;
    }

    struct Edge {
        int from;
        int to;
        T cap;
        T flow;
    };
    std::vector<Edge> edges() {
        std::vector<Edge> a;
        for (int i = 0; i < e.size(); i += 2) {
            Edge x;
            x.from = e[i + 1].to;
            x.to = e[i].to;
            x.cap = e[i].cap + e[i + 1].cap;
            x.flow = e[i + 1].cap;
            a.push_back(x);
        }
        return a;
    }
};

std::map<std::string, int>mp;
void solve() {
    //D方块,C梅花,H红桃,S黑桃,点数2-9,10(T),J,Q,K,A
    //t1转换为D,t2转换为C,t3转换成H.t4转换为S,t5转换为万能牌,t6将一张转换成另一张(完全复制)
    //同花顺,花色相同
    std::vector<int>a(4),b(6);
    int n;
    std::cin >> n;
    for (int i = 0; i < n; i++) {
        std::string s;
        std::cin >> s;
        if (s[1] == 'D')a[0]++;
        else if (s[1] == 'C')a[1]++;
        else if (s[1] == 'H')a[2]++;
        else a[3]++;
    }
    std::cin >> b[0] >> b[1] >> b[2] >> b[3] >> b[4] >> b[5];
    b[4] += b[5];
    ll ans = 0,sum=0;
    for (int i = 0; i < 4; i++) {
        ans += a[i] / 5;
        a[i] %= 5;
        sum += a[i];
    }
    ll reans = 0;
    //for (int i = 0; i < 4; i++) {
    //    //res1表示除了当前花色其他排的总数量,res2表示可以转入的牌的数量和万能牌的数量
    //    ll res1 = sum - a[i], res2 = 3 * b[i] + b[4];
    //    //5-a[i]表示需要转入牌的数量,需要转入的数量不能大于剩下的牌的数量,且不能大于能够转入的万能牌的数量
    //    if (5 - a[i] <= res1 && 5 - a[i] <= res2) {//这个表示可以凑成
    //        ans++;
    //        sum -= a[i];//总数--;
    //        //如果用到了万能牌
    //        if (5 - a[i] > 3 * b[i]) {//这个表示要转换的数量超过了万能牌的数量
    //            //总转入的数量减去万能牌的数量就是新转入的数量
    //            b[4] = res2 - 5 + a[i];
    //        }
    //    }

    //}
    ll op = 0;
    for (auto re : mp) {
        reans = 0;
        int sum1 = sum;
        std::vector<int>c = b;
        for (int j = 0; j < 4; j++) {
            int i = re.first[j]-'0';
            //res1表示除了当前花色其他排的总数量,res2表示可以转入的牌的数量和万能牌的数量
            ll res1 = sum1 - a[i], res2 = 3 * c[i] + c[4];
            //5-a[i]表示需要转入牌的数量,需要转入的数量不能大于剩下的牌的数量,且不能大于能够转入的万能牌的数量
            if (5 - a[i] <= res1 && 5 - a[i] <= res2) {//这个表示可以凑成
                reans++;
                sum1 -= 5;//总数--;
                //如果用到了万能牌
                if (5 - a[i] > 3 * c[i]) {//这个表示要转换的数量超过了万能牌的数量
                    //总转入的数量减去万能牌的数量就是新转入的数量
                    c[4] = res2 - 5 + a[i];
                }
            }
        }
        op = std::max(op, reans);
    }
    std::cout << ans+op << "\n";
    //6种能力牌,现在四种花色都不足以凑成5张
    //让其它三种往这种上堆
}
int main() {
    std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
    int t = 1;
    std::cin >> t;
    std::vector<int>vis(4);
    auto dfs = [&](auto self, std::string s, int sum)->void {
        if (s.size() > 4)return;
        if (sum > 6)return;
        if (s.size() == 4 && sum == 6 && mp.find(s) == mp.end()) {
            mp[s] = 1;
            return;
        }
        for (int i = 0; i < 4; i++) {
            if (vis[i])continue;
            vis[i] = 1;
            s.push_back(i + '0');
            sum += i;
            self(self, s, sum);
            s.pop_back();
            sum -= i;
            vis[i] = 0;
        }
    };
    std::string s = "";
    dfs(dfs, s, 0);
    while (t--) {
        solve();
    }
    return 0;
}