//不要去洛谷上面提交，洛谷的这题数据有问题，去codeVs

 #include<cstdio>

 #include<cstring>

 #define ll long double

 //node[i]代表i，里面的l代表决策的作用起点，r代表决策的作用终点，p是决策的值

 struct node{int  l,r,p;}q[];

 #define MAX 1000000000000000000LL

 #define N 100100

 ll sum[N],f[N];

 int n,l,p,T;

 char ch[];

 //求|y|^p的函数

 ll pow(ll y){

     if(y<)y=-y;

     ll ans=;

     for (int i=;i<=p;i++) ans*=y;

     return ans;

 }

 //计算不协调度

 ll calc(int x,int y){

     return f[x]+pow(sum[y]-sum[x]+(y-x-)-l);

 }

 //二分查找找决策转折点

 //node表示老决策点，x表示新决策点的值

 //这个函数就是在老的决策点的范围中寻找新的决策点的值

 int find(node t,int x){

     int l=t.l,r=t.r;

     while(l<=r){//当头小于等于尾，也就是还有数可以查找的时候

         //mid=(头+尾)/2

         int mid=(l+r)>>;

         //小于的情况，也就是新的决策点更有，我们就要一直往前继续扩展新的决策点的起点，

         //直到老决策点比较好的时候

         if (calc(x,mid)<=calc(t.p,mid)) r=mid-;

         //大于的情况，也就老决策点比较好的时候，我们往后搜索新决策点的作用域的起点

         else l=mid+;

     }

     //返回头

     return l;

 }

 void dp(){

     //用数组模拟栈，头置为1，尾置为0

     int head=,tail=;

     //将第一个决策入栈，决策1的起点为0，终点为n，决策的初始值置为0，因为初始决策就是0

     q[++tail]=(node){,n,};

     //求取f[i]

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

         //如果栈头结点上的决策作用终点小于i，说明这个决策已经无法对i进行作用，所以我们要换新的决策

         //head<=tail栈的头小于等于尾，说明栈里面还有新的决策，那就换上新的决策

         //因为head++，所以此时头节点是指向新的决策

         if(q[head].r<i&&head<=tail) head++;

         //用新的可以作用i位置的决策来计算f[i]的值，这样计算出来的f[i]的值就是最优值

         f[i]=calc(q[head].p,i);

         //calc(i,n)表示通过值为i的决策去计算f[n]的值

         //calc(q[tail].p,n)表示通过旧决策q[tail].p去计算f[n]的值

         //calc(i,n)<=calc(q[tail].p,n)表示值为i的决策优于老决策，我们才进行下一步

         //不然，如果老决策更好，我们根部用不着换决策 

         //每一个被计算出来的f[i]，都会使i成为新的决策，因为我有了f[i]的值，

         //所以我可以用f[i]的值帮助计算别的f[k](k>i)，所以f[i]就是新的决策 

         /*

         比如说我们的样例1中，当i==3时，我们通过 q[head].p=2这个决策把f[3]算出来了

         比如说这里的n是4，如果calc(3,4)<=calc(2,4)，那说明值为3的这个新决策更好，

         我们就要在决策2的作用区间里面找出决策3的作用区间

         */ 

         //如果新决策更好，找出新决策的作用范围

         //确定新决策点的终点

         if (calc(i,n)<=calc(q[tail].p,n)){

             //如果栈的头小于等于尾，head<=tail，说明栈里有元素

             //calc(q[tail].p,q[tail].l)表示用旧决策点决策值来决策旧决策点的起点

             //calc(i,q[tail].l)用新决策点来决策旧决策点的起点

             //如果后者小于前者，说明新决更好，那就要在更广阔的范围里面去寻找新决策点的决策范围

             //换句话说，就是当新决策点的作用范围覆盖了老决策点，我们要到比旧决策点更老点决策点里面寻找新决策点的作用方位

             while(head<=tail&&calc(q[tail].p,q[tail].l)>=calc(i,q[tail].l)) tail--;

             //head>tail说明栈已经为空了，就是说现在新决策点最好，所以把新决策点入栈

             if(head>tail)q[++tail]=(node){i,n,i};

             else{

                 //否则，我们就要去寻找新决策点的作用范围

                 //x返回新决策点范围的起点

                 int x=find(q[tail],i);

                 //旧决策点的尾部置为x-1

                 q[tail].r=x-;

                 //将新决策点入栈

                 q[++tail]=(node){x,n,i};

             }

         }

     }

 }

 int main(){

     scanf("%d",&T);

     while(T--){

         scanf("%d%d%d",&n,&l,&p);

         for (int i=;i<=n;i++) scanf("%s",ch),sum[i]=sum[i-]+strlen(ch);

         dp();

         if(f[n]>MAX)

             puts("Too hard to arrange");

         else

             printf("%lld\n",(long long)f[n]);

         puts("--------------------");

     }

     return ;

 }