Fox Ciel has a board with n rows and n columns. So, the board consists of n × n cells. Each cell contains either a symbol '.', or a symbol '#'.

A cross on the board is a connected set of exactly five cells of the board that looks like a cross. The picture below shows how it looks.

<image>

Ciel wants to draw several (may be zero) crosses on the board. Each cross must cover exactly five cells with symbols '#', and any cell with symbol '#' must belong to some cross. No two crosses can share a cell.

Please, tell Ciel if she can draw the crosses in the described way.

Input

The first line contains an integer n (3 ≤ n ≤ 100) — the size of the board.

Each of the next n lines describes one row of the board. The i-th line describes the i-th row of the board and consists of n characters. Each character is either a symbol '.', or a symbol '#'.

Output

Output a single line with "YES" if Ciel can draw the crosses in the described way. Otherwise output a single line with "NO".

Examples

Input

5
.#...
####.
.####
...#.
.....


Output

YES


Input

4
####
####
####
####


Output

NO


Input

6
.#....
####..
.####.
.#.##.
######
.#..#.


Output

YES


Input

6
.#..#.
######
.####.
.####.
######
.#..#.


Output

NO


Input

3
...
...
...


Output

YES

Note

In example 1, you can draw two crosses. The picture below shows what they look like.

<image>

In example 2, the board contains 16 cells with '#', but each cross contains 5. Since 16 is not a multiple of 5, so it's impossible to cover all.
import java.util.*;
import java.math.*;
import java.io.*;
import java.text.*; 
 public class A{

    static FastReader scan=new FastReader();
   public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
  
static char mat[][]=new char[105][105];

long  get( long x){
    return x*(x-1)/2;
}
static boolean can(int x,int y){
    if(mat[x-1][y]!='#')return false;
    if(mat[x+1][y]!='#')return false;
    if(mat[x][y-1]!='#')return false;
    if(mat[x][y+1]!='#')return false;
    return true;

}
static void make(int x,int y){
    mat[x][y]=mat[x+1][y]=mat[x-1][y]=mat[x][y-1]=mat[x][y+1]='.';

}
public static void main(String[] args)  throws Exception 
{
/*long n=scan.nextLong();
long m=scan.nextLong();
if(m==1)
{
    out.print((n*2)+" "+(n*2));
    out.close();
    return;
}
long min=n/m;
min*=m;
min/=2;
out.print(min+" ");
long max=m-1;
n-=max;
out.println(n*(n-1)/2);*/
//KMP
/*
KMP uses degenerating property(pattern having same sub-
patterns appearing more than once in the pattern)
the idea:whenever we detect a mismatch(after some matches)
,we already know some of the characters in the text of the 
next window.We take advantage of this info to avoid matching 
the chars that we know will anyway match. 

TIME O(N) in the worst case
*/
 int n=scan.nextInt();
 //System.out.println(mat[100][100]);
 char used[][]=new char[n][n];
 for(int i=0;i<n;i++)
 used[i]=scan.next().toCharArray();

for (int i=1; i<=n; ++i){
            for (int j=1; j<=n; ++j){
                mat[i][j] = used[i-1][j-1];
            }
        }



 for(int i=1;i<=n;i++){
    for(int j=1;j<=n;j++){
    //System.out.println("i "+i+" j "+j);
        
        if(mat[i][j]=='.')
            continue;       
        if(can(i,j))
            make(i,j);    
      
    }
 }
  for(int i=1;i<=n;i++){
    for(int j=1;j<=n;j++){
       // System.out.println("i "+i+" j "+j );
       
        if(mat[i][j]=='#')
            {
                out.println("NO");
                out.close();
                return;
            }
          
            



    }}
    out.println("YES");



      
 out.close();








  

}
 public static  long pow(long b, long e) {
            long r = 1;
            while (e > 0) {
                if (e % 2 == 1) r = r * b ;
                b = b * b;
                e >>= 1;
            }
            return r;
        }
private static void sort(long[] arr) {
        List<Long> list = new ArrayList<>();
        for (long object : arr) list.add(object);
        Collections.sort(list);
        for (int i = 0; i < list.size(); ++i) arr[i] = list.get(i);
    }
 public static class FastReader {
        BufferedReader br;
        StringTokenizer root;
        
 
        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
 
        String next() {
            while (root == null || !root.hasMoreTokens()) {
                try {
                    root = new StringTokenizer(br.readLine());
                } catch (Exception addd) {
                    addd.printStackTrace();
                }
            }
            return root.nextToken();
        }
 
        int nextInt() {
            return Integer.parseInt(next());
        }
 
        double nextDouble() {
            return Double.parseDouble(next());
        }
 
        long nextLong() {
            return Long.parseLong(next());
        }
 
        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (Exception addd) {
                addd.printStackTrace();
            }
            return str;
        }
         public int[] nextIntArray(int arraySize) {
            int array[] = new int[arraySize];
 
            for (int i = 0; i < arraySize; i++) {
                array[i] = nextInt();
            }
 
            return array;
        }
}
static class pair{
    int i;
    int j;
pair(int i,int j){
    this.i=i;
    this.j=j;
}

}}







