#include <bits/stdc++.h>

template<typename Val,
         typename VV = std::plus<Val>>
class fenwick_tree {
public:
    typedef std::size_t size_type;

protected:
    const Val E;

    size_type n;
    std::vector<Val> val;

    VV fun;

public:
    fenwick_tree() : fenwick_tree(0) {}

    fenwick_tree(size_type _n)
        : E(), n(_n), val(n + 1, E) {}

    fenwick_tree(size_type _n, const Val &_E)
        : E(_E), n(_n), val(n + 1, E) {}

    size_type size() const {
        return n;
    }

    void modify(size_type x, const Val &v) {
        for (++x; x <= n; x += x & -x) {
            val[x] = fun(val[x], v);
        }
    }

    Val query(size_type x) {
        Val s = E;

        for (; x; x ^= x & -x) {
            s = fun(s, val[x]);
        }

        return s;
    }
};

template<typename T>
struct max {
    const T &operator()(const T &a, const T &b) const {
        return std::max(a, b);
    }
};

class lower {
    int n, m;
    fenwick_tree<int, max<int>> T;

public:
    lower(int t_n, int t_m) : n(t_n), m(t_m), T(n + 1) {
        T.modify(n, m);
    }

    void modify(int x, int y) {
        T.modify(x, y + 1);
    }

    int query(int x) {
        return T.query(x + 1);
    }

    int check(int x, int y) {
        if (query(x) >= y + 1) {
            return -1;
        }

        if (query(x + 1) >= y) {
            return 0;
        }

        return 1;
    }
};

class upper {
    int n, m;
    fenwick_tree<int, max<int>> T;

public:
    upper(int t_n, int t_m) : n(t_n), m(t_m), T(n + 1) {
        T.modify(n, m);
    }

    void modify(int x, int y) {
        T.modify(n - x - 1, m - y);
    }

    int query(int x) {
        return m - T.query(n - x + 1);
    }

    int check(int x, int y) {
        if (query(x + 1) <= y) {
            return -1;
        }

        if (query(x) <= y + 1) {
            return 0;
        }

        return 1;
    }
};

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    std::istream &fin = std::cin;
    std::ostream &fout = std::cout;

    int n, m, q;
    fin >> n >> m >> q;

    lower L(n, m);
    upper U(n, m);

    std::vector<std::set<int>> row(n), col(m);

    auto insL = [&](int x, int y) {
        std::queue<std::pair<int, int>> Q;
        Q.emplace(x, y);

        while (!Q.empty()) {
            int x = Q.front().first, y = Q.front().second;
            Q.pop();
            L.modify(x, y);
            assert(x >= 1);

            while (!row[x - 1].empty()) {
                auto it = row[x - 1].begin();

                if (*it <= y + 1) {
                    Q.emplace(x - 1, *it);
                    row[x - 1].erase(it);
                } else {
                    break;
                }
            }

            assert(y + 1 < m);

            while (!col[y + 1].empty()) {
                auto it = --col[y + 1].end();

                if (*it >= x - 1) {
                    Q.emplace(*it, y + 1);
                    col[y + 1].erase(it);
                } else {
                    break;
                }
            }
        }
    };

    auto insU = [&](int x, int y) {
        std::queue<std::pair<int, int>> Q;
        Q.emplace(x, y);

        while (!Q.empty()) {
            int x = Q.front().first, y = Q.front().second;
            Q.pop();
            U.modify(x, y);
            assert(y >= 1);

            while (!col[y - 1].empty()) {
                auto it = col[y - 1].begin();

                if (*it <= x + 1) {
                    Q.emplace(*it, y - 1);
                    col[y - 1].erase(it);
                } else {
                    break;
                }
            }

            assert(x + 1 < n);

            while (!row[x + 1].empty()) {
                auto it = --row[x + 1].end();

                if (*it >= y - 1) {
                    Q.emplace(x + 1, *it);
                    row[x + 1].erase(it);
                } else {
                    break;
                }
            }
        }
    };

    auto check = [&](int x, int y) {
        int cL = L.check(x, y), cU = U.check(x, y);

        if (cL == -1 || cU == -1) {
            return false;
        }

        if (cL == 0 && cU == 0) {
            return true;
        }

        if (cL == 0) {
            insL(x, y);
        } else if (cU == 0) {
            insU(x, y);
        } else {
            row[x].insert(y);
            col[y].insert(x);
        }

        return false;
    };

    int ans = 0;

    while (q--) {
        int x, y, z;
        fin >> x >> y >> z;
        x = (x ^ ans) % n, y = (y ^ ans) % m;

        if (!check(x, y)) {
            fout << "NIE\n";
        } else {
            fout << "TAK\n";
            ans ^= z;
        }
    }
}