output_description: Print the number of cells whose density value is 0 in first line.  
  Print the maximum value of density in the second line.
input_description: x1,y1,s1
      x2,y2,s2
        :
        :
      
  
  (xi, yi) represents the position of the i-th drop and si denotes its size. The
  number of drops is less than or equal to 50.
attempt: class Paper:
      def __init__(self, x, y):
  
          self.A = [[0 for i in range(x)] for j in range(y)]
          self.size = (x, y)
  
      def drop(self, x, y, s):
          if s == 1:
              if y + 1 <= self.size[1] - 1:
                  self.A[y + 1][x] += 1
              for i in range(max(0, x - 1), 1 + min(self.size[0] - 1, x + 1)):
                  self.A[y][i] += 1
              if y - 1 >= 0:
                  self.A[y - 1][x] += 1
  
          if s == 2:
              if y + 1 <= self.size[1] - 1:
                  for i in range(max(0, x - 1), 1 + min(self.size[0] - 1, x + 1)):
                      self.A[y + 1][i] += 1
              for i in range(max(0, x - 1), 1 + min(self.size[0] - 1, x + 1)):
                  self.A[y][i] += 1
              if y - 1 >= 0:
                  for i in range(max(0, x - 1), 1 + min(self.size[0] - 1, x + 1)):
                      self.A[y - 1][i] += 1
  
          if s == 3:
              if y + 2 <= self.size[1] - 1:
                  self.A[y + 2][x] += 1
              if y + 1 <= self.size[1] - 1:
                  for i in range(max(0, x - 1), 1 + min(self.size[0] - 1, x + 1)):
                      self.A[y + 1][i] += 1
              for i in range(max(0, x - 2), 1 + min(self.size[0] - 1, x + 2)):
                  self.A[y][i] += 1
              if y - 1 >= 0:
                  for i in range(max(0, x - 1), 1 + min(self.size[0] - 1, x + 1)):
                      self.A[y - 1][i] += 1
              if y - 2 >= 0:
                  self.A[y - 2][x] += 1
  
  
  if __name__ == "__main__":
      import sys
  
      p = Paper(10, 10)
      L = sys.stdin.readlines()
      for l in L:
          x, y, s = map(int, l.split(","))
          p.drop(x, y, s)
      #        for i in range(10):
      #            print(p.A[i])
      #        print()
      temp = []
      for y in p.A:
          temp.extend(y)
  
      A1 = temp.count(0)
      A2 = max(temp)
  
      print(A1)
      print(A2)
  
problem_description: Dropping Ink
  
  As shown in the following figure, there is a paper consisting of a grid
  structure where each cell is indicated by (x, y) coordinate system.
  
  We are going to put drops of ink on the paper. A drop comes in three different
  sizes: Large, Medium, and Small. From the point of fall, the ink sinks into
  surrounding cells as shown in the figure depending on its size. In the figure,
  a star denotes the point of fall and a circle denotes the surrounding cells.
  
  ![](https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink1)  
  
  Originally, the paper is white that means for each cell the value of density
  is 0. The value of density is increased by 1 when the ink sinks into the
  corresponding cells. For example, if we put a drop of Small ink at (1, 2) and
  a drop of Medium ink at (3, 2), the ink will sink as shown in the following
  figure (left side):
  
  ![](https://judgeapi.u-aizu.ac.jp/resources/images/IMAGE1_ink2)  
  
  In the figure, density values of empty cells are 0. The ink sinking into out
  of the paper should be ignored as shown in the figure (top side). We can put
  several drops of ink at the same point.
  
  Your task is to write a program which reads a sequence of points of fall (x,
  y) with its size (Small = 1, Medium = 2, Large = 3), and prints the number of
  cells whose density value is 0. The program must also print the maximum value
  of density.
  
  You may assume that the paper always consists of 10 × 10, and 0 ≤ x < 10, 0 ≤
  y < 10\.
samples: [{"input": ",5,3\n    3,6,1\n    3,4,2\n    4,5,2\n    3,6,3\n    2,4,1", "output": "5"}]