You are given a grid of squares with H horizontal rows and W vertical columns, where each square is painted white or black. HW characters from A_{11} to A_{HW} represent the colors of the squares. A_{ij} is `#` if the square at the i-th row from the top and the j-th column from the left is black, and A_{ij} is `.` if that square is white.

We will repeatedly perform the following operation until all the squares are black:

* Every white square that shares a side with a black square, becomes black.



Find the number of operations that will be performed. The initial grid has at least one black square.

Constraints

* 1 \leq H,W \leq 1000
* A_{ij} is `#` or `.`.
* The given grid has at least one black square.

Input

Input is given from Standard Input in the following format:


H W
A_{11}A_{12}...A_{1W}
:
A_{H1}A_{H2}...A_{HW}


Output

Print the number of operations that will be performed.

Examples

Input

3 3
...
.#.
...


Output

2


Input

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


Output

3
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.Queue;

public class Main {
    static boolean[][] white;
    static Queue<Point> q;

    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String[] line0 = reader.readLine().split(" ");
        int h = Integer.parseInt(line0[0]);
        int w = Integer.parseInt(line0[1]);
        white = new boolean[h + 2][w + 2];
        q = new ArrayDeque<>(h * w);
        for (int x = 0; x < h; x++) {
            String line = reader.readLine();
            for (int y = 0; y < w; y++) {
                if (line.charAt(y) == '#') {
                    q.offer(new Point(x, y, 0));
                } else {
                    white[x + 1][y + 1] = true;
                }
            }
        }
        while (!q.isEmpty()) {
            Point p = q.poll();
            int x = p.x;
            int y = p.y;
            int nextDepth = p.depth + 1;
            neighbor(x - 1, y, nextDepth);
            neighbor(x + 1, y, nextDepth);
            neighbor(x, y - 1, nextDepth);
            neighbor(x, y + 1, nextDepth);
        }
        System.out.println(Point.maxDepth);
    }

    static void neighbor(int x, int y, int depth) {
        if (white[x + 1][y + 1]) {
            q.offer(new Point(x, y, depth));
            white[x + 1][y + 1] = false;
        }
    }

    static class Point {
        int x;
        int y;
        int depth;
        static int maxDepth;

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