省流：拉低洛谷均分，给谷民们丢脸了

Day -2

状态一泻千里，模拟赛只能靠拼暴力和部分分谋生。虽然后来被证实为T1放水的noi模拟,confidence++

但是看了一下之前梦熊S组模拟的T2，发现虽然是蓝题但好像不是很难(?)，confidence++

Day -1

上午在打模拟赛，终于切了一个题，虽然是原题buff。

下午运动会开幕式，看表演看得很爽。用扩音器怒喷基友Sb成功引起全场注意

晚上补了一下去年J组的题，except 大模拟。大模拟去死

Day 0

运动会Day1，上午我们班拿下了若干个小组第一，包括但不限于100，400，1500。昨天被我喷sb的那个直接锁定1500金牌。

下午丢了个铅球，成功成为了凑数的文化生。后来直接就就坐车去GY住酒店了，成功回到了熟悉的贵师大门口。

晚上大概写了一些板子，结果线段树1都能写挂，感觉是不详之兆。

Day 1

下午进考场，贵州师范学院的机子一如既往地烂，显示屏角度一言难尽。感觉不如学校机房

14:30+eps下发了密码，打开压缩包。大概开了一下四个题，感觉T1,T2比较可做，T4看都不想看。

14:59写完T1，感慨T1放水题也成ccf传统了。接着开T2

15:19发现很可做啊，第一问直接模拟都能做，第二问可以处理出来每个车子在哪几个监控之间会被抓，然后就变成线段覆盖的问题了，confidence++。伏笔

然后就开始死磕区间覆盖，想到了包括但不限于树状数组维护端点值，神秘贪心，神秘DP。一直在猜结论和hack自己。然后就没什么思路了，一直在想这个题。

感觉这个T2的线段覆盖就是一个普及组内容，但我就是想不到，于是一直在磕这个题。

XX:XX意识到时日无多，再死磕下去就要遗憾离场了。直接愤然敲下fuck ccf20pts暴力跑路。

迅速把T3的暴力给码了，又去想T2的乱搞随机化做法，无果。

就这样糊里糊涂地结束了。应该是100+20+20=140pts

出来吃饭发现一桌人保底都是100pts，但是一个T2做法都凑不出来。

后来教练问了一下， GY那几个不出意外地200多分，ZY那边鲜有200，我们这一桌全是100多，还是太菜了。

这个故事告诉我们一个道理：在场上别一直死磕某个题。

NOIP一定会赢的。

Day 2

抑郁了，上洛谷发现T2的0.4倍经验我竟然之前做过，但是考场上没有想起来这个线段覆盖的trick，不好好复习导致的。

Day inf

最后结果：100+20+20+0=140pts

菜的好处就是没有分给你挂

附赛时code：

//【数据删除】 
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define FOR_(i,a,b) for(int i=b;i>=a;i--)
#define fir first
#define sec second
#define pb push_back
namespace FastIO{
    int buf[100]={0},p=0;
    int rd(){
        int x=0,f=1;char c=getchar();
        while(c<'0'||'9'<c){if(c=='-')f=-1;c=getchar();}
        while('0'<=c&&c<='9')x=x*10+c-'0',c=getchar();
        return x*f; 
    }void write(int x,char c='#'){
        if(!x)putchar('0');
        else{
            if(x<0)putchar('-'),x*=-1;
            while(x)buf[++p]=x%10,x/=10;
            while(p)putchar(buf[p--]+'0');
        }
        if(c!='#')putchar(c);
    }
}
#define rd FastIO::rd
#define write FastIO::write
typedef unsigned long long ull;
typedef __int128 u128;
typedef pair<int,int> pii;
const int N=1e5+10;
int a[N],cnt[N],b[N];
signed main(){
    freopen("duel.in","r",stdin),freopen("duel.out","w",stdout);
    int n=rd();
    FOR(i,1,n)a[i]=rd(),b[i]=a[i];
    sort(a+1,a+n+1),sort(b+1,b+n+1);
    int n1=unique(b+1,b+n+1)-(b+1);
    FOR(i,1,n)a[i]=lower_bound(b+1,b+n1+1,a[i])-b;
    int minv=0,ans=n;
    FOR(i,1,n){
        if(i==1){minv=a[i],cnt[a[i]]++;continue;}
        if(minv!=a[i]){
            ans--,cnt[minv]--;
            if(!cnt[minv])minv++;
        }
        cnt[a[i]]++;
    }
    write(ans,'\n');
    return 0;
}
/*
14:41 看完第一题
14:41+eps 感觉可以排序后贪，好像写个离散化，维护一下就写完了？
14:57 过完大样例，开下一题。不是，CCF第一题放水题成传统了是吧，希望大模拟也别成传统
*/

