#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;
        //static int cnt = 0;
        //std::cout << "fail: " << ++cnt << std::endl;
    }
    std::set<std::pair<int, int>>::iterator it = dp[processed].lower_bound({time1, 0});
    /*if (it != dp[processed].end() && it->first == time1) {
        if (it->second > time2) {
            dp[processed].erase(it);
            dp[processed].emplace(time1, time2);
        }
        return;
    }*/
    auto it1 = it;
    for (int i = 0; i < 10 && 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 < 10 && it2 != dp[processed].rend(); ++it2, ++i) {
        if (it2->first <= time1 && it2->second <= time2) {
            return;
        }
    }
    /*for (auto p : dp[processed]) {
        if (p.first <= time1 && p.second <= time2) {
            return;
        }
    }*/


    dp[processed].emplace(time1, time2);
    if (processed == n) {
        answer = std::min(answer, std::max(time1, time2));
    }
}

int main() {
    int s = 0;
    for (int i = 1; i <= 5000; ++i) {
        s += (5000/ i) * i;
    }
    std::cout << s << std::endl;
    std::cin >> s1 >> s2 >> d1 >> d2 >> n;
    std::vector<int> h(n + 1);
    int hsum = 0;
    for (int i = 1; i <= n; ++i) {
        //std::cin >> h[i];
        h[i] = i;
        hsum += h[i];
    }
    std::cout << "~ans = " << std::min(s1,s2) * hsum << std::endl;

    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);
                if (height <= d1) {
                    update(dp, processed, p.first + s1 * height, nextTook);
                }
                if (height <= d2) {
                    update(dp, processed, nextTook, p.second + s2 * height);
                }
            }
        }
    }

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