# 2 "2298.cpp"
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
#include <numeric>
#include <complex>
#include <functional>
#include <iterator>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>

namespace algorithm {
   using namespace std;

   template <class TNode>
   class IBFS {
   public:
      queue <TNode> Q;
      IBFS() {
         Q = queue <TNode>();
      }
      virtual void init() = 0;
      virtual TNode get_start_node() = 0;
      virtual bool is_goal( TNode node ) = 0;
      TNode run() {
         init();
         Q.push( get_start_node() );
         while ( ! Q.empty() ) {
            TNode node = Q.front();
            Q.pop();
            if ( is_goal( node ) ) {
               return node;
            }
            find(node);
         }
         return TNode();
      }
      virtual void find( TNode node ) = 0;
      void push_next_node( TNode node ) {
         Q.push(node);
      }
   };
}


namespace solution {
   using namespace std;
   using namespace algorithm;

   typedef istringstream ISS;
   typedef ostringstream OSS;
   typedef vector<string> VS;
   typedef long long LL;
   typedef int INT;
   typedef vector<INT> VI;
   typedef vector<VI> VVI;
   typedef pair<INT, INT> II;

   const int SIZE = 201;
   const int MAX_LENGTH = 10001;
   const int NONE = -1.0;
   const double EPS = 1e-9;
   int N;
   int K;
   int T;
   int U;
   int V;
   int L;
   bool D[MAX_LENGTH];


   bool lessthan_equal( double a, double b ) {
      if ( fabs( a - b ) < EPS ) return true;
      return a < b;
   }

   class Node {
   public:
      double cost;
      int id;
      int remains;
      int carrots;
      Node(): cost(NONE){}
      Node( double cost, int id, int remains, int carrots ):
         cost(cost), id(id), remains(remains), carrots(carrots) {}
      friend ostream& operator << ( ostream& os, Node node ) {
         return os << node.cost << ", " << node.id << ", "
                   << node.remains << ", " << node.carrots << " / ";
      }
   };

   class BFS: public IBFS<Node> {
   private:
      double base;
      double fast;
   public:
      void init() {
         base = 1.0 / U;
         fast = 1.0 / V;
      }

      Node get_start_node() {
         return Node( 0.0, 0, 0, 0 );
      }

      bool is_goal( Node node ) {
         return node.id == L;
      }

      void find( Node node ) {
         int id = node.id;
         int carrots = node.carrots;
         int remains = node.remains;
         double cost = node.cost;


         if ( D[id] ) {
            if ( carrots == K ) {
               remains = T * V;
            } else {
               carrots ++;
               if ( remains == 0 ) {
                  remains = T * V;
                  carrots --;
               }
            }
         }

         double t = base;
         if ( remains ) {
            t = min( t, fast );
            remains --;
         }
         if ( remains == 0 && carrots ) {
            remains = T * V;
            carrots --;
         }

         push_next_node( Node( cost + t, id + 1, remains, carrots ) );
      }
   };

   class Solution {
   private:
      void init() {
         for ( int i = 0; i < MAX_LENGTH; ++ i ) {
            D[i] = false;
         }
      }

      bool input() {
         if ( ! ( cin >> N >> K >> T >> U >> V >> L ) ) return false;
         for ( int i = 0; i < N; ++ i ) {
            int d;
            cin >> d;
            D[d] = true;
         }
         return true;
      }

      double solve() {
         return BFS().run().cost;
      }

   public:
      int run() {
         while ( init(), input() ) {
            printf( "%.9f\n", solve() );
         }
         return 0;
      }
   };
}

int main() {
   using namespace solution;
   Solution s;
   return s.run();
}

Measured memory_bytes: 1256