In an embassy of a well-known kingdom an electronic queue is organised. Every person who comes to the embassy, needs to make the following three actions: show the ID, pay money to the cashier and be fingerprinted. Besides, the actions should be performed in the given order.

For each action several separate windows are singled out: k1 separate windows for the first action (the first type windows), k2 windows for the second one (the second type windows), and k3 for the third one (the third type windows). The service time for one person in any of the first type window equals to t1. Similarly, it takes t2 time to serve a person in any of the second type windows. And it takes t3 to serve one person in any of the third type windows. Thus, the service time depends only on the window type and is independent from the person who is applying for visa.

At some moment n people come to the embassy, the i-th person comes at the moment of time ci. The person is registered under some number. After that he sits in the hall and waits for his number to be shown on a special board. Besides the person's number the board shows the number of the window where one should go and the person goes there immediately. Let's consider that the time needed to approach the window is negligible. The table can show information for no more than one person at a time. The electronic queue works so as to immediately start working with the person who has approached the window, as there are no other people in front of the window.

The Client Service Quality inspectors noticed that several people spend too much time in the embassy (this is particularly tiresome as the embassy has no mobile phone reception and 3G). It was decided to organise the system so that the largest time a person spends in the embassy were minimum. Help the inspectors organise the queue. Consider that all actions except for being served in at the window, happen instantly.

Input

The first line contains three space-separated integers k1, k2, k3 (1 ≤ ki ≤ 109), they are the number of windows of the first, second and third type correspondingly.

The second line contains three space-separated integers t1, t2, t3 (1 ≤ ti ≤ 105), they are the periods of time needed to serve one person in the window of the first, second and third type correspondingly. 

The third line contains an integer n (1 ≤ n ≤ 105), it is the number of people.

The fourth line contains n space-separated integers ci (1 ≤ ci ≤ 109) in the non-decreasing order; ci is the time when the person number i comes to the embassy.

Output

Print the single number, the maximum time a person will spend in the embassy if the queue is organized optimally.

Please, do not use the %lld specificator to read or write 64-bit integers in C++. It is preferred to use the cin, cout streams (also you may use the %I64d specificator).

Examples

Input

1 1 1
1 1 1
5
1 1 1 1 1


Output

7


Input

2 1 1
5 1 1
5
1 2 3 3 5


Output

13

Note

In the first test 5 people come simultaneously at the moment of time equal to 1. There is one window of every type, it takes 1 unit of time to be served at each window. That's why the maximal time a person spends in the embassy is the time needed to be served at the windows (3 units of time) plus the time the last person who comes to the first window waits (4 units of time).

Windows in the second test work like this:

The first window of the first type: [1, 6) — the first person, [6, 11) — third person, [11, 16) — fifth person

The second window of the first type: [2, 7) — the second person, [7, 12) — the fourth person

The only second type window: [6, 7) — first, [7, 8) — second, [11, 12) — third, [12, 13) — fourth, [16, 17) — fifth

The only third type window: [7, 8) — first, [8, 9) — second, [12, 13) — third, [13, 14) — fourth, [17, 18) — fifth

We can see that it takes most time to serve the fifth person.
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const double pi = 3.141592653589793238462;
const int nmax = 200000;
const int hash_base = 119;
const long long inf = 2e18;
long long k[3], t[3], n, c[nmax], pr = -1, ans = 0, cur_t;
queue<pair<long long, long long> > q[3], v[3];
priority_queue<long long> tim;
int main() {
  for (int i = 0; i < 3; i++) cin >> k[i];
  for (int i = 0; i < 3; i++) cin >> t[i];
  cin >> n;
  for (int i = 0; i < n; i++) {
    scanf("%I64d", &c[i]);
    v[0].push(make_pair(c[i], 0));
    tim.push(-c[i]);
  };
  while (!tim.empty()) {
    long long T = -tim.top();
    tim.pop();
    for (int i = 0; i <= 6; i++) {
      while (!q[2].empty() && q[2].front().second <= T) {
        k[2]++;
        ans = max(ans, T - q[2].front().first);
        q[2].pop();
      };
      while (!v[2].empty() && k[2]) {
        q[2].push(make_pair(v[2].front().first, T + t[2]));
        v[2].pop();
        k[2]--;
        tim.push(-(T + t[2]));
      };
      while (!q[1].empty() && q[1].front().second <= T) {
        k[1]++;
        v[2].push(q[1].front());
        q[1].pop();
      };
      while (!v[1].empty() && k[1]) {
        q[1].push(make_pair(v[1].front().first, T + t[1]));
        v[1].pop();
        k[1]--;
        tim.push(-(T + t[1]));
      };
      while (!q[0].empty() && q[0].front().second <= T) {
        k[0]++;
        v[1].push(q[0].front());
        q[0].pop();
      };
      while (!v[0].empty() && k[0] && v[0].front().first <= T) {
        q[0].push(make_pair(v[0].front().first, T + t[0]));
        v[0].pop();
        k[0]--;
        tim.push(-(T + t[0]));
      };
    };
  };
  cout << ans << endl;
  return 0;
}
