Problem: You are given a straight half-line divided into segments of unit length, which we will call positions. The positions are numbered by positive integers that start with 1 from the end of half-line, i. e. 1, 2, 3 and so on. The distance between the positions is the absolute difference between the respective numbers. 

Laharl, Etna and Flonne occupy some positions on the half-line and they want to get to the position with the largest possible number. They are originally placed in different positions. 

Each of the characters can perform each of the following actions no more than once: 

  * Move a certain distance. 
  * Grab another character and lift him above the head. 
  * Throw the lifted character a certain distance. 



Each character has a movement range parameter. They can only move to free positions, assuming that distance between those positions doesn't exceed the movement range. 

One character can lift another character if the distance between the two characters equals 1, and no one already holds that another character. We can assume that the lifted character moves to the same position as the person who has lifted him, and the position in which he stood before becomes free. A lifted character cannot perform any actions and the character that holds him cannot walk. 

Also, each character has a throwing range parameter. It is the distance at which this character can throw the one lifted above his head. He can only throw a character to a free position, and only when there is a lifted character. 

We accept the situation when one person grabs another one who in his turn has the third character in his hands. This forms a "column" of three characters. For example, Laharl can hold Etna while Etna holds Flonne. In this case, Etna and the Flonne cannot perform any actions, and Laharl can only throw Etna (together with Flonne) at some distance. 

Laharl, Etna and Flonne perform actions in any order. They perform actions in turns, that is no two of them can do actions at the same time.

Determine the maximum number of position at least one of the characters can reach. That is, such maximal number x so that one of the characters can reach position x.

Input

The first line contains three integers: Laharl's position, his movement range and throwing range. The second and the third lines describe Etna's and Flonne's parameters correspondingly in the similar form. It is guaranteed that the three characters occupy distinct positions. All numbers in the input are between 1 and 10, inclusive.

Output

Print a single number — the maximum ordinal number of position which either Laharl, Etna or Flonne can reach.

Examples

Input

9 3 3
4 3 1
2 3 3


Output

15

Note

Let us explain how to reach position 15 in the sample.

Initially Laharl occupies position 9, Etna — position 4 and Flonne — position 2.

First Laharl moves to position 6.

Then Flonne moves to position 5 and grabs Etna.

Laharl grabs Flonne and throws to position 9.

Flonne throws Etna to position 12.