//【数据删除】
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define FOR_(i,a,b) for(int i=b;i>=a;i--)
#define fir first
#define sec second
#define pb push_back
namespace FastIO{
    int buf[100]={0},p=0;
    int rd(){
        int x=0,f=1;char c=getchar();
        while(c<'0'||'9'<c){if(c=='-')f=-1;c=getchar();}
        while('0'<=c&&c<='9')x=x*10+c-'0',c=getchar();
        return x*f; 
    }void write(int x,char c='#'){
        if(!x)putchar('0');
        else{
            if(x<0)putchar('-'),x*=-1;
            while(x)buf[++p]=x%10,x/=10;
            while(p)putchar(buf[p--]+'0');
        }
        if(c!='#')putchar(c);
    }
}
#define rd FastIO::rd
#define write FastIO::write
typedef unsigned long long ull;
typedef __int128 u128;
typedef pair<int,int> pii;
typedef long double ld;
const int N=1e5+10,M=1e6+10,INF=LLONG_MAX;
struct DS{
    int c[M],tot;
    void clear(){memset(c,0,sizeof(c));}
    #define lowbit(x) (x&(-x))
    void add(int i,int x){
        i++;
        while(i<M)c[i]+=x,i+=lowbit(i);
    }int query(int i){
        i++,tot=0;
        while(i)tot+=c[i],i-=lowbit(i);
        return tot;
    }int query(int l,int r){
        return query(r)-query(l-1);
    }
    #undef lowbit
}ds;
struct Car{int d,v,a;}cars[N];
struct Range{int l,r;}ranges[N];
int n,m,L,V,p[N],st[N],b[N];
vector<int> vec;
pii clac(int d,int v,int a){
    if(a==0){
        if(v>V)return {d,L};
        else return {-1,-1};
    }else if(a>0){
        if(v>V)return {d,L};
        else{
            ld t=1.0*(V-v)/a;
            int dd=(int)(v*t+a*t*t/2);
            return {min(L,d+dd),L};
        }
    }else if(a<0){
        if(v<=V)return {-1,-1};
        else{
            ld t=1.0*(V-v)/a;
            int dd=(int)(v*t+a*t*t/2+0.999999999);
            return {d,min(L,d+dd)};
        }
    }
    return {-1,-1};
}
void init(){ds.clear(),memset(st,0,sizeof(st)),memset(b,0,sizeof(b));}
void solve(){
    init();
    n=rd(),m=rd(),L=rd(),V=rd();
    FOR(i,1,n){
        int d=rd(),v=rd(),a=rd();
        cars[i]={d,v,a};
    }
    FOR(i,1,m){
        int d=rd();
        p[i]=d,ds.add(p[i],1);
    }
    int ans1=0,tot=0,ans2=INF;
    FOR(i,1,n){
        pii p1=clac(cars[i].d,cars[i].v,cars[i].a);
        int l=p1.fir,r=p1.sec;
        if(l==-1&&r==-1)continue;
        if(ds.query(l,r))ans1++;
    }
    write(ans1,' ');
    FOR(i,1,n){
        pii p1=clac(cars[i].d,cars[i].v,cars[i].a);
        int l=p1.fir,r=p1.sec;
        if(l==-1&&r==-1)continue;
        if(!ds.query(l,r))continue;
        l=lower_bound(p+1,p+m+1,l)-p,r=upper_bound(p+1,p+m+1,r)-p-1;
        ranges[++tot]={l,r};
    }
    FOR(S,0,(1<<m)-1){
        int cnt=0;
        FOR(i,1,m)if((S>>(i-1))&1)b[i]=1,cnt++;
        FOR(i,1,m)b[i]+=b[i-1];
        FOR(i,1,tot){
            int l=ranges[i].l,r=ranges[i].r;
            if(b[r]-b[l-1]==0)cnt=INF;
        }
        ans2=min(ans2,cnt);
        FOR(i,0,m)b[i]=0;
    }
    write(m-ans2,'\n');
}
signed main(){
    freopen("detect.in","r",stdin),freopen("detect.out","w",stdout);
    int T=rd();
    while(T--)solve();
    return 0;
}
/*
15:24 好像会了？第一问直接模拟，第二问可以发现的是每一辆车被发现超速的测速仪分布一定是一个区间。就相当于找最少的点包含在全部的区间里面,这个东西其实就是区间的r<l的个数？树状数组维护一下就好了，好像蛮对的 
16:15 写完了，测一发发现用树状数组维护是假的 
16:18 不对，用差分维护一下就好了啊，我是【数据删除】 
16:35 不对，那个还是假的，废了 
16:42 还是没有什么思路啊，去趟厕所先 
17:01 突然发现最开始的好像又是对的，只要别重复统计就好 
17:22 好像又不对啊，啊啊啊啊啊 
17:47 不会要遗憾离场了吧，赶紧写个O(ans*n+m)的骗分补救一下,noip再战 
18:02 md,突然发现骗分都不会，只能写 2^m 次方了 
*/

//【数据删除】
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define FOR_(i,a,b) for(int i=b;i>=a;i--)
#define fir first
#define sec second
#define pb push_back
namespace FastIO{
    int buf[100]={0},p=0;
    int rd(){
        int x=0,f=1;char c=getchar();
        while(c<'0'||'9'<c){if(c=='-')f=-1;c=getchar();}
        while('0'<=c&&c<='9')x=x*10+c-'0',c=getchar();
        return x*f; 
    }void write(int x,char c='#'){
        if(!x)putchar('0');
        else{
            if(x<0)putchar('-'),x*=-1;
            while(x)buf[++p]=x%10,x/=10;
            while(p)putchar(buf[p--]+'0');
        }
        if(c!='#')putchar(c);
    }
}
#define rd FastIO::rd
#define write FastIO::write
typedef unsigned long long ull;
typedef __int128 u128;
typedef pair<int,int> pii;
const int N=2e5+10;
int a[N];
void solve(){
    int n=rd(),ans=0;
    FOR(i,0,n-1)a[i]=rd();
    FOR(S,0,(1<<n)-1){
        int sum=0,t[2]={-1,-1};
        FOR(i,0,n-1){
            int c=(S>>i)&1;
            if(t[c]!=-1)if(a[t[c]]==a[i])sum+=a[i];
            t[c]=i;
        }
        ans=max(ans,sum);
    }
    write(ans,'\n');
} 
signed main(){
    freopen("color.in","r",stdin),freopen("color.out","w",stdout);
    int T=rd();
    while(T--)solve();
    return 0;
}
//17:09 还是开T3吧，码个2^n暴力
//17:15 20pts到手，跳回T2