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# (.NET Core 3.1.201) (judge verdict: Wrong Answer)

using System;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Linq;
using System.Collections.Generic;
using System.Text.RegularExpressions;

class Program
{
    const string Yes = "Yes";
    const string No = "No";
    const char White = '.';
    const char Black = '#';
    const long Mod = 1000000007;

    static void Main(string[] args) {
#if DEBUG
        MyDebugger.Test(process, "../TextFile1.txt");
#else
        object ret = process(new StreamReader(Console.OpenStandardInput()));
        Console.WriteLine(ret);
#endif
    }

    static object process(TextReader input) {
        var t = int.Parse(input.ReadLine());

        var sb = new StringBuilder();
        for(int i=0; i<t; i++) {
            var spl = input.ReadLine().Split(' ');
            var n = long.Parse(spl[0]);
            var a = long.Parse(spl[1]);
            var b = long.Parse(spl[2]);
            var c = long.Parse(spl[3]);
            var d = long.Parse(spl[4]);

            var r = test(n, a, b, c, d);
            //sb.AppendLine(r.ToString());

            Debug.WriteLine(r.ToString());
            //Debug.WriteLine("");
        }

        return sb;
    }

    static long test(long n, long a, long b, long c, long d) {
        long min = long.MaxValue;

        Func<long, long, long, long, long> f = (ac, bc, cc, dc) => {
            long ret = ac*a + bc*b + cc*c + dc*d;
            //Debug.WriteLine($"{ac} {bc} {cc} {dc} : {ret}");

            //if(ac == 2 && bc == 1) {
            //    var zzzz = 0;
            //}
            return ret;
        };

        minmin = long.MaxValue;
        mins = new Dictionary<long, long>();
        search(0, n, a, b, c, d);
        for(int i=-100; i<=100; i++) {
            search(d * Math.Abs(i), n+i, a, b, c, d);
        }

        return minmin;
    }

    static long minmin;
    static Dictionary<long, long> mins;

    static void search(long co, long n, long a, long b, long c, long d) {
        if(n == 1) {
            co += n * d;
            minmin = Math.Min(minmin, co);
            //Debug.WriteLine($"{co}");
            return;
        }

        if(minmin <= co) {
            return;
        }

        if(n<1000000000)
        minmin = Math.Min(minmin, co + n * d);

        if (mins.ContainsKey(n) && mins[n] <= co) {
            return;
        }

        if(!mins.ContainsKey(n) || mins[n] > co) {
            mins[n] = co;
        }

        if (n / 2 != 0) {
            search(co + a + d * (n % 2), n / 2, a, b, c, d);
        }
        if (n / 3 != 0) {
            search(co + b + d * (n % 3), n / 3, a, b, c, d);
        }
        if (n / 5 != 0) {
            search(co + c + d * (n % 5), n / 5, a, b, c, d);
        }

        n++;
        co += d;
        if (n / 2 != 0) {
            search(co + a + d * (n % 2), n / 2, a, b, c, d);
        }
        if (n / 3 != 0) {
            search(co + b + d * (n % 3), n / 3, a, b, c, d);
        }
        if (n / 5 != 0) {
            search(co + c + d * (n % 5), n / 5, a, b, c, d);
        }

        n-=2;
        if (n / 2 != 0) {
            search(co + a + d * (n % 2), n / 2, a, b, c, d);
        }
        if (n / 3 != 0) {
            search(co + b + d * (n % 3), n / 3, a, b, c, d);
        }
        if (n / 5 != 0) {
            search(co + c + d * (n % 5), n / 5, a, b, c, d);
        }
    }

    //static long Pow(long x, long n) {
    //    long bx = x;
    //    long bn = n;

    //    long ans = 1;
    //    while (n > 0) {
    //        if (n % 2 == 1) {
    //            ans = ans * x;
    //        }
    //        x = x * x;
    //        n /= 2;
    //    }
    //    return ans;
    //}

    static long Pow(long x, long n) {
        return (long)Math.Pow(x, n);
    }

    static int[] ToIntArray(string strs, int n) {
        var ret = new int[n];
        var spl = strs.Split(' ');
        for (int i = 0; i < n; i++)
            ret[i] = int.Parse(spl[i]);
        return ret;
    }
}