#include <bits/stdc++.h>

using namespace std;

const int inf = 1000000000;

class flow {
    public:
    class edge {
        public:
        int nxt, to, f, c;
    };

    vector<edge> e;
    vector<int> head;
    vector<int> pree;
    vector<int> prev;
    vector<int> d;
    vector<int> vis;
    int source;
    int sink;
    int cnt;

    flow(int N, int M, int _source, int _sink) : head(N), pree(N), prev(N), vis(N), d(N), e(M), source(_source), sink(_sink) { cnt = 1; }

    inline void link(int u, int v, int f, int c) {
        e[++cnt].nxt = head[u];
        head[u] = cnt;
        e[cnt].f = f;
        e[cnt].to = v;
        e[cnt].c = c;
    }
    inline void insert(int u, int v, int f, int c) {
        link(u, v, f, c);
        link(v, u, 0, -c);
    }
    bool spfa() {
        d.assign(d.size(), -1);
        d[source] = 0;
        queue<int> q;
        q.push(source);
        while(!q.empty()) {
            int u = q.front();
            q.pop();
            vis[u] = 0;
            for(int i = head[u]; i; i = e[i].nxt) if(e[i].f && (d[e[i].to] == -1 || d[e[i].to] < d[u] + e[i].c)) {
                pree[e[i].to] = i;
                prev[e[i].to] = u;
                d[e[i].to] = d[u] + e[i].c;
                if(vis[e[i].to] == 0) {
                    q.push(e[i].to);
                    vis[e[i].to] = 1;
                }
            }
        }
        return d[sink] != -1; 
    }
    inline int Edmonds_Karp() {
        int ans = 0;
        while(spfa()) {
            int now = sink;
            int delta = 1000000000;
            while(now != source) {
                delta = min(delta, e[pree[now]].f);
                now = prev[now];
            }
            now = sink;
            while(now != source) {
                e[pree[now]].f -= delta;
                e[pree[now] ^ 1].f += delta; 
                now = prev[now];
            }
            ans += d[sink] * delta;
        } 
        return ans;
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int T;
    cin >> T;

    while(T--) {
        int n, a, b, c;
        cin >> n >> a >> b >> c;

        map<string, int> mp;
        mp["012"] = 1;
        mp["021"] = 2;
        mp["102"] = 3;
        mp["120"] = 4;
        mp["201"] = 5;
        mp["210"] = 6;

        int source = 0;
        int sink = 11;
        int A = 8;
        int B = 9;
        int C = 10;

        flow flow(15, 105, source, sink);
        flow.insert(1, A, inf, 3);
        flow.insert(1, B, inf, 2);
        flow.insert(1, C, inf, 1);
        flow.insert(2, A, inf, 3);
        flow.insert(2, B, inf, 1);
        flow.insert(2, C, inf, 2);
        flow.insert(3, A, inf, 2);
        flow.insert(3, B, inf, 3);
        flow.insert(3, C, inf, 1);
        flow.insert(4, A, inf, 1);
        flow.insert(4, B, inf, 3);
        flow.insert(4, C, inf, 2);
        flow.insert(5, A, inf, 2);
        flow.insert(5, B, inf, 1);
        flow.insert(5, C, inf, 3);
        flow.insert(6, A, inf, 1);
        flow.insert(6, B, inf, 2);
        flow.insert(6, C, inf, 3);

        flow.insert(A, sink, a, 0);
        flow.insert(B, sink, b, 0);
        flow.insert(C, sink, c, 0);

        vector<int> cnt(7);

        for(int i = 0; i < n; ++i) {
            string s;
            cin >> s;

            cnt[mp[s]] += 1;
        }

        for(int i = 1; i < 7; ++i) {
            flow.insert(source, i, cnt[i], 0);
        }

        cout << flow.Edmonds_Karp() << '\n';
    }

    return 0;
}