#include <stdio.h>
#include <assert.h>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <array>
#include <vector>
#include <queue>
#include <set>
#include <cmath>
#include <unordered_map>
//#include <unordered_set>
//#include <boost/container/static_vector.hpp>
//#include <boost/unordered_set.hpp>
//#include <boost/unordered_map.hpp>
//#include <unistd.h>

class BIT {
    // Binary Indexed Tree : 数列要素1つへの加算、数列のある地点までの累積和を高速に計算
    public:
    std::vector<int> data;
    BIT() {}
    BIT(const int size) {
        // 想定されるサイズの2倍の値を入れた方がいいかもしれない。数列は1から数えることを想定している。
        data.resize(size*2, 0);
    }
    int sum(int i) const {
        int s = 0;
        while (i > 0) {
            s += data[i];
            i = i & (i-1); // iの最後のビットを引く。
        }
        return s;
    }

    void add(int i, int x) {
        while (i < data.size()) {
            data[i] += x;
            i += i - (i & (i-1)); // iの最後のビットを加算する。
        }
    }
};

const int MAX_N = 100050;
const int MAX_K = 1050;
int N, K;
int X[MAX_N], Y[MAX_N];
char C[MAX_N];

BIT bit_hor[MAX_K*2], bit_ver[MAX_K*2];

int ret_val[MAX_K*2][MAX_K*2];

int mod_val(int x) {
    x = x % (K*2);
    return x == 0 ? K * 2 : x;
}

int ac_x(int y, int x1, int x2) {
    y = mod_val(y);
    x1 = mod_val(x1);
    x2 = mod_val(x2);

    if (x1 <= x2) {
        return bit_hor[y].sum(x2) - bit_hor[y].sum(x1 - 1);
    } else {
        return bit_hor[y].sum(K*2) - bit_hor[y].sum(x1 - 1) + bit_hor[y].sum(x2);
    }
}

int ac_y(int x, int y1, int y2) {
    x = mod_val(x);
    y1 = mod_val(y1);
    y2 = mod_val(y2);

    if (y1 <= y2) {
        return bit_ver[x].sum(y2) - bit_ver[x].sum(y1 - 1);
    } else {
        return bit_ver[x].sum(K*2) - bit_ver[x].sum(y1 - 1) + bit_ver[x].sum(y2);
    }
}

int calc_ret_val(int x, int y) {
    if (ret_val[x][y] != -1) {
        return ret_val[x][y];
    }
    if (x == 1 && y == 1) {
        int ret = 0;
        for (int j = 1; j <= K; j++) {
            ret += ac_x(j, 1, K) + ac_x(j + K, 1 + K, K * 2);
        }
        ret_val[x][y] = ret;
    } else if (1 < x) {
        ret_val[x][y] = calc_ret_val(x - 1, y) + ac_y(x + K - 1, y, y + K - 1) + ac_y(x + K * 2 - 1, y + K, y + K * 2 - 1) - ac_y(x - 1, y, y + K - 1) - ac_y(x - 1 + K, y + K, y + K * 2 - 1);
    } else {
        ret_val[x][y] = calc_ret_val(x, y - 1) + ac_x(y + K - 1, x, x + K - 1) + ac_x(y + K * 2 - 1, x + K, x + K * 2 - 1) - ac_x(y - 1, x, x + K - 1) - ac_x(y - 1 + K, x + K, x + K * 2 - 1);
    }
    return ret_val[x][y];
}

int main(int argc, char **argv) {
    std::cin >> N >> K;

    for (int i = 1; i <= N; i++) {
        std::cin >> X[i] >> Y[i] >> C[i];
    }

    for (int i = 1; i <= K * 2; i++) {
        bit_hor[i] = BIT(K*2);
        bit_ver[i] = BIT(K*2);

    }

    for (int i = 1; i <= N; i++) {
        if (C[i] == 'W') {
            C[i] = 'B';
            X[i] = X[i] + K;
        }
        X[i] = mod_val(X[i]);
        Y[i] = mod_val(Y[i]);

        bit_hor[Y[i]].add(X[i], 1);
        bit_ver[X[i]].add(Y[i], 1);
    }

    for (int i = 1; i <= K * 2; i++) {
        for (int j = 1; j <= K * 2; j++) {
            ret_val[i][j] = -1;
        }
    }

    int ret = 0;
    for (int i = 1; i <= K * 2; i++) {
        for (int j = 1; j <= K * 2; j++) {
            ret_val[i][j] = calc_ret_val(i, j);
            ret = std::max(ret, ret_val[i][j]);
            
        }
    }
    std::cout << ret << std::endl;
    
    return 0;

}

Measured memory_bytes: 80256