#pragma GCC optimize("O3")
#pragma GCC target("sse4")
// #pragma GCC optimize("Ofast")
// #pragma GCC target("avx,avx2,fma")
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const double PI=acos(-1.0);
#define t1(x)             cerr<<#x<<"="<<x<<endl
#define t2(x, y)          cerr<<#x<<"="<<x<<" "<<#y<<"="<<y<<endl
#define t3(x, y, z)       cerr<<#x<<"=" <<x<<" "<<#y<<"="<<y<<" "<<#z<<"="<<z<<endl
#define t4(a,b,c,d)       cerr<<#a<<"="<<a<<" "<<#b<<"="<<b<<" "<<#c<<"="<<c<<" "<<#d<<"="<<d<<endl
#define t5(a,b,c,d,e)     cerr<<#a<<"="<<a<<" "<<#b<<"="<<b<<" "<<#c<<"="<<c<<" "<<#d<<"="<<d<<" "<<#e<<"="<<e<<endl
#define t6(a,b,c,d,e,f)   cerr<<#a<<"="<<a<<" "<<#b<<"="<<b<<" "<<#c<<"="<<c<<" "<<#d<<"="<<d<<" "<<#e<<"="<<e<<" "<<#f<<"="<<f<<endl
#define GET_MACRO(_1,_2,_3,_4,_5,_6,NAME,...) NAME
#define tr(...) GET_MACRO(__VA_ARGS__,t6,t5, t4, t3, t2, t1)(__VA_ARGS__)
#define __ freopen("tictactoe.in","r",stdin);freopen("tictactoe.out","w",stdout);
#define fastio() ios::sync_with_stdio(0);cin.tie(0)
#define MEMS(x,t) memset(x,t,sizeof(x));
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
/*-------------------------------------------------------------------------------------------------------------------------------------*/
#define MOD 1000000007
#define endl "\n"
#define int long long
#define inf 1e18
#define ld long double
/*-------------------------------------------------------------------------------------------------------------------------------------*/

ll poww(long long a, long long n, long long m)
{
        long long ans = 1;
        long long mul = a;
        while (n != 0)
        {
                if (n % 2)
                {
                        ans = (ans * mul) % m;
                }
                mul = (mul * mul) % m;
                n /= 2;
        }
        return ans;
}

const int SZ=2e6+100;
ll factorial[SZ];
ll iv[SZ];
void precompute()
{
    factorial[0]=1;
    iv[0]=1;
    for(int i=1;i<SZ;i++)
    {
        factorial[i]=(factorial[i-1]*i)%MOD;
        iv[i]=poww(factorial[i],MOD-2,MOD);
    }
}
ll InverseEuler(ll n, ll m)
{
    return poww(n, m - 2, m);
}
ll C(ll n, ll r, ll m)
{
    if(r>n || r<0)return 0;
    return (factorial[n] * ((iv[r] * iv[n-r]) % m)) % m;
}


const int N=1e3+10;
int dis[N][N];


int dx[]={-2,-2,-1,-1,+1,+1,2,2};
int dy[]={-1,1,-2,2,-2,2,-1,1};

int n,m,k;
vector<int> d;
bool check(int x,int y)
{
    return x>=0 && y>=0 && x<n && y<m;
}
int get_frac(int a,int b)
{
    a%=MOD;
    return (a*poww(b,MOD-2,MOD))%MOD;
}
// int fact[N*N];
signed main()
{
    fastio();
    // fact[0]=1;
    // for(int i=1;i<N*N;i++)
    // {
        // fact[i]=fact[i-1]*i;
        // fact[i]%=MOD;
    // }
    precompute();
    int t;
    cin>>t;
    while(t--)
    {
        cin>>n>>m>>k;
        string s[n];
        for(int i=0;i<n;i++)
        {
            cin>>s[i];
        }
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                dis[i][j]=inf;
            }
        }
        queue<pair<pair<int,int>,int>> q;
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(s[i][j]=='X')
                {
                    q.push({{i,j},0});
                    dis[i][j]=0;
                }
            }
        }
        while(q.size())
        {
            auto tmp=q.front();
            q.pop();
            int x=tmp.first.first;
            int y=tmp.first.second;
            int d=tmp.second;
            dis[x][y]=d;
            for(int j=0;j<8;j++)
            {
                for(int kj=0;kj<8;kj++)
                {
                    if(check(x+dx[j],y+dy[kj]) && dis[x+dx[j]][y+dy[kj]]>d+1)
                    {
                        dis[x+dx[j]][y+dy[kj]]=d+1;
                        q.push({{x+dx[j],y+dy[kj]},d+1});
                    }
                }
            }
        }
        d=vector<int>(n*m+1,0);

        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                assert(dis[i][j]<inf);
                d[dis[i][j]]++;
            }
        }
        int ans=0;
        int total=0;
        vector<int> p_atmost(n*m+1,0);
        vector<int> p2(n*m+1,0);
        for(int i=0;i<=n*m;i++)
        {
            total+=d[i];

            //prob of max distance atmost i
            p_atmost[i]=(C(total,k,MOD));

            p2[i]=p_atmost[i];
            if(i>0)
                p2[i]=p_atmost[i]-p_atmost[i-1];
            if(p2[i]<0)p2[i]+=MOD;

            ans+=(p2[i]*i)%MOD;
            ans%=MOD;
        }
        ans*=poww(C(n*m,k,MOD),MOD-2,MOD);ans%=MOD;
        cout<<ans<<endl;
    }
}