#include<stdio.h>

#include<string.h>

#include<math.h>

#include<queue>

#include<stdlib.h>

#define INF 1000000000

using namespace std;

const int maxn = ;

struct Set

{

    int x,y;

}mnum[*],hnum[*];

struct node

{

    int to;

    int v;

    int flag;

    int cost;

    int next;

}edge[maxn*maxn/];

char map[][];

int n,m,cou1,cou2,index,head[maxn],s,t,pre[maxn],fpre[maxn],N,dis[maxn];

int Get(int i,int j)

{

    return abs(mnum[i].x-hnum[j].x)+abs(mnum[i].y-hnum[j].y);

}

void add(int x,int y,int v,int cost)

{

    edge[index].to=y;

    edge[index].v=v;

    edge[index].cost=cost;

    edge[index].flag=index+;

    edge[index].next=head[x];

    head[x]=index++;

    edge[index].to=x;

    edge[index].v=;

    edge[index].cost=-cost;

    edge[index].flag=index-;

    edge[index].next=head[y];

    head[y]=index++;

}

void makemap()

{

    int i,j;

    cou1=cou2=;

    for(i=;i<n;i++)

    {

        for(j=;j<m;j++)

        {

            if(map[i][j]=='m')

            {

                mnum[++cou1].x=i;

                mnum[cou1].y=j;

            }

            else if(map[i][j]=='H')

            {

                hnum[++cou2].x=i;

                hnum[cou2].y=j;

            }

        }

    }

    index=;

    memset(head,-,sizeof(head));

    N=cou1+cou2+;

    s=;

    t=cou1+cou2+;

    for(i=;i<=cou1;i++)

        add(s,i,,);

    for(i=;i<=cou2;i++)

        add(i+cou1,t,,);

    for(i=;i<=cou1;i++)

    {

        for(j=;j<=cou2;j++)

        {

            add(i,j+cou1,,Get(i,j));

        }

    }

}

bool spfa(int s,int t)

{

    int vis[maxn];

    queue<int>q;

    memset(pre,-,sizeof(pre));

    memset(vis,,sizeof(vis));

    int i;

    for(i=;i<=N;i++)

        dis[i]=INF;

    vis[s]=;

    dis[s]=;

    pre[s]=;

    q.push(s);

    while(!q.empty())

    {

        int u=q.front();

        q.pop();

        vis[u]=;

        for(i=head[u];i!=-;i=edge[i].next)

        {

            if(edge[i].v&&dis[edge[i].to]>dis[u]+edge[i].cost)

            {

                dis[edge[i].to]=dis[u]+edge[i].cost;

                if(!vis[edge[i].to])

                {

                    vis[edge[i].to]=;

                    q.push(edge[i].to);

                }

                pre[edge[i].to]=u;

                fpre[edge[i].to]=i;

            }

        }

    }

    if(dis[t]>=INF)return false;

    return true;

}

int main()

{

    int i,j;

    while(~scanf("%d%d",&n,&m))

    {

        if(!n&&!m)break;

        for(i=;i<n;i++)

            scanf("%s",map[i]);

        makemap();

        int ans=;

        while(spfa(s,t))

        {

            int minflow=INF;

            for(i=t;i!=;i=pre[i])

            {

                if(minflow>edge[fpre[i]].v)

                    minflow=edge[fpre[i]].v;

            }

            ans+=minflow*dis[t];

            for(i=t;i!=;i=pre[i])

            {

                edge[fpre[i]].v-=minflow;

                edge[edge[fpre[i]].flag].v+=minflow;

            }

        }

        printf("%d\n",ans);

    }

}

#include<stdio.h>

#include<string.h>

#include<algorithm>

#define INF 99999999

#define maxn 105

using namespace std;

struct node

{

    int x;

    int y;

}h[maxn],m[maxn];

char g[maxn][maxn];

int map[maxn][maxn],pr[maxn],pl[maxn],visr[maxn],visl[maxn],match[maxn],slack[maxn];

int col,row;

void init(int x)

{

    int i,j;

    for(i=;i<=x;i++)

        for(j=;j<=x;j++)

            if(i==j)map[i][j]=;

            else map[i][j]=INF;

}

int dfs(int u,int n)

{

    int i,j;

    visl[u]=;

    for(i=;i<n;i++)

    {

        if(!visr[i])

        {

            int val=pl[u]+pr[i]-map[u][i];

            if(val==)

            {

                visr[i]=;

                if(match[i]==-||dfs(match[i],n))

                {

                    match[i]=u;

                    return ;

                }

            }

            if(val>&&val<slack[i])

                slack[i]=val;

        }

    }

    return ;

}

int km(int n)

{

    int i,j;

    memset(pr,,sizeof(pr));

    memset(match,-,sizeof(match));

    for(i=;i<n;i++)

        pl[i]=INF;

    for(i=;i<n;i++)

    {

        for(j=;j<n;j++)

            slack[j]=INF;

        while()

        {

            memset(visr,,sizeof(visr));

            memset(visl,,sizeof(visl));

            if(dfs(i,n))break;

            int k=INF;

            for(j=;j<n;j++)

            {

                if(!visr[j]&&slack[j]<k)

                    k=slack[j];

            }

            for(j=;j<n;j++)

            {

                if(visl[j])

                    pl[j]-=k;

                if(visr[j])

                    pr[j]+=k;

            }

        }

    }

    int res=;

    for(i=;i<n;i++)

    {

        res+=map[match[i]][i];

    }

    return res;

}

int main()

{

    int i,j;

    while(scanf("%d%d",&row,&col)!=EOF)

    {

        if(row==&&col==)

            break;

        int count1=,count2=;

        for(i=;i<row;i++)

            scanf("%s",g[i]);

        for(i=;i<row;i++)

            for(j=;j<col;j++)

            {

                if(g[i][j]=='H')

                {

                    h[count1].x=i;h[count1++].y=j;

                }

                else if(g[i][j]=='m')

                {

                    m[count2].x=i;m[count2++].y=j;

                }

            }

        init(count1);

        for(i=;i<count1;i++)

            for(j=;j<count2;j++)

            {

                map[i][j]=-(abs(h[i].x-m[j].x)+abs(h[i].y-m[j].y));

            }

        printf("%d\n",-km(count1));

    }

}