#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int fare(int l[], int c[], int dest)
{
  if(dest <= l[0])
    return c[0];
  if(dest <= l[1])
    return c[1];
  if(dest <= l[2])
    return c[2];
  return -1;
}

#if 0
int distance(int a, int b)
{
  int dist = abs(pos[a] - pos[b]);
  int ret = fare(dist);
  if(ret == -1)
    ret = 1000000001;
  return ret;
}

void dijkstra(int size, int start, vector<int> &result)
{
  const int MAX = 1000000002;
  
  result.resize(size);
  
  bool decided[10000];
  fill(result.begin(), result.end(), MAX);
  fill(decided, decided+size, false);
  result[start] = 0;

  for(int j=0; j<size; j++) {
    int min = MAX, next = -1;
    for(int i=0; i<size; i++) {
      if(!decided[i] && result[i] < min) {
	min = result[i];
	next = i;
      }
    }
    decided[next] = true;
    for(int i=0; i<size; i++) {
      if(result[next] + distance(next, i) < result[i])
	result[i] = result[next] + distance(next, i);
    }
  }
}
#endif

int main()
{
  int l[3], c[3];
  int n;
  int start, dest;
  int pos[10000];
  int cost[10000];

  // *****input*****
  fill(pos, pos+10000, 0);
  fill(cost, cost+10000, 2000000000);

  for(int i=0; i<3; i++)
    cin >> l[i];
  for(int i=0; i<3; i++)
    cin >> c[i];
  cin >> n;
  cin >> start >> dest;
  --start; --dest;
  pos[0] = 0;
  for(int i=1; i<n; i++)
    cin >> pos[i];

  // *****solve*****
  cost[dest] = 0;
  int minimum;
  if (start < dest) {
    for(int i=dest-1; i>=start; i--) {
      minimum = 2000000000;
      int direct = fare(l, c, pos[dest] - pos[i]);
      if(direct != -1) 
	minimum = direct;
      for(int j=i+1; j<=dest-1; j++) {
	int a = fare(l, c, pos[j] - pos[i]);
	int b = cost[j];
	if(a == -1) break;
	else if(a+b < minimum)
	  minimum = a+b;
      }
      cost[i] = minimum;
    }
  }
  else {
    for(int i=dest+1; i<=start; i++) {
      minimum = 2000000000;
      int direct = fare(l, c, pos[i] - pos[dest]);
      if(direct != -1) 
	minimum = direct;
      for(int j=i-1; j>=dest+1; j--) {
	int a = fare(l, c, pos[i] - pos[j]);
	int b = cost[j];
	if(a == -1) break;
	else if(a+b < minimum)
	  minimum = a+b;
      }
      cost[i] = minimum;
    }
  }
  //  vector<int> result;
  //  dijkstra(n, start, result);

  //  for(int i=0; i<n; i++)
  //cout << result[i] << endl;
  cout << cost[start] << endl;

  return 0;
}