#include <iostream>
#include <algorithm>
#include <queue>
#include <utility>
using namespace std;

constexpr int INF = 1 << 29;

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

using P = pair<int, int>;

int N, M;
char field[111][111];

int solve() {
    int memo[111][111];
    for (int j = 0; j < M; ++j) { fill(memo[j], memo[j]+N, INF); }

    priority_queue<P> que;

    for (int j = 0; j < M; ++j) {
        for (int k = 0; k < N; ++k) {
            if (field[j][k] == '&') {
                memo[j][k] = 0;
                que.emplace(0, j*N + k);
            }
        }
    }

    while (!que.empty()) {
        P p = que.top(); que.pop();
        int cost = -p.first, x = p.second/N, y = p.second%N;

        if (cost > memo[x][y]) { continue; }

        char st = field[x][y];

        for (int d = 0; d < 4; ++d) {
            int nx = x+dx[d], ny = y+dy[d];
            if (nx < 0 || M <= nx || ny < 0 || N <= ny) { continue; }

            int next_cost = cost + (st == '#' && field[nx][ny] == '.');

            if (next_cost < memo[nx][ny]) {
                memo[nx][ny] = next_cost;
                que.emplace(-next_cost, nx*N+ny);
            }
        }
    }

    int ans = INF;
    for (int j = 0; j < M; ++j) {
        if (field[j][0] == '.') {
            ans = min(ans, memo[j][0]);
        }
        if (field[j][N-1] == '.') {
            ans = min(ans, memo[j][N-1]);
        }
    }
    for (int j = 0; j < N; ++j) {
        if (field[0][j] == '.') {
            ans = min(ans, memo[0][j]);
        }
        if (field[M-1][j] == '.') {
            ans = min(ans, memo[M-1][j]);
        }
    }
    return ans;
}

bool loop() {
    cin >> N >> M;
    if (N+M == 0) { return false; }
    for (int j = 0; j < M; ++j) { cin >> field[j]; }

    cout << solve() << endl;

    return true;
}

int main() { while (loop()); return 0; }