#include <vector>
#include <cctype>

enum elems { A_UNINIT, A_WALL, A_FINISH };

using MatrixC = std::vector<elems>;
using TestC = std::vector<unsigned char>;
using Matrix = std::vector<MatrixC>;
using Test = std::vector<TestC>;

struct TestInput {
	TestInput(size_t h_, size_t w_) : h(h_), w(w_), Amount(Matrix(h_, MatrixC(w_, A_UNINIT))) {}
	void inputAmount();
	size_t height() const { return h; }
	size_t width() const { return w; }

	Matrix Amount;
	Test testArr;        // To be initialised
	const size_t h {};
	const size_t w {};
};

void TestInput::inputAmount() {
	for (size_t i {}; i < height(); ++i)
		for (size_t j {}; j < width(); ++j)
			if (toupper(testArr[i][j]) == 'X')
				Amount[i][j] = A_WALL;
			else if (toupper(testArr[i][j]) == 'A')
				Amount[i][j] = A_FINISH;
}

#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <vector>
#include <string>
#include <queue>
#include <utility>
using namespace std;

//----------------------------------------------------------

vector<string> readInput( istream &in )
{
   vector<string> result;
   for ( string line; getline( in, line ); ) result.push_back( line );
   return result;
}

//----------------------------------------------------------

void drawSolution( const vector< vector<int> > &F, int W = 1 )
{
   for ( auto &row : F )
   {
      for ( int e : row )
      {
         if ( e < 0 ) cout << setw( W ) << '.';
         else         cout << setw( W ) << e;
      }
      cout << '\n';
   }
}

//----------------------------------------------------------

vector< vector<int> > fill( const vector<string> &board )
{
   const vector< pair<int,int> > jp = { {-1,-1}, {-1,0}, {-1,1}, {0,-1}, {0,1}, {1,-1}, {1,0}, {1,1} };

   int rows = board.size(), cols = board[0].size();
   queue< pair<int,int> > Q;
   vector< vector<int> > F( rows, vector<int>( cols, -99 ) );

   // Set starting points (as 0) and barriers (as -1)
   for ( int i = 0; i < rows; i++ )
   {
      for ( int j = 0; j < cols; j++ )
      {
         if ( board[i][j] == 'A' )
         {
            F[i][j] = 0;
            Q.push( { i, j } );
         }
         else if ( board[i][j] == 'X' )
         {
            F[i][j] = -1;
         }
      }
   }

   // Check adjacent points to current front-of-queue
   while( !Q.empty() )
   {
      auto pr = Q.front();   Q.pop();
      int i = pr.first, j = pr.second;
      int nextValue = F[i][j] + 1;
      for ( int n = 0; n < jp.size(); n++ )
      {
         int ii = i + jp[n].first, jj = j + jp[n].second;                // adjacent point
         if ( ii < 0 || ii >= rows || jj < 0 || jj >= cols ) continue;   // if outside domain then ignore
         if ( F[ii][jj] < -1 )                                           // not yet set
         {
            F[ii][jj] = nextValue;                                       // set or improve value
            Q.push( { ii, jj } );                                        // add to current front line
         }
      }
   }

   return F;
}

//----------------------------------------------------------

int main()
{
// ifstream in( "input.txt" );              // for real
   istringstream in( "..............\n"     // for demo
                     "..............\n"
                     "..............\n"
                     "..............\n"
                     ".......X......\n"
                     ".......X......\n"
                     "...A...X......\n"
                     "...A...X......\n"
                     ".......X......\n"
                     ".......X......\n" );

   vector<string> board = readInput( in );
   vector< vector<int> > F = fill( board );
   drawSolution( F, 3 );
}