// The "problem1" class.
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.StringTokenizer;
import java.util.Vector;

public class problem1
{
    public static File inputFile = new File ("DATA4.txt");
    public static File outputFile = new File ("OUT4.txt");
    public static char[] [] maze = new char [8] [8];
    public static char[] [] mazeOrg = new char [8] [8];
    public static int[] A = new int [2]; //x, y
    public static int[] Aorg = new int [2];
    public static int[] B = new int [2]; //x, y

    public static void main (String[] args) throws Exception
    {
	FileReader inFile = new FileReader (inputFile);
	BufferedReader in = new BufferedReader (inFile);

	FileWriter outFile = new FileWriter (outputFile);
	BufferedWriter out = new BufferedWriter (outFile);

	String inputLine;
	while ((inputLine = in.readLine ()) != null)
	{
	    try
	    {
		for (int i = 0 ; i != 8 ; i++)
		{
		    for (int o = 0 ; o != 8 ; o++)
		    {
			maze [i] [o] = inputLine.charAt (o);
			mazeOrg [i] [o] = inputLine.charAt (o);
		    }
		    inputLine = in.readLine ();
		}
	    }
	    catch (Exception ex)
	    {
	    }



	    // for (int i = 0; i != 8; i++)
	    // {
	    //     for (int o = 0; o != 8; o++)
	    //     {
	    //         System.out.print(maze[i][o]);
	    //
	    //     System.out.println();
	    // }
	    A = findX ('A');
	    Aorg = findX ('A');
	    B = findX ('B');

	    int amount[] = new int [8];
	    int vertDistance = B [0] - A [0];
	    int horzDistance = B [1] - A [1];

	    amount [0] = findB (0);


	    amount [1] = findB (1);
	    restore ();

	    amount [2] = findB (2);
	    restore ();


	    amount [3] = findB (3);
	    restore ();

	    amount [4] = findB (4);
	    restore ();

	    amount [5] = findB (5);
	    restore ();

	    amount [6] = findB (6);
	    restore ();

	    amount [7] = findB (7);


	    int min = 100;

	    for (int i = 0 ; i != 8 ; i++)
	    {
		if (amount[i] < 4)
		{
		    continue;
		}
		
		else if(amount [i] < min)
		{
		    min = amount[i];
		}
	    }
	    
	    out.write(Integer.toString(min));
	    out.newLine();
	}
	
	out.close();
    } // main method


    public static void restore ()
    {
	for (int i = 0 ; i != 8 ; i++)
	{
	    for (int o = 0 ; o != 8 ; o++)
	    {
		maze [i] [o] = mazeOrg [i] [o];
	    }
	}

	A [0] = Aorg [0];
	A [1] = Aorg [1];
    }


