#include <bits/stdc++.h>
using namespace std;
int ans, now[4];
int Pos[4], Move[4], Throw[4];
bool HaveThrew[4], HaveLifted[4], HaveMoved[4], BeLifted[4];
int LiftWho[4];
struct Node {
  int p[4];
  int x;
  Node() {
    x = -1;
    p[1] = p[2] = p[3] = -123121;
  }
} h[6527119];
void dfs(int p[]);
int main() {
  cin >> Pos[1] >> Move[1] >> Throw[1];
  cin >> Pos[2] >> Move[2] >> Throw[2];
  cin >> Pos[3] >> Move[3] >> Throw[3];
  ans = max(Pos[1], max(Pos[2], Pos[3]));
  memset(HaveThrew, 0, sizeof(HaveThrew));
  memset(HaveLifted, 0, sizeof(HaveLifted));
  memset(HaveMoved, 0, sizeof(HaveMoved));
  memset(BeLifted, 0, sizeof(BeLifted));
  dfs(Pos);
  cout << ans << endl;
  return 0;
}
bool check(int p[]) {
  int pos = p[1] * 1121 + p[2] * 111 + p[3] * 2923;
  pos %= 6511797;
  int lifted = HaveLifted[1] * 23 + HaveLifted[2] * 311 + HaveLifted[3] * 21547;
  lifted %= 6511797;
  int moved = HaveMoved[1] * 29 + HaveMoved[2] * 577 + HaveMoved[3] * 9911;
  moved %= 6511797;
  int threw = HaveThrew[1] * 59 + HaveThrew[2] * 23533 + HaveThrew[3] * 782311;
  threw %= 6511797;
  int hasH = (pos + (lifted + moved % 6511797 + threw % 6511797)) % 6511797;
  int temp = hasH;
  bool b = false;
  while (h[hasH].x != -1) {
    if (h[hasH].p[1] == p[1] && h[hasH].p[2] == p[2] && h[hasH].p[3] == p[3]) {
      b = true;
      break;
    }
    hasH++;
  }
  if (b == true) {
    return true;
  }
  hasH = temp;
  h[hasH].x = 1;
  h[hasH].p[1] = p[1];
  h[hasH].p[2] = p[2];
  h[hasH].p[3] = p[3];
  return false;
}
void dfs(int p[]) {
  if (check(p) == true) return;
  for (int i = 1; i <= 3; ++i) ans = max(ans, p[i]);
  for (int i = 1; i <= 3; ++i) {
    if (BeLifted[i] == true) continue;
    if (HaveMoved[i] == false &&
        (HaveLifted[i] == false ||
         HaveLifted[i] == true && HaveThrew[i] == true)) {
      for (int j = 1; j <= Move[i]; ++j) {
        bool b = true;
        int temp = p[i];
        for (int k = 1; k <= 3; ++k)
          if (i != k && p[k] == temp + j) {
            b = false;
            break;
          }
        if (b == true) {
          p[i] = temp + j;
          HaveMoved[i] = true;
          dfs(p);
          HaveMoved[i] = false;
          p[i] = temp;
        }
        b = true;
        for (int k = 1; k <= 3; ++k)
          if (i != k && p[k] == temp - j) {
            b = false;
            break;
          }
        if (b == true && temp - j > 0) {
          p[i] = temp - j;
          HaveMoved[i] = true;
          dfs(p);
          HaveMoved[i] = false;
          p[i] = temp;
        }
      }
    }
    if (HaveLifted[i] == false) {
      for (int j = 1; j <= 3; ++j)
        if (i != j && abs(p[i] - p[j]) == 1 && BeLifted[j] == false) {
          HaveLifted[i] = true;
          LiftWho[i] = j;
          int temp = p[j];
          BeLifted[j] = true;
          p[j] = 0;
          dfs(p);
          BeLifted[j] = false;
          p[j] = temp;
          HaveLifted[i] = false;
          LiftWho[i] = 0;
        }
    }
    if (HaveLifted[i] == true && HaveThrew[i] == false) {
      for (int j = 1; j <= Throw[i]; ++j) {
        int temp = p[i];
        bool b = true;
        for (int k = 1; k <= 3; ++k)
          if (LiftWho[i] != k && temp + j == p[k]) {
            b = false;
            break;
          }
        if (b == true) {
          p[LiftWho[i]] = temp + j;
          HaveThrew[i] = true;
          BeLifted[LiftWho[i]] = false;
          dfs(p);
          BeLifted[LiftWho[i]] = true;
          p[LiftWho[i]] = 0;
          HaveThrew[i] = false;
        }
        b = true;
        for (int k = 1; k <= 3; ++k)
          if (LiftWho[i] != k && temp - j == p[k]) {
            b = false;
            break;
          }
        if (b == true && temp - j > 0) {
          HaveThrew[i] = true;
          p[LiftWho[i]] = temp - j;
          BeLifted[LiftWho[i]] = false;
          dfs(p);
          BeLifted[LiftWho[i]] = true;
          p[LiftWho[i]] = 0;
          HaveThrew[i] = false;
        }
      }
    }
  }
}
