Fox Ciel starts to learn programming. The first task is drawing a fox! However, that turns out to be too hard for a beginner, so she decides to draw a snake instead.

A snake is a pattern on a n by m table. Denote c-th cell of r-th row as (r, c). The tail of the snake is located at (1, 1), then it's body extends to (1, m), then goes down 2 rows to (3, m), then goes left to (3, 1) and so on.

Your task is to draw this snake for Fox Ciel: the empty cells should be represented as dot characters ('.') and the snake cells should be filled with number signs ('#').

Consider sample tests in order to understand the snake pattern.

Input

The only line contains two integers: n and m (3 ≤ n, m ≤ 50). 

n is an odd number.

Output

Output n lines. Each line should contain a string consisting of m characters. Do not output spaces.

Examples

Input

3 3


Output

###
..#
###


Input

3 4


Output

####
...#
####


Input

5 3


Output

###
..#
###
#..
###


Input

9 9


Output

#########
........#
#########
#........
#########
........#
#########
#........
#########
// don't place package name class name "Codechef", Main only if class is public

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
import java.util.*;

public final class Main{
    public static class FastReader{
        BufferedReader br;
        StringTokenizer st;
        public FastReader(){
            br=new BufferedReader(new InputStreamReader(System.in));
        }
        String next(){
            while (st==null || !st.hasMoreElements()){
                try{
                    st=new StringTokenizer(br.readLine());
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        int nextInt(){
            return Integer.parseInt(next());
        }
        long nextLong(){
            return Long.parseLong(next());
        }
        double nextDouble(){
            return Double.parseDouble(next());
        }
        float nextFloat(){
            return Float.parseFloat(next());
        }
        String nextLine(){
            String str="";
            try{
                str=br.readLine();
            }catch (Exception e){
                e.printStackTrace();
            }
            return str;
        }
    }

    static FastReader in= new FastReader();
    public static void main(String[] args) throws FileNotFoundException {
        //long t= in.nextLong();
        //while (t-->0){
            solve();
        //}
    }

    static void solve(){
        int n= in.nextInt();
        int m= in.nextInt();
        StringBuffer sb= new StringBuffer();
        for(int i=1;i<=n;i++){
            if(i%2==1){
                for(int j=1;j<=m;j++){
                    sb.append("#");
                }
            }else{
                if((i/2)%2==0){
                    sb.append("#");
                    for(int j=1;j<=m-1;j++){
                        sb.append(".");
                    }
                }else{
                    for(int j=1;j<=m-1;j++){
                        sb.append(".");
                    }
                    sb.append("#");
                }
            }
            sb.append("\n");
        }
        System.out.println(sb);
    }

    int isDigitSumPalindrome(int N) {
        // code here
        int sum= sumOfDigits(String.valueOf(N));
        int rev=0;
        int org= sum;
        while (sum!=0){
            int d= sum%10;
            rev = rev*10 +d;
            sum /= 10;
        }
        if (org==rev){
            return 1;
        }else{
            return 0;
        }
    }

    int sumOfDigits(String n){
        int sum= 0;
        for (char c: n.toCharArray()){
            sum += Integer.parseInt(String.valueOf(c));
        }
        return sum;
    }

    public static int[] revArray(int[] arr) {
        int n= arr.length;
        int i=0, j=n-1;
        while (i<j){
            int temp= arr[i];
            arr[i]= arr[j];
            arr[j]= temp;
            i++;
            j--;
        }
        return arr;
    }

    static long gcd(long a, long b){
        if (b==0)
            return a;
        return gcd(b, a%b);
    }
    static long lcm(long a,long b){
        return (a*b)/gcd(a,b);
    }

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

    static class Compare {
        static void compare(ArrayList<Pair> arr, long n) {
            arr.sort(new Comparator<Pair>() {
                @Override
                public int compare(Pair p1, Pair p2) {
                    return (int) (p1.first - p2.first);
                }
            });
        }
    }
}