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.
/*
* To change this template, choose Tools | Templates and open the template in
* the editor.
*/

import java.io.*;

import java.util.*;


public class Task extends ASolver {

    char[][] x;
    int n;

    public static void main(String[] args) throws IOException {
        Task task = new Task();
        task.init();
        task.readData();
        task.writeData(task.solve());
    }

    @Override
    public void init() {
        super.init();
    }

    @Override
    public boolean readData() {
        try {

            n = nextInt();

            x = new char[n][n];
            for (int i = 0; i < n; i++) {
                String line = next();
                x[i] = line.toCharArray();
            }

        } catch (Exception ex) {
            System.out.println(ex.getCause());
            System.out.println(ex.getMessage());
            return false;
        }
        return true;
    }

    public String solve() throws IOException {

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (x[i][j] == '#') {
                    if (isTopOfCross(i, j)) {
                        flushCross(i, j);
                        return solve();
                    } else {
                        return "NO";
                    }

                }
            }
        }

        return "YES";
    }

    public boolean isTopOfCross(int topI, int topJ) {

        if (topI + 2 >= n || topJ - 1 < 0 || topJ + 1 >= n) {
            return false;
        }

        return x[topI + 1][topJ - 1] == '#'
                && x[topI + 1][topJ + 1] == '#'
                && x[topI + 1][topJ] == '#'
                && x[topI + 2][topJ] == '#';
    }

    public void flushCross(int topI, int topJ) {
        x[topI][topJ] = '.';
        x[topI + 1][topJ - 1] = '.';
        x[topI + 1][topJ + 1] = '.';
        x[topI + 1][topJ] = '.';
        x[topI + 2][topJ] = '.';
    }

}

abstract class ASolver {

    protected StringTokenizer tokens;
    protected BufferedReader input;
    protected PrintWriter output;

    public void init() {
        input = new BufferedReader(new InputStreamReader(System.in));
    }

    public abstract boolean readData();

    public void writeData(String result) {
        System.out.println(result);
    }

    public void writeData(int result) {
        System.out.println(result);
    }

    public void writeData(long result) {
        System.out.println(result);
    }

    public int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    public double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    public String next() throws IOException {
        while (tokens == null || !tokens.hasMoreTokens()) {
            tokens = new StringTokenizer(input.readLine());
        }
        return tokens.nextToken();
    }

    public String nextPoints() throws IOException {
        while (tokens == null || !tokens.hasMoreTokens()) {
            tokens = new StringTokenizer(input.readLine(), "\n");
        }
        return tokens.nextToken();
    }

    public long infinityImitator(long a, long b) {
        if (a == Long.MIN_VALUE) {
            return Long.MIN_VALUE;
        } else {
            return a + b;
        }
    }

    public int infinityImitator(int a, int b) {
        if (a == Integer.MIN_VALUE) {
            return Integer.MIN_VALUE;
        } else {
            return a + b;
        }
    }

    /*
     * public long max(long... a) { long result = Long.MIN_VALUE; for (int i =
     * 0; i < a.length; i++) { result = Math.max(result, a[i]); } return result;
     * }
     */
    public int indexMax(int... a) {
        int result = 0;
        int index = -1;
        int length = a.length;
        for (int i = 0; i < length; i++) {
            if (a[i] > result) {
                result = a[i];
                index = i;
            }
        }
        return index;
    }

    public int indexMax(long... a) {
        long result = 0;
        int index = -1;
        int length = a.length;
        for (int i = 0; i < length; i++) {
            if (a[i] > result) {
                result = a[i];
                index = i;
            }
        }
        return index;
    }

    public int max(int... a) {
        int result = Integer.MIN_VALUE;
        for (int i = 0; i < a.length; i++) {
            result = Math.max(result, a[i]);
        }
        return result;
    }

    public long max(long... a) {
        long result = Integer.MIN_VALUE;
        for (int i = 0; i < a.length; i++) {
            result = Math.max(result, a[i]);
        }
        return result;
    }

    public int nod(int[] array) {
        int nod = array[0];

        for (int i = 1; i < array.length; i++) {
            nod = nod(nod, array[i]);
        }

        return nod;
    }

    private int nod(int m, int n) {

        int result = 0;

        if (m == 0) {
            return n;
        }

        if (n == 0) {
            return m;
        }

        if (n == m) {
            return m;
        }

        if (m == 1 || n == 1) {
            return 1;
        }

        int mDel = m % 2;
        int nDel = n % 2;


        if (mDel != 0 && nDel != 0) {
            return nod((Math.max(m, n) - Math.min(m, n)) / 2, Math.min(m, n));
        } else if (mDel == 0 && nDel != 0) {
            return nod(m / 2, n);
        } else if (mDel != 0 && nDel == 0) {
            return nod(m, n / 2);
        } else {
            return 2 * nod(m / 2, n / 2);
        }
    }
}