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 = map(int, input().split())
  x, y, c = zip(
      *(((int(x), int(y), c) for x, y, c in (input().split() for _ in range(N))))
  )
  
  K2 = 2 * K
  
  # 各クエリを(0, 0)から(K -1, K - 1) の矩形にマッピングし、各マスの個数をカウント
  cs = [[0 for _ in range(K2)] for _ in range(K2)]
  for i, j, k in zip(x, y, c):
      cs[(i + K * (k == "W")) % K2][j % K2] += 1
  
  # dp[i][j] はマス(i, j) から K*K のマスを黒で塗るときに叶えられる要望の数
  dp = [[0 for _ in range(K2)] for _ in range(K2)]
  # 累積和を用いて解を求める
  dp[0][0] = sum(cs[i][j] for i in range(K) for j in range(K))
  for i in range(1, K + 1):
      dp[i][0] = (
          dp[i - 1][0]
          + sum(cs[i + K - 1][j] for j in range(K))
          - sum(cs[i - 1][j] for j in range(K))
      )
      dp[0][i] = (
          dp[0][i - 1]
          + sum(cs[j][i + K - 1] for j in range(K))
          - sum(cs[j][i - 1] for j in range(K))
      )
  for i in range(K + 1, K2):
      dp[i][0] = (
          dp[i - 1][0]
          + sum(cs[i - (K + 1)][j] for j in range(K))
          - sum(cs[i - 1][j] for j in range(K))
      )
      dp[0][i] = (
          dp[0][i - 1]
          + sum(cs[j][i - (K + 1)] for j in range(K))
          - sum(cs[j][i - 1] for j in range(K))
      )
  for i in range(1, K + 1):
      for j in range(1, K + 1):
          dp[i][j] = (
              dp[i - 1][j]
              + dp[i][j - 1]
              - dp[i - 1][j - 1]
              + cs[i + K - 1][j + K - 1]
              + cs[i - 1][j - 1]
              - cs[i - 1][j + K - 1]
              - cs[i + K - 1][j - 1]
          )
      for j in range(K + 1, K2):
          dp[i][j] = (
              dp[i - 1][j]
              + dp[i][j - 1]
              - dp[i - 1][j - 1]
              + cs[i + K - 1][j - (K + 1)]
              + cs[i - 1][j - 1]
              - cs[i - 1][j - (K + 1)]
              - cs[i + K - 1][j - 1]
          )
  for i in range(K + 1, 2 * K):
      for j in range(1, K + 1):
          dp[i][j] = (
              dp[i - 1][j]
              + dp[i][j - 1]
              - dp[i - 1][j - 1]
              + cs[i - (K + 1)][j + K - 1]
              + cs[i - 1][j - 1]
              - cs[i - 1][j + K - 1]
              - cs[i - (K + 1)][j - 1]
          )
      for j in range(K + 1, K2):
          dp[i][j] = (
              dp[i - 1][j]
              + dp[i][j - 1]
              - dp[i - 1][j - 1]
              + cs[i - (K + 1)][j - (K + 1)]
              + cs[i - 1][j - 1]
              - cs[i - 1][j - (K + 1)]
              - cs[i - (K + 1)][j - 1]
          )
  # 全通りの塗り方を試し、解を求める
  ans = max(
      max(dp[i][j] + dp[i + K][j + K] for i in range(K) for j in range(K)),
      max(dp[i][j] + dp[i - K][j - K] for i in range(K, K2) for j in range(K, K2)),
  )
  
  # 出力
  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"}]