Algorithms
Medium
2768
2889
Number of Black Blocks
number-of-black-blocks
"""
You are given two integers m and n representing the dimensions of a 0-indexed m x n grid.

You are also given a 0-indexed 2D integer matrix coordinates, where coordinates[i] = [x, y] indicates that the cell with coordinates [x, y] is colored black. All cells in the grid that do not appear in coordinates are white.

A block is defined as a 2 x 2 submatrix of the grid. More formally, a block with cell [x, y] as its top-left corner where 0 <= x < m - 1 and 0 <= y < n - 1 contains the coordinates [x, y], [x + 1, y], [x, y + 1], and [x + 1, y + 1].

Return a 0-indexed integer array arr of size 5 such that arr[i] is the number of blocks that contains exactly i black cells.

Example 1:

Input: m = 3, n = 3, coordinates = [[0,0]]
Output: [3,1,0,0,0]
Explanation: The grid looks like this:
[https://assets.leetcode.com/uploads/2023/06/18/screen-shot-2023-06-18-at-44656-am.png]
There is only 1 block with one black cell, and it is the block starting with cell [0,0].
The other 3 blocks start with cells [0,1], [1,0] and [1,1]. They all have zero black cells.
Thus, we return [3,1,0,0,0].

Example 2:

Input: m = 3, n = 3, coordinates = [[0,0],[1,1],[0,2]]
Output: [0,2,2,0,0]
Explanation: The grid looks like this:
[https://assets.leetcode.com/uploads/2023/06/18/screen-shot-2023-06-18-at-45018-am.png]
There are 2 blocks with two black cells (the ones starting with cell coordinates [0,0] and [0,1]).
The other 2 blocks have starting cell coordinates of [1,0] and [1,1]. They both have 1 black cell.
Therefore, we return [0,2,2,0,0].


Constraints:

 * 2 <= m <= 105
 * 2 <= n <= 105
 * 0 <= coordinates.length <= 104
 * coordinates[i].length == 2
 * 0 <= coordinates[i][0] < m
 * 0 <= coordinates[i][1] < n
 * It is guaranteed that coordinates contains pairwise distinct coordinates.
"""
class Solution:
    def countBlackBlocks(self, m: int, n: int, coordinates: List[List[int]]) -> List[int]:
        
You are given two integers m and n representing the dimensions of a 0-indexed m x n grid.

You are also given a 0-indexed 2D integer matrix coordinates, where coordinates[i] = [x, y] indicates that the cell with coordinates [x, y] is colored black. All cells in the grid that do not appear in coordinates are white.

A block is defined as a 2 x 2 submatrix of the grid. More formally, a block with cell [x, y] as its top-left corner where 0 <= x < m - 1 and 0 <= y < n - 1 contains the coordinates [x, y], [x + 1, y], [x, y + 1], and [x + 1, y + 1].

Return a 0-indexed integer array arr of size 5 such that arr[i] is the number of blocks that contains exactly i black cells.

Example 1:

