GCD and MST
You are given an array $$$a$$$ of $$$n$$$ ($$$n \geq 2$$$) positive integers and an integer $$$p$$$. Consider an undirected weighted graph of $$$n$$$ vertices numbered from $$$1$$$ to $$$n$$$ for which the edges between the vertices $$$i$$$ and $$$j$$$ ($$$i<j$$$) are added in the following manner:  If $$$gcd(a_i, a_{i+1}, a_{i+2}, \dots, a_{j}) = min(a_i, a_{i+1}, a_{i+2}, \dots, a_j)$$$, then there is an edge of weight $$$min(a_i, a_{i+1}, a_{i+2}, \dots, a_j)$$$ between $$$i$$$ and $$$j$$$.  If $$$i+1=j$$$, then there is an edge of weight $$$p$$$ between $$$i$$$ and $$$j$$$. Here $$$gcd(x, y, \ldots)$$$ denotes the greatest common divisor (GCD) of integers $$$x$$$, $$$y$$$, ....Note that there could be multiple edges between $$$i$$$ and $$$j$$$ if both of the above conditions are true, and if both the conditions fail for $$$i$$$ and $$$j$$$, then there is no edge between these vertices.The goal is to find the weight of the minimum spanning tree of this graph.
Here are the graphs for the four test cases of the example (the edges of a possible MST of the graphs are marked pink):For test case 1  For test case 2  For test case 3  For test case 4  
The first line contains a single integer $$$t$$$ ($$$1 \leq t \leq 10^4$$$) — the number of test cases.The first line of each test case contains two integers $$$n$$$ ($$$2 \leq n \leq 2 \cdot 10^5$$$) and $$$p$$$ ($$$1 \leq p \leq 10^9$$$) — the number of nodes and the parameter $$$p$$$.The second line contains $$$n$$$ integers $$$a_1, a_2, a_3, \dots, a_n$$$ ($$$1 \leq a_i \leq 10^9$$$).It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$2 \cdot 10^5$$$. 
Output $$$t$$$ lines. For each test case print the weight of the corresponding graph.
for _ in range(int(input())):
    (x, y) = list(map(int, input().split()))
    a = list(map(int, input().split()))
    b = [y] * (x - 1)
    node = a[0]
    for i in range(1, x):
        if a[i] % node == 0:
            b[i - 1] = min(node, b[i - 1])
        else:
            node = a[i]
    node = a[x - 1]
    for i in range(x - 2, -1, -1):
        if a[i] % node == 0:
            b[i] = min(node, b[i])
        else:
            node = a[i]
    print(sum(b))
from sys import stdin, stdout
import collections, heapq, bisect, math
input = stdin.readline

def rint():
    return int(input())

def rstr():
    return input().strip()

def rlstr():
    return list(input().strip().split())

def rlint():
    return list(map(int, input().split()))

def main():
    (n, p) = rlint()
    a = rlint()
    b = [p] * (n - 1)
    c = a[0]
    for i in range(1, n):
        if a[i] % c == 0:
            b[i - 1] = min(b[i - 1], c)
        else:
            c = a[i]
    c = a[-1]
    for i in range(n - 2, -1, -1):
        if a[i] % c == 0:
            b[i] = min(b[i], c)
        else:
            c = a[i]
    print(sum(b))
if __name__ == '__main__':
    for _ in range(rint()):
        main()
def solve_test_case():
    (n, x) = map(int, input().split())
    a = list(map(int, input().split()))
    is_connected = [False] * n
    vals = [(a[i], i) for i in range(n)]
    vals.sort()
    ans = 0
    for p in vals:
        (cur_val, i) = p
        if cur_val >= x:
            break
        while i > 0:
            if is_connected[i - 1]:
                break
            if a[i - 1] % cur_val == 0:
                is_connected[i - 1] = True
                ans += cur_val
                i -= 1
            else:
                break
        i = p[1]
        while i < n - 1:
            if is_connected[i]:
                break
            if a[i + 1] % cur_val == 0:
                is_connected[i] = True
                ans += cur_val
                i += 1
            else:
                break
    for i in range(n - 1):
        if not is_connected[i]:
            ans += x
    print(ans)

def main():
    t = int(input())
    for _ in range(t):
        solve_test_case()
if __name__ == '__main__':
    main()