#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <numeric>
#include <queue>
#include <stack>
#include <map> 
#include <set>
#include <string>
#include <functional>
#include <list>
#include <time.h>
#include <iomanip>
#include <assert.h>
#include <numeric>
#include <sstream>
#define BIT(nr) (1UL << (nr))
//#define int long long
//#define ll long long
//#define double long double
#define mod 1000000007
#define MAXN (int)1e+5 * 2+1
#define LL_MAX 214748364	//ない環境用
#define LL_HALFMAX 214748364	//ない環境用
#define MIN -(9223372036854775807 / 2)
#define REP(i,a,n) for(int i=(a); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define FOR(it,c) for(__typeof((c).begin()) it=(c).begin(); it!=(c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
#define REPS(i,x) for(int i=1;i<=(int)(x);i++)
#define RREP(i,x) for(int i=((int)(x)-1);i>=0;i--)
#define RREPS(i,x) for(int i=((int)(x));i>0;i--)
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define mp make_pair
template<typename T1, typename T2> inline void chmin(T1 & a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> inline void chmax(T1& a, T2 b) { if (a < b) a = b; }


using namespace std;

using Weight = double;
using Flow = double;
struct Edge {
	int src, dst;
	Weight weight;
	Flow cap;
	Edge() : src(0), dst(0), weight(0) {}
	Edge(int s, int d, Weight w) : src(s), dst(d), weight(w) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
using Array = std::vector<Weight>;
using Matrix = std::vector<Array>;

void add_edge(Graph& g, int a, int b, Weight w = 1) {
	g[a].emplace_back(a, b, w);
	g[b].emplace_back(b, a, w);
}
void add_arc(Graph& g, int a, int b, Weight w = 1) { g[a].emplace_back(a, b, w); }

std::vector<Weight> dijkstra(const Graph &g, int s) {
	const Weight INF = std::numeric_limits<Weight>::max() / 8;
	using state = std::tuple<Weight, int>;
	std::priority_queue<state> q;
	std::vector<Weight> dist(g.size(), INF);
	dist[s] = 0;
	q.emplace(0, s);
	while (q.size()) {
		Weight d;
		int v;
		std::tie(d, v) = q.top();
		q.pop();
		d *= -1;
		/* if(v == t) return d; */
		if (dist[v] < d) continue;
		for (auto &e : g[v]) {
			if (dist[e.dst] > dist[v] + e.weight) {
				dist[e.dst] = dist[v] + e.weight;
				q.emplace(-dist[e.dst], e.dst);
			}
		}
	}
	return dist;
}

void solve(int n, int m, int p, int a, int b) {
	vector<double> t(n);
	rep(i, n) cin >> t[i];
	vector<int> x(p), y(p);
	vector<double> z(p);
	rep(i, p) cin >> x[i] >> y[i] >> z[i];

	// チケットの状態 2^n 個を持ったグラフを構築する
	// Gのノード番号を No とすると、元のグラフのノード番号はNo / n、チケット使用状況は No % n
	// つまり、No = n * ticketStat + S ただし、Sはチケットの使用状況を表す集合
	int ticketStat = 1 << n;
	Graph G((m + 1) * ticketStat);

	rep(i, p) {
		// before use
		rep(s, ticketStat) {
			rep(tic, n) {
				if ((s >> tic) & 1) {
					int mask = ~(1 << tic);
					int nxt = s & mask;
					int src = x[i] * ticketStat + s;
					int dst = y[i] * ticketStat + nxt;
					double weight = z[i] / t[tic];

					add_arc(G, src, dst, weight);

					// reverse
					src = y[i] * ticketStat + s;
					dst = x[i] * ticketStat + nxt;

					add_arc(G, src, dst, weight);
				}
			}
		}
	}

	auto v = dijkstra(G, (a + 1) * ticketStat - 1);

	double ans = (double)LL_HALFMAX;

	REP(i, b*ticketStat, (b + 1)*ticketStat) {
		chmin(ans, v[i]);
	}

	if (ans >= 214748362) {
		cout << "Impossible" << endl;
	}
	else {
		cout << setprecision(20) << ans << endl;
	}
}

signed main() {

	while (1) {
		int n, m, p, a, b;
		cin >> n >> m >> p >> a >> b;
		if (n == 0) {
			break;
		}
		solve(n, m, p, a, b);
	}
	return 0;
}


Measured memory_bytes: 35944