Problem: The earth is under an attack of a deadly virus. Luckily, prompt actions of the Ministry of Health against this emergency successfully confined the spread of the infection within a square grid of areas. Recently, public health specialists found an interesting pattern with regard to the transition of infected areas. At each step in time, every area in the grid changes its infection state according to infection states of its directly (horizontally, vertically, and diagonally) adjacent areas.

* An infected area continues to be infected if it has two or three adjacent infected areas.
* An uninfected area becomes infected if it has exactly three adjacent infected areas.
* An area becomes free of the virus, otherwise.



Your mission is to fight against the virus and disinfect all the areas. The Ministry of Health lets an anti-virus vehicle prototype under your command. The functionality of the vehicle is summarized as follows.

* At the beginning of each time step, you move the vehicle to one of the eight adjacent areas. The vehicle is not allowed to move to an infected area (to protect its operators from the virus). It is not allowed to stay in the same area.
* Following vehicle motion, all the areas, except for the area where the vehicle is in, change their infection states according to the transition rules described above.
Special functionality of the vehicle protects its area from virus infection even if the area is adjacent to exactly three infected areas. Unfortunately, this virus-protection capability of the vehicle does not last. Once the vehicle leaves the area, depending on the infection states of the adjacent areas, the area can be infected.
The area where the vehicle is in, which is uninfected, has the same effect to its adjacent areas as an infected area as far as the transition rules are concerned.



The following series of figures illustrate a sample scenario that successfully achieves the goal.

Initially, your vehicle denoted by @ is found at (1, 5) in a 5 × 5-grid of areas, and you see some infected areas which are denoted by #'s.

<image>

Firstly, at the beginning of time step 1, you move your vehicle diagonally to the southwest, that is, to the area (2, 4). Note that this vehicle motion was possible because this area was not infected at the start of time step 1.

Following this vehicle motion, infection state of each area changes according to the transition rules. The column "1-end" of the figure illustrates the result of such changes at the end of time step 1. Note that the area (3, 3) becomes infected because there were two adjacent infected areas and the vehicle was also in an adjacent area, three areas in total.

In time step 2, you move your vehicle to the west and position it at (2, 3).

Then infection states of other areas change. Note that even if your vehicle had exactly three infected adjacent areas (west, southwest, and south), the area that is being visited by the vehicle is not infected. The result of such changes at the end of time step 2 is as depicted in "2-end".

Finally, in time step 3, you move your vehicle to the east. After the change of the infection states, you see that all the areas have become virus free! This completely disinfected situation is the goal. In the scenario we have seen, you have successfully disinfected all the areas in three time steps by commanding the vehicle to move (1) southwest, (2) west, and (3) east.

Your mission is to find the length of the shortest sequence(s) of vehicle motion commands that can successfully disinfect all the areas.



Input

The input is a sequence of datasets. The end of the input is indicated by a line containing a single zero. Each dataset is formatted as follows.

n
a11 a12 ... a1n
a21 a22 ... a2n
...
an1 an2 ... ann


Here, n is the size of the grid. That means that the grid is comprised of n × n areas. You may assume 1 ≤ n ≤ 5. The rest of the dataset consists of n lines of n letters. Each letter aij specifies the state of the area at the beginning: '#' for infection, '.' for free of virus, and '@' for the initial location of the vehicle. The only character that can appear in a line is '#', '.', or '@'. Among n × n areas, there exists exactly one area which has '@'.

Output

For each dataset, output the minimum number of time steps that is required to disinfect all the areas. If there exists no motion command sequence that leads to complete disinfection, output -1. The output should not contain any other extra character.

Examples

Input

3
...
.@.
...
3
.##
.#.
@##
3
##.
#..
@..
5
....@
##...
#....
...#.
##.##
5
#...#
...#.
#....
...##
..@..
5
#....
.....
.....
.....
..@..
5
#..#.
#.#.#
.#.#.
....#
.#@##
5
..##.
..#..
#....
#....
.#@..
0


Output

0
10
-1
3
2
1
6
4


Input

3
...
.@.
...
3
.##
.#.
@##
3
.
..
@..
5
....@
...
....
...#.
.##
5
...#
...#.
....
...##
..@..
5
....
.....
.....
.....
..@..
5
..#.
.#.#
.#.#.
....#
.#@##
5
..##.
..#..
....
....
.#@..
0


Output

0
10
-1
3
2
1
6
4

Solution (in CPP):

Solution:
#include <cassert>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <vector>
using namespace std;

constexpr int dx[] = {-1, 0, 1, 1, 1, 0, -1, -1};
constexpr int dy[] = {-1, -1, -1, 0, 1, 1, 1, 0};


inline int encode(const vector<string> &state) {
	const int n = state.size();

	int index;
	int res = 0;

	for(int y = 0; y < n; ++y) {
		for(int x = 0; x < n; ++x) {
			res = (res << 1) + (state[y][x] == '#' ? 1 : 0);
			if(state[y][x] == '@') {
				index = x + y * n;
			}
		}
	}

	res |= (index << (n * n));
	return res;
}

inline vector<string> decode(int code, int n) {
	vector<string> res(n, string(n, '.'));
	for(int y = n - 1; y >= 0; --y) {
		for(int x = n - 1; x >= 0; --x) {
			if(code & 1) res[y][x] = '#';
			code >>= 1;
		}
	}

	res[code / n][code % n] = '@';
	return res;
}

inline bool out(int x, int y, int n) {
	return x < 0 || y < 0 || x >= n || y >= n;
}

vector<string> update(const vector<string> &state) {
	const int n = state.size();
	vector<string> res(n, string(n, '.'));

	for(int y = 0; y < n; ++y) {
		for(int x = 0; x < n; ++x) {
			if(state[y][x] == '@') {
				res[y][x] = '@';
				continue;
			}

			int cnt = 0;
			for(int d = 0; d < 8; ++d) {
				const int nx = x + dx[d];
				const int ny = y + dy[d];

				if(!out(nx, ny, n) && state[ny][nx] != '.') ++cnt;
			}

			if(cnt == 3 || (cnt == 2 && state[y][x] == '#')) {
				res[y][x] = '#';
			}
		}
	}

	return res;
}

int bfs(const vector<string> &start) {
	const int n = start.size();
	const int s = encode(start);
	const int goal_mask = (1 << (n * n)) - 1;

	if((s & goal_mask) == 0) return 0;

	unordered_map<int, int> dist;
	queue<int> que;

	dist.insert({s, 0});
	que.push(s);

	while(!que.empty()) {
		const int code = que.front();
		que.pop();

		const int current_dist = dist[code];
		const auto state = decode(code, n);
		const int x = (code >> (n * n)) % n;
		const int y = (code >> (n * n)) / n;

		for(int d = 0; d < 8; ++d) {
			const int nx = x + dx[d];
			const int ny = y + dy[d];

			if(out(nx, ny, n) || state[ny][nx] == '#') continue;

			vector<string> next_state(state);
			swap(next_state[ny][nx], next_state[y][x]);
			next_state = update(move(next_state));
			const int next_code = encode(next_state);

			if(!dist.count(next_code)) {
				if((next_code & goal_mask) == 0) return current_dist + 1;
				dist.insert({next_code, current_dist + 1});
				que.push(next_code);
			}
		}
	}

	return -1;
}

int main() {
	cin.tie(nullptr);
	ios::sync_with_stdio(false);

	int cnt = 0;
	for(int n; cin >> n && n;) {
		vector<string> start(n);
		for(auto &e : start) cin >> e;
		cout << bfs(start) << endl;
	}

	return EXIT_SUCCESS;
}