```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

const INF = 1 << 60
const MAX_K = 60

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	var t int
	fmt.Fscan(in, &t)
	for i := 0; i < t; i++ {
		var n int
		fmt.Fscan(in, &n)
		a := make([]int, n+1)
		for i := 1; i <= n; i++ {
			fmt.Fscan(in, &a[i])
		}
		possible := true
		seenBig := false
		for i := 1; i <= n; i++ {
			if a[i] == 1 {
				if seenBig {
					possible = false
					break
				}
			} else {
				seenBig = true
			}
		}
		if !possible {
			fmt.Fprintln(out, -1)
			continue
		}
		ans := 0
		prevBase := a[1]
		prevK := 0
		if a[1] == 1 {
			prevK = 0
		} else {
			ans = 0
		}
		for i := 2; i <= n; i++ {
			found := false
			minK := INF
			for k := 0; k <= MAX_K; k++ {
				if leq(prevBase, prevK, a[i], k) {
					minK = k
					found = true
					break
				}
			}
			if !found {
				possible = false
				break
			}
			ans += minK
			prevBase = a[i]
			prevK = minK
		}
		if !possible {
			fmt.Fprintln(out, -1)
		} else {
			fmt.Fprintln(out, ans)
		}
	}
	out.Flush()
}

func leq(b, pk, a, qk int) bool {
	if b == 1 {
		return true
	}
	if a == 1 {
		return false
	}
	if pk == qk {
		return b <= a
	} else if pk > qk {
		d := pk - qk
		if d >= 5 {
			return false
		}
		exp := uint(1 << d)
		return powerLeq(uint(b), exp, a)
	} else {
		d := qk - pk
		if d >= 5 {
			return true
		}
		exp := uint(1 << d)
		return leqPower(uint(a), exp, b)
	}
}

func powerLeq(base uint, exp uint, target int) bool {
	var res uint64 = 1
	b := uint64(base)
	t := uint64(target)
	for i := uint(0); i < exp; i++ {
		if b != 0 && res > t/b {
			return false
		}
		res *= b
	}
	return res <= t
}

func leqPower(base uint, exp uint, target int) bool {
	var res uint64 = 1
	b := uint64(base)
	t := uint64(target)
	for i := uint(0); i < exp; i++ {
		if b != 0 && res > t/b {
			return true
		}
		next := res * b
		if b != 0 && (next/b != res || next < res) {
			return true
		}
		res = next
	}
	return t <= res
}
```