extern crate core;

use std::fmt;
use std::cmp::{Ordering, min, max };
use std::ops::{Add, Sub, Mul, Div, Neg, Index, IndexMut, SubAssign, Range};
use std::collections::{BTreeMap, VecDeque, BinaryHeap, BTreeSet, HashMap};
use std::fmt::{Display, Formatter, Error};

fn show<T: Display>(vec: &Vec<T>) {
    if vec.is_empty() {
        println!("[]");
    }else {
        print!("[{}", vec[0]);
        for i in 1 .. vec.len() {
            print!(", {}", vec[i]);
        }
        println!("]");
    }
}
fn show2<T: Display>(vec: &Vec<Vec<T>>) {
    if vec.is_empty() {
        println!("[]");
    }else {
        for l in vec {
            show(l);
        }
    }
}

macro_rules! read_line{
    () => {{
        let mut line = String::new();
        std::io::stdin().read_line(&mut line).ok();
        line
    }};
    (delimiter: ' ') => {
        read_line!().split_whitespace().map(|x|x.to_string()).collect::<Vec<_>>()
    };
    (delimiter: $p:expr) => {
        read_line!().split($p).map(|x|x.to_string()).collect::<Vec<_>>()
    };
    (' ') => {
        read_line!(delimiter: ' ')
    };
    ($delimiter:expr) => {
        read_line!(delimiter: $delimiter)
    };
    (' '; $ty:ty) => {
        read_line!().split_whitespace().map(|x|x.parse::<$ty>().ok().unwrap()).collect::<Vec<$ty>>()
    };
    ($delimiter:expr; $ty:ty) => {
        read_line!($delimiter).into_iter().map(|x|x.parse::<$ty>().ok().unwrap()).collect::<Vec<$ty>>()
    };
}
macro_rules! read_value{
    () => {
        read_line!().trim().parse().ok().unwrap()
    }
}
macro_rules! let_all {
    ($($n:ident:$t:ty),*) => {
        let line = read_line!(delimiter: ' ');
        let mut iter = line.iter();
        $(let $n:$t = iter.next().unwrap().parse().ok().unwrap();)*
    };
}

macro_rules! let_mut_all {
    ($($n:ident:$t:ty),*) => {
        let line = read_line!(delimiter: ' ');
        let mut iter = line.iter();
        $(let mut $n:$t = iter.next().unwrap().parse().ok().unwrap();)*
    };
}
struct ValueWithKey<V, K> {
    value: V,
    key: K
}
impl <V, K: PartialOrd> Ord for ValueWithKey<V, K> {
    fn cmp(&self, other: &Self) -> Ordering {
        self.key.partial_cmp(&other.key).unwrap()
    }
}
impl <V, K: PartialOrd> PartialOrd for ValueWithKey<V, K> {
    fn partial_cmp(&self, other: &ValueWithKey<V, K>) -> Option<Ordering> {
        other.key.partial_cmp(&self.key)
    }
}
impl <V, K: PartialEq> PartialEq for ValueWithKey<V, K> {
    fn eq(&self, other: &Self) -> bool {
        other.key.eq(&self.key)
    }
}
impl <V, K: PartialEq> Eq for ValueWithKey<V, K>{}

fn main() {
    loop {
        let_all!(n: usize, m: usize, p: usize, a: usize, b: usize); if n == 0 && m == 0 && p == 0 && a == 0 && b == 0 {break;}
        let tickets = read_line!(' '; f64);
        let mut cities: Vec<Vec<(usize, f64)>> = vec![Vec::new(); m];
        for _ in 0 .. p {
            let_all!(x: usize, y: usize, z: f64);
            cities[x - 1].push((y - 1, z));
            cities[y - 1].push((x - 1, z));
        }
        let mut heap: BinaryHeap<ValueWithKey<(usize, usize), f64>> = BinaryHeap::new();
        let mut min_time = vec![vec![std::f64::MAX; 1 << n]; m];
        heap.push(ValueWithKey{value: (a - 1, 0usize), key: 0f64});
        while let Some(ValueWithKey{value: (current, state), key: time}) = heap.pop() {
            for &(next, length) in &cities[current] {
                for i in 0 .. n {
                    if (state & (1 << i)) == 0 {
                        if min_time[next][state | (1 << i)] > time + length / tickets[i] {
                            min_time[next][state | (1 << i)] = time + length / tickets[i];
                            heap.push(ValueWithKey{value: (next, state | (1 << i)), key: min_time[next][state | (1 << i)]});
                        }
                    }
                }
            }
        }
        if let Some(min) = min_time[b - 1].iter().filter(|&&f| f != std::f64::MAX).min_by(|f, g| f.partial_cmp(g).unwrap()) {
            println!("{:.6}", min);
        }else {
            println!("Impossible");
        }
    }
}



Measured memory_bytes: 7108