#include <bits/stdc++.h>
using namespace std;

const long long MODULO = 1e9 + 7;
const int N = 3005;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
int n, k;
char a[N][N];

inline bool ins(int x, int y)
{
  return x >= 0 && x < n && y >= 0 && y < n;
}

long long wyn = 0;
bool jedynka[N][N], dwojka[N][N];
long long jedynki = 0;
long long suma[5], sasi[N][N], sasi2[N][N];
bool poko[N][N];
void dfs(int x, int y, int len)
{
  suma[len]++;
  if (len == k) return;
  for (int i = 0; i < 4; i++) if (ins(x + dx[i], y + dy[i])) if (!jedynka[x+dx[i]][y+dy[i]]) if (a[x+dx[i]][y+dy[i]] != '#')
    dfs(x+dx[i], y+dy[i], len+1);
}

long long fast_pow(long long aa, long long bb)
{
  if (!bb) return 1;
  long long x = fast_pow(aa, bb/2);
  x *= x; x %= MODULO;
  if (bb % 2LL == 1) { x *= aa; x %= MODULO; }
  return x;
}
inline long long sym_new(long long nn, const long long kk)
{
  if (nn < kk) return 0;
  if (kk == 1) return nn;
  if (kk == 2) return (nn * (nn-1) / 2LL) % MODULO;
  if (kk == 3 && nn <= 1e6) return (nn * (nn-1) * (nn-2) / 6LL) % MODULO;
  long long wynik = 1;
  for (long long i = nn; i > nn-kk; i--)
  {
    wynik *= i;
    wynik %= MODULO;
  }
  long long dd = 1;
  for (long long i = 1; i <= kk; i++)
    dd *= i;
  return (wynik * fast_pow(dd, MODULO-2)) % MODULO;
}

int odle[N][N];

