#include <iostream>
#include <vector>
#include <set>
#include <map>

#define REP(x,n) for(int x=0;x<(n);++x)
#define FOREACH(x, c) for(auto x = (c).begin(); x != (c).end(); ++x)

//#define DEBUG_LEVEL -10

#ifdef DEBUG_LEVEL
    #define DEBUG(level, x) {if (level >= DEBUG_LEVEL) {x}}
#else
    #define DEBUG(level, x)
#endif

using namespace std;

const int MAX_N = 100001;
const int GLOBAL_PARTY = -1;

int scores[MAX_N];
int scoresPerParty[MAX_N];
struct Node {
    vector<int> edges;
    map<int, set<Node*>> neighbourRootsPerParty;
    Node* ancestor;
    int party;
} graph[MAX_N];

Node* getRoot(Node* current) {
    if (current->ancestor == nullptr) {
        return current;
    }
    return current->ancestor = getRoot(current->ancestor);
}

set<Node*> queue;
set<Node*> rootsPerParty[MAX_N];

void processInitial(int start, int depth) {
    Node& thisNode = graph[start];
    Node* thisRoot = getRoot(&thisNode);
    DEBUG(0, cerr << __LINE__ << string(2*depth, ' ')<< " Processing node " << start << " with party " << thisNode.party << " and root " << thisRoot-graph << endl;)
    FOREACH(it, thisNode.edges) {
        int targetNo = *it;
        Node& targetNode = graph[targetNo];
        Node* targetRoot = getRoot(&targetNode);
        DEBUG(-3, cerr << __LINE__ << string(2*depth, ' ')<< "   Checking neighbour " << targetNo << " with party " << targetNode.party << " and root " << targetRoot-graph << endl;)
        if (targetRoot->party == thisRoot->party && targetRoot != thisRoot) {
            DEBUG(-1, cerr << __LINE__ << string(2*depth, ' ')<< "   Adding node " << targetNo << " to current set" << endl;)
            targetNode.ancestor = thisRoot;
            --scoresPerParty[targetNode.party];
            DEBUG(-2, cerr << __LINE__ << string(2*depth, ' ') << "     For party " << targetNode.party << " remain " << scoresPerParty[targetNode.party] << " nodes" << endl;)
            processInitial(targetNo, depth+1);
        }
    }
    if (scoresPerParty[thisNode.party] == 1) {
        DEBUG(-1, cerr << __LINE__ << " Party " << thisNode.party << " is coherent" << endl;)
        scoresPerParty[thisNode.party] = 0;
        FOREACH(it, thisNode.edges) {
            Node& neighbour = graph[*it];
            neighbour.neighbourRootsPerParty[thisNode.party].erase(&thisNode);
            getRoot(&neighbour)->neighbourRootsPerParty[thisNode.party].erase(&thisNode);
            getRoot(&neighbour)->neighbourRootsPerParty[GLOBAL_PARTY].insert(thisRoot);
        }
        thisRoot->party = GLOBAL_PARTY;
        queue.insert(thisRoot);
    }
}

bool inline contains(set<Node*>& nodes, Node* element) {
    return nodes.find(element) != nodes.end();
}

bool allCanReach(set<Node*>& nodes, Node* target) {
    FOREACH(nodeIt, nodes) {
        if (!contains((*nodeIt)->neighbourRootsPerParty[target->party], target)) {
            DEBUG(-3, cerr << __LINE__ << " Node " << (*nodeIt)-graph << " cannot reach " << target-graph << endl;)
            return false;
        }
    }
    DEBUG(-2, cerr << __LINE__ << " All nodes for party " << (*nodes.begin())->party << " can reach " << target-graph << endl;)
    return true;
}

void reassignNeighbours(Node* from, Node* to) {
    DEBUG(-3, cerr << __LINE__ << " Reassigning neighbours from " << from-graph << " to " << to-graph << endl;)
    FOREACH(nrppIt, from->neighbourRootsPerParty) {
        FOREACH(it, nrppIt->second) {
            Node* neighbour = *it;
            if (neighbour != to) {
                DEBUG(-4, cerr << __LINE__ << "   Reassigning neighbour " << neighbour-graph << " for party " << nrppIt->first << endl;)
                Node* neighbourRoot = getRoot(neighbour);
                auto& nrpp = neighbourRoot->neighbourRootsPerParty[from->party];
                nrpp.erase(from);
                if (neighbourRoot != to) {
                    neighbourRoot->neighbourRootsPerParty[to->party].insert(to);
                    to->neighbourRootsPerParty[nrppIt->first].insert(neighbourRoot);
                }
                DEBUG(-4, cerr << __LINE__ << "   Finished reassigning neighbour " << neighbour-graph << " for party " << nrppIt->first << endl;)
            }
        }
    }
    DEBUG(-3, cerr << __LINE__ << " Finished reassigning neighbours from " << from-graph << " to " << to-graph << endl;)
}

