import java.io.IOException

fun main(args: Array<String>) {
    val scanner = FastScanner()
    val N = scanner.nextInt()
    val K = scanner.nextInt()
    val H = 2 * K
    val W = 2 * K
    val b = Array(4 * K + 1, { IntArray(4 * K, { 0 })})
    val s = Array(4 * K + 1, { IntArray(4 * K + 1, { 0 })})
    (0 until N).forEach {
        var x = scanner.nextInt()
        val y = scanner.nextInt()
        val c = scanner.next()[0]
        if (c == 'W') {
            x += K
        }
        b[(x % H) + 1][(y % W) + 1]++
    }

    // O (4K^2)
    for (i in 1 .. 4 * K) {
        for (j in 1 .. 4 * K) {
            s[i][j] = s[i][j-1] + b[(i-1)%(2*K)+1][(j-1)%(2*K)+1]
        }
    }

    for (i in 1 .. 4 * K) {
        for (j in 1 .. 4 * K) {
            s[i][j] += s[i-1][j]
        }
    }

    fun get(x: Int, y: Int) : Int {
        return s[x+K-1][y+K-1] + s[x-1][y-1] - s[x-1][y+K-1] - s[x+K-1][y-1];
    }


    var max = 0
    // O (K^2)
    (1..2 * K).forEach {i ->
        (1..2 * K).forEach { j ->
            max = Math.max(max, get(i, j) + get(i + K, j + K))
        }
    }


    println(max)
}


internal class FastScanner {
    private val `in` = System.`in`
    private val buffer = ByteArray(1024)
    private var ptr = 0
    private var buflen = 0
    private fun hasNextByte(): Boolean {
        if (ptr < buflen) {
            return true
        } else {
            ptr = 0
            try {
                buflen = `in`.read(buffer)
            } catch (e: IOException) {
                e.printStackTrace()
            }

            if (buflen <= 0) {
                return false
            }
        }
        return true
    }

    private fun readByte(): Int {
        return if (hasNextByte()) buffer[ptr++].toInt() else -1
    }

    private fun isPrintableChar(c: Int): Boolean {
        return 33 <= c && c <= 126
    }

    private fun skipUnprintable() {
        while (hasNextByte() && !isPrintableChar(buffer[ptr].toInt())) ptr++
    }

    operator fun hasNext(): Boolean {
        skipUnprintable()
        return hasNextByte()
    }

    operator fun next(): String {
        if (!hasNext()) return ""
        val sb = StringBuilder()
        var b = readByte()
        while (isPrintableChar(b)) {
            sb.appendCodePoint(b)
            b = readByte()
        }
        return sb.toString()
    }

    fun nextLong(): Long {
        if (!hasNext()) return -1
        var n: Long = 0
        var minus = false
        var b = readByte()
        if (b == '-'.toInt()) {
            minus = true
            b = readByte()
        }
        if (b < '0'.toInt() || '9'.toInt() < b) {
            throw NumberFormatException()
        }
        while (true) {
            if ('0'.toInt() <= b && b <= '9'.toInt()) {
                n *= 10
                n += (b - '0'.toInt()).toLong()
            } else return if (b == -1 || !isPrintableChar(b)) {
                if (minus) -n else n
            } else {
                throw NumberFormatException()
            }
            b = readByte()
        }
    }

    fun nextInt(): Int {
        val set = hashSetOf<Char>()
        set.add('3')
        set.clear()

        if (!hasNext()) return -1
        var n: Int = 0
        var minus = false
        var b = readByte()
        if (b == '-'.toInt()) {
            minus = true
            b = readByte()
        }
        if (b < '0'.toInt() || '9'.toInt() < b) {
            throw NumberFormatException()
        }
        while (true) {
            if ('0'.toInt() <= b && b <= '9'.toInt()) {
                n *= 10
                n += (b - '0'.toInt()).toInt()
            } else return if (b == -1 || !isPrintableChar(b)) {
                if (minus) -n else n
            } else {
                throw NumberFormatException()
            }
            b = readByte()
        }
    }
}

Measured memory_bytes: 225276