from math import inf, gcd

#https://github.com/cheran-senthil/PyRival/blob/master/pyrival/algebra/modinv.py

def extended_gcd(a, b):
    """returns gcd(a, b), s, r s.t. a * s + b * r == gcd(a, b)"""
    s, old_s = 0, 1
    r, old_r = b, a
    while r:
        q = old_r // r
        old_r, r = r, old_r - q * r
        old_s, s = s, old_s - q * s
    return old_r, old_s, (old_r - old_s * a) // b if b else 0


def modinv(a, m):
    """returns the modular inverse of a w.r.t. to m, works when a and m are coprime"""
    g, x, _ = extended_gcd(a % m, m)
    return x % m if g == 1 else None




def helper(a, b, d):
    g, x, y = extended_gcd(a, b)
    assert a * x + b * y == g
    assert gcd(a, b) == abs(g)
    if d % g != 0:
        return None

    x *= d // g
    y *= d // g
    assert a * x + b * y == d

    m = b // g
    n = a // g

    assert m != 0
    if m < 0:
        m *= -1
        n *= -1
    k = x // m
    x -= k * m
    y += k * n
    assert a * x + b * y == d
    assert 0 <= x < m

    return x


def solve(W, N, D, X):
    assert len(X) == W

    g = gcd(D, N)
    def f(diff):
        # Need D * i = diff - N * j
        x = helper(D, N, diff)
        if x is None:
            return inf
        return x

    need = 0
    for i in range(W):
        j = W - 1 - i
        if i < j:
            if X[i] != X[j]:
                diff1 = (X[i] - X[j]) % N
                diff2 = (X[j] - X[i]) % N
                need += min(f(diff1), f(diff2))
        else:
            break
    if need == inf:
        return "IMPOSSIBLE"
    return need


if __name__ == "__main__":
    T = int(input())
    for t in range(1, T + 1):
        (W, N, D) = [int(x) for x in input().split()]
        X = [int(x) for x in input().split()]
        ans = solve(W, N, D, X)
        print("Case #" + str(t) + ": " + str(ans))