#include <iostream>
#include <math.h>
#include <vector>

using namespace std;

int connectedOnes;
int connectedTwos;
int connectedThrees;

int ones;
int twos;
int threes;
int fours;

const int s1size = 4;
const int s2size = 8;
const int s3size = 12;
const int s4size = 16;

const int s1[4][2] = {{0,  1},
                      {1,  0},
                      {-1, 0},
                      {0,  -1}};
const int s2[8][2] = {{0,  2},
                      {2,  0},
                      {-2, 0},
                      {0,  -2},
                      {1,  1},
                      {1,  -1},
                      {-1, 1},
                      {-1, -1}};
const int s3[12][2] = {{0,  3},
                       {3,  0},
                       {-3, 0},
                       {0,  -3},
                       {2,  -1},
                       {2,  1},
                       {-1, 2},
                       {1,  2},
                       {-2, 1},
                       {-2, -1},
                       {1,  -2},
                       {-1, -2}};
const int s4[16][2] = {{0,  4},
                       {4,  0},
                       {-4, 0},
                       {0,  -4},
                       {3,  1},
                       {1,  3},
                       {-1, 3},
                       {3,  -1},
                       {-3, 1},
                       {-3, -1},
                       {1,  -3},
                       {-1, -3},
                       {2,  -2},
                       {2,  2},
                       {-2, 2},
                       {-2, -2}};

int spread1(int *board, vector<int> x, vector<int> y, int size);
int spread2(int *board, vector<int> x, vector<int> y, int size);
int spread3(int *board, vector<int> x, vector<int> y, int size);
int spread4(int *board, vector<int> x, vector<int> y, int size);

int countAll(int *board, int n, int size);

long long komBP(int ones, int k);

const long long mod = 1000000007;

int main() {

    int n;
    int k;
    vector<int> tilesX;
    vector<int> tilesY;
    int *options = new int[4];
    cin >> n;
    cin >> k;
    int size = n + 8;

    int *board = new int[3008 * 3008];
    for (int i = 0; i < size; ++i) {
        board[size * i + 0] = 0;
        board[size * i + size] = 0;
    }
    for (int i = 0; i < size; ++i) {
        board[0 + i] = 0;
        board[size * size + i] = 0;
    }

    for (int k = 4; k < n + 4; ++k) {
        for (int l = 4; l < n + 4; ++l) {
            char input;
            cin >> input;
            if (input == '#') {
                board[k * size + l] = -1;
                tilesX.push_back(k);
                tilesY.push_back(l);
            } else {
                board[k * size + l] = 5;
            }
        }
    }

    switch (k) {
        case 1:
            ones =spread1(board, tilesX, tilesY, size);
            cout << ones;
            break;
        case 2:
            ones =spread1(board, tilesX, tilesY, size);
            twos =spread2(board, tilesX, tilesY, size);
            countAll(board, n, size);
            cout << (komBP(ones, k)+connectedOnes*twos)%mod;
            break;
        case 3:
            ones =spread1(board, tilesX, tilesY, size);
            twos =spread2(board, tilesX, tilesY, size);
            threes =spread3(board, tilesX, tilesY, size);
            countAll(board, n, size);
            cout << (komBP(ones, k)+connectedOnes*twos+connectedTwos*threes)%mod;
            break;
        case 4:
            ones =spread1(board, tilesX, tilesY, size);
            twos =spread2(board, tilesX, tilesY, size);
            threes =spread3(board, tilesX, tilesY, size);
            fours =spread4(board, tilesX, tilesY, size);
            countAll(board, n, size);
            cout << (komBP(ones, k)+connectedOnes*twos+connectedTwos*threes+connectedThrees*fours)%mod;
            break;
    }
    return 0;
}

long long factorial(int n)
{
    long long ret = 1;
    for(long long i = 1; i <= n; ++i) {
        ret *= i;
        ret %= mod;
    }
    return ret;
}

long long komBP(int ones, int k){
    if(ones < k){
        return 0;
    } else if(ones == k ) {
        return 1;
    }
    long long licznik = factorial(ones);
    long long mianownik = factorial(k) * factorial(ones-k);
    long long val = mianownik;
    int counter = 1;
    while(val%mod!=1){
        val+=mianownik;
        counter++;
    }
    return (licznik*counter)%mod;
}

int spread1(int *board, vector<int> x, vector<int> y, int size) {
    for (int i = 0; i < x.size(); ++i) {
        for (int j = 0; j < s1size; ++j) {
            if (1 < board[(x.operator[](i)+s1[j][0]) * size + y.operator[](i) + s1[j][1]]) {
                board[(x.operator[](i)+s1[j][0]) * size + y.operator[](i) + s1[j][1]] = 1;
                ones++;
            }
        }
    }
    return ones;
}


int spread2(int *board, vector<int> x, vector<int> y, int size) {
    int targetVal = 2;
    for (int i = 0; i < x.size(); ++i) {
        for (int j = 0; j < s2size; ++j) {
            int xField = (x.operator[](i)+s2[j][0]);
            int yField = y.operator[](i) + s2[j][1];
            int arrayPlace = xField*size+yField;
            if (targetVal < board[arrayPlace]) {
                twos++;
                board[arrayPlace] = targetVal;
            }
        }
    }
    return twos;
}

int spread3(int *board, vector<int> x, vector<int> y, int size) {
    for (int i = 0; i < x.size(); ++i) {
        for (int j = 0; j < s3size; ++j) {
            if (3 < board[(x.operator[](i)+s3[j][0]) * size + y.operator[](i) + s3[j][1]]) {
                board[(x.operator[](i)+s3[j][0]) * size + y.operator[](i) + s3[j][1]] = 3;
                threes++;
            }
        }
    }
    return threes;
}

int spread4(int *board, vector<int> x, vector<int> y, int size) {
    for (int i = 0; i < x.size(); ++i) {
        for (int j = 0; j < s4size; ++j) {
            if (4 < board[(x.operator[](i)+s4[j][0]) * size + y.operator[](i) + s4[j][1]]) {
                board[(x.operator[](i)+s4[j][0]) * size + y.operator[](i) + s4[j][1]] = 4;
                fours++;
            }
        }
    }
    return fours;
}

int countAll(int *board, int n, int size) {
    for (int i = 4; i < n+4; ++i) {
        for (int k = 4; k < n+4; ++k) {
            switch (board[i*size+k]){
                case 1:
                    for (int j = 0; j < s1size; ++j) {
                        if (2 == board[(i+s1[j][0]) * size + k + s1[j][1]]) {
                            connectedOnes++;
                            break;
                        }
                    }
                    break;
                case 2:
                    for (int j = 0; j < s1size; ++j) {
                        if (3 == board[(i+s1[j][0]) * size + k + s1[j][1]]) {
                            connectedTwos++;
                            break;
                        }
                    }
                    break;
                case 3:
                    for (int j = 0; j < s1size; ++j) {
                        if (4 == board[(i+s1[j][0]) * size + k + s1[j][1]]) {
                            connectedThrees++;
                            break;
                        }
                    }
                    break;
            }
        }
    }
}