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 Rust (1.42.0) (judge verdict: Accepted)

#![allow(unused, non_snake_case, dead_code, non_upper_case_globals)]
use {
    proconio::{marker::*, *},
    std::{cmp::*, collections::*, mem::*},
};
macro_rules ! chmin {($ base : expr , $ ($ cmps : expr ) ,+ $ (, ) * ) => {{let cmp_min = min ! ($ ($ cmps ) ,+ ) ; if $ base > cmp_min {$ base = cmp_min ; true } else {false } } } ; }
macro_rules ! chmax {($ base : expr , $ ($ cmps : expr ) ,+ $ (, ) * ) => {{let cmp_max = max ! ($ ($ cmps ) ,+ ) ; if $ base < cmp_max {$ base = cmp_max ; true } else {false } } } ; }
macro_rules ! min {($ a : expr $ (, ) * ) => {{$ a } } ; ($ a : expr , $ b : expr $ (, ) * ) => {{std :: cmp :: min ($ a , $ b ) } } ; ($ a : expr , $ ($ rest : expr ) ,+ $ (, ) * ) => {{std :: cmp :: min ($ a , min ! ($ ($ rest ) ,+ ) ) } } ; }
macro_rules ! max {($ a : expr $ (, ) * ) => {{$ a } } ; ($ a : expr , $ b : expr $ (, ) * ) => {{std :: cmp :: max ($ a , $ b ) } } ; ($ a : expr , $ ($ rest : expr ) ,+ $ (, ) * ) => {{std :: cmp :: max ($ a , max ! ($ ($ rest ) ,+ ) ) } } ; }
fn main() {
    input! {//
        t:usize,
        mut nabcd:[(i128,i128,i128,i128,i128);t]
    }
    for &(n, a, b, c, d) in nabcd.iter() {
        let mut g = G {
            n: n,
            a: a,
            b: b,
            c: c,
            d: d,
            dp: HashMap::new(),
        };
        println!("{}", g.solve(n));
    }
}
struct G {
    n: i128,
    a: i128,
    b: i128,
    c: i128,
    d: i128,
    dp: HashMap<i128, i128>,
}
impl G {
    fn solve(&mut self, n: i128) -> i128 {
        if n == 1 {
            return self.d;
        }
        if n == 0 {
            // return 0;
            return INF;
        }
        let dp = *self.dp.entry(n).or_insert(0);
        if dp > 0 {
            return dp;
        }
        let mut ret = n * self.d;
        ret = min(
            ret,
            self.solve(n / 2) + self.a + (n - (n / 2 * 2)) * (self.d),
        );
        ret = min(
            ret,
            self.solve((n + 1) / 2) + self.a + ((n + 1) / 2 * 2 - n) * (self.d),
        );
        ret = min(ret, self.solve(n / 3) + self.b + (n - (n / 3 * 3)) * self.d);
        ret = min(
            ret,
            self.solve((n + 2) / 3) + self.b + ((n + 2) / 3 * 3 - n) * self.d,
        );
        ret = min(ret, self.solve(n / 5) + self.c + (n - n / 5 * 5) * self.d);
        ret = min(
            ret,
            self.solve((n + 4) / 5) + self.c + ((n + 4) / 5 * 5 - n) * self.d,
        );
        *self.dp.entry(n).or_insert(0) = ret;
        ret
    }
}
// fn rec(n:i128,a:i128,b:i128,c:i128,d:i128)
const INF: i128 = 1 << 120;