/**/ /*
    题意：问n+1个n维点的球心，即其他点到该点距离相等
    设距离为R,很容里列出n+1个方程，但是有2次项，只要下一行减上一行即可
    得到一个n个方程n个未知数，用高斯消元
    
    矩阵为
    A[i][j] = (V[i+1][j] - V[i][j])*2
    A[i][n+1] = V[i+1][j]^2 - V[i][j]^2  （只是增广的那一项）

    会超long long  但用java高精度会超时！
    1 <= N <= 50, |xi| <= 10^17  而且答案是整数解且 |Xi| <= 10^17
    只要运算过程中取模一个大于 2*10^17的素数即可
    Ax = B  
    => Ax %p = B %p
    => A%p x = B %p 
    即原方程的解等价于系数为A%p的方程的解

    注意：
    由于答案可以是负数，%p的话结果是[0,p)，不对
    所以一开始对所有坐标都平移一下，都加上10^17，最后答案减去10^17即正确了

    看http://www.cppblog.com/AmazingCaddy/archive/2010/08/25/124608.html

    我自己写的高斯消元超时，太慢了
    他这种是对row这一行都除以A[row][row]使得A[row][row]为1，很快
    由于取余，所以可以直接除（乘以逆元），不怕整不整除问题！！
*/
#include < cstdio >
#include < cstring >
#include < algorithm >
#include < iostream >
#include < cmath >

using   namespace  std; 


 const   long   long  MOD  =  1000000000000000003LL;
 const   long   long  p  =  1000000000000000003LL;
 const   long   long  INF  =  100000000000000000LL;
 const   int  MAXN  =   60 ;

typedef  long   long  ll;

 long   long  v[MAXN][MAXN];
 long   long  A[MAXN][MAXN];

inline  long   long  imod( long   long  a)
 {
    return (a%MOD + MOD)%MOD;
}

inline  long   long  iabs( long   long  a)
 {
    return a>0?a:-a;
}

inline  long   long  imul( long   long  a, long   long  b)
 {
    long long ans = 0 ,  n = iabs(b);
    while(n)
    {
        if(n&1)
        {
            ans += a;
            if(ans >= MOD) ans -= MOD;
        }
        a <<= 1;
        if(a >= MOD ) a -= MOD;
        n>>=1;
    }
    if(b<0)ans= imod(-ans);
    return ans;
}

inline  long   long  ipow( long   long  a, long   long  b)
 {
    if(b==1)return a%MOD;
    long long ans = ipow(a,b>>1); 
    ans = imul(ans,ans);
    if(b&1)ans = imul(ans,a);
    return ans;
}

inline  long   long  inv( long   long  a)
 {
    return ipow(a,MOD-2);
}

inline  long   long  gcd( long   long  a, long   long  b)
 {
    return b?gcd(b,a%b):a;
}

void  printA( int  n)
 {
    for(int i = 1 ; i<= n; i++)
    {
        for(int j =1;  j<= n+1 ; j++)
            printf("%I64d ",A[i][j]);
        puts("");
    }
}

void  getA( int  n)
 {
    for(int i = 1; i<= n; i++)
    {
        A[i][n+1] = 0;
        for(int j = 1; j <= n ; j++)
        {
            A[i][j] = imod((v[i+1][j] - v[i][j])*2);
            A[i][n+1] = imod(A[i][n+1] + imul(v[i+1][j],v[i+1][j]) - imul(v[i][j],v[i][j]));
        }
    }
    //printA(n);
}

void  guass( int  n)
 {
    for(int row = 1; row <= n ; row ++)
    {
        int k =  row;
        long long Max = A[row][row];
        for(int i = row+1; i<=n; i++)
            if(A[i][row]>Max)Max=A[k=i][row];
        if(k!=row)
        {
            for(int j = row ; j <= n+1 ; j++)
                swap(A[k][j] , A[row][j]);
        }
        long long div = inv(A[row][row]);
        //使得A[row][row] = 1;
        for(int j = row + 1 ; j <= n+1 ; j++)
        {
            A[row][j] = imul(A[row][j],div);//由于取余，所以可以直接除（乘以逆元），不怕整不整除问题！！
            for(int i = row+1; i <= n ; i++)
            {
                A[i][j] = imod(A[i][j] - imul(A[row][j],A[i][row]));
            }
        }
    }
    for(int row = n ; row >= 1; row --)
    {
        for(int j = n ; j> row ; j--)
        {
            A[row][n+1] = imod(A[row][n+1] - imul(A[j][j],A[row][j]) );
        }
        A[row][row] = A[row][n+1];
    }
}

void  print( int  n)
 {
    for(int i = 1; i <= n; i++)
    {
        if(i>1)putchar(' ');
        printf("%I64d",A[i][i]-INF);
    }
    puts("");
}

int  main()
 {
#ifdef ONLINE_JUDGE
#else
    freopen("in","r",stdin);
#endif

    int T , t = 1; 
    for(scanf("%d",&T);T--;)
    {
        int n;
        scanf("%d",&n);
        for(int i = 1; i <= n+1; i ++)
            for(int j= 1; j <= n; j++)
            {
                scanf("%I64d",&v[i][j]);
                v[i][j] += INF;//平移一下，这样答案才是正确的
            }
        getA(n);
        guass(n);
        printf("Case %d:\n",t++);
        print(n);
    }
    return 0;
}