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<iostream>
#include<map>
#include<cassert>
int64_t n,a,b,c,d;
std::map<int64_t,int64_t> memo;

int64_t dfs(int64_t n){
  if(memo.count(n)){
    return memo[n];
  }
  int64_t tmp = (1LL<<58);
  if(n%2==0)tmp = std::min(tmp,dfs(n/2)+a);
  else{
    tmp = std::min(tmp,dfs((n+1)/2)+a+d);
    tmp = std::min(tmp,dfs((n-1)/2)+a+d);
  }
  if(n%3==0)tmp = std::min(tmp,dfs(n/3)+b);
  else{
    int64_t low3 = n/3*3;
    int64_t high3 = (n/3+1)*3;
    assert(low3<n&&n<high3);
    tmp = std::min(tmp,dfs(low3/3)+b+d*(n-low3));
    tmp = std::min(tmp,dfs(high3/3)+b+d*(high3-n));
  }
  if(n%5==0)tmp = std::min(tmp,dfs(n/5)+c);
  else{
    int64_t low5 = n/5*5;
    int64_t high5 = (n/5+1)*5;
    assert(low5<n && n<high5);
    tmp = std::min(tmp,dfs(low5/5)+c+d*(n-low5));
    tmp = std::min(tmp,dfs(high5/5)+c+d*(high5-n));
  }
  return memo[n] = tmp;
}

void solve(){
  std::cin>>n>>a>>b>>c>>d;
  memo.clear();
  memo[0] = 0;
  memo[1] = d;
  dfs(n);
  std::cout<< memo[n] <<std::endl;
}

int main(){
  int t;
  std::cin>>t;
  while(t--)solve();
}