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# (Mono-mcs 6.8.0.105) (judge verdict: Runtime Error)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


    class Program
    {
        static void Main(string[] args)
        {
            int T = int.Parse(Console.ReadLine());
            
            for(int i = 0; i < T; i++){
            

            long count;
            
            count = Chase();
            
            Console.WriteLine(count);
            }
        }
        
        static long Chase(){
            string[] Input = Console.ReadLine().Split(' ');
            long[] list = new long[long.Parse(Input[0]) + 2];
            list[1] = long.Parse(Input[4]);
            long N = 1;
            
            while(N <= long.Parse(Input[0]) + 1){
                for(int i = 0; i < 5; i++){
                    if(i == 0){
                        if(long.Parse(Input[0]) + 1 >= N * 2){
                            if(list[N * 2]  > list[N] + long.Parse(Input[i + 1]) || list[N * 2] == 0)
                            {
                            list[N * 2]  = list[N] + long.Parse(Input[i + 1]);
                            }
                        }
                    }else if(i == 1){
                        if(long.Parse(Input[0]) + 1 >= N * 3){
                            if(list[N * 3]  > list[N] + long.Parse(Input[i + 1]) || list[N * 3] == 0)
                            {
                             list[N * 3]  = list[N] + long.Parse(Input[i + 1]);
                            }
                        }
                    }else if(i == 2){
                        if(long.Parse(Input[0]) + 1 >= N * 5){
                            if(list[N * 5]  > list[N] + long.Parse(Input[i + 1]) || list[N * 5] == 0)
                            {
                            list[N * 5]  = list[N] + long.Parse(Input[i + 1]);
                            }
                        }
                    }else if(i == 3){
                        if(long.Parse(Input[0]) + 1 >= N + 1){
                            if(list[N + 1] > list[N] + long.Parse(Input[i + 1]) || list[N + 1] == 0)
                            {
                            list[N + 1] = list[N] + long.Parse(Input[i + 1]);
                            }
                        }
                    }else if(i == 4){
                        if(long.Parse(Input[0]) + 1 >= N - 1){
                            if(list[N - 1] > list[N] + long.Parse(Input[i]) || list[N - 1] == 0)
                            {
                            list[N - 1] = list[N] + long.Parse(Input[i]);
                            }
                        }
                    }
                }
                N++;
            }
            return list[long.Parse(Input[0])];
        }
    }