#include<bits/stdc++.h>

using namespace std;

#define endl '\n'
#define PB push_back

typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef vector<ld> vld;

typedef pair<ld, pii> Node;

const ld INF = 1e9;

vector<vld> dis;

int h, w;

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

int check_valid(int x, int y) {
    if (x < 0 || y < 0 || x > 2*h || y > 2*w) {
        return 0;
    }
    return 1;
}

vector<string> vs;
ld sq, cir, tsq;

void dijkstra() {
    priority_queue<Node, vector<Node>, greater<Node>> pq;
    int x = 0, y = 1;
    dis[x][y] = sq;
    pq.push({dis[x][y], {x,y}});
    x = 1, y = 0;
    dis[x][y] = sq;
    pq.push({dis[x][y], {x,y}});

    pii des1 = make_pair(2*h-1, 2*w), des2 = make_pair(2*h, 2*w-1);
    while (!pq.empty()) {
        auto [dist, u] = pq.top();
        pq.pop();
        if (u == des1 || u == des2) break;
        auto [x,y] = u;
        if (dist != dis[x][y]) {
            continue;
        }

//        cerr << x << " " << y << " " << dist << '\n';

        int xx, yy;

        if (x%2 == 0 && y%2==1) {
            // border node

            // baame shoja
            xx = x;
            yy = y - 2;
            if (check_valid(xx,yy)) {
                if (dist + tsq < dis[xx][yy]) {
                    dis[xx][yy] = dist+tsq;
                    pq.push({dis[xx][yy], {xx,yy}});
                }
            }

            // daane shoja
            xx = x;
            yy = y + 2;
            if (check_valid(xx,yy)) {
                if (dist + tsq < dis[xx][yy]) {
                    dis[xx][yy] = dist+tsq;
                    pq.push({dis[xx][yy], {xx,yy}});
                }
            }
        }
        else {
            // middle node
            // upore shoja
            xx = x - 2;
            yy = y;
            if (check_valid(xx,yy)) {
                if (dist + tsq < dis[xx][yy]) {
                    dis[xx][yy] = dist+tsq;
                    pq.push({dis[xx][yy], {xx,yy}});
                }
            }

            // niche shoja
            xx = x+2;
            yy = y;
            if (check_valid(xx,yy)) {
                if (dist + tsq < dis[xx][yy]) {
                    dis[xx][yy] = dist+tsq;
                    pq.push({dis[xx][yy], {xx,yy}});
                }
            }
        }

        // top left
        xx = x-1;
        yy = y-1;
        if (check_valid(xx,yy)) {
            ld d;
            if (x%2 == 0 && y%2==1) {
                // border node
                int r = x/2;
                int c = (y+1)/2;
                if (vs[r][c] == 'O') {
                    d = cir;
                }
                else {
                    d = tsq;
                }
            }
            else {
                // middle node
                int r = (x+1)/2;
                int c = y/2;
                if (vs[r][c] == 'O') {
                    d = cir;
                }
                else {
                    d = tsq;
                }
            }
            if (dist + d < dis[xx][yy]) {
                dis[xx][yy] = dist+d;
                pq.push({dis[xx][yy], {xx,yy}});
            }
        }

        // top right
        xx = x-1;
        yy = y+1;
        if (check_valid(xx,yy)) {
            ld d;
            if (x%2 == 0 && y%2==1) {
                // border node
                int r = x/2;
                int c = (y+1)/2;
                if (vs[r][c] == 'O') {
                    d = cir;
                }
                else {
                    d = tsq;
                }
            }
            else {
                // middle node
                int r = (x+1)/2;
                int c = (y/2)+1;
                if (vs[r][c] == 'O') {
                    d = cir;
                }
                else {
                    d = tsq;
                }
            }
            if (dist + d < dis[xx][yy]) {
                dis[xx][yy] = dist+d;
                pq.push({dis[xx][yy], {xx,yy}});
            }
        }

        // bottom right
        xx = x+1;
        yy = y+1;
        if (check_valid(xx,yy)) {
            ld d;
            if (x%2 == 0 && y%2==1) {
                // border node
                int r = (x/2)+1;
                int c = (y+1)/2;
                if (vs[r][c] == 'O') {
                    d = cir;
                }
                else {
                    d = tsq;
                }
            }
            else {
                // middle node
                int r = (x+1)/2;
                int c = (y/2)+1;
                if (vs[r][c] == 'O') {
                    d = cir;
                }
                else {
                    d = tsq;
                }
            }
            if (dist + d < dis[xx][yy]) {
                dis[xx][yy] = dist+d;
                pq.push({dis[xx][yy], {xx,yy}});
            }
        }

        // bottom left
        xx = x+1;
        yy = y-1;
        if (check_valid(xx,yy)) {
            ld d;
            if (x%2 == 0 && y%2==1) {
                // border node
                int r = (x/2)+1;
                int c = (y+1)/2;
                if (vs[r][c] == 'O') {
                    d = cir;
                }
                else {
                    d = tsq;
                }
            }
            else {
                // middle node
                int r = (x+1)/2;
                int c = (y/2);
                if (vs[r][c] == 'O') {
                    d = cir;
                }
                else {
                    d = tsq;
                }
            }
            if (dist + d < dis[xx][yy]) {
                dis[xx][yy] = dist+d;
                pq.push({dis[xx][yy], {xx,yy}});
            }
        }

    }
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);

    cin >> h >> w;
    vs = vector<string> (h+1);
    for (int i = 1; i <= h; i++) {
        cin >> vs[i];
        vs[i] = "$" + vs[i];
    }

    sq = 5;
    cir = acos(-1.0) * 2.5;
    tsq = 10;

    dis = vector<vld>(2*h+1, vld(2*w+1, INF));
    dijkstra();
    ld ans = min(dis[2*h-1][2*w], dis[2*h][2*w-1]);
    ans += sq;
    cout << fixed << setprecision(10) << ans << endl;
    return 0;
}