#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <string.h>
#include <set>
#include <queue>

using namespace std;

struct Field {
  int state;
  char x;
  char y;
  int cost;
  bool operator<(const Field &rhs) const {
    if (state != rhs.state) { return state < rhs.state; }
    if (x != rhs.x) { return x < rhs.x; }
    return y < rhs.y;
  }
};

char input[10][10];
int now[5][5];
int temp[5][5];
int temp2[5][5];
int n;
const int dx[8] = { 1, 1,  1,  0, -1, -1, -1, 0 };
const int dy[8] = { 1, 0, -1, -1, -1,  0,  1, 1 };
set<Field> visit;

void print_now(int px, int py) {
  for (int y = 0; y < n; y++) {
    for (int x = 0; x < n; x++) {
      if (temp[y][x] == 1) {
        putchar('#');
      } else if (px == x && py == y) {
        putchar('@');
      } else {
        putchar('.');
      }
    }
    puts("");
  }
  puts("");
}

void encode(Field &field, int x, int y) {
  field.x = x;
  field.y = y;
  field.cost++;
  temp[y][x] = 0;
  field.state = 0;
  for (int y = 0; y < n; y++) {
    for (int x = 0; x < n; x++) {
      if (temp[y][x] == 1) {
        field.state |= 1 << (x + y * n);
      }
    }
  }
}

void decode(Field field, int &x, int &y) {
  x = field.x;
  y = field.y;
  for (int y = 0; y < n; y++) {
    for (int x = 0; x < n; x++) {
      temp[y][x] = (field.state >> (x + y * n)) & 1;
    }
  }
}


int get_sum(int x, int y) {
  int sum = 0;
  for (int i = 0; i < 8; i++) {
    int nx = x + dx[i];
    int ny = y + dy[i];
    if (nx < 0 || nx >= n || ny < 0 || ny >= n) { continue; }
    sum += temp[ny][nx];
  }
  return sum;
}

void lifegame(int x, int y) {
  temp[y][x] = 1;
  for (int y = 0; y < n; y++) {
    for (int x = 0; x < n; x++) {
      int sum = get_sum(x, y);
      if (temp[y][x] == 0 && sum == 3) {
        temp2[y][x] = 1;
      } else if (temp[y][x] == 1 && (sum == 2 || sum == 3)) {
        temp2[y][x] = 1;
      } else {
        temp2[y][x] = 0;
      }
    }
  }
  memcpy(temp, temp2, sizeof(temp));
}

bool end() {
  for (int y = 0; y < n; y++) {
    for (int x = 0; x < n; x++) {
      if (temp[y][x] == 1) { return false; }
    }
  }
  return true;
}

int main() {
  while (scanf("%d", &n), n) {
    int sx, sy;
    for (int y = 0; y < n; y++) {
      scanf("%s", input[y]);
      for (int x = 0; x < n; x++) {
        if (input[y][x] == '.') {
          temp[y][x] = 0;
        } else if (input[y][x] == '#') {
          temp[y][x] = 1;
        } else {
          temp[y][x] = 0;
          sx = x;
          sy = y;
        }
      }
    }
    queue<Field> que;
    Field field;
    encode(field, sx, sy);
    field.cost = 0;
    que.push(field);
    visit.clear();
    visit.insert(field);
    while (!que.empty()) {
      field = que.front();
      que.pop();
      int x, y;
      decode(field, x, y);
      if (end()) { printf("%d\n", field.cost); goto next; }
      memcpy(now, temp, sizeof(now));
      //print_now(x, y);
      for (int i = 0; i < 8; i++) {
        int nx = x + dx[i];
        int ny = y + dy[i];
        if (nx < 0 || nx >= n || ny < 0 || ny >= n) { continue; }
        if (now[ny][nx] == 1) { continue; }
        Field next = field;
        memcpy(temp, now, sizeof(temp));
        lifegame(nx, ny);
        encode(next, nx, ny);
        if (visit.find(next) != visit.end()) { continue; }
        visit.insert(next);
        que.push(next);
      }
    }
    puts("-1");
next:;
  }
}

Measured memory_bytes: 1868