#include<bits/stdc++.h>
using namespace std;
#define debug
typedef long long ll;
const int MAXN=100010;
const int MAXM=4000100;
const int INF=0x3f3f3f3f;

struct Edge{
    int to, next, cap, flow;
}edge[MAXM];

int tot;
int head[MAXN];
int gap[MAXN], dep[MAXN], cur[MAXN];

void init(){
    tot=0;
    memset(head, -1, sizeof(head));
}

void addedge(int u, int v, int w, int rw=0){
    edge[tot].to=v; edge[tot].cap=w; edge[tot].flow=0;
    edge[tot].next=head[u]; head[u]=tot++;

    edge[tot].to=u; edge[tot].cap=rw; edge[tot].flow=0;
    edge[tot].next=head[v]; head[v]=tot++;
}
int Q[MAXN];

void BFS(int start, int end){
    memset(dep, -1, sizeof(dep));
    memset(gap, 0, sizeof(gap));
    gap[0]=1;
    int front=0, rear=0;
    dep[end]=0;
    Q[rear++]=end;
    while(front != rear){
        int u=Q[front++];
        for(int i=head[u]; i!=-1; i=edge[i].next){
            int v=edge[i].to;
            if(dep[v]!=-1)
                continue;
            Q[rear++]=v;
            dep[v]=dep[u]+1;
            gap[dep[v]]++;
        }
    }
}
int S[MAXN];
int sap(int start, int end, int N){
    BFS(start, end);
    memcpy(cur, head, sizeof(head));
    int top=0;
    int u=start;
    int ans=0;
    while(dep[start]<N){
        if(u==end){
            int Min=INF;
            int inser;
            for(int i=0; i<top; ++i){
                if(Min>edge[S[i]].cap-edge[S[i]].flow){
                    Min=edge[S[i]].cap-edge[S[i]].flow;
                    inser=i;
                }
            }
            for(int i=0; i<top; ++i){
                edge[S[i]].flow+=Min;
                edge[S[i]^1].flow-=Min;
            }
            ans+=Min;
            top=inser;
            u=edge[S[top]^1].to;
            continue;
        }
        bool flag=false;
        int v;
        for(int i=cur[u]; i!=-1; i=edge[i].next){
            v=edge[i].to;
            if(edge[i].cap-edge[i].flow && dep[v]+1==dep[u]){
                flag=true;
                cur[u]=i;
                break;
            }
        }
        if(flag){
            S[top++]=cur[u];
            u=v;
            continue;
        }
        int Min=N;
        for(int i=head[u]; i!=-1; i=edge[i].next){
            if(edge[i].cap - edge[i].flow && dep[edge[i].to]<Min){
                Min=dep[edge[i].to];
                cur[u]=i;
            }
        }
        gap[dep[u]]--;
        if(!gap[dep[u]])
            return ans;
        dep[u]=Min+1;
        gap[dep[u]]++;
        if(u!=start)
            u=edge[S[--top]^1].to;
    }
    return ans;
}


int main(){
    std::ios::sync_with_stdio(false);
    int H, W;
    cin>>H>>W;
    vector<string> mp(H);
    int sx, sy, tx, ty;
    for(int i=0; i<H; ++i){
        cin>>mp[i];
        for(int j=0; j<W; ++j){
            if(mp[i][j]=='S'){
                sx=i; sy=j;
            }
            if(mp[i][j]=='T'){
                tx=i; ty=j;
            }
        }
    }
    if(sx==tx || sy==ty){
        cout<<-1<<endl;
        return 0;
    }
    #define idx(i, j) (((i)*W)+(j))
    init();
    for(int i=0; i<H; ++i){
        for(int j=0; j<W; ++j){
            if(mp[i][j]=='o'){
                addedge(idx(i, j), idx(i, j)+H*W, 1);
            }
        }
    }
    addedge(idx(sx, sy), idx(sx, sy)+H*W, INF);
    addedge(idx(tx, ty), idx(tx, ty)+H*W, INF);

    for(int i=0; i<H; ++i){
        if(mp[i][sy]=='o'){
            addedge(idx(sx, sy)+H*W, idx(i, sy), INF);
        }
    }
    for(int i=0; i<W; ++i){
        if(mp[sx][i]=='o'){
            addedge(idx(sx, sy)+H*W, idx(sx, i), INF);
        }
    }

    for(int i=0; i<H; ++i){
        for(int j=0; j<W; ++j){
            if(mp[i][j]=='o'){
                for(int k=j+1; k<W; ++k){
                    if(mp[i][k]=='o'){
                        addedge(idx(i, j)+H*W, idx(i, k), INF, 0);
                        addedge(idx(i, k)+H*W, idx(i, j), INF, 0);
                    }
                }
            }
        }
    }

    for(int i=0; i<W; ++i){
        for(int j=0; j<H; ++j){
            if(mp[j][i]=='o'){
                for(int k=j+1; k<H; ++k){
                    if(mp[k][i]=='o'){
                        addedge(idx(j, i)+H*W, idx(k, i), INF, 0);
                        addedge(idx(k, i)+H*W, idx(j, i), INF, 0);
                    }
                }
            }
        }
    }

    for(int i=0; i<H; ++i){
        if(mp[i][ty]=='o'){
            addedge(idx(i, ty)+H*W, idx(tx, ty), INF, 0);
        }
    }
    for(int i=0; i<W; ++i){
        if(mp[tx][i]=='o'){
            addedge(idx(tx, i)+H*W, idx(tx, ty), INF, 0);
        }
    }
    int ans=sap(idx(sx, sy), idx(tx, ty)+H*W, H*W*2);
    cout<<ans<<endl;
    return 0;
}


Measured memory_bytes: 64128