private static int[] memo;

public static int unboundedKnapsack(int sum, List<int> arr, bool resetMemo = true)
{
    if (resetMemo) memo = new int[sum + 1];

    if (sum == 0 || arr.Count == 0) return 0;

    if (memo[sum] > 0) return memo[sum];

    var maxSum = 0;
    for (var i = 0; i < arr.Count; i++)
    {
        if (arr[i] <= sum)
        {
            maxSum = Math.Max(maxSum, arr[i] + unboundedKnapsack(sum - arr[i], arr, false));
        }
    }

    memo[sum] = Math.Max(maxSum, memo[sum]);
    return maxSum;
}

if __name__ == '__main__':
    fptr = open(os.environ['OUTPUT_PATH'], 'w')

    t = int(input().strip())

    for _ in range(0, t):
        first_multiple_input = input().rstrip().split()

        n = int(first_multiple_input[0])

        k = int(first_multiple_input[1])

        arr = list(map(int, input().rstrip().split()))
    
        result = unboundedKnapsack(k, arr)

        fptr.write(str(result) + '\n')

    fptr.close()

def unboundedKnapsack(k, arr):
    # progressively get responses (DP)
    # k 0 1 2 3 4 5 6
    # 0 0 0 0 0 0 0 0 
    # 2 0 0 2 2 4 4 6    dp[i][j] = max(dp[i-1][j], dp[i][j-i]+i)
    # 3 0 0 2 3 4 5 6    (choosing between not adding anything and
    # 4 0 0 2 3 4 5 6     adding the current N's value to the Nth
    #                     value behind)
    
    # stop searching if k is found. If not, return largest.
    
    # Creating dp table
    dp = [[0 for _ in range(0, k+1)] for _ in range(0, len(arr)+1)]
    options = [0] + arr
    num_ints = len(arr)
    max_val = 0

    for i in range(1, num_ints+1):
        for j in range(1, k+1):
            if j < options[i]:
                # is the current k less than the value of the line?
                dp[i][j] = dp[i-1][j]
            else:
                dp[i][j] = max(dp[i-1][j], dp[i][j-options[i]]+options[i])
            if dp[i][j] == k:
                # found k in DP table
                return k
            max_val = max(max_val, dp[i][j])
            j += 1
        i += 1
        
    # k is not on DP table, so returning max value found
    return max_val

int cumulative_sum(int* arr , int arr_count ,int  k ,int index , int sum)
{
    if(index == arr_count)
    {
        return sum;
    }
    else if( k%arr[index] == 0)
    {
        return k;
    }
    int max_sum = 0 , temp = 0 , count = 0 ,  i = 0;
    while (sum <= k) {
        sum += arr[index];
        count++;
    }
    sum -= arr[index];
    max_sum = sum;
    
    for (i = 0 ; i< count ; i++) {
        temp = cumulative_sum(arr , arr_count , k , index+1 , sum);
        if(temp == k)
        {
            return k;
        }
        else if(temp > max_sum)
        {
            max_sum = temp;
        }
        sum -= arr[index];
    }
    
    return max_sum;
}

/*
 * Complete the 'unboundedKnapsack' function below.
 *
 * The function is expected to return an INTEGER.
 * The function accepts following parameters:
 *  1. INTEGER k
 *  2. INTEGER_ARRAY arr
 */

int unboundedKnapsack(int k, int arr_count, int* arr) {

    return cumulative_sum(arr,arr_count,k,0,0);

}