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.io.*;
import java.math.BigInteger;
import java.util.*;
 
 
 
 public class Main {
	public static InputReader in;
    public static PrintWriter pw;
 
 
 
	public static void main(String args[]) {
		new Thread(null, new Runnable() {
            public void run() {
                try{
                    solve();
                }
                catch(Exception e){
                    e.printStackTrace();
                }
            }
        }, "1", 1 << 26).start();
    }
	static ArrayList<Integer> g[];
	static ArrayList<Integer> h[];
	static boolean visited[];
	static boolean visit[];
	static int par[];
	static int degree[];
	static int edjes=0;
	static int start=-1;
	static int end=-1;
	static int Total=0;
	static int time1[];
	static int time2[];
	static int glob=0;
	static long cnt=0;
	static boolean vis2[][];
	static int lev=1;
    static int depth[];
    static long[] sm;
    static int val[];
    static int len=0;
    static long sum1=0;
    static int pre[][];
 static HashMap<String,Integer> hm;
 //static TreeSet<Long> set;
 static boolean Not[];
 //static int pre[][];
 static int ana[];
 static HashSet<Integer> set[];
    public static void solve(){
		
	
		 in = new InputReader(System.in);
	 	 pw = new PrintWriter(System.out);
	     
        int n=in.nextInt();
        char c[][]=new char[n][n];
        for(int i=0;i<n;i++)
        {
        	String s=in.readString();
        	for(int j=0;j<n;j++)
        		c[i][j]=s.charAt(j);
        }
        boolean bool[][]=new boolean[n][n];
        for(int i=0;i<n;i++)
        {
        	for(int j=0;j<n;j++)
        	{
        		if(!bool[i][j]&&c[i][j]=='#')
        		{
        			if(i-1>=0&&i+1<n&&j+1<n&&j-1>=0&&!bool[i-1][j]&&!bool[i+1][j]&&!bool[i][j+1]&&!bool[i][j-1])
        			{
        if(c[i-1][j]=='#'&&c[i-1][j]==c[i+1][j]&&c[i+1][j]==c[i][j-1]&&c[i][j-1]==c[i][j+1])
        {
        	bool[i-1][j]=true;
        	bool[i+1][j]=true;
        	bool[i][j-1]=true;
        	bool[i][j+1]=true;
        	bool[i][j]=true;
        }
        			}
        		}
        	}
        }
        for(int i=0;i<n;i++)
        {
        	for(int j=0;j<n;j++)
        	{
        		if(c[i][j]=='#'&&!bool[i][j])
        		{
        			System.out.println("NO");
        			System.exit(0);
        		}
        	}
        }
        System.out.println("YES");
    }
    
  private static boolean check(int mid, int[] a, int[] pr,int n) {
	
	  HashMap<Integer,Integer> hm=new HashMap();
	  
	  for(int i=1;i<=(mid+1);i++)
	  {
		  for(int x:set[i]){
		if(!hm.containsKey(x))
		  hm.put(x,1);
		else
			hm.put(x,hm.get(x)+1);
		if(hm.get(x)==(mid+1))
		{
			//System.out.println(i+" "+mid);
			//ana[i]=1;
			return true;
		}
		  }
	  }
	  int now=1;
	  int then=mid+2;
	  while(then<=n)
	  {
		  for(int x:set[now])
		  {
			  if(hm.containsKey(x))
				  hm.put(x,hm.get(x)-1);
		  }
		  for(int x:set[then])
		  {
			  if(!hm.containsKey(x))
				  hm.put(x,1);
			  else
				  hm.put(x,hm.get(x)+1);
			  if(hm.get(x)==(mid+1))
			  {
				  
				  ana[now+1]=1;
				  return true;
			  }
		  }
		  now++;
		  then++;
	  }
	  
	return false;
}

/*  public static int bfs(int x,int y,int tx,int ty,int n,int m)
    {
    		boolean vis[][]=new boolean[101][101];
    		vis[x][y]=true;
    		int lev=0;
    		Queue<String> Q=new LinkedList();
    		String sx=x+" "+y;
    		Q.add(sx);
    		while(!Q.isEmpty())
    		{
    			int count=Q.size();
    			while(count>0)
    			{
    				String p=Q.poll();
    				int i=Integer.parseInt(p.split(" ")[0]);
    				int j=Integer.parseInt(p.split(" ")[1]);
    				vis[i][j]=true;
    				if(i==tx&&j==ty)
    				{
    					return lev;
    				}
    				if(i==tx&&(j-1)==ty)
    				{
    					return lev;
    				}
    				if(i==tx&&(j+1)==ty)
    				{
    					return lev;
    				}
    				if((i+1)==tx&&(j)==ty)
    				{
    					return lev;
    				}
    				if((i-1)==tx&&(j)==ty)
    				{
    					return lev;
    				}
    				if(i<n&&j-1>=0&&!vis[i][j-1]&&a[i][j-1]=='O')
    				{
    					vis[i][j-1]=true;
    					String s=(i)+" "+(j-1);
    					Q.add(s);
    				}
    				if(i<n&&j+1<m&&!vis[i][j+1]&&a[i][j+1]=='O')
    				{
    					vis[i][j+1]=true;
    					String s=(i)+" "+(j+1);
    					Q.add(s);
    				}
    				if(i+1<n&&j<m&&!vis[i+1][j]&&a[i+1][j]=='O')
    				{
    					vis[i+1][j]=true;
    					String s=(i+1)+" "+j;
    					Q.add(s);
    				}
    				if(i-1>=0&&j<m&&!vis[i-1][j]&&a[i-1][j]=='O')
    				{
    					vis[i-1][j]=true;
    					String s=(i-1)+" "+j;
    					Q.add(s);
    				}
    				count--;
    			}
    			lev++;
    		//	System.out.println(Q);
    		}
    		return -1;
    }*/
    public static void dfs(int curr,int parent)
    {
    	visited[curr]=true;
    	par[curr]=parent;
    	for(int x:g[curr])
    	{
    		if(!visited[x])
    		{
    		depth[x]=depth[curr]+1;
    		dfs(x,curr);	
    		}
    	}
    		
    	
    }
  /*  public static void dfs2(int curr,int parent, HashSet<Integer> fk)
    {
    	visited[curr]=true;
    	fk.add(curr);
    	//System.out.print(curr+" ");
    	cnt++;
    	for(int x:g[curr])
    	{
    		if(x!=parent)
    		{
    			dfs2(x,par[x],fk);
    		}
    	}
    }*/
    /*public static void dfs1(int curr)
    {
    	visited[curr]=true;
    	long find=sm[curr]-(long)val[curr];
    	if(set.lower(find)!=null)
    	{
    		cnt+=(size[curr]);
    		return;
    	}
    	set.add(sm[curr]);
    	for(int x:g[curr])
    	{
    		if(!visited[x])
    			dfs1(x);
    	}
    	set.remove(sm[curr]);
    }
   /* public static void dfs(int curr,int parent)
    {
    	visited[curr]=true;
    	par[curr]=parent;
    	String s=curr+" "+parent;
    	sum1+=(hm.get(s));
    	size[curr]=1;
    	for(int x:g[curr])
    	{
    		if(!visited[x])
    		{
    			dfs(x,curr);
    			size[curr]+=size[x];
    		}
    	}
    	sm[curr]=sum1;
    	String p=curr+" "+parent;
    	sum1-=(hm.get(p));
    }
	public static int len(String s)
    {
    	
    	if(s.charAt(len++)=='l')
    	{
    		return 1;
    	}
    	else{
    		return Math.max(len(s), len(s))+1;
    	}
    }
    */
    
   public static int LCA(int p,int q)
    {
    	if(depth[p]<depth[q])
		{
			int tmp=p;
			p=q;
			q=tmp;
		}
		int dist=depth[p]-depth[q];
		while(dist>0)
		{
			int raise=(int)(Math.log(dist)/Math.log(2));
			p=pre[p][raise];
			dist-=(1<<raise);
		}
		if(p==q)
		{
			return p;
		}
		else{
		
		int current=(int)(Math.log(depth[p])/Math.log(2));
		for(int j=current;j>=0;j--)
		{
			if(pre[p][j]!=0&&pre[p][j]!=pre[q][j])
			{
				p=pre[p][j];
				q=pre[q][j];
			}
		}
		}
	return par[p];
    }
    
public static void dfs(int curr,int lev,int parent)
{
     visited[curr]=true;
     depth[curr]=lev;
     par[curr]=parent;
    // set[lev].add(curr);
     for(int x:g[curr])
     {
    	 if(!visited[x])
    	 {
    		 dfs(x,lev+1,curr);
    	 }
     }
     
}


	




     
        
     
        

   
/*public static void dfs2(int curr,int lev)
{
	time1[curr]=glob++;
	
	depth[curr]=lev;
	visited[curr]=true;
	nodes[lev].add(time1[curr]);
	values[lev].add(a[curr]);
	for(int x:g[curr])
	{
		if(!visited[x])
		{
			dfs2(x,lev+1);
		}
	}
time2[curr]=glob++;
}
 
 
 
public static void bfs1(int curr)
{
Queue<Integer> Q=new LinkedList<Integer>();
Q.add(1);
visit[1]=true;
int lev=2;
levels[1].add(1);
while(!Q.isEmpty())
{
	int cnt=Q.size();
	while(cnt>0)
	{
		int p=Q.poll();
		visit[p]=true;
		for(int x:g[p])
		{
			if(!visit[x])
			{
				Q.add(x);
				levels[lev].add(x);
			}
		}
		cnt--;
	}
	max=Math.max(lev, max);
	lev++;
}
}
 
 
	
 	private static long fact(int len) {
	long ans=1;
	for(int i=1;i<=len;i++)
		ans*=i;
	return ans;
}
 */
 
 
	
	// SubTree Checker DFS (TO CHECK IF X IS IN A SUBTREE OF Y)
	public static void dfs3(int curr)
	{
		visited[curr]=true;
		time1[curr]=glob++;
		for(int x:g[curr])
		{
		if(!visited[x])
			dfs3(x);
		}
		time2[curr]=glob++;
	}
    
	
	
 
    /*NO OF EDJES IN WHOLE CONNECTED COMPONENTS
  
	public static void dfs1(int curr)
	{
		visited[curr]=true;
		for(int next:g[curr])
		{
			edje++;
			if(!visited[next])
				dfs1(next);
		}
	}
	/*SUM OF ALL SUBTREE NODE'S VLAUES DFS
	public static void dfs(int curr,int prev)
		{
		val[curr]=1;
			for(int x:g[curr])
			{
				if(x!=prev)
				{
		            dfs(x,curr);
		            val[curr]+=val[x];
					
			    }
			}
		}*/
	
		public static long power(long a,long b)
		{
			long result=1;
			while(b>0)
			{
				if(b%2==1)
					result*=a;
				a=a*a;
				b/=2;
			}
			return result;
		}
				public static long pow(long n,long p,long m)
	{
		 long  result = 1;
		  if(p==0)
		    return 1;
		if (p==1)
		    return n;
		while(p!=0)
		{
		    if(p%2==1)
		        result *= n;
		    if(result>=m)
		    result%=m;
		    p >>=1;
		    n*=n;
		    if(n>=m)
		    n%=m;
		}
		return result;
	}
	static class Pair implements Comparable<Pair>{
	int now;
		int aft;
		int index;
		Pair(int ver,int weight,int index){
	     	this.now=ver;
			this.aft=weight;
			this.index=index;
			
		}
		@Override
		public int compareTo(Pair o) {
			if((o.now-o.aft)-(now-aft)!=0)
				return (int)-((o.now-o.aft)-(now-aft));

				return (int)(o.now-now);
		}
				
	}
	public static long gcd(long a, long b) {
		  if (b == 0) return a;
		  return gcd(b, a%b);
		}
	static class InputReader {
 
		private InputStream stream;
		private byte[] buf = new byte[8192];
		private int curChar, snumChars;
		private SpaceCharFilter filter;
 
		public InputReader(InputStream stream) {
			this.stream = stream;
		}
 
		public int snext() {
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars) {
				curChar = 0;
				try {
					snumChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (snumChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}
 
		public   int nextInt() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}
 
		public long nextLong() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = snext();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = snext();
			} while (!isSpaceChar(c));
			return res * sgn;
		}
 
		public int[] nextIntArray(int n) {
			int a[] = new int[n];
			for (int i = 0; i < n; i++)
				a[i] = nextInt();
			return a;
		}
 
		public String readString() {
			int c = snext();
			while (isSpaceChar(c))
				c = snext();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = snext();
			} while (!isSpaceChar(c));
			return res.toString();
		}
 
		public boolean isSpaceChar(int c) {
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
 
		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);
		}
	}
}