Etna moves to position 15.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456")
using namespace std;
template <typename T>
T sqr(const T &x) {
  return x * x;
}
template <typename T>
T my_abs(const T &x) {
  return x < 0 ? -x : x;
}
const int INF = (int)1e9;
const long long LINF = (long long)6e18;
const long long INF64 = LINF;
const long long INFLL = LINF;
const long double EPS = 1e-7;
const long double PI = 3.1415926535897932384626433832795;
const long double ME = 1e-5;
const long long MOD = (int)1e9 + 7;
const long long MOD2 = (int)1e9 + 21;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
const int SQN = 500;
const int LOGN = 17;
const int N = (int)1e3 + 10;
bool used[43 * 8 * 43 * 8 * 43 * 8];
int spos[3];
int tr[3];
int rr[3];
int ans = 0;
int q[43 * 8 * 43 * 8 * 43 * 8];
int ql = 0;
int qr = 0;
int pos[3];
int l[3];
int wl[3];
int t[3];
int r[3];
int npos[3];
int nl[3];
int nwl[3];
int nt[3];
int nr[3];
inline void parse_st(int st) {
  memset(l, false, sizeof(l));
  for (int i = int(3) - 1; i >= 0; --i) {
    int cs = st % (43 * 8);
    st /= 43 * 8;
    pos[i] = cs >> 3;
    r[i] = (cs >> 2) & 1;
    cs = cs & 3;
    if (cs == 0) {
      wl[i] = -1;
      t[i] = false;
    }
    if (cs == 1) {
      int cwl = (i + 2) % 3;
      wl[i] = cwl;
      l[cwl] = true;
      t[i] = false;
    }
    if (cs == 2) {
      int cwl = (i + 1) % 3;
      wl[i] = cwl;
      l[cwl] = true;
      t[i] = false;
    }
    if (cs == 3) {
      wl[i] = -1;
      t[i] = true;
    }
  }
  for (int i = 0; i < int(3); ++i) {
    ans = max(ans, pos[i]);
  }
}
inline int pack_nst() {
  int res = 0;
  for (int i = 0; i < int(3); ++i) {
    res *= 43 * 8;
    int st = npos[i];
    st <<= 1;
    st |= nr[i];
    st <<= 2;
    if (nwl[i] == -1) {
      if (nt[i]) {
        st |= 3;
      }
    } else {
      if (((i + 2) % 3) == nwl[i]) {
        st |= 1;
      } else {
        st |= 2;
      }
    }
    res += st;
  }
  return res;
}
void bfs(int start_st) {
  used[start_st] = true;
  q[qr++] = start_st;
  while (ql != qr) {
    int cur = q[ql++];
    used[cur] = true;
    parse_st(cur);
    for (int i = 0; i < int(3); ++i) {
      if (l[i]) {
        continue;
      }
      if (!r[i] && (wl[i] == -1)) {
        memcpy(npos, pos, sizeof(pos));
        memcpy(nl, l, sizeof(l));
        memcpy(nr, r, sizeof(r));
        memcpy(nwl, wl, sizeof(wl));
        memcpy(nt, t, sizeof(t));
        for (int np = int(max(0, pos[i] - rr[i])); np < int(pos[i] + rr[i] + 1);
             ++np) {
          bool ok = true;
          for (int j = 0; j < int(3); ++j) {
            if (np == pos[(i + j) % 3]) {
              ok = false;
              break;
            }
          }
          if (!ok) {
            continue;
          }
          npos[i] = np;
          nr[i] = true;
          int nst = pack_nst();
          if (!used[nst]) {
            used[nst] = true;
            q[qr++] = nst;
          }
        }
      }
      if (wl[i] != -1) {
        memcpy(npos, pos, sizeof(pos));
        memcpy(nl, l, sizeof(l));
        memcpy(nr, r, sizeof(r));
        memcpy(nwl, wl, sizeof(wl));
        memcpy(nt, t, sizeof(t));
        for (int np = int(max(0, pos[i] - tr[i])); np < int(pos[i] + tr[i] + 1);
             ++np) {
          bool ok = true;
          for (int j = 0; j < int(3); ++j) {
            if (np == pos[(i + j) % 3]) {
              ok = false;
              break;
            }
          }
          if (!ok) {
            continue;
          }
          npos[wl[i]] = np;
          if (wl[wl[i]] != -1) {
            npos[wl[wl[i]]] = np;
          }
          nwl[i] = -1;
          nt[i] = true;
          int nst = pack_nst();
          if (!used[nst]) {
            used[nst] = true;
            q[qr++] = nst;
          }
        }
      }
      if (!t[i] && (wl[i] == -1)) {
        for (int j = 0; j < int(3); ++j) {
          if ((abs(pos[j] - pos[i]) == 1) && !l[j]) {
            memcpy(npos, pos, sizeof(pos));
            memcpy(nl, l, sizeof(l));
            memcpy(nr, r, sizeof(r));
            memcpy(nwl, wl, sizeof(wl));
            memcpy(nt, t, sizeof(t));
            npos[j] = pos[i];
            nwl[i] = j;
            if (wl[j] != -1) {
              npos[wl[j]] = pos[i];
            }
            int nst = pack_nst();
            if (!used[nst]) {
              used[nst] = true;
              q[qr++] = nst;
            }
          }
        }
      }
    }
  }
}
inline void solve() {
  for (int i = 0; i < int(3); ++i) {
    cin >> spos[i] >> rr[i] >> tr[i];
    spos[i]--;
  }
  int state = 0;
  for (int i = 0; i < int(3); ++i) {
    state = state * 43 * 8 + (spos[i] << 3);
  }
  bfs(state);
  cout << ans + 1 << endl;
}
int main() {
  ios_base::sync_with_stdio(false);
  srand((unsigned int)time(NULL));
  cout << setprecision(15) << fixed;
  solve();
  cerr << "time: " << clock() << " ms" << endl;
  return 0;
}