Language: C++

#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define ford(i, n) for (int i = (int)(n) - 1; i >= 0; --i)
#define fore(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
#define forr(i, a, b) for (int i = (int)(a); i >= (int)(b); --i)

#ifdef LOCAL_SYSTEM
#define DEBUG(x) cerr << #x << ": " << (x) << endl;
#define DEBUGARR(a, n) cerr << #a << ": "; print_array(cerr, a, n); cerr << endl;
#else
#define DEBUG(x)
#define DEBUGARR(a, n)
#endif

using namespace std;

template<typename T> void print_sequential_container(ostream& stream, const vector<T>& c) {
    stream << "[";
    auto &last = *(--c.end());
    for (auto &e: c) {
        stream << e;
        if (e != last) {
            stream << ", ";
        }
    }
    stream << "]";
}

template<typename T> void print_array(ostream& stream, T a[], int n) {
    stream << "[";
    for (int i = 0; i < n; i++) {
        stream << a[i];
        if (i != n - 1) {
            stream << ", ";
        }
    }
    stream << "]";
}

template<typename T> void print_set(ostream& stream, const T& c) {
    stream << "{";
    auto &last = *(--c.end());
    for (auto &e: c) {
        stream << e;
        if (e != last) {
            stream << ", ";
        }
    }
    stream << "}";
}

template<typename T> void print_map(ostream& stream, const T& c) {
    stream << "{";
    auto &last = *(--c.end());
    for (auto &e: c) {
        stream << e.fi << ": " << e.se;
        if (e != last) {
            stream << ", ";
        }
    }
    stream << "}";
}

template<typename T> ostream& operator << (ostream& stream, const vector<T>& c) {
    print_sequential_container(stream, c);
    return stream;
}

template<typename T> ostream& operator << (ostream& stream, const list<T>& c) {
    print_sequential_container(stream, c);
    return stream;
}

template<typename T> ostream& operator << (ostream& stream, const forward_list<T>& c) {
    print_sequential_container(stream, c);
    return stream;
}

template<typename T, size_t N> ostream& operator << (ostream& stream, const array<T, N>& c) {
    print_sequential_container(stream, c);
    return stream;
}

template<typename T> ostream& operator << (ostream& stream, const deque<T>& c) {
    print_sequential_container(stream, c);
    return stream;
}

template<typename T> ostream& operator << (ostream& stream, const stack<T>& c) {
    vector<T> v;
    while (not c.empty()) {
        v.pb(c.top());
        c.pop();
    }
    for (int i = ((int)v.size()) - 1; i >= 0; i--) {
        c.push(v[i]);
    }
    print_sequential_container(stream, v);
    return stream;
}

template<typename T> ostream& operator << (ostream& stream, const queue<T>& c) {
    vector<T> v;
    while (not c.empty()) {
        v.pb(c.front());
        c.pop();
    }
    for (T e: v) {
        c.push(e);
    }
    print_sequential_container(stream, v);
    return stream;
}

template<typename T> ostream& operator << (ostream& stream, const priority_queue<T>& c) {
    vector<T> v;
    while (not c.empty()) {
        v.pb(c.top());
        c.pop();
    }
    for (T e: v) {
        c.push(e);
    }
    print_sequential_container(stream, v);
    return stream;
}

template<typename T> ostream& operator << (ostream& stream, const set<T>& c) {
    print_set(stream, c);
    return stream;
}

template<typename T> ostream& operator << (ostream& stream, const unordered_set<T>& c) {
    print_set(stream, c);
    return stream;
}

template<typename T> ostream& operator << (ostream& stream, const multiset<T>& c) {
    print_set(stream, c);
    return stream;
}

template<typename T> ostream& operator << (ostream& stream, const unordered_multiset<T>& c) {
    print_set(stream, c);
    return stream;
}

template<typename T1, typename T2> ostream& operator << (ostream& stream, const map<T1, T2>& c) {
    print_map(stream, c);
    return stream;
}

template<typename T1, typename T2> ostream& operator << (ostream& stream, const unordered_map<T1, T2>& c) {
    print_map(stream, c);
    return stream;
}

template<typename T1, typename T2> ostream& operator << (ostream& stream, const multimap<T1, T2>& c) {
    print_map(stream, c);
    return stream;
}

template<typename T1, typename T2> ostream& operator << (ostream& stream, const unordered_multimap<T1, T2>& c) {
    print_map(stream, c);
    return stream;
}

template<typename T1, typename T2> ostream& operator << (ostream& stream, const pair<T1, T2>& p) {
    stream << "(" << p.fi << ", " << p.se << ")";
    return stream;
}

template<typename T>
size_t make_hash(const T& v) {
    return std::hash<T>()(v);
}

size_t hash_combine(const size_t& h, const size_t& v) {
    return h ^ (v + 0x9e3779b9 + (h << 6) + (h >> 2));
}

namespace std {
    template <typename T1, typename T2>
    struct hash<pair<T1, T2>> {
    public:
        size_t operator()(const pair<T1, T2>& p) const {
            return hash_combine(make_hash(p.fi), make_hash(p.se));
        }
    };
};

template<typename T>
struct hash_container
{
    size_t operator()(const T& c) const {
        size_t h = 0;
        for(const auto& e: c) {
            h = hash_combine(h, make_hash(e));
        }
        return h;
    }
};

typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vpii;
typedef vector<vi> vvi;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef pair<ll, ll> pll;
typedef double ld;

template<typename T> bool amin(T &a, T b) { return a > b ? (a = b, true) : false; }
template<typename T> bool amax(T &a, T b) { return a < b ? (a = b, true) : false; }

const int mod = 1000000007;
const int inf = 1000000000;
const ll infll = (ll)inf * (ll)inf;
const int maxn = 100000;

struct Q {
    int x, y;
    char c;
};

bool cmpx(Q& q1, Q& q2) {
    return q1.x < q2.x;
}

bool cmpy(Q& q1, Q& q2) {
    return q1.y < q2.y;
}

int g(int x, int k) {
    if (x >= 0) return x / k;
    return (x + 1) / k - 1;
}

class TaskB {
public:
    void solve(istream& in, ostream& out) {
        int n, k;
        in >> n >> k;
        vector<Q> v(n);
        forn(i, n) in >> v[i].x >> v[i].y >> v[i].c;
        int res = 0;
        forn(x, k + 1) {
            forn(y, k + 1) {
                int curr = 0;
                forn(i, n) {
                    int a = g(v[i].x - x, k), b = g(v[i].y - y, k);
                    int p = abs(a + b) % 2;
                    if (p == 0 and v[i].c == 'W') {
                        curr++;
                    }
                    if (p == 1 and v[i].c == 'B') {
                        curr++;
                    }
                }
                res = max(res, curr);
            }
        }
        out << res;
    }
};


Compiler output:
/usr/bin/ld: /usr/lib/gcc/x86_64-linux-gnu/14/../../../x86_64-linux-gnu/Scrt1.o: in function `_start':
(.text+0x17): undefined reference to `main'
collect2: error: ld returned 1 exit status