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: # -*- coding: utf-8 -*-
  from collections import Counter
  import numpy as np
  
  n, k = list(map(int, input().split()))
  table = np.zeros((2 * k, 2 * k), dtype="int32")
  for i in range(n):
      t = input().split()
      if t[2] == "B":
          table[int(t[0]) % (2 * k)][int(t[1]) % (2 * k)] += 1
      else:
          table[(int(t[0]) + k) % (2 * k)][int(t[1]) % (2 * k)] += 1
  
  # print(table)
  
  n_table = np.zeros((3 * k, 3 * k), dtype="int32")
  n_table[0 : 2 * k, 0 : 2 * k] = table
  n_table[2 * k : 3 * k, 0 : 2 * k] = table[0:k, 0 : 2 * k]
  n_table[0 : 2 * k, 2 * k : 3 * k] = table[0 : 2 * k, 0:k]
  n_table[2 * k : 3 * k, 2 * k : 3 * k] = table[0:k, 0:k]
  
  # print(n_table)
  i_table = np.zeros((3 * k, 3 * k), dtype="int32")
  
  for i in range(0, 3 * k):
      i_table[i][0] = n_table[i][0]
      for j in range(1, 3 * k):
          i_table[i][j] += i_table[i][j - 1] + n_table[i][j]
  for i in range(1, 3 * k):
      for j in range(0, 3 * k):
          i_table[i][j] += i_table[i - 1][j]
  
  # print(i_table)
  ans = 0
  hope1 = i_table[k - 1][k - 1]
  hope2 = (
      i_table[2 * k - 1][2 * k - 1]
      - i_table[2 * k - 1][k - 1]
      - i_table[k - 1][2 * k - 1]
      + i_table[k - 1][k - 1]
  )
  ans = max(ans, hope1 + hope2)
  for i in range(1, k):
      hope1 = i_table[k - 1][i + k - 1] - i_table[k - 1][i - 1]
      hope2 = (
          i_table[2 * k - 1][i + 2 * k - 1]
          - i_table[2 * k - 1][i + k - 1]
          - i_table[k - 1][i + 2 * k - 1]
          + i_table[k - 1][i + k - 1]
      )
      ans = max(ans, hope1 + hope2)
  for i in range(1, k):
      hope1 = i_table[i + k - 1][k - 1] - i_table[i - 1][k - 1]
      hope2 = (
          i_table[i + 2 * k - 1][2 * k - 1]
          - i_table[i + 2 * k - 1][k - 1]
          - i_table[i + k - 1][2 * k - 1]
          + i_table[i + k - 1][k - 1]
      )
      ans = max(ans, hope1 + hope2)
  
  for i in range(1, k):
      for j in range(1, k):
          hope1 = (
              i_table[i + k - 1][j + k - 1]
              - i_table[i + k - 1][j - 1]
              - i_table[i - 1][j + k - 1]
              + i_table[i - 1][j - 1]
          )
          hope2 = (
              i_table[i + 2 * k - 1][j + 2 * k - 1]
              - i_table[i + 2 * k - 1][j + k - 1]
              - i_table[i + k - 1][j + 2 * k - 1]
              + i_table[i + k - 1][j + k - 1]
          )
          ans = max(ans, hope1 + hope2)
  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"}]