#include <iostream>
#include <cmath>
#define REP(i, a, n) for(int i = ((int) a); i < ((int) n); i++)
#define INF 100000000
using namespace std;
typedef long long ll;

string S;
ll dp[300][300][2];

ll number(int l, int r) {
  ll ret = 0;
  REP(i, l, r) {
    if('0' <= S[i] && S[i] <= '9') ret = ret * 10 + (S[i] - '0');
    else return -1;
  }
  return ret;
}

ll dfs(int l, int r, int mode, int depth) {

  if(dp[l][r][mode] > -INF * 2) return dp[l][r][mode];

  ll n = number(l, r);
  if(n >= 0) return n;

  ll ret = mode == 0 ? -INF : INF;
  REP(i, l, r) if(S[i] == '+' || S[i] == '-') {
    int nl = l, nr = r;
    while(1) {
      ll n1 = dfs(nl, i, mode, depth + 1);
      ll n2 = dfs(i + 1, nr, S[i] == '-' ? 1 - mode : mode, depth + 1);
      if(abs(n1) != INF && abs(n2) != INF) {
        if(mode == 0) {
          if(S[i] == '+') ret = max(ret, n1 + n2);
          if(S[i] == '-') ret = max(ret, n1 - n2);
        } else {
          if(S[i] == '+') ret = min(ret, n1 + n2);
          if(S[i] == '-') ret = min(ret, n1 - n2);
        }
      }
      if(S[nl] != '(' && S[nr - 1] != ')') break;
      if(S[nl] == '(') nl++;
      if(S[nr - 1] == ')') nr--;
    }
  }
  return dp[l][r][mode] = ret;
}

int main(void) {
  cin >> S;

  REP(i, 0, 201) REP(j, 0, 201) REP(k, 0, 2) dp[i][j][k] = -INF * 2;
  cout << dfs(0, S.size(), 0, 0) << endl;

  return 0;
}
### Prompt

Generate a CPP solution to the following problem:

Tunnel formula

One day while exploring an abandoned mine, you found a long formula S written in the mine. If you like large numbers, you decide to take out the choke and add `(` or `)` so that the result of the formula calculation is as large as possible. If it has to be a mathematical formula even after adding it, how many can it be at the maximum?

There is enough space between the letters, and you can add as many `(` or `)` as you like. If the final formula is a formula, you may write `(` or `)` so that the correspondence of the first parenthesis is broken (see Sample 2). Also, here, <expr> defined by the following BNF is called a mathematical formula. All numbers in the formula are single digits.


<expr> :: = "(" <expr> ")"
| <term> "+" <term>
| <term> "-" <term>
<term> :: = <digit> | <expr>
<digit> :: = "0" | "1" | "2" | "3" | "4"
| "5" | "6" | "7" | "8" | "9"


Constraints

* 3 ≤ | S | ≤ 200



S represents a mathematical formula.

Input Format

Input is given from standard input in the following format.


S


Output Format

Output the answer as an integer.

Sample Input 1


1- (2 + 3-4 + 5)


Sample Output 1


Five


1- (2 + 3- (4 + 5)) is the maximum.

Sample Input 2


1- (2 + 3 + 4)


Sample Output 2


0


(1- (2 + 3) + 4) is the maximum.

Sample Input 3


1- (2 + 3)


Sample Output 3


-Four


Note that 1- (2) + (3) is not the formula here.





Example

Input

1-(2+3-4+5)


Output

5

### Response

```cpp
#include <iostream>
#include <cmath>
#define REP(i, a, n) for(int i = ((int) a); i < ((int) n); i++)
#define INF 100000000
using namespace std;
typedef long long ll;

string S;
ll dp[300][300][2];

ll number(int l, int r) {
  ll ret = 0;
  REP(i, l, r) {
    if('0' <= S[i] && S[i] <= '9') ret = ret * 10 + (S[i] - '0');
    else return -1;
  }
  return ret;
}

ll dfs(int l, int r, int mode, int depth) {

  if(dp[l][r][mode] > -INF * 2) return dp[l][r][mode];

  ll n = number(l, r);
  if(n >= 0) return n;

  ll ret = mode == 0 ? -INF : INF;
  REP(i, l, r) if(S[i] == '+' || S[i] == '-') {
    int nl = l, nr = r;
    while(1) {
      ll n1 = dfs(nl, i, mode, depth + 1);
      ll n2 = dfs(i + 1, nr, S[i] == '-' ? 1 - mode : mode, depth + 1);
      if(abs(n1) != INF && abs(n2) != INF) {
        if(mode == 0) {
          if(S[i] == '+') ret = max(ret, n1 + n2);
          if(S[i] == '-') ret = max(ret, n1 - n2);
        } else {
          if(S[i] == '+') ret = min(ret, n1 + n2);
          if(S[i] == '-') ret = min(ret, n1 - n2);
        }
      }
      if(S[nl] != '(' && S[nr - 1] != ')') break;
      if(S[nl] == '(') nl++;
      if(S[nr - 1] == ')') nr--;
    }
  }
  return dp[l][r][mode] = ret;
}

int main(void) {
  cin >> S;

  REP(i, 0, 201) REP(j, 0, 201) REP(k, 0, 2) dp[i][j][k] = -INF * 2;
  cout << dfs(0, S.size(), 0, 0) << endl;

  return 0;
}
```