#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
//@etohari
using namespace std;
using namespace __gnu_pbds;

#define my_wife "She belongs to another guy"
#define bit(mask,i) ((mask >> i)&1)
#define cntbit(mask) __builtin_popcountll(mask)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define uniquev(v) sort(all(v)), (v).resize(unique(all(v)) - (v).begin())
#define sz(s) (int32_t)s.size()
#define __lcm(a,b) ((int64_t)a / __gcd(a, b) * b)
#define rand(l, r) uniform_int_distribution < int64_t > (l, r)(rng)
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define ordered_set tree < int32_t, null_type, less < int32_t >, rb_tree_tag,tree_order_statistics_node_update >

void etohari();
void init(){};

signed main() {
        cin.tie(NULL)->sync_with_stdio(false);
        // https://www.facebook.com/hai290605
        constexpr bool MULTITEST = 0;
        // https://codeforces.com/profile/I_Will_Marry_Ngoc
        init();
        int32_t test = 1;
        if (MULTITEST) cin >> test;
        for (int32_t i_test = 1; i_test <= test; i_test ++){
                etohari();
                cout << "\n";
        }
        return (0 ^ 0);
}

template < class T > bool minimum(T& a, T& b) { return b < a ? a = b, 1 : 0; }
template < class T > bool maximum(T& a, T& b) { return a < b ? a = b, 1 : 0; }

constexpr int32_t MAXN = 1e3 + 10;
constexpr int32_t MAXM = 1e6 + 10; 
constexpr int32_t MOD = 1e9 + 7;
constexpr int32_t INF = 0x3f3f3f3f;
constexpr long double PI = 3.14159265358979323846;

constexpr int16_t DR[] = { };
constexpr int16_t DC[] = { };

template<typename T> using reverse_pq = priority_queue<T, vector<T>, greater<T> >;

template < class T >
class dijkstra_t{
public: 
        dijkstra_t(const int& n) : adj(n), dist(n) {}

        void add_edge(int u, int v, T c){
                // cout << u << " " << v << " " << c << "\n";
                v--; u--;
                adj[u].emplace_back(v, c);
                adj[v].emplace_back(u, c);
        }        

        T solve(int s, int t){
                s--, t--;
                fill(all(dist), INF);
                dist[s] = 0;
                reverse_pq < pair < T, int > > qe;
                qe.emplace(0, s);
                while (!qe.empty()){
                        auto [du, u] = qe.top();
                        qe.pop();
                        for (auto [v, c] : adj[u]){
                                auto x = du + c;
                                if (minimum(dist[v], x))qe.emplace(dist[v], v);
                        }
                }
                return dist[t];
        }
private:
        vector < T > dist;
        vector < vector < pair < int, T > > > adj;
};

int n, m;
char a[MAXN][MAXN];

void etohari(){ 
        cin >> n >> m;

        for (int i = 1; i <= n; i ++){
                for (int j = 1; j <= m; j ++){
                        cin >> a[i][j];
                }
        }

        dijkstra_t < long double > dk((2 * n + 1) * (2 * m + 1));

        int max_n = 2 * n + 1;
        int max_m = 2 * m + 1;
        for (int i = 1; i <= n; i ++){
                for (int j = 1; j <= m; j ++){
                        int x1 = ((i - 1) * 2) * max_m + (j - 1) * 2 + 1;
                        int x2 = ((i - 1) * 2 + 1) * max_m + (j - 1) * 2 + 1;
                        int x3 = ((i - 1) * 2 + 2) * max_m + (j - 1) * 2 + 1;
                        // cout << x1 << " " << x2 << " " << x3 << "\n";
                        long double c1 = 5;
                        long double c2 = a[i][j] == 'X' ? 10 : PI * 10.0 / 4.0;
                        dk.add_edge(x1, x1 + 1, c1);
                        dk.add_edge(x1 + 1, x1 + 2, c1);
                        dk.add_edge(x1, x2, c1);
                        dk.add_edge(x2, x3, c1);
                        dk.add_edge(x3, x3 + 1, c1);
                        dk.add_edge(x3 + 1, x3 + 2, c1);
                        dk.add_edge(x1 + 2, x2 + 2, c1);
                        dk.add_edge(x2 + 2, x3 + 2, c1);
                        dk.add_edge(x1 + 1, x2, c2);
                        dk.add_edge(x1 + 1, x2 + 2, c2);
                        dk.add_edge(x3 + 1, x2, c2);
                        dk.add_edge(x3 + 1, x2 + 2, c2);
                }
        }

        cout << fixed << setprecision(20) << dk.solve(1, (2 * n + 1) * (2 * m + 1));     
}