using System;
using System.Linq;
using System.Collections.Generic;

namespace Problem_8._Bombs
{
    class Program
    {
        static void Main(string[] args)
        {
            int dimensions = int.Parse(Console.ReadLine());

            int[][] matrix = new int[dimensions][];

            for (int i = 0; i < matrix.Length; i++)
            {
                matrix[i] = Console.ReadLine().Split().Select(int.Parse).ToArray();
            }

            string[] bombsCoors = Console.ReadLine().Split(' ', StringSplitOptions.RemoveEmptyEntries);

            for (int i = 0; i < bombsCoors.Length; i++)
            {
                int[] indexes = bombsCoors[i].Split(',').Select(int.Parse).ToArray();

                int bombRow = indexes[0];
                int bombCol = indexes[1];

                int nextBombRow = -1;
                int nextBombCol = -1;

                if (i != bombsCoors.Length - 1)
                {
                    int[] nextIndexes = bombsCoors[i + 1].Split(',').Select(int.Parse).ToArray();
                    nextBombRow = nextIndexes[0];
                    nextBombCol = nextIndexes[1];
                }

                if (IsInside(matrix, bombRow, bombCol - 1) && !IsBomb(matrix, bombRow, bombCol - 1, nextBombRow, nextBombCol))
                {
                    if (IsPositive(matrix, bombRow, bombCol - 1))
                    {
                        matrix[bombRow][bombCol - 1] -= matrix[bombRow][bombCol];
                    }
                }

                if (IsInside(matrix, bombRow - 1, bombCol - 1) && !IsBomb(matrix, bombRow - 1, bombCol - 1, nextBombRow, nextBombCol))
                {
                    if (IsPositive(matrix, bombRow - 1, bombCol - 1))
                    {
                        matrix[bombRow - 1][bombCol - 1] -= matrix[bombRow][bombCol];
                    }
                }

                if (IsInside(matrix, bombRow - 1, bombCol) && !IsBomb(matrix, bombRow - 1, bombCol, nextBombRow, nextBombCol))
                {
                    if (IsPositive(matrix, bombRow - 1, bombCol))
                    {
                        matrix[bombRow - 1][bombCol] -= matrix[bombRow][bombCol];
                    }
                }

                if (IsInside(matrix, bombRow - 1, bombCol + 1) && !IsBomb(matrix, bombRow - 1, bombCol + 1, nextBombRow, nextBombCol))
                {
                    if (IsPositive(matrix, bombRow - 1, bombCol + 1))
                    {
                        matrix[bombRow - 1][bombCol + 1] -= matrix[bombRow][bombCol];
                    }
                }

                if (IsInside(matrix, bombRow, bombCol + 1) && !IsBomb(matrix, bombRow, bombCol + 1, nextBombRow, nextBombCol))
                {
                    if (IsPositive(matrix, bombRow, bombCol + 1))
                    {
                        matrix[bombRow][bombCol + 1] -= matrix[bombRow][bombCol];
                    }
                }

                if (IsInside(matrix, bombRow + 1, bombCol + 1) && !IsBomb(matrix, bombRow + 1, bombCol + 1, nextBombRow, nextBombCol))
                {
                    if (IsPositive(matrix, bombRow + 1, bombCol + 1))
                    {
                        matrix[bombRow + 1][bombCol + 1] -= matrix[bombRow][bombCol];
                    }
                }

                if (IsInside(matrix, bombRow + 1, bombCol) && !IsBomb(matrix, bombRow + 1, bombCol, nextBombRow, nextBombCol))
                {
                    if (IsPositive(matrix, bombRow + 1, bombCol))
                    {
                        matrix[bombRow + 1][bombCol] -= matrix[bombRow][bombCol];
                    }
                }

                if (IsInside(matrix, bombRow + 1, bombCol - 1) && !IsBomb(matrix, bombRow + 1, bombCol - 1, nextBombRow, nextBombCol))
                {
                    if (IsPositive(matrix, bombRow + 1, bombCol - 1))
                    {
                        matrix[bombRow + 1][bombCol - 1] -= matrix[bombRow][bombCol];
                    }
                }

                matrix[bombRow][bombCol] = 0;
            }

            int alive = 0;
            int sum = 0;

            for (int i = 0; i < matrix.Length; i++)
            {
                for (int j = 0; j < matrix[i].Length; j++)
                {
                    if (matrix[i][j] > 0)
                    {
                        alive++;
                        sum += matrix[i][j];
                    }
                }
            }

            Console.WriteLine($"Alive cells: {alive}");
            Console.WriteLine($"Sum: {sum}");

            foreach (var item in matrix)
            {
                Console.WriteLine(string.Join(" ", item));
            }
        }

        private static bool IsPositive(int[][] matrix, int bombRow, int bombCol)
        {
            return matrix[bombRow][bombCol] > 0;
        }

        private static bool IsBomb(int[][] matrix, int bombRow, int bombCol, int nextBombRow, int nextBombCol)
        {
            return bombRow == nextBombRow && bombCol == nextBombCol;
        }

        private static bool IsInside(int[][] matrix, int row, int col)
        {
            return row >= 0 && row < matrix.Length && col >= 0 && col < matrix[row].Length;
        }
    }
}