Problem:
Score : 500 points

Problem 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:

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?

Constraints

1 ≤ N ≤ 10^5

1 ≤ K ≤ 1000

0 ≤ x_i ≤ 10^9

0 ≤ y_i ≤ 10^9

If i ≠ j, then (x_i,y_i) ≠ (x_j,y_j).

c_i is B or W.

N, K, x_i and y_i are integers.

Input

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

Output

Print the maximum number of desires that can be satisfied at the same time.

Sample Input 1

4 3
0 1 W
1 2 W
5 3 B
5 4 B

Sample Output 1

4

He can satisfy all his desires by painting as shown in the example above.

Sample Input 2

2 1000
0 0 B
0 1 W

Sample Output 2

2

Sample Input 3

6 2
1 2 B
2 1 W
2 2 B
1 0 B
0 6 W
4 5 W

Sample Output 3

4

Solution in C (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h> // int64_t

#define max(a,b) ((a) > (b) ? (a) : (b))
#define min(a,b) ((a) > (b) ? (b) : (a))

int get_int2(int *a1, int *a2) {
  scanf("%d %d", a1, a2);
  return 0;
}

int get_int3(int *a1, int *a2, char *a3) {
  scanf("%d %d %c", a1, a2, a3);
  return 0;
}

struct point2d {
    int x;
    int y;
};

#define NUM_MAX 100000
#define K_MAX 1000

enum color {
    ENUM_WHITE = 'W',
    ENUM_BLACK = 'B'
};

int main(void) {
    int num, pat;
    get_int2(&num, &pat);

    int i;
    static int cnt[K_MAX*2][K_MAX*2];
    for(i = 0; i < num; i++) {
        int x, y;
        char color;
        get_int3(&x, &y, &color);
        x %= (pat*2);
        y %= (pat*2);
        struct point2d np1 = {x%(pat*2), (y+pat)%(pat*2)};
        struct point2d np2 = {(x+pat)%(pat*2), y%(pat*2)};
        struct point2d np3 = {(x+pat)%(pat*2), (y+pat)%(pat*2)};
        if(color == ENUM_WHITE) {
            cnt[x][y]++;
            cnt[np3.x][np3.y]++;
        } else {
            cnt[np1.x][np1.y]++;
            cnt[np2.x][np2.y]++;
        }
    }

    int row, col;
#ifdef DEBUG
    for(row = 0; row < pat*2; row++) {
        for(col = 0; col < pat*2; col++) {
            printf(" %d", cnt[row][col]);
        }
        putchar('\n');
    }
#endif

    // calc cumulative sum of 2d
    static int cum_row[K_MAX*2+1][K_MAX*2+1];
    static int cum_col[K_MAX*2+1][K_MAX*2+1];
    static int cum[K_MAX*2+1][K_MAX*2+1];
    for(row = 1; row <= pat*2; row++) {
        for(col = 1; col <= pat*2; col++) {
            cum_row[row][col] = cum_row[row][col-1] + cnt[row-1][col-1];
        }
    }

    for(col = 1; col <= pat*2; col++) {
        for(row = 1; row <= pat*2; row++) {
            cum_col[row][col] = cum_col[row-1][col] + cnt[row-1][col-1];
        }
    }

    for(row = 1; row <= pat*2; row++) {
        for(col = 1; col <= pat*2; col++) {
            cum[row][col] = cum[row-1][col-1] + cum_col[row][col] + cum_row[row][col] - cnt[row-1][col-1];
        }
    }
#ifdef DEBUG
    printf("cum\n");
    for(row = 1; row <= pat*2; row++) {
        for(col = 1; col <= pat*2; col++) {
            printf(" %d", cum[row][col]);
        }
        putchar('\n');
    }
#endif

    int ans = 0;
    for(row = 0; row < pat; row++) {
        for(col = 0; col < pat; col++) {
            ans = max(ans, cum[row+pat][col+pat] - cum[row][col+pat] - cum[row+pat][col] + cum[row][col]);
        }
    }
    printf("%d\n", ans);
    return 0;
}