import java.io.*;
import java.util.*;
import java.awt.geom.*;

/**
 * Solution to Knight Moves
 * 
 * We'll use a simple breadth-first search.
 * 
 * @author vanb
 */
public class knightmoves_vanb
{
    public Scanner sc;
    public PrintStream ps;
    
    /**
     * A State of the BFS. 
     * It'll include the (i,j) position of the knight,
     * and the number of moves so far.
     * 
     * @author vanb
     */
    public class State
    {
        /** i,j=position, distance=# moves */
        public int i, j, distance;
        
        /**
         * Create a State.
         * 
         * @param i Row
         * @param j Column
         * @param distance Number of MOves
         */
        public State( int i, int j, int distance )
        {
            this.i = i;
            this.j = j;
            this.distance = distance;
        }
    }
    
    /** di[] and dj[] describe the ways a knight can move. */
    public static final int di[] = { 1, 2, 2, 1, -1, -2, -2, -1 };
    public static final int dj[] = { 2, 1, -1, -2, 2, 1, -1, -2 };
           
    /**
     * Driver.
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner( System.in );
        ps = System.out; 

        // Read in the limits
        int n = sc.nextInt();
        int m = sc.nextInt();
        
        // Read in the board
        char board[][] = new char[n][];
        for( int i=0; i<n; i++ )
        {
            board[i] = sc.next().toCharArray();
        }
        
        // Look for the coordinates of the start ('K') 
        int starti = 0;
        int startj = 0;
        int kcount = 0, xcount = 0;
        for( int i=0; i<n; i++ ) for( int j=0; j<m; j++ )
        {
            if( board[i][j]=='K' )
            {
                starti = i;
                startj = j;
                ++kcount;
            }
            else if( board[i][j]=='X' )
            {
                ++xcount;
            }
        }

        // This is code the judges used to make sure that the input matched specs
        if( kcount!=1 ) System.err.println( "PANIC!! Number of Ks is " + kcount );
        if( xcount!=1 ) System.err.println( "PANIC!! Number of Xs is " + xcount );
        
        // The final answer.
        // If we never get to the target, the answer is -1
        int answer = -1;
        
        // Queue for the BFS
        LinkedList<State> q = new LinkedList<State>();
        
        // Starting state of the BFS is the starting coords, 0 moves
        q.add( new State( starti, startj, 0 ) );
        while( !q.isEmpty() )
        {
            State s = q.pollFirst();
            
            // Have we reached the target?
            if( board[s.i][s.j]=='X' )
            {
                answer = s.distance;
                break;
            }
            
            // Go through all of the possible knight moves
            for( int d=0; d<di.length; d++ )
            {
                // This is where the knight would end up
                int ii = s.i+di[d];
                int jj = s.j+dj[d];
                
                // Is it on the board?
                if( ii>=0 && ii<n && jj>=0 && jj<m )
                {
                    // Is it unoccupied?
                    if( board[ii][jj]=='.' )
                    {
                        // Mark it so we won't go there again.
                        board[ii][jj] = '#';
                        q.add( new State( ii, jj, s.distance+1) );
                    }
                    // Is it the target?
                    else if( board[ii][jj]=='X' )
                    {
                        q.add( new State( ii, jj, s.distance+1) );
                    }
                }
            } 
        }
        
        ps.println( answer );
    }
    
    /**
     * @param args
     */
    public static void main( String[] args ) throws Exception
    {
        new knightmoves_vanb().doit();
    }   
}