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 Go (1.14.1) (judge verdict: Runtime Error)

package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"strconv"
	"strings"
)

type testCase struct {
	n int
	a int
	b int
	c int
	d int
}

func main() {
	sc := bufio.NewScanner(os.Stdin)
	sc.Scan()
	t, _ := strconv.Atoi(sc.Text())
	tcs := []testCase{}
	for i := 0; i < t; i++ {
		sc.Scan()
		line := strings.Split(sc.Text(), " ")
		n, _ := strconv.Atoi(line[0])
		a, _ := strconv.Atoi(line[1])
		b, _ := strconv.Atoi(line[2])
		c, _ := strconv.Atoi(line[3])
		d, _ := strconv.Atoi(line[4])
		tc := testCase{n, a, b, c, d}
		tcs = append(tcs, tc)
	}
	for _, tc := range tcs {
		ans := solve(tc)
		fmt.Println(ans)
	}
}

func solve(tc testCase) (ans int) {
	size := calcSize(tc.n)
	dp := make([]int, size+1)
	for i := range dp {
		if i == 0 {
			continue
		}
		dp[i] = math.MaxInt64
	}
	for update(tc, dp) {
		fmt.Println(dp)
	}
	return dp[tc.n]
}

func update(tc testCase, dp []int) bool {
	for i := 0; i < len(dp)-1; i++ {
		var cost int
		if (i+1)%2 == 0 {
			cost = dp[(i+1)/2] + tc.a
			if cost < dp[i+1] {
				dp[i+1] = cost
			}
		}
		if (i+1)%3 == 0 {
			cost = dp[(i+1)/3] + tc.b
			if cost < dp[i+1] {
				dp[i+1] = cost
			}
		}
		if (i+1)%5 == 0 {
			cost = dp[(i+1)/5] + tc.c
			if cost < dp[i+1] {
				dp[i+1] = cost
			}
		}
		cost = dp[i] + tc.d
		if cost < dp[i+1] {
			dp[i+1] = cost
		}
	}
	updatedInBackward := false
	for i := len(dp) - 1; i > 0; i-- {
		cost := dp[i] + tc.d
		if cost < dp[i-1] {
			dp[i-1] = cost
			updatedInBackward = true
		}
	}
	return updatedInBackward
}

func calcSize(n int) int {
	div2, div3, div5 := false, false, false
	for i := n; ; i++ {
		if i%2 == 0 {
			div2 = true
		}
		if i%3 == 0 {
			div3 = true
		}
		if i%5 == 0 {
			div5 = true
		}
		if div2 && div3 && div5 {
			return i
		}
	}
}