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

using namespace __gnu_pbds;
using namespace std;

template<class T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template<class T> using ordered_multiset = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define IO ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long
#define ld long double
const int N = 7e2 + 5, MOD = 998244353;
const ld PI = acos(-1), EPS = 1e-8;

struct point {
    int x, y, z;

/*
 * 0 1 2
 * 7   3
 * 6 5 4
*/
    point() {}

    point(int x, int y, int z) : x(x), y(y), z(z) {}

    bool operator<(const point &P) const {
        return 0;
    }

};

int h, w;
vector<pair<point, ld>> adj[N][N][10];
ld dist[N][N][10];

bool valid(int i, int j) {
    return (i >= 0 && i < h && j >= 0 && j < w);
}

ld dijkstra() {
    priority_queue<pair<ld, point>, vector<pair<ld, point>>, greater<>> pq;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            for (int k = 0; k < 10; k++) {
                dist[i][j][k] = 1e9;
            }
        }
    }
    point dummy(0, 0, 0);
    pq.push({0.0, dummy});
    dist[0][0][0] = 0.0;

    while (!pq.empty()) {
        ld cost = pq.top().first;
        point cur = pq.top().second;
        int x = cur.x, y = cur.y, z = cur.z;
        pq.pop();

        for (auto child: adj[x][y][z]) {
            point nxt = child.first;
            ld newCost = cost + child.second;

            if (newCost < dist[nxt.x][nxt.y][nxt.z] && dist[nxt.x][nxt.y][nxt.z] - newCost > EPS) {
                dist[nxt.x][nxt.y][nxt.z] = newCost;
                pq.push({newCost, nxt});
            }
        }
    }

    return dist[h - 1][w - 1][4];
}

void doWork() {
    cin >> h >> w;
    for (int i = 0; i < h; i++) {
        for (int j = 0; j < w; j++) {
            char ch;
            cin >> ch;

            for (int k = 0; k < 8; k++) {
                point L(i, j, (k - 1 + 8) % 8);
                point R(i, j, (k + 1) % 8);

                adj[i][j][k].push_back({L, 5.0});
                adj[i][j][k].push_back({R, 5.0});
            }
            if (ch == 'O') {
                ld v = 2.0 * PI * 5.0 * 0.25;
                point p1(i, j, 1);
                point p3(i, j, 3);
                point p5(i, j, 5);
                point p7(i, j, 7);

                adj[i][j][1].push_back({p3, v});
                adj[i][j][1].push_back({p7, v});

                adj[i][j][3].push_back({p1, v});
                adj[i][j][3].push_back({p5, v});

                adj[i][j][5].push_back({p3, v});
                adj[i][j][5].push_back({p7, v});

                adj[i][j][7].push_back({p1, v});
                adj[i][j][7].push_back({p5, v});
            }
        }
    }

    // connect each adjacent cells
    for (int i = 0; i < h; i++) {
        for (int j = 0; j < w; j++) {
            // right cell
            point r0(i, j + 1, 0);// ymen 0
            point r7(i, j + 1, 7);// ymen 7
            point r6(i, j + 1, 6);// ymen 6
            // down cell
            point d0(i + 1, j, 0);// t7t 0
            point d1(i + 1, j, 1);// t7t 1
            point d2(i + 1, j, 2);// t7t 2

            if (valid(i, j + 1)) {
                adj[i][j][2].push_back({r0, 0.0});
                adj[i][j][3].push_back({r7, 0.0});
                adj[i][j][4].push_back({r6, 0.0});
            }
            if (valid(i + 1, j)) {
                adj[i][j][4].push_back({d2, 0.0});
                adj[i][j][5].push_back({d1, 0.0});
                adj[i][j][6].push_back({d0, 0.0});
            }
        }
    }

    cout << fixed << setprecision(8) << dijkstra();
}

int main() {
    IO
    int T = 1;
    //cin >> T;
    while (T--) {
        doWork();
    }
}