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

#define fast ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define ll long long
#define ld long double
#define el "\n"
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define ordered_multiset tree<ll, null_type,less_equal<ll>, rb_tree_tag, tree_order_statistics_node_update>
using namespace __gnu_pbds;
using namespace std;
const ll N = 700 + 10, INF = 1e18;
const ld pi = acos(-1);
const int mod = 1e9 + 7, LOG = 20;
const ld eps = 1e-4;
int dx[] = {0, -1, 0, 1, -1, 1, -1, 1};
int dy[] = {-1, 0, 1, 0, 1, -1, -1, 1};
ll n, m, k, x, y;
ld sidecircle = 0.5 * pi * 5;
ld dis[N][N][10], vis[N][N][10];
char grid[N][N];

void zbtsquare(int x, int y) {
    ld cur;
    for (int i = 0; i < 8; i++) {
        cur = 0;
        for (int j = i; j < i + 8; j++) {
            dis[x][y][j % 8] = min(cur + dis[x][y][i], dis[x][y][j % 8]);
            cur += 5;
        }
        cur = 0;
        for (int j = i; j > i - 8; j--) {
            dis[x][y][(j + 8) % 8] = min(cur + dis[x][y][i], dis[x][y][(j + 8) % 8]);
            cur += 5;
        }
    }
}

void zbtcircle(int x, int y) {
    ld cur;
    for (int i = 1; i < 8; i += 2) {
        cur = 0;
        for (int j = i; j < i + 8; j += 2) {
            //cout << x << " " << y << " " << j << " " << cur + dis[x][y][i] << el;
            dis[x][y][j % 8] = min(cur + dis[x][y][i], dis[x][y][j % 8]);
            cur += sidecircle;
        }
        cur = 0;
        for (int j = i; j > i - 8; j -= 2) {
            //cout << x << " " << y << " " << j << " " << cur + dis[x][y][i] << el;
            dis[x][y][(j + 8) % 8] = min(cur + dis[x][y][i], dis[x][y][(j + 8) % 8]);
            cur += sidecircle;
        }
    }
}

bool valid(int x, int y) {
    return (x >= 1 && x <= n && y >= 1 && y <= m);
}

