#include <iostream>
#include <vector>
#include <queue>
using namespace std;

vector<int> BFS(vector<vector<int>> &graph, int v)
{
    vector<bool> visit(graph.size(), false);
    vector<int> layer(graph.size(), -1);
    queue<int> bfs;

    layer[v] = 0;
    visit[v] = true;
    bfs.push(v);

    while (!bfs.empty())
    {
        int u = bfs.front();
        bfs.pop();

        for (auto x : graph[u])
        {
            if (!visit[x])
            {
                visit[x] = true;
                layer[x] = layer[u] + 1; // ✅ increment distance properly
                bfs.push(x);
            }
        }
    }

    return layer;
}

void solve(vector<int> &tom, vector<int> &jerry, vector<vector<int>> &graph,
           int s, vector<bool> &visit, bool &p, int &e)
{
    visit[s] = true;

    if (tom[s] != -1)
    {
        if (tom[s] <= jerry[s])
            return;
    }

    if (s == e)
    {
        p = true;
        return;
    }

    for (auto x : graph[s])
    {
        if (!visit[x])
            solve(tom, jerry, graph, x, visit, p, e);
    }
}

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

    int n, m, t, jt, e;
    cin >> n >> m >> t >> jt >> e;

    vector<vector<int>> graphj(n + 1);
    vector<vector<int>> grapht(n + 1);

    for (int i = 0; i < m; i++)
    {
        int x, y, d;
        cin >> x >> y >> d;

        graphj[x].push_back(y);
        graphj[y].push_back(x);

        if (d == 2)
        {
            grapht[x].push_back(y);
            grapht[y].push_back(x);
        }
    }

    vector<int> ans = BFS(grapht, t);

    while (jt--)
    {
        int x;
        cin >> x;
        vector<int> jerry = BFS(graphj, x);
        vector<bool> visit(n + 1, false);
        bool p = false;
        solve(ans, jerry, graphj, x, visit, p, e);

        if (!p)
            cout << "NEM\n";
        else
            cout << "IGEN\n";
    }

    return 0;
}