#include <bits/stdc++.h>

using namespace std;

#define compact(r, c, n) r * n + c
#define get_r(v, n) v / n
#define get_c(v, n) v % n

typedef pair<int, int> pii;

const int inf = 1e9;

int dr[4] = {0, 0, 1, -1};
int dc[4] = {-1, 1, 0, 0};

int main(){
    cin.tie(NULL)->sync_with_stdio(false);

    int n, k;
    cin >> n >> k;

    vector<string> grid(n);
    for(int i = 0; i < n; i++)
        cin >> grid[i];

    vector<vector<int>> paths(n, vector<int>()), rpath(n, vector<int>(2 * n));
    vector<pii> path(n * n);

    for(int i = 0; i < n; i++){
        int r = i;
        int c = 0;
        int ind = 2 * n - 1;

        while(r < n && c < n){
            assert(ind >= 0);

            path[compact(r, c, n)] = {i, ind};
            rpath[i][ind] = compact(r, c, n);
            paths[i].push_back(ind--);

            r++;

            swap(r, c);
        }
    }

    vector<int> d(n*n, inf);
    queue<int> q;

    d[compact(0, 0, n)] = 0;
    q.push(compact(0, 0, n));
    
    paths[0].erase(lower_bound(paths[0].begin(), paths[0].end(), path[0].second, greater<int>()));

    assert(count(paths[0].begin(), paths[0].end(), path[0].second) == 0);

    while(!q.empty()){
        int loc = q.front();
        int row = get_r(loc, n);
        int col = get_c(loc, n);

        //cout << loc << " <- Location\n";

        q.pop();

        for(int i = 0; i < 4; i++){
            int nrow = row + dr[i];
            int ncol = col + dc[i];

            if(nrow >= 0 && nrow < n && ncol >= 0 && ncol < n && grid[nrow][ncol] == '.' && d[compact(nrow, ncol, n)] == inf){
                d[compact(nrow, ncol, n)] = d[loc] + 1;
                q.push(compact(nrow, ncol, n));

                vector<int> &path_ref = paths[path[compact(nrow, ncol, n)].first];
                path_ref.erase(lower_bound(path_ref.begin(), path_ref.end(), path[compact(nrow, ncol, n)].second, greater<int>()));
            
                assert(count(path_ref.begin(), path_ref.end(), path[compact(nrow, ncol, n)].second) == 0);
            }
        }

        vector<int> &path_ref = paths[path[loc].first];
        auto start_ind = lower_bound(path_ref.begin(), path_ref.end(), path[loc].second, greater<int>());        
        auto current_ind = start_ind;

        //cout << loc << " | " << path[loc].second << " | " << *start_ind << " " << rpath[path[loc].first][*current_ind] << endl;

        while(current_ind != path_ref.end() && path[loc].second - *current_ind <= k){
            int jmploc = rpath[path[loc].first][*current_ind];

            if(grid[get_r(jmploc, n)][get_c(jmploc, n)] == '.'){
                d[jmploc] = d[loc] + 1;
                q.push(jmploc);
            }

            current_ind++;
        }

        if(start_ind != path_ref.end())
            path_ref.erase(start_ind, current_ind);
    }
    
    if(d[n * n - 1] == inf)
        cout << "-1\n";
    else
        cout << d[n * n - 1] << "\n";
}