using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CompLib.Collections;
using CompLib.Util;

public class Program
{

    public void Solve()
    {
        var sc = new Scanner();
        int t = sc.NextInt();
        var sb = new StringBuilder();
        for (int i = 0; i < t; i++)
        {
            sb.AppendLine(Q(sc.NextLong(), sc.NextInt(), sc.NextInt(), sc.NextInt(), sc.NextInt()));
        }
        Console.Write(sb);
    }

    // オーバーフローしないなら正しい値を するなら Inf
    long Mul(long x, long y)
    {
        long d = long.MaxValue / x;
        return y > d ? long.MaxValue : x * y;
    }

    string Q(long n, long a, long b, long c, long d)
    {
        var map = new Dictionary<long, long>();
        var pq = new PriorityQueue<Pair>((l, r) => l.Coin.CompareTo(r.Coin));
        pq.Enqueue(new Pair(n, 0));
        map[n] = 0;
        while (pq.Count > 0)
        {

            var pop = pq.Dequeue();
            // Console.WriteLine($"{pop.N} {pop.Coin}");
            if (pop.N == 0)
            {
                return pop.Coin.ToString();
            }
            long o;
            // 5
            {
                long m = pop.N % 5;
                {
                    long nn = pop.N / 5;
                    long nc = pop.Coin + Math.Min(d * m + c, Mul(d, pop.N - nn));
                    if (!map.TryGetValue(nn, out o) || o > nc)
                    {
                        map[nn] = nc;
                        pq.Enqueue(new Pair(nn, nc));
                    }
                }

                {
                    long nn = pop.N / 5 + 1;
                    long nc = pop.Coin + Math.Min(d * (5 - m) + c, Mul(d, pop.N - nn));
                    if (!map.TryGetValue(nn, out o) || o > nc)
                    {
                        map[nn] = nc;
                        pq.Enqueue(new Pair(nn, nc));
                    }
                }
            }

            // 3
            {
                long m = pop.N % 3;
                {
                    long nn = pop.N / 3;
                    long nc = pop.Coin + Math.Min(d * m + b, Mul(d, pop.N - nn));
                    if (!map.TryGetValue(nn, out o) || o > nc)
                    {
                        map[nn] = nc;
                        pq.Enqueue(new Pair(nn, nc));
                    }
                }

                {
                    long nn = pop.N / 3 + 1;
                    long nc = pop.Coin + Math.Min(d * (3 - m) + b, Mul(d, pop.N - nn));
                    if (!map.TryGetValue(nn, out o) || o > nc)
                    {
                        map[nn] = nc;
                        pq.Enqueue(new Pair(nn, nc));
                    }
                }
            }

            // 2
            {
                long m = pop.N % 2;
                {
                    long nn = pop.N / 2;
                    long nc = pop.Coin + Math.Min(d * m + a, Mul(d, pop.N - nn));
                    if (!map.TryGetValue(nn, out o) || o > nc)
                    {
                        map[nn] = nc;
                        pq.Enqueue(new Pair(nn, nc));
                    }
                }

                {
                    long nn = pop.N / 2 + 1;
                    long nc = pop.Coin + Math.Min(d * (2 - m) + a, Mul(d, pop.N - nn));
                    if (!map.TryGetValue(nn, out o) || o > nc)
                    {
                        map[nn] = nc;
                        pq.Enqueue(new Pair(nn, nc));
                    }
                }
            }
        }

        return "-1";
    }



    public static void Main(string[] args) => new Program().Solve();
}

struct Pair
{
    // 持ってる数、
    public long N, Coin;
    public Pair(long n, long c)
    {
        N = n;
        Coin = c;
    }
}

// https://bitbucket.org/camypaper/complib
namespace CompLib.Collections
{
    using System;
    using System.Collections.Generic;

    #region PriorityQueue

    /// <summary>
    /// 指定した型のインスタンスを最も価値が低い順に取り出すことが可能な可変サイズのコレクションを表します．
    /// </summary>
    /// <typeparam name="T">優先度付きキュー内の要素の型を指定します．</typeparam>
    /// <remarks>内部的にはバイナリヒープによって実装されています．</remarks>
    public class PriorityQueue<T>
    {
        readonly List<T> heap = new List<T>();
        readonly Comparison<T> cmp;

        /// <summary>
        /// デフォルトの比較子を使用してインスタンスを初期化します．
        /// </summary>
        /// <remarks>この操作は O(1) で実行されます．</remarks>
        public PriorityQueue()
        {
            cmp = Comparer<T>.Default.Compare;
        }

