/*

Rohan Puttagunta

August 5, 2009



HOW TO USE:

Create a file called "format" (or if you have a different file name, change

the file name in the first line of the main) that has your grid. The gird

has to be 17 lines long, 17 characters per line and with a "." representing

the empty spaces (doesn't matter what the other character are). The program

will look at the set of the points marked by a "." and look for large rfree

sets withing these points. It will print out all rfree sets it finds larger

than "threshhold" which is set near the beginning of the program.



The program works by counting the number of rectangles each point is a part

of and then removing the point that is in the most rectangles. If there is a

tie, it chooses one randomly. It keeps removing points until there are no

more rectangles. This process is repeated 100,000 times (takes about 6

minutes to run on my computer).



 */



import java.io.*;

import java.util.*;



public class greedy {

	public static int threshhold=72;

	public static char[][] rep;

	public static int size;

	public static boolean flag;

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

		BufferedReader in=new BufferedReader(new FileReader("format"));

		String[] read=new String[17];

		for (int i=0; i<read.length; i++)

			read[i]=in.readLine();

		for (int fdskl=0; fdskl<100000; fdskl++){

			int[] grid=new int[17];

			int len=17;

			size=0;

			flag=true;

			rep=new char[17][17];

			for (int i=0; i<grid.length; i++){

				for (int j=0; j<read[i].length(); j++){

					rep[i][j]='R';

					if (read[i].charAt(j)=='.'){

						rep[i][j]='B';

						grid[i]+=Math.pow(2,j);

						size++;

					}

				}

			}

			while (flag){

				int[][] num=calculate(grid, len);

				int max=0;

				int count=0;

				for (int i=0; i<num.length; i++)

					for (int j=0; j<num[i].length; j++)

						if (num[i][j]>max){

							max=num[i][j];

							count=1;

						}

						else if (num[i][j]==max)

							count++;

				int l=(int)Math.floor(Math.random()*count);

				boolean flag=true;

				for (int i=0; i<num.length && flag; i++)

					for (int j=0; j<num[i].length && flag; j++)

						if (num[i][j]==max){

							if (l==0){

								flag=false;

								grid[i]-=Math.pow(2,j);

								rep[i][j]='.';

							}

							l--;

						}

		

				size--;

			}

		}

	}

	

	public static int[][] calculate(int[] grid, int len){

		int[][] ret=new int[grid.length][len];

		boolean end=true;

		for (int i=0; i<ret.length; i++)

			for (int j=i+1; j<ret.length; j++){

				int help=Integer.bitCount(grid[i]&grid[j]);

				int add=help-1;

				if (add>0)

					end=false;

				int mult=1;

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

					if ((grid[i]&grid[j]&mult)!=0){

						ret[i][k]+=add;

						ret[j][k]+=add;

					}

					mult*=2;

				}

			}

		if (end){

			if (size>threshhold){

				System.out.println(size);

				for (int i=0; i<rep.length; i++){

					for (int j=0; j<rep.length; j++)

						System.out.print(rep[i][j]);

					System.out.println();

				}

			}

			flag=false;

		}

		return ret;

	}

}