/*

    做网络流的题建图真的是太重要了！

    本题是将人所在的位置和房子所在的位置建立边的联系，其中man到house这一条边的流量为 1， 费用为两者的距离

    而方向边的流量为 0， 费用为正向边的相反数（也就是沿着反向边进行增广时，费用要减少，更改先前错误的选择）

    最后增加一个源点和一个汇点完毕（源点映射到man， house映射到汇点， 费用为0， 流量为1） 
　　　　

 */

 #include<iostream>

 #include<cmath>

 #include<cstdio>

 #include<cstring>

 #include<queue>

 #define Max 0x3f3f3f3f

 #define N 205

 using namespace std;

 class node

 {

 public:

    int x, y;

 };

 node xyM[N];

 node xyH[N];

 int cost[N][N], cap[N][N];

 int cntM, cntH;

 int pre[N*], dist[N*], vis[N*], n, m;

 void addE(int i, int j, int ct, int cp)

 {

     cost[i][j]=ct;

     cap[i][j]=cp;

     cost[j][i]=-ct;

     //cap[j][i]=0;

 }

 int s, t, minCost;

 void buildMap()

 {

    int i, j;

    memset(cap, , sizeof(cap));

    s=; t=cntM+cntH+;

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

      addE(, i+, , );

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

      addE(cntM+i+, t, , );

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

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

        addE(i+, cntM+j+, abs(xyM[i].x-xyH[j].x)+abs(xyM[i].y-xyH[j].y), );

 }

 queue<int>q;

 int spfa()

 {

     int u, v;

     memset(dist, 0x3f, sizeof(dist));

     dist[]=;

     q.push();

     vis[]=;

     while(!q.empty())

     {

         u=q.front();

         q.pop();

         vis[u]=;

         for(v=; v<=t; ++v)

           if(cap[u][v]> && dist[v]>dist[u]+cost[u][v])

           {

               dist[v]=dist[u]+cost[u][v];

               pre[v]=u;

               if(!vis[v])

               {

                     vis[v]=;

                     q.push(v);

           }

       }

     }

     if(dist[t]==Max)

       return ;

     return ;

 }

 void updateEdge()

 {

    int u, minFlow=Max;

    for(u=t; u!=s; u=pre[u])//通过最短路径寻找这条路径上的最小流量

       if(cap[pre[u]][u]<minFlow)

         minFlow=cap[pre[u]][u];

     for(u=t; u!=s; u=pre[u])

     {

         cap[pre[u]][u]-=minFlow;

         cap[u][pre[u]]+=minFlow;

         minCost+=cost[pre[u]][u];

     }

 }

 int main()

 {

    int i, j;

    char c;

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

    {

        cntM=cntH=;

        minCost=;

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

          {

            getchar();

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

              {

             scanf("%c", &c);

             if(c=='m')

             {

                xyM[cntM].x=i;

                xyM[cntM++].y=j;

         }

         else if(c=='H')

         {

            xyH[cntH].x=i;

                xyH[cntH++].y=j;

         }

          }

         }

         buildMap();

         while(spfa())

           updateEdge();

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

    }

    return ;

 }

 #include<iostream>

 #include<queue>

 #include<cstring>

 #include<cstdio>

 #include<algorithm>

 #define INF 0x3f3f3f3f

 #define N 1000005

 using namespace std;

 int cntH, cntM;

 struct node{

     int x, y;

 };

 struct EDGE{

     int u, v, cap, cost, nt;

 };

 EDGE edge[N];

 queue<int>q;

 node man[], house[];

 int first[];

 int dist[];

 int pre[], flow[], vis[];

 int cnt, t;

 int minCost;

 int n, m;

 void addEdge(int u, int v, int cap, int cost){

     edge[cnt].u=u;

     edge[cnt].v=v;

     edge[cnt].cap=cap;

     edge[cnt].nt=first[u];

     edge[cnt].cost=cost;

     first[u]=cnt++;

     edge[cnt].u=v;

     edge[cnt].v=u;

     edge[cnt].cap=;

     edge[cnt].nt=first[v];

     edge[cnt].cost=-cost;

     first[v]=cnt++;

 }

 void buildMap(){

     memset(first, -, sizeof(first));

     t=cntH+cntM+;

     for(int i=; i<=cntM; ++i)

         for(int j=; j<=cntH; ++j)

             addEdge(i, cntM+j, , abs(man[i].x-house[j].x) + abs(man[i].y-house[j].y));

     for(int i=; i<=cntM; ++i)

         addEdge(, i, , );

     for(int i=; i<=cntH; ++i)

         addEdge(cntM+i, t, , );

 }

 bool MCMF(){

     memset(dist, 0x3f, sizeof(dist));

     memset(vis, , sizeof(vis));

     q.push();

     flow[]=INF;

     dist[]=;

     vis[]=;

     while(!q.empty()){

         int u=q.front(); q.pop();

         vis[u]=;

         for(int e=first[u]; ~e; e=edge[e].nt){

             int v=edge[e].v, cap=edge[e].cap, cost=edge[e].cost;

             if(cap> && dist[v]>dist[u]+cost){

                 dist[v]=dist[u]+cost;

                 flow[v]=min(flow[u], cap);

                 pre[v]=e;

                 if(!vis[v]){

                     vis[v]=;

                     q.push(v);

                 }

             }

         }

     }

     if(dist[t]==INF) return false;

     minCost+=dist[t];

     int x=t;

     while(x!=){

         edge[pre[x]].cap-=flow[t];

         edge[pre[x]^].cap+=flow[t];

         x=edge[pre[x]].u;

     }

     return true;

 }

 int main(){

     while(scanf("%d%d", &n, &m) && (n||m)){

         cnt=cntH=cntM=;

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

             getchar();

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

                 char ch;

                 scanf("%c", &ch);

                 if(ch=='m'){

                     man[++cntM].x=i;

                     man[cntM].y=j;

                 }

                 else if(ch=='H'){

                     house[++cntH].x=i;

                     house[cntH].y=j;

                 }

             }

         }

         buildMap();

         minCost=;

         while(MCMF());

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

     }

     return ;

 }