The city of Fishtopia can be imagined as a grid of 4 rows and an odd number of columns. It has two main villages; the first is located at the top-left cell (1,1), people who stay there love fishing at the Tuna pond at the bottom-right cell (4, n). The second village is located at (4, 1) and its people love the Salmon pond at (1, n).

The mayor of Fishtopia wants to place k hotels in the city, each one occupying one cell. To allow people to enter the city from anywhere, hotels should not be placed on the border cells.

A person can move from one cell to another if those cells are not occupied by hotels and share a side.

Can you help the mayor place the hotels in a way such that there are equal number of shortest paths from each village to its preferred pond?

Input

The first line of input contain two integers, n and k (3 ≤ n ≤ 99, 0 ≤ k ≤ 2×(n-2)), n is odd, the width of the city, and the number of hotels to be placed, respectively.

Output

Print "YES", if it is possible to place all the hotels in a way that satisfies the problem statement, otherwise print "NO".

If it is possible, print an extra 4 lines that describe the city, each line should have n characters, each of which is "#" if that cell has a hotel on it, or "." if not.

Examples

Input

7 2


Output

YES
.......
.#.....
.#.....
.......


Input

5 3


Output

YES
.....
.###.
.....
.....
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);



            int col = in.nextInt();
            int n = in.nextInt();

            List<Point> li = new ArrayList<>(400);
            boolean possible = true;


            if (n < 4) {
                if (n == 1) {
                    li.add(new Point(2, (col + 1) / 2));
                } else if (n == 2) {
                    li.add(new Point(2, (col + 1) / 2));
                    li.add(new Point(3, (col + 1) / 2));
                } else if (n == 3) {
                    if (col - 2 < 3) {
                        possible = false;
                    } else {
                        li.add(new Point(2, (col + 1) / 2 + 1));
                        li.add(new Point(2, (col + 1) / 2));
                        li.add(new Point(2, (col + 1) / 2 - 1));
                    }
                }
            } else {
                int re = n - n / 4 * 4;
                if (re == 3) {
                    int r2 = n/2;
                    int r2s1 = r2/2;
                    if(n - n/2 + 1>col-2){
                        possible = false;
                    }
                    if(possible){
                        for(int j=(col+1)/2-r2s1;j<=(col+1)/2+r2s1;j++){
                            li.add(new Point(2,j));
                        }
                        int r2s2 = (n-r2)/2;
                        for(int j=(col+1)/2-r2s2;j<=(col+1)/2+r2s2;j++){
                            if(j!=(col+1)/2)
                                li.add(new Point(3,j));
                        }
                    }

                } else if (re == 0) {
                    int colspan = n / 2;
                    if (col - 2 < colspan) {
                        possible = false;
                    } else {
                        int oneside = colspan / 2;
                        for (int j = (col + 1) / 2 - oneside; j <= (col + 1) / 2 + oneside; j++) {
                            if (j == (col + 1) / 2) {
                                continue;
                            }
                            li.add(new Point(2, j));
                            li.add(new Point(3, j));
                        }
                    }
                } else if (re == 1) {
                    int colspan = n / 2;
                    if (col - 2 < colspan) {
                        possible = false;
                    } else {
                        int oneside = colspan / 2;
                        for (int j = (col + 1) / 2 - oneside; j <= (col + 1) / 2 + oneside; j++) {
                            if (j == (col + 1) / 2) {
                                li.add(new Point(2, j));
                            } else {
                                li.add(new Point(2, j));
                                li.add(new Point(3, j));
                            }

                        }
                    }
                } else if (re == 2) {
                    int colspan = n / 2;
                    if (col - 2 < colspan) {
                        possible = false;
                    } else {
                        int oneside = colspan / 2;
                        for (int j = (col + 1) / 2 - oneside; j <= (col + 1) / 2 + oneside; j++) {
                            li.add(new Point(2, j));
                            li.add(new Point(3, j));
                        }
                    }
                }
            }

            if (possible) {
                System.out.println("YES");
                System.out.println(drawPoints(li, 4, col));
            } else {
                System.out.println("NO");
            }


    }

    public static String drawPoints(List<Point> li,int row, int col){
        StringBuilder sb = new StringBuilder();
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                sb.append('.');
            }
            sb.append('\n');
        }
        for(Point p:li){
            int relpos = (p.x-1)*(col+1) + (p.y-1);
            sb.setCharAt(relpos,'#');
        }
        return sb.toString();
    }

}

class Point{
    public int x;
    public int y;

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