#include <iostream>

 #include <cstdio>

 #include <fstream>

 #include <algorithm>

 #include <cmath>

 #include <deque>

 #include <vector>

 #include <queue>

 #include <string>

 #include <cstring>

 #include <map>

 #include <stack>

 #include <set>

 #define LL long long

 #define eps 1e-8

 #define INF 0x3f3f3f3f

 #define MAXN 1005

 using namespace std;

 struct Edge{

     int from, to, cap, flow;

     //Edge(int u, int v, int c, int f) :from(u), to(v), cap(c), flow(f){};

 };

 struct Dinic{

     int n, m, i, s, t;

     Edge e;

     vector<Edge> edges;

     vector<int> G[MAXN];

     int d[MAXN], cur[MAXN];

     bool vis[MAXN];

     void init(int n){

         this->n = n;

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

             G[i].clear();

         }

         edges.clear();

     }

     void AddEdge(int from, int to, int cap){

         edges.push_back(Edge{ from, to, cap,  });

         edges.push_back(Edge{ to, from, ,  });

         m = edges.size();

         G[from].push_back(m - );

         G[to].push_back(m - );

     }

     bool BFS(){

         memset(vis, , sizeof(vis));

         queue<int> Q;

         Q.push(s);

         d[s] = ;

         vis[s] = ;

         while (!Q.empty()){

             int x = Q.front();

             Q.pop();

             for (i = ; i < G[x].size(); i++){

                 Edge& e = edges[G[x][i]];

                 if (!vis[e.to] && e.cap > e.flow){

                     vis[e.to] = true;

                     d[e.to] = d[x] + ;

                     Q.push(e.to);

                 }

             }

         }

         return vis[t];

     }

     int DFS(int x, int a){

         if (x == t || a == ) return a;

         int flow = , f;

         for (int& i = cur[x]; i < G[x].size(); i++){

             Edge& e = edges[G[x][i]];

             if (d[x] +  == d[e.to] && (f = DFS(e.to, min(a, e.cap - e.flow))) > ){

                 e.flow += f;

                 edges[G[x][i] ^ ].flow -= f;

                 flow += f;

                 a -= f;

                 if (a == ) break;

             }

         }

         return flow;

     }

     int MaxFlow(int s, int t, int need){

         int flow = ;

         this->s = s;

         this->t = t;

         while (BFS()){

             memset(cur, , sizeof(cur));

             flow += DFS(s, INF);

             if (flow > need) return flow;

         }

         return flow;

     }

 };

 char a[][];

 Dinic p;

 const int step[][] = { , , , , -, , , - };

 bool vis[][];

 int main()

 {

 #ifndef ONLINE_JUDGE

     freopen("in.txt", "r", stdin);

     //freopen("out.txt", "w", stdout);

 #endif // OPEN_FILE

     int n, m;

     scanf("%d%d", &n, &m);

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

         scanf("%s", a[i] + );

     }

     int s = , t =  * n * m + ;

     p.init(t);

     memset(vis, , sizeof(vis));

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

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

             int u = (i - ) * m + j;

             if(a[i][j] == 'W'){

                 p.AddEdge(s, u, );

                 for (int k = ; k < ; k++){

                     int x = i + step[k][];

                     int y = j + step[k][];

                     if (x <  || y <  || x > n || y > m) continue;

                     if (a[x][y] == 'I'){

                         p.AddEdge(u, (x - ) * m + y, );

                     }

                 }

             }

             else if (a[i][j] == 'I'){

                 int v = u + n * m;

                 p.AddEdge(u, v, );

                 for (int k = ; k < ; k++){

                     int x = i + step[k][];

                     int y = j + step[k][];

                     if (x <  || y <  || x > n || y > m) continue;

                     if (a[x][y] == 'N'){

                         p.AddEdge(v, (x - ) * m + y, );

                         if (vis[x][y]) continue;

                         p.AddEdge((x - ) * m + y, t, );

                         vis[x][y] = true;

                     }

                 }

             }

         }

     }

     int ans = p.MaxFlow(s, t, INF);

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

 }