#include <bits/stdc++.h>

using namespace std;

/*
    O problema estipula que possuimos um certo numero de caminhoes e devemos transportar todos os paineis
    na ordem que eles aparecem na entrada

    A ideia para resolver é a seguinte:
    - Estipulo um valor máximo que cada caminhão transportará
    - Verifico se é possível transportar todos os painéis com essa restrição de valor maximo, e com o número de caminhõe disponiveis
    - Se for possivel transportar todos, posso tentar diminuir o valor e verificar se isso ainda é possível
    - Se não for, só posso aumentar o valor

    Para estipular esse valor utiliza-se a busca binária
*/
int main(){
    int testes, nPaineis, caminhoes, frete, peso[110], maior;
    cin >> testes;
    while(testes--){
        cin >> nPaineis >> caminhoes >> frete;

        // logica de maior para saber qual o maior peso de uma carga
        maior = 0;
        for(int i = 0; i < nPaineis; i++){
            cin >> peso[i];
            // a função max retorna o maior dentre os dois valores
            maior = max(maior, peso[i]);
        }
        // O limite inferior da busca seria o maior peso de uma carga, o superior seria um valor muito grande, maior que a soma das cargas
        // Note que não posso dizer que cada caminhão vai carregar apenas 10kg se existe uma carga de 12kg pq ela não
        // entraria em nenhum caminhão, logo o menor valor que eles podem carregar seria 12kg

        int limiteInferior = maior, limiteSuperior = 200000, meio, resposta;

        while(limiteInferior <= limiteSuperior){
            meio = (limiteInferior + limiteSuperior)/2;

            // Digo que seria necessario ao menos 1 caminhão, e o peso inicial dele é de 0kg
            int nCaminhoesNecessarios = 1, pesoAtual = 0;
            for(int i = 0; i < nPaineis; i++){
                // carrega-se o caminhao com a cargas até que o peso maximo (meio) seja excedido
                pesoAtual += peso[i];
                // Se o peso foi excedido
                if(pesoAtual > meio){
                    // - vou precisar de um novo caminhao
                    nCaminhoesNecessarios++;
                    // - vou carrega-lo com a carga atual, logo o peso dele seria o mesmo da carga
                    pesoAtual = peso[i];
                }
            }

            // Se eu precisei de menos caminhoes do que estavam disponiveis, quer  dizer que:
            if(nCaminhoesNecessarios <= caminhoes){
                // - o valor que foi estipulado é uma resposta valida, porém não necessariamente a menor
                resposta = meio;
                // - diminuo o limite superior para diminuir o valor do chute e talvez achar uma resposta valida menor
                limiteSuperior = meio-1;
            }
            // Se eu precisei de mais caminhões do que estavam disponiveis
            else{
                // a unica coisa que posso fazer é aumentar o quanto de carga colocarei em cada um
                // para tentar diminuir o numero de caminhoes necessarios
                limiteInferior = meio+1;
            }
        }
        cout << resposta << " $" << resposta*frete*caminhoes << endl;
    }
}

/****************************************************************************
*                       FELIZ ANIVERSÁRIO!!!                               *
*           MUITA SAÚDE, FELICIDADES, YOGA, ACCEPTEDS,                         *
*       HIDROMEl, SHAVÁSANA, CAFÉS DA MAQUINA E TUDO DE BOM!!!                *
*                                                                           *
*****************************************************************************/