void mergeParty(set<Node*>& partyRoots) {
    Node* mainRoot = *partyRoots.begin();
    DEBUG(-1, cerr << __LINE__ << " Merging party " << mainRoot->party << " with main root " << mainRoot-graph << endl;)
    partyRoots.erase(mainRoot);
    while (!partyRoots.empty()) {
        Node* root = *partyRoots.begin();
        partyRoots.erase(root);
        if (root != mainRoot) {
            DEBUG(-2, cerr << __LINE__ << " Merging " << root-graph << " into " << mainRoot-graph << endl;)
            root->ancestor = mainRoot;
            rootsPerParty[mainRoot->party].erase(root);
            reassignNeighbours(root, mainRoot);
        }
    }
    partyRoots.insert(mainRoot);
    DEBUG(-1, cerr << __LINE__ << " Finished merging party " << mainRoot->party << " with main root " << mainRoot-graph << endl;)
}

void mergeGlobal(Node* mainRoot, set<Node*>& nodesToMerge) {
    DEBUG(-2, cerr << __LINE__ << " Started merging global neighbours into " << mainRoot-graph << endl;)
    while (!nodesToMerge.empty()) {
        Node* neighbour = *nodesToMerge.begin();
        nodesToMerge.erase(neighbour);
        
        if (neighbour->ancestor == nullptr && neighbour != mainRoot) {
            DEBUG(-1, cerr << __LINE__ << " Merging global neighbour " << neighbour-graph << " into " << mainRoot-graph << endl;)
            neighbour->ancestor = mainRoot;
            reassignNeighbours(neighbour, mainRoot);
            neighbour->party = GLOBAL_PARTY;
            queue.insert(neighbour);
        }
    }
    DEBUG(-2, cerr << __LINE__ << " Finished merging global neighbours into " << mainRoot-graph << endl;)
}

void processRoot(Node* currentRoot) {
    if (currentRoot->ancestor != nullptr) {
        DEBUG(-1, cerr << "Skip processing global root " << currentRoot-graph << ", remaining: " << queue.size() << endl;)
        return;
    }
    DEBUG(-1, cerr << "Processing global root " << currentRoot-graph << ", remaining: " << queue.size() << endl;)
    DEBUG(-3,
        cerr << __LINE__ << " with neighbours: ";
        FOREACH(partyIt, currentRoot->neighbourRootsPerParty) {
            cerr << partyIt->first << ": { ";
            FOREACH(neighbourIt, partyIt->second) {
                cerr << (*neighbourIt)-graph << " ";
            }
            cerr << "} ";
        }
        cerr << endl;
    )
    
    auto globalNeighbourRootsIt = currentRoot->neighbourRootsPerParty.find(GLOBAL_PARTY);
    if (globalNeighbourRootsIt != currentRoot->neighbourRootsPerParty.end()) {
        DEBUG(-2,
            cerr << __LINE__ << " Merging with global neighbours: ";
            FOREACH(it, globalNeighbourRootsIt->second) {
                cerr << " " << (*it) - graph;
            }
            cerr << endl;
        )
        mergeGlobal(currentRoot, globalNeighbourRootsIt->second);
        currentRoot->neighbourRootsPerParty.erase(globalNeighbourRootsIt);

        DEBUG(-3,
            cerr << __LINE__ << " Neighbours after merging: ";
            FOREACH(partyIt, currentRoot->neighbourRootsPerParty) {
                cerr << partyIt->first << ": { ";
                FOREACH(neighbourIt, partyIt->second) {
                    cerr << (*neighbourIt)-graph << " ";
                }
                cerr << "} ";
            }
            cerr << endl;
            if (getRoot(currentRoot) != currentRoot) {
                cerr << __LINE__ << " Root neighbours after merging: ";
                FOREACH(partyIt, getRoot(currentRoot)->neighbourRootsPerParty) {
                    cerr << partyIt->first << ": { ";
                    FOREACH(neighbourIt, partyIt->second) {
                        cerr << (*neighbourIt)-graph << " ";
                    }
                    cerr << "} ";
                }
                cerr << endl;
            }
        )
    }
    Node* newRoot = getRoot(currentRoot); // maybe we should check the ancestor

    FOREACH(nrppIt, currentRoot->neighbourRootsPerParty) {
        if (scoresPerParty[nrppIt->first] == 0) {
            DEBUG(-3, cerr << __LINE__ << " Party " << nrppIt->first << " already coherent, skipping" << endl;)
            continue;
        }
        int party = nrppIt->first;
        set<Node*>& fullNeighbours = newRoot->neighbourRootsPerParty[party];
        if (fullNeighbours.size() == rootsPerParty[party].size()) {
            scoresPerParty[party] = 0;
            DEBUG(-3, cerr << __LINE__ << " Connects with all " << rootsPerParty[party].size() << " roots of party " << party << endl;)
            auto& rpp = rootsPerParty[party];
            while (!rpp.empty()) {
                Node* partyRoot = *rpp.begin();
                rpp.erase(partyRoot);
                DEBUG(-3, cerr << __LINE__ << " Adding root " << partyRoot-graph << " to queue" << endl;)
                partyRoot->party = GLOBAL_PARTY;
                queue.insert(partyRoot);
            }
        } else if (nrppIt->second.size() > 1) {
            DEBUG(-3,
                cerr << __LINE__ << " Merging " << nrppIt->second.size() << " roots for party " << party << " together: ";
                FOREACH(neighbourRootIt, nrppIt->second) {
                    cerr << (*neighbourRootIt)-graph << " ";
                }
                cerr << endl;
            )
            mergeParty(nrppIt->second);
        }
    }
}

