output_description: Print the maximum number of desires that can be satisfied at the same time.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N K
      x_1 y_1 c_1
      x_2 y_2 c_2
      :
      x_N y_N c_N
attempt: n, k = [int(_) for _ in input().split()]
  x = []
  y = []
  c = []
  for i in range(0, n):
      t_x, t_y, t_c = input().split()
      x.append(int(t_x))
      y.append(int(t_y))
      c.append(t_c)
  
  for i in range(0, n):
      if c[i] == "W":
          c[i] = "B"
          y[i] = y[i] + k
  
  for i in range(0, n):
      x[i] = x[i] % (2 * k)
      y[i] = y[i] % (2 * k)
  
  
  a = [[0 for _ in range(6 * k)] for _ in range(6 * k)]
  
  
  for i in range(n):
      a[x[i] + 1 + (2 * k - 1)][y[i] + 1 + (2 * k - 1)] += 2
      a[x[i] + 1 + (2 * k - 1)][y[i] - k + 1 + (2 * k - 1)] -= 2
      a[x[i] + 1 + (2 * k - 1)][y[i] + 1 + k + (2 * k - 1)] -= 2
      a[x[i] + 1 + (2 * k - 1)][y[i] + 1 + 2 * k + (2 * k - 1)] += 1
      a[x[i] + 1 + (2 * k - 1)][y[i] + 1 - 2 * k + (2 * k - 1)] += 1
  
      a[x[i] - k + 1 + (2 * k - 1)][y[i] - k + 1 + (2 * k - 1)] += 2
      a[x[i] - k + 1 + (2 * k - 1)][y[i] + 1 + (2 * k - 1)] -= 2
      a[x[i] - k + 1 + (2 * k - 1)][y[i] + 1 + k + (2 * k - 1)] += 2
      a[x[i] - k + 1 + (2 * k - 1)][y[i] + 1 + 2 * k + (2 * k - 1)] -= 1
      a[x[i] - k + 1 + (2 * k - 1)][y[i] + 1 - 2 * k + (2 * k - 1)] -= 1
  
      a[x[i] + 1 + k + (2 * k - 1)][y[i] + 1 + (2 * k - 1)] -= 2
      a[x[i] + 1 + k + (2 * k - 1)][y[i] + 1 + k + (2 * k - 1)] += 2
      a[x[i] + 1 + k + (2 * k - 1)][y[i] + 1 + 2 * k + (2 * k - 1)] -= 1
      a[x[i] + 1 + k + (2 * k - 1)][y[i] + 1 - k + (2 * k - 1)] += 2
      a[x[i] + 1 + k + (2 * k - 1)][y[i] + 1 - 2 * k + (2 * k - 1)] -= 1
  
      a[x[i] + 1 + 2 * k + (2 * k - 1)][y[i] + 1 + (2 * k - 1)] += 1
      a[x[i] + 1 + 2 * k + (2 * k - 1)][y[i] + 1 + k + (2 * k - 1)] -= 1
      a[x[i] + 1 + 2 * k + (2 * k - 1)][y[i] + 1 + 2 * k + (2 * k - 1)] += 1
      a[x[i] + 1 + 2 * k + (2 * k - 1)][y[i] + 1 - k + (2 * k - 1)] -= 1
  
      a[x[i] + 1 - 2 * k + (2 * k - 1)][y[i] + 1 + (2 * k - 1)] += 1
      a[x[i] + 1 - 2 * k + (2 * k - 1)][y[i] + 1 + k + (2 * k - 1)] -= 1
      a[x[i] + 1 - 2 * k + (2 * k - 1)][y[i] + 1 - k + (2 * k - 1)] -= 1
      a[x[i] + 1 - 2 * k + (2 * k - 1)][y[i] + 1 - 2 * k + (2 * k - 1)] += 1
  
  
  s = [[0 for _ in range(6 * k)] for _ in range(6 * k)]
  
  s[0][0] = a[0][0]
  
  
  for i in range(0, 6 * k - 1):
      for j in range(0, i + 1):
          if j == 0:
              s[j][i + 1] = s[j][i] + a[j][i + 1]
          else:
              s[j][i + 1] = s[j][i] + s[j - 1][i + 1] + a[j][i + 1] - s[j - 1][i]
      for l in range(0, i + 1):
          if l == 0:
              s[i + 1][l] = s[i][l] + a[i + 1][l]
          else:
              s[i + 1][l] = s[i][l] + s[i + 1][l - 1] + a[i + 1][l] - s[i][l - 1]
      s[i + 1][i + 1] = s[i][i + 1] + s[i + 1][i] + a[i + 1][i + 1] - s[i][i]
  
  
  ans = 0
  for i in range(0, 2 * k):
      for j in range(0, 2 * k):
          ans = max(ans, s[i + (k - 1)][j + (k - 1)])
  
  print(ans)
  
problem_description: Statement
  
  AtCoDeer is thinking of painting an infinite two-dimensional grid in a
  _checked pattern of side K_. Here, a checked pattern of side K is a pattern
  where each square is painted black or white so that each connected component
  of each color is a K × K square. Below is an example of a checked pattern of
  side 3:
  
  ![cba927b2484fad94fb5ff7473e9aadef.png](https://img.atcoder.jp/arc089/cba927b2484fad94fb5ff7473e9aadef.png)
  
  AtCoDeer has N desires. The i-th desire is represented by x_i, y_i and c_i. If
  c_i is `B`, it means that he wants to paint the square (x_i,y_i) black; if c_i
  is `W`, he wants to paint the square (x_i,y_i) white. At most how many desires
  can he satisfy at the same time?
samples: [{"input": "4 3\n    0 1 W\n    1 2 W\n    5 3 B\n    5 4 B", "output": "4\n    \n\nHe can satisfy all his desires by painting as shown in the example above.\n\n* * *"}, {"input": "2 1000\n    0 0 B\n    0 1 W", "output": "2\n    \n\n* * *"}, {"input": "6 2\n    1 2 B\n    2 1 W\n    2 2 B\n    1 0 B\n    0 6 W\n    4 5 W", "output": "4"}]