#include <algorithm>
#include <iostream>
#include <iterator>
#include <queue>
#include <vector>

#define cost_t int_least64_t
#define COST_INF INT_LEAST64_MAX

const int MAX_CITIES = 100;
const int MAX_TIME = 100;
const int NUM_TIME = MAX_TIME + 1;

struct Edge {
	int target;
	int distance;
};

struct City {
	bool has_freezer;
	std::vector<Edge> edges;

	City() : has_freezer(false) {}
};

struct KeyState {
	int city;
	cost_t cost;
	int left_time;
};

struct GreaterCost {
	bool operator()(KeyState& x, KeyState& y) {
		return x.cost > y.cost;
	}
};

class CostCache {
	const int CACHE_SIZE = MAX_CITIES * NUM_TIME;

	cost_t *m_cache;

public:
	CostCache() {
		m_cache = new cost_t[CACHE_SIZE];
	}

	~CostCache()
	{
		delete[] m_cache;
	}

	void clear() {
		std::fill(&m_cache[0], &m_cache[CACHE_SIZE], COST_INF);
	}

	cost_t& get(int city, int time) {
		return m_cache[city * NUM_TIME + time];
	}

	cost_t get_min_cost(int city) {
		return *std::min_element(&m_cache[city * NUM_TIME], &m_cache[(city + 1) * NUM_TIME]);
	}

	bool update(int city, int left_time, cost_t cost) {
		cost_t& r = get(city, left_time);
		if (cost < r) {
			r = cost;
			return true;
		}
		return false;
	}
};

int main()
{
	CostCache cost_cache;
	std::vector<City> cities;
	cities.reserve(MAX_CITIES);

	while (true) {
		int num_cities, max_time, num_freezable_cities, num_roads, start_city, dest_city;
		std::cin >> num_cities >> max_time >> num_freezable_cities >> num_roads >> start_city >> dest_city;

		if (num_cities == 0) return 0;

		// ?????????????????????????????????????????°????????´???
		cities.clear();
		cities.resize(num_cities);

		for (int i = 0; i < num_freezable_cities; i++) {
			int j;
			std::cin >> j;
			cities[j].has_freezer = true;
		}

		for (int i = 0; i < num_roads; i++) {
			int x, y, t;
			std::cin >> x >> y >> t;
			cities[x].edges.push_back({ y, t });
			cities[y].edges.push_back({ x, t });
		}

		cost_cache.clear();

		std::priority_queue<KeyState, std::vector<KeyState>, GreaterCost> queue;
		queue.push({ start_city, 0, max_time });

		while (!queue.empty()) {
			KeyState state = queue.top();
			queue.pop();

			if (cost_cache.get(state.city, state.left_time) < state.cost)
				continue;

			City& current_city = cities[state.city];

			for (Edge& edge : current_city.edges) {
				if (current_city.has_freezer) {
					// ???????¨???????????????????1???????????????????????????
					for (int freeze_time = 0; state.left_time + freeze_time <= MAX_TIME; freeze_time++) {
						int new_left_time = state.left_time + freeze_time - edge.distance;
						if (new_left_time < 0) continue;

						cost_t new_cost = state.cost + freeze_time + edge.distance;

						if (cost_cache.update(edge.target, new_left_time, new_cost))
							queue.push({ edge.target, new_cost, new_left_time });
					}
				}
				else {
					int new_left_time = state.left_time - edge.distance;
					if (new_left_time >= 0) {
						cost_t new_cost = state.cost + edge.distance;

						if (cost_cache.update(edge.target, new_left_time, new_cost))
							queue.push({ edge.target, new_cost, new_left_time });
					}
				}
			}
		}

		cost_t result = cost_cache.get_min_cost(dest_city);
		if (result == COST_INF) {
			std::cout << "Help!\n";
		}
		else {
			std::cout << result << std::endl;
		}
	}
}

Measured memory_bytes: 4624