#include <bits/stdc++.h>
namespace orislib {
struct Edge {
  int from, to;
  int w;
  Edge(int from, int to, int w) : from(from), to(to), w(w) {}
  bool operator<(const Edge& e) const {
    return w != e.w ? w > e.w : from != e.from ? from < e.from : to < e.to;
  }
  static const int INF;
};
const int Edge::INF = INT_MAX;
}  // namespace orislib
using namespace std;
using namespace orislib;
const int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
const int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
const int Mod = 1000000000 + 0;
template <typename T>
inline T sq(T x) {
  return x * x;
}
template <typename T>
inline T In() {
  T x;
  cin >> x;
  return x;
}
template <typename T>
inline void Out(T& x) {
  cout << x;
}
template <typename T>
inline void sort(T& v) {
  sort(begin(v), end(v));
}
template <typename T>
inline void revs(T& v) {
  reverse(begin(v), end(v));
}
template <typename T>
inline void uniq(T& v) {
  sort(v);
  v.erase(unique(begin(v), end(v)), end(v));
}
template <typename T>
inline int ubnd(T& v, typename T::value_type x) {
  return upper_bound(begin(v), end(v), x) - begin(v);
}
template <typename T>
inline int lbnd(T& v, typename T::value_type x) {
  return lower_bound(begin(v), end(v), x) - begin(v);
}
template <typename T, typename F>
inline void inpt(T& v, int n, F f) {
  for (v.reserve(n); n--; v.emplace_back(f()))
    ;
}
template <typename T, typename F>
inline void show(T& v, F f, string d = " ", string e = "\n") {
  int i = 0;
  for (auto& x : v) i++ && (cout << d), f(x);
  cout << e;
}
template <typename T>
inline typename T::iterator minel(T& v) {
  return min_element(begin(v), end(v));
}
template <typename T>
inline typename T::iterator maxel(T& v) {
  return max_element(begin(v), end(v));
}
inline void fast_io() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
}
inline int in() {
  int x;
  scanf("%d", &x);
  return x;
}
inline long long pow_mod(long long a, long long k, long long m) {
  long long r = 1;
  for (; k > 0; a = a * a % m, k >>= 1)
    if (k & 1) r = r * a % m;
  return r;
}
inline long long mod_inv(long long a, long long p) {
  return pow_mod(a, p - 2, p);
}
void dijkstra(const std::vector<std::vector<Edge> >& g, int s,
              vector<Edge::int>& dist, vector<int>& prev) {
  const int V = g.size();
  prev.assign(V, -1);
  dist.assign(V, Edge::INF);
  dist[s] = 0;
  priority_queue<Edge> pq;
  for (pq.push(Edge(-2, s, 0)); !pq.empty();) {
    Edge c = pq.top();
    pq.pop();
    if (prev[c.to] != -1) continue;
    prev[c.to] = c.from;
    for (const auto& e : g[c.to]) {
      if (dist[e.to] > e.w + c.w) {
        dist[e.to] = e.w + c.w;
        pq.push(Edge(e.from, e.to, e.w + c.w));
      }
    }
  }
}
int main() {
  int w, h;
  while (w = in(), h = in()) {
    std::vector<std::vector<Edge> > g(w * h);
    char field[128][128];
    for (int i = 0; i < h; i++) scanf("%s", field[i]);
    int s;
    for (int i = 0; i < h; i++) {
      for (int j = 0; j < w; j++) {
        if (field[i][j] == '&') s = i * w + j;
        for (int d = 0; d < 4; d++) {
          int nx = j + dx[d], ny = i + dy[d];
          if (nx < 0 || w <= nx || ny < 0 || h <= ny) continue;
          g[i * w + j].emplace_back(i * w + j, ny * w + nx,
                                    field[ny][nx] == '#');
        }
      }
    }
    vector<int> dist, prev;
    dijkstra(g, s, dist, prev);
    int mini = 1000000;
    for (int i = 0; i < h; i++) {
      mini = min(mini, dist[i * w]);
      mini = min(mini, dist[i * w + w - 1]);
    }
    for (int i = 0; i < w; i++) {
      mini = min(mini, dist[i]);
      mini = min(mini, dist[(h - 1) * w + i]);
    }
    printf("%d\n", mini);
  }
  return 0;
}
