#include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <vector>
#include <climits>

using namespace std;

int main() {
    // Mở file input/output
    // freopen("bwater.inp", "r", stdin);
    // freopen("bwater.out", "w", stdout);

    long long Q, H, S, D, N;
    cin >> Q >> H >> S >> D >> N;

    // 1. Chuẩn hóa giá về đơn vị 0.25 lít (Q là đơn vị cơ sở)
    // Q đã là giá cho 0.25 lít
    H = min(H, 2 * Q); // Nếu mua 2 bình Q rẻ hơn H, coi như H có giá 2Q
    S = min(S, 2 * H); // So sánh với 2 H
    S = min(S, 4 * Q); // So sánh với 4 Q
    D = min(D, 2 * S); // So sánh với 2 S
    D = min(D, 4 * H); // So sánh với 4 H

    long long dp[3]; // Quy hoạch động cho 0, 1, 2 lít
    dp[0] = 0;

    // Tính giá tối ưu cho 1 lít (đơn vị 0.25 lít * 4)
    // Có thể dùng S hoặc 4 Q hoặc 2 H
    dp[1] = min({(long long)4 * Q, (long long)2 * H, S});

    // Tính giá tối ưu cho 2 lít
    // Có thể dùng D hoặc 2 * dp[1]
    dp[2] = min(D, 2 * dp[1]);

    long long cost = 0;
    // Lấy số bình 2 lít cần mua
    long long bottles_2L = N / 2;
    cost += bottles_2L * dp[2];
    N %= 2;

    // Nếu còn dư 1 lít
    if (N > 0) {
        cost += dp[1];
    }

    cout << cost << endl;
    return 0;
}

#include <iostream>
#include <algorithm>
#include <climits>

using namespace std;

int main() {
    long long Q, H, S, D, N;
    cin >> Q >> H >> S >> D >> N;

    // Bước 1: Tối ưu hóa giá
    // Đảm bảo mua bình lớn không bao giờ đắt hơn mua bình nhỏ tương đương
    H = min(H, 2 * Q);
    S = min(S, 4 * Q);
    S = min(S, 2 * H);
    D = min(D, 2 * S);
    D = min(D, 4 * H);

    // Bước 2: Tính toán chi phí
    long long ans = 0;

    // Mua bình 2 lít (D) cho phần chia hết cho 2
    // Logic: Nếu D < 2*S, ta dùng D. Ngược lại dùng 2*S.
    // Công thức: ans += (N/2) * D + (N%2) * S
    // Tuy nhiên, ta phải so sánh D với giá 2 lít (2*S).
    // Nhưng D đã được chuẩn hóa là min(D, 2*S).

    long long cost_2L = D;
    long long cost_1L = S;
    // cost_0_5L = H;
    // cost_0_25L = Q;

    ans += (N / 2) * cost_2L;
    ans += (N % 2) * cost_1L;

    cout << ans;
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    long long Q, H, S, D, N;
    cin >> Q >> H >> S >> D >> N;

    // Chuẩn hóa
    H = min(H, 2 * Q);
    S = min(S, 2 * H);
    S = min(S, 4 * Q);
    D = min(D, 2 * S);
    D = min(D, 4 * H);

    long long ans = -1;

    // Thử các số lượng bình 2 lít từ 0 đến N/2 + 1
    // Số bình 2 lít tối đa là ceil(N/2)
    long long max_bottles_D = N / 2 + 1;

    for (long long i = 0; i <= max_bottles_D; ++i) {
        long long current_liters = i * 2;
        long long cost = i * D;

        long long remaining = N - current_liters;

        if (remaining <= 0) {
            // Mua thừa: chỉ cần tính giá D
            if (ans == -1 || cost < ans) ans = cost;
        } else {
            // Mua thêm bình 1 lít (S)
            // Hoặc có thể dùng 2 H hoặc 4 Q, nhưng đã chuẩn hóa S là rẻ nhất cho 1 lít
            long long cost_1L = S;
            long long cost_0_5L = H;
            long long cost_0_25L = Q;

            // Logic mua lẻ:
            // Nếu cần 1 lít -> S
            // Nếu cần 0.5 lít -> H
            // Nếu cần 0.25 lít -> Q
            // Vòng lặp này chỉ cần quan tâm đến phần lẻ sau khi mua D.
            // Phần lẻ này chỉ có thể là 0, 0.5, 1, 1.5 lít.
            // Nhưng N là số nguyên (lít).
            // Nếu N là số nguyên, phần lẻ sau khi trừ bình 2 lít là 0 hoặc 1 lít.
            // Do đó chỉ cần dùng S cho phần lẻ.

            cost += (remaining % 2 == 0) ? (remaining / 2) * D : ((remaining / 2) * D) + S;
            // Đoạn trên sai logic một chút nếu dùng D cho phần lẻ. 
            // Phần lẻ là remaining. Nếu remaining là 1, dùng S.
            // Nếu remaining là 3, dùng 1 D và 1 S.
            // Công thức đúng là: cost += (remaining / 2) * D + (remaining % 2) * S.

            // Tối ưu hóa vòng lặp: Thay vì lặp, ta chỉ cần so sánh 2 trường hợp:
            // 1. Mua đủ D rồi cộng S
            // 2. Mua ít D hơn 1 đơn vị (tức là mua D-1) rồi cộng thêm phần còn lại.
        }
    }

    // Thực ra với N nguyên, ta chỉ cần so sánh:
    // Case 1: Mua N/2 bình D + (N%2)*S
    // Case 2: Mua (N/2 - 1) bình D + (N%2 + 2)*S (nếu N/2 >= 1)
    // Case 3: Mua 0 bình D + N*S
    // Nhưng do đã chuẩn hóa D <= 2*S, nên Case 1 luôn tối ưu.

    // Code dưới đây là minh họa cho việc thử các số lượng D (thực sự không cần thiết nếu đã chuẩn hóa):
    // Tuy nhiên, nếu N là số thực (ví dụ 1.5 lít), thì cần lặp. Problem cho N là lít, giả định số nguyên.

    // Vì N là số nguyên (lít), ta chỉ cần:
    ans = (N / 2) * D + (N % 2) * S;
    cout << ans;
    return 0;
}