Problem: There are many interesting tasks on domino tilings. For example, an interesting fact is known. Let us take a standard chessboard (8 × 8) and cut exactly two squares out of it. It turns out that the resulting board can always be tiled using dominoes 1 × 2, if the two cut out squares are of the same color, otherwise it is impossible. 

Petya grew bored with dominoes, that's why he took a chessboard (not necessarily 8 × 8), cut some squares out of it and tries to tile it using triminoes. Triminoes are reactangles 1 × 3 (or 3 × 1, because triminoes can be rotated freely), also the two extreme squares of a trimino are necessarily white and the square in the middle is black. The triminoes are allowed to put on the chessboard so that their squares matched the colors of the uncut squares of the chessboard, and also the colors must match: the black squares must be matched with the black ones only and the white ones — with the white squares. The triminoes must not protrude above the chessboard or overlap each other. All the uncut squares of the board must be covered with triminoes. 

Help Petya find out if it is possible to tile his board using triminos in the described way and print one of the variants of tiling.

Input

The first line contains two integers n and m (1 ≤ n, m ≤ 1000) — the board size. Next n lines contain m symbols each and represent the board description. If some position contains ".", then the square in this position has been cut out. Symbol "w" stands for a white square, "b" stands for a black square. It is guaranteed that through adding the cut squares can result in a correct chessboard (i.e. with alternating black and white squares), thought, perhaps, of a non-standard size.

Output

If at least one correct tiling exists, in the first line print "YES" (without quotes), and then — the tiling description. The description must contain n lines, m symbols in each. The cut out squares, as well as in the input data, are marked by ".". To denote triminoes symbols "a", "b", "c", "d" can be used, and all the three squares of each trimino must be denoted by the same symbol. If two triminoes share a side, than they must be denoted by different symbols. Two triminoes not sharing a common side can be denoted by one and the same symbol (c.f. sample).

If there are multiple correct ways of tiling, it is allowed to print any. If it is impossible to tile the board using triminoes or the correct tiling, for which four symbols "a", "b", "c", "d" would be enough, doesn't exist, print "NO" (without quotes) in the first line.

Examples

Input

6 10
.w.wbw.wbw
wbwbw.w.w.
bw.wbwbwbw
w.wbw.wbwb
...wbw.w.w
..wbw.wbw.


Output

YES
.a.aaa.ccc
baccc.c.a.
ba.dddcbab
b.aaa.cbab
...bbb.b.b
..ccc.ddd.

Input

2 2
wb
bw


Output

NO


Input

1 3
wbw


Output

YES
bbb


Input

1 3
...


Output

YES
...

Solution (in JAVA):

Solution:

import java.util.ArrayList;
import java.util.Scanner;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author madi
 */
public class Round44J {

    static char[][] f;
    static int n;
    static int m;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] in = sc.nextLine().split(" ");
        n = Integer.parseInt(in[0]);
        m = Integer.parseInt(in[1]);

        char[][] b = new char[n][m];
        f = new char[n][m];

        String line;
        for (int i = 0; i < n; i++) {
            line = sc.nextLine();
            for (int j = 0; j < m; j++) {
                b[i][j] = line.charAt(j);
                f[i][j] = '.';
            }
        }

        int starti = 0;
        int startj = 0;

        while (starti < n) {
            if (b[starti][startj] == '.' || f[starti][startj] != '.') {
                startj++;
                if (startj >= m) {
                    startj = 0;
                    starti++;
                }
            } else if (b[starti][startj] == 'b' && f[starti][startj] == '.') {
                System.out.println("NO");
                return;
            } else {
                if (startj < m - 2 && b[starti][startj + 1] == 'b' && b[starti][startj + 2] == 'w' && f[starti][startj] == '.' && f[starti][startj + 1] == '.' && f[starti][startj + 2] == '.') {
                    char c = getColor(starti, startj, 2);
                    f[starti][startj] = c;
                    f[starti][startj + 1] = c;
                    f[starti][startj + 2] = c;
                    startj = startj + 3;
                } else if (starti < n - 2 && b[starti + 1][startj] == 'b' && b[starti + 2][startj] == 'w' && f[starti][startj] == '.' && f[starti + 1][startj] == '.' && f[starti + 2][startj] == '.') {
                    char c = getColor(starti, startj, 1);
                    f[starti][startj] = c;
                    f[starti + 1][startj] = c;
                    f[starti + 2][startj] = c;
                    startj++;
                } else {
                    System.out.println("NO");
                    return;
                }
                if (startj >= m) {
                    startj = 0;
                    starti++;
                }
            }
        }

        System.out.println("YES");
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                System.out.print(f[i][j]);
            }
            System.out.println();
        }

    }

    private static char getColor(int a, int b, int c) {
        char[] colors = {'a', 'b', 'c', 'd'};

        ArrayList<Character> ar = new ArrayList<Character>();

        if (c == 1) {
            if (b - 1 >= 0) {
                for (int i = a; i < a + 3; i++) {
                    if (!ar.contains(f[i][b - 1])) {
                        ar.add(f[i][b - 1]);
                    }
                }
            }
            if (b + 1 < m) {
                for (int i = a; i < a + 3; i++) {
                    if (!ar.contains(f[i][b + 1])) {
                        ar.add(f[i][b + 1]);
                    }
                }
            }
            if (a - 1 >= 0) {
                if (!ar.contains(f[a - 1][b])) {
                    ar.add(f[a - 1][b]);
                }
            }
            if (a + 3 < n) {
                if (!ar.contains(f[a + 3][b])) {
                    ar.add(f[a + 3][b]);
                }
            }
        } else {
            if (a - 1 >= 0) {
                for (int i = b; i < b + 3; i++) {
                    if (!ar.contains(f[a - 1][i])) {
                        ar.add(f[a - 1][i]);
                    }
                }
            }
            if (a + 1 < n) {
                for (int i = b; i < b + 3; i++) {
                    if (!ar.contains(f[a + 1][i])) {
                        ar.add(f[a + 1][i]);
                    }
                }
            }
            if (b - 1 >= 0) {
                if (!ar.contains(f[a][b - 1])) {
                    ar.add(f[a][b - 1]);
                }
            }
            if (b + 3 < m) {
                if (!ar.contains(f[a][b + 3])) {
                    ar.add(f[a][b + 3]);
                }
            }
        }

        char res = 'd';
        for (int i = 0; i < 4; i++) {

            if (!ar.contains(colors[i])) {
                res = colors[i];
                break;
            }
        }

        return res;

    }
}