        /// <summary>
        /// デリゲートで表されるような比較関数を使用してインスタンスを初期化します．
        /// </summary>
        /// <param name="comparison"></param>
        /// <remarks>この操作は O(1) で実行されます．</remarks>
        public PriorityQueue(Comparison<T> comparison)
        {
            cmp = comparison;
        }

        /// <summary>
        /// 指定された比較子を使用してインスタンスを初期化します．
        /// </summary>
        /// <param name="comparer"></param>
        /// <remarks>この操作は O(1) で実行されます．</remarks>
        public PriorityQueue(IComparer<T> comparer)
        {
            cmp = comparer.Compare;
        }

        /// <summary>
        /// 優先度付きキューに要素を追加します．
        /// </summary>
        /// <param name="item">優先度付きキューに追加される要素</param>
        /// <remarks>最悪計算量 O(log N) で実行されます．</remarks>
        public void Enqueue(T item)
        {
            var pos = heap.Count;
            heap.Add(item);
            while (pos > 0)
            {
                var par = (pos - 1) / 2;
                if (cmp(heap[par], item) <= 0)
                    break;
                heap[pos] = heap[par];
                pos = par;
            }

            heap[pos] = item;
        }

        /// <summary>
        /// 優先度付きキューから最も価値が低い要素を削除し，返します．
        /// </summary>
        /// <returns>優先度付きキューから削除された要素．</returns>
        /// <remarks>最悪計算量 O(log N) で実行されます．</remarks>
        public T Dequeue()
        {
            var ret = heap[0];
            var pos = 0;
            var x = heap[heap.Count - 1];

            while (pos * 2 + 1 < heap.Count - 1)
            {
                var lch = pos * 2 + 1;
                var rch = pos * 2 + 2;
                if (rch < heap.Count - 1 && cmp(heap[rch], heap[lch]) < 0) lch = rch;
                if (cmp(heap[lch], x) >= 0)
                    break;
                heap[pos] = heap[lch];
                pos = lch;
            }

            heap[pos] = x;
            heap.RemoveAt(heap.Count - 1);
            return ret;
        }

        /// <summary>
        ///  優先度付きキューに含まれる最も価値が低い要素を削除せずに返します．
        /// </summary>
        /// <returns>優先度付きキューに含まれる最も価値が低い要素．</returns>
        /// <remarks>この操作は O(1) で実行されます．</remarks>
        public T Peek()
        {
            return heap[0];
        }

        /// <summary>
        /// 優先度付きキュー内の要素の数を取得します．
        /// </summary>
        /// <returns>優先度付キュー内にある要素の数</returns>
        /// <remarks>最悪計算量 O(1) で実行されます．</remarks>
        public int Count
        {
            get { return heap.Count; }
        }

        /// <summary>
        /// 優先度付きキュー内に要素が存在するかどうかを O(1) で判定します．
        /// </summary>
        /// <returns>優先度付キュー内にある要素が存在するならば true，そうでなければ　false．</returns>
        /// <remarks>この操作は O(1) で実行されます．</remarks>
        public bool Any()
        {
            return heap.Count > 0;
        }

        /// <summary>
        /// 優先度付きキューに含まれる要素を昇順に並べて返します．
        /// </summary>
        /// <remarks>この操作は計算量 O(N log N)で実行されます．</remarks>
        public T[] Items
        {
            get
            {
                var ret = heap.ToArray();
                Array.Sort(ret, cmp);
                return ret;
            }
        }
    }

    #endregion
}

namespace CompLib.Util
{
    using System;
    using System.Linq;

    class Scanner
    {
        private string[] _line;
        private int _index;
        private const char Separator = ' ';

        public Scanner()
        {
            _line = new string[0];
            _index = 0;
        }

        public string Next()
        {
            while (_index >= _line.Length)
            {
                _line = Console.ReadLine().Split(Separator);
                _index = 0;
            }

            return _line[_index++];
        }

        public int NextInt() => int.Parse(Next());
        public long NextLong() => long.Parse(Next());
        public double NextDouble() => double.Parse(Next());
        public decimal NextDecimal() => decimal.Parse(Next());
        public char NextChar() => Next()[0];
        public char[] NextCharArray() => Next().ToCharArray();

        public string[] Array()
        {
            _line = Console.ReadLine().Split(Separator);
            _index = _line.Length;
            return _line;
        }

        public int[] IntArray() => Array().Select(int.Parse).ToArray();
        public long[] LongArray() => Array().Select(long.Parse).ToArray();
        public double[] DoubleArray() => Array().Select(double.Parse).ToArray();
        public decimal[] DecimalArray() => Array().Select(decimal.Parse).ToArray();
    }
}


Measured memory_bytes: 31600