#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp> // Including tree_order_statistics_node_update
using namespace __gnu_pbds;
using namespace std;
#define line '\n'
#define khaled ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
long long derangement(int n){if(n == 0)return 1;if(n == 1)return 0;if(n == 2)return 1;return (n - 1)*(derangement(n - 1) + derangement(n - 2));}
bool line_checking(long long a1,long long b1,long long a2,long long b2,long long a3,long long b3){return (a3-a1)*(b2-b1)==(a2-a1)*(b3-b1);}
bool valid(long long i,long long j,long long n,long long m){return i>=0&&i<n&&j>=0&&j<m;}
long long safe_mul_mod(long long a,long long b,const long long &mod){long long res=0,y=a%mod;while(b>0){if(b&1){res=((res%mod)+(y%mod))%mod;}y=((y%mod)*(2ll%mod))%mod;b>>=1;}return (res%mod);}
long long mul(long long x,long long y,const long long&mod){return ((x%mod)*(y%mod))%mod;}
long long add(long long x,long long y,const long long&mod){return (((x%mod)+(y%mod))%mod+mod)%mod;}
long long fast_power(long long base,long long power,const long long &m=INT64_MAX){if (power == 1 || power == 0)return base * power + (!power);long long res = (fast_power(base, power / 2, m) % m) % m;if (power & 1)return mul(base,mul(res,res,m),m);else return mul(res,res,m);}
long long mod_inverse_fermat(long long B,const long long&mod=1e9+7){ return fast_power(B,mod-2,mod);}//mod is prime
vector<int>mod_inverse_for_range(int n,int p){vector<int>inv(n+1,1);for(int i=2;i<n+1;i++) {inv[i] = ( p - (p / i) * inv[p % i] % p ) % p;}return inv;}//mod is prime
vector<long long>factorial(long long n,const long long& mod){vector<long long>v(n+1,1);for(int i=2;i<=n;i++)v[i]=mul(i,v[i-1],mod);return v;}
long long NCR_MOD(long long n, long long r,vector<long long>&fact,const long long&mod){return mul(mul(fact[n], mod_inverse_fermat(fact[n - r], mod), mod), mod_inverse_fermat(fact[r], mod), mod);}
long long phi(long long n) {long long result = n;for (int i = 2; i * i <= n; i++) {if (n % i == 0) {while (n % i == 0)n /= i;result -= result / i;}}if (n > 1)result -= result / n;return result;}
long double NCR_LINEAR_TIME(long long n,long long r){if(r>n)return 0;if(r==0||r==n){return 1;}if(r==1||r==n-1)return n;return NCR_LINEAR_TIME(n-1,r-1)*(long double)n/r;}
bool power_of_two(int n) { n=abs(n);  return n && !(n & (n - 1));}
int dx[]{1,-1,0,0,1,1,-1,-1};//0->4 normal,4->8 diagonal
int dy[]{0,0,1,-1,1,-1,1,-1};
const long double pi=3.14159265350979323846;
const long double Eps=1e-10;
#define int __int128
template<class integer>
inline integer to_int(const string& s, size_t* idx = 0, int base = 10) {
    size_t n = s.size(), i = idx ? *idx : 0; bool sign = false; integer x = 0;
    if (s[i] == '-')
        ++i, sign = true;
    function<int(char)> char_to_digit = [&](char c) {
        static const int d[] = {'a'-10,'0'};
        return tolower(c)-d[isdigit(c)]; };
    while (i < n)
        x *= base, x += char_to_digit(s[i++]);
    if (idx)
        *idx = i;
    return sign ? -x : x; }

template<class integer>
inline string to_string(integer x, int base = 10) {
    bool sign = false; string s;
    if (x < 0)
        x = -x, sign = true;
    function<char(int)> digit_to_char = [](int d) {
        static const char c[] = {'a'-10,'0'};
        return c[d < 10]+d; };
    do
        s += digit_to_char(x%base), x /= base;
    while (x > 0);
    if (sign)
        s += '-';
    reverse(s.begin(),s.end());
    return s; }

template<class integer>
inline istream& read(istream& is, integer& x) {
    string s; is >> s, x = to_int<integer>(s); return is; }

template<class integer>
inline ostream& write(ostream& os, integer x) { return os << to_string(x); }

using  lll =   signed __int128;
using ulll = unsigned __int128;

inline istream& operator>>(istream& is,  lll &x) { return  read(is,x); }
inline istream& operator>>(istream& is, ulll &x) { return  read(is,x); }
inline ostream& operator<<(ostream& os,  lll  x) { return write(os,x); }
inline ostream& operator<<(ostream& os, ulll  x) { return write(os,x); }
template<typename T>
using ordered_set=tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
const int N=1e5+1;
const int mod=1e9+7;
int inf=1;
/*--------------------------------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------------------------------*/
int c(int n,int k){
    int res=0;
    while(n){
        if(n%10==k)res++;
        n/=10;
    }
    return res;
}
int dp[101][3][3][3][3][3][3][3][3][3][3];
vector<vector<int>>dlog;
int solve(int index,vector<int>&v,int zero,int one,int two,int three,int four,int five,int six,int seven,int eight,int nine){
    if(zero>2||one>2||two>2||three>2||four>2||five>2||six>2||seven>2||eight>2||nine>2)return -inf;
    if(index==v.size()){
       return 0;
    }
    int &ret=dp[index][zero][one][two][three][four][five][six][seven][eight][nine];
    if(~ret)return ret;
    int res1=solve(index+1,v,zero+dlog[index][0],one+dlog[index][1],two+dlog[index][2],three+dlog[index][3],four+dlog[index][4],five+dlog[index][5],six+dlog[index][6],
                   seven+dlog[index][7],eight+dlog[index][8],nine+dlog[index][9])+v[index];
    int res2=solve(index+1,v,zero,one,two,three,four,five,six,seven,eight,nine);
    return ret =  max(res1,res2);
}
signed main() {
    khaled
    int t;
    cin>>t;
    int l=30;
    while(l--)
        inf=inf*10;
    while(t--){
        int n;
        cin>>n;
        for(int i=0;i<n;i++)memset(dp[i],-1,sizeof(dp[i]));
        dlog.clear();
        vector<int>v(n);
        dlog.resize(n,vector<int>(10));
        for(auto &val:v)cin>>val;
        for(int j=0;j<n;j++){
            for(auto &i:{0,1,2,3,4,5,6,7,8,9})
                dlog[j][i]=c(v[j],i);
        }
        cout<<solve(0,v,0,0,0,0,0,0,0,0,0,0)<<line;
    }
}