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)

use proconio::input;
use std::cmp::*;
use std::collections::BinaryHeap;

#[allow(unused_imports)]
use proconio::marker::{Bytes, Chars};

#[derive(Copy, Clone, Eq, PartialEq, Debug)]
struct State {
    cost: i64,
    n: i64,
    min_div: i64,
}

impl Ord for State {
    fn cmp(&self, other: &State) -> Ordering {
        other.cost.cmp(&self.cost).then(other.n.cmp(&self.n)) // BinaryHeapはmax-heapなので、costは逆方向に比較する
    }
}
impl PartialOrd for State {
    fn partial_cmp(&self, other: &State) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

fn f(n: i64, a: i64, b: i64, c: i64, d: i64) -> i64 {
    let mut q: BinaryHeap<State> = BinaryHeap::new();
    q.push(State {
        n: n,
        cost: 0,
        min_div: 2,
    });
    let mut min_cost = 1000000000i64 * 1000;
    let mut last_n = 0;
    let mut last_cost = 0;

    while let Some(State { n, cost, min_div }) = q.pop() {
        if n == 0 {
            min_cost = cost;
            break;
        }
        if n < 0 {
            continue;
        }
        if n == last_n && cost==last_cost {
            continue;
        }
        last_n = n;
        last_cost = cost;

        //println!("{} {} {}", n, cost, min_div);
        {
            let tmp = cost as i128 + n as i128 * d as i128;
            if tmp < min_cost as i128 {
                min_cost = tmp as i64;
                q.push(State {
                    n: 0,
                    cost: tmp as i64,
                    min_div: 6,
                });   
            }
        }

        let mut ff = |n, cost, div| {
            if n % div == 0 {
                q.push(State {
                    n: n / div,
                    cost: cost + if div==2 {a} else if div==3 {b} else {c},
                    min_div: div,
                })
            }
        };

        if min_div <= 2 {
            ff(n, cost, 2);
        }
        if min_div <= 3 {
            ff(n, cost, 3);
        }
        ff(n, cost, 5);

        ff(n + 1, cost + d, 2);
        ff(n - 1, cost + d, 2);
        ff(n + 1, cost + d, 3);
        ff(n - 1, cost + d, 3);
        ff(n + 1, cost + d, 5);
        ff(n - 1, cost + d, 5);

        ff(n + 2, cost + d * 2, 3);
        ff(n - 2, cost + d * 2, 3);
        ff(n + 2, cost + d * 2, 5);
        ff(n - 2, cost + d * 2, 5);

        ff(n + 3, cost + d * 3, 5);
        ff(n - 3, cost + d * 3, 5);
        
        ff(n + 4, cost + d * 4, 5);
        ff(n - 4, cost + d * 4, 5);
    }
    //while let Some(s) = q.pop() {
    //    println!("{:?}", s);
    //}
    return min_cost;
}

//#[proconio::fastout]
fn main() {
    input! {
        t:usize,
    }
    for _i in 0..t {
        input! {
            n:i64,
            a:i64,
            b:i64,
            c:i64,
            d:i64,
        }
        println!("{}", f(n, a, b, c, d));
    }
}