    public static int findB (int direction)  //0 - up, 1 - upright, 2 - right, 3 - rightdown, 4 - down, 5 - downleft, 6 - left, 7 - leftup
    {
	int vertDistance = B [0] - A [0];
	int horzDistance = B [1] - A [1];
	int amount = 0;

	if (isAonB ())
	{
	    return amount;
	}
	else
	{
	    switch (direction)
	    {
		case 0: //Up
		    amount++;

		    if (A [0] == 0)
		    {
			amount += findB (2);
			break;
		    }

		    if (maze [A [0] - 1] [A [1]] == '@')
		    {
			return amount;
		    }

		    if (maze [A [0] - 1] [A [1]] == '#' || maze [A [0] - 1] [A [1]] == '@') //up
		    {
			amount += findB (1);
			break;
		    }

		    maze [A [0]] [A [1]] = '@';
		    maze [--A [0]] [A [1]] = 'A';

		    amount += findB (0);

		    break;
		case 1: //Up right
		    amount++;

		    if (A [0] == 0) //check vert
		    {
			amount += findB (2);
			break;
		    }

		    if (A [1] == 7) //check right
		    {
			amount += findB (4);
			break;
		    }

		    if (maze [A [0] - 1] [A [1] + 1] == '@')
		    {
			return amount;
		    }

		    if (maze [A [0] - 1] [A [1] + 1] == '#' || maze [A [0] - 1] [A [1] + 1] == '@') //up right
		    {
			amount += findB (2);
			break;
		    }

		    maze [A [0]] [A [1]] = '@';
		    maze [--A [0]] [++A [1]] = 'A';

		    amount += findB (1);

		    break;
		case 2: //right
		    amount++;

		    if (A [1] == 7)
		    {
			amount += findB (4);
			break;
		    }

		    if (maze [A [0]] [A [1] + 1] == '@')
		    {
			return amount;
		    }

		    if (maze [A [0]] [A [1] + 1] == '#' || maze [A [0]] [A [1] + 1] == '@') //right
		    {
			amount += findB (3);
			break;
		    }

		    maze [A [0]] [A [1]] = '@';
		    maze [A [0]] [++A [1]] = 'A';

		    amount += findB (2);

		    break;
		case 3: //rightdown
		    amount++;

		    if (A [1] == 7) //check right
		    {
			amount += findB (4);
			break;
		    }

		    if (A [0] == 7) //check down
		    {
			amount += findB (6);
			break;
		    }

		    if (maze [A [0] + 1] [A [1] + 1] == '@')
		    {
			return amount;
		    }

		    if (maze [A [0] + 1] [A [1] + 1] == '#' || maze [A [0] + 1] [A [1] + 1] == '@') //rightdown
		    {
			amount += findB (4);
			break;
		    }

		    maze [A [0]] [A [1]] = '@';
		    maze [++A [0]] [++A [1]] = 'A';

		    amount += findB (3);

		    break;
		case 4: //down
		    amount++;

		    if (A [0] == 7) //check down
		    {
			amount += findB (6);
			break;
		    }

		    if (maze [A [0] + 1] [A [1]] == '@')
		    {
			return amount;
		    }

		    if (maze [A [0] + 1] [A [1]] == '#' || maze [A [0] + 1] [A [1]] == '@') //down
		    {
			amount += findB (5);
			break;
		    }

		    maze [A [0]] [A [1]] = '@';
		    maze [++A [0]] [A [1]] = 'A';

		    amount += findB (4);

		    break;
		case 5: //downleft
		    amount++;

		    if (A [0] == 7) //check down
		    {
			amount += findB (6);
			break;
		    }

		    if (A [1] == 0) //check left
		    {
			amount += findB (0);
			break;
		    }

		    if (maze [A [0] + 1] [A [1] - 1] == '@')
		    {
			return amount;
		    }

		    if (maze [A [0] + 1] [A [1] - 1] == '#' || maze [A [0] + 1] [A [1] - 1] == '@') //downleft
		    {
			amount += findB (6);
			break;
		    }

		    maze [A [0]] [A [1]] = '@';
		    maze [++A [0]] [--A [1]] = 'A';

		    amount += findB (5);

		    break;
		case 6: //left
		    amount++;

		    if (A [1] == 0) //check left
		    {
			amount += findB (0);
			break;
		    }

		    if (maze [A [0]] [A [1] - 1] == '@')
		    {
			return amount;
		    }

		    if (maze [A [0]] [A [1] - 1] == '#' || maze [A [0]] [A [1] - 1] == '@') //left
		    {
			amount += findB (2);
			break;
		    }

		    maze [A [0]] [A [1]] = '@';
		    maze [A [0]] [--A [1]] = 'A';

		    amount += findB (6);

		    break;
		case 7: //leftup
		    amount++;

		    if (A [0] == 0) //check up
		    {
			amount += findB (3);
			break;
		    }

		    if (A [1] == 0) //check left
		    {
			amount += findB (0);
			break;
		    }

		    if (maze [A [0] - 1] [A [1] - 1] == '@')
		    {
			return amount;
		    }

		    if (maze [A [0] - 1] [A [1] - 1] == '#' || maze [A [0] - 1] [A [1] - 1] == '@') //upleft
		    {
			amount += findB (0);
			break;
		    }

		    maze [A [0]] [A [1]] = '@';
		    maze [--A [0]] [--A [1]] = 'A';

		    amount += findB (7);

		    break;
		default:
		    System.out.println ("error");
		    break;
	    }
	}

	return amount;
    }


    public static boolean isAonB ()
    {
	return (A [0] == B [0] && A [1] == B [1]);
    }


    public static boolean isDirectInFront ()
    {
	int vertDistance = B [0] - A [0];
	int horzDistance = B [1] - A [1];

	return (vertDistance == 1 || horzDistance == 1);
    }


    public static int[] findX (char x)
    {
	int found[] = new int [2];

	for (int i = 0 ; i != 8 ; i++)
	{
	    for (int o = 0 ; o != 8 ; o++)
	    {
		if (maze [i] [o] == x)
		{
		    found [0] = i;
		    found [1] = o;
		}
	    }
	}

	return found;
    }
} // problem1 class