Problem: After too much playing on paper, Iahub has switched to computer games. The game he plays is called "Block Towers". It is played in a rectangular grid with n rows and m columns (it contains n × m cells). The goal of the game is to build your own city. Some cells in the grid are big holes, where Iahub can't build any building. The rest of cells are empty. In some empty cell Iahub can build exactly one tower of two following types:

  1. Blue towers. Each has population limit equal to 100. 
  2. Red towers. Each has population limit equal to 200. However, it can be built in some cell only if in that moment at least one of the neighbouring cells has a Blue Tower. Two cells are neighbours is they share a side. 



Iahub is also allowed to destroy a building from any cell. He can do this operation as much as he wants. After destroying a building, the other buildings are not influenced, and the destroyed cell becomes empty (so Iahub can build a tower in this cell if needed, see the second example for such a case).

Iahub can convince as many population as he wants to come into his city. So he needs to configure his city to allow maximum population possible. Therefore he should find a sequence of operations that builds the city in an optimal way, so that total population limit is as large as possible.

He says he's the best at this game, but he doesn't have the optimal solution. Write a program that calculates the optimal one, to show him that he's not as good as he thinks. 

Input

The first line of the input contains two integers n and m (1 ≤ n, m ≤ 500). Each of the next n lines contains m characters, describing the grid. The j-th character in the i-th line is '.' if you're allowed to build at the cell with coordinates (i, j) a tower (empty cell) or '#' if there is a big hole there. 

Output

Print an integer k in the first line (0 ≤ k ≤ 106) — the number of operations Iahub should perform to obtain optimal result.

Each of the following k lines must contain a single operation in the following format:

  1. «B x y» (1 ≤ x ≤ n, 1 ≤ y ≤ m) — building a blue tower at the cell (x, y); 
  2. «R x y» (1 ≤ x ≤ n, 1 ≤ y ≤ m) — building a red tower at the cell (x, y); 
  3. «D x y» (1 ≤ x ≤ n, 1 ≤ y ≤ m) — destroying a tower at the cell (x, y). 



If there are multiple solutions you can output any of them. Note, that you shouldn't minimize the number of operations.

Examples

Input

2 3
..#
.#.


Output

4
B 1 1
R 1 2
R 2 1
B 2 3


Input

1 3
...


Output

5
B 1 1
B 1 2
R 1 3
D 1 2
R 1 2

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.InputMismatchException;

/**
 * Author   : Laputa
 * Date     : 2013-08-20
 * Time     : 00:15
 * Project  : acm
 * Problem  : C
 */

public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		Task solver = new Task();
		solver.solve(1, in, out);
		out.close();
	}
}

class Task {

	static boolean map[][];
	static boolean vis[][];
	static int n, m;
	//static ArrayList<Character> op0;
	//static ArrayList<Integer> op1;
	//static ArrayList<Integer> op2;
	static char ans1[];
	static int ans2[];
	static int ans3[];
	static int cntans;
	static int dirx[] = {0, 0, -1, 1};
	static int diry[] = {1, -1, 0, 0};

	public static void dfs(int i, int j, boolean first) {
		vis[i][j] = true;
		ans1[cntans] = 'B';
		ans2[cntans] = i + 1;
		ans3[cntans++] = j + 1;
		//System.out.println("B"+" "+i+" "+j);
		for (int k = 0; k < 4; k++) {
			int newx = i + dirx[k];
			int newy = j + diry[k];
			if (newx >= n || newx < 0 || newy >= m || newy < 0) {
				continue;
			}
			if (map[newx][newy] && !vis[newx][newy]) {
				dfs(newx, newy, false);
			}
		}

		if (!first) {
			ans1[cntans] = 'D';
			ans2[cntans] = i + 1;
			ans3[cntans++] = j + 1;
			ans1[cntans] = 'R';
			ans2[cntans] = i + 1;
			ans3[cntans++] = j + 1;
		}
	}

	public void solve(int testNumber, InputReader cin, OutputWriter out) {
		n = cin.nextInt();
		m = cin.nextInt();
		map = new boolean[n + 2][m + 2];
		vis = new boolean[n + 2][m + 2];
		//op0=new ArrayList<>();
		//op1=new ArrayList<>();
		//op2=new ArrayList<>();
		cntans = 0;
		ans1 = new char[1000005];
		ans2 = new int[1000005];
		ans3 = new int[1000005];
		String ipt;
		for (int i = 0; i < n; i++) {
			ipt = cin.nextString();
			for (int j = 0; j < m; j++) {
				if (ipt.charAt(j) == '.') {
					map[i][j] = true;
				}
			}
		}

		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				if (!vis[i][j] && map[i][j]) {
					dfs(i, j, true);
				}
			}
		}

		out.println(cntans);
		for (int i = 0; i < cntans; i++) {
			out.println(ans1[i]+" "+ans2[i]+" "+ans3[i]);
			//out.printf("%c %d %d\n", ans1[i], ans2[i], ans3[i]);
		}
	}

}

class InputReader {

	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	public static boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	public static boolean isEndofline(int c) {
		return c == '\n' || c == '\r';
	}

	public int nextChar() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int nextInt() {
		int c = nextChar();
		while (isSpaceChar(c))
			c = nextChar();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = nextChar();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = nextChar();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nextLong() {
		int c = nextChar();
		while (isSpaceChar(c))
			c = nextChar();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = nextChar();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = nextChar();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public String nextString() {
		int c = nextChar();
		while (isSpaceChar(c))
			c = nextChar();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = nextChar();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	public String nextLine() {
		int c = nextChar();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = nextChar();
		} while (!isEndofline(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	public boolean hasNext() {
		int value;
		while (isSpaceChar(value = peek()) && value != -1)
			nextChar();
		return value == -1;
	}

	public int peek() {
		if (numChars == -1)
			return -1;
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				return -1;
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar];
	}

	public double nextDouble() {
		int c = nextChar();
		while (isSpaceChar(c))
			c = nextChar();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = nextChar();
		}
		double res = 0;
		while (!isSpaceChar(c) && c != '.') {
			if (c == 'e' || c == 'E')
				return res * Math.pow(10, nextInt());
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = nextChar();
		}
		if (c == '.') {
			c = nextChar();
			double m = 1;
			while (!isSpaceChar(c)) {
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				m /= 10;
				res += (c - '0') * m;
				c = nextChar();
			}
		}
		return res * sgn;
	}

	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}

class OutputWriter {
	private final PrintWriter writer;

	public OutputWriter(OutputStream outputStream) {
		writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
	}

	public OutputWriter(Writer writer) {
		this.writer = new PrintWriter(writer);
	}

	public void print(Object... objects) {
		for (int i = 0; i < objects.length; i++) {
			if (i != 0)
				writer.print(' ');
			writer.print(objects[i]);
		}
	}

	public void println(Object... objects) {
		print(objects);
		writer.println();
	}

	public void println() {
		writer.println();
	}

	public void printf(String format, Object... args) {
		writer.printf(format, args);
	}

	public void close() {
		writer.close();
	}

}