#include <bits/stdc++.h>
using namespace std;

struct dfs_node {
    int node;
    int parent;
    bool visited;
};

struct city_data {
    int parent;
    bool visited = false;
    int dfs_in;
    int dfs_out;
    int depth;
};

struct edge {
    int higher;
    int lower;
};

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

    int t;
    int n, m, k;
    int u, v;
    bool valid = true;

    vector<int> colors_in_city;

    cin >> t;

    for(int i=0; i<t; i++) {
        valid = true;

        cin >> n >> m >> k;
        

        vector<vector<int>> roads;
        roads.resize(n);
        colors_in_city.resize(n);

        vector<city_data> c_data;
        c_data.resize(n);
        vector<bool> used_colors;
        used_colors.assign(k, false);


        for(int j=0; j<n; j++) {
            cin >> colors_in_city[j];
            colors_in_city[j]--;
        }
        for(int j=0; j<m; j++) {
            cin >> u >> v;
            roads[u-1].push_back(v-1);
            roads[v-1].push_back(u-1);
        }

        int root;
        vector<vector<int>> colors_used_ordered;
        vector<int> highest_ancestor_for_color;
        highest_ancestor_for_color.resize(k);

        for(int j=0; j<n; j++) {
            if(c_data[j].visited) {
                continue;
            }
            root = j;

            c_data[root].visited = true;

            map<int, vector<int>> dfs_colors;
            vector<edge> edges;
            vector<int> nodes_in_current_tree;

            //dfs from root

            int dfs_order = 0;

            vector<dfs_node> dfs_stack;

            dfs_node dnnn;
            dnnn.node = root;
            dnnn.parent = root;
            dnnn.visited = false;
            dfs_stack.push_back(dnnn);

            set<int> all_colors_in_current_subtree;

            while(dfs_stack.size() > 0) {
                dfs_node current = dfs_stack.back();
                dfs_stack.pop_back();

                if(!current.visited) {
                    nodes_in_current_tree.push_back(current.node);
                    int current_color = colors_in_city[current.node];
                    all_colors_in_current_subtree.insert(current_color);
                    if(dfs_colors.count(current_color)) {
                        dfs_colors[current_color].push_back(current.node);
                    } else {
                        vector<int> colors_list;
                        colors_list.push_back(current.node);
                        dfs_colors.emplace(current_color, colors_list);
                    }

                    c_data[current.node].dfs_in = dfs_order;
                    dfs_order++;

                    c_data[current.node].parent = current.parent;
                    c_data[current.node].visited = true;
                    c_data[current.node].depth = current.node == root ? 0 : c_data[current.parent].depth + 1;

                    dfs_node dnn;
                    dnn.node = current.node;
                    dnn.parent = current.parent;
                    dnn.visited = true;
                    dfs_stack.push_back(dnn);

                    for(int l=0; l<roads[current.node].size(); l++) {
                        int connection = roads[current.node][l];
                        if(connection != current.parent) {
                            dfs_node dn;
                            dn.node = connection;
                            dn.parent = current.node;
                            dn.visited = false;
                            dfs_stack.push_back(dn);
                            if(colors_in_city[current.node] != colors_in_city[connection]) {
                                edge ed;
                                ed.higher = current.node;
                                ed.lower = connection;
                                edges.push_back(ed);
                            }
                        }
                    }
                } else {
                    c_data[current.node].dfs_out = dfs_order;
                    dfs_order++;
                }
            }

            // check if colors in subtree were not used in other subtrees

            for(auto itr : all_colors_in_current_subtree) {
                    if(used_colors[itr]) {
                        valid = false;
                        break;
                    }
                    used_colors[itr] = true;
            }

            if(!valid) {
                break;
            }


            // find highest ancestor for each color

            for(map<int,vector<int>>::iterator iter = dfs_colors.begin(); iter != dfs_colors.end(); ++iter) {
                int col =  iter->first;
                vector<int> col_l = iter->second;
                int first = col_l.front();
                int last = col_l.back();

                int highest_ancestor;

                int depth_first = c_data[first].depth;
                int depth_last = c_data[last].depth;

                if(depth_first > depth_last) {
                    while(depth_first > depth_last) {
                        first = c_data[first].parent;
                        depth_first = c_data[first].depth;
                    }
                } else if(depth_last > depth_first) {
                    while(depth_last > depth_first) {
                        last = c_data[last].parent;
                        depth_last = c_data[last].depth;
                    }
                }

                while(first != last) {
                    first = c_data[first].parent;
                    last = c_data[last].parent;
                }

                highest_ancestor = first;

                highest_ancestor_for_color[col] = highest_ancestor;
            }

            // for each road in current tree add a dependency direction

            vector<set<int>> dependencies;
            dependencies.resize(k);

            for(int l=0; l<edges.size(); l++) {
                edge e = edges[l];
                if(highest_ancestor_for_color[colors_in_city[e.lower]] == e.lower) {
                    dependencies[colors_in_city[e.higher]].insert(colors_in_city[e.lower]);
                } else {
                    dependencies[colors_in_city[e.lower]].insert(colors_in_city[e.higher]);
                }
            }

            // check if dependencies without cycle

            vector<int> indegrees;
            indegrees.assign(k, 0);
            int ordered = 0;

            for(auto ii: all_colors_in_current_subtree) {
                for(auto itr : dependencies[ii]) {
                    indegrees[itr]++;
                }
            }

            queue<int> que;

            for(auto iii: all_colors_in_current_subtree) {
                if(indegrees[iii] == 0) {
                    que.push(iii);
                }
            }

            while(que.size() > 0) {
                int ff = que.front();
                que.pop();
                ordered++;
                for(auto itr : dependencies[ff]) {
                    indegrees[itr]--;
                    if(indegrees[itr] == 0) {
                        que.push(itr);
                    }
                }
            }

            valid = ordered == all_colors_in_current_subtree.size();

            if(!valid) {
                break;
            }

        }

        if(valid) {
            cout<<"TAK\n";
        } else {
            cout<<"NIE\n";
        }
    }

    return 0;
}