void trantition(int x, int y, priority_queue<pair<ld, pair<pair<int, int>, int>>> &pq) {
    if (valid(x + 1, y - 1)) {
        if (dis[x + 1][y - 1][2] > dis[x][y][6]) {
            dis[x + 1][y - 1][2] = dis[x][y][6];
            pq.push({-dis[x + 1][y - 1][2], {{x + 1, y - 1}, 2}});
        }
    }
    if (valid(x + 1, y - 1)) {
        if (dis[x][y + 1][0] > dis[x][y][2]) {
            dis[x][y + 1][0] = dis[x][y][2];
            pq.push({-dis[x][y + 1][0], {{x, y + 1}, 0}});
        }
        if (dis[x][y + 1][7] > dis[x][y][3]) {
            dis[x][y + 1][7] = dis[x][y][3];
            pq.push({-dis[x][y + 1][7], {{x, y + 1}, 7}});
        }
        if (dis[x][y + 1][6] > dis[x][y][4]) {
            dis[x][y + 1][6] = dis[x][y][4];
            pq.push({-dis[x][y + 1][6], {{x, y + 1}, 6}});
        }
    }
    if (valid(x + 1, y + 1)) {
        if (dis[x + 1][y + 1][0] > dis[x][y][4]) {
            dis[x + 1][y + 1][0] = dis[x][y][4];
            pq.push({-dis[x + 1][y + 1][0], {{x + 1, y + 1}, 0}});
        }
    }
    if (valid(x + 1, y)) {
        if (dis[x + 1][y][2] > dis[x][y][4]) {
            dis[x + 1][y][2] = dis[x][y][4];
            pq.push({-dis[x + 1][y][2], {{x + 1, y}, 2}});
        }
        if (dis[x + 1][y][1] > dis[x][y][5]) {
            dis[x + 1][y][1] = dis[x][y][5];
            pq.push({-dis[x + 1][y][1], {{x + 1, y}, 1}});
        }
        if (dis[x + 1][y][0] > dis[x][y][6]) {
            dis[x + 1][y][0] = dis[x][y][6];
            pq.push({-dis[x + 1][y][0], {{x + 1, y}, 0}});
        }
    }
    if (valid(x - 1, y + 1)) {
        if (dis[x - 1][y + 1][6] > dis[x][y][2]) {
            dis[x - 1][y + 1][6] = dis[x][y][2];
            pq.push({-dis[x - 1][y + 1][6], {{x + 1, y}, 6}});
        }
    }
    if (valid(x, y - 1)) {
        if (dis[x][y - 1][2] > dis[x][y][0]) {
            dis[x][y - 1][2] = dis[x][y][0];
            pq.push({-dis[x][y - 1][2], {{x, y - 1}, 2}});
        }
        if (dis[x][y - 1][3] > dis[x][y][7]) {
            dis[x][y - 1][3] = dis[x][y][7];
            pq.push({-dis[x][y - 1][3], {{x, y - 1}, 3}});
        }
        if (dis[x][y - 1][4] > dis[x][y][6]) {
            dis[x][y - 1][4] = dis[x][y][6];
            pq.push({-dis[x][y - 1][4], {{x, y - 1}, 4}});
        }
    }
    if (valid(x - 1, y - 1)) {
        if (dis[x - 1][y - 1][4] > dis[x][y][0]) {
            dis[x - 1][y - 1][4] = dis[x][y][0];
            pq.push({-dis[x - 1][y - 1][4], {{x - 1, y - 1}, 4}});
        }
    }
    if (valid(x - 1, y)) {
        if (dis[x - 1][y][6] > dis[x][y][0]) {
            dis[x - 1][y][6] = dis[x][y][0];
            pq.push({-dis[x - 1][y][6], {{x - 1, y}, 6}});
        }
        if (dis[x - 1][y][5] > dis[x][y][1]) {
            dis[x - 1][y][5] = dis[x][y][1];
            pq.push({-dis[x - 1][y][5], {{x - 1, y}, 5}});
        }
        if (dis[x - 1][y][4] > dis[x][y][2]) {
            dis[x - 1][y][4] = dis[x][y][2];
            pq.push({-dis[x - 1][y][4], {{x - 1, y}, 4}});
        }
    }
    if (valid(x, y + 1)) {
        if (dis[x][y + 1][0] > dis[x][y][2]) {
            dis[x][y + 1][0] = dis[x][y][2];
            pq.push({-dis[x][y + 1][0], {{x, y + 1}, 0}});
        }
        if (dis[x][y + 1][7] > dis[x][y][3]) {
            dis[x][y + 1][7] = dis[x][y][3];
            pq.push({-dis[x][y + 1][7], {{x, y + 1}, 7}});
        }
        if (dis[x][y + 1][6] > dis[x][y][4]) {
            dis[x][y + 1][6] = dis[x][y][4];
            pq.push({-dis[x][y + 1][6], {{x, y + 1}, 6}});
        }
    }
    //cout << pq.size() << el;
}

void solve() {
    priority_queue<pair<ld, pair<pair<int, int>, int>>> pq;
    dis[1][1][0] = 0;
    pq.push({0, {{1, 1}, 0}});
    ld cost;
    int state;
    while (pq.size()) {
        x = pq.top().second.first.first;
        y = pq.top().second.first.second;
        cost = -pq.top().first;
        state = pq.top().second.second;
        pq.pop();
        if (dis[x][y][state] < cost) {
            continue;
        }
        zbtsquare(x, y);
        if (grid[x][y] == 'O') {
            zbtcircle(x, y);
            zbtsquare(x, y);
        }
        for (int i = 0; i < 8; i++) {
            //cout << dis[x][y][i] << el;
            if (vis[x][y][i] > dis[x][y][i]) {
                pq.push({-dis[x][y][i], {{x, y}, i}});
                //cout << x << " " << y << " " << i << el;
                vis[x][y][i] = dis[x][y][i];
            }
        }
        trantition(x, y, pq);
    }
}

void dowork() {
    cin >> n >> m;
    for (int i = 0; i <= n; i++) {
        for (int j = 0; j <= m; j++) {
            for (int k = 0; k <= 8; k++) {
                dis[i][j][k] = vis[i][j][k] = 2e18;
            }
        }
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            cin >> grid[i][j];
        }
    }
    solve();
    cout << fixed << setprecision(10) << dis[n][m][4] << el;
}

signed main() {
    fast
    int t = 1;
    //cin >> t;
    for (int i = 1; i <= t; i++) {
        dowork();
    }
    return 0;
}