#include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>

#define el '\n'
#define FIO ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);

using namespace std;
using namespace __gnu_pbds;

typedef long long ll;
typedef long double ld;
typedef complex<ld> pt;
typedef unsigned long long ull;

template<typename T, typename X>
using hashTable = gp_hash_table<T, X>;
template<typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template<typename T>
using ordered_multiset = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;

// mt19937_64 for long long
mt19937 rng(std::chrono::system_clock::now().time_since_epoch().count());

const ld eps = 1e-8;
const int N = 7e2 + 5;

int dcmp(ld a, ld b)
{
    // a == b : 0
    // a != b : != 0
    // a > b : 1
    // a < b : -1
    // a >= b : != -1
    // a <= b : != 1
    return fabs(a - b) <= eps ? 0 : a < b ? -1 : 1;
}

struct Node
{
    ld dist;
    int i, j, st;

    Node(ld dist, int x, int y, int state) : dist(dist), i(x), j(y), st(state)
    {}

    const bool operator<(const Node &other) const
    {
        return dist > other.dist;
    }
};

int n, m;
ld d[N][N][4];
char grid[N][N];
const ld curve = 2.5 * acos(-1);

ld dijkstra()
{
    priority_queue<Node> pq;
    pq.push(Node(5.0, 1, 1, 0)), d[1][1][0] = 5.0;
    pq.push(Node(5.0, 1, 1, 3)), d[1][1][3] = 5.0;

    while(pq.size())
    {
        auto it = pq.top();
        pq.pop();

        ld dist;
        int i, j, st;
        dist = it.dist, i = it.i, j = it.j, st = it.st;

        
        if(dcmp(dist, d[i][j][st]) != 0)
            continue;


        ld newC, step;
        if(grid[i][j] == 'X')
            step = 10.0;
        else
            step = curve;

        for(int nxtState = 0, k; nxtState < 4; nxtState++)
        {
            k = abs(st - nxtState);
            k = min(k, 4 - k);

            newC = dist + step * k;
            if(dcmp(d[i][j][nxtState], newC) == 1)
            {
                d[i][j][nxtState] = newC;
                pq.push(Node(newC, i, j, nxtState));
            }
        }

        if(st == 0)
        {
            if(i - 1 >= 1 && dcmp(d[i - 1][j][2], dist) == 1)
            {
                d[i - 1][j][2] = dist;
                pq.push(Node(dist, i - 1, j, 2));
            }

            if(j + 1 <= m && dcmp(d[i][j + 1][0], dist + 10.0) == 1)
            {
                d[i][j + 1][0] = dist + 10.0;
                pq.push(Node(dist + 10.0, i, j + 1, 0));
            }

            if(j - 1 >= 1 && dcmp(d[i][j - 1][0], dist + 10.0) == 1)
            {
                d[i][j - 1][0] = dist + 10.0;
                pq.push(Node(dist + 10.0, i, j - 1, 0));
            }
        }
        else if(st == 1)
        {
            if(j + 1 <= m && dcmp(d[i][j + 1][3], dist) == 1)
            {
                d[i][j + 1][3] = dist;
                pq.push(Node(dist, i, j + 1, 3));
            }

            if(i + 1 <= n && dcmp(d[i + 1][j][1], dist + 10.0) == 1)
            {
                d[i + 1][j][1] = dist + 10.0;
                pq.push(Node(dist + 10.0, i + 1, j, 1));
            }

            if(i - 1 >= 1 && dcmp(d[i - 1][j][1], dist + 10.0) == 1)
            {
                d[i - 1][j][1] = dist + 10.0;
                pq.push(Node(dist + 10.0, i - 1, j, 1));
            }

        }
        else if(st == 2)
        {
            if(i + 1 <= n && dcmp(d[i + 1][j][0], dist) == 1)
            {
                d[i + 1][j][0] = dist;
                pq.push(Node(dist, i + 1, j, 0));
            }

            if(j + 1 <= m && dcmp(d[i][j + 1][2], dist + 10.0) == 1)
            {
                d[i][j + 1][2] = dist + 10.0;
                pq.push(Node(dist + 10.0, i, j + 1, 2));
            }

            if(j - 1 >= 1 && dcmp(d[i][j - 1][2], dist + 10.0) == 1)
            {
                d[i][j - 1][2] = dist + 10.0;
                pq.push(Node(dist + 10.0, i, j - 1, 2));
            }
        }
        else
        {
            if(j - 1 >= 1 && dcmp(d[i][j - 1][1], dist) == 1)
            {
                d[i][j - 1][1] = dist;
                pq.push(Node(dist, i, j - 1, 1));
            }

            if(i + 1 <= n && dcmp(d[i + 1][j][3], dist + 10.0) == 1)
            {
                d[i + 1][j][3] = dist + 10.0;
                pq.push(Node(dist + 10.0, i + 1, j, 3));
            }

            if(i - 1 >= 1 && dcmp(d[i - 1][j][3], dist + 10.0) == 1)
            {
                d[i - 1][j][3] = dist + 10.0;
                pq.push(Node(dist + 10.0, i - 1, j, 3));
            }
        }
    }
    return min(d[n][m][1], d[n][m][2]) + 5.0;
}

void doWork()
{
    char c;
    cin >> n >> m;
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            cin >> grid[i][j];
            for(int k = 0; k < 4; k++)
                d[i][j][k] = 1e18;
        }
    }
    cout << fixed << setprecision(12) << dijkstra();
}

signed main()
{
    FIO
    int T = 1;
//    cin >> T;
    for(int i = 1; i <= T; i++)
        doWork();
}