#define D(x) cout << #x " = " << x << endl
#define DD(x, y) cout << "(" #x ", " #y ") = (" << x << ", " << y << ")" << endl
#define DDD(x, y, z) cout << "(" #x ", " #y ", " #z ") = (" << x << ", " << y << ", " << z << ")" << endl
#define DV(v) for (auto __macro_vi : v){ cout << __macro_vi << " ";} cout << endl;
#define DA(a, n) for (int __macro_i = 0; __macro_i < n; ++__macro_i) { cout << a[__macro_i] << " "; } cout << endl;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define ALL(v) (v).begin(), (v).end()
#include<iostream>
#include<vector>
#include<cassert>
#include<cmath>
#include<sstream>
#include<queue>

using namespace std;

class Graph{
private:
    struct Node {
        int index;
        bool done;
        long long dist;
        vector<pair<int, int>> adj;
        Node() : done(false), dist(INF) {}

        bool operator>(const Node& another) const {
            return dist > another.dist;
        }
    };

    vector<Node> nodes;

    void range_check(int i) {
        if (i < 0 || i >= n) {
            cout << "dijkstra: Invalid node index: " << i << endl;
            throw "Exception";
        }
    }
public:
    const static long long INF = 1LL << 62;
    const int n;

    // n nodes directed graph
    Graph(int _n) : n(_n) {
        nodes = vector<Node>(_n);
        for (int i = 0; i < _n; ++i) {
            nodes[i].index = i;
        } 
    }

    // add directed edge from u-th node to v-th node
    void addEdge(int u, int v, int w) {
        range_check(u);
        range_check(v);
        nodes[u].adj.push_back(make_pair(v, w));
        if (w < 0) {
            cout << "dijkstra: All weights must be positive: " << w << " (" << u << " -- " << v << ")" << endl;
            throw "Exception";
        }
    }

    // add undirected edge between u-th node and v-th node
    void addUndirectedEdge(int u, int v, int w) {
        addEdge(u, v, w);
        addEdge(v, u, w);
    }

    // calculate shortest distance from s-th node
    void dijkstra(int s) {
        range_check(s);

        priority_queue<Node, vector<Node>, greater<Node>> pq;

        nodes[s].dist = 0;
        pq.push(nodes[s]);

        while (!pq.empty()) {
            Node top = pq.top();
            pq.pop();
            top.done = true;

            int u = top.index;
            for (pair<int, int> p : top.adj) {
                int v = p.first;
                int w = p.second;
                if (nodes[v].done) continue;

                long long newdist = nodes[u].dist + (long long)w;
                if (nodes[v].dist > newdist) {
                    nodes[v].dist = newdist;
                    pq.push(nodes[v]);
                }
            }
        }
    }

    // shortest distance to i
    long long shortestDistTo(int i) const {
        return nodes[i].dist;
    }

    // dump this graph
    string dump() const {
        ostringstream os;
        os << "node -> adj-node(distance), ..." << endl;
        for (Node node : nodes) {
            os << node.index << " -> ";
            for (pair<int, int> p : node.adj) {
                os << p.first << "(" << p.second << "), ";
            }
            os << endl;
        }
        return os.str();
    }
};

int n, m, l, k, start, goal;
int nodei(int i, int left) {
    return left * n + i;
}

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

    while(1) {
        cin >> n >> m >> l >> k >> start >> goal;
        if (n == 0) break;
        Graph g(n * (m + 1));
        vector<bool> isb(n, false);
        REP(i, l) {int ki; cin >> ki; isb[ki] = true;}
        isb[start] = true;
        REP(i, k) {
            int x, y, t;
            cin >> x >> y >> t;
            REP(tmp, 2) {
                for(int j = 0; j + t <= m; ++j) {
                    g.addEdge(nodei(x, j + t), nodei(y, j), t);
                }
                if (isb[x]) {
                    for (int j = 0; j <= m; ++j) {
                        for (int charge = 1; charge <= m; ++charge) {
                            if (j + charge > m) continue;
                            int left = j + charge - t;
                            if (left < 0 || left > m) continue;
                            g.addEdge(nodei(x, j), nodei(y, left), charge + t);
                        }
                    }
                }
                swap(x, y);
            }
        }
        g.dijkstra(nodei(start, m));
        long long ans = Graph::INF;
        REP(i, m + 1) {
            ans = min(ans, g.shortestDistTo(nodei(goal, i)));
        }
        if (ans == Graph::INF) {
            cout << "Help!" << endl;
        } else {
            cout << ans << endl;
        }
    }
}



Measured memory_bytes: 89448