/*
 ID: bradyawn
 PROG: contest
 LANG: C++11
 */

#include <iostream>
#include <algorithm>
#include <iomanip>
#include <fstream>
#include <vector>
#include <deque>
#include <string>
#include <cmath>
#include <map>
#include <unordered_map>
#include <utility>
#include <set>
#include <unordered_set>
#include <ctime>
#include <queue>
#include <stack>
#include <bitset>
#include <random>
#include <cstring>
#include <complex>

using namespace std;

typedef long long ll;
typedef pair<int,int> i2;
typedef pair<ll,ll> ll2;

int r,c,n;

struct S
{
    int row;
    int col;
    int dist;
};

deque<S> d;

char grid[51][51];
char sGrid[51][51];
int ans[51][51];

int island[16][16];

void add(int i, int j, int prevD)
{
    if (!(i >= 1 && i <= r)) return;
    if (!(j >= 1 && j <= c)) return;
    if (grid[i][j] == '.') return;
    if (grid[i][j] == 'X') d.push_front({i,j,prevD});
    if (grid[i][j] == 'S') d.push_back({i,j,prevD+1});
}

void fix()
{
    d.clear();
    for (int i = 1; i <= r; i++)
        for (int j = 1; j <= c; j++) grid[i][j] = sGrid[i][j];
}

int dfs(int i, int j) //find distance from island at i,j to fixed island
{
    if (!(i >= 1 && i <= r)) return 1e9;
    if (!(j >= 1 && j <= c)) return 1e9;
    if (grid[i][j] != 'X') return 1e9;
    grid[i][j] = '.';

    int ret = ans[i][j];

    ret = min(ret, dfs(i+1, j));
    ret = min(ret, dfs(i-1, j));
    ret = min(ret, dfs(i, j+1));
    ret = min(ret, dfs(i, j-1));

    return ret;
}

void bfs(S st)
{
    memset(ans, 0, sizeof ans);
    fix();

    d.push_front(st);

    while (!d.empty())
    {
        auto node = d.front(); d.pop_front();
        int i = node.row;
        int j = node.col;

        grid[i][j] = '.';

        ans[i][j] = node.dist;

        add(i+1, j, node.dist);
        add(i-1, j, node.dist);
        add(i, j+1, node.dist);
        add(i, j-1, node.dist);


    }
}

/*
 void prnt()
 {
 for (int i = 1; i <= r; i++)
 for (int j = 1; j <= c; j++) outf << ans[i][j] << " \n"[j==c];
 outf << '\n';
 }*/

int dp[1<<16][16];

int solve(int mask, int cur)
{
    int ret = 1e9;
    if (dp[mask][cur] != -1) return dp[mask][cur];
    if (mask == ((1 << n)-1)) return 0;
    for (int i = 0; i < n; i++)
        if ( ((1 << i) & mask) == 0) ret = min(ret, island[cur][i]+solve(mask | (1 << i), i));
    return dp[mask][cur] = ret;
}

int main()
{
    ifstream inf("island.in");
    ofstream outf("island.out");
    //outf << setprecision(10);
    ios::sync_with_stdio(0); inf.tie(0);

    inf >> r >> c;

    vector<S> pts; //start points

    for (int i = 1; i <= r; i++)
        for (int j = 1; j <= c; j++)
        {
            inf >> grid[i][j];
            sGrid[i][j] = grid[i][j];
        }

    for (int i = 1; i <= r; i++)
        for (int j = 1; j <= c; j++)
        {
            if (grid[i][j] == 'X') pts.push_back({i,j,0});
            dfs(i,j);
        }

    n = pts.size();

    for (int i = 0; i < n; i++)
    {
        bfs(pts[i]); fix();
        for (int j = 0; j < n; j++) island[i][j] = dfs(pts[j].row, pts[j].col);
    }

    memset(dp, -1, sizeof dp);

    for (int mask = (1 << n)-1; mask >= 0; mask--)
        for (int cur = 0; cur < n; cur++) solve(mask, cur);

    outf << solve(0,15) << '\n';

    return 0;

}