#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <math.h>

void parseArray(const char* str, int tires[][2], int* tiresSize) {
    *tiresSize = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']' && *tiresSize < 10) {
        // Find start of tire pair
        while (*p && *p != '[') p++;
        if (*p == '[') p++;
        
        // Parse first number
        tires[*tiresSize][0] = (int)strtol(p, (char**)&p, 10);
        
        // Skip comma
        while (*p && *p != ',') p++;
        if (*p == ',') p++;
        
        // Parse second number
        tires[*tiresSize][1] = (int)strtol(p, (char**)&p, 10);
        
        (*tiresSize)++;
        
        // Skip to end of this tire pair
        while (*p && *p != ']') p++;
        if (*p == ']') p++;
        while (*p && (*p == ',' || *p == ' ')) p++;
    }
}

int solution(int tires[][2], int tiresSize, int changeTime, int numLaps) {
    // Precompute minimum cost for k consecutive laps with any single tire
    // We only need to consider up to around 20 consecutive laps due to exponential growth
    int maxConsecutive = numLaps < 20 ? numLaps : 20;
    int minCost[21];
    for (int i = 0; i <= maxConsecutive; i++) {
        minCost[i] = INT_MAX;
    }
    
    for (int k = 1; k <= maxConsecutive; k++) {
        for (int t = 0; t < tiresSize; t++) {
            int f = tires[t][0];
            int r = tires[t][1];
            int cost = 0;
            int currentLapCost = f;
            for (int lap = 0; lap < k; lap++) {
                cost += currentLapCost;
                currentLapCost *= r;
                // Early termination if cost becomes too large
                if (cost > 1000000) {
                    break;
                }
            }
            if (cost < minCost[k]) {
                minCost[k] = cost;
            }
        }
    }
    
    // DP: dp[i] = minimum time to complete exactly i laps
    int* dp = (int*)malloc((numLaps + 1) * sizeof(int));
    for (int i = 0; i <= numLaps; i++) {
        dp[i] = INT_MAX;
    }
    dp[0] = 0;
    
    for (int i = 0; i < numLaps; i++) {
        if (dp[i] == INT_MAX) {
            continue;
        }
        
        // Try all possible segment lengths from position i
        int maxSegment = maxConsecutive < (numLaps - i) ? maxConsecutive : (numLaps - i);
        for (int segmentLen = 1; segmentLen <= maxSegment; segmentLen++) {
            int nextPos = i + segmentLen;
            
            // Cost = current cost + change cost (if not first segment) + segment cost
            int changeCost = i > 0 ? changeTime : 0;
            int totalCost = dp[i] + changeCost + minCost[segmentLen];
            
            if (totalCost < dp[nextPos]) {
                dp[nextPos] = totalCost;
            }
        }
    }
    
    int result = dp[numLaps];
    free(dp);
    return result;
}

int main() {
    char buffer[1000];
    fgets(buffer, sizeof(buffer), stdin);
    
    int tires[10][2];
    int tiresSize;
    parseArray(buffer, tires, &tiresSize);
    
    int changeTime, numLaps;
    scanf("%d", &changeTime);
    scanf("%d", &numLaps);
    
    int result = solution(tires, tiresSize, changeTime, numLaps);
    printf("%d\n", result);
    
    return 0;
}