void processRoots() {
    DEBUG(-1, cerr << __LINE__ << " Processing queue of size: " << queue.size() << endl;)
    while (!queue.empty()) {
        Node* currentRoot = *queue.begin();
        queue.erase(currentRoot);
        processRoot(currentRoot);
    }
}

bool solve() {
    queue.clear();
    int n,m,k, a,b, party;
    cin >> n >> m >> k;
    REP(x,k) {
        scoresPerParty[x+1] = 0;
        rootsPerParty[x+1].clear();
    }
    REP(x,n) {
        cin >> party;
        scores[x] = party;
        graph[x].edges.clear();
        graph[x].neighbourRootsPerParty.clear();
        graph[x].ancestor = nullptr;
        graph[x].party = scores[x];

        ++scoresPerParty[party];
    }
    REP(x,m) {
        cin >> a >> b;
        graph[a-1].edges.push_back(b-1);
        graph[b-1].edges.push_back(a-1);
    }

    REP(x,n) {
        if (graph[x].ancestor == nullptr) {
            processInitial(x, 0);
        }
    }

    set<Node*> roots;

    REP(x,n) {
        Node& thisNode = graph[x];
        Node* thisRoot = getRoot(&thisNode);
        roots.insert(thisRoot);
        if (thisRoot->party != GLOBAL_PARTY) {
            rootsPerParty[thisRoot->party].insert(thisRoot);
            DEBUG(-3, cerr << __LINE__ << " Adding root " << thisRoot-graph << " for party " << thisRoot->party << " from node " << x << endl;)
        }
        FOREACH(it, thisNode.edges) {
            Node& otherNode = graph[*it];
            if (&otherNode != thisRoot) {
                thisRoot->neighbourRootsPerParty[otherNode.party].insert(getRoot(&otherNode));
            }
        }
    }

    DEBUG(-1, 
        cerr << __LINE__ << " Neighbour roots per party:" << endl;
        REP(x,k) {
            cerr << "  Party " << x+1 << ": " << endl;
            FOREACH(it, rootsPerParty[x+1]) {
                Node* root = *it;
                cerr << "   * Root " << root-graph << " with neighbours: ";
                FOREACH(partyIt, root->neighbourRootsPerParty) {
                    cerr << partyIt->first << ": { ";
                    FOREACH(neighbourIt, partyIt->second) {
                        cerr << (*neighbourIt)-graph << " ";
                    }
                    cerr << "} ";
                }
                cerr << endl;
            }
        }
        
        cerr << __LINE__ << " Remaining parties:" << endl << "\t";
        REP(x,k) {
            cerr << scoresPerParty[x+1] << " ";
        }
        cerr << endl;
    )

    processRoots();



    DEBUG(-1, 
        cerr << __LINE__ << " Result party:" << endl << "\t";
        REP(x,k) {
            cerr << scoresPerParty[x+1] << " ";
        }
        cerr << endl;
    )
    REP(x,k) {
        if (scoresPerParty[x+1] > 0) {
            return false;
        }
    }
    return true;
}

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

    int t;
    cin>>t;
    REP(x,t) {
        cout << (solve() ? "TAK" : "NIE") << endl;
    }
}