int main()
{
  scanf("%d%d", &n, &k);
  for (int i = 0; i < n; i++)  
    scanf("%s", a[i]);
  
 /* queue<pair<int,int>> Q;
  for (int i = 0; i < n; i++) 
    for (int j = 0; j < n; j++)
    {
      if (a[i][j] == '#'){ odle[i][j] = 0; Q.push({i,j}); }
      else odle[i][j] = 1e9;
    }
  while(!Q.empty())
  {
    pair<int,int> u = Q.front(); Q.pop();
    for (int r = 0; r < 4; r++) if (ins(u.first+dx[r], u.second+dy[r]))
    {
      if (odle[u.first+dx[r]][u.second+dy[r]] > odle[u.first][u.second]+1)
      {
        odle[u.first+dx[r]][u.second+dy[r]] = odle[u.first][u.second]+1;
        Q.push({u.first+dx[r], u.second+dy[r]});
      }
    }
  } */

  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) if (a[i][j] != '#')
      for (int z = 0; z < 4; z++)
        if (ins(i + dx[z], j + dy[z]))
          if (a[i + dx[z]][j + dy[z]] == '#')
          {
            jedynka[i][j] = 1;
            jedynki++;
            break;
          }

  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++) if (!jedynka[i][j] && a[i][j] != '#')
      for (int z = 0; z < 4; z++) 
        if (ins(i + dx[z], j + dy[z]))
          if (jedynka[i + dx[z]][j + dy[z]])
          {
            dwojka[i][j] = 1;
            sasi2[i+dx[z]][j+dy[z]]++;
            sasi[i][j]++; // tutaj nie mozna robic breaka
          }
           
  if (k <= 3) for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
      if (jedynka[i][j])
        dfs(i, j, 1);

  if (k == 1) // pewnie dziala :-)
  {
    printf("%lld\n", suma[1] % MODULO); // 1 = 1
    return 0;
  }
  if (k == 2) // pewnie dziala :-)
  {
    printf("%lld\n", (suma[2] + sym_new(suma[1], 2)) % MODULO); // 2 = 1 + 1 = 2
    return 0;
  }
  if (k == 3) // dziala :-)
  {
    wyn = sym_new(suma[1] % MODULO, 3); // 3 = 1 + 1 + 1
    for (int i = 0; i < n; i++)
      for (int j = 0; j < n; j++)
        if (dwojka[i][j])
        {
          int wokol = 0;
          for (int r = 0; r < 4; r++)
            if (ins(i + dx[r], j + dy[r]))
              if (jedynka[i+dx[r]][j+dy[r]])
                wokol++;
          wyn += 1LL * wokol * (suma[1] - wokol) + 1LL * wokol * (wokol - 1) / 2LL; // 3 = 2 + 1
        }
    for (int i = 0; i < n; i++)
      for (int j = 0; j < n; j++)
        if (jedynka[i][j])
        {
          int wokol = 0;
          for (int r = 0; r < 4; r++)
            if (ins(i + dx[r], j + dy[r]))
              if (dwojka[i+dx[r]][j+dy[r]])
                wokol++;
          wyn += 1LL * wokol * (wokol - 1) / 2LL; // 3 = 2 + 1
        }
            
    wyn += suma[3]; // 3 = 3
    printf("%lld\n", wyn % MODULO);
    return 0;
  }
  
  if (k == 4) // no i tez dziala 
  {
    for (int i = 0; i < n; i++)
      for (int j = 0; j < n; j++)
        if (!jedynka[i][j] && a[i][j] != '#')
          poko[i][j] = 1;
               
    vector<pair<int,int>> jedyneczki, pokosy;
    for (int i = 0; i < n; i++)
      for (int j = 0; j < n; j++)
      {
        if (poko[i][j]) pokosy.push_back({i, j});
        if (jedynka[i][j]) jedyneczki.push_back({i, j});
      }
  
    wyn = sym_new(jedynki, 4); // 4 jedynki
    
    #define i iter.first
    #define j iter.second
    
     // 3 jedynki
     for (auto iter: pokosy)
     {
        int moje = sasi[i][j];
        int reszta = jedynki - moje;
        if (moje != 0)
        {
          wyn += sym_new(moje, 1) * sym_new(reszta, 2) +
                 sym_new(moje, 2) * sym_new(reszta, 1) +
                 sym_new(moje, 3) * sym_new(reszta, 0);
        }
       }

    wyn %= MODULO;
    
    long long licze_sobie = 0;
    for (auto iter: pokosy)
      for (int r = 0; r < 2; r++)
        if (ins(i+dx[r], j+dy[r]) && poko[i+dx[r]][j+dy[r]])
        {
           int ile = sasi[i][j] + sasi[i+dx[r]][j+dy[r]];
           if (ile != 0) licze_sobie += sym_new(ile, 2) + sym_new(ile,1) * sym_new(jedynki-ile,1);
        }
          
    wyn += licze_sobie;
    long long parki = 0;      
    for (auto iter: jedyneczki)
    {
      wyn += sasi2[i][j] * parki;    
      parki += sasi2[i][j];
    }
    for (auto iter: pokosy)
      wyn -= sym_new(sasi[i][j], 2);
  
   for (auto iter: jedyneczki)
      for (int r = 0; r < 4; r++) if (ins(i + dx[r], j + dy[r]) && poko[i + dx[r]][j + dy[r]])
        for (int r2 = r+1; r2 < 4; r2++) if (ins(i + dx[r2], j + dy[r2]) && poko[i + dx[r2]][j + dy[r2]])
        {
          int ile = sasi[i+dx[r]][j+dy[r]] + sasi[i+dx[r2]][j+dy[r2]] - 1;
          if (abs(dx[r]) != abs(dx[r2]))
            if (jedynka[i+dx[r]+dx[r2]][j+dy[r]+dy[r2]])
              ile--;
          wyn += jedynki - ile;
        }              
    
    for (auto iter: pokosy)
      for (int r = 0; r < 2; r++) if (ins(i+dx[r], j+dy[r]) && poko[i+dx[r]][j+dy[r]])
        for (int r2 = 0; r2 < 4; r2++) if (ins(i+dx[r2], j+dy[r2]))
          for (int r3 = 0; r3 < 4; r3++) if (ins(i+dx[r]+dx[r3], j+dy[r]+dy[r3]))
          if (jedynka[i+dx[r2]][j+dy[r2]] && jedynka[i+dx[r]+dx[r3]][j+dy[r]+dy[r3]])
            wyn--;
              
    for (auto iter: jedyneczki)
      for (int r = 1; r <= 2; r++)
        if (ins(i+dx[r]+dx[r+1],j+dy[r]+dy[r+1]) && jedynka[i+dx[r]+dx[r+1]][j+dy[r]+dy[r+1]])
          if (!jedynka[i+dx[r]][j+dy[r]] && a[i+dx[r]][j+dy[r]] != '#')
            if (!jedynka[i+dx[r+1]][j+dy[r+1]] && a[i+dx[r+1]][j+dy[r+1]] != '#')
              wyn--;
    
    wyn %= MODULO; 
   
    // moj ulubiony przypadek - 1 jedynka
    for (auto iter: pokosy)
      for (int r = 0; r < 4; r++) if (ins(i + dx[r], j + dy[r]) && poko[i + dx[r]][j + dy[r]])
        for (int r2 = r+1; r2 < 4; r2++) if (ins(i + dx[r2], j + dy[r2]) && poko[i + dx[r2]][j + dy[r2]])
        {
          vector<pair<int,int>> te_punkty;
          for (int e = 0; e < 4; e++)
          {
            if (ins(i+dx[e], j+dy[e]) && jedynka[i+dx[e]][j+dy[e]]) te_punkty.push_back({i+dx[e], j+dy[e]});
            if (ins(i+dx[r]+dx[e], j+dy[r]+dy[e]) && jedynka[i+dx[r]+dx[e]][j+dy[r]+dy[e]]) te_punkty.push_back({i+dx[r]+dx[e], j+dy[r]+dy[e]});
            if (ins(i+dx[r2]+dx[e], j+dy[r2]+dy[e]) && jedynka[i+dx[r2]+dx[e]][j+dy[r2]+dy[e]]) te_punkty.push_back({i+dx[r2]+dx[e], j+dy[r2]+dy[e]});
        }
        sort(te_punkty.begin(), te_punkty.end());
        te_punkty.resize(distance(te_punkty.begin(), unique(te_punkty.begin(), te_punkty.end())));
        wyn += te_punkty.size();
      }
    for (auto iter: jedyneczki)
      wyn += sym_new(sasi2[i][j], 3);
    for (auto iter: jedyneczki)
      for (int r = 0; r < 4; r++) if (ins(i+dx[r], j+dy[r]) && poko[i+dx[r]][j+dy[r]])
        for (int r2 = 0; r2 < 4; r2++) if (r != r2) if (ins(i+dx[r2], j+dy[r2]) && poko[i+dx[r2]][j+dy[r2]])
          for (int r3 = 0; r3 < 4; r3++) if (ins(i+dx[r]+dx[r3], j+dy[r]+dy[r3]) && poko[i+dx[r]+dx[r3]][j+dy[r]+dy[r3]])
            if (abs(i+dx[r]+dx[r3] - i-dx[r2]) + abs(j+dy[r]+dy[r3] - j-dy[r2]) > 1)
              wyn++;
          
    printf("%lld\n", wyn % MODULO);
    return 0;
  }

  return 0;
}