import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;

/**
 * Solution to Haybales
 * 
 * @author vanb
 */
public class haybales_vanb
{
    private static BufferedReader br;
    private static PrintStream ps;
    
    /** This is bigger than any number of jumps we'll see */
    private static final int INFINITY = 10000;
    
    /**
     * This records a position on the field and how many jumps it took to get there.
     * For rows, it will record the column number, and for columns, it will record the row number.
     * 
     * @author vanb
     */
    private class From implements Comparable<From>
    {
        /** The number of jumps it took to get here */
        public int jumps;
        
        /** Where we are - the row number or column number */
        public int where;
        
        /**
         * Create one of these.
         * 
         * @param jumps The number of jumps it took to get here
         * @param where Where we are - the row number or column number
         */
        public From( int jumps, int where )
        {
            this.jumps = jumps;
            this.where = where;
        }
        
        @Override
        /**
         * Compare this From with another.
         * 
         * @param other Another of these
         * @return >0 if this one is 'better' than the other, <0 if it's 'worse', 0 if they'e the same.
         */
        public int compareTo( From other )
        {
            // Smaller number of jumps is obviously better.
            int diff = jumps - other.jumps;
            
            // Same number of jumps? The the larger position is better.
            // That will be closer to the spot we're trying to move to.
            if( diff==0 ) diff = other.where - where;
            return diff;
        }
    }
    
    /**
     * Do it!
     * 
     * @throws Exception
     */
    private void doit() throws Exception
    {
        String tokens[] = br.readLine().trim().split( "\\s+" );
        int n = Integer.parseInt( tokens[0] );
        int k = Integer.parseInt( tokens[1] );
        //System.err.println( n + " " + k );
        
        // Read the field
        char field[][] = new char[n][];
        for( int i=0; i<n; i++ ) field[i] = br.readLine().trim().toCharArray();
        
        // We're going to keep track of previous square's number of jumps
        // for each column, and for a row.
        // We're going to sort them so we get the best one first.
        PriorityQueue<From> columns[] = new PriorityQueue[n];
        for( int i=0; i<n; i++ ) columns[i] = new PriorityQueue<From>(k);
        PriorityQueue<From> row = new PriorityQueue<From>(k);
        
        // We start at square 0,0, so we know how many jumps it takes (zero).
        // So, no need to compute it.
        field[0][0] = 'X';
        int best = INFINITY;
        
        // For each row...
        for( int i=0; i<n; i++ )
        {
            // Starting a new row
            row.clear();
            
            // If it's the first row, populate our queues with the knowledge
            // that it takes 0 jumps to get to (0,0)
            if( i==0 )
            {
                row.add( new From( 0, 0 ) );
                columns[0].add( new From( 0, 0 ) );
            }
            
            // For each column, if there isn't a haybale here...
            for( int j=0; j<n; j++ ) if( field[i][j]=='.' )
            {
                // Look for the best we can do if we jump to the right within the row
                int bestrow = INFINITY;
                while( !row.isEmpty() )
                {
                    // Get the best (smallest) number of jumps
                    From f = row.peek();
                    
                    // If it's in range, use it, and get out.
                    if( j-f.where<=k )
                    {
                        bestrow = f.jumps;
                        break;
                    }
                    
                    // If it's out of range, get rid of it and keep trying.
                    row.poll();
                }
                
                // Look for the best we can do if we jump down within the column
                int bestcol = INFINITY;
                while( !columns[j].isEmpty() )
                {
                    // Get the best (smallest) number of jumps
                    From f = columns[j].peek();
                    
                    // If it's in range, use it, and get out.
                    if( i-f.where<=k )
                    {
                        bestcol = f.jumps;
                        break;
                    }
                    
                    // If it's out of range, get rid of it and keep trying
                    columns[j].poll();
                }
                
                // Look for the best, row or column (add one for the jump from there to here)
                best = Math.min( bestrow, bestcol )+1;
                
                // If we can make it, record it.
                if( best<INFINITY )
                {
                    row.add( new From( best, j ) );
                    columns[j].add( new From( best, i ) );
                }
            }
        }
        
        // n==1 is a special case. Remember, we didn't process (0,0).
        // The bottom right square is the last one we'll process, so 'best' will hold our answer.
        ps.println( n==1 ? 0 : best<INFINITY ? best : -1 );
    }
       
    /**
     * Main!
     * 
     * @param args Command-line args (not used)
     * @throws Exception
     */
    public static void main( String[] args ) throws Exception
    {
        br = new BufferedReader( new InputStreamReader( System.in ) );
        ps = System.out;
        
        new haybales_vanb().doit();
    }

}