#include <iostream>
#include <unordered_map>
#include <map>
#include <vector>
#include <set>
#include <unordered_set>

int answer = std::numeric_limits<int>::max();
int n;

int s1, s2, d1, d2;

template <class T>
void update(T& dp, int processed, int time1, int time2) {
    if (time1 >= answer || time2 >= answer) {
        return;
    }
    if (processed == n) {
        answer = std::max(time1, time2);
        return;
    }
    std::set<std::pair<int, int>>::iterator it = dp[processed].lower_bound({time1, 0});

    auto it1 = it;
    for (int i = 0; i < 3 && it1 != dp[processed].end(); ++it1, ++i) {
        if (it1->first <= time1 && it1->second <= time2) {
            return;
        }
    }
    auto it2 = std::make_reverse_iterator(it);
    for (int i = 0; i < 3 && it2 != dp[processed].rend(); ++it2, ++i) {
        if (it2->first <= time1 && it2->second <= time2) {
            return;
        }
    }



    dp[processed].emplace(time1, time2);
}

int main() {
    std::cin >> s1 >> s2 >> d1 >> d2 >> n;
    std::vector<int> h(n + 10);
    for (int i = 1; i <= n; ++i) {
        h[i] = (i % 50) +1;
        //std::cin >> h[i];
    }

    std::vector<std::set<std::pair<int, int>>> dp(n + 1);
    dp[0].emplace(0,0);

    for (int i = 0; i < n; ++i) {
        //std::cout << "i=" << i << " : " << dp[i].size() << std::endl;
        for (const auto p : dp[i]) {
            int height = 0;
            for (int processed = i + 1; processed <= n; ++processed) {
                height += h[processed];
                if (height > d1 && height > d2) {
                    break;
                }
                int nextTook = std::max(p.second, p.first);
                bool hasNext = processed != n;
                if (height <= d1) {
                    int nextTime = p.first + s1 * (height + h[processed + 1]);
                    if (!hasNext || nextTime > nextTook) {
                        update(dp, processed, p.first + s1 * height, nextTook);
                    }
                }
                if (height <= d2) {
                    int nextTime = p.second + s2 * (height + h[processed + 1]);
                    if (!hasNext || nextTime > nextTook) {
                        update(dp, processed, nextTook, p.second + s2 * height);
                    }
                }
            }
        }
    }

    std::cout << answer << std::endl;
}