#include <bits/stdc++.h>
using namespace std;

#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")

#ifdef LOCAL
#include "lib/debug.h"
#else
#define debug(...) 42
#endif

void solve() {
    int n, m;
    cin >> n >> m;

    vector<string> grid(n);
    for(int i = 0; i < n; ++i)
        cin >> grid[i];

    int dj[] = {1, 0, -1, 0};
    int di[] = {0, 1, 0, -1};
    auto check = [&] (int i, int j) -> bool {
        return (i >= 0 && i < n && j >= 0 && j < m);
    };

    deque<vector<int64_t>> pq;
    const int64_t INF = 1e18;
    vector<vector<vector<int64_t>>> dist(n, vector<vector<int64_t>> (m, vector<int64_t> (4, INF)));
    vector<vector<vector<int>>> vis(n, vector<vector<int>> (m, vector<int> (4, 0)));
    dist[n - 1][m - 1][2] = 0;
    pq.push_front({0, n - 1, m - 1, 2});
    while(!pq.empty()) {
        auto nn = pq.front();
        pq.pop_front();
        if(vis[nn[1]][nn[2]][nn[3]])
            continue;
        vis[nn[1]][nn[2]][nn[3]] = 1;
        if(grid[nn[1]][nn[2]] == '.') {
            int new_i = nn[1] + di[nn[3]];
            int new_j = nn[2] + dj[nn[3]];
            if(check(new_i, new_j) && dist[new_i][new_j][nn[3]] > dist[nn[1]][nn[2]][nn[3]]) {
                dist[new_i][new_j][nn[3]] = dist[nn[1]][nn[2]][nn[3]];
                pq.push_front({-dist[new_i][new_j][nn[3]], new_i, new_j, nn[3]});
            }
        }
        else {
            for(int mv = 0; mv < 4; ++mv) {
                if(mv == nn[3]) {
                    int new_i = nn[1] + di[nn[3]];
                    int new_j = nn[2] + dj[nn[3]];
                    if(check(new_i, new_j) && dist[new_i][new_j][nn[3]] > dist[nn[1]][nn[2]][nn[3]]) {
                        dist[new_i][new_j][nn[3]] = dist[nn[1]][nn[2]][nn[3]];
                        pq.push_front({-dist[new_i][new_j][nn[3]], new_i, new_j, nn[3]});
                    }
                }
                else {
                    int new_i = nn[1] + di[mv];
                    int new_j = nn[2] + dj[mv];
                    if(check(new_i, new_j) && dist[new_i][new_j][mv] > 1 + dist[nn[1]][nn[2]][nn[3]]) {
                        dist[new_i][new_j][mv] = 1 + dist[nn[1]][nn[2]][nn[3]];
                        pq.push_back({-dist[new_i][new_j][mv], new_i, new_j, mv});
                    }
                }
            }
        }
    }

    int64_t ans = dist[0][0][2];
    cout << (ans != INF ? ans : -1) << "\n";
}

signed main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int t = 1;
    // cin >> t;

    for (int i = 1; i <= t; ++i) {
#ifdef LOCAL
        cout << "Case #" << i << endl;
        cerr << "Case #" << i << endl;
#endif
        solve();
    }

    return 0;
}