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

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.

Examples

Input

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


Output

4


Input

2 1000
0 0 B
0 1 W


Output

2


Input

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


Output

4
#include <iostream>
#include <vector>
#include <string>
#include <list>
#include <queue>
#include <algorithm>
#define rep(i, n) for(i = 0; i < (n); i++)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define MOD 1000000007
#define PI 3.14159265358979323846
#define INF 1 << 30

using namespace std;
typedef long long ll;
typedef pair<int, int> pp;

void AllSum(vector<vector<int>> & d) {
	int i, j;
	rep(i, d.size()) {
		rep(j, d[i].size() - 1)
			d[i][j + 1] += d[i][j];
	}
	rep(j, d[0].size()) {
		rep(i, d.size() - 1)
			d[i + 1][j] += d[i][j];
	}
	return;
}

int main(void) {
	int num, i, j, k, kk, a, b, ans = 0, sum;
	char c;
	cin >> num >> k;
	kk = k << 1;
	vector<vector<int>> d(k, vector<int>(kk, 0));
	rep(i, num) {
		cin >> a >> b >> c;
		if (c == 'W')
			a += k;
		a %= kk;
		b %= kk;
		if (a >= k) {
			a -= k;
			b += k;
			b %= kk;
		}
		d[a][b]++;
	}
	AllSum(d);
	rep(i, k) {
		rep(j, k) {
			sum = (d[i][j] << 1) + d[k - 1][j + k] - d[i][j + k] - d[k - 1][j];
			if (j < k - 1)
				sum += d[i][kk - 1] - d[i][j + k];
			chmax(ans, sum);
			chmax(ans, num - sum);
		}
	}
	cout << ans << "\n";
	return 0;
}