Problem:
Score : 400 points

Problem Statement

You start with the number 0 and you want to reach the number N.

You can change the number, paying a certain amount of coins, with the following operations:

Multiply the number by 2, paying A coins.

Multiply the number by 3, paying B coins.

Multiply the number by 5, paying C coins.

Increase or decrease the number by 1, paying D coins.

You can perform these operations in arbitrary order and an arbitrary number of times.

What is the minimum number of coins you need to reach N?

You have to solve T testcases.

Constraints

1 \le T \le 10

1 \le N \le 10^{18}

1 \le A, B, C, D \le 10^9

All numbers N, A, B, C, D are integers.

Input

The input is given from Standard Input. The first line of the input is

T

Then, T lines follow describing the T testcases.
Each of the T lines has the format

N A B C D

Output

For each testcase, print the answer on Standard Output followed by a newline.

Sample Input 1

5
11 1 2 4 8
11 1 2 2 8
32 10 8 5 4
29384293847243 454353412 332423423 934923490 1
900000000000000000 332423423 454353412 934923490 987654321

Sample Output 1

20
19
26
3821859835
23441258666

For the first testcase, a sequence of moves that achieves the minimum cost of 20 is:

Initially x = 0.

Pay 8 to increase by 1 (x = 1).

Pay 1 to multiply by 2 (x = 2).

Pay 1 to multiply by 2 (x = 4).

Pay 2 to multiply by 3 (x = 12).

Pay 8 to decrease by 1 (x = 11).

For the second testcase, a sequence of moves that achieves the minimum cost of 19 is:

Initially x = 0.

Pay 8 to increase by 1 (x = 1).

Pay 1 to multiply by 2 (x = 2).

Pay 2 to multiply by 5 (x = 10).

Pay 8 to increase by 1 (x = 11).

Solution in C++ (GCC 9.2.1) (judge verdict: Wrong Answer)

#include <bits/stdc++.h>

using namespace std;

const int max_x = 200;
const int shift = max_x / 2;
const long long inf = 1000111222000111222LL;
constexpr int val[3] = {2, 3, 5};
constexpr int mx_p[3] = {63, 41, 29};

int t, num[mx_p[0]][mx_p[1]][mx_p[2]];
long long n, a[3], d;
vector<long long> pw[3];
long long dp[11111][max_x];

long long mul(long long x, long long y) {
    if (!x || !y) {
        return 0;
    }
    if (x > inf / y) {
        return inf;
    }
    return x * y;
}

void upd(int i, int x, long long val) {
    if (dp[i][x] == -1) {
        dp[i][x] = val;
    } else {
        dp[i][x] = min(dp[i][x], val);
    }
}

int main() {
    //freopen("input.txt", "r", stdin);
    //freopen("output.txt", "w", stdout);
    for (int i = 0; i < 3; ++i) {
        pw[i].push_back(1);
        while (pw[i].back() < inf) {
            pw[i].push_back(pw[i].back() * val[i]);
        }
        //cout << pw[i].size() << endl;
    }
    vector<int> ids[3];
    vector<long long> vals;
    memset(num, -1, sizeof(num));
    for (int i = 0; i < pw[0].size(); ++i) {
        for (int j = 0; j < pw[1].size(); ++j) {
            for (int k = 0; k < pw[2].size(); ++k) {
                long long val = mul(pw[0][i], mul(pw[1][j], pw[2][k]));
                if (val < inf) {
                    num[i][j][k] = ids[0].size();
                    ids[0].push_back(i);
                    ids[1].push_back(j);
                    ids[2].push_back(k);
                    vals.push_back(val);
                }
            }
        }
    }
    //cout << ids[0].size() << endl;
    cin >> t;
    while (t--) {
        cin >> n >> a[0] >> a[1] >> a[2] >> d;
        memset(dp, -1, sizeof(dp));
        dp[num[0][0][0]][shift] = 0;
        long long ans = inf;
        for (int i = 0; i < ids[0].size(); ++i) {
            for (int x = 0; x + 1 < max_x; ++x) {
                if (dp[i][x] == -1) {
                    continue;
                }
                upd(i, x + 1, dp[i][x] + d);
            }
            for (int x = max_x - 1; x; --x) {
                if (dp[i][x] == -1) {
                    continue;
                }
                upd(i, x - 1, dp[i][x] + d);
            }
            for (int x = 0; x < max_x; ++x) {
                if (dp[i][x] == -1) {
                    continue;
                }
                long long cur = n / vals[i] + x - shift;
                if (cur < 0) {
                    continue;
                }
                ans = min(ans, dp[i][x] + mul(cur, d));
                for (int j = 0; j < 3; ++j) {
                    if (cur % val[j]) {
                        continue;
                    }
                    const int to = num[ids[0][i] + (j == 0)][ids[1][i] + (j == 1)][ids[2][i] + (j == 2)];
                    if (to == -1) {
                        continue;
                    }
                    long long tox = cur / val[j] + shift - n / vals[to];
                    if (0 <= tox && tox < max_x) {
                        upd(to, tox, dp[i][x] + a[j]);
                    }
                }
            }
        }
        cout << ans << endl;
    }
    return 0;
}