Once upon a time there were several little pigs and several wolves on a two-dimensional grid of size n × m. Each cell in this grid was either empty, containing one little pig, or containing one wolf.

A little pig and a wolf are adjacent if the cells that they are located at share a side. The little pigs are afraid of wolves, so there will be at most one wolf adjacent to each little pig. But each wolf may be adjacent to any number of little pigs.

They have been living peacefully for several years. But today the wolves got hungry. One by one, each wolf will choose one of the little pigs adjacent to it (if any), and eats the poor little pig. This process is not repeated. That is, each wolf will get to eat at most one little pig. Once a little pig gets eaten, it disappears and cannot be eaten by any other wolf.

What is the maximum number of little pigs that may be eaten by the wolves?

Input

The first line contains integers n and m (1 ≤ n, m ≤ 10) which denotes the number of rows and columns in our two-dimensional grid, respectively. Then follow n lines containing m characters each — that is the grid description. "." means that this cell is empty. "P" means that this cell contains a little pig. "W" means that this cell contains a wolf. 

It is guaranteed that there will be at most one wolf adjacent to any little pig.

Output

Print a single number — the maximal number of little pigs that may be eaten by the wolves.

Examples

Input

2 3
PPW
W.P


Output

2


Input

3 3
P.W
.P.
W.P


Output

0

Note

In the first example, one possible scenario in which two little pigs get eaten by the wolves is as follows. 

<image>
import java.io.*;
import java.math.*;
import java.util.*;


/**
 *
 * @author Saju
 *
 */

public class Main {

	private static int dx[] = { 1, 0, -1, 0 };
	private static int dy[] = { 0, -1, 0, 1 };

	private static final long INF = Long.MAX_VALUE;
	private static final int INT_INF = Integer.MAX_VALUE;
	private static final long NEG_INF = Long.MIN_VALUE;
	private static final int NEG_INT_INF = Integer.MIN_VALUE;
	private static final double EPSILON = 1e-10;

	private static final int MAX = 201;
	private static final long MOD = 1000000007;

	private static final int MAXN = 100007;
	private static final int MAXA = 10000009;
	private static final int MAXLOG = 22;

	public static void main(String[] args) throws IOException {

		InputReader in = new InputReader(System.in);
		PrintWriter out = new PrintWriter(System.out);

//		 InputReader in = new InputReader(new FileInputStream("src/test.in"));
//		 PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("src/test.out")));



/*



*/
		
		int r = in.nextInt();
		int c = in.nextInt();
		char[][] grid=  new char[r][c];
		
		List<Pair> wolves = new ArrayList<>();
		for(int i = 0; i < r; i++) {
			grid[i] = in.next().toCharArray();
			for(int j = 0; j < c; j++) {
				if(grid[i][j] == 'W') {
					wolves.add(new Pair(j, i));
				}
			}
		}
		if(wolves.size() > 0) {
			boolean[][] eaten = new boolean[r][c];
			int max = call(0, r, c, wolves, grid, eaten, 0);
			out.println(max);
		}
		else {
			out.println("0");
		}
		
		out.flush();
		out.close();
		System.exit(0);
	}
	
	private static boolean allEaten = false;
	
	private static int call(int i, int r, int c, List<Pair> wolves, char[][] grid, boolean[][] eaten, int cnt) {
		
		if(cnt == wolves.size()) {
			allEaten = true;
		}
		if(i == wolves.size()) {
			return 0;
		}
		int max = 0;
		for(int j = 0; j < 4; j++) {
			int vx = wolves.get(i).x + dx[j];
			int vy = wolves.get(i).y + dy[j];
			int val = 0;
			if(vx >= 0 && vx < c && vy >= 0 && vy < r && !eaten[vy][vx] && grid[vy][vx] == 'P' && !allEaten) {
				eaten[vy][vx] = true;
				val = 1 + call(i + 1, r, c, wolves, grid, eaten, cnt + 1);
//				System.out.println(i + " " + val);
				eaten[vy][vx] = false;
			}
			max = max(max, val);
			
		}
		if(max == 0 && !allEaten) {
			max = max(max, call(i + 1, r, c, wolves, grid, eaten, cnt));
		}
//		System.out.println("I " + i + " "+ max);
		return max;
	}


	private static int ceil(int n, int x) {
		int div = n / x;
		if(div * x != n) {
			div++;
		}
		return div;
	}

	private static class Pair{
	
		int x;
		int y;
		Pair(int x, int y){
			this.x = x;
			this.y = y;
		}
	}

	private static class Point {
		double x;
		double y;

		Point(double x, double y) {
			this.x = x;
			this.y = y;
		}

		double getDistance(Point p2) {
			Point p1 = this;
			double dx = p1.x - p2.x;
			double dy = p1.y - p2.y;

			return Math.sqrt((dx * dx) + (dy * dy));
		}
	}

	private static int abs(int x) {
		if (x < 0) {
			return -x;
		}
		return x;
	}

	private static long abs(long x) {
		if(x < 0) {
			return -x;
		}
		return x;
	}

	private static int lcm(int a, int b) {
		return (a * b) / gcd(a, b);
	}

	private static int gcd(int a, int b) {
		if (a == 0)
			return b;
		return gcd(b % a, a);
	}

	private static int log(long x, int base) {
		return (int) (Math.log(x) / Math.log(base));
	}

	private static long min(long a, long b) {
		if (a < b) {
			return a;
		}
		return b;
	}

	private static int min(int a, int b) {
		if (a < b) {
			return a;
		}
		return b;
	}

	private static long max(long a, long b) {
		if (a < b) {
			return b;
		}
		return a;
	}

	private static int max(int a, int b) {
		if (a < b) {
			return b;
		}
		return a;
	}

	private static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(stream));
			tokenizer = null;
		}

		public String next() {
			try {
				while (tokenizer == null || !tokenizer.hasMoreTokens()) {
					tokenizer = new StringTokenizer(reader.readLine());

				}
			} catch (IOException e) {
				return null;
			}
			return tokenizer.nextToken();
		}

		public String nextLine() {
			String line = null;
			try {
				tokenizer = null;
				line = reader.readLine();
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
			return line;
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}

		public double nextDouble() {
			return Double.parseDouble(next());
		}

		public long nextLong() {
			return Long.parseLong(next());
		}

		public boolean hasNext() {
			try {
				while (tokenizer == null || !tokenizer.hasMoreTokens()) {
					tokenizer = new StringTokenizer(reader.readLine());
				}
			} catch (Exception e) {
				return false;
			}
			return true;
		}
	}
}
	 	 		 		    					 	  	   	