Input: m = 3, n = 3, coordinates = [[0,0]]
Output: [3,1,0,0,0]
Explanation: The grid looks like this:
[https://assets.leetcode.com/uploads/2023/06/18/screen-shot-2023-06-18-at-44656-am.png]
There is only 1 block with one black cell, and it is the block starting with cell [0,0].
The other 3 blocks start with cells [0,1], [1,0] and [1,1]. They all have zero black cells.
Thus, we return [3,1,0,0,0].

Example 2:

Input: m = 3, n = 3, coordinates = [[0,0],[1,1],[0,2]]
Output: [0,2,2,0,0]
Explanation: The grid looks like this:
[https://assets.leetcode.com/uploads/2023/06/18/screen-shot-2023-06-18-at-45018-am.png]
There are 2 blocks with two black cells (the ones starting with cell coordinates [0,0] and [0,1]).
The other 2 blocks have starting cell coordinates of [1,0] and [1,1]. They both have 1 black cell.
Therefore, we return [0,2,2,0,0].


Constraints:

 * 2 <= m <= 105
 * 2 <= n <= 105
 * 0 <= coordinates.length <= 104
 * coordinates[i].length == 2
 * 0 <= coordinates[i][0] < m
 * 0 <= coordinates[i][1] < n
 * It is guaranteed that coordinates contains pairwise distinct coordinates.


Please complete the code below to solve above prblem:
```python
class Solution:
    def countBlackBlocks(self, m: int, n: int, coordinates: List[List[int]]) -> List[int]:
        
```

my_solution = Solution()

test_input = { "m": 3, "n": 3, "coordinates": [[0,0]] }
assert my_solution.countBlackBlocks(**test_input) == [3,1,0,0,0]

test_input = { "m": 3, "n": 3, "coordinates": [[0,0],[1,1],[0,2]] }
assert my_solution.countBlackBlocks(**test_input) == [0,2,2,0,0]

test_input = { "m": 32, "n": 32, "coordinates": [[17,29],[29,16],[19,20],[18,9],[16,7],[20,25],[22,19],[4,9],[14,17],[6,23],[2,2],[20,1],[8,7],[4,7],[14,14],[10,10],[1,27],[18,23],[6,30],[8,18],[26,23],[25,8],[5,6],[3,4]] }
assert my_solution.countBlackBlocks(**test_input) == [866,94,1,0,0]

test_input = { "m": 22, "n": 73, "coordinates": [[11,14],[16,11],[20,5],[5,33],[14,7],[16,60],[0,15],[15,72],[6,60],[9,16],[14,51],[1,52],[18,24],[17,30],[3,4],[19,13],[9,10],[11,40],[15,7],[13,62],[8,41],[12,71],[4,72],[18,7],[1,0],[4,35],[16,33],[7,30],[13,52],[5,1],[15,21],[3,59],[2,41],[4,28]] }
assert my_solution.countBlackBlocks(**test_input) == [1387,122,3,0,0]

test_input = { "m": 22, "n": 79, "coordinates": [[11,43],[17,56],[11,58],[19,68],[5,10],[18,35],[18,27],[10,53],[1,72],[4,64],[4,72],[3,76],[18,36],[14,47],[12,57],[10,11],[13,5],[17,39],[1,4],[3,32],[6,34],[2,62],[8,35],[9,18],[12,77],[8,43],[1,49],[15,14],[15,27],[4,68],[19,24],[9,19],[17,3],[3,51],[5,61]] }
assert my_solution.countBlackBlocks(**test_input) == [1503,130,5,0,0]

test_input = { "m": 3, "n": 89, "coordinates": [[0,46],[1,29],[0,50],[1,61]] }
assert my_solution.countBlackBlocks(**test_input) == [164,12,0,0,0]

test_input = { "m": 25, "n": 97, "coordinates": [[23,65],[11,33],[6,76],[9,65],[18,13],[16,59],[0,86],[17,14],[23,61],[8,78],[19,40],[18,57],[1,66],[15,1],[13,44],[17,6],[14,90],[1,22],[5,34],[0,53],[1,65],[20,32],[22,54],[3,11],[20,53],[7,70],[0,30],[23,17],[18,2],[14,93],[1,28],[19,82],[6,61],[13,64],[6,73],[0,52],[17,93],[20,63],[16,24],[14,6],[20,28],[4,57],[19,76],[21,50],[5,44],[5,29],[11,36],[14,87],[2,10],[4,78],[12,35],[11,27],[20,7],[11,20],[9,51],[22,37],[11,30],[2,77],[5,87],[13,5],[2,56],[23,25],[0,44],[19,23],[23,1],[3,70],[3,86],[17,92],[19,24],[23,39],[16,2],[15,45],[14,82],[21,30],[11,90],[7,82],[17,50],[12,66],[22,84],[15,71],[14,54]] }
assert my_solution.countBlackBlocks(**test_input) == [2002,290,12,0,0]

test_input = { "m": 58, "n": 74, "coordinates": [[38,21],[1,34],[29,15],[46,33],[56,7],[55,63],[7,32],[53,38],[30,73],[17,68],[32,26],[13,39],[10,22],[42,38],[29,9],[7,53],[17,2],[56,13],[34,26],[31,30],[16,21],[13,56],[16,72],[21,8],[47,28],[2,24],[32,23],[13,4],[37,29],[1,11],[45,70],[49,40],[11,61],[20,49],[11,4],[17,61],[11,68],[14,64],[31,10],[1,14],[10,47],[21,48],[46,51],[25,59],[45,12],[47,43],[32,39],[11,28],[55,46],[50,7]] }
assert my_solution.countBlackBlocks(**test_input) == [3964,196,1,0,0]

test_input = { "m": 40, "n": 82, "coordinates": [[11,63],[20,43],[16,53],[33,52],[7,30],[36,2],[25,65],[10,31],[4,29],[31,17],[14,52],[36,32],[35,68],[26,8],[20,68],[21,45],[7,46],[32,15],[33,13],[30,4],[32,9],[32,78],[32,66],[27,58],[20,14],[12,29],[8,80],[2,1],[1,0],[34,41],[1,3],[1,74],[0,69],[21,7],[36,16],[0,21],[4,80],[33,78],[18,11],[18,50],[17,63],[24,29]] }
assert my_solution.countBlackBlocks(**test_input) == [3000,156,3,0,0]

test_input = { "m": 57, "n": 92, "coordinates": [[38,14],[27,72]] }
assert my_solution.countBlackBlocks(**test_input) == [5088,8,0,0,0]

test_input = { "m": 94, "n": 98, "coordinates": [[39,62],[40,20],[47,78],[75,10],[52,82],[11,77],[52,21],[22,12],[75,42],[75,68],[42,39],[68,75],[1,29],[18,79],[56,82],[72,41],[52,28],[61,83],[44,55],[73,81],[43,71],[55,23],[4,13],[89,68],[36,57],[48,22],[64,49],[10,72],[84,80],[1,77],[50,7],[54,0],[76,9],[57,6],[7,81],[66,80]] }
assert my_solution.countBlackBlocks(**test_input) == [8880,140,1,0,0]

test_input = { "m": 30, "n": 97, "coordinates": [] }
assert my_solution.countBlackBlocks(**test_input) == [2784,0,0,0,0]

test_input = { "m": 11, "n": 28, "coordinates": [[7,24],[8,22],[1,5],[6,21],[0,22],[0,15],[4,16],[2,11],[0,11],[1,3],[3,26],[1,20],[5,27],[9,8],[7,25],[0,19],[3,21],[2,13],[6,7],[5,13],[0,1],[4,18],[4,1],[2,24],[7,17],[3,15],[9,18],[1,25],[3,18],[4,27],[4,20],[4,7],[9,12],[7,1],[3,12],[5,26],[5,23],[2,4],[3,5],[6,18],[4,10],[8,8],[2,7],[7,15],[5,0],[4,9],[8,1],[8,0],[1,17],[3,9],[2,10],[1,13],[0,10],[8,14],[1,21],[1,10],[7,8],[4,6],[7,23],[0,20],[8,13],[3,24],[1,15],[5,24],[4,11],[9,14],[4,12],[7,2],[2,25],[2,9],[6,14],[0,25],[7,4],[4,2],[6,1],[4,8],[6,17]] }
assert my_solution.countBlackBlocks(**test_input) == [83,107,63,17,0]

test_input = { "m": 6, "n": 47, "coordinates": [[1,1],[1,23],[1,5],[0,22],[1,12],[0,24],[4,24],[2,8],[1,11],[0,31],[1,39],[0,43],[2,18],[1,17],[1,3],[3,10],[0,26],[2,38],[1,0],[3,37],[3,2],[1,26],[4,34],[3,24],[0,23]] }
assert my_solution.countBlackBlocks(**test_input) == [159,58,11,2,0]

test_input = { "m": 45, "n": 88, "coordinates": [[13,14],[6,48],[4,20],[18,57],[2,48],[0,70],[42,71],[20,70],[29,11],[34,24],[24,28],[38,45],[31,73],[41,85],[18,69]] }
assert my_solution.countBlackBlocks(**test_input) == [3770,58,0,0,0]

test_input = { "m": 7, "n": 36, "coordinates": [[2,21],[3,14],[4,18],[5,30],[4,26],[5,7],[2,31],[4,22],[0,0],[2,22],[4,6],[0,30],[0,19],[0,21],[3,11],[4,28],[5,25],[2,11],[0,23],[5,16],[3,29],[3,17],[4,11],[1,7],[1,19],[1,34],[5,19],[5,6],[5,28],[4,8],[2,9],[1,6],[4,24],[2,14],[1,24],[3,16],[0,2],[0,26],[5,27],[3,35],[2,16],[4,2],[4,32],[5,0],[0,34],[1,5],[2,4],[1,4],[0,22],[2,2],[3,19],[3,4],[1,10],[3,5],[1,29],[0,33],[0,3]] }
assert my_solution.countBlackBlocks(**test_input) == [63,99,42,6,0]

test_input = { "m": 59, "n": 60, "coordinates": [[4,37],[56,0],[32,53],[27,8],[18,42],[5,25],[11,46],[51,55],[55,16],[7,17],[47,1],[47,38],[28,7],[17,39],[29,59],[47,39],[56,42],[2,31],[41,16],[44,32],[27,1],[14,8],[38,52],[38,48],[40,12],[25,32],[15,55],[12,22],[0,38],[38,58],[54,52],[19,28],[39,45],[10,43],[44,26],[18,14],[34,30],[6,23],[39,22],[15,29],[50,31],[24,11],[12,5],[42,45],[18,38],[27,56],[33,58],[54,24],[40,24],[24,2],[28,44],[33,53],[49,57],[47,56],[50,18],[25,14],[56,54],[40,55],[53,44],[27,42],[39,23],[44,38],[25,2],[47,14],[27,50],[26,46],[15,1],[16,15],[55,56],[27,21],[6,7]] }
assert my_solution.countBlackBlocks(**test_input) == [3155,256,11,0,0]

test_input = { "m": 89, "n": 90, "coordinates": [[12,15],[31,16],[75,79],[86,48],[19,77],[39,82],[77,62],[75,35],[19,35]] }
assert my_solution.countBlackBlocks(**test_input) == [7796,36,0,0,0]

test_input = { "m": 26, "n": 42, "coordinates": [[7,13],[1,3],[11,32],[5,8],[11,4],[9,24],[0,0],[18,20],[13,35],[19,31],[15,35],[1,41],[18,40],[18,41],[14,11],[20,0],[11,6],[14,16],[0,11],[4,36],[9,12],[20,36],[14,33],[6,34],[0,12],[22,6],[22,34],[13,6],[12,1],[4,23],[6,18],[11,38],[19,17],[22,27],[21,6],[3,35],[9,11],[23,6],[22,29],[8,5],[6,26],[3,18],[0,2],[3,41],[24,6],[24,1],[7,9],[8,35],[0,6],[6,23],[13,40],[10,38],[10,20],[21,7],[20,11],[10,11],[19,3],[14,9],[1,5],[3,30],[9,9],[17,34],[18,16],[3,26],[18,19],[17,16],[2,17],[5,22],[5,41],[16,32],[9,7],[1,36],[6,30],[6,38],[9,20],[4,28],[12,8],[7,26],[5,30],[2,27],[3,32],[11,7],[7,41],[8,4],[10,34],[19,19],[13,32],[23,25]] }
assert my_solution.countBlackBlocks(**test_input) == [739,246,37,3,0]

test_input = { "m": 31, "n": 46, "coordinates": [[5,31],[13,5],[6,32],[3,24],[5,41],[22,22],[18,38],[29,11],[25,28],[10,43],[29,5],[10,28],[21,2],[27,1],[4,42],[18,2],[22,26],[22,4],[2,26],[21,4],[5,32],[0,43],[24,32],[2,30],[18,44],[18,43],[7,36],[15,13],[11,29],[6,17],[10,7],[15,8],[4,11],[9,7],[28,1],[0,15],[21,19],[6,0],[24,19],[1,0],[15,30],[1,18],[4,24],[1,9],[24,16],[22,28],[4,35],[14,15],[27,23],[13,1],[2,8],[4,20],[19,30],[15,11],[0,34],[27,21],[10,1],[10,33],[11,26],[13,40],[11,45],[25,4],[28,28],[4,7],[7,29],[3,45],[20,17],[25,38],[27,41],[23,35],[19,10],[2,7],[0,25],[4,18],[23,37],[6,38]] }
assert my_solution.countBlackBlocks(**test_input) == [1081,251,17,1,0]

test_input = { "m": 11, "n": 21, "coordinates": [[0,19],[2,8],[6,9],[5,15],[6,15],[2,5],[3,14],[2,10],[8,13],[4,2],[0,0],[7,19],[9,10],[8,19]] }
assert my_solution.countBlackBlocks(**test_input) == [153,43,4,0,0]

test_input = { "m": 76, "n": 95, "coordinates": [[16,61],[1,23],[51,8],[36,87],[60,92],[23,44],[28,93],[15,35],[8,68],[58,57],[58,80],[53,7],[47,25],[55,4],[6,61],[43,56],[6,40],[39,44],[67,76],[44,16],[40,93],[7,6],[59,44],[74,6],[1,72],[38,93],[58,51],[17,79],[73,79],[58,65],[45,28],[17,36],[69,94],[66,73],[56,1],[31,62],[62,68],[54,64],[72,46],[67,59],[9,47],[33,86],[45,49],[3,6],[63,59],[51,47],[31,74],[52,42],[34,80],[61,30],[62,4],[11,9],[44,21],[73,69],[7,77],[43,17],[53,22],[37,10],[49,5],[64,82],[51,77],[74,2],[60,2],[17,53],[16,51],[52,80],[22,23],[17,80],[52,26],[15,1],[19,59],[7,39]] }
assert my_solution.countBlackBlocks(**test_input) == [6768,278,4,0,0]

test_input = { "m": 65, "n": 71, "coordinates": [[62,8],[18,63],[23,43],[30,3],[40,48],[60,62],[58,9],[13,20],[47,46],[34,0],[11,6],[17,28],[20,34],[24,48],[24,18],[43,18],[31,59],[25,60],[15,68],[24,35],[33,47],[32,4],[26,42],[35,63],[31,22],[16,0],[45,45],[52,19],[46,49],[36,37],[11,10],[23,5],[4,13],[17,20],[14,41],[26,4],[21,7],[52,40],[31,18],[55,26],[17,57],[41,31],[1,47],[56,61],[46,38],[7,16],[53,13],[45,4],[1,69],[29,15],[46,12],[29,65],[61,10],[35,54],[33,26],[41,34],[55,48],[42,48],[0,8],[44,44],[52,10],[30,37],[14,54],[4,29],[50,58],[41,10],[30,19],[31,1],[31,62],[31,44],[53,7],[12,56],[57,69],[34,2],[34,16],[42,68],[45,15],[44,61],[15,60],[54,69],[1,39],[50,59],[51,47],[52,15],[33,69],[5,51],[19,38],[10,61],[42,17],[60,30]] }
assert my_solution.countBlackBlocks(**test_input) == [4131,344,5,0,0]

test_input = { "m": 25, "n": 95, "coordinates": [[8,74],[20,10],[18,56],[23,20],[7,16],[7,5],[23,52],[19,31],[11,93],[0,68],[4,3],[21,52],[17,61],[7,65],[11,20],[1,61],[20,63],[9,71],[11,63],[11,61],[0,74],[17,60],[16,12],[3,54],[23,66],[23,37],[14,0],[19,64],[18,82],[4,87],[14,82],[23,3],[11,86],[3,64],[9,32],[14,8],[1,24],[21,20],[21,38],[22,27],[21,82],[10,58],[19,5],[22,57],[18,44],[10,83]] }
assert my_solution.countBlackBlocks(**test_input) == [2081,172,3,0,0]

test_input = { "m": 40, "n": 84, "coordinates": [[19,36],[35,7],[3,78],[17,4],[28,8],[20,38],[12,38],[30,6],[37,45],[26,53],[11,46]] }
assert my_solution.countBlackBlocks(**test_input) == [3193,44,0,0,0]

test_input = { "m": 8, "n": 57, "coordinates": [[3,38],[1,41],[6,23],[0,54],[3,11],[3,44],[1,24],[0,38],[5,28]] }
assert my_solution.countBlackBlocks(**test_input) == [360,32,0,0,0]

test_input = { "m": 32, "n": 41, "coordinates": [[12,13],[20,33],[3,12],[28,40],[9,10],[18,10],[5,18],[9,24],[29,24],[9,33],[25,38],[29,17],[28,25],[0,35],[2,30],[18,37],[7,0],[14,21],[25,27],[17,33],[9,38],[19,22],[17,5],[18,4],[9,18],[15,6],[4,21],[12,4],[5,35],[19,26],[6,6],[0,2],[0,28],[1,13],[19,10],[5,16],[2,31],[24,2],[3,22],[23,12],[0,17],[6,30],[20,31],[10,32],[17,15],[1,34],[28,6],[21,15],[14,11],[27,23],[4,16],[2,11],[21,26],[23,19],[27,15],[3,5],[28,10],[1,2],[27,18],[19,36],[2,2],[17,13],[7,19],[25,0],[5,37],[30,6],[3,39],[28,30],[26,0],[9,5],[23,5],[27,6],[4,26],[15,39],[10,26]] }
assert my_solution.countBlackBlocks(**test_input) == [976,244,20,0,0]

test_input = { "m": 63, "n": 99, "coordinates": [[17,28],[7,39],[14,81],[44,4],[21,7],[21,95],[1,89],[57,74],[34,2],[55,56],[43,50],[52,28],[38,61],[35,62],[57,46],[30,72],[25,46],[4,32],[18,25],[53,98]] }
assert my_solution.countBlackBlocks(**test_input) == [5998,78,0,0,0]

test_input = { "m": 44, "n": 97, "coordinates": [[17,3],[29,4],[40,71],[32,45],[3,59],[22,34],[11,17],[17,43],[4,32],[8,8],[19,43],[12,19],[32,57],[9,15],[7,46],[4,39],[11,26],[17,87],[21,70],[12,58],[35,88],[12,72],[23,61],[23,43],[3,86],[31,30],[17,26],[14,22],[16,77],[41,73],[39,91],[41,74],[15,78],[31,36],[11,45],[9,57],[25,68],[42,28],[5,60],[38,72],[26,14],[33,48],[39,50],[38,33],[41,21],[39,86],[29,64],[4,69],[37,25],[28,85],[9,32],[9,76],[13,25],[26,43],[10,79],[2,2],[23,85],[39,29],[34,47],[13,17],[34,59],[27,84],[29,93],[17,89],[23,27],[9,16],[39,64],[3,37],[41,75],[32,26],[27,11]] }
assert my_solution.countBlackBlocks(**test_input) == [3853,266,9,0,0]

test_input = { "m": 45, "n": 53, "coordinates": [[15,41],[0,27],[24,15],[34,31],[36,27],[32,46],[1,39],[4,8],[18,8],[39,3],[2,50],[6,33],[25,46],[17,41],[27,46],[37,30],[41,23],[16,14],[21,17],[26,47],[31,47],[9,23],[32,21],[29,28],[37,41],[10,37],[21,31],[1,25],[31,19],[16,49],[2,22],[1,43],[39,33],[6,12],[12,39],[40,15],[31,50],[8,7],[5,21],[8,4],[30,10],[15,20],[9,21],[38,28],[42,14],[36,8],[27,5],[2,2],[13,32],[13,50],[22,8],[23,25],[33,23],[9,22],[28,12],[15,37],[40,10],[42,45],[1,11],[26,2],[30,18],[0,19],[15,38],[32,2],[26,19],[29,29],[24,21],[24,10],[19,8],[24,31],[37,34],[5,20],[11,30],[41,19],[34,43],[41,7],[38,36],[13,10],[39,14],[22,4],[34,27],[23,21],[9,24],[13,29],[14,30],[32,48],[9,47],[13,37],[3,4],[1,6],[19,48],[41,47],[40,33],[26,23],[1,4],[40,28],[31,37]] }
assert my_solution.countBlackBlocks(**test_input) == [1929,334,25,0,0]

test_input = { "m": 36, "n": 62, "coordinates": [[5,42],[14,2],[32,11],[28,38],[18,49],[23,52],[32,52],[15,39],[11,38],[15,54],[21,27],[14,0],[26,38],[4,43],[22,26],[5,17]] }
assert my_solution.countBlackBlocks(**test_input) == [2075,58,2,0,0]

test_input = { "m": 30, "n": 98, "coordinates": [[10,13],[23,8],[9,69],[20,70],[17,12],[12,39],[7,72],[14,0],[5,45],[21,24],[10,88],[2,8],[22,86],[2,28],[20,62],[6,82],[27,10],[7,28],[12,79],[21,38],[24,92],[0,47],[8,8],[26,3],[20,57],[12,36],[21,47],[19,12],[20,35],[28,26],[4,61],[5,90],[0,48],[14,50],[3,63],[17,93],[12,5],[12,94],[7,25]] }
assert my_solution.countBlackBlocks(**test_input) == [2664,148,1,0,0]

test_input = { "m": 20, "n": 41, "coordinates": [[11,3],[1,36],[17,23],[13,1],[14,33],[2,23],[0,5],[5,32],[14,36],[8,16],[0,9],[14,26],[8,9],[6,5],[10,12],[17,20],[10,33],[16,23],[12,40],[8,17],[12,35],[11,23],[6,34],[2,4],[7,0],[7,7],[8,27],[7,39],[13,19],[14,2],[9,23],[12,33],[14,20],[12,27],[15,22],[1,19],[10,17],[7,36],[4,29],[12,37],[7,18],[10,20]] }
assert my_solution.countBlackBlocks(**test_input) == [608,144,8,0,0]

test_input = { "m": 60, "n": 73, "coordinates": [[45,35],[12,1],[43,11],[58,9],[0,3],[51,34],[1,65],[15,55],[32,29],[41,36],[41,61],[5,39],[54,2],[21,35],[41,69],[12,71],[17,5],[56,59],[41,40],[49,17],[48,56],[18,71],[39,57],[1,46],[53,44],[40,46],[52,14],[57,68],[14,66],[20,26],[48,8],[46,22],[34,41],[15,47],[18,45],[16,29],[40,6],[51,51],[47,70],[29,64],[51,32],[18,40],[10,62],[5,28],[57,3],[43,69],[49,58],[8,7],[18,9],[24,0],[56,0],[23,39],[31,19],[56,12],[34,17],[13,42],[8,23],[28,20],[42,38],[5,16],[29,36],[56,47],[45,23],[51,58],[2,69],[2,44],[5,6],[53,6],[50,48],[51,64],[43,15],[37,70],[18,44],[41,23],[51,31],[31,10],[25,53],[28,46],[56,42],[7,49],[55,50],[31,26],[3,26],[43,52],[54,68],[21,37]] }
assert my_solution.countBlackBlocks(**test_input) == [3915,328,5,0,0]

test_input = { "m": 37, "n": 80, "coordinates": [[5,3],[29,79],[35,32],[29,8],[10,57]] }
assert my_solution.countBlackBlocks(**test_input) == [2826,18,0,0,0]

test_input = { "m": 31, "n": 97, "coordinates": [[29,40],[29,6],[11,73],[10,81],[12,92],[23,62],[16,86],[26,0],[9,95],[17,17],[22,60],[27,15],[15,70],[7,18],[1,27],[18,51],[14,38],[2,42],[26,43],[0,52],[1,69],[23,50],[26,68],[24,53],[23,31],[7,78],[18,23],[14,96],[25,49],[23,74],[11,35],[5,14],[24,35]] }
assert my_solution.countBlackBlocks(**test_input) == [2754,126,0,0,0]

test_input = { "m": 17, "n": 43, "coordinates": [[8,38],[2,23],[15,18],[1,3],[7,40],[3,30],[13,1],[12,40],[9,4],[0,10],[5,36],[3,15],[3,5],[7,23],[5,13],[11,26],[3,28],[14,23],[10,16],[2,11],[14,5],[11,32],[1,20],[4,0],[15,13],[3,12],[12,9],[3,31],[8,35],[8,17],[3,42],[1,36],[5,2],[13,14],[9,2],[6,28],[5,4],[2,1],[13,36],[2,24],[12,29],[15,3],[11,20],[2,25],[13,8],[4,17],[8,29],[0,33],[11,3],[0,29],[12,30],[6,16],[7,33],[13,7],[5,26],[14,24],[3,16],[0,11],[11,28],[11,34],[6,8],[4,25],[14,20],[8,0],[7,32],[7,27],[8,23],[5,14],[4,30],[14,3],[6,21],[6,41],[12,18],[14,25],[8,3],[8,14]] }
assert my_solution.countBlackBlocks(**test_input) == [418,219,34,1,0]

test_input = { "m": 12, "n": 73, "coordinates": [[7,64],[5,14],[5,46]] }
assert my_solution.countBlackBlocks(**test_input) == [780,12,0,0,0]

test_input = { "m": 36, "n": 91, "coordinates": [[14,10],[28,69],[34,15],[6,62],[2,44],[12,81],[19,47],[32,89],[13,59],[12,25],[8,62],[26,87],[31,29],[16,49],[4,46],[3,46],[10,47],[31,87],[15,44],[1,75],[0,61],[3,35],[3,58],[25,88],[15,56],[30,30],[13,26],[9,49],[24,56],[17,17],[19,85],[23,80],[5,68],[30,79],[34,34],[32,69],[19,58],[20,43],[4,40],[33,44],[21,71],[3,37],[34,54],[10,28],[9,62],[20,19],[21,84],[22,32],[9,90],[10,82],[19,38],[15,51],[32,11],[26,72],[34,46],[17,89],[16,28],[15,81],[0,39],[5,28],[10,5],[20,0],[32,40],[14,76],[8,72]] }
assert my_solution.countBlackBlocks(**test_input) == [2905,238,7,0,0]

test_input = { "m": 11, "n": 76, "coordinates": [[2,6],[1,36],[2,60],[3,57],[1,72],[5,15],[1,30],[1,28],[8,15],[4,39],[1,2],[0,56],[5,2],[4,27],[9,2],[3,67],[7,19],[6,54],[7,73],[9,51],[8,63],[0,27],[8,44],[5,31],[0,11]] }
assert my_solution.countBlackBlocks(**test_input) == [657,92,1,0,0]

test_input = { "m": 24, "n": 70, "coordinates": [[9,49],[13,17],[14,52],[17,13],[20,40],[6,62],[18,62],[14,9],[13,0],[15,34],[5,33],[18,1],[17,33],[6,63],[4,26],[3,28],[18,68],[2,15],[5,10],[21,13],[10,53],[5,35],[21,60],[9,59],[1,0],[15,53],[5,45],[0,42],[6,24],[9,9],[2,44],[8,12],[1,16],[13,29],[21,38],[20,39],[4,13],[17,56],[10,45],[3,65],[14,15],[5,62],[13,18],[4,35],[18,11],[12,31],[18,18],[7,50],[12,52],[11,47],[7,14],[11,61],[13,1],[2,1],[4,19],[15,8],[0,7],[18,15],[20,31],[1,17],[15,31],[7,39],[5,52],[8,9],[1,50],[16,34],[21,15],[8,66],[5,53],[18,43],[5,19],[9,61],[11,52],[18,36],[4,9],[21,28],[10,30],[17,68],[4,52],[16,38],[15,57],[13,35],[9,32],[2,65],[17,34],[14,1],[16,3]] }
assert my_solution.countBlackBlocks(**test_input) == [1290,258,35,4,0]

test_input = { "m": 55, "n": 74, "coordinates": [[33,73],[38,37],[4,69],[23,58],[47,17],[48,36],[46,42],[6,63],[22,23],[36,57],[20,38],[42,66],[31,6],[13,3],[5,40],[25,28],[50,7],[6,7],[23,66],[29,17],[5,67],[41,63],[2,53],[3,24],[25,49],[43,18],[27,11],[37,72],[30,14],[16,70],[22,71],[0,48],[21,4],[8,9],[38,57],[14,12],[13,54],[11,40],[10,28],[9,49],[31,24],[11,28],[11,51],[10,62],[46,39],[3,35],[23,15],[52,25],[37,55],[28,63],[1,2],[26,12],[29,30],[44,62],[35,34],[25,31],[8,63],[8,6],[38,14],[19,14],[8,28],[26,14],[27,36],[20,61],[23,12],[15,20]] }
assert my_solution.countBlackBlocks(**test_input) == [3685,254,3,0,0]

test_input = { "m": 6, "n": 79, "coordinates": [[2,64],[4,74],[2,3],[1,63],[2,34],[3,57],[1,1],[3,52],[1,56],[3,1],[1,61],[2,49],[1,66],[2,25],[1,20],[4,51],[0,78],[1,30]] }
assert my_solution.countBlackBlocks(**test_input) == [323,65,2,0,0]

test_input = { "m": 36, "n": 75, "coordinates": [[23,28],[21,10],[16,48],[26,45],[13,45],[24,66],[34,15],[20,13],[4,42],[17,14],[7,19],[8,5],[4,27],[16,32],[19,0],[27,69],[18,62],[18,63],[4,24],[15,51],[24,53],[6,46],[33,51],[13,65],[11,39],[14,37],[33,1],[5,16],[24,15],[30,63],[34,23],[12,22],[29,44],[19,8],[3,4],[12,67],[0,44],[4,65],[5,44],[16,13],[16,71],[16,10],[27,71],[28,56],[1,23],[11,42],[1,1],[10,19],[10,18],[8,55],[23,68],[12,23],[12,61],[31,3],[13,14],[20,30],[25,1],[4,37],[25,32]] }
assert my_solution.countBlackBlocks(**test_input) == [2365,218,7,0,0]

test_input = { "m": 31, "n": 87, "coordinates": [[12,40],[28,11],[20,65],[24,38],[21,65],[29,11],[11,8],[26,16],[8,25],[18,63],[11,69],[9,16],[14,25],[2,34],[7,14],[26,74],[27,51],[13,53],[25,2],[27,17],[3,45],[23,22],[28,38],[5,26],[23,33],[2,16],[14,41],[22,79],[25,75],[7,79],[9,6],[14,73],[15,61],[27,16],[29,21],[27,72],[16,17],[1,37]] }
assert my_solution.countBlackBlocks(**test_input) == [2437,135,7,1,0]

test_input = { "m": 55, "n": 67, "coordinates": [[44,3],[12,10],[20,17],[41,24],[25,40],[21,46],[5,9],[34,64],[29,40],[49,32],[19,37],[42,61],[35,46],[49,52],[16,65],[4,32],[20,48],[5,59],[28,26],[2,3],[40,28],[20,35],[4,29],[47,20],[3,8],[26,39],[7,54],[8,10],[37,5],[33,13],[3,44],[14,63],[21,24],[26,17],[11,60],[19,44],[46,23],[37,6],[9,64],[15,36],[1,36],[44,31],[3,24],[13,3],[49,39],[28,11],[21,32],[27,34],[44,52],[51,51],[17,50],[49,47],[0,5],[11,51],[37,23],[45,45],[50,19],[33,51],[14,36],[7,44],[3,36],[7,27],[18,54],[31,4],[15,12],[38,38],[52,33],[36,16],[25,42],[28,37],[24,50],[26,24],[48,26],[2,24],[33,10],[10,9],[25,26],[15,64],[52,58],[0,44],[7,48],[32,43],[10,6],[43,11],[50,53],[43,26],[13,45],[50,28],[40,0],[31,50],[42,51],[4,59],[18,62],[26,45],[22,44],[37,58],[38,43],[5,53],[23,1],[21,21]] }
assert my_solution.countBlackBlocks(**test_input) == [3182,370,12,0,0]

test_input = { "m": 19, "n": 40, "coordinates": [[8,25],[14,19],[9,0],[10,26],[11,8],[4,8],[2,0],[13,6],[4,24],[6,11],[5,19],[2,21],[4,11],[4,29],[1,25],[6,14],[0,28],[5,39],[7,33],[15,7],[13,25],[15,5],[9,34],[0,33],[6,10],[3,20],[6,13],[14,12],[6,17],[3,1],[2,30],[13,16],[14,1],[9,9],[14,10],[17,4],[13,39],[8,7],[16,19],[2,5],[10,19],[1,6],[15,4],[7,0],[3,18],[16,3],[14,21],[10,31],[11,31],[1,33],[2,23],[17,20],[8,9],[0,16],[4,32],[9,4],[9,8],[0,8],[1,0],[13,1],[1,34],[7,9],[8,34],[4,39],[10,7],[4,5],[9,12],[5,36],[15,0],[15,36],[6,22]] }
assert my_solution.countBlackBlocks(**test_input) == [478,190,32,2,0]

test_input = { "m": 16, "n": 27, "coordinates": [[7,4],[11,26],[2,21],[3,3],[13,11],[7,14],[0,8]] }
assert my_solution.countBlackBlocks(**test_input) == [366,24,0,0,0]

test_input = { "m": 34, "n": 39, "coordinates": [[4,12],[29,24],[15,28],[3,1],[7,0],[0,27],[15,5],[2,0],[16,7],[19,33],[3,11],[5,26],[29,32],[21,32],[31,10],[17,4],[23,32],[5,10],[3,12],[27,11],[12,26],[2,5],[1,0],[20,2],[11,26],[0,11],[12,4],[14,7],[13,18],[9,7],[16,9],[10,3],[3,33],[13,27],[27,18],[11,19],[18,13],[16,21],[2,15],[11,27],[13,33],[8,21],[16,19],[26,27],[3,36],[9,3],[13,38],[10,22],[1,38],[12,31],[13,13],[17,19],[30,1],[15,37],[21,5],[14,15],[6,37],[8,23],[26,22],[24,38],[21,23]] }
assert my_solution.countBlackBlocks(**test_input) == [1041,200,11,2,0]

test_input = { "m": 26, "n": 41, "coordinates": [[12,9],[1,18],[7,10],[22,0],[15,10],[12,3],[20,15],[0,27],[16,35],[20,40],[7,38],[13,27],[9,32],[4,26],[9,40],[4,1],[21,33],[16,12],[6,38],[22,40],[10,24],[20,21],[17,31],[12,6],[8,27],[9,15],[5,13],[14,31],[11,17],[20,31],[22,35],[23,19],[23,16],[3,15],[16,11],[23,27],[9,33],[16,3],[5,12],[21,20],[12,1],[13,30],[13,17],[13,22],[9,28],[7,8],[8,5],[19,15],[16,1],[23,36],[4,6],[18,40],[8,19],[5,2],[21,2],[23,7]] }
assert my_solution.countBlackBlocks(**test_input) == [804,180,16,0,0]

test_input = { "m": 39, "n": 68, "coordinates": [[35,51],[9,25],[13,28],[14,62],[24,6]] }
assert my_solution.countBlackBlocks(**test_input) == [2526,20,0,0,0]

test_input = { "m": 33, "n": 94, "coordinates": [[15,21],[0,63],[25,30],[11,77],[6,65],[14,5],[3,18],[30,61],[21,52],[17,8],[10,69],[24,84],[19,18],[10,75],[4,47],[8,9],[17,22],[3,70],[30,90],[22,58],[15,84],[4,78],[8,15],[20,18],[23,60],[26,83],[27,14],[5,31],[2,48],[18,48],[16,33],[6,31],[1,82],[5,46],[19,13],[0,86],[3,44],[9,49],[13,47],[0,4],[31,52],[6,68],[15,79],[29,47],[6,4],[5,33],[10,9],[30,50],[9,77],[13,79],[20,87],[11,27],[23,86]] }
assert my_solution.countBlackBlocks(**test_input) == [2775,196,5,0,0]

test_input = { "m": 65, "n": 78, "coordinates": [[43,38],[0,36],[40,68],[52,19],[16,59],[10,35],[23,1],[1,58],[29,38],[19,49],[34,40],[57,37],[32,66],[35,37],[16,10],[53,51],[9,53],[23,40],[42,74],[31,51],[17,51],[21,32],[33,72]] }
assert my_solution.countBlackBlocks(**test_input) == [4838,90,0,0,0]

test_input = { "m": 47, "n": 80, "coordinates": [[26,59],[14,64],[4,67],[17,51],[10,66],[18,78],[17,69],[33,57],[18,44],[16,78],[27,39],[22,18],[16,69],[21,5],[19,52],[39,40],[13,17],[15,10],[30,33],[9,67],[34,10],[3,39],[32,52],[33,71],[24,65],[15,57],[43,53]] }
assert my_solution.countBlackBlocks(**test_input) == [3529,102,3,0,0]

test_input = { "m": 42, "n": 99, "coordinates": [[27,29],[39,18],[40,17],[36,14],[17,76],[15,67],[2,41],[37,70],[34,67],[36,15],[23,57],[7,46],[7,42],[3,91],[3,32],[17,30],[35,37],[25,91],[32,83],[20,81],[20,19],[23,51],[17,10],[23,61],[18,24],[3,13],[16,48],[0,88],[31,81],[4,20],[34,95],[30,22],[28,58],[4,50],[1,77],[4,13],[7,37],[13,1],[28,75],[28,77],[4,4],[31,20],[40,6],[18,65]] }
assert my_solution.countBlackBlocks(**test_input) == [3849,164,5,0,0]

test_input = { "m": 77, "n": 80, "coordinates": [[34,8],[7,40],[67,29],[64,70],[32,71],[17,29],[19,15],[6,77],[68,39],[11,9],[9,59],[19,63],[44,11],[24,54],[13,15],[10,23],[27,35],[14,68],[9,61],[17,74],[44,56],[37,78],[20,68],[7,58],[9,38],[72,22],[72,33],[41,33],[64,63],[22,69],[2,12],[51,73],[43,32],[16,57],[11,16],[3,38],[14,45],[73,28],[8,51],[72,42],[18,65],[45,42],[42,18],[34,38],[47,50],[47,0],[29,32],[15,66],[43,61],[49,36],[69,71],[47,45],[55,64],[1,62],[42,0],[18,49],[57,48],[22,16],[14,7],[56,10],[49,42],[19,46],[40,68],[65,49],[8,20],[12,0],[31,17],[50,6],[8,14],[6,38],[32,67],[4,3],[10,13],[44,8],[21,43],[70,34],[49,22],[72,47],[59,59],[56,72],[33,30],[18,20],[2,76],[22,33]] }
assert my_solution.countBlackBlocks(**test_input) == [5674,330,0,0,0]

test_input = { "m": 53, "n": 93, "coordinates": [] }
assert my_solution.countBlackBlocks(**test_input) == [4784,0,0,0,0]

test_input = { "m": 48, "n": 91, "coordinates": [[19,79],[30,11],[6,54],[35,3],[41,20],[8,3],[8,46],[37,67],[21,61],[27,70],[15,32],[44,61],[1,70],[9,68],[28,16],[19,43],[12,68],[21,12],[7,77],[18,32],[1,25],[31,11],[1,82],[10,18],[31,86],[21,24],[11,43],[15,4],[8,12],[39,68],[11,65],[37,53],[10,39],[30,61],[34,46],[33,9],[30,64],[27,59],[31,60],[14,64],[11,70],[16,83],[28,15],[26,21],[33,71],[31,53],[39,36],[27,77],[41,82],[21,45],[3,59],[42,14],[19,59],[5,57]] }
assert my_solution.countBlackBlocks(**test_input) == [4019,206,5,0,0]

test_input = { "m": 53, "n": 77, "coordinates": [[29,74],[44,76],[10,11],[11,14],[45,0],[41,19],[32,49],[21,50],[14,41],[7,74],[42,47],[50,19],[6,34],[47,0],[19,64],[39,25],[49,46],[45,1],[9,67],[51,19],[6,59],[24,52],[40,61],[48,23],[23,49],[4,64],[40,27],[49,42],[17,30],[13,14],[3,49],[41,14],[36,0],[5,32],[6,1],[4,27],[11,22],[26,37],[5,61],[22,15],[42,1],[9,33],[20,25],[44,38],[46,16],[10,20],[45,13],[31,27],[27,70],[22,11],[28,17]] }
assert my_solution.countBlackBlocks(**test_input) == [3760,188,4,0,0]

test_input = { "m": 12, "n": 69, "coordinates": [[8,6],[1,19],[0,23],[7,8],[7,31],[10,16],[9,2],[6,1],[8,63],[7,45],[5,40],[1,27],[2,14],[6,54],[0,4],[1,62],[4,45],[5,31],[7,33],[2,38]] }
assert my_solution.countBlackBlocks(**test_input) == [672,76,0,0,0]

test_input = { "m": 49, "n": 78, "coordinates": [[4,26],[9,25],[9,77],[42,45],[47,12],[30,68],[15,63],[23,11],[24,24],[23,49],[26,77]] }
assert my_solution.countBlackBlocks(**test_input) == [3656,40,0,0,0]

test_input = { "m": 63, "n": 95, "coordinates": [[36,71],[2,38],[25,72],[16,54],[38,59],[44,82],[7,57],[8,65],[5,90],[8,82],[56,26],[39,15],[36,30],[31,53],[59,80],[38,25],[50,47],[12,72],[27,26],[41,23],[20,25],[19,74],[22,18],[19,75],[53,61],[25,17],[12,22],[32,40],[40,1],[6,7],[6,24],[46,43],[39,84],[17,92],[12,91],[32,25],[20,68],[11,12],[23,20],[7,36],[42,22],[21,69],[19,9],[25,8],[57,82],[52,83],[43,81],[60,19],[26,83],[18,73],[44,12],[30,45],[25,84],[55,77],[35,41],[53,8],[0,44],[29,36],[36,69],[9,53],[37,15],[24,0],[13,60],[31,62],[56,84],[45,59],[45,82],[58,35],[12,15],[34,60],[28,51],[18,40],[53,73],[10,48],[28,6],[8,16],[41,34],[50,15],[23,30],[33,21],[2,34]] }
assert my_solution.countBlackBlocks(**test_input) == [5517,302,9,0,0]

test_input = { "m": 42, "n": 58, "coordinates": [[35,34],[26,21],[17,14],[34,44],[12,51],[1,33],[23,17],[30,54],[25,46],[39,12],[21,13],[26,37],[13,38],[37,10],[27,57],[3,14],[19,31]] }
assert my_solution.countBlackBlocks(**test_input) == [2271,66,0,0,0]

test_input = { "m": 6, "n": 12, "coordinates": [[4,7],[2,11],[0,7],[0,10],[1,4],[2,0],[2,10],[0,8],[3,8],[3,2],[0,5],[1,10],[0,9],[3,4],[2,9],[1,1],[3,7],[2,3],[0,0]] }
assert my_solution.countBlackBlocks(**test_input) == [18,19,14,4,0]

test_input = { "m": 51, "n": 77, "coordinates": [[41,39],[28,5],[6,8],[36,7],[2,46],[18,75],[12,63],[42,26],[16,42],[6,9],[9,55],[37,61],[8,69],[35,10],[34,51],[33,2],[37,64],[5,32],[17,53],[38,51],[42,18],[24,35],[8,25],[17,58],[41,53],[2,9],[48,37],[13,7],[47,20],[28,59],[17,8],[32,27],[39,16],[43,74],[38,61],[40,14],[35,28],[9,46],[30,44],[46,12],[7,45],[26,76],[34,10],[28,51],[47,1],[46,65],[29,71],[2,24],[11,43],[16,28],[33,40],[18,29],[8,73],[30,55],[0,47],[45,34],[3,45],[16,5],[33,9],[4,68],[36,47],[11,39],[8,37],[6,63],[42,51],[4,16],[37,5],[32,60],[40,17],[9,14],[5,29],[22,34],[47,21],[44,37],[2,75],[21,76],[30,46],[20,60]] }
assert my_solution.countBlackBlocks(**test_input) == [3505,284,11,0,0]

test_input = { "m": 58, "n": 65, "coordinates": [[20,24],[4,13],[38,14],[41,21],[6,36],[12,3],[51,52],[10,7],[14,50],[47,60],[30,59],[46,58],[55,49],[35,25],[15,53],[24,39],[55,40],[4,43],[36,28],[21,38],[36,1],[44,42],[12,26],[50,30],[36,14],[53,0],[11,48],[0,55],[42,17],[34,48],[15,43],[13,6],[33,29],[32,20],[12,13],[7,1],[22,41],[26,64],[16,16],[3,5],[14,0],[39,19],[32,47],[47,14],[51,64],[51,12],[7,45],[43,46],[47,28],[50,60],[45,8],[6,30],[9,35],[21,47],[17,39]] }
assert my_solution.countBlackBlocks(**test_input) == [3438,210,0,0,0]

test_input = { "m": 6, "n": 10, "coordinates": [[2,7],[0,4],[3,3],[0,2],[3,0],[4,2],[2,1]] }
assert my_solution.countBlackBlocks(**test_input) == [25,18,2,0,0]

test_input = { "m": 37, "n": 75, "coordinates": [[34,9],[30,27],[20,54],[35,35],[24,8],[0,68],[22,23],[10,20],[4,32],[8,20],[33,6],[7,63],[17,72],[8,37],[28,48],[25,24],[25,74],[20,38],[9,51],[10,74],[3,37],[20,17],[11,31],[14,67],[19,26],[34,7],[31,51],[5,47],[24,28]] }
assert my_solution.countBlackBlocks(**test_input) == [2555,108,1,0,0]

test_input = { "m": 32, "n": 90, "coordinates": [[14,54],[13,33],[27,23],[28,68],[23,46],[12,22],[4,85],[4,41],[26,32],[0,42],[16,24],[17,83],[28,75],[4,39],[5,46],[10,51],[27,88],[6,69],[22,11],[7,9],[19,37],[0,74],[24,85],[28,74],[28,3],[13,80],[9,30],[16,86],[3,22],[2,3],[21,68],[11,32],[19,68],[25,83],[25,31],[12,10],[26,3],[16,57],[24,47],[12,73],[21,87],[9,28],[21,16],[23,29],[25,13],[23,82],[19,7],[29,11],[21,78],[24,23],[7,66],[9,57],[6,78],[13,22],[0,39],[20,48],[18,66],[17,77],[25,66],[11,25],[19,26],[20,75],[29,63],[3,52],[28,15],[13,84],[12,21],[0,4],[7,60],[16,74],[1,3],[7,5],[14,27],[22,4],[12,6],[16,0],[16,14],[12,17],[27,75],[20,16],[0,16],[9,26],[4,43],[19,0],[22,81],[12,71],[15,54],[3,61],[13,72],[7,71],[2,30],[2,18],[16,15],[28,5],[2,7],[25,89]] }
assert my_solution.countBlackBlocks(**test_input) == [2413,326,18,2,0]

test_input = { "m": 21, "n": 81, "coordinates": [[5,71],[9,65],[12,36],[19,38],[7,66],[7,2],[14,13],[4,71],[19,32],[14,30],[13,21],[16,79],[0,2],[3,27],[13,72],[18,49],[0,72],[0,52],[18,24],[18,41],[13,7],[1,29],[15,24],[16,2],[8,25],[5,51],[19,15],[12,18],[16,61],[9,6],[7,61],[18,37],[10,79],[6,35],[17,12],[2,36],[13,64],[9,59],[5,42],[19,30],[7,51],[15,53],[10,75],[2,34],[8,0],[2,70],[3,36],[12,38],[4,35],[9,25],[13,68],[13,13],[14,25],[6,48],[15,33],[15,29]] }
assert my_solution.countBlackBlocks(**test_input) == [1396,192,12,0,0]

test_input = { "m": 44, "n": 54, "coordinates": [[37,23],[27,31],[19,28],[30,2],[15,29],[4,40],[7,47],[36,18],[17,49],[18,51],[29,42],[8,34],[28,51],[17,27],[18,49],[26,16],[34,39],[11,19],[20,43],[23,47],[25,0],[20,32],[16,5],[29,30],[22,3],[4,12],[13,8],[5,6],[35,40],[15,49],[27,14],[37,8],[41,15],[0,16],[37,37],[38,31],[36,52],[18,22],[30,3],[31,18]] }
assert my_solution.countBlackBlocks(**test_input) == [2128,146,5,0,0]

test_input = { "m": 2, "n": 52, "coordinates": [[0,24],[0,29],[0,14],[0,23],[0,33],[0,51],[0,27],[0,50],[0,7],[0,32],[0,9],[0,26],[0,17],[0,31],[0,19],[0,11],[0,3],[0,15],[0,20],[0,12],[0,18],[0,45],[0,48],[0,41],[0,8],[0,42],[0,47],[0,43],[0,2],[0,34],[0,0],[0,5],[0,49],[0,4],[0,36],[0,40],[0,44],[0,6],[0,38],[0,22],[0,13]] }
assert my_solution.countBlackBlocks(**test_input) == [0,22,29,0,0]

test_input = { "m": 3, "n": 75, "coordinates": [[0,49],[1,17],[1,18],[0,20],[1,65],[0,35],[1,70],[1,20],[0,43],[1,58],[1,36],[0,28],[0,74],[0,30],[1,51],[1,63],[1,66]] }
assert my_solution.countBlackBlocks(**test_input) == [102,39,7,0,0]

test_input = { "m": 33, "n": 93, "coordinates": [[18,53],[29,30],[29,23],[10,74],[5,25],[17,26],[5,87],[27,11],[29,16],[22,34],[19,86],[24,80],[11,46],[13,41],[7,24],[24,86],[30,89],[17,92],[11,21],[8,71],[7,8],[24,21],[22,32],[27,21],[29,17],[4,25],[22,91],[23,81],[10,59],[19,87],[20,16],[30,56],[13,70],[18,78],[13,27],[3,48],[8,3],[1,27],[16,62],[3,46],[6,23],[22,12],[0,26],[18,91],[0,1],[8,36],[8,16],[27,17],[12,1],[9,88]] }
assert my_solution.countBlackBlocks(**test_input) == [2760,174,10,0,0]

test_input = { "m": 70, "n": 88, "coordinates": [[40,71],[29,33],[59,67],[55,61],[17,41]] }
assert my_solution.countBlackBlocks(**test_input) == [5983,20,0,0,0]

test_input = { "m": 76, "n": 88, "coordinates": [[39,76],[42,86],[4,51],[60,0],[5,28],[1,46],[28,25],[21,12],[5,39],[19,20],[71,58],[70,25],[38,32],[42,51],[49,62],[39,20],[48,24],[10,14],[17,85],[27,2],[5,40],[56,23],[21,67],[15,28],[15,84],[73,34],[50,81],[20,68],[0,30],[30,53],[33,82],[58,65],[4,7],[73,50],[55,25],[45,59],[69,78],[63,47],[19,83],[46,41],[23,66],[0,76],[63,18],[1,3],[18,71],[27,79],[51,21],[9,46],[48,30],[11,30],[67,74],[74,9],[8,8],[29,9],[66,4],[52,42],[21,56],[40,74],[16,57],[54,64],[41,4],[20,64],[28,9],[55,85],[13,35],[15,33],[43,43],[24,61],[11,52],[34,70],[19,66],[23,57],[68,86],[58,53],[23,19],[46,10],[59,49],[66,9],[24,64],[23,36],[20,10],[1,68],[12,20],[8,73],[59,41]] }
assert my_solution.countBlackBlocks(**test_input) == [6196,324,5,0,0]

test_input = { "m": 77, "n": 92, "coordinates": [[57,46],[24,2],[13,78],[50,91],[50,3],[17,80],[62,17],[5,88],[17,53],[73,42],[10,62],[21,60],[36,45],[36,53],[57,29],[68,43],[4,80],[74,26],[18,23],[44,69],[9,16],[52,20],[25,13],[0,60],[23,80],[26,23],[49,34],[58,71],[24,53],[56,82],[30,63],[53,19],[34,14],[47,5],[2,49],[20,2],[38,87],[30,46],[56,48],[34,1],[24,14],[70,40],[33,74],[65,86],[17,39],[48,80],[24,19],[30,90],[17,61],[31,83],[66,79],[25,30],[57,51],[25,43],[54,47],[60,12],[17,67],[2,57],[40,32],[58,90],[19,62],[9,47],[45,26],[0,37],[10,65],[64,1],[64,38],[2,34],[53,4],[16,37],[2,22],[69,91],[27,64],[50,4],[27,88],[17,47],[9,28],[19,57],[35,88],[4,55],[7,21],[37,68],[8,83],[70,37],[38,0],[40,89],[5,36],[74,37],[59,64],[28,89],[34,75],[42,21],[51,26],[21,57],[66,63]] }
assert my_solution.countBlackBlocks(**test_input) == [6552,358,6,0,0]

test_input = { "m": 25, "n": 52, "coordinates": [[7,8],[3,21],[10,39],[12,35],[20,21],[5,37],[4,28],[15,49],[14,26],[12,47],[10,28]] }
assert my_solution.countBlackBlocks(**test_input) == [1180,44,0,0,0]

test_input = { "m": 78, "n": 84, "coordinates": [[70,29],[22,36],[60,16],[39,28],[67,15],[50,11],[69,28],[24,32],[48,52]] }
assert my_solution.countBlackBlocks(**test_input) == [6356,34,1,0,0]

test_input = { "m": 46, "n": 76, "coordinates": [[18,2],[41,13],[38,28],[9,54],[35,67],[31,72],[29,47],[44,16],[35,5],[36,14],[16,69],[34,74],[15,32],[37,29],[41,37],[5,9],[26,68],[40,38],[30,38],[42,57],[2,2],[42,54],[4,23],[40,15],[22,18],[0,28],[34,33],[37,17],[24,49],[25,73],[35,63],[20,60],[20,16],[10,50],[24,46],[26,8],[43,56],[9,37],[24,56],[42,73],[2,9],[14,72],[35,0],[40,20],[30,8],[12,30],[15,37],[42,75],[31,2],[43,34],[24,18],[19,27],[42,23],[6,70],[22,21],[15,63],[13,39],[36,12],[13,46],[23,71],[21,44],[21,26],[3,15],[41,41],[17,43],[34,47],[4,65],[36,18],[19,1],[31,55],[44,21],[15,9],[18,46],[29,32],[32,19],[1,48],[41,55],[40,66],[43,3],[32,25],[36,49],[7,5],[26,4],[27,21],[27,44]] }
assert my_solution.countBlackBlocks(**test_input) == [3047,322,6,0,0]

test_input = { "m": 6, "n": 35, "coordinates": [[1,26],[4,24],[2,2],[4,17],[2,5],[3,32],[3,21],[1,0],[2,8],[4,20],[1,4],[2,9],[1,17],[3,1],[0,2],[4,6],[0,18],[4,23],[2,24],[0,16],[1,15],[3,22],[2,12],[1,18],[4,21],[0,26],[4,19],[4,2],[3,34],[0,24],[3,31],[2,34],[3,2],[1,24],[0,33],[0,31]] }
assert my_solution.countBlackBlocks(**test_input) == [81,59,25,5,0]

test_input = { "m": 95, "n": 99, "coordinates": [[40,34],[77,26],[5,19],[84,36],[6,42],[92,59],[67,70],[62,38],[87,44],[79,79],[92,44],[75,85],[43,2],[91,34],[78,69],[19,1],[10,15],[82,79],[28,14],[79,72],[57,84],[75,93],[29,93],[91,66],[84,38],[76,81],[5,11],[32,7],[48,25],[10,70],[67,37],[31,91],[45,19],[59,19],[29,98],[37,57],[83,18],[44,80],[91,27],[74,69],[13,62],[5,23],[91,70],[89,71],[11,32],[82,30],[45,61],[10,50],[25,65],[22,32],[77,13],[9,79],[69,37],[77,63],[6,48],[7,77],[35,8],[27,94],[45,37],[30,78],[81,21],[89,84],[75,73],[74,18],[4,28],[10,66],[43,54],[28,7],[26,41],[2,74],[6,70],[8,30],[18,98],[63,10],[22,98]] }
assert my_solution.countBlackBlocks(**test_input) == [8918,294,0,0,0]

test_input = { "m": 57, "n": 91, "coordinates": [[42,12],[38,56],[28,82],[54,52],[24,5]] }
assert my_solution.countBlackBlocks(**test_input) == [5020,20,0,0,0]

test_input = { "m": 60, "n": 73, "coordinates": [[22,24],[22,4],[45,1],[38,57],[54,41],[6,58],[8,44],[40,42],[19,47],[31,47],[48,33],[43,37],[22,54],[36,23],[23,9],[51,15],[24,39],[32,0],[17,7],[41,27],[39,12],[11,10],[22,58],[13,69],[37,37],[17,48],[18,19],[52,40],[52,32],[11,2],[32,21],[39,33],[32,1],[54,17],[0,71],[7,21],[18,24],[0,13],[22,29],[49,62],[44,63],[53,53],[31,44],[28,5],[46,65],[37,27],[39,55],[16,56],[33,10],[40,19],[43,58],[6,65],[24,41],[48,61],[28,46],[0,15],[0,55],[29,49],[5,72],[34,21],[33,40],[14,34],[9,70],[3,48],[16,15],[56,68],[18,68],[2,13],[47,38],[55,55],[22,13],[19,59],[48,60],[53,2],[46,67],[58,9],[56,67],[23,50]] }
assert my_solution.countBlackBlocks(**test_input) == [3955,286,7,0,0]

test_input = { "m": 14, "n": 76, "coordinates": [[1,20],[9,9],[6,57],[3,8],[6,71],[2,67],[12,53],[6,44],[6,16],[3,26],[10,39],[7,4]] }
assert my_solution.countBlackBlocks(**test_input) == [927,48,0,0,0]

test_input = { "m": 69, "n": 72, "coordinates": [[45,12],[54,37],[43,47],[4,45],[28,24],[56,5],[10,67],[30,0],[34,48],[40,45],[27,47],[47,58],[63,59],[53,53],[24,31],[16,51],[55,40],[42,27],[7,38],[3,0],[9,43],[17,15],[63,52],[27,24],[6,32],[13,50],[55,68],[11,34],[42,18],[20,42],[48,20],[36,8],[29,50],[4,55],[33,24],[43,32],[20,67],[29,37],[36,7],[66,60],[61,6],[8,28],[55,31],[61,17],[55,49],[64,33],[32,9],[54,67],[34,40],[52,39],[45,64],[4,38],[44,8],[48,34],[35,14],[25,43],[35,31],[10,21],[63,13],[7,0],[13,54],[54,68],[13,44],[51,62],[17,28],[33,31],[8,70],[25,32],[44,49],[25,16],[35,44],[23,37],[23,48],[8,49],[23,42]] }
assert my_solution.countBlackBlocks(**test_input) == [4543,277,7,1,0]

test_input = { "m": 29, "n": 79, "coordinates": [[26,78],[24,55],[3,8],[3,55],[12,76],[11,23],[4,52],[5,73],[27,21],[8,19],[14,54],[10,4],[8,23],[13,16],[4,1],[21,47],[11,15],[2,26],[24,59],[12,22],[2,69],[20,1],[10,74],[25,53],[0,13],[9,28],[7,4],[10,76],[13,75],[24,25],[14,19],[12,7],[5,53],[5,59],[7,41],[8,25],[7,65],[23,48],[18,37],[7,67],[2,76],[8,64],[22,46],[2,16],[20,31],[7,38],[13,66],[22,30],[17,23],[22,60],[4,10],[6,37],[5,33],[19,58],[22,53],[9,53],[4,22],[12,4],[2,51],[3,63],[4,18],[22,43]] }
assert my_solution.countBlackBlocks(**test_input) == [1946,232,6,0,0]

test_input = { "m": 6, "n": 58, "coordinates": [[0,33],[3,43],[4,25],[0,42],[4,2],[0,31],[2,10],[0,18],[1,46],[2,55],[0,13],[1,8],[2,24],[1,54],[3,54],[0,6],[0,37],[3,34],[3,53],[1,33],[2,1],[2,26],[3,11],[2,37],[1,24],[0,2],[0,14],[2,33],[0,41],[4,7],[4,28],[3,48],[3,0],[4,38],[1,34],[0,26],[4,43],[3,35],[2,7],[4,37],[4,26],[4,51],[4,21],[3,1],[4,53],[0,34],[4,3],[3,50],[3,24],[2,5],[3,40],[2,14],[4,39],[2,43],[2,50],[0,21],[2,8],[0,51],[0,47],[1,22],[3,17],[4,13],[2,2],[3,55],[4,29],[0,16],[1,55],[2,49],[0,24],[1,16],[2,17],[1,19],[1,42],[4,40],[0,5],[0,9],[2,32],[2,25],[0,40],[2,18],[3,31],[3,26],[1,57],[0,45],[0,17],[2,22],[3,3],[1,27],[1,20],[0,44],[2,0],[3,30],[2,40],[3,39],[4,50]] }
assert my_solution.countBlackBlocks(**test_input) == [80,107,76,19,3]

test_input = { "m": 28, "n": 64, "coordinates": [[3,3],[13,53],[17,60],[1,30],[21,59],[1,51],[2,49],[1,16],[14,22],[23,17],[13,55],[8,38],[13,31],[8,34],[17,6]] }
assert my_solution.countBlackBlocks(**test_input) == [1641,60,0,0,0]

test_input = { "m": 15, "n": 45, "coordinates": [[4,29],[0,10],[10,21],[6,5],[4,27],[3,11],[8,36],[1,38],[5,19],[9,1],[5,14],[8,18],[2,8],[13,5],[5,11],[6,37],[2,17],[5,39],[7,3],[2,3],[9,20],[9,41],[0,40],[10,20],[12,30],[2,4],[12,0],[5,16],[11,35],[4,38],[9,11],[3,34],[4,39],[5,8],[10,27],[5,13],[2,36],[9,44],[5,42],[7,43],[13,16],[0,30],[6,35],[8,12],[7,33],[11,12],[13,0],[10,0],[4,17],[0,34],[10,4],[0,22],[2,25],[8,39],[9,40],[4,35],[9,10],[7,18],[7,28],[13,12],[7,8],[10,37],[11,27],[12,40],[8,0],[7,4]] }
assert my_solution.countBlackBlocks(**test_input) == [402,186,26,2,0]

test_input = { "m": 50, "n": 60, "coordinates": [[37,49],[8,45],[11,21],[38,10],[47,35],[15,33],[18,8],[15,22],[16,24],[14,50],[38,24],[8,23],[24,58],[11,35],[37,39],[29,18],[1,8],[40,47],[40,59],[47,48],[15,54],[16,33],[22,29],[39,16],[35,43],[40,54],[11,8],[16,14],[8,7],[38,1],[17,3],[8,3],[0,38],[43,22],[14,10],[31,15],[11,46],[21,45],[13,6],[0,34],[2,42],[47,57],[30,2],[6,38],[8,31],[11,44],[44,36],[10,45],[41,29],[31,30],[47,54],[3,51],[26,5],[3,43],[22,42],[27,28],[48,4],[0,49],[45,22],[7,58],[26,27],[35,31],[40,15],[45,44],[42,34],[17,54]] }
assert my_solution.countBlackBlocks(**test_input) == [2642,242,7,0,0]

test_input = { "m": 36, "n": 54, "coordinates": [[7,0],[22,50],[2,41],[33,48],[1,26]] }
assert my_solution.countBlackBlocks(**test_input) == [1837,18,0,0,0]

test_input = { "m": 26, "n": 68, "coordinates": [[8,51],[18,5],[18,64]] }
assert my_solution.countBlackBlocks(**test_input) == [1663,12,0,0,0]

test_input = { "m": 21, "n": 46, "coordinates": [[12,7],[12,35],[13,14],[11,22],[2,1],[11,28],[1,7],[6,36],[2,15],[15,18],[1,39],[12,38],[11,35],[9,9],[17,6],[12,10]] }
assert my_solution.countBlackBlocks(**test_input) == [838,60,2,0,0]

test_input = { "m": 35, "n": 74, "coordinates": [[9,54],[9,23],[8,48],[14,29],[17,37],[6,4],[17,39],[18,41],[18,50],[24,20],[29,65],[30,3],[5,19],[11,58],[6,67],[21,44],[8,3],[7,11],[18,29],[22,46],[19,51],[4,49],[13,15],[19,48],[12,33],[8,6],[25,48],[17,70],[2,68],[21,53],[9,37],[27,8],[14,69],[2,16],[20,54],[8,67],[31,44],[10,38],[19,21],[16,43],[25,65],[33,20],[17,5],[23,6],[14,23],[14,26],[1,61],[28,21],[1,68],[24,59],[19,17],[23,4],[25,52],[2,43],[30,13],[31,34],[32,43],[14,20],[11,4],[30,20],[0,67],[27,20],[32,64],[20,17],[24,61],[5,35],[31,18],[28,40],[13,11],[29,59],[17,50],[13,54],[20,67],[32,2],[4,18]] }
assert my_solution.countBlackBlocks(**test_input) == [2197,272,13,0,0]

test_input = { "m": 28, "n": 52, "coordinates": [[3,23],[24,28],[7,19],[11,12],[4,27],[3,17],[8,41],[20,30],[23,24],[1,41],[12,30],[2,50],[18,36],[5,7],[1,42],[7,0],[10,51],[20,46],[20,24],[19,7],[23,28],[26,8],[17,31],[22,7],[22,26],[15,8],[19,27],[16,33],[15,39],[13,51],[20,47],[3,39],[25,36],[25,37],[10,0],[19,26],[8,9],[12,31],[19,44],[8,1],[3,12],[8,5],[23,46],[22,15],[18,2],[22,10],[24,43],[16,9],[18,22],[22,8],[20,6],[3,1],[8,17],[25,1],[9,32],[11,34],[7,44],[2,38],[13,37],[26,1],[2,26],[14,38],[6,36],[22,24],[6,27],[18,38],[25,41],[22,39],[18,51],[2,18],[12,24],[4,14],[21,38],[6,44],[18,25],[12,1],[12,4],[1,22],[12,40],[18,11]] }
assert my_solution.countBlackBlocks(**test_input) == [1096,252,29,0,0]

test_input = { "m": 5, "n": 56, "coordinates": [[1,2],[3,7],[2,24],[0,5],[2,3],[2,25],[3,20],[1,8],[2,26],[0,53],[2,44],[0,49],[3,30],[0,11],[1,6],[0,14],[1,9],[2,34],[2,54],[0,31],[1,10],[0,39],[0,26],[0,12],[0,37],[0,42],[0,28],[2,29],[2,46],[1,44],[0,47],[0,35],[1,53],[1,38],[0,24],[0,2],[3,23],[3,36],[3,24],[2,17],[2,35],[3,37],[2,0],[3,45],[0,16],[1,34],[0,29],[1,5],[2,38]] }
assert my_solution.countBlackBlocks(**test_input) == [105,76,35,4,0]

test_input = { "m": 36, "n": 38, "coordinates": [[7,13],[24,30],[23,29],[31,14],[28,33],[16,37],[3,27],[21,36],[9,30],[22,12],[22,21],[6,37],[18,31],[19,4],[18,20],[11,8],[16,14],[7,1],[11,30],[23,16],[15,15],[23,26],[13,12],[11,19]] }
assert my_solution.countBlackBlocks(**test_input) == [1205,88,2,0,0]

test_input = { "m": 70, "n": 75, "coordinates": [[17,67],[60,71],[53,71],[14,36],[19,57],[35,22],[8,11],[27,36],[47,71],[58,54],[35,63],[54,18],[17,22],[34,60],[26,35],[61,39],[65,20],[38,37],[58,34],[34,23],[63,32],[55,32],[35,53],[29,52],[6,4],[5,66],[5,6],[6,60],[61,50],[16,24],[24,51],[65,45],[11,14],[7,27],[67,24],[34,53],[61,16],[60,50],[19,41],[56,19],[10,15],[17,0],[8,59],[32,24],[35,27],[41,34],[59,6],[17,30]] }
assert my_solution.countBlackBlocks(**test_input) == [4923,176,7,0,0]

test_input = { "m": 8, "n": 68, "coordinates": [[5,36],[4,65],[1,9],[5,49],[5,34],[6,59],[5,27],[4,2],[6,53],[6,22],[4,60],[3,65],[6,16],[2,56],[0,27],[6,25],[3,32],[5,2],[3,63],[0,58],[0,37],[6,44],[0,61],[6,37],[1,36],[2,1],[1,4],[6,24],[5,12],[5,23],[0,57],[4,59],[1,44],[2,51],[5,1],[0,8],[5,22],[4,3],[5,0],[5,45],[2,8],[1,12],[1,8],[2,10],[0,48],[1,55],[1,14],[3,12],[5,39],[1,31],[1,27],[0,31],[4,61],[0,54],[2,46],[4,66],[6,32],[5,53],[3,11],[5,4],[2,21],[1,49]] }
assert my_solution.countBlackBlocks(**test_input) == [288,140,35,6,0]