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: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using static System.Console;
using static System.Math;

namespace AtTest.AGC_044
{
    class A
    {
        static void Main(string[] args)
        {
            var sw = new System.IO.StreamWriter(OpenStandardOutput()) { AutoFlush = false };
            SetOut(sw);

            Method(args);

            Out.Flush();
        }

        static void Method(string[] args)
        {
            int t = ReadInt();
            for(int i = 0; i < t; i++)
            {
                long[] nabcd = ReadLongs();
                long n = nabcd[0];
                long a = nabcd[1];
                long b = nabcd[2];
                long c = nabcd[3];
                long d = nabcd[4];

                var dict = new Dictionary<long, long>();
                var que = new Queue<long[]>();
                que.Enqueue(new long[2] { n, 0 });
                while (que.Count > 0)
                {
                    long[] val = que.Dequeue();
                    long now = val[0];
                    long cnt = val[1];
                    if (dict.ContainsKey(now) && dict[now] <= cnt)
                    {
                        continue;
                    }

                    if (dict.ContainsKey(now))
                    {
                        dict[now] = cnt;
                    }
                    else
                    {
                        dict.Add(now, cnt);
                    }

                    if (now == 0)
                    {
                        continue;
                    }

                    if (now >= 2)
                    {
                        que.Enqueue(new long[2] { now / 2, cnt + a + (now % 2) * d });
                        que.Enqueue(new long[2] { now / 2 + 1, cnt + a + (2 - now % 2) * d });
                    }
                    if (now >= 3)
                    {
                        que.Enqueue(new long[2] { now / 3, cnt + b + (now % 3) * d });
                        que.Enqueue(new long[2] { now / 3 + 1, cnt + b + (3 - now % 3) * d });
                    }
                    if (now >= 5)
                    {
                        que.Enqueue(new long[2] { now / 5, cnt + c + (now % 5) * d });
                        que.Enqueue(new long[2] { now / 5 + 1, cnt + c + (5 - now % 5) * d });
                    }
                    if ((double)now * d < long.MaxValue)
                    {
                        que.Enqueue(new long[2] { 0, cnt + now * d });
                    }
                }

                WriteLine(dict[0]);
            }
        }

        private static string Read() { return ReadLine(); }
        private static char[] ReadChars() { return Array.ConvertAll(Read().Split(), a => a[0]); }
        private static int ReadInt() { return int.Parse(Read()); }
        private static long ReadLong() { return long.Parse(Read()); }
        private static double ReadDouble() { return double.Parse(Read()); }
        private static int[] ReadInts() { return Array.ConvertAll(Read().Split(), int.Parse); }
        private static long[] ReadLongs() { return Array.ConvertAll(Read().Split(), long.Parse); }
        private static double[] ReadDoubles() { return Array.ConvertAll(Read().Split(), double.Parse); }
    }
}