#!/usr/bin/python3

import sys, math, os
#import re, string, fractions, itertools
#import bisect, heapq
#from fractions import Fraction
#from functools import reduce


LocaL = "MATE_DESKTOP_SESSION_ID" in os.environ

def mle_assert(x):
    if LocaL:
        assert x
    elif not x:
        x = list(range(10**8))


def tle_assert(x):
    if LocaL:
        assert x
    elif not x:
        for i in range(10000):
            for j in range(1000):
                for k in range(1000):
                    pass


sys.setrecursionlimit(10000)
#Z = 10**9 + 7
ssr = sys.stdin.readline
ssw = sys.stdout.write
ssf = sys.stdout.flush
sew = sys.stderr.write
def rdline(): return ssr().strip()
def rdstrs(): return ssr().split()
def rdints(): return list(map(int, ssr().split()))
def rd1int(): return int(rdline())



def multinv(i, m):
    """Return multiplicative inverse of i modulo m"""
    assert m>1
    #m0 = m
    i = i % m
    a = 1
    c = 0
    while i>0:
        q = m // i
        m, c, i, a = i, a, m-q*i, c-q*a
    assert m==1
    return c
    #return c % m0


def do_one_case(cnum):
    W, N, D = rdints()
    X = rdints()
    assert len(X) == W
    X = [ x-1 for x in X ]
    g = math.gcd(N,D)
    n = N//g
    d = D//g
    di = multinv(d,n)

    ans = 0
    for i in range(W//2):
        a = X[i]
        b = X[W-1-i]
        c = abs(a-b)
        if g>1:
            if c%g:
                print(f"Case #{cnum}: IMPOSSIBLE")
                return
            c = c // g
        k = (di*c) % n
        assert 0<=k<n
        k = min(k, n-k)
        ans += k

    print(f"Case #{cnum}: {ans}")




def main():
    T = rd1int()
    for i in range(T):
        do_one_case(i+1)
        sys.stdout.flush()


if __name__ == "__main__":
    main()