#include <bits/stdc++.h>
using namespace std;
#define int long long
int n, m, q;
vector<int> adj[5005];
int parityTo[5005][2]; // 0. for even, 1 for odd, parity from start to current node
void BFS(int src){
memset(parityTo, -1, sizeof(parityTo));
queue<pair<int, int>> q;
parityTo[src][0] = 0; // even -> 0 length
q.push({src, 0});
while(!q.empty()){
auto cur = q.front();
q.pop();
int idx = cur.first;
int parity = cur.second;
for(int ch : adj[idx]){
int np = parity ^ 1; // change by flip
if(parityTo[ch][np] == -1){
parityTo[ch][np] = parityTo[idx][parity] + 1;
q.push({ch, np});
}
}
}
}
struct test{
int id;
int start;
int end;
int len;
bool ans;
} queries[1000005];
bool comp(const test &a, const test &b){
return a.start < b.start;
}
bool comp2(const test &a, const test &b){
return a.id < b.id;
}
// do this: do queries in ascending order so that we can do bfs each time, but it will be COMP SIZE O(n+m) each time but n, m bounded by compoent size, amortize
int32_t main(){
cin >> n >> m >> q;
vector<bool> hasEdge(5005, false);
for(int i = 0; i < m; i++){
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
hasEdge[a] = true;
hasEdge[b] = true;
}
for(int i = 0; i < q; i++){
queries[i].id = i;
cin >> queries[i].start >> queries[i].end >> queries[i].len;
}
sort(queries, queries + q, comp);
for(int i = 0; i < q;){
int curStart = queries[i].start;
BFS(curStart);
// loop all sme start nodes
int idx = i;
while(idx < q && queries[idx].start == curStart){
if(adj[curStart].size() == 0){
queries[idx].ans = false;
idx++;
continue;
}
int curEnd = queries[idx].end;
int dist = queries[idx].len;
int needPar = dist%2;
if(parityTo[curEnd][needPar] != -1 && parityTo[curEnd][needPar] <= dist){
queries[idx].ans = true;
}else{
queries[idx].ans = false;
}
idx++;
}
i = idx; // idx is now NOT satisfy in same start node
}
sort(queries, queries + q, comp2);
for(int i = 0; i < q; i++){
if(queries[i].ans){
cout << "TAK\n";
}else{
cout << "NIE\n";
}
}
}
