import java.util.*;

public class LifeGame
{
	static final boolean safe_slow_version = false;

	public static void main( String[] arg )
	{
		int nCase = 1;
		for(Scanner sc = new Scanner(System.in) ;; ++nCase)
		{
			// read the first line of the input
			int N=sc.nextInt(), M=sc.nextInt(), L=sc.nextInt();
			if( N==0 && M==0 && L==0 )
				break;

			assert 1<=N && N<=6          : "\n    N (hexmap size) is out-of-range";
			assert 2<=M && M<=1000000000 : "\n    M (modulo value) is out-of-range";
			assert 1<=L && L<=1000000000 : "\n    L (iteration) is out-of-range";

			// read the initial state
			int S = 3*N*(N-1)+1; // Size of the hex-map
			long[] Ini = new long[S];
			for(int i=0; i<S; ++i)
			{
				Ini[i] = sc.nextLong();
				assert 0<=Ini[i] && Ini[i]<M : "\n   Virus num is out-of-range";
			}

			// calculate the state after L steps
			long[] Fin = safe_slow_version ? mult_safe(oneStepMatrix(N, S), L, Ini, M)
			                               : mult_fast(oneStepMatrix(N, S), L, Ini, M);

			// print the sum
			long sum = 0;
			for(int i=0; i<S; ++i)
				sum += Fin[i];
			System.out.println( "Case "+nCase+": "+sum );
		}
	}

	static long[][] oneStepMatrix( int N, int S )
	{
		long[][] m = new long[S][S];
		for(int i=0,y=0; y<2*N-1; ++y)
		{
			int W = (y<N ? N+y : 3*N-2-y);
			for(int x=0; x<W; ++x,++i)
			{
				// self
				m[i][i] = 1;
				// right
				if( x<=W-2 )
					m[i][i+1] = m[i+1][i] = 1;
				// under
				if( y<N-1 )
					m[i][i+W] = m[i+W][i] = m[i][i+W+1] = m[i+W+1][i] = 1;
				else if( y<2*N-2 )
					if( y<N-1 || (1<=x && x<=W-2) )
						m[i][i+W-1] = m[i+W-1][i] = m[i][i+W] = m[i+W][i] = 1;
					else if( x==0 )
						m[i][i+W] = m[i+W][i] = 1;
					else if( x==W-1 )
						m[i][i+W-1] = m[i+W-1][i] = 1;
			}
		}
		return m;
	}

	// calc m^L v (mod M) in iterative way
	static long[] mult_safe(long[][] m, int L, long[] v, long M)
	{
		int S = v.length;

		long[] a = new long[S];
		for(int k=0; k<L; ++k)
		{
			for(int i=0; i<S; ++i)
				for(int j=0; j<S; ++j)
					a[i] = (a[i] + m[i][j] * v[j]) % M;
			v = a;
			a = new long[S];
		}
		return v;
	}

	// calc m^L v (mod M) in clever way
	static long[] mult_fast(long[][] m, int L, long[] v, long M)
	{
		long[][] mL = null;
		for(int bitmask=1; bitmask<=L; bitmask<<=1, m=matmult(m,m,M))
			if( (L & bitmask) != 0 )
				if( mL == null )
					mL = m;
				else
					mL = matmult(mL,m,M);
		return mult_safe(mL, 1, v, M);
	}

	// matrix multiplication (mod M)
	static long[][] matmult(long[][] a, long[][] b, long M)
	{
		int S = a.length;
		long[][] c = new long[S][S];
		for(int i=0; i<S; ++i)
			for(int j=0; j<S; ++j)
				for(int k=0; k<S; ++k)
					c[i][j] = (c[i][j] + a[i][k]*b[k][j]) % M;
		return c;
	}
}