#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>());
    vector<pii> path(n * n);

    for(int i = 0; i < n; i++){
        int r = i;
        int c = 0;
        int ind = 0;
        
        while(r < n && c < n){ 
            //cout << r << " " << c << "\n";

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

            r++;

            swap(r, c);
        }
    }

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

    d[compact(0, 0, n)] = 0;
    q.insert({0, compact(0, 0, n)});
    
    //paths[0].erase(lower_bound(paths[0].begin(), paths[0].end(), path[0].second));

    while(!q.empty()){
        int loc = q.begin()->second;
        int row = get_r(loc, n);
        int col = get_c(loc, n);

        if(row == n-1 && col == n-1){
            cout << d[loc] << "\n";
            return 0;
        }

        q.erase(q.begin());

        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;
                assert(compact(nrow, ncol, n) != loc);
                q.insert({d[loc] + 1, 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));
            }
        }

        int cnt = 0;

        while(cnt <= k){ 
            if(row < n && col < n){
                if(d[compact(row, col, n)] == inf && grid[row][col] == '.'){
                    d[compact(row, col, n)] = d[loc] + 1;
                    assert(loc != compact(row, col, n));
                    q.insert({d[loc] + 1, compact(row, col, n)});
                }
            }

            row++;
            cnt++;

            swap(row, col);
        }

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

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

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

            current_ind++;
        }

        if(start_ind != path_ref.end())
            path_ref.erase(start_ind, current_ind);*/
    }
    
    
    cout << "